?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Samba 3: added Samba 3.0.24 sources
[tomato.git] / release / src / router / samba3 / source / rpc_parse / parse_srv.c
blob7d15eda630f908074d8e03717c5aa832215c21b3
1 /*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-1997,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
6 * Copyright (C) Paul Ashton 1997,
7 * Copyright (C) Jeremy Allison 1999,
8 * Copyright (C) Nigel Williams 2001,
9 * Copyright (C) Jim McDonough (jmcd@us.ibm.com) 2002.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26 #include "includes.h"
27
28 #undef DBGC_CLASS
29 #define DBGC_CLASS DBGC_RPC_PARSE
30
31 /*******************************************************************
32 Inits a SH_INFO_0_STR structure
33 ********************************************************************/
34
35 void init_srv_share_info0_str(SH_INFO_0_STR *sh0, const char *net_name)
36 {
37 DEBUG(5,("init_srv_share_info0_str\n"));
38
39 init_unistr2(&sh0->uni_netname, net_name, UNI_STR_TERMINATE);
40 }
41
42 /*******************************************************************
43 Reads or writes a structure.
44 ********************************************************************/
45
46 static BOOL srv_io_share_info0_str(const char *desc, SH_INFO_0_STR *sh0, prs_struct *ps, int depth)
47 {
48 if (sh0 == NULL)
49 return False;
50
51 prs_debug(ps, depth, desc, "srv_io_share_info0_str");
52 depth++;
53
54 if(!prs_align(ps))
55 return False;
56 if(sh0->ptrs->ptr_netname)
57 if(!smb_io_unistr2("", &sh0->uni_netname, True, ps, depth))
58 return False;
59
60 return True;
61 }
62
63 /*******************************************************************
64 makes a SH_INFO_0 structure
65 ********************************************************************/
66
67 void init_srv_share_info0(SH_INFO_0 *sh0, const char *net_name)
68 {
69 DEBUG(5,("init_srv_share_info0: %s\n", net_name));
70
71 sh0->ptr_netname = (net_name != NULL) ? 1 : 0;
72 }
73
74 /*******************************************************************
75 Reads or writes a structure.
76 ********************************************************************/
77
78 static BOOL srv_io_share_info0(const char *desc, SH_INFO_0 *sh0, prs_struct *ps, int depth)
79 {
80 if (sh0 == NULL)
81 return False;
82
83 prs_debug(ps, depth, desc, "srv_io_share_info0");
84 depth++;
85
86 if(!prs_align(ps))
87 return False;
88
89 if(!prs_uint32("ptr_netname", ps, depth, &sh0->ptr_netname))
90 return False;
91
92 return True;
93 }
94
95 /*******************************************************************
96 Inits a SH_INFO_1_STR structure
97 ********************************************************************/
98
99 void init_srv_share_info1_str(SH_INFO_1_STR *sh1, const char *net_name, const char *remark)
100 {
101 DEBUG(5,("init_srv_share_info1_str\n"));
102
103 init_unistr2(&sh1->uni_netname, net_name, UNI_STR_TERMINATE);
104 init_unistr2(&sh1->uni_remark, remark, UNI_STR_TERMINATE);
105 }
106
107 /*******************************************************************
108 Reads or writes a structure.
109 ********************************************************************/
110
111 static BOOL srv_io_share_info1_str(const char *desc, SH_INFO_1_STR *sh1, prs_struct *ps, int depth)
112 {
113 if (sh1 == NULL)
114 return False;
115
116 prs_debug(ps, depth, desc, "srv_io_share_info1_str");
117 depth++;
118
119 if(!prs_align(ps))
120 return False;
121
122 if(sh1->ptrs->ptr_netname)
123 if(!smb_io_unistr2("", &sh1->uni_netname, True, ps, depth))
124 return False;
125
126 if(!prs_align(ps))
127 return False;
128
129 if(sh1->ptrs->ptr_remark)
130 if(!smb_io_unistr2("", &sh1->uni_remark, True, ps, depth))
131 return False;
132
133 return True;
134 }
135
136 /*******************************************************************
137 makes a SH_INFO_1 structure
138 ********************************************************************/
139
140 void init_srv_share_info1(SH_INFO_1 *sh1, const char *net_name, uint32 type, const char *remark)
141 {
142 DEBUG(5,("init_srv_share_info1: %s %8x %s\n", net_name, type, remark));
143
144 sh1->ptr_netname = (net_name != NULL) ? 1 : 0;
145 sh1->type = type;
146 sh1->ptr_remark = (remark != NULL) ? 1 : 0;
147 }
148
149 /*******************************************************************
150 Reads or writes a structure.
151 ********************************************************************/
152
153 static BOOL srv_io_share_info1(const char *desc, SH_INFO_1 *sh1, prs_struct *ps, int depth)
154 {
155 if (sh1 == NULL)
156 return False;
157
158 prs_debug(ps, depth, desc, "srv_io_share_info1");
159 depth++;
160
161 if(!prs_align(ps))
162 return False;
163
164 if(!prs_uint32("ptr_netname", ps, depth, &sh1->ptr_netname))
165 return False;
166 if(!prs_uint32("type ", ps, depth, &sh1->type))
167 return False;
168 if(!prs_uint32("ptr_remark ", ps, depth, &sh1->ptr_remark))
169 return False;
170
171 return True;
172 }
173
174 /*******************************************************************
175 Inits a SH_INFO_2_STR structure
176 ********************************************************************/
177
178 void init_srv_share_info2_str(SH_INFO_2_STR *sh2,
179 const char *net_name, const char *remark,
180 const char *path, const char *passwd)
181 {
182 DEBUG(5,("init_srv_share_info2_str\n"));
183
184 init_unistr2(&sh2->uni_netname, net_name, UNI_STR_TERMINATE);
185 init_unistr2(&sh2->uni_remark, remark, UNI_STR_TERMINATE);
186 init_unistr2(&sh2->uni_path, path, UNI_STR_TERMINATE);
187 init_unistr2(&sh2->uni_passwd, passwd, UNI_STR_TERMINATE);
188 }
189
190 /*******************************************************************
191 Reads or writes a structure.
192 ********************************************************************/
193
194 static BOOL srv_io_share_info2_str(const char *desc, SH_INFO_2 *sh, SH_INFO_2_STR *sh2, prs_struct *ps, int depth)
195 {
196 if (sh2 == NULL)
197 return False;
198
199 if (UNMARSHALLING(ps))
200 ZERO_STRUCTP(sh2);
201
202 prs_debug(ps, depth, desc, "srv_io_share_info2_str");
203 depth++;
204
205 if(!prs_align(ps))
206 return False;
207
208 if (sh->ptr_netname)
209 if(!smb_io_unistr2("", &sh2->uni_netname, True, ps, depth))
210 return False;
211
212 if (sh->ptr_remark)
213 if(!smb_io_unistr2("", &sh2->uni_remark, True, ps, depth))
214 return False;
215
216 if (sh->ptr_netname)
217 if(!smb_io_unistr2("", &sh2->uni_path, True, ps, depth))
218 return False;
219
220 if (sh->ptr_passwd)
221 if(!smb_io_unistr2("", &sh2->uni_passwd, True, ps, depth))
222 return False;
223
224 return True;
225 }
226
227 /*******************************************************************
228 Inits a SH_INFO_2 structure
229 ********************************************************************/
230
231 void init_srv_share_info2(SH_INFO_2 *sh2,
232 const char *net_name, uint32 type, const char *remark,
233 uint32 perms, uint32 max_uses, uint32 num_uses,
234 const char *path, const char *passwd)
235 {
236 DEBUG(5,("init_srv_share_info2: %s %8x %s\n", net_name, type, remark));
237
238 sh2->ptr_netname = (net_name != NULL) ? 1 : 0;
239 sh2->type = type;
240 sh2->ptr_remark = (remark != NULL) ? 1 : 0;
241 sh2->perms = perms;
242 sh2->max_uses = max_uses;
243 sh2->num_uses = num_uses;
244 sh2->ptr_path = (path != NULL) ? 1 : 0;
245 sh2->ptr_passwd = (passwd != NULL) ? 1 : 0;
246 }
247
248 /*******************************************************************
249 Reads or writes a structure.
250 ********************************************************************/
251
252 static BOOL srv_io_share_info2(const char *desc, SH_INFO_2 *sh2, prs_struct *ps, int depth)
253 {
254 if (sh2 == NULL)
255 return False;
256
257 prs_debug(ps, depth, desc, "srv_io_share_info2");
258 depth++;
259
260 if(!prs_align(ps))
261 return False;
262
263 if(!prs_uint32("ptr_netname", ps, depth, &sh2->ptr_netname))
264 return False;
265 if(!prs_uint32("type ", ps, depth, &sh2->type))
266 return False;
267 if(!prs_uint32("ptr_remark ", ps, depth, &sh2->ptr_remark))
268 return False;
269 if(!prs_uint32("perms ", ps, depth, &sh2->perms))
270 return False;
271 if(!prs_uint32("max_uses ", ps, depth, &sh2->max_uses))
272 return False;
273 if(!prs_uint32("num_uses ", ps, depth, &sh2->num_uses))
274 return False;
275 if(!prs_uint32("ptr_path ", ps, depth, &sh2->ptr_path))
276 return False;
277 if(!prs_uint32("ptr_passwd ", ps, depth, &sh2->ptr_passwd))
278 return False;
279
280 return True;
281 }
282
283 /*******************************************************************
284 Inits a SH_INFO_501_STR structure
285 ********************************************************************/
286
287 void init_srv_share_info501_str(SH_INFO_501_STR *sh501,
288 const char *net_name, const char *remark)
289 {
290 DEBUG(5,("init_srv_share_info501_str\n"));
291
292 init_unistr2(&sh501->uni_netname, net_name, UNI_STR_TERMINATE);
293 init_unistr2(&sh501->uni_remark, remark, UNI_STR_TERMINATE);
294 }
295
296 /*******************************************************************
297 Inits a SH_INFO_2 structure
298 *******************************************************************/
299
300 void init_srv_share_info501(SH_INFO_501 *sh501, const char *net_name, uint32 type, const char *remark, uint32 csc_policy)
301 {
302 DEBUG(5,("init_srv_share_info501: %s %8x %s %08x\n", net_name, type,
303 remark, csc_policy));
304
305 ZERO_STRUCTP(sh501);
306
307 sh501->ptr_netname = (net_name != NULL) ? 1 : 0;
308 sh501->type = type;
309 sh501->ptr_remark = (remark != NULL) ? 1 : 0;
310 sh501->csc_policy = csc_policy;
311 }
312
313 /*******************************************************************
314 Reads of writes a structure.
315 *******************************************************************/
316
317 static BOOL srv_io_share_info501(const char *desc, SH_INFO_501 *sh501, prs_struct *ps, int depth)
318 {
319 if (sh501 == NULL)
320 return False;
321
322 prs_debug(ps, depth, desc, "srv_io_share_info501");
323 depth++;
324
325 if (!prs_align(ps))
326 return False;
327
328 if (!prs_uint32("ptr_netname", ps, depth, &sh501->ptr_netname))
329 return False;
330 if (!prs_uint32("type ", ps, depth, &sh501->type))
331 return False;
332 if (!prs_uint32("ptr_remark ", ps, depth, &sh501->ptr_remark))
333 return False;
334 if (!prs_uint32("csc_policy ", ps, depth, &sh501->csc_policy))
335 return False;
336
337 return True;
338 }
339
340 /*******************************************************************
341 Reads or writes a structure.
342 ********************************************************************/
343
344 static BOOL srv_io_share_info501_str(const char *desc, SH_INFO_501_STR *sh501, prs_struct *ps, int depth)
345 {
346 if (sh501 == NULL)
347 return False;
348
349 prs_debug(ps, depth, desc, "srv_io_share_info501_str");
350 depth++;
351
352 if(!prs_align(ps))
353 return False;
354 if(!smb_io_unistr2("", &sh501->uni_netname, True, ps, depth))
355 return False;
356
357 if(!prs_align(ps))
358 return False;
359 if(!smb_io_unistr2("", &sh501->uni_remark, True, ps, depth))
360 return False;
361
362 return True;
363 }
364
365 /*******************************************************************
366 Inits a SH_INFO_502 structure
367 ********************************************************************/
368
369 void init_srv_share_info502(SH_INFO_502 *sh502,
370 const char *net_name, uint32 type, const char *remark,
371 uint32 perms, uint32 max_uses, uint32 num_uses,
372 const char *path, const char *passwd, SEC_DESC *psd, size_t sd_size)
373 {
374 DEBUG(5,("init_srv_share_info502: %s %8x %s\n", net_name, type, remark));
375
376 ZERO_STRUCTP(sh502);
377
378 sh502->ptr_netname = (net_name != NULL) ? 1 : 0;
379 sh502->type = type;
380 sh502->ptr_remark = (remark != NULL) ? 1 : 0;
381 sh502->perms = perms;
382 sh502->max_uses = max_uses;
383 sh502->num_uses = num_uses;
384 sh502->ptr_path = (path != NULL) ? 1 : 0;
385 sh502->ptr_passwd = (passwd != NULL) ? 1 : 0;
386 sh502->reserved = 0; /* actual size within rpc */
387 sh502->sd_size = (uint32)sd_size;
388 sh502->ptr_sd = (psd != NULL) ? 1 : 0;
389 }
390
391 /*******************************************************************
392 Reads or writes a structure.
393 ********************************************************************/
394
395 static BOOL srv_io_share_info502(const char *desc, SH_INFO_502 *sh502, prs_struct *ps, int depth)
396 {
397 if (sh502 == NULL)
398 return False;
399
400 prs_debug(ps, depth, desc, "srv_io_share_info502");
401 depth++;
402
403 if(!prs_align(ps))
404 return False;
405
406 if(!prs_uint32("ptr_netname", ps, depth, &sh502->ptr_netname))
407 return False;
408 if(!prs_uint32("type ", ps, depth, &sh502->type))
409 return False;
410 if(!prs_uint32("ptr_remark ", ps, depth, &sh502->ptr_remark))
411 return False;
412 if(!prs_uint32("perms ", ps, depth, &sh502->perms))
413 return False;
414 if(!prs_uint32("max_uses ", ps, depth, &sh502->max_uses))
415 return False;
416 if(!prs_uint32("num_uses ", ps, depth, &sh502->num_uses))
417 return False;
418 if(!prs_uint32("ptr_path ", ps, depth, &sh502->ptr_path))
419 return False;
420 if(!prs_uint32("ptr_passwd ", ps, depth, &sh502->ptr_passwd))
421 return False;
422 if(!prs_uint32_pre("reserved ", ps, depth, &sh502->reserved, &sh502->reserved_offset))
423 return False;
424 if(!prs_uint32("ptr_sd ", ps, depth, &sh502->ptr_sd))
425 return False;
426
427 return True;
428 }
429
430 /*******************************************************************
431 Inits a SH_INFO_502_STR structure
432 ********************************************************************/
433
434 void init_srv_share_info502_str(SH_INFO_502_STR *sh502str,
435 const char *net_name, const char *remark,
436 const char *path, const char *passwd, SEC_DESC *psd, size_t sd_size)
437 {
438 DEBUG(5,("init_srv_share_info502_str\n"));
439
440 init_unistr2(&sh502str->uni_netname, net_name, UNI_STR_TERMINATE);
441 init_unistr2(&sh502str->uni_remark, remark, UNI_STR_TERMINATE);
442 init_unistr2(&sh502str->uni_path, path, UNI_STR_TERMINATE);
443 init_unistr2(&sh502str->uni_passwd, passwd, UNI_STR_TERMINATE);
444 sh502str->sd = psd;
445 sh502str->reserved = 0;
446 sh502str->sd_size = sd_size;
447 }
448
449 /*******************************************************************
450 Reads or writes a structure.
451 ********************************************************************/
452
453 static BOOL srv_io_share_info502_str(const char *desc, SH_INFO_502_STR *sh502, prs_struct *ps, int depth)
454 {
455 if (sh502 == NULL)
456 return False;
457
458 prs_debug(ps, depth, desc, "srv_io_share_info502_str");
459 depth++;
460
461 if(!prs_align(ps))
462 return False;
463
464 if(sh502->ptrs->ptr_netname) {
465 if(!smb_io_unistr2("", &sh502->uni_netname, True, ps, depth))
466 return False;
467 }
468
469 if(!prs_align(ps))
470 return False;
471
472 if(sh502->ptrs->ptr_remark) {
473 if(!smb_io_unistr2("", &sh502->uni_remark, True, ps, depth))
474 return False;
475 }
476
477 if(!prs_align(ps))
478 return False;
479
480 if(sh502->ptrs->ptr_path) {
481 if(!smb_io_unistr2("", &sh502->uni_path, True, ps, depth))
482 return False;
483 }
484
485 if(!prs_align(ps))
486 return False;
487
488 if(sh502->ptrs->ptr_passwd) {
489 if(!smb_io_unistr2("", &sh502->uni_passwd, True, ps, depth))
490 return False;
491 }
492
493 if(!prs_align(ps))
494 return False;
495
496 if(sh502->ptrs->ptr_sd) {
497 uint32 old_offset;
498 uint32 reserved_offset;
499
500 if(!prs_uint32_pre("reserved ", ps, depth, &sh502->reserved, &reserved_offset))
501 return False;
502
503 old_offset = prs_offset(ps);
504
505 if (!sec_io_desc(desc, &sh502->sd, ps, depth))
506 return False;
507
508 if(UNMARSHALLING(ps)) {
509
510 sh502->ptrs->sd_size = sh502->sd_size = sec_desc_size(sh502->sd);
511
512 prs_set_offset(ps, old_offset + sh502->reserved);
513 }
514
515 prs_align(ps);
516
517 if(MARSHALLING(ps)) {
518
519 sh502->ptrs->reserved = sh502->reserved = prs_offset(ps) - old_offset;
520 }
521
522 if(!prs_uint32_post("reserved ", ps, depth,
523 &sh502->reserved, reserved_offset, sh502->reserved))
524 return False;
525 if(!prs_uint32_post("reserved ", ps, depth,
526 &sh502->ptrs->reserved, sh502->ptrs->reserved_offset, sh502->ptrs->reserved))
527 return False;
528 }
529
530 return True;
531 }
532
533 /*******************************************************************
534 Inits a SH_INFO_1004_STR structure
535 ********************************************************************/
536
537 void init_srv_share_info1004_str(SH_INFO_1004_STR *sh1004, const char *remark)
538 {
539 DEBUG(5,("init_srv_share_info1004_str\n"));
540
541 init_unistr2(&sh1004->uni_remark, remark, UNI_STR_TERMINATE);
542 }
543
544 /*******************************************************************
545 Reads or writes a structure.
546 ********************************************************************/
547
548 static BOOL srv_io_share_info1004_str(const char *desc, SH_INFO_1004_STR *sh1004, prs_struct *ps, int depth)
549 {
550 if (sh1004 == NULL)
551 return False;
552
553 prs_debug(ps, depth, desc, "srv_io_share_info1004_str");
554 depth++;
555
556 if(!prs_align(ps))
557 return False;
558 if(sh1004->ptrs->ptr_remark)
559 if(!smb_io_unistr2("", &sh1004->uni_remark, True, ps, depth))
560 return False;
561
562 return True;
563 }
564
565 /*******************************************************************
566 makes a SH_INFO_1004 structure
567 ********************************************************************/
568
569 void init_srv_share_info1004(SH_INFO_1004 *sh1004, const char *remark)
570 {
571 DEBUG(5,("init_srv_share_info1004: %s\n", remark));
572
573 sh1004->ptr_remark = (remark != NULL) ? 1 : 0;
574 }
575
576 /*******************************************************************
577 Reads or writes a structure.
578 ********************************************************************/
579
580 static BOOL srv_io_share_info1004(const char *desc, SH_INFO_1004 *sh1004, prs_struct *ps, int depth)
581 {
582 if (sh1004 == NULL)
583 return False;
584
585 prs_debug(ps, depth, desc, "srv_io_share_info1004");
586 depth++;
587
588 if(!prs_align(ps))
589 return False;
590
591 if(!prs_uint32("ptr_remark", ps, depth, &sh1004->ptr_remark))
592 return False;
593
594 return True;
595 }
596
597 /*******************************************************************
598 Reads or writes a structure.
599 ********************************************************************/
600
601 static BOOL srv_io_share_info1005(const char* desc, SRV_SHARE_INFO_1005* sh1005, prs_struct* ps, int depth)
602 {
603 if(sh1005 == NULL)
604 return False;
605
606 prs_debug(ps, depth, desc, "srv_io_share_info1005");
607 depth++;
608
609 if(!prs_align(ps))
610 return False;
611
612 if(!prs_uint32("share_info_flags", ps, depth,
613 &sh1005->share_info_flags))
614 return False;
615
616 return True;
617 }
618
619 /*******************************************************************
620 Reads or writes a structure.
621 ********************************************************************/
622
623 static BOOL srv_io_share_info1006(const char* desc, SRV_SHARE_INFO_1006* sh1006, prs_struct* ps, int depth)
624 {
625 if(sh1006 == NULL)
626 return False;
627
628 prs_debug(ps, depth, desc, "srv_io_share_info1006");
629 depth++;
630
631 if(!prs_align(ps))
632 return False;
633
634 if(!prs_uint32("max uses ", ps, depth, &sh1006->max_uses))
635 return False;
636
637 return True;
638 }
639
640 /*******************************************************************
641 Inits a SH_INFO_1007_STR structure
642 ********************************************************************/
643
644 void init_srv_share_info1007_str(SH_INFO_1007_STR *sh1007, const char *alternate_directory_name)
645 {
646 DEBUG(5,("init_srv_share_info1007_str\n"));
647
648 init_unistr2(&sh1007->uni_AlternateDirectoryName, alternate_directory_name, UNI_STR_TERMINATE);
649 }
650
651 /*******************************************************************
652 Reads or writes a structure.
653 ********************************************************************/
654
655 static BOOL srv_io_share_info1007_str(const char *desc, SH_INFO_1007_STR *sh1007, prs_struct *ps, int depth)
656 {
657 if (sh1007 == NULL)
658 return False;
659
660 prs_debug(ps, depth, desc, "srv_io_share_info1007_str");
661 depth++;
662
663 if(!prs_align(ps))
664 return False;
665 if(sh1007->ptrs->ptr_AlternateDirectoryName)
666 if(!smb_io_unistr2("", &sh1007->uni_AlternateDirectoryName, True, ps, depth))
667 return False;
668
669 return True;
670 }
671
672 /*******************************************************************
673 makes a SH_INFO_1007 structure
674 ********************************************************************/
675
676 void init_srv_share_info1007(SH_INFO_1007 *sh1007, uint32 flags, const char *alternate_directory_name)
677 {
678 DEBUG(5,("init_srv_share_info1007: %s\n", alternate_directory_name));
679
680 sh1007->flags = flags;
681 sh1007->ptr_AlternateDirectoryName = (alternate_directory_name != NULL) ? 1 : 0;
682 }
683
684 /*******************************************************************
685 Reads or writes a structure.
686 ********************************************************************/
687
688 static BOOL srv_io_share_info1007(const char *desc, SH_INFO_1007 *sh1007, prs_struct *ps, int depth)
689 {
690 if (sh1007 == NULL)
691 return False;
692
693 prs_debug(ps, depth, desc, "srv_io_share_info1007");
694 depth++;
695
696 if(!prs_align(ps))
697 return False;
698
699 if(!prs_uint32("flags ", ps, depth, &sh1007->flags))
700 return False;
701 if(!prs_uint32("ptr_Alter..", ps, depth, &sh1007->ptr_AlternateDirectoryName))
702 return False;
703
704 return True;
705 }
706
707 /*******************************************************************
708 Reads or writes a structure.
709 ********************************************************************/
710
711 static BOOL srv_io_share_info1501(const char* desc, SRV_SHARE_INFO_1501* sh1501,
712 prs_struct* ps, int depth)
713 {
714 if(sh1501 == NULL)
715 return False;
716
717 prs_debug(ps, depth, desc, "srv_io_share_info1501");
718 depth++;
719
720 if(!prs_align(ps))
721 return False;
722
723 if (!sec_io_desc_buf(desc, &sh1501->sdb, ps, depth))
724 return False;
725
726 return True;
727 }
728
729 /*******************************************************************
730 Reads or writes a structure.
731 ********************************************************************/
732
733 static BOOL srv_io_srv_share_ctr(const char *desc, SRV_SHARE_INFO_CTR *ctr, prs_struct *ps, int depth)
734 {
735 if (ctr == NULL)
736 return False;
737
738 prs_debug(ps, depth, desc, "srv_io_srv_share_ctr");
739 depth++;
740
741 if (UNMARSHALLING(ps)) {
742 memset(ctr, '\0', sizeof(SRV_SHARE_INFO_CTR));
743 }
744
745 if(!prs_align(ps))
746 return False;
747
748 if(!prs_uint32("info_level", ps, depth, &ctr->info_level))
749 return False;
750
751 if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
752 return False;
753 if(!prs_uint32("ptr_share_info", ps, depth, &ctr->ptr_share_info))
754 return False;
755
756 if (ctr->ptr_share_info == 0)
757 return True;
758
759 if(!prs_uint32("num_entries", ps, depth, &ctr->num_entries))
760 return False;
761 if(!prs_uint32("ptr_entries", ps, depth, &ctr->ptr_entries))
762 return False;
763
764 if (ctr->ptr_entries == 0) {
765 if (ctr->num_entries == 0)
766 return True;
767 else
768 return False;
769 }
770
771 if(!prs_uint32("num_entries2", ps, depth, &ctr->num_entries2))
772 return False;
773
774 if (ctr->num_entries2 != ctr->num_entries)
775 return False;
776
777 switch (ctr->switch_value) {
778
779 case 0:
780 {
781 SRV_SHARE_INFO_0 *info0 = ctr->share.info0;
782 int num_entries = ctr->num_entries;
783 int i;
784
785 if (UNMARSHALLING(ps)) {
786 if (!(info0 = PRS_ALLOC_MEM(ps, SRV_SHARE_INFO_0, num_entries)))
787 return False;
788 ctr->share.info0 = info0;
789 }
790
791 for (i = 0; i < num_entries; i++) {
792 if(!srv_io_share_info0("", &info0[i].info_0, ps, depth))
793 return False;
794 }
795
796 for (i = 0; i < num_entries; i++) {
797 info0[i].info_0_str.ptrs = &info0[i].info_0;
798 if(!srv_io_share_info0_str("", &info0[i].info_0_str, ps, depth))
799 return False;
800 }
801
802 break;
803 }
804
805 case 1:
806 {
807 SRV_SHARE_INFO_1 *info1 = ctr->share.info1;
808 int num_entries = ctr->num_entries;
809 int i;
810
811 if (UNMARSHALLING(ps)) {
812 if (!(info1 = PRS_ALLOC_MEM(ps, SRV_SHARE_INFO_1, num_entries)))
813 return False;
814 ctr->share.info1 = info1;
815 }
816
817 for (i = 0; i < num_entries; i++) {
818 if(!srv_io_share_info1("", &info1[i].info_1, ps, depth))
819 return False;
820 }
821
822 for (i = 0; i < num_entries; i++) {
823 info1[i].info_1_str.ptrs = &info1[i].info_1;
824 if(!srv_io_share_info1_str("", &info1[i].info_1_str, ps, depth))
825 return False;
826 }
827
828 break;
829 }
830
831 case 2:
832 {
833 SRV_SHARE_INFO_2 *info2 = ctr->share.info2;
834 int num_entries = ctr->num_entries;
835 int i;
836
837 if (UNMARSHALLING(ps)) {
838 if (!(info2 = PRS_ALLOC_MEM(ps,SRV_SHARE_INFO_2,num_entries)))
839 return False;
840 ctr->share.info2 = info2;
841 }
842
843 for (i = 0; i < num_entries; i++) {
844 if(!srv_io_share_info2("", &info2[i].info_2, ps, depth))
845 return False;
846 }
847
848 for (i = 0; i < num_entries; i++) {
849 if(!srv_io_share_info2_str("", &info2[i].info_2, &info2[i].info_2_str, ps, depth))
850 return False;
851 }
852
853 break;
854 }
855
856 case 501:
857 {
858 SRV_SHARE_INFO_501 *info501 = ctr->share.info501;
859 int num_entries = ctr->num_entries;
860 int i;
861
862 if (UNMARSHALLING(ps)) {
863 if (!(info501 = PRS_ALLOC_MEM(ps, SRV_SHARE_INFO_501, num_entries)))
864 return False;
865 ctr->share.info501 = info501;
866 }
867
868 for (i = 0; i < num_entries; i++) {
869 if (!srv_io_share_info501("", &info501[i].info_501, ps, depth))
870 return False;
871 }
872
873 for (i = 0; i < num_entries; i++) {
874 if (!srv_io_share_info501_str("", &info501[i].info_501_str, ps, depth))
875 return False;
876 }
877
878 break;
879 }
880
881 case 502:
882 {
883 SRV_SHARE_INFO_502 *info502 = ctr->share.info502;
884 int num_entries = ctr->num_entries;
885 int i;
886
887 if (UNMARSHALLING(ps)) {
888 if (!(info502 = PRS_ALLOC_MEM(ps,SRV_SHARE_INFO_502,num_entries)))
889 return False;
890 ctr->share.info502 = info502;
891 }
892
893 for (i = 0; i < num_entries; i++) {
894 if(!srv_io_share_info502("", &info502[i].info_502, ps, depth))
895 return False;
896 }
897
898 for (i = 0; i < num_entries; i++) {
899 info502[i].info_502_str.ptrs = &info502[i].info_502;
900 if(!srv_io_share_info502_str("", &info502[i].info_502_str, ps, depth))
901 return False;
902 }
903
904 break;
905 }
906
907 case 1004:
908 {
909 SRV_SHARE_INFO_1004 *info1004 = ctr->share.info1004;
910 int num_entries = ctr->num_entries;
911 int i;
912
913 if (UNMARSHALLING(ps)) {
914 if (!(info1004 = PRS_ALLOC_MEM(ps,SRV_SHARE_INFO_1004,num_entries)))
915 return False;
916 ctr->share.info1004 = info1004;
917 }
918
919 for (i = 0; i < num_entries; i++) {
920 if(!srv_io_share_info1004("", &info1004[i].info_1004, ps, depth))
921 return False;
922 }
923
924 for (i = 0; i < num_entries; i++) {
925 info1004[i].info_1004_str.ptrs = &info1004[i].info_1004;
926 if(!srv_io_share_info1004_str("", &info1004[i].info_1004_str, ps, depth))
927 return False;
928 }
929
930 break;
931 }
932
933 case 1005:
934 {
935 SRV_SHARE_INFO_1005 *info1005 = ctr->share.info1005;
936 int num_entries = ctr->num_entries;
937 int i;
938
939 if (UNMARSHALLING(ps)) {
940 if (!(info1005 = PRS_ALLOC_MEM(ps,SRV_SHARE_INFO_1005,num_entries)))
941 return False;
942 ctr->share.info1005 = info1005;
943 }
944
945 for (i = 0; i < num_entries; i++) {
946 if(!srv_io_share_info1005("", &info1005[i], ps, depth))
947 return False;
948 }
949
950 break;
951 }
952
953 case 1006:
954 {
955 SRV_SHARE_INFO_1006 *info1006 = ctr->share.info1006;
956 int num_entries = ctr->num_entries;
957 int i;
958
959 if (UNMARSHALLING(ps)) {
960 if (!(info1006 = PRS_ALLOC_MEM(ps,SRV_SHARE_INFO_1006,num_entries)))
961 return False;
962 ctr->share.info1006 = info1006;
963 }
964
965 for (i = 0; i < num_entries; i++) {
966 if(!srv_io_share_info1006("", &info1006[i], ps, depth))
967 return False;
968 }
969
970 break;
971 }
972
973 case 1007:
974 {
975 SRV_SHARE_INFO_1007 *info1007 = ctr->share.info1007;
976 int num_entries = ctr->num_entries;
977 int i;
978
979 if (UNMARSHALLING(ps)) {
980 if (!(info1007 = PRS_ALLOC_MEM(ps,SRV_SHARE_INFO_1007,num_entries)))
981 return False;
982 ctr->share.info1007 = info1007;
983 }
984
985 for (i = 0; i < num_entries; i++) {
986 if(!srv_io_share_info1007("", &info1007[i].info_1007, ps, depth))
987 return False;
988 }
989
990 for (i = 0; i < num_entries; i++) {
991 info1007[i].info_1007_str.ptrs = &info1007[i].info_1007;
992 if(!srv_io_share_info1007_str("", &info1007[i].info_1007_str, ps, depth))
993 return False;
994 }
995
996 break;
997 }
998
999 case 1501:
1000 {
1001 SRV_SHARE_INFO_1501 *info1501 = ctr->share.info1501;
1002 int num_entries = ctr->num_entries;
1003 int i;
1004
1005 if (UNMARSHALLING(ps)) {
1006 if (!(info1501 = PRS_ALLOC_MEM(ps,SRV_SHARE_INFO_1501,num_entries)))
1007 return False;
1008 ctr->share.info1501 = info1501;
1009 }
1010
1011 for (i = 0; i < num_entries; i++) {
1012 if(!srv_io_share_info1501("", &info1501[i], ps, depth))
1013 return False;
1014 }
1015
1016 break;
1017 }
1018
1019 default:
1020 DEBUG(5,("%s no share info at switch_value %d\n",
1021 tab_depth(depth), ctr->switch_value));
1022 break;
1023 }
1024
1025 return True;
1026 }
1027
1028 /*******************************************************************
1029 Inits a SRV_Q_NET_SHARE_ENUM structure.
1030 ********************************************************************/
1031
1032 void init_srv_q_net_share_enum(SRV_Q_NET_SHARE_ENUM *q_n,
1033 const char *srv_name, uint32 info_level,
1034 uint32 preferred_len, ENUM_HND *hnd)
1035 {
1036
1037 DEBUG(5,("init_q_net_share_enum\n"));
1038
1039 init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
1040
1041 q_n->ctr.info_level = q_n->ctr.switch_value = info_level;
1042 q_n->ctr.ptr_share_info = 1;
1043 q_n->ctr.num_entries = 0;
1044 q_n->ctr.ptr_entries = 0;
1045 q_n->ctr.num_entries2 = 0;
1046 q_n->preferred_len = preferred_len;
1047
1048 memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
1049 }
1050
1051 /*******************************************************************
1052 Reads or writes a structure.
1053 ********************************************************************/
1054
1055 BOOL srv_io_q_net_share_enum(const char *desc, SRV_Q_NET_SHARE_ENUM *q_n, prs_struct *ps, int depth)
1056 {
1057 if (q_n == NULL)
1058 return False;
1059
1060 prs_debug(ps, depth, desc, "srv_io_q_net_share_enum");
1061 depth++;
1062
1063 if(!prs_align(ps))
1064 return False;
1065
1066 if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1067 return False;
1068 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1069 return False;
1070
1071 if(!srv_io_srv_share_ctr("share_ctr", &q_n->ctr, ps, depth))
1072 return False;
1073
1074 if(!prs_align(ps))
1075 return False;
1076
1077 if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
1078 return False;
1079
1080 if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
1081 return False;
1082
1083 return True;
1084 }
1085
1086 /*******************************************************************
1087 Reads or writes a structure.
1088 ********************************************************************/
1089
1090 BOOL srv_io_r_net_share_enum(const char *desc, SRV_R_NET_SHARE_ENUM *r_n, prs_struct *ps, int depth)
1091 {
1092 if (r_n == NULL)
1093 return False;
1094
1095 prs_debug(ps, depth, desc, "srv_io_r_net_share_enum");
1096 depth++;
1097
1098 if(!srv_io_srv_share_ctr("share_ctr", &r_n->ctr, ps, depth))
1099 return False;
1100
1101 if(!prs_align(ps))
1102 return False;
1103
1104 if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
1105 return False;
1106
1107 if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
1108 return False;
1109
1110 if(!prs_werror("status", ps, depth, &r_n->status))
1111 return False;
1112
1113 return True;
1114 }
1115
1116 /*******************************************************************
1117 initialises a structure.
1118 ********************************************************************/
1119
1120 BOOL init_srv_q_net_share_get_info(SRV_Q_NET_SHARE_GET_INFO *q_n, const char *srv_name, const char *share_name, uint32 info_level)
1121 {
1122
1123 uint32 ptr_share_name;
1124
1125 DEBUG(5,("init_srv_q_net_share_get_info\n"));
1126
1127 init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
1128 init_buf_unistr2(&q_n->uni_share_name, &ptr_share_name, share_name);
1129
1130 q_n->info_level = info_level;
1131
1132 return True;
1133 }
1134
1135 /*******************************************************************
1136 Reads or writes a structure.
1137 ********************************************************************/
1138
1139 BOOL srv_io_q_net_share_get_info(const char *desc, SRV_Q_NET_SHARE_GET_INFO *q_n, prs_struct *ps, int depth)
1140 {
1141 if (q_n == NULL)
1142 return False;
1143
1144 prs_debug(ps, depth, desc, "srv_io_q_net_share_get_info");
1145 depth++;
1146
1147 if(!prs_align(ps))
1148 return False;
1149
1150 if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1151 return False;
1152 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1153 return False;
1154
1155 if(!smb_io_unistr2("", &q_n->uni_share_name, True, ps, depth))
1156 return False;
1157
1158 if(!prs_align(ps))
1159 return False;
1160
1161 if(!prs_uint32("info_level", ps, depth, &q_n->info_level))
1162 return False;
1163
1164 return True;
1165 }
1166
1167 /*******************************************************************
1168 Reads or writes a structure.
1169 ********************************************************************/
1170
1171 static BOOL srv_io_srv_share_info(const char *desc, prs_struct *ps, int depth, SRV_SHARE_INFO *r_n)
1172 {
1173 if (r_n == NULL)
1174 return False;
1175
1176 prs_debug(ps, depth, desc, "srv_io_srv_share_info");
1177 depth++;
1178
1179 if(!prs_align(ps))
1180 return False;
1181
1182 if(!prs_uint32("switch_value ", ps, depth, &r_n->switch_value ))
1183 return False;
1184
1185 if(!prs_uint32("ptr_share_ctr", ps, depth, &r_n->ptr_share_ctr))
1186 return False;
1187
1188 if (r_n->ptr_share_ctr != 0) {
1189 switch (r_n->switch_value) {
1190 case 0:
1191 if(!srv_io_share_info0("", &r_n->share.info0.info_0, ps, depth))
1192 return False;
1193
1194 /* allow access to pointers in the str part. */
1195 r_n->share.info0.info_0_str.ptrs = &r_n->share.info0.info_0;
1196
1197 if(!srv_io_share_info0_str("", &r_n->share.info0.info_0_str, ps, depth))
1198 return False;
1199
1200 break;
1201 case 1:
1202 if(!srv_io_share_info1("", &r_n->share.info1.info_1, ps, depth))
1203 return False;
1204
1205 /* allow access to pointers in the str part. */
1206 r_n->share.info1.info_1_str.ptrs = &r_n->share.info1.info_1;
1207
1208 if(!srv_io_share_info1_str("", &r_n->share.info1.info_1_str, ps, depth))
1209 return False;
1210
1211 break;
1212 case 2:
1213 if(!srv_io_share_info2("", &r_n->share.info2.info_2, ps, depth))
1214 return False;
1215
1216 if(!srv_io_share_info2_str("", &r_n->share.info2.info_2, &r_n->share.info2.info_2_str, ps, depth))
1217 return False;
1218
1219 break;
1220 case 501:
1221 if (!srv_io_share_info501("", &r_n->share.info501.info_501, ps, depth))
1222 return False;
1223 if (!srv_io_share_info501_str("", &r_n->share.info501.info_501_str, ps, depth))
1224 return False;
1225 break;
1226
1227 case 502:
1228 if(!srv_io_share_info502("", &r_n->share.info502.info_502, ps, depth))
1229 return False;
1230
1231 /* allow access to pointers in the str part. */
1232 r_n->share.info502.info_502_str.ptrs = &r_n->share.info502.info_502;
1233
1234 if(!srv_io_share_info502_str("", &r_n->share.info502.info_502_str, ps, depth))
1235 return False;
1236 break;
1237 case 1004:
1238 if(!srv_io_share_info1004("", &r_n->share.info1004.info_1004, ps, depth))
1239 return False;
1240
1241 /* allow access to pointers in the str part. */
1242 r_n->share.info1004.info_1004_str.ptrs = &r_n->share.info1004.info_1004;
1243
1244 if(!srv_io_share_info1004_str("", &r_n->share.info1004.info_1004_str, ps, depth))
1245 return False;
1246 break;
1247 case 1005:
1248 if(!srv_io_share_info1005("", &r_n->share.info1005, ps, depth))
1249 return False;
1250 break;
1251 case 1006:
1252 if(!srv_io_share_info1006("", &r_n->share.info1006, ps, depth))
1253 return False;
1254 break;
1255 case 1007:
1256 if(!srv_io_share_info1007("", &r_n->share.info1007.info_1007, ps, depth))
1257 return False;
1258
1259 /* allow access to pointers in the str part. */
1260 r_n->share.info1007.info_1007_str.ptrs = &r_n->share.info1007.info_1007;
1261
1262 if(!srv_io_share_info1007_str("", &r_n->share.info1007.info_1007_str, ps, depth))
1263 return False;
1264 break;
1265 case 1501:
1266 if (!srv_io_share_info1501("", &r_n->share.info1501, ps, depth))
1267 return False;
1268 default:
1269 DEBUG(5,("%s no share info at switch_value %d\n",
1270 tab_depth(depth), r_n->switch_value));
1271 break;
1272 }
1273 }
1274
1275 return True;
1276 }
1277
1278 /*******************************************************************
1279 Reads or writes a structure.
1280 ********************************************************************/
1281
1282 BOOL srv_io_r_net_share_get_info(const char *desc, SRV_R_NET_SHARE_GET_INFO *r_n, prs_struct *ps, int depth)
1283 {
1284 if (r_n == NULL)
1285 return False;
1286
1287 prs_debug(ps, depth, desc, "srv_io_r_net_share_get_info");
1288 depth++;
1289
1290 if(!prs_align(ps))
1291 return False;
1292
1293 if(!srv_io_srv_share_info("info ", ps, depth, &r_n->info))
1294 return False;
1295
1296 if(!prs_align(ps))
1297 return False;
1298
1299 if(!prs_werror("status", ps, depth, &r_n->status))
1300 return False;
1301
1302 return True;
1303 }
1304
1305 /*******************************************************************
1306 intialises a structure.
1307 ********************************************************************/
1308
1309 BOOL init_srv_q_net_share_set_info(SRV_Q_NET_SHARE_SET_INFO *q_n,
1310 const char *srv_name,
1311 const char *share_name,
1312 uint32 info_level,
1313 const SRV_SHARE_INFO *info)
1314 {
1315
1316 uint32 ptr_share_name;
1317
1318 DEBUG(5,("init_srv_q_net_share_set_info\n"));
1319
1320 init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
1321 init_buf_unistr2(&q_n->uni_share_name, &ptr_share_name, share_name);
1322
1323 q_n->info_level = info_level;
1324
1325 q_n->info = *info;
1326
1327 q_n->ptr_parm_error = 1;
1328 q_n->parm_error = 0;
1329
1330 return True;
1331 }
1332
1333 /*******************************************************************
1334 Reads or writes a structure.
1335 ********************************************************************/
1336
1337 BOOL srv_io_q_net_share_set_info(const char *desc, SRV_Q_NET_SHARE_SET_INFO *q_n, prs_struct *ps, int depth)
1338 {
1339 if (q_n == NULL)
1340 return False;
1341
1342 prs_debug(ps, depth, desc, "srv_io_q_net_share_set_info");
1343 depth++;
1344
1345 if(!prs_align(ps))
1346 return False;
1347
1348 if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1349 return False;
1350 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1351 return False;
1352
1353 if(!smb_io_unistr2("", &q_n->uni_share_name, True, ps, depth))
1354 return False;
1355
1356 if(!prs_align(ps))
1357 return False;
1358
1359 if(!prs_uint32("info_level", ps, depth, &q_n->info_level))
1360 return False;
1361
1362 if(!prs_align(ps))
1363 return False;
1364
1365 if(!srv_io_srv_share_info("info ", ps, depth, &q_n->info))
1366 return False;
1367
1368 if(!prs_align(ps))
1369 return False;
1370 if(!prs_uint32("ptr_parm_error", ps, depth, &q_n->ptr_parm_error))
1371 return False;
1372 if(q_n->ptr_parm_error!=0) {
1373 if(!prs_uint32("parm_error", ps, depth, &q_n->parm_error))
1374 return False;
1375 }
1376
1377 return True;
1378 }
1379
1380 /*******************************************************************
1381 Reads or writes a structure.
1382 ********************************************************************/
1383
1384 BOOL srv_io_r_net_share_set_info(const char *desc, SRV_R_NET_SHARE_SET_INFO *r_n, prs_struct *ps, int depth)
1385 {
1386 if (r_n == NULL)
1387 return False;
1388
1389 prs_debug(ps, depth, desc, "srv_io_r_net_share_set_info");
1390 depth++;
1391
1392 if(!prs_align(ps))
1393 return False;
1394
1395 if(!prs_uint32("ptr_parm_error ", ps, depth, &r_n->ptr_parm_error))
1396 return False;
1397
1398 if(r_n->ptr_parm_error) {
1399
1400 if(!prs_uint32("parm_error ", ps, depth, &r_n->parm_error))
1401 return False;
1402 }
1403
1404 if(!prs_werror("status", ps, depth, &r_n->status))
1405 return False;
1406
1407 return True;
1408 }
1409
1410
1411 /*******************************************************************
1412 Reads or writes a structure.
1413 ********************************************************************/
1414
1415 BOOL srv_io_q_net_share_add(const char *desc, SRV_Q_NET_SHARE_ADD *q_n, prs_struct *ps, int depth)
1416 {
1417 if (q_n == NULL)
1418 return False;
1419
1420 prs_debug(ps, depth, desc, "srv_io_q_net_share_add");
1421 depth++;
1422
1423 if(!prs_align(ps))
1424 return False;
1425
1426 if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1427 return False;
1428 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1429 return False;
1430
1431 if(!prs_align(ps))
1432 return False;
1433
1434 if(!prs_uint32("info_level", ps, depth, &q_n->info_level))
1435 return False;
1436
1437 if(!prs_align(ps))
1438 return False;
1439
1440 if(!srv_io_srv_share_info("info ", ps, depth, &q_n->info))
1441 return False;
1442
1443 if(!prs_align(ps))
1444 return False;
1445
1446 if(!prs_uint32("ptr_err_index", ps, depth, &q_n->ptr_err_index))
1447 return False;
1448 if (q_n->ptr_err_index)
1449 if (!prs_uint32("err_index", ps, depth, &q_n->err_index))
1450 return False;
1451
1452 return True;
1453 }
1454
1455 void init_srv_q_net_share_add(SRV_Q_NET_SHARE_ADD *q, const char *srvname,
1456 const char *netname, uint32 type, const char *remark,
1457 uint32 perms, uint32 max_uses, uint32 num_uses,
1458 const char *path, const char *passwd,
1459 int level, SEC_DESC *sd)
1460 {
1461 switch(level) {
1462 case 502: {
1463 size_t sd_size = sec_desc_size(sd);
1464 q->ptr_srv_name = 1;
1465 init_unistr2(&q->uni_srv_name, srvname, UNI_STR_TERMINATE);
1466 q->info.switch_value = q->info_level = level;
1467 q->info.ptr_share_ctr = 1;
1468 init_srv_share_info502(&q->info.share.info502.info_502, netname, type,
1469 remark, perms, max_uses, num_uses, path, passwd, sd, sd_size);
1470 init_srv_share_info502_str(&q->info.share.info502.info_502_str, netname,
1471 remark, path, passwd, sd, sd_size);
1472 q->ptr_err_index = 1;
1473 q->err_index = 0;
1474 }
1475 break;
1476 case 2:
1477 default:
1478 q->ptr_srv_name = 1;
1479 init_unistr2(&q->uni_srv_name, srvname, UNI_STR_TERMINATE);
1480 q->info.switch_value = q->info_level = level;
1481 q->info.ptr_share_ctr = 1;
1482 init_srv_share_info2(&q->info.share.info2.info_2, netname, type,
1483 remark, perms, max_uses, num_uses, path, passwd);
1484 init_srv_share_info2_str(&q->info.share.info2.info_2_str, netname,
1485 remark, path, passwd);
1486 q->ptr_err_index = 1;
1487 q->err_index = 0;
1488 break;
1489 }
1490 }
1491
1492
1493 /*******************************************************************
1494 Reads or writes a structure.
1495 ********************************************************************/
1496
1497 BOOL srv_io_r_net_share_add(const char *desc, SRV_R_NET_SHARE_ADD *r_n, prs_struct *ps, int depth)
1498 {
1499 if (r_n == NULL)
1500 return False;
1501
1502 prs_debug(ps, depth, desc, "srv_io_r_net_share_add");
1503 depth++;
1504
1505 if(!prs_align(ps))
1506 return False;
1507
1508 if(!prs_uint32("ptr_parm_error", ps, depth, &r_n->ptr_parm_error))
1509 return False;
1510
1511 if(r_n->ptr_parm_error) {
1512
1513 if(!prs_uint32("parm_error", ps, depth, &r_n->parm_error))
1514 return False;
1515 }
1516
1517 if(!prs_werror("status", ps, depth, &r_n->status))
1518 return False;
1519
1520 return True;
1521 }
1522
1523 /*******************************************************************
1524 initialises a structure.
1525 ********************************************************************/
1526
1527 void init_srv_q_net_share_del(SRV_Q_NET_SHARE_DEL *del, const char *srvname,
1528 const char *sharename)
1529 {
1530 del->ptr_srv_name = 1;
1531 init_unistr2(&del->uni_srv_name, srvname, UNI_STR_TERMINATE);
1532 init_unistr2(&del->uni_share_name, sharename, UNI_STR_TERMINATE);
1533 }
1534
1535 /*******************************************************************
1536 Reads or writes a structure.
1537 ********************************************************************/
1538
1539 BOOL srv_io_q_net_share_del(const char *desc, SRV_Q_NET_SHARE_DEL *q_n, prs_struct *ps, int depth)
1540 {
1541 if (q_n == NULL)
1542 return False;
1543
1544 prs_debug(ps, depth, desc, "srv_io_q_net_share_del");
1545 depth++;
1546
1547 if(!prs_align(ps))
1548 return False;
1549
1550 if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1551 return False;
1552 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1553 return False;
1554
1555 if(!smb_io_unistr2("", &q_n->uni_share_name, True, ps, depth))
1556 return False;
1557
1558 if(!prs_align(ps))
1559 return False;
1560 if(!prs_uint32("reserved", ps, depth, &q_n->reserved))
1561 return False;
1562
1563 return True;
1564 }
1565
1566 /*******************************************************************
1567 Reads or writes a structure.
1568 ********************************************************************/
1569
1570 BOOL srv_io_r_net_share_del(const char *desc, SRV_R_NET_SHARE_DEL *q_n, prs_struct *ps, int depth)
1571 {
1572 if (q_n == NULL)
1573 return False;
1574
1575 prs_debug(ps, depth, desc, "srv_io_r_net_share_del");
1576 depth++;
1577
1578 if(!prs_align(ps))
1579 return False;
1580
1581 if(!prs_werror("status", ps, depth, &q_n->status))
1582 return False;
1583
1584 return True;
1585 }
1586
1587 /*******************************************************************
1588 Inits a SESS_INFO_0_STR structure
1589 ********************************************************************/
1590
1591 void init_srv_sess_info0_str(SESS_INFO_0_STR *ss0, const char *name)
1592 {
1593 DEBUG(5,("init_srv_sess_info0_str\n"));
1594
1595 init_unistr2(&ss0->uni_name, name, UNI_STR_TERMINATE);
1596 }
1597
1598 /*******************************************************************
1599 Reads or writes a structure.
1600 ********************************************************************/
1601
1602 static BOOL srv_io_sess_info0_str(const char *desc, SESS_INFO_0_STR *ss0, prs_struct *ps, int depth)
1603 {
1604 if (ss0 == NULL)
1605 return False;
1606
1607 prs_debug(ps, depth, desc, "srv_io_sess_info0_str");
1608 depth++;
1609
1610 if(!prs_align(ps))
1611 return False;
1612
1613 if(!smb_io_unistr2("", &ss0->uni_name, True, ps, depth))
1614 return False;
1615
1616 return True;
1617 }
1618
1619 /*******************************************************************
1620 Inits a SESS_INFO_0 structure
1621 ********************************************************************/
1622
1623 void init_srv_sess_info0(SESS_INFO_0 *ss0, const char *name)
1624 {
1625 DEBUG(5,("init_srv_sess_info0: %s\n", name));
1626
1627 ss0->ptr_name = (name != NULL) ? 1 : 0;
1628 }
1629
1630 /*******************************************************************
1631 Reads or writes a structure.
1632 ********************************************************************/
1633
1634 static BOOL srv_io_sess_info0(const char *desc, SESS_INFO_0 *ss0, prs_struct *ps, int depth)
1635 {
1636 if (ss0 == NULL)
1637 return False;
1638
1639 prs_debug(ps, depth, desc, "srv_io_sess_info0");
1640 depth++;
1641
1642 if(!prs_align(ps))
1643 return False;
1644
1645 if(!prs_uint32("ptr_name", ps, depth, &ss0->ptr_name))
1646 return False;
1647
1648 return True;
1649 }
1650
1651 /*******************************************************************
1652 Reads or writes a structure.
1653 ********************************************************************/
1654
1655 static BOOL srv_io_srv_sess_info_0(const char *desc, SRV_SESS_INFO_0 *ss0, prs_struct *ps, int depth)
1656 {
1657 if (ss0 == NULL)
1658 return False;
1659
1660 prs_debug(ps, depth, desc, "srv_io_srv_sess_info_0");
1661 depth++;
1662
1663 if(!prs_align(ps))
1664 return False;
1665
1666 if(!prs_uint32("num_entries_read", ps, depth, &ss0->num_entries_read))
1667 return False;
1668 if(!prs_uint32("ptr_sess_info", ps, depth, &ss0->ptr_sess_info))
1669 return False;
1670
1671 if (ss0->ptr_sess_info != 0) {
1672 uint32 i;
1673 uint32 num_entries = ss0->num_entries_read;
1674
1675 if (num_entries > MAX_SESS_ENTRIES) {
1676 num_entries = MAX_SESS_ENTRIES; /* report this! */
1677 }
1678
1679 if(!prs_uint32("num_entries_read2", ps, depth, &ss0->num_entries_read2))
1680 return False;
1681
1682 SMB_ASSERT_ARRAY(ss0->info_0, num_entries);
1683
1684 for (i = 0; i < num_entries; i++) {
1685 if(!srv_io_sess_info0("", &ss0->info_0[i], ps, depth))
1686 return False;
1687 }
1688
1689 for (i = 0; i < num_entries; i++) {
1690 if(!srv_io_sess_info0_str("", &ss0->info_0_str[i], ps, depth))
1691 return False;
1692 }
1693
1694 if(!prs_align(ps))
1695 return False;
1696 }
1697
1698 return True;
1699 }
1700
1701 /*******************************************************************
1702 Inits a SESS_INFO_1_STR structure
1703 ********************************************************************/
1704
1705 void init_srv_sess_info1_str(SESS_INFO_1_STR *ss1, const char *name, const char *user)
1706 {
1707 DEBUG(5,("init_srv_sess_info1_str\n"));
1708
1709 init_unistr2(&ss1->uni_name, name, UNI_STR_TERMINATE);
1710 init_unistr2(&ss1->uni_user, user, UNI_STR_TERMINATE);
1711 }
1712
1713 /*******************************************************************
1714 Reads or writes a structure.
1715 ********************************************************************/
1716
1717 static BOOL srv_io_sess_info1_str(const char *desc, SESS_INFO_1_STR *ss1, prs_struct *ps, int depth)
1718 {
1719 if (ss1 == NULL)
1720 return False;
1721
1722 prs_debug(ps, depth, desc, "srv_io_sess_info1_str");
1723 depth++;
1724
1725 if(!prs_align(ps))
1726 return False;
1727
1728 if(!smb_io_unistr2("", &ss1->uni_name, True, ps, depth))
1729 return False;
1730 if(!smb_io_unistr2("", &(ss1->uni_user), True, ps, depth))
1731 return False;
1732
1733 return True;
1734 }
1735
1736 /*******************************************************************
1737 Inits a SESS_INFO_1 structure
1738 ********************************************************************/
1739
1740 void init_srv_sess_info1(SESS_INFO_1 *ss1,
1741 const char *name, const char *user,
1742 uint32 num_opens, uint32 open_time, uint32 idle_time,
1743 uint32 user_flags)
1744 {
1745 DEBUG(5,("init_srv_sess_info1: %s\n", name));
1746
1747 ss1->ptr_name = (name != NULL) ? 1 : 0;
1748 ss1->ptr_user = (user != NULL) ? 1 : 0;
1749
1750 ss1->num_opens = num_opens;
1751 ss1->open_time = open_time;
1752 ss1->idle_time = idle_time;
1753 ss1->user_flags = user_flags;
1754 }
1755
1756 /*******************************************************************
1757 reads or writes a structure.
1758 ********************************************************************/
1759
1760 static BOOL srv_io_sess_info1(const char *desc, SESS_INFO_1 *ss1, prs_struct *ps, int depth)
1761 {
1762 if (ss1 == NULL)
1763 return False;
1764
1765 prs_debug(ps, depth, desc, "srv_io_sess_info1");
1766 depth++;
1767
1768 if(!prs_align(ps))
1769 return False;
1770
1771 if(!prs_uint32("ptr_name ", ps, depth, &ss1->ptr_name))
1772 return False;
1773 if(!prs_uint32("ptr_user ", ps, depth, &ss1->ptr_user))
1774 return False;
1775
1776 if(!prs_uint32("num_opens ", ps, depth, &ss1->num_opens))
1777 return False;
1778 if(!prs_uint32("open_time ", ps, depth, &ss1->open_time))
1779 return False;
1780 if(!prs_uint32("idle_time ", ps, depth, &ss1->idle_time))
1781 return False;
1782 if(!prs_uint32("user_flags", ps, depth, &ss1->user_flags))
1783 return False;
1784
1785 return True;
1786 }
1787
1788 /*******************************************************************
1789 Reads or writes a structure.
1790 ********************************************************************/
1791
1792 static BOOL srv_io_srv_sess_info_1(const char *desc, SRV_SESS_INFO_1 *ss1, prs_struct *ps, int depth)
1793 {
1794 if (ss1 == NULL)
1795 return False;
1796
1797 prs_debug(ps, depth, desc, "srv_io_srv_sess_info_1");
1798 depth++;
1799
1800 if(!prs_align(ps))
1801 return False;
1802
1803 if(!prs_uint32("num_entries_read", ps, depth, &ss1->num_entries_read))
1804 return False;
1805 if(!prs_uint32("ptr_sess_info", ps, depth, &ss1->ptr_sess_info))
1806 return False;
1807
1808 if (ss1->ptr_sess_info != 0) {
1809 uint32 i;
1810 uint32 num_entries = ss1->num_entries_read;
1811
1812 if (num_entries > MAX_SESS_ENTRIES) {
1813 num_entries = MAX_SESS_ENTRIES; /* report this! */
1814 }
1815
1816 if(!prs_uint32("num_entries_read2", ps, depth, &ss1->num_entries_read2))
1817 return False;
1818
1819 SMB_ASSERT_ARRAY(ss1->info_1, num_entries);
1820
1821 for (i = 0; i < num_entries; i++) {
1822 if(!srv_io_sess_info1("", &ss1->info_1[i], ps, depth))
1823 return False;
1824 }
1825
1826 for (i = 0; i < num_entries; i++) {
1827 if(!srv_io_sess_info1_str("", &ss1->info_1_str[i], ps, depth))
1828 return False;
1829 }
1830
1831 if(!prs_align(ps))
1832 return False;
1833 }
1834
1835 return True;
1836 }
1837
1838 /*******************************************************************
1839 Reads or writes a structure.
1840 ********************************************************************/
1841
1842 static BOOL srv_io_srv_sess_ctr(const char *desc, SRV_SESS_INFO_CTR **pp_ctr, prs_struct *ps, int depth)
1843 {
1844 SRV_SESS_INFO_CTR *ctr = *pp_ctr;
1845
1846 prs_debug(ps, depth, desc, "srv_io_srv_sess_ctr");
1847 depth++;
1848
1849 if(UNMARSHALLING(ps)) {
1850 ctr = *pp_ctr = PRS_ALLOC_MEM(ps, SRV_SESS_INFO_CTR, 1);
1851 if (ctr == NULL)
1852 return False;
1853 }
1854
1855 if (ctr == NULL)
1856 return False;
1857
1858 if(!prs_align(ps))
1859 return False;
1860
1861 if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
1862 return False;
1863 if(!prs_uint32("ptr_sess_ctr", ps, depth, &ctr->ptr_sess_ctr))
1864 return False;
1865
1866 if (ctr->ptr_sess_ctr != 0) {
1867 switch (ctr->switch_value) {
1868 case 0:
1869 if(!srv_io_srv_sess_info_0("", &ctr->sess.info0, ps, depth))
1870 return False;
1871 break;
1872 case 1:
1873 if(!srv_io_srv_sess_info_1("", &ctr->sess.info1, ps, depth))
1874 return False;
1875 break;
1876 default:
1877 DEBUG(5,("%s no session info at switch_value %d\n",
1878 tab_depth(depth), ctr->switch_value));
1879 break;
1880 }
1881 }
1882
1883 return True;
1884 }
1885
1886 /*******************************************************************
1887 Inits a SRV_Q_NET_SESS_ENUM structure.
1888 ********************************************************************/
1889
1890 void init_srv_q_net_sess_enum(SRV_Q_NET_SESS_ENUM *q_n,
1891 const char *srv_name, const char *qual_name,
1892 const char *user_name, uint32 sess_level,
1893 SRV_SESS_INFO_CTR *ctr, uint32 preferred_len,
1894 ENUM_HND *hnd)
1895 {
1896 q_n->ctr = ctr;
1897
1898 DEBUG(5,("init_q_net_sess_enum\n"));
1899
1900 init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
1901 init_buf_unistr2(&q_n->uni_qual_name, &q_n->ptr_qual_name, qual_name);
1902 init_buf_unistr2(&q_n->uni_user_name, &q_n->ptr_user_name, user_name);
1903
1904 q_n->sess_level = sess_level;
1905 q_n->preferred_len = preferred_len;
1906
1907 memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
1908 }
1909
1910 /*******************************************************************
1911 Reads or writes a structure.
1912 ********************************************************************/
1913
1914 BOOL srv_io_q_net_sess_enum(const char *desc, SRV_Q_NET_SESS_ENUM *q_n, prs_struct *ps, int depth)
1915 {
1916 if (q_n == NULL)
1917 return False;
1918
1919 prs_debug(ps, depth, desc, "srv_io_q_net_sess_enum");
1920 depth++;
1921
1922 if(!prs_align(ps))
1923 return False;
1924
1925 if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
1926 return False;
1927 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
1928 return False;
1929
1930 if(!prs_align(ps))
1931 return False;
1932
1933 if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
1934 return False;
1935 if(!smb_io_unistr2("", &q_n->uni_qual_name, q_n->ptr_qual_name, ps, depth))
1936 return False;
1937
1938 if(!prs_align(ps))
1939 return False;
1940 if(!prs_uint32("ptr_user_name", ps, depth, &q_n->ptr_user_name))
1941 return False;
1942 if(!smb_io_unistr2("", &q_n->uni_user_name, q_n->ptr_user_name, ps, depth))
1943 return False;
1944
1945 if(!prs_align(ps))
1946 return False;
1947
1948 if(!prs_uint32("sess_level", ps, depth, &q_n->sess_level))
1949 return False;
1950
1951 if (q_n->sess_level != (uint32)-1) {
1952 if(!srv_io_srv_sess_ctr("sess_ctr", &q_n->ctr, ps, depth))
1953 return False;
1954 }
1955
1956 if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
1957 return False;
1958
1959 if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
1960 return False;
1961
1962 return True;
1963 }
1964
1965 /*******************************************************************
1966 Reads or writes a structure.
1967 ********************************************************************/
1968
1969 BOOL srv_io_r_net_sess_enum(const char *desc, SRV_R_NET_SESS_ENUM *r_n, prs_struct *ps, int depth)
1970 {
1971 if (r_n == NULL)
1972 return False;
1973
1974 prs_debug(ps, depth, desc, "srv_io_r_net_sess_enum");
1975 depth++;
1976
1977 if(!prs_align(ps))
1978 return False;
1979
1980 if(!prs_uint32("sess_level", ps, depth, &r_n->sess_level))
1981 return False;
1982
1983 if (r_n->sess_level != (uint32)-1) {
1984 if(!srv_io_srv_sess_ctr("sess_ctr", &r_n->ctr, ps, depth))
1985 return False;
1986 }
1987
1988 if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
1989 return False;
1990 if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
1991 return False;
1992 if(!prs_werror("status", ps, depth, &r_n->status))
1993 return False;
1994
1995 return True;
1996 }
1997
1998 /*******************************************************************
1999 Inits a SRV_Q_NET_SESS_DEL structure.
2000 ********************************************************************/
2001
2002 void init_srv_q_net_sess_del(SRV_Q_NET_SESS_DEL *q_n, const char *srv_name,
2003 const char *cli_name, const char *user_name)
2004 {
2005 DEBUG(5,("init_q_net_sess_enum\n"));
2006
2007 init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
2008 init_buf_unistr2(&q_n->uni_cli_name, &q_n->ptr_cli_name, cli_name);
2009 init_buf_unistr2(&q_n->uni_user_name, &q_n->ptr_user_name, user_name);
2010 }
2011
2012 /*******************************************************************
2013 Reads or writes a structure.
2014 ********************************************************************/
2015
2016 BOOL srv_io_q_net_sess_del(const char *desc, SRV_Q_NET_SESS_DEL *q_n, prs_struct *ps, int depth)
2017 {
2018 if (q_n == NULL)
2019 return False;
2020
2021 prs_debug(ps, depth, desc, "srv_io_q_net_sess_del");
2022 depth++;
2023
2024 if(!prs_align(ps))
2025 return False;
2026
2027 if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
2028 return False;
2029 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
2030 return False;
2031
2032 if(!prs_align(ps))
2033 return False;
2034
2035 if(!prs_uint32("ptr_cli_name", ps, depth, &q_n->ptr_cli_name))
2036 return False;
2037 if(!smb_io_unistr2("", &q_n->uni_cli_name, q_n->ptr_cli_name, ps, depth))
2038 return False;
2039
2040 if(!prs_align(ps))
2041 return False;
2042 if(!prs_uint32("ptr_user_name", ps, depth, &q_n->ptr_user_name))
2043 return False;
2044 if(!smb_io_unistr2("", &q_n->uni_user_name, q_n->ptr_user_name, ps, depth))
2045 return False;
2046
2047 return True;
2048 }
2049
2050 /*******************************************************************
2051 Reads or writes a structure.
2052 ********************************************************************/
2053
2054 BOOL srv_io_r_net_sess_del(const char *desc, SRV_R_NET_SESS_DEL *r_n, prs_struct *ps, int depth)
2055 {
2056 if (r_n == NULL)
2057 return False;
2058
2059 prs_debug(ps, depth, desc, "srv_io_r_net_sess_del");
2060 depth++;
2061
2062 if(!prs_align(ps))
2063 return False;
2064
2065 if(!prs_werror("status", ps, depth, &r_n->status))
2066 return False;
2067
2068 return True;
2069 }
2070
2071 /*******************************************************************
2072 Inits a CONN_INFO_0 structure
2073 ********************************************************************/
2074
2075 void init_srv_conn_info0(CONN_INFO_0 *ss0, uint32 id)
2076 {
2077 DEBUG(5,("init_srv_conn_info0\n"));
2078
2079 ss0->id = id;
2080 }
2081
2082 /*******************************************************************
2083 Reads or writes a structure.
2084 ********************************************************************/
2085
2086 static BOOL srv_io_conn_info0(const char *desc, CONN_INFO_0 *ss0, prs_struct *ps, int depth)
2087 {
2088 if (ss0 == NULL)
2089 return False;
2090
2091 prs_debug(ps, depth, desc, "srv_io_conn_info0");
2092 depth++;
2093
2094 if(!prs_align(ps))
2095 return False;
2096
2097 if(!prs_uint32("id", ps, depth, &ss0->id))
2098 return False;
2099
2100 return True;
2101 }
2102
2103 /*******************************************************************
2104 Reads or writes a structure.
2105 ********************************************************************/
2106
2107 static BOOL srv_io_srv_conn_info_0(const char *desc, SRV_CONN_INFO_0 *ss0, prs_struct *ps, int depth)
2108 {
2109 if (ss0 == NULL)
2110 return False;
2111
2112 prs_debug(ps, depth, desc, "srv_io_srv_conn_info_0");
2113 depth++;
2114
2115 if(!prs_align(ps))
2116 return False;
2117
2118 if(!prs_uint32("num_entries_read", ps, depth, &ss0->num_entries_read))
2119 return False;
2120 if(!prs_uint32("ptr_conn_info", ps, depth, &ss0->ptr_conn_info))
2121 return False;
2122
2123 if (ss0->ptr_conn_info != 0) {
2124 int i;
2125 int num_entries = ss0->num_entries_read;
2126
2127 if (num_entries > MAX_CONN_ENTRIES) {
2128 num_entries = MAX_CONN_ENTRIES; /* report this! */
2129 }
2130
2131 if(!prs_uint32("num_entries_read2", ps, depth, &ss0->num_entries_read2))
2132 return False;
2133
2134 for (i = 0; i < num_entries; i++) {
2135 if(!srv_io_conn_info0("", &ss0->info_0[i], ps, depth))
2136 return False;
2137 }
2138
2139 if(!prs_align(ps))
2140 return False;
2141 }
2142
2143 return True;
2144 }
2145
2146 /*******************************************************************
2147 Inits a CONN_INFO_1_STR structure
2148 ********************************************************************/
2149
2150 void init_srv_conn_info1_str(CONN_INFO_1_STR *ss1, const char *usr_name, const char *net_name)
2151 {
2152 DEBUG(5,("init_srv_conn_info1_str\n"));
2153
2154 init_unistr2(&ss1->uni_usr_name, usr_name, UNI_STR_TERMINATE);
2155 init_unistr2(&ss1->uni_net_name, net_name, UNI_STR_TERMINATE);
2156 }
2157
2158 /*******************************************************************
2159 Reads or writes a structure.
2160 ********************************************************************/
2161
2162 static BOOL srv_io_conn_info1_str(const char *desc, CONN_INFO_1_STR *ss1, prs_struct *ps, int depth)
2163 {
2164 if (ss1 == NULL)
2165 return False;
2166
2167 prs_debug(ps, depth, desc, "srv_io_conn_info1_str");
2168 depth++;
2169
2170 if(!prs_align(ps))
2171 return False;
2172
2173 if(!smb_io_unistr2("", &ss1->uni_usr_name, True, ps, depth))
2174 return False;
2175 if(!smb_io_unistr2("", &ss1->uni_net_name, True, ps, depth))
2176 return False;
2177
2178 return True;
2179 }
2180
2181 /*******************************************************************
2182 Inits a CONN_INFO_1 structure
2183 ********************************************************************/
2184
2185 void init_srv_conn_info1(CONN_INFO_1 *ss1,
2186 uint32 id, uint32 type,
2187 uint32 num_opens, uint32 num_users, uint32 open_time,
2188 const char *usr_name, const char *net_name)
2189 {
2190 DEBUG(5,("init_srv_conn_info1: %s %s\n", usr_name, net_name));
2191
2192 ss1->id = id ;
2193 ss1->type = type ;
2194 ss1->num_opens = num_opens ;
2195 ss1->num_users = num_users;
2196 ss1->open_time = open_time;
2197
2198 ss1->ptr_usr_name = (usr_name != NULL) ? 1 : 0;
2199 ss1->ptr_net_name = (net_name != NULL) ? 1 : 0;
2200 }
2201
2202 /*******************************************************************
2203 Reads or writes a structure.
2204 ********************************************************************/
2205
2206 static BOOL srv_io_conn_info1(const char *desc, CONN_INFO_1 *ss1, prs_struct *ps, int depth)
2207 {
2208 if (ss1 == NULL)
2209 return False;
2210
2211 prs_debug(ps, depth, desc, "srv_io_conn_info1");
2212 depth++;
2213
2214 if(!prs_align(ps))
2215 return False;
2216
2217 if(!prs_uint32("id ", ps, depth, &ss1->id))
2218 return False;
2219 if(!prs_uint32("type ", ps, depth, &ss1->type))
2220 return False;
2221 if(!prs_uint32("num_opens ", ps, depth, &ss1->num_opens))
2222 return False;
2223 if(!prs_uint32("num_users ", ps, depth, &ss1->num_users))
2224 return False;
2225 if(!prs_uint32("open_time ", ps, depth, &ss1->open_time))
2226 return False;
2227
2228 if(!prs_uint32("ptr_usr_name", ps, depth, &ss1->ptr_usr_name))
2229 return False;
2230 if(!prs_uint32("ptr_net_name", ps, depth, &ss1->ptr_net_name))
2231 return False;
2232
2233 return True;
2234 }
2235
2236 /*******************************************************************
2237 Reads or writes a structure.
2238 ********************************************************************/
2239
2240 static BOOL srv_io_srv_conn_info_1(const char *desc, SRV_CONN_INFO_1 *ss1, prs_struct *ps, int depth)
2241 {
2242 if (ss1 == NULL)
2243 return False;
2244
2245 prs_debug(ps, depth, desc, "srv_io_srv_conn_info_1");
2246 depth++;
2247
2248 if(!prs_align(ps))
2249 return False;
2250
2251 if(!prs_uint32("num_entries_read", ps, depth, &ss1->num_entries_read))
2252 return False;
2253 if(!prs_uint32("ptr_conn_info", ps, depth, &ss1->ptr_conn_info))
2254 return False;
2255
2256 if (ss1->ptr_conn_info != 0) {
2257 int i;
2258 int num_entries = ss1->num_entries_read;
2259
2260 if (num_entries > MAX_CONN_ENTRIES) {
2261 num_entries = MAX_CONN_ENTRIES; /* report this! */
2262 }
2263
2264 if(!prs_uint32("num_entries_read2", ps, depth, &ss1->num_entries_read2))
2265 return False;
2266
2267 for (i = 0; i < num_entries; i++) {
2268 if(!srv_io_conn_info1("", &ss1->info_1[i], ps, depth))
2269 return False;
2270 }
2271
2272 for (i = 0; i < num_entries; i++) {
2273 if(!srv_io_conn_info1_str("", &ss1->info_1_str[i], ps, depth))
2274 return False;
2275 }
2276
2277 if(!prs_align(ps))
2278 return False;
2279 }
2280
2281 return True;
2282 }
2283
2284 /*******************************************************************
2285 Reads or writes a structure.
2286 ********************************************************************/
2287
2288 static BOOL srv_io_srv_conn_ctr(const char *desc, SRV_CONN_INFO_CTR **pp_ctr, prs_struct *ps, int depth)
2289 {
2290 SRV_CONN_INFO_CTR *ctr = *pp_ctr;
2291
2292 prs_debug(ps, depth, desc, "srv_io_srv_conn_ctr");
2293 depth++;
2294
2295 if (UNMARSHALLING(ps)) {
2296 ctr = *pp_ctr = PRS_ALLOC_MEM(ps, SRV_CONN_INFO_CTR, 1);
2297 if (ctr == NULL)
2298 return False;
2299 }
2300
2301 if (ctr == NULL)
2302 return False;
2303
2304 if(!prs_align(ps))
2305 return False;
2306
2307 if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
2308 return False;
2309 if(!prs_uint32("ptr_conn_ctr", ps, depth, &ctr->ptr_conn_ctr))
2310 return False;
2311
2312 if (ctr->ptr_conn_ctr != 0) {
2313 switch (ctr->switch_value) {
2314 case 0:
2315 if(!srv_io_srv_conn_info_0("", &ctr->conn.info0, ps, depth))
2316 return False;
2317 break;
2318 case 1:
2319 if(!srv_io_srv_conn_info_1("", &ctr->conn.info1, ps, depth))
2320 return False;
2321 break;
2322 default:
2323 DEBUG(5,("%s no connection info at switch_value %d\n",
2324 tab_depth(depth), ctr->switch_value));
2325 break;
2326 }
2327 }
2328
2329 return True;
2330 }
2331
2332 /*******************************************************************
2333 Reads or writes a structure.
2334 ********************************************************************/
2335
2336 void init_srv_q_net_conn_enum(SRV_Q_NET_CONN_ENUM *q_n,
2337 const char *srv_name, const char *qual_name,
2338 uint32 conn_level, SRV_CONN_INFO_CTR *ctr,
2339 uint32 preferred_len,
2340 ENUM_HND *hnd)
2341 {
2342 DEBUG(5,("init_q_net_conn_enum\n"));
2343
2344 q_n->ctr = ctr;
2345
2346 init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name );
2347 init_buf_unistr2(&q_n->uni_qual_name, &q_n->ptr_qual_name, qual_name);
2348
2349 q_n->conn_level = conn_level;
2350 q_n->preferred_len = preferred_len;
2351
2352 memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
2353 }
2354
2355 /*******************************************************************
2356 Reads or writes a structure.
2357 ********************************************************************/
2358
2359 BOOL srv_io_q_net_conn_enum(const char *desc, SRV_Q_NET_CONN_ENUM *q_n, prs_struct *ps, int depth)
2360 {
2361 if (q_n == NULL)
2362 return False;
2363
2364 prs_debug(ps, depth, desc, "srv_io_q_net_conn_enum");
2365 depth++;
2366
2367 if(!prs_align(ps))
2368 return False;
2369
2370 if(!prs_uint32("ptr_srv_name ", ps, depth, &q_n->ptr_srv_name))
2371 return False;
2372 if(!smb_io_unistr2("", &q_n->uni_srv_name, q_n->ptr_srv_name, ps, depth))
2373 return False;
2374
2375 if(!prs_align(ps))
2376 return False;
2377
2378 if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
2379 return False;
2380 if(!smb_io_unistr2("", &q_n->uni_qual_name, q_n->ptr_qual_name, ps, depth))
2381 return False;
2382
2383 if(!prs_align(ps))
2384 return False;
2385
2386 if(!prs_uint32("conn_level", ps, depth, &q_n->conn_level))
2387 return False;
2388
2389 if (q_n->conn_level != (uint32)-1) {
2390 if(!srv_io_srv_conn_ctr("conn_ctr", &q_n->ctr, ps, depth))
2391 return False;
2392 }
2393
2394 if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
2395 return False;
2396
2397 if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
2398 return False;
2399
2400 return True;
2401 }
2402
2403 /*******************************************************************
2404 Reads or writes a structure.
2405 ********************************************************************/
2406
2407 BOOL srv_io_r_net_conn_enum(const char *desc, SRV_R_NET_CONN_ENUM *r_n, prs_struct *ps, int depth)
2408 {
2409 if (r_n == NULL)
2410 return False;
2411
2412 prs_debug(ps, depth, desc, "srv_io_r_net_conn_enum");
2413 depth++;
2414
2415 if(!prs_align(ps))
2416 return False;
2417
2418 if(!prs_uint32("conn_level", ps, depth, &r_n->conn_level))
2419 return False;
2420
2421 if (r_n->conn_level != (uint32)-1) {
2422 if(!srv_io_srv_conn_ctr("conn_ctr", &r_n->ctr, ps, depth))
2423 return False;
2424 }
2425
2426 if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
2427 return False;
2428 if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
2429 return False;
2430 if(!prs_werror("status", ps, depth, &r_n->status))
2431 return False;
2432
2433 return True;
2434 }
2435
2436 /*******************************************************************
2437 Inits a FILE_INFO_3_STR structure
2438 ********************************************************************/
2439
2440 void init_srv_file_info3_str(FILE_INFO_3_STR *fi3, const char *user_name, const char *path_name)
2441 {
2442 DEBUG(5,("init_srv_file_info3_str\n"));
2443
2444 init_unistr2(&fi3->uni_path_name, path_name, UNI_STR_TERMINATE);
2445 init_unistr2(&fi3->uni_user_name, user_name, UNI_STR_TERMINATE);
2446 }
2447
2448 /*******************************************************************
2449 Reads or writes a structure.
2450 ********************************************************************/
2451
2452 static BOOL srv_io_file_info3_str(const char *desc, FILE_INFO_3_STR *sh1, prs_struct *ps, int depth)
2453 {
2454 if (sh1 == NULL)
2455 return False;
2456
2457 prs_debug(ps, depth, desc, "srv_io_file_info3_str");
2458 depth++;
2459
2460 if(!prs_align(ps))
2461 return False;
2462
2463 if(!smb_io_unistr2("", &sh1->uni_path_name, True, ps, depth))
2464 return False;
2465 if(!smb_io_unistr2("", &sh1->uni_user_name, True, ps, depth))
2466 return False;
2467
2468 return True;
2469 }
2470
2471 /*******************************************************************
2472 Inits a FILE_INFO_3 structure
2473 ********************************************************************/
2474
2475 void init_srv_file_info3(FILE_INFO_3 *fl3,
2476 uint32 id, uint32 perms, uint32 num_locks,
2477 const char *path_name, const char *user_name)
2478 {
2479 DEBUG(5,("init_srv_file_info3: %s %s\n", path_name, user_name));
2480
2481 fl3->id = id;
2482 fl3->perms = perms;
2483 fl3->num_locks = num_locks;
2484
2485 fl3->ptr_path_name = (path_name != NULL) ? 1 : 0;
2486 fl3->ptr_user_name = (user_name != NULL) ? 1 : 0;
2487 }
2488
2489 /*******************************************************************
2490 Reads or writes a structure.
2491 ********************************************************************/
2492
2493 static BOOL srv_io_file_info3(const char *desc, FILE_INFO_3 *fl3, prs_struct *ps, int depth)
2494 {
2495 if (fl3 == NULL)
2496 return False;
2497
2498 prs_debug(ps, depth, desc, "srv_io_file_info3");
2499 depth++;
2500
2501 if(!prs_align(ps))
2502 return False;
2503
2504 if(!prs_uint32("id ", ps, depth, &fl3->id))
2505 return False;
2506 if(!prs_uint32("perms ", ps, depth, &fl3->perms))
2507 return False;
2508 if(!prs_uint32("num_locks ", ps, depth, &fl3->num_locks))
2509 return False;
2510 if(!prs_uint32("ptr_path_name", ps, depth, &fl3->ptr_path_name))
2511 return False;
2512 if(!prs_uint32("ptr_user_name", ps, depth, &fl3->ptr_user_name))
2513 return False;
2514
2515 return True;
2516 }
2517
2518 /*******************************************************************
2519 Reads or writes a structure.
2520 ********************************************************************/
2521
2522 static BOOL srv_io_srv_file_ctr(const char *desc, SRV_FILE_INFO_CTR *ctr, prs_struct *ps, int depth)
2523 {
2524 if (ctr == NULL)
2525 return False;
2526
2527 prs_debug(ps, depth, desc, "srv_io_srv_file_ctr");
2528 depth++;
2529
2530 if (UNMARSHALLING(ps)) {
2531 memset(ctr, '\0', sizeof(SRV_FILE_INFO_CTR));
2532 }
2533
2534 if(!prs_align(ps))
2535 return False;
2536
2537 if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
2538 return False;
2539 if (ctr->switch_value != 3) {
2540 DEBUG(5,("%s File info %d level not supported\n",
2541 tab_depth(depth), ctr->switch_value));
2542 }
2543 if(!prs_uint32("ptr_file_info", ps, depth, &ctr->ptr_file_info))
2544 return False;
2545 if(!prs_uint32("num_entries", ps, depth, &ctr->num_entries))
2546 return False;
2547 if(!prs_uint32("ptr_entries", ps, depth, &ctr->ptr_entries))
2548 return False;
2549 if (ctr->ptr_entries == 0)
2550 return True;
2551 if(!prs_uint32("num_entries2", ps, depth,
2552 &ctr->num_entries2))
2553 return False;
2554
2555 switch (ctr->switch_value) {
2556 case 3: {
2557 SRV_FILE_INFO_3 *info3 = ctr->file.info3;
2558 int num_entries = ctr->num_entries;
2559 int i;
2560
2561 if (UNMARSHALLING(ps)) {
2562 if (!(info3 = PRS_ALLOC_MEM(ps, SRV_FILE_INFO_3, num_entries)))
2563 return False;
2564 ctr->file.info3 = info3;
2565 }
2566
2567 for (i = 0; i < num_entries; i++) {
2568 if(!srv_io_file_info3("", &ctr->file.info3[i].info_3, ps, depth))
2569 return False;
2570 }
2571 for (i = 0; i < num_entries; i++) {
2572 if(!srv_io_file_info3_str("", &ctr->file.info3[i].info_3_str, ps, depth))
2573 return False;
2574 }
2575 break;
2576 }
2577 default:
2578 DEBUG(5,("%s no file info at switch_value %d\n",
2579 tab_depth(depth), ctr->switch_value));
2580 break;
2581 }
2582
2583 return True;
2584 }
2585
2586 /*******************************************************************
2587 Inits a SRV_Q_NET_FILE_ENUM structure.
2588 ********************************************************************/
2589
2590 void init_srv_q_net_file_enum(SRV_Q_NET_FILE_ENUM *q_n,
2591 const char *srv_name, const char *qual_name,
2592 const char *user_name,
2593 uint32 file_level, SRV_FILE_INFO_CTR *ctr,
2594 uint32 preferred_len,
2595 ENUM_HND *hnd)
2596 {
2597 DEBUG(5,("init_q_net_file_enum\n"));
2598
2599 init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
2600 init_buf_unistr2(&q_n->uni_qual_name, &q_n->ptr_qual_name, qual_name);
2601 init_buf_unistr2(&q_n->uni_user_name, &q_n->ptr_user_name, user_name);
2602
2603 q_n->file_level = q_n->ctr.switch_value = file_level;
2604 q_n->preferred_len = preferred_len;
2605 q_n->ctr.ptr_file_info = 1;
2606 q_n->ctr.num_entries = 0;
2607 q_n->ctr.num_entries2 = 0;
2608
2609 memcpy(&q_n->enum_hnd, hnd, sizeof(*hnd));
2610 }
2611
2612 /*******************************************************************
2613 Reads or writes a structure.
2614 ********************************************************************/
2615
2616 BOOL srv_io_q_net_file_enum(const char *desc, SRV_Q_NET_FILE_ENUM *q_n, prs_struct *ps, int depth)
2617 {
2618 if (q_n == NULL)
2619 return False;
2620
2621 prs_debug(ps, depth, desc, "srv_io_q_net_file_enum");
2622 depth++;
2623
2624 if(!prs_align(ps))
2625 return False;
2626
2627 if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
2628 return False;
2629 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
2630 return False;
2631
2632 if(!prs_align(ps))
2633 return False;
2634
2635 if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
2636 return False;
2637 if(!smb_io_unistr2("", &q_n->uni_qual_name, q_n->ptr_qual_name, ps, depth))
2638 return False;
2639
2640 if(!prs_align(ps))
2641 return False;
2642
2643 if(!prs_uint32("ptr_user_name", ps, depth, &q_n->ptr_user_name))
2644 return False;
2645 if(!smb_io_unistr2("", &q_n->uni_user_name, q_n->ptr_user_name, ps, depth))
2646 return False;
2647
2648 if(!prs_align(ps))
2649 return False;
2650 if(!prs_uint32("file_level", ps, depth, &q_n->file_level))
2651 return False;
2652
2653 if (q_n->file_level != (uint32)-1) {
2654 if(!srv_io_srv_file_ctr("file_ctr", &q_n->ctr, ps, depth))
2655 return False;
2656 }
2657
2658 if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
2659 return False;
2660
2661 if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
2662 return False;
2663
2664 return True;
2665 }
2666
2667 /*******************************************************************
2668 Reads or writes a structure.
2669 ********************************************************************/
2670
2671 BOOL srv_io_r_net_file_enum(const char *desc, SRV_R_NET_FILE_ENUM *r_n, prs_struct *ps, int depth)
2672 {
2673 if (r_n == NULL)
2674 return False;
2675
2676 prs_debug(ps, depth, desc, "srv_io_r_net_file_enum");
2677 depth++;
2678
2679 if(!prs_align(ps))
2680 return False;
2681
2682 if(!prs_uint32("file_level", ps, depth, &r_n->file_level))
2683 return False;
2684
2685 if (r_n->file_level != 0) {
2686 if(!srv_io_srv_file_ctr("file_ctr", &r_n->ctr, ps, depth))
2687 return False;
2688 }
2689
2690 if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
2691 return False;
2692 if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
2693 return False;
2694 if(!prs_werror("status", ps, depth, &r_n->status))
2695 return False;
2696
2697 return True;
2698 }
2699
2700 /*******************************************************************
2701 Initialize a net file close request
2702 ********************************************************************/
2703 void init_srv_q_net_file_close(SRV_Q_NET_FILE_CLOSE *q_n, const char *server,
2704 uint32 file_id)
2705 {
2706 q_n->ptr_srv_name = 1;
2707 init_unistr2(&q_n->uni_srv_name, server, UNI_STR_TERMINATE);
2708 q_n->file_id = file_id;
2709 }
2710
2711 /*******************************************************************
2712 Reads or writes a structure.
2713 ********************************************************************/
2714 BOOL srv_io_q_net_file_close(const char *desc, SRV_Q_NET_FILE_CLOSE *q_n,
2715 prs_struct *ps, int depth)
2716 {
2717 if (q_n == NULL)
2718 return False;
2719
2720 prs_debug(ps, depth, desc, "srv_io_q_net_file_close");
2721 depth++;
2722
2723 if(!prs_align(ps))
2724 return False;
2725
2726 if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
2727 return False;
2728 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
2729 return False;
2730
2731 if(!prs_align(ps))
2732 return False;
2733
2734 if(!prs_uint32("file_id", ps, depth, &q_n->file_id))
2735 return False;
2736
2737 return True;
2738 }
2739
2740 /*******************************************************************
2741 Reads or writes a structure.
2742 ********************************************************************/
2743
2744 BOOL srv_io_r_net_file_close(const char *desc, SRV_R_NET_FILE_CLOSE *q_n,
2745 prs_struct *ps, int depth)
2746 {
2747 if (q_n == NULL)
2748 return False;
2749
2750 prs_debug(ps, depth, desc, "srv_io_r_net_file_close");
2751 depth++;
2752
2753 if(!prs_align(ps))
2754 return False;
2755
2756 if(!prs_werror("status", ps, depth, &q_n->status))
2757 return False;
2758
2759 return True;
2760 }
2761
2762 /*******************************************************************
2763 Inits a SRV_INFO_100 structure.
2764 ********************************************************************/
2765
2766 void init_srv_info_100(SRV_INFO_100 *sv100, uint32 platform_id, const char *name)
2767 {
2768 DEBUG(5,("init_srv_info_100\n"));
2769
2770 sv100->platform_id = platform_id;
2771 init_buf_unistr2(&sv100->uni_name, &sv100->ptr_name, name);
2772 }
2773
2774 /*******************************************************************
2775 Reads or writes a SRV_INFO_101 structure.
2776 ********************************************************************/
2777
2778 static BOOL srv_io_info_100(const char *desc, SRV_INFO_100 *sv100, prs_struct *ps, int depth)
2779 {
2780 if (sv100 == NULL)
2781 return False;
2782
2783 prs_debug(ps, depth, desc, "srv_io_info_100");
2784 depth++;
2785
2786 if(!prs_align(ps))
2787 return False;
2788
2789 if(!prs_uint32("platform_id ", ps, depth, &sv100->platform_id))
2790 return False;
2791 if(!prs_uint32("ptr_name ", ps, depth, &sv100->ptr_name))
2792 return False;
2793
2794 if(!smb_io_unistr2("uni_name ", &sv100->uni_name, True, ps, depth))
2795 return False;
2796
2797 return True;
2798 }
2799
2800
2801 /*******************************************************************
2802 Inits a SRV_INFO_101 structure.
2803 ********************************************************************/
2804
2805 void init_srv_info_101(SRV_INFO_101 *sv101, uint32 platform_id, const char *name,
2806 uint32 ver_major, uint32 ver_minor,
2807 uint32 srv_type, const char *comment)
2808 {
2809 DEBUG(5,("init_srv_info_101\n"));
2810
2811 sv101->platform_id = platform_id;
2812 init_buf_unistr2(&sv101->uni_name, &sv101->ptr_name, name);
2813 sv101->ver_major = ver_major;
2814 sv101->ver_minor = ver_minor;
2815 sv101->srv_type = srv_type;
2816 init_buf_unistr2(&sv101->uni_comment, &sv101->ptr_comment, comment);
2817 }
2818
2819 /*******************************************************************
2820 Reads or writes a SRV_INFO_101 structure.
2821 ********************************************************************/
2822
2823 static BOOL srv_io_info_101(const char *desc, SRV_INFO_101 *sv101, prs_struct *ps, int depth)
2824 {
2825 if (sv101 == NULL)
2826 return False;
2827
2828 prs_debug(ps, depth, desc, "srv_io_info_101");
2829 depth++;
2830
2831 if(!prs_align(ps))
2832 return False;
2833
2834 if(!prs_uint32("platform_id ", ps, depth, &sv101->platform_id))
2835 return False;
2836 if(!prs_uint32("ptr_name ", ps, depth, &sv101->ptr_name))
2837 return False;
2838 if(!prs_uint32("ver_major ", ps, depth, &sv101->ver_major))
2839 return False;
2840 if(!prs_uint32("ver_minor ", ps, depth, &sv101->ver_minor))
2841 return False;
2842 if(!prs_uint32("srv_type ", ps, depth, &sv101->srv_type))
2843 return False;
2844 if(!prs_uint32("ptr_comment ", ps, depth, &sv101->ptr_comment))
2845 return False;
2846
2847 if(!prs_align(ps))
2848 return False;
2849
2850 if(!smb_io_unistr2("uni_name ", &sv101->uni_name, True, ps, depth))
2851 return False;
2852 if(!smb_io_unistr2("uni_comment ", &sv101->uni_comment, True, ps, depth))
2853 return False;
2854
2855 return True;
2856 }
2857
2858 /*******************************************************************
2859 Inits a SRV_INFO_102 structure.
2860 ********************************************************************/
2861
2862 void init_srv_info_102(SRV_INFO_102 *sv102, uint32 platform_id, const char *name,
2863 const char *comment, uint32 ver_major, uint32 ver_minor,
2864 uint32 srv_type, uint32 users, uint32 disc, uint32 hidden,
2865 uint32 announce, uint32 ann_delta, uint32 licenses,
2866 const char *usr_path)
2867 {
2868 DEBUG(5,("init_srv_info_102\n"));
2869
2870 sv102->platform_id = platform_id;
2871 init_buf_unistr2(&sv102->uni_name, &sv102->ptr_name, name);
2872 sv102->ver_major = ver_major;
2873 sv102->ver_minor = ver_minor;
2874 sv102->srv_type = srv_type;
2875 init_buf_unistr2(&sv102->uni_comment, &sv102->ptr_comment, comment);
2876
2877 /* same as 101 up to here */
2878
2879 sv102->users = users;
2880 sv102->disc = disc;
2881 sv102->hidden = hidden;
2882 sv102->announce = announce;
2883 sv102->ann_delta = ann_delta;
2884 sv102->licenses = licenses;
2885 init_buf_unistr2(&sv102->uni_usr_path, &sv102->ptr_usr_path, usr_path);
2886 }
2887
2888
2889 /*******************************************************************
2890 Reads or writes a SRV_INFO_102 structure.
2891 ********************************************************************/
2892
2893 static BOOL srv_io_info_102(const char *desc, SRV_INFO_102 *sv102, prs_struct *ps, int depth)
2894 {
2895 if (sv102 == NULL)
2896 return False;
2897
2898 prs_debug(ps, depth, desc, "srv_io_info102");
2899 depth++;
2900
2901 if(!prs_align(ps))
2902 return False;
2903
2904 if(!prs_uint32("platform_id ", ps, depth, &sv102->platform_id))
2905 return False;
2906 if(!prs_uint32("ptr_name ", ps, depth, &sv102->ptr_name))
2907 return False;
2908 if(!prs_uint32("ver_major ", ps, depth, &sv102->ver_major))
2909 return False;
2910 if(!prs_uint32("ver_minor ", ps, depth, &sv102->ver_minor))
2911 return False;
2912 if(!prs_uint32("srv_type ", ps, depth, &sv102->srv_type))
2913 return False;
2914 if(!prs_uint32("ptr_comment ", ps, depth, &sv102->ptr_comment))
2915 return False;
2916
2917 /* same as 101 up to here */
2918
2919 if(!prs_uint32("users ", ps, depth, &sv102->users))
2920 return False;
2921 if(!prs_uint32("disc ", ps, depth, &sv102->disc))
2922 return False;
2923 if(!prs_uint32("hidden ", ps, depth, &sv102->hidden))
2924 return False;
2925 if(!prs_uint32("announce ", ps, depth, &sv102->announce))
2926 return False;
2927 if(!prs_uint32("ann_delta ", ps, depth, &sv102->ann_delta))
2928 return False;
2929 if(!prs_uint32("licenses ", ps, depth, &sv102->licenses))
2930 return False;
2931 if(!prs_uint32("ptr_usr_path", ps, depth, &sv102->ptr_usr_path))
2932 return False;
2933
2934 if(!smb_io_unistr2("uni_name ", &sv102->uni_name, True, ps, depth))
2935 return False;
2936 if(!prs_align(ps))
2937 return False;
2938 if(!smb_io_unistr2("uni_comment ", &sv102->uni_comment, True, ps, depth))
2939 return False;
2940 if(!prs_align(ps))
2941 return False;
2942 if(!smb_io_unistr2("uni_usr_path", &sv102->uni_usr_path, True, ps, depth))
2943 return False;
2944
2945 return True;
2946 }
2947
2948 /*******************************************************************
2949 Reads or writes a SRV_INFO_102 structure.
2950 ********************************************************************/
2951
2952 static BOOL srv_io_info_ctr(const char *desc, SRV_INFO_CTR *ctr, prs_struct *ps, int depth)
2953 {
2954 if (ctr == NULL)
2955 return False;
2956
2957 prs_debug(ps, depth, desc, "srv_io_info_ctr");
2958 depth++;
2959
2960 if(!prs_align(ps))
2961 return False;
2962
2963 if(!prs_uint32("switch_value", ps, depth, &ctr->switch_value))
2964 return False;
2965 if(!prs_uint32("ptr_srv_ctr ", ps, depth, &ctr->ptr_srv_ctr))
2966 return False;
2967
2968 if (ctr->ptr_srv_ctr != 0 && ctr->switch_value != 0 && ctr != NULL) {
2969 switch (ctr->switch_value) {
2970 case 100:
2971 if(!srv_io_info_100("sv100", &ctr->srv.sv100, ps, depth))
2972 return False;
2973 break;
2974 case 101:
2975 if(!srv_io_info_101("sv101", &ctr->srv.sv101, ps, depth))
2976 return False;
2977 break;
2978 case 102:
2979 if(!srv_io_info_102("sv102", &ctr->srv.sv102, ps, depth))
2980 return False;
2981 break;
2982 default:
2983 DEBUG(5,("%s no server info at switch_value %d\n",
2984 tab_depth(depth), ctr->switch_value));
2985 break;
2986 }
2987 if(!prs_align(ps))
2988 return False;
2989 }
2990
2991 return True;
2992 }
2993
2994 /*******************************************************************
2995 Inits a SRV_Q_NET_SRV_GET_INFO structure.
2996 ********************************************************************/
2997
2998 void init_srv_q_net_srv_get_info(SRV_Q_NET_SRV_GET_INFO *srv,
2999 const char *server_name, uint32 switch_value)
3000 {
3001 DEBUG(5,("init_srv_q_net_srv_get_info\n"));
3002
3003 init_buf_unistr2(&srv->uni_srv_name, &srv->ptr_srv_name, server_name);
3004
3005 srv->switch_value = switch_value;
3006 }
3007
3008 /*******************************************************************
3009 Reads or writes a structure.
3010 ********************************************************************/
3011
3012 BOOL srv_io_q_net_srv_get_info(const char *desc, SRV_Q_NET_SRV_GET_INFO *q_n, prs_struct *ps, int depth)
3013 {
3014 if (q_n == NULL)
3015 return False;
3016
3017 prs_debug(ps, depth, desc, "srv_io_q_net_srv_get_info");
3018 depth++;
3019
3020 if(!prs_align(ps))
3021 return False;
3022
3023 if(!prs_uint32("ptr_srv_name ", ps, depth, &q_n->ptr_srv_name))
3024 return False;
3025 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3026 return False;
3027
3028 if(!prs_align(ps))
3029 return False;
3030
3031 if(!prs_uint32("switch_value ", ps, depth, &q_n->switch_value))
3032 return False;
3033
3034 return True;
3035 }
3036
3037 /*******************************************************************
3038 Inits a SRV_R_NET_SRV_GET_INFO structure.
3039 ********************************************************************/
3040
3041 void init_srv_r_net_srv_get_info(SRV_R_NET_SRV_GET_INFO *srv,
3042 uint32 switch_value, SRV_INFO_CTR *ctr, WERROR status)
3043 {
3044 DEBUG(5,("init_srv_r_net_srv_get_info\n"));
3045
3046 srv->ctr = ctr;
3047
3048 if (W_ERROR_IS_OK(status)) {
3049 srv->ctr->switch_value = switch_value;
3050 srv->ctr->ptr_srv_ctr = 1;
3051 } else {
3052 srv->ctr->switch_value = 0;
3053 srv->ctr->ptr_srv_ctr = 0;
3054 }
3055
3056 srv->status = status;
3057 }
3058
3059 /*******************************************************************
3060 Inits a SRV_R_NET_SRV_SET_INFO structure.
3061 ********************************************************************/
3062
3063 void init_srv_r_net_srv_set_info(SRV_R_NET_SRV_SET_INFO *srv,
3064 uint32 switch_value, WERROR status)
3065 {
3066 DEBUG(5,("init_srv_r_net_srv_set_info\n"));
3067
3068 srv->switch_value = switch_value;
3069 srv->status = status;
3070 }
3071
3072 /*******************************************************************
3073 Reads or writes a structure.
3074 ********************************************************************/
3075
3076 BOOL srv_io_q_net_srv_set_info(const char *desc, SRV_Q_NET_SRV_SET_INFO *q_n,
3077 prs_struct *ps, int depth)
3078 {
3079 prs_debug(ps, depth, desc, "srv_io_q_net_srv_set_info");
3080 depth++;
3081
3082 if(!prs_align(ps))
3083 return False;
3084
3085 if(!prs_uint32("ptr_srv_name ", ps, depth, &q_n->ptr_srv_name))
3086 return False;
3087 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3088 return False;
3089
3090 if(!prs_align(ps))
3091 return False;
3092
3093 if(!prs_uint32("switch_value ", ps, depth, &q_n->switch_value))
3094 return False;
3095
3096 if (UNMARSHALLING(ps)) {
3097 q_n->ctr = PRS_ALLOC_MEM(ps, SRV_INFO_CTR, 1);
3098
3099 if (!q_n->ctr)
3100 return False;
3101 }
3102
3103 if(!srv_io_info_ctr("ctr", q_n->ctr, ps, depth))
3104 return False;
3105
3106 return True;
3107 }
3108
3109 /*******************************************************************
3110 Reads or writes a structure.
3111 ********************************************************************/
3112
3113 BOOL srv_io_r_net_srv_get_info(const char *desc, SRV_R_NET_SRV_GET_INFO *r_n, prs_struct *ps, int depth)
3114 {
3115 if (r_n == NULL)
3116 return False;
3117
3118 prs_debug(ps, depth, desc, "srv_io_r_net_srv_get_info");
3119 depth++;
3120
3121 if(!prs_align(ps))
3122 return False;
3123
3124 if(!srv_io_info_ctr("ctr", r_n->ctr, ps, depth))
3125 return False;
3126
3127 if(!prs_werror("status", ps, depth, &r_n->status))
3128 return False;
3129
3130 return True;
3131 }
3132
3133 /*******************************************************************
3134 Reads or writes a structure.
3135 ********************************************************************/
3136
3137 BOOL srv_io_r_net_srv_set_info(const char *desc, SRV_R_NET_SRV_SET_INFO *r_n,
3138 prs_struct *ps, int depth)
3139 {
3140 prs_debug(ps, depth, desc, "srv_io_r_net_srv_set_info");
3141 depth++;
3142
3143 if(!prs_align(ps))
3144 return False;
3145
3146 if(!prs_uint32("switch value ", ps, depth, &r_n->switch_value))
3147 return False;
3148
3149 if(!prs_werror("status", ps, depth, &r_n->status))
3150 return False;
3151
3152 return True;
3153 }
3154
3155 /*******************************************************************
3156 Reads or writes a structure.
3157 ********************************************************************/
3158
3159 BOOL srv_io_q_net_remote_tod(const char *desc, SRV_Q_NET_REMOTE_TOD *q_n, prs_struct *ps, int depth)
3160 {
3161 if (q_n == NULL)
3162 return False;
3163
3164 prs_debug(ps, depth, desc, "srv_io_q_net_remote_tod");
3165 depth++;
3166
3167 if(!prs_align(ps))
3168 return False;
3169
3170 if(!prs_uint32("ptr_srv_name ", ps, depth, &q_n->ptr_srv_name))
3171 return False;
3172 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3173 return False;
3174
3175 return True;
3176 }
3177
3178 /*******************************************************************
3179 Reads or writes a TIME_OF_DAY_INFO structure.
3180 ********************************************************************/
3181
3182 static BOOL srv_io_time_of_day_info(const char *desc, TIME_OF_DAY_INFO *tod, prs_struct *ps, int depth)
3183 {
3184 if (tod == NULL)
3185 return False;
3186
3187 prs_debug(ps, depth, desc, "srv_io_time_of_day_info");
3188 depth++;
3189
3190 if(!prs_align(ps))
3191 return False;
3192
3193 if(!prs_uint32("elapsedt ", ps, depth, &tod->elapsedt))
3194 return False;
3195 if(!prs_uint32("msecs ", ps, depth, &tod->msecs))
3196 return False;
3197 if(!prs_uint32("hours ", ps, depth, &tod->hours))
3198 return False;
3199 if(!prs_uint32("mins ", ps, depth, &tod->mins))
3200 return False;
3201 if(!prs_uint32("secs ", ps, depth, &tod->secs))
3202 return False;
3203 if(!prs_uint32("hunds ", ps, depth, &tod->hunds))
3204 return False;
3205 if(!prs_uint32("timezone ", ps, depth, &tod->zone))
3206 return False;
3207 if(!prs_uint32("tintervals ", ps, depth, &tod->tintervals))
3208 return False;
3209 if(!prs_uint32("day ", ps, depth, &tod->day))
3210 return False;
3211 if(!prs_uint32("month ", ps, depth, &tod->month))
3212 return False;
3213 if(!prs_uint32("year ", ps, depth, &tod->year))
3214 return False;
3215 if(!prs_uint32("weekday ", ps, depth, &tod->weekday))
3216 return False;
3217
3218 return True;
3219 }
3220
3221 /*******************************************************************
3222 Inits a TIME_OF_DAY_INFO structure.
3223 ********************************************************************/
3224
3225 void init_time_of_day_info(TIME_OF_DAY_INFO *tod, uint32 elapsedt, uint32 msecs,
3226 uint32 hours, uint32 mins, uint32 secs, uint32 hunds,
3227 uint32 zone, uint32 tintervals, uint32 day,
3228 uint32 month, uint32 year, uint32 weekday)
3229 {
3230 DEBUG(5,("init_time_of_day_info\n"));
3231
3232 tod->elapsedt = elapsedt;
3233 tod->msecs = msecs;
3234 tod->hours = hours;
3235 tod->mins = mins;
3236 tod->secs = secs;
3237 tod->hunds = hunds;
3238 tod->zone = zone;
3239 tod->tintervals = tintervals;
3240 tod->day = day;
3241 tod->month = month;
3242 tod->year = year;
3243 tod->weekday = weekday;
3244 }
3245
3246
3247 /*******************************************************************
3248 Reads or writes a structure.
3249 ********************************************************************/
3250
3251 BOOL srv_io_r_net_remote_tod(const char *desc, SRV_R_NET_REMOTE_TOD *r_n, prs_struct *ps, int depth)
3252 {
3253 if (r_n == NULL)
3254 return False;
3255
3256 prs_debug(ps, depth, desc, "srv_io_r_net_remote_tod");
3257 depth++;
3258
3259 if(!prs_align(ps))
3260 return False;
3261
3262 if(!prs_uint32("ptr_srv_tod ", ps, depth, &r_n->ptr_srv_tod))
3263 return False;
3264
3265 if(!srv_io_time_of_day_info("tod", r_n->tod, ps, depth))
3266 return False;
3267
3268 if(!prs_werror("status", ps, depth, &r_n->status))
3269 return False;
3270
3271 return True;
3272 }
3273
3274 /*******************************************************************
3275 initialises a structure.
3276 ********************************************************************/
3277
3278 BOOL init_srv_q_net_disk_enum(SRV_Q_NET_DISK_ENUM *q_n,
3279 const char *srv_name,
3280 uint32 preferred_len,
3281 ENUM_HND *enum_hnd
3282 )
3283 {
3284
3285
3286 DEBUG(5,("init_srv_q_net_srv_disk_enum\n"));
3287
3288 init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
3289
3290 q_n->disk_enum_ctr.level = 0;
3291 q_n->disk_enum_ctr.disk_info_ptr = 0;
3292
3293 q_n->preferred_len = preferred_len;
3294 memcpy(&q_n->enum_hnd, enum_hnd, sizeof(*enum_hnd));
3295
3296 return True;
3297 }
3298
3299 /*******************************************************************
3300 Reads or writes a structure.
3301 ********************************************************************/
3302
3303 BOOL srv_io_q_net_disk_enum(const char *desc, SRV_Q_NET_DISK_ENUM *q_n, prs_struct *ps, int depth)
3304 {
3305 if (q_n == NULL)
3306 return False;
3307
3308 prs_debug(ps, depth, desc, "srv_io_q_net_disk_enum");
3309 depth++;
3310
3311 if(!prs_align(ps))
3312 return False;
3313
3314 if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
3315 return False;
3316
3317 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3318 return False;
3319
3320 if(!prs_align(ps))
3321 return False;
3322
3323 if(!prs_uint32("level", ps, depth, &q_n->disk_enum_ctr.level))
3324 return False;
3325
3326 if(!prs_uint32("entries_read", ps, depth, &q_n->disk_enum_ctr.entries_read))
3327 return False;
3328
3329 if(!prs_uint32("buffer", ps, depth, &q_n->disk_enum_ctr.disk_info_ptr))
3330 return False;
3331
3332 if(!prs_align(ps))
3333 return False;
3334
3335 if(!prs_uint32("preferred_len", ps, depth, &q_n->preferred_len))
3336 return False;
3337 if(!smb_io_enum_hnd("enum_hnd", &q_n->enum_hnd, ps, depth))
3338 return False;
3339
3340 return True;
3341 }
3342
3343 /*******************************************************************
3344 Reads or writes a structure.
3345 ********************************************************************/
3346
3347 BOOL srv_io_r_net_disk_enum(const char *desc, SRV_R_NET_DISK_ENUM *r_n, prs_struct *ps, int depth)
3348 {
3349
3350 unsigned int i;
3351 uint32 entries_read, entries_read2, entries_read3;
3352
3353 if (r_n == NULL)
3354 return False;
3355
3356 prs_debug(ps, depth, desc, "srv_io_r_net_disk_enum");
3357 depth++;
3358
3359 entries_read = entries_read2 = entries_read3 = r_n->disk_enum_ctr.entries_read;
3360
3361 if(!prs_align(ps))
3362 return False;
3363
3364 if(!prs_uint32("entries_read", ps, depth, &entries_read))
3365 return False;
3366 if(!prs_uint32("ptr_disk_info", ps, depth, &r_n->disk_enum_ctr.disk_info_ptr))
3367 return False;
3368
3369 /*this may be max, unknown, actual?*/
3370
3371 if(!prs_uint32("max_elements", ps, depth, &entries_read2))
3372 return False;
3373 if(!prs_uint32("unknown", ps, depth, &r_n->disk_enum_ctr.unknown))
3374 return False;
3375 if(!prs_uint32("actual_elements", ps, depth, &entries_read3))
3376 return False;
3377
3378 r_n->disk_enum_ctr.entries_read = entries_read3;
3379
3380 if(UNMARSHALLING(ps)) {
3381
3382 DISK_INFO *dinfo;
3383
3384 if(!(dinfo = PRS_ALLOC_MEM(ps, DISK_INFO, entries_read3)))
3385 return False;
3386 r_n->disk_enum_ctr.disk_info = dinfo;
3387 }
3388
3389 for(i=0; i < r_n->disk_enum_ctr.entries_read; i++) {
3390
3391 if(!prs_uint32("unknown", ps, depth, &r_n->disk_enum_ctr.disk_info[i].unknown))
3392 return False;
3393
3394 if(!smb_io_unistr3("disk_name", &r_n->disk_enum_ctr.disk_info[i].disk_name, ps, depth))
3395 return False;
3396
3397 if(!prs_align(ps))
3398 return False;
3399 }
3400
3401 if(!prs_uint32("total_entries", ps, depth, &r_n->total_entries))
3402 return False;
3403
3404 if(!smb_io_enum_hnd("enum_hnd", &r_n->enum_hnd, ps, depth))
3405 return False;
3406
3407 if(!prs_werror("status", ps, depth, &r_n->status))
3408 return False;
3409
3410 return True;
3411 }
3412
3413 /*******************************************************************
3414 initialises a structure.
3415 ********************************************************************/
3416
3417 BOOL init_srv_q_net_name_validate(SRV_Q_NET_NAME_VALIDATE *q_n, const char *srv_name, const char *share_name, int type)
3418 {
3419 uint32 ptr_share_name;
3420
3421 DEBUG(5,("init_srv_q_net_name_validate\n"));
3422
3423 init_buf_unistr2(&q_n->uni_srv_name, &q_n->ptr_srv_name, srv_name);
3424 init_buf_unistr2(&q_n->uni_name, &ptr_share_name, share_name);
3425
3426 q_n->type = type;
3427 q_n->flags = 0;
3428
3429 return True;
3430 }
3431
3432 /*******************************************************************
3433 Reads or writes a structure.
3434 ********************************************************************/
3435
3436 BOOL srv_io_q_net_name_validate(const char *desc, SRV_Q_NET_NAME_VALIDATE *q_n, prs_struct *ps, int depth)
3437 {
3438 if (q_n == NULL)
3439 return False;
3440
3441 prs_debug(ps, depth, desc, "srv_io_q_net_name_validate");
3442 depth++;
3443
3444 if(!prs_align(ps))
3445 return False;
3446
3447 if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
3448 return False;
3449
3450 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3451 return False;
3452
3453 if(!prs_align(ps))
3454 return False;
3455
3456 if(!smb_io_unistr2("", &q_n->uni_name, True, ps, depth))
3457 return False;
3458
3459 if(!prs_align(ps))
3460 return False;
3461
3462 if(!prs_uint32("type", ps, depth, &q_n->type))
3463 return False;
3464
3465 if(!prs_uint32("flags", ps, depth, &q_n->flags))
3466 return False;
3467
3468 return True;
3469 }
3470
3471 /*******************************************************************
3472 Reads or writes a structure.
3473 ********************************************************************/
3474
3475 BOOL srv_io_r_net_name_validate(const char *desc, SRV_R_NET_NAME_VALIDATE *r_n, prs_struct *ps, int depth)
3476 {
3477 if (r_n == NULL)
3478 return False;
3479
3480 prs_debug(ps, depth, desc, "srv_io_r_net_name_validate");
3481 depth++;
3482
3483 if(!prs_align(ps))
3484 return False;
3485
3486 if(!prs_werror("status", ps, depth, &r_n->status))
3487 return False;
3488
3489 return True;
3490 }
3491
3492 /*******************************************************************
3493 Reads or writes a structure.
3494 ********************************************************************/
3495
3496 BOOL srv_io_q_net_file_query_secdesc(const char *desc, SRV_Q_NET_FILE_QUERY_SECDESC *q_n, prs_struct *ps, int depth)
3497 {
3498 if (q_n == NULL)
3499 return False;
3500
3501 prs_debug(ps, depth, desc, "srv_io_q_net_file_query_secdesc");
3502 depth++;
3503
3504 if(!prs_align(ps))
3505 return False;
3506
3507 if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
3508 return False;
3509
3510 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3511 return False;
3512
3513 if(!prs_align(ps))
3514 return False;
3515
3516 if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
3517 return False;
3518
3519 if(!smb_io_unistr2("", &q_n->uni_qual_name, True, ps, depth))
3520 return False;
3521
3522 if(!prs_align(ps))
3523 return False;
3524
3525 if(!smb_io_unistr2("", &q_n->uni_file_name, True, ps, depth))
3526 return False;
3527
3528 if(!prs_uint32("unknown1", ps, depth, &q_n->unknown1))
3529 return False;
3530
3531 if(!prs_uint32("unknown2", ps, depth, &q_n->unknown2))
3532 return False;
3533
3534 if(!prs_uint32("unknown3", ps, depth, &q_n->unknown3))
3535 return False;
3536
3537 return True;
3538 }
3539
3540 /*******************************************************************
3541 Reads or writes a structure.
3542 ********************************************************************/
3543
3544 BOOL srv_io_r_net_file_query_secdesc(const char *desc, SRV_R_NET_FILE_QUERY_SECDESC *r_n, prs_struct *ps, int depth)
3545 {
3546 if (r_n == NULL)
3547 return False;
3548
3549 prs_debug(ps, depth, desc, "srv_io_r_net_file_query_secdesc");
3550 depth++;
3551
3552 if(!prs_align(ps))
3553 return False;
3554
3555 if(!prs_uint32("ptr_response", ps, depth, &r_n->ptr_response))
3556 return False;
3557
3558 if(!prs_uint32("size_response", ps, depth, &r_n->size_response))
3559 return False;
3560
3561 if(!prs_uint32("ptr_secdesc", ps, depth, &r_n->ptr_secdesc))
3562 return False;
3563
3564 if(!prs_uint32("size_secdesc", ps, depth, &r_n->size_secdesc))
3565 return False;
3566
3567 if(!sec_io_desc("sec_desc", &r_n->sec_desc, ps, depth))
3568 return False;
3569
3570 if(!prs_align(ps))
3571 return False;
3572
3573 if(!prs_werror("status", ps, depth, &r_n->status))
3574 return False;
3575
3576 return True;
3577 }
3578
3579 /*******************************************************************
3580 Reads or writes a structure.
3581 ********************************************************************/
3582
3583 BOOL srv_io_q_net_file_set_secdesc(const char *desc, SRV_Q_NET_FILE_SET_SECDESC *q_n, prs_struct *ps, int depth)
3584 {
3585 if (q_n == NULL)
3586 return False;
3587
3588 prs_debug(ps, depth, desc, "srv_io_q_net_file_set_secdesc");
3589 depth++;
3590
3591 if(!prs_align(ps))
3592 return False;
3593
3594 if(!prs_uint32("ptr_srv_name", ps, depth, &q_n->ptr_srv_name))
3595 return False;
3596
3597 if(!smb_io_unistr2("", &q_n->uni_srv_name, True, ps, depth))
3598 return False;
3599
3600 if(!prs_align(ps))
3601 return False;
3602
3603 if(!prs_uint32("ptr_qual_name", ps, depth, &q_n->ptr_qual_name))
3604 return False;
3605
3606 if(!smb_io_unistr2("", &q_n->uni_qual_name, True, ps, depth))
3607 return False;
3608
3609 if(!prs_align(ps))
3610 return False;
3611
3612 if(!smb_io_unistr2("", &q_n->uni_file_name, True, ps, depth))
3613 return False;
3614
3615 if(!prs_align(ps))
3616 return False;
3617
3618 if(!prs_uint32("sec_info", ps, depth, &q_n->sec_info))
3619 return False;
3620
3621 if(!prs_uint32("size_set", ps, depth, &q_n->size_set))
3622 return False;
3623
3624 if(!prs_uint32("ptr_secdesc", ps, depth, &q_n->ptr_secdesc))
3625 return False;
3626
3627 if(!prs_uint32("size_secdesc", ps, depth, &q_n->size_secdesc))
3628 return False;
3629
3630 if(!sec_io_desc("sec_desc", &q_n->sec_desc, ps, depth))
3631 return False;
3632
3633 return True;
3634 }
3635
3636 /*******************************************************************
3637 Reads or writes a structure.
3638 ********************************************************************/
3639
3640 BOOL srv_io_r_net_file_set_secdesc(const char *desc, SRV_R_NET_FILE_SET_SECDESC *r_n, prs_struct *ps, int depth)
3641 {
3642 if (r_n == NULL)
3643 return False;
3644
3645 prs_debug(ps, depth, desc, "srv_io_r_net_file_set_secdesc");
3646 depth++;
3647
3648 if(!prs_align(ps))
3649 return False;
3650
3651 if(!prs_werror("status", ps, depth, &r_n->status))
3652 return False;
3653
3654 return True;
3655 }
3656
3657 /*******************************************************************
3658 Inits a structure
3659 ********************************************************************/
3660
3661 void init_srv_q_net_remote_tod(SRV_Q_NET_REMOTE_TOD *q_u, const char *server)
3662 {
3663 q_u->ptr_srv_name = 1;
3664 init_unistr2(&q_u->uni_srv_name, server, UNI_STR_TERMINATE);
3665 }
Tomato firmware and modifications.