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