r13350: Implement rpccli_samr_set_domain_info. Weird that it was not around :-)
[kai/samba.git] / source3 / rpc_parse / parse_samr.c
1 /* 
2  *  Unix SMB/CIFS implementation.
3  *  RPC Pipe client / server routines
4  *  Copyright (C) Andrew Tridgell              1992-2000,
5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
6  *  Copyright (C) Paul Ashton                  1997-2000,
7  *  Copyright (C) Elrond                            2000,
8  *  Copyright (C) Jeremy Allison                    2001,
9  *  Copyright (C) Jean Fran├žois Micouleau      1998-2001,
10  *  Copyright (C) Jim McDonough <jmcd@us.ibm.com>   2002.
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 SAMR_Q_CLOSE_HND structure.
34 ********************************************************************/
35
36 void init_samr_q_close_hnd(SAMR_Q_CLOSE_HND * q_c, POLICY_HND *hnd)
37 {
38         DEBUG(5, ("init_samr_q_close_hnd\n"));
39         
40         q_c->pol = *hnd;
41 }
42
43 /*******************************************************************
44 reads or writes a structure.
45 ********************************************************************/
46
47 BOOL samr_io_q_close_hnd(const char *desc, SAMR_Q_CLOSE_HND * q_u,
48                          prs_struct *ps, int depth)
49 {
50         if (q_u == NULL)
51                 return False;
52
53         prs_debug(ps, depth, desc, "samr_io_q_close_hnd");
54         depth++;
55
56         if(!prs_align(ps))
57                 return False;
58
59         return smb_io_pol_hnd("pol", &q_u->pol, ps, depth);
60 }
61
62 /*******************************************************************
63 reads or writes a structure.
64 ********************************************************************/
65
66 BOOL samr_io_r_close_hnd(const char *desc, SAMR_R_CLOSE_HND * r_u,
67                          prs_struct *ps, int depth)
68 {
69         if (r_u == NULL)
70                 return False;
71
72         prs_debug(ps, depth, desc, "samr_io_r_close_hnd");
73         depth++;
74
75         if(!prs_align(ps))
76                 return False;
77
78         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
79                 return False;
80
81         if(!prs_ntstatus("status", ps, depth, &r_u->status))
82                 return False;
83
84         return True;
85 }
86
87 /*******************************************************************
88 inits a SAMR_Q_LOOKUP_DOMAIN structure.
89 ********************************************************************/
90
91 void init_samr_q_lookup_domain(SAMR_Q_LOOKUP_DOMAIN * q_u,
92                                POLICY_HND *pol, char *dom_name)
93 {
94         DEBUG(5, ("init_samr_q_lookup_domain\n"));
95
96         q_u->connect_pol = *pol;
97
98         init_unistr2(&q_u->uni_domain, dom_name, UNI_FLAGS_NONE);
99         init_uni_hdr(&q_u->hdr_domain, &q_u->uni_domain);
100 }
101
102 /*******************************************************************
103 reads or writes a structure.
104 ********************************************************************/
105 BOOL samr_io_q_lookup_domain(const char *desc, SAMR_Q_LOOKUP_DOMAIN * q_u,
106                              prs_struct *ps, int depth)
107 {
108         if (q_u == NULL)
109                 return False;
110
111         prs_debug(ps, depth, desc, "samr_io_q_lookup_domain");
112         depth++;
113
114         if(!prs_align(ps))
115                 return False;
116
117         if(!smb_io_pol_hnd("connect_pol", &q_u->connect_pol, ps, depth))
118                 return False;
119
120         if(!smb_io_unihdr("hdr_domain", &q_u->hdr_domain, ps, depth))
121                 return False;
122
123         if(!smb_io_unistr2("uni_domain", &q_u->uni_domain, q_u->hdr_domain.buffer, ps, depth))
124                 return False;
125
126         return True;
127 }
128
129 /*******************************************************************
130 inits a SAMR_R_LOOKUP_DOMAIN structure.
131 ********************************************************************/
132
133 void init_samr_r_lookup_domain(SAMR_R_LOOKUP_DOMAIN * r_u,
134                                DOM_SID *dom_sid, NTSTATUS status)
135 {
136         DEBUG(5, ("init_samr_r_lookup_domain\n"));
137
138         r_u->status = status;
139         r_u->ptr_sid = 0;
140         if (NT_STATUS_IS_OK(status)) {
141                 r_u->ptr_sid = 1;
142                 init_dom_sid2(&r_u->dom_sid, dom_sid);
143         }
144 }
145
146 /*******************************************************************
147 reads or writes a structure.
148 ********************************************************************/
149
150 BOOL samr_io_r_lookup_domain(const char *desc, SAMR_R_LOOKUP_DOMAIN * r_u,
151                              prs_struct *ps, int depth)
152 {
153         if (r_u == NULL)
154                 return False;
155
156         prs_debug(ps, depth, desc, "samr_io_r_lookup_domain");
157         depth++;
158
159         if(!prs_align(ps))
160                 return False;
161
162         if(!prs_uint32("ptr", ps, depth, &r_u->ptr_sid))
163                 return False;
164
165         if (r_u->ptr_sid != 0) {
166                 if(!smb_io_dom_sid2("sid", &r_u->dom_sid, ps, depth))
167                         return False;
168                 if(!prs_align(ps))
169                         return False;
170         }
171
172         if(!prs_ntstatus("status", ps, depth, &r_u->status))
173                 return False;
174
175         return True;
176 }
177
178 /*******************************************************************
179 reads or writes a structure.
180 ********************************************************************/
181
182 void init_samr_q_remove_sid_foreign_domain(SAMR_Q_REMOVE_SID_FOREIGN_DOMAIN * q_u, POLICY_HND *dom_pol, DOM_SID *sid)
183 {
184         DEBUG(5, ("samr_init_samr_q_remove_sid_foreign_domain\n"));
185
186         q_u->dom_pol = *dom_pol;
187         init_dom_sid2(&q_u->sid, sid);
188 }
189
190 /*******************************************************************
191 reads or writes a structure.
192 ********************************************************************/
193
194 BOOL samr_io_q_remove_sid_foreign_domain(const char *desc, SAMR_Q_REMOVE_SID_FOREIGN_DOMAIN * q_u,
195                           prs_struct *ps, int depth)
196 {
197         if (q_u == NULL)
198                 return False;
199
200         prs_debug(ps, depth, desc, "samr_io_q_remove_sid_foreign_domain");
201         depth++;
202
203         if(!prs_align(ps))
204                 return False;
205
206         if(!smb_io_pol_hnd("domain_pol", &q_u->dom_pol, ps, depth))
207                 return False;
208
209         if(!smb_io_dom_sid2("sid", &q_u->sid, ps, depth))
210                 return False;
211
212         if(!prs_align(ps))
213                 return False;
214
215         return True;
216 }
217
218 /*******************************************************************
219 reads or writes a structure.
220 ********************************************************************/
221
222 BOOL samr_io_r_remove_sid_foreign_domain(const char *desc, SAMR_R_REMOVE_SID_FOREIGN_DOMAIN * r_u,
223                           prs_struct *ps, int depth)
224 {
225         if (r_u == NULL)
226                 return False;
227
228         prs_debug(ps, depth, desc, "samr_io_r_remove_sid_foreign_domain");
229         depth++;
230
231         if(!prs_align(ps))
232                 return False;
233
234         if(!prs_ntstatus("status", ps, depth, &r_u->status))
235                 return False;
236
237         return True;
238 }
239
240 /*******************************************************************
241 reads or writes a structure.
242 ********************************************************************/
243
244 void init_samr_q_open_domain(SAMR_Q_OPEN_DOMAIN * q_u,
245                              POLICY_HND *pol, uint32 flags,
246                              const DOM_SID *sid)
247 {
248         DEBUG(5, ("samr_init_samr_q_open_domain\n"));
249
250         q_u->pol = *pol;
251         q_u->flags = flags;
252         init_dom_sid2(&q_u->dom_sid, sid);
253 }
254
255 /*******************************************************************
256 reads or writes a structure.
257 ********************************************************************/
258
259 BOOL samr_io_q_open_domain(const char *desc, SAMR_Q_OPEN_DOMAIN * q_u,
260                            prs_struct *ps, int depth)
261 {
262         if (q_u == NULL)
263                 return False;
264
265         prs_debug(ps, depth, desc, "samr_io_q_open_domain");
266         depth++;
267
268         if(!prs_align(ps))
269                 return False;
270
271         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
272                 return False;
273
274         if(!prs_uint32("flags", ps, depth, &q_u->flags))
275                 return False;
276
277         if(!smb_io_dom_sid2("sid", &q_u->dom_sid, ps, depth))
278                 return False;
279
280         return True;
281 }
282
283 /*******************************************************************
284 reads or writes a structure.
285 ********************************************************************/
286
287 BOOL samr_io_r_open_domain(const char *desc, SAMR_R_OPEN_DOMAIN * r_u,
288                            prs_struct *ps, int depth)
289 {
290         if (r_u == NULL)
291                 return False;
292
293         prs_debug(ps, depth, desc, "samr_io_r_open_domain");
294         depth++;
295
296         if(!prs_align(ps))
297                 return False;
298
299         if(!smb_io_pol_hnd("domain_pol", &r_u->domain_pol, ps, depth))
300                 return False;
301
302         if(!prs_ntstatus("status", ps, depth, &r_u->status))
303                 return False;
304
305         return True;
306 }
307
308 /*******************************************************************
309 reads or writes a structure.
310 ********************************************************************/
311
312 void init_samr_q_get_usrdom_pwinfo(SAMR_Q_GET_USRDOM_PWINFO * q_u,
313                                    POLICY_HND *user_pol)
314 {
315         DEBUG(5, ("samr_init_samr_q_get_usrdom_pwinfo\n"));
316
317         q_u->user_pol = *user_pol;
318 }
319
320 /*******************************************************************
321 reads or writes a structure.
322 ********************************************************************/
323
324 BOOL samr_io_q_get_usrdom_pwinfo(const char *desc, SAMR_Q_GET_USRDOM_PWINFO * q_u,
325                                  prs_struct *ps, int depth)
326 {
327         if (q_u == NULL)
328                 return False;
329
330         prs_debug(ps, depth, desc, "samr_io_q_get_usrdom_pwinfo");
331         depth++;
332
333         if(!prs_align(ps))
334                 return False;
335
336         return smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth);
337 }
338
339 /*******************************************************************
340  Init.
341 ********************************************************************/
342
343 void init_samr_r_get_usrdom_pwinfo(SAMR_R_GET_USRDOM_PWINFO *r_u, NTSTATUS status)
344 {
345         DEBUG(5, ("init_samr_r_get_usrdom_pwinfo\n"));
346         
347         r_u->unknown_0 = 0x0000;
348
349         /*
350          * used to be   
351          * r_u->unknown_1 = 0x0015;
352          * but for trusts.
353          */
354         r_u->unknown_1 = 0x01D1;
355         r_u->unknown_1 = 0x0015;
356
357         r_u->unknown_2 = 0x00000000;
358
359         r_u->status = status;
360 }
361
362 /*******************************************************************
363 reads or writes a structure.
364 ********************************************************************/
365
366 BOOL samr_io_r_get_usrdom_pwinfo(const char *desc, SAMR_R_GET_USRDOM_PWINFO * r_u,
367                                  prs_struct *ps, int depth)
368 {
369         if (r_u == NULL)
370                 return False;
371
372         prs_debug(ps, depth, desc, "samr_io_r_get_usrdom_pwinfo");
373         depth++;
374
375         if(!prs_align(ps))
376                 return False;
377
378         if(!prs_uint16("unknown_0", ps, depth, &r_u->unknown_0))
379                 return False;
380         if(!prs_uint16("unknown_1", ps, depth, &r_u->unknown_1))
381                 return False;
382         if(!prs_uint32("unknown_2", ps, depth, &r_u->unknown_2))
383                 return False;
384         if(!prs_ntstatus("status   ", ps, depth, &r_u->status))
385                 return False;
386
387         return True;
388 }
389
390
391 /*******************************************************************
392 reads or writes a structure.
393 ********************************************************************/
394
395 BOOL samr_io_q_set_sec_obj(const char *desc, SAMR_Q_SET_SEC_OBJ * q_u,
396                              prs_struct *ps, int depth)
397 {
398         if (q_u == NULL)
399                 return False;
400
401         prs_debug(ps, depth, desc, "samr_io_q_set_sec_obj");
402         depth++;
403
404         if(!prs_align(ps))
405                 return False;
406
407         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
408                 return False;
409
410         if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
411                 return False;
412                 
413         if(!sec_io_desc_buf("sec_desc", &q_u->buf, ps, depth))
414                 return False;
415         
416         return True;
417 }
418
419
420 /*******************************************************************
421 reads or writes a structure.
422 ********************************************************************/
423
424 void init_samr_q_query_sec_obj(SAMR_Q_QUERY_SEC_OBJ * q_u,
425                                POLICY_HND *user_pol, uint32 sec_info)
426 {
427         DEBUG(5, ("samr_init_samr_q_query_sec_obj\n"));
428
429         q_u->user_pol = *user_pol;
430         q_u->sec_info = sec_info;
431 }
432
433
434 /*******************************************************************
435 reads or writes a structure.
436 ********************************************************************/
437
438 BOOL samr_io_q_query_sec_obj(const char *desc, SAMR_Q_QUERY_SEC_OBJ * q_u,
439                              prs_struct *ps, int depth)
440 {
441         if (q_u == NULL)
442                 return False;
443
444         prs_debug(ps, depth, desc, "samr_io_q_query_sec_obj");
445         depth++;
446
447         if(!prs_align(ps))
448                 return False;
449
450         if(!smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth))
451                 return False;
452
453         if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
454                 return False;
455
456         return True;
457 }
458
459 /*******************************************************************
460 reads or writes a structure.
461 ********************************************************************/
462
463 void init_samr_q_query_dom_info(SAMR_Q_QUERY_DOMAIN_INFO * q_u,
464                                 POLICY_HND *domain_pol, uint16 switch_value)
465 {
466         DEBUG(5, ("samr_init_samr_q_query_dom_info\n"));
467
468         q_u->domain_pol = *domain_pol;
469         q_u->switch_value = switch_value;
470 }
471
472 /*******************************************************************
473 reads or writes a structure.
474 ********************************************************************/
475
476 BOOL samr_io_q_query_dom_info(const char *desc, SAMR_Q_QUERY_DOMAIN_INFO * q_u,
477                               prs_struct *ps, int depth)
478 {
479         if (q_u == NULL)
480                 return False;
481
482         prs_debug(ps, depth, desc, "samr_io_q_query_dom_info");
483         depth++;
484
485         if(!prs_align(ps))
486                 return False;
487
488         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
489                 return False;
490
491         if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
492                 return False;
493
494         return True;
495 }
496
497
498 /*******************************************************************
499 inits a structure.
500 ********************************************************************/
501
502 void init_unk_info3(SAM_UNK_INFO_3 *u_3, NTTIME nt_logout)
503 {
504         u_3->logout.low = nt_logout.low;
505         u_3->logout.high = nt_logout.high;
506 }
507
508 /*******************************************************************
509 reads or writes a structure.
510 ********************************************************************/
511
512 static BOOL sam_io_unk_info3(const char *desc, SAM_UNK_INFO_3 * u_3,
513                              prs_struct *ps, int depth)
514 {
515         if (u_3 == NULL)
516                 return False;
517
518         prs_debug(ps, depth, desc, "sam_io_unk_info3");
519         depth++;
520
521         if(!smb_io_time("logout", &u_3->logout, ps, depth))
522                 return False;
523
524         return True;
525 }
526
527 /*******************************************************************
528 inits a structure.
529 ********************************************************************/
530
531 void init_unk_info6(SAM_UNK_INFO_6 * u_6)
532 {
533         u_6->unknown_0 = 0x00000000;
534         u_6->ptr_0 = 1;
535         memset(u_6->padding, 0, sizeof(u_6->padding));  /* 12 bytes zeros */
536 }
537
538 /*******************************************************************
539 reads or writes a structure.
540 ********************************************************************/
541
542 static BOOL sam_io_unk_info6(const char *desc, SAM_UNK_INFO_6 * u_6,
543                              prs_struct *ps, int depth)
544 {
545         if (u_6 == NULL)
546                 return False;
547
548         prs_debug(ps, depth, desc, "sam_io_unk_info6");
549         depth++;
550
551         if(!prs_uint32("unknown_0", ps, depth, &u_6->unknown_0)) /* 0x0000 0000 */
552                 return False;
553         if(!prs_uint32("ptr_0", ps, depth, &u_6->ptr_0)) /* pointer to unknown structure */
554                 return False;
555         if(!prs_uint8s(False, "padding", ps, depth, u_6->padding, sizeof(u_6->padding)))        /* 12 bytes zeros */
556                 return False;
557
558         return True;
559 }
560
561 /*******************************************************************
562 inits a structure.
563 ********************************************************************/
564
565 void init_unk_info7(SAM_UNK_INFO_7 * u_7, uint32 server_role)
566 {
567         u_7->server_role = server_role;
568 }
569
570 /*******************************************************************
571 reads or writes a structure.
572 ********************************************************************/
573
574 static BOOL sam_io_unk_info7(const char *desc, SAM_UNK_INFO_7 * u_7,
575                              prs_struct *ps, int depth)
576 {
577         if (u_7 == NULL)
578                 return False;
579
580         prs_debug(ps, depth, desc, "sam_io_unk_info7");
581         depth++;
582
583         if(!prs_uint16("server_role", ps, depth, &u_7->server_role))
584                 return False;
585
586         return True;
587 }
588
589 /*******************************************************************
590 inits a structure.
591 ********************************************************************/
592
593 void init_unk_info8(SAM_UNK_INFO_8 * u_8, uint32 seq_num)
594 {
595         unix_to_nt_time(&u_8->domain_create_time, 0);
596         u_8->seq_num.low = seq_num;
597         u_8->seq_num.high = 0x0000;
598 }
599
600 /*******************************************************************
601 reads or writes a structure.
602 ********************************************************************/
603
604 static BOOL sam_io_unk_info8(const char *desc, SAM_UNK_INFO_8 * u_8,
605                              prs_struct *ps, int depth)
606 {
607         if (u_8 == NULL)
608                 return False;
609
610         prs_debug(ps, depth, desc, "sam_io_unk_info8");
611         depth++;
612
613         if (!prs_uint64("seq_num", ps, depth, &u_8->seq_num))
614                 return False;
615
616         if(!smb_io_time("domain_create_time", &u_8->domain_create_time, ps, depth))
617                 return False;
618
619         return True;
620 }
621
622
623 /*******************************************************************
624 inits a structure.
625 ********************************************************************/
626
627 void init_unk_info12(SAM_UNK_INFO_12 * u_12, NTTIME nt_lock_duration, NTTIME nt_reset_time, uint16 lockout)
628 {
629         u_12->duration.low = nt_lock_duration.low;
630         u_12->duration.high = nt_lock_duration.high;
631         u_12->reset_count.low = nt_reset_time.low;
632         u_12->reset_count.high = nt_reset_time.high;
633
634         u_12->bad_attempt_lockout = lockout;
635 }
636
637 /*******************************************************************
638 reads or writes a structure.
639 ********************************************************************/
640
641 static BOOL sam_io_unk_info12(const char *desc, SAM_UNK_INFO_12 * u_12,
642                               prs_struct *ps, int depth)
643 {
644         if (u_12 == NULL)
645                 return False;
646
647         prs_debug(ps, depth, desc, "sam_io_unk_info12");
648         depth++;
649
650         if(!smb_io_time("duration", &u_12->duration, ps, depth))
651                 return False;
652         if(!smb_io_time("reset_count", &u_12->reset_count, ps, depth))
653                 return False;
654         if(!prs_uint16("bad_attempt_lockout", ps, depth, &u_12->bad_attempt_lockout))
655                 return False;
656
657         return True;
658 }
659
660 /*******************************************************************
661 inits a structure.
662 ********************************************************************/
663
664 void init_unk_info5(SAM_UNK_INFO_5 * u_5,const char *server)
665 {
666         init_unistr2(&u_5->uni_server, server, UNI_FLAGS_NONE);
667         init_uni_hdr(&u_5->hdr_server, &u_5->uni_server);
668 }
669
670 /*******************************************************************
671 reads or writes a structure.
672 ********************************************************************/
673
674 static BOOL sam_io_unk_info5(const char *desc, SAM_UNK_INFO_5 * u_5,
675                              prs_struct *ps, int depth)
676 {
677         if (u_5 == NULL)
678                 return False;
679
680         prs_debug(ps, depth, desc, "sam_io_unk_info5");
681         depth++;
682
683         if(!smb_io_unihdr("hdr_server", &u_5->hdr_server, ps, depth))
684                 return False;
685
686         if(!smb_io_unistr2("uni_server", &u_5->uni_server, u_5->hdr_server.buffer, ps, depth))
687                 return False;
688
689         return True;
690 }
691
692 /*******************************************************************
693 inits a structure.
694 ********************************************************************/
695
696 void init_unk_info2(SAM_UNK_INFO_2 * u_2,
697                         const char *comment, const char *domain, const char *server,
698                         uint32 seq_num, uint32 num_users, uint32 num_groups, uint32 num_alias, NTTIME nt_logout, uint32 server_role)
699 {
700         u_2->logout.low = nt_logout.low;
701         u_2->logout.high = nt_logout.high;
702
703         u_2->seq_num.low = seq_num;
704         u_2->seq_num.high = 0x00000000;
705
706
707         u_2->unknown_4 = 0x00000001;
708         u_2->server_role = server_role;
709         u_2->unknown_6 = 0x00000001;
710         u_2->num_domain_usrs = num_users;
711         u_2->num_domain_grps = num_groups;
712         u_2->num_local_grps = num_alias;
713
714         memset(u_2->padding, 0, sizeof(u_2->padding));  /* 12 bytes zeros */
715
716         init_unistr2(&u_2->uni_comment, comment, UNI_FLAGS_NONE);
717         init_uni_hdr(&u_2->hdr_comment, &u_2->uni_comment);
718         init_unistr2(&u_2->uni_domain, domain, UNI_FLAGS_NONE);
719         init_uni_hdr(&u_2->hdr_domain, &u_2->uni_domain);
720         init_unistr2(&u_2->uni_server, server, UNI_FLAGS_NONE);
721         init_uni_hdr(&u_2->hdr_server, &u_2->uni_server);
722 }
723
724 /*******************************************************************
725 reads or writes a structure.
726 ********************************************************************/
727
728 static BOOL sam_io_unk_info2(const char *desc, SAM_UNK_INFO_2 * u_2,
729                              prs_struct *ps, int depth)
730 {
731         if (u_2 == NULL)
732                 return False;
733
734         prs_debug(ps, depth, desc, "sam_io_unk_info2");
735         depth++;
736
737         if(!smb_io_time("logout", &u_2->logout, ps, depth))
738                 return False;
739         if(!smb_io_unihdr("hdr_comment", &u_2->hdr_comment, ps, depth))
740                 return False;
741         if(!smb_io_unihdr("hdr_domain", &u_2->hdr_domain, ps, depth))
742                 return False;
743         if(!smb_io_unihdr("hdr_server", &u_2->hdr_server, ps, depth))
744                 return False;
745
746         /* put all the data in here, at the moment, including what the above
747            pointer is referring to
748          */
749
750         if(!prs_uint64("seq_num ", ps, depth, &u_2->seq_num))
751                 return False;
752
753         if(!prs_uint32("unknown_4 ", ps, depth, &u_2->unknown_4)) /* 0x0000 0001 */
754                 return False;
755         if(!prs_uint32("server_role ", ps, depth, &u_2->server_role))
756                 return False;
757         if(!prs_uint32("unknown_6 ", ps, depth, &u_2->unknown_6)) /* 0x0000 0001 */
758                 return False;
759         if(!prs_uint32("num_domain_usrs ", ps, depth, &u_2->num_domain_usrs))
760                 return False;
761         if(!prs_uint32("num_domain_grps", ps, depth, &u_2->num_domain_grps))
762                 return False;
763         if(!prs_uint32("num_local_grps", ps, depth, &u_2->num_local_grps))
764                 return False;
765
766         if(!smb_io_unistr2("uni_comment", &u_2->uni_comment, u_2->hdr_comment.buffer, ps, depth))
767                 return False;
768         if(!smb_io_unistr2("uni_domain", &u_2->uni_domain, u_2->hdr_domain.buffer, ps, depth))
769                 return False;
770         if(!smb_io_unistr2("uni_server", &u_2->uni_server, u_2->hdr_server.buffer, ps, depth))
771                 return False;
772
773         return True;
774 }
775
776 /*******************************************************************
777 inits a structure.
778 ********************************************************************/
779
780 void init_unk_info1(SAM_UNK_INFO_1 *u_1, uint16 min_pass_len, uint16 pass_hist, 
781                     uint32 password_properties, NTTIME nt_expire, NTTIME nt_min_age)
782 {
783         u_1->min_length_password = min_pass_len;
784         u_1->password_history = pass_hist;
785         u_1->password_properties = password_properties;
786         
787         /* password never expire */
788         u_1->expire.high = nt_expire.high;
789         u_1->expire.low = nt_expire.low;
790         
791         /* can change the password now */
792         u_1->min_passwordage.high = nt_min_age.high;
793         u_1->min_passwordage.low = nt_min_age.low;
794         
795 }
796
797 /*******************************************************************
798 reads or writes a structure.
799 ********************************************************************/
800
801 static BOOL sam_io_unk_info1(const char *desc, SAM_UNK_INFO_1 * u_1,
802                              prs_struct *ps, int depth)
803 {
804         if (u_1 == NULL)
805           return False;
806
807         prs_debug(ps, depth, desc, "sam_io_unk_info1");
808         depth++;
809
810         if(!prs_uint16("min_length_password", ps, depth, &u_1->min_length_password))
811                 return False;
812         if(!prs_uint16("password_history", ps, depth, &u_1->password_history))
813                 return False;
814         if(!prs_uint32("password_properties", ps, depth, &u_1->password_properties))
815                 return False;
816         if(!smb_io_time("expire", &u_1->expire, ps, depth))
817                 return False;
818         if(!smb_io_time("min_passwordage", &u_1->min_passwordage, ps, depth))
819                 return False;
820
821         return True;
822 }
823
824 /*******************************************************************
825 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
826 ********************************************************************/
827
828 void init_samr_r_query_dom_info(SAMR_R_QUERY_DOMAIN_INFO * r_u,
829                                 uint16 switch_value, SAM_UNK_CTR * ctr,
830                                 NTSTATUS status)
831 {
832         DEBUG(5, ("init_samr_r_query_dom_info\n"));
833
834         r_u->ptr_0 = 0;
835         r_u->switch_value = 0;
836         r_u->status = status;   /* return status */
837
838         if (NT_STATUS_IS_OK(status)) {
839                 r_u->switch_value = switch_value;
840                 r_u->ptr_0 = 1;
841                 r_u->ctr = ctr;
842         }
843 }
844
845 /*******************************************************************
846 reads or writes a structure.
847 ********************************************************************/
848
849 BOOL samr_io_r_query_dom_info(const char *desc, SAMR_R_QUERY_DOMAIN_INFO * r_u,
850                               prs_struct *ps, int depth)
851 {
852         if (r_u == NULL)
853                 return False;
854
855         prs_debug(ps, depth, desc, "samr_io_r_query_dom_info");
856         depth++;
857
858         if(!prs_align(ps))
859                 return False;
860
861         if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
862                 return False;
863
864         if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
865                 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
866                         return False;
867                 if(!prs_align(ps))
868                         return False;
869
870                 switch (r_u->switch_value) {
871                 case 0x0c:
872                         if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
873                                 return False;
874                         break;
875                 case 0x08:
876                         if(!sam_io_unk_info8("unk_inf8",&r_u->ctr->info.inf8, ps,depth))
877                                 return False;
878                         break;
879                 case 0x07:
880                         if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
881                                 return False;
882                         break;
883                 case 0x06:
884                         if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
885                                 return False;
886                         break;
887                 case 0x05:
888                         if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
889                                 return False;
890                         break;
891                 case 0x03:
892                         if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
893                                 return False;
894                         break;
895                 case 0x02:
896                         if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
897                                 return False;
898                         break;
899                 case 0x01:
900                         if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
901                                 return False;
902                         break;
903                 default:
904                         DEBUG(0, ("samr_io_r_query_dom_info: unknown switch level 0x%x\n",
905                                 r_u->switch_value));
906                         r_u->status = NT_STATUS_INVALID_INFO_CLASS;
907                         return False;
908                 }
909         }
910         
911         if(!prs_align(ps))
912                 return False;
913
914         if(!prs_ntstatus("status", ps, depth, &r_u->status))
915                 return False;
916         
917         return True;
918 }
919
920 /*******************************************************************
921 reads or writes a SAMR_R_SET_SEC_OBJ structure.
922 ********************************************************************/
923
924 BOOL samr_io_r_set_sec_obj(const char *desc, SAMR_R_SET_SEC_OBJ * r_u,
925                              prs_struct *ps, int depth)
926 {
927         if (r_u == NULL)
928                 return False;
929   
930         prs_debug(ps, depth, desc, "samr_io_r_set_sec_obj");
931         depth++;
932
933         if(!prs_align(ps))
934                 return False;
935
936         if(!prs_ntstatus("status", ps, depth, &r_u->status))
937                 return False;
938
939         return True;
940 }
941
942 /*******************************************************************
943 reads or writes a SAMR_R_QUERY_SEC_OBJ structure.
944 ********************************************************************/
945
946 BOOL samr_io_r_query_sec_obj(const char *desc, SAMR_R_QUERY_SEC_OBJ * r_u,
947                              prs_struct *ps, int depth)
948 {
949         if (r_u == NULL)
950                 return False;
951   
952         prs_debug(ps, depth, desc, "samr_io_r_query_sec_obj");
953         depth++;
954
955         if(!prs_align(ps))
956                 return False;
957
958         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
959                 return False;
960         if (r_u->ptr != 0) {
961                 if(!sec_io_desc_buf("sec", &r_u->buf, ps, depth))
962                         return False;
963         }
964
965         if(!prs_ntstatus("status", ps, depth, &r_u->status))
966                 return False;
967
968         return True;
969 }
970
971 /*******************************************************************
972 reads or writes a SAM_STR1 structure.
973 ********************************************************************/
974
975 static BOOL sam_io_sam_str1(const char *desc, SAM_STR1 * sam, uint32 acct_buf,
976                             uint32 name_buf, uint32 desc_buf,
977                             prs_struct *ps, int depth)
978 {
979         if (sam == NULL)
980                 return False;
981
982         prs_debug(ps, depth, desc, "sam_io_sam_str1");
983         depth++;
984
985         if(!prs_align(ps))
986                 return False;
987         if (!smb_io_unistr2("name", &sam->uni_acct_name, acct_buf, ps, depth))
988                 return False;
989
990         if (!smb_io_unistr2("desc", &sam->uni_acct_desc, desc_buf, ps, depth))
991                 return False;
992
993         if (!smb_io_unistr2("full", &sam->uni_full_name, name_buf, ps, depth))
994                 return False;
995
996         return True;
997 }
998
999 /*******************************************************************
1000 inits a SAM_ENTRY1 structure.
1001 ********************************************************************/
1002
1003 static void init_sam_entry1(SAM_ENTRY1 *sam, uint32 user_idx,
1004                             UNISTR2 *sam_name, UNISTR2 *sam_full,
1005                             UNISTR2 *sam_desc, uint32 rid_user,
1006                             uint16 acb_info)
1007 {
1008         DEBUG(5, ("init_sam_entry1\n"));
1009
1010         ZERO_STRUCTP(sam);
1011
1012         sam->user_idx = user_idx;
1013         sam->rid_user = rid_user;
1014         sam->acb_info = acb_info;
1015
1016         init_uni_hdr(&sam->hdr_acct_name, sam_name);
1017         init_uni_hdr(&sam->hdr_user_name, sam_full);
1018         init_uni_hdr(&sam->hdr_user_desc, sam_desc);
1019 }
1020
1021 /*******************************************************************
1022 reads or writes a SAM_ENTRY1 structure.
1023 ********************************************************************/
1024
1025 static BOOL sam_io_sam_entry1(const char *desc, SAM_ENTRY1 * sam,
1026                               prs_struct *ps, int depth)
1027 {
1028         if (sam == NULL)
1029                 return False;
1030
1031         prs_debug(ps, depth, desc, "sam_io_sam_entry1");
1032         depth++;
1033
1034         if(!prs_align(ps))
1035                 return False;
1036
1037         if(!prs_uint32("user_idx ", ps, depth, &sam->user_idx))
1038                 return False;
1039
1040         if(!prs_uint32("rid_user ", ps, depth, &sam->rid_user))
1041                 return False;
1042         if(!prs_uint16("acb_info ", ps, depth, &sam->acb_info))
1043                 return False;
1044
1045         if(!prs_align(ps))
1046                 return False;
1047
1048         if (!smb_io_unihdr("hdr_acct_name", &sam->hdr_acct_name, ps, depth))
1049                 return False;
1050         if (!smb_io_unihdr("hdr_user_desc", &sam->hdr_user_desc, ps, depth))
1051                 return False;
1052         if (!smb_io_unihdr("hdr_user_name", &sam->hdr_user_name, ps, depth))
1053                 return False;
1054
1055         return True;
1056 }
1057
1058 /*******************************************************************
1059 reads or writes a SAM_STR2 structure.
1060 ********************************************************************/
1061
1062 static BOOL sam_io_sam_str2(const char *desc, SAM_STR2 * sam, uint32 acct_buf,
1063                             uint32 desc_buf, prs_struct *ps, int depth)
1064 {
1065         if (sam == NULL)
1066                 return False;
1067
1068         prs_debug(ps, depth, desc, "sam_io_sam_str2");
1069         depth++;
1070
1071         if(!prs_align(ps))
1072                 return False;
1073
1074         if(!smb_io_unistr2("uni_srv_name", &sam->uni_srv_name, acct_buf, ps, depth)) /* account name unicode string */
1075                 return False;
1076         if(!smb_io_unistr2("uni_srv_desc", &sam->uni_srv_desc, desc_buf, ps, depth))    /* account desc unicode string */
1077                 return False;
1078
1079         return True;
1080 }
1081
1082 /*******************************************************************
1083 inits a SAM_ENTRY2 structure.
1084 ********************************************************************/
1085 static void init_sam_entry2(SAM_ENTRY2 * sam, uint32 user_idx,
1086                             UNISTR2 *sam_name, UNISTR2 *sam_desc,
1087                             uint32 rid_user, uint16 acb_info)
1088 {
1089         DEBUG(5, ("init_sam_entry2\n"));
1090
1091         sam->user_idx = user_idx;
1092         sam->rid_user = rid_user;
1093         sam->acb_info = acb_info;
1094
1095         init_uni_hdr(&sam->hdr_srv_name, sam_name);
1096         init_uni_hdr(&sam->hdr_srv_desc, sam_desc);
1097 }
1098
1099 /*******************************************************************
1100 reads or writes a SAM_ENTRY2 structure.
1101 ********************************************************************/
1102
1103 static BOOL sam_io_sam_entry2(const char *desc, SAM_ENTRY2 * sam,
1104                               prs_struct *ps, int depth)
1105 {
1106         if (sam == NULL)
1107                 return False;
1108
1109         prs_debug(ps, depth, desc, "sam_io_sam_entry2");
1110         depth++;
1111
1112         if(!prs_align(ps))
1113                 return False;
1114
1115         if(!prs_uint32("user_idx ", ps, depth, &sam->user_idx))
1116                 return False;
1117
1118         if(!prs_uint32("rid_user ", ps, depth, &sam->rid_user))
1119                 return False;
1120         if(!prs_uint16("acb_info ", ps, depth, &sam->acb_info))
1121                 return False;
1122
1123         if(!prs_align(ps))
1124                 return False;
1125
1126         if(!smb_io_unihdr("unihdr", &sam->hdr_srv_name, ps, depth))     /* account name unicode string header */
1127                 return False;
1128         if(!smb_io_unihdr("unihdr", &sam->hdr_srv_desc, ps, depth))     /* account name unicode string header */
1129                 return False;
1130
1131         return True;
1132 }
1133
1134 /*******************************************************************
1135 reads or writes a SAM_STR3 structure.
1136 ********************************************************************/
1137
1138 static BOOL sam_io_sam_str3(const char *desc, SAM_STR3 * sam, uint32 acct_buf,
1139                             uint32 desc_buf, prs_struct *ps, int depth)
1140 {
1141         if (sam == NULL)
1142                 return False;
1143
1144         prs_debug(ps, depth, desc, "sam_io_sam_str3");
1145         depth++;
1146
1147         if(!prs_align(ps))
1148                 return False;
1149
1150         if(!smb_io_unistr2("uni_grp_name", &sam->uni_grp_name, acct_buf, ps, depth))    /* account name unicode string */
1151                 return False;
1152         if(!smb_io_unistr2("uni_grp_desc", &sam->uni_grp_desc, desc_buf, ps, depth))    /* account desc unicode string */
1153                 return False;
1154
1155         return True;
1156 }
1157
1158 /*******************************************************************
1159 inits a SAM_ENTRY3 structure.
1160 ********************************************************************/
1161
1162 static void init_sam_entry3(SAM_ENTRY3 * sam, uint32 grp_idx,
1163                             UNISTR2 *grp_name, UNISTR2 *grp_desc,
1164                             uint32 rid_grp)
1165 {
1166         DEBUG(5, ("init_sam_entry3\n"));
1167
1168         sam->grp_idx = grp_idx;
1169         sam->rid_grp = rid_grp;
1170         sam->attr = 0x07;       /* group rid attributes - gets ignored by nt 4.0 */
1171
1172         init_uni_hdr(&sam->hdr_grp_name, grp_name);
1173         init_uni_hdr(&sam->hdr_grp_desc, grp_desc);
1174 }
1175
1176 /*******************************************************************
1177 reads or writes a SAM_ENTRY3 structure.
1178 ********************************************************************/
1179
1180 static BOOL sam_io_sam_entry3(const char *desc, SAM_ENTRY3 * sam,
1181                               prs_struct *ps, int depth)
1182 {
1183         if (sam == NULL)
1184                 return False;
1185
1186         prs_debug(ps, depth, desc, "sam_io_sam_entry3");
1187         depth++;
1188
1189         if(!prs_align(ps))
1190                 return False;
1191
1192         if(!prs_uint32("grp_idx", ps, depth, &sam->grp_idx))
1193                 return False;
1194
1195         if(!prs_uint32("rid_grp", ps, depth, &sam->rid_grp))
1196                 return False;
1197         if(!prs_uint32("attr   ", ps, depth, &sam->attr))
1198                 return False;
1199
1200         if(!smb_io_unihdr("unihdr", &sam->hdr_grp_name, ps, depth))     /* account name unicode string header */
1201                 return False;
1202         if(!smb_io_unihdr("unihdr", &sam->hdr_grp_desc, ps, depth))     /* account name unicode string header */
1203                 return False;
1204
1205         return True;
1206 }
1207
1208 /*******************************************************************
1209 inits a SAM_ENTRY4 structure.
1210 ********************************************************************/
1211
1212 static void init_sam_entry4(SAM_ENTRY4 * sam, uint32 user_idx,
1213                             uint32 len_acct_name)
1214 {
1215         DEBUG(5, ("init_sam_entry4\n"));
1216
1217         sam->user_idx = user_idx;
1218         init_str_hdr(&sam->hdr_acct_name, len_acct_name+1, len_acct_name, len_acct_name != 0);
1219 }
1220
1221 /*******************************************************************
1222 reads or writes a SAM_ENTRY4 structure.
1223 ********************************************************************/
1224
1225 static BOOL sam_io_sam_entry4(const char *desc, SAM_ENTRY4 * sam,
1226                               prs_struct *ps, int depth)
1227 {
1228         if (sam == NULL)
1229                 return False;
1230
1231         prs_debug(ps, depth, desc, "sam_io_sam_entry4");
1232         depth++;
1233
1234         if(!prs_align(ps))
1235                 return False;
1236
1237         if(!prs_uint32("user_idx", ps, depth, &sam->user_idx))
1238                 return False;
1239         if(!smb_io_strhdr("strhdr", &sam->hdr_acct_name, ps, depth))
1240                 return False;
1241
1242         return True;
1243 }
1244
1245 /*******************************************************************
1246 inits a SAM_ENTRY5 structure.
1247 ********************************************************************/
1248
1249 static void init_sam_entry5(SAM_ENTRY5 * sam, uint32 grp_idx,
1250                             uint32 len_grp_name)
1251 {
1252         DEBUG(5, ("init_sam_entry5\n"));
1253
1254         sam->grp_idx = grp_idx;
1255         init_str_hdr(&sam->hdr_grp_name, len_grp_name, len_grp_name,
1256                      len_grp_name != 0);
1257 }
1258
1259 /*******************************************************************
1260 reads or writes a SAM_ENTRY5 structure.
1261 ********************************************************************/
1262
1263 static BOOL sam_io_sam_entry5(const char *desc, SAM_ENTRY5 * sam,
1264                               prs_struct *ps, int depth)
1265 {
1266         if (sam == NULL)
1267                 return False;
1268
1269         prs_debug(ps, depth, desc, "sam_io_sam_entry5");
1270         depth++;
1271
1272         if(!prs_align(ps))
1273                 return False;
1274
1275         if(!prs_uint32("grp_idx", ps, depth, &sam->grp_idx))
1276                 return False;
1277         if(!smb_io_strhdr("strhdr", &sam->hdr_grp_name, ps, depth))
1278                 return False;
1279
1280         return True;
1281 }
1282
1283 /*******************************************************************
1284 inits a SAM_ENTRY structure.
1285 ********************************************************************/
1286
1287 void init_sam_entry(SAM_ENTRY *sam, UNISTR2 *uni2, uint32 rid)
1288 {
1289         DEBUG(10, ("init_sam_entry: %d\n", rid));
1290
1291         sam->rid = rid;
1292         init_uni_hdr(&sam->hdr_name, uni2);
1293 }
1294
1295 /*******************************************************************
1296 reads or writes a SAM_ENTRY structure.
1297 ********************************************************************/
1298
1299 static BOOL sam_io_sam_entry(const char *desc, SAM_ENTRY * sam,
1300                              prs_struct *ps, int depth)
1301 {
1302         if (sam == NULL)
1303                 return False;
1304
1305         prs_debug(ps, depth, desc, "sam_io_sam_entry");
1306         depth++;
1307
1308         if(!prs_align(ps))
1309                 return False;
1310         if(!prs_uint32("rid", ps, depth, &sam->rid))
1311                 return False;
1312         if(!smb_io_unihdr("unihdr", &sam->hdr_name, ps, depth)) /* account name unicode string header */
1313                 return False;
1314
1315         return True;
1316 }
1317
1318 /*******************************************************************
1319 inits a SAMR_Q_ENUM_DOM_USERS structure.
1320 ********************************************************************/
1321
1322 void init_samr_q_enum_dom_users(SAMR_Q_ENUM_DOM_USERS * q_e, POLICY_HND *pol,
1323                                 uint32 start_idx,
1324                                 uint16 acb_mask, uint16 unk_1, uint32 size)
1325 {
1326         DEBUG(5, ("init_samr_q_enum_dom_users\n"));
1327
1328         q_e->pol = *pol;
1329
1330         q_e->start_idx = start_idx;     /* zero indicates lots */
1331         q_e->acb_mask = acb_mask;
1332         q_e->unknown_1 = unk_1;
1333         q_e->max_size = size;
1334 }
1335
1336 /*******************************************************************
1337 reads or writes a structure.
1338 ********************************************************************/
1339
1340 BOOL samr_io_q_enum_dom_users(const char *desc, SAMR_Q_ENUM_DOM_USERS * q_e,
1341                               prs_struct *ps, int depth)
1342 {
1343         if (q_e == NULL)
1344                 return False;
1345
1346         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_users");
1347         depth++;
1348
1349         if(!prs_align(ps))
1350                 return False;
1351
1352         if(!smb_io_pol_hnd("domain_pol", &q_e->pol, ps, depth))
1353                 return False;
1354
1355         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
1356                 return False;
1357         if(!prs_uint16("acb_mask ", ps, depth, &q_e->acb_mask))
1358                 return False;
1359         if(!prs_uint16("unknown_1", ps, depth, &q_e->unknown_1))
1360                 return False;
1361
1362         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
1363                 return False;
1364
1365         return True;
1366 }
1367
1368
1369 /*******************************************************************
1370 inits a SAMR_R_ENUM_DOM_USERS structure.
1371 ********************************************************************/
1372
1373 void init_samr_r_enum_dom_users(SAMR_R_ENUM_DOM_USERS * r_u,
1374                                 uint32 next_idx, uint32 num_sam_entries)
1375 {
1376         DEBUG(5, ("init_samr_r_enum_dom_users\n"));
1377
1378         r_u->next_idx = next_idx;
1379
1380         if (num_sam_entries != 0) {
1381                 r_u->ptr_entries1 = 1;
1382                 r_u->ptr_entries2 = 1;
1383                 r_u->num_entries2 = num_sam_entries;
1384                 r_u->num_entries3 = num_sam_entries;
1385
1386                 r_u->num_entries4 = num_sam_entries;
1387         } else {
1388                 r_u->ptr_entries1 = 0;
1389                 r_u->num_entries2 = num_sam_entries;
1390                 r_u->ptr_entries2 = 1;
1391         }
1392 }
1393
1394 /*******************************************************************
1395 reads or writes a structure.
1396 ********************************************************************/
1397
1398 BOOL samr_io_r_enum_dom_users(const char *desc, SAMR_R_ENUM_DOM_USERS * r_u,
1399                               prs_struct *ps, int depth)
1400 {
1401         uint32 i;
1402
1403         if (r_u == NULL)
1404                 return False;
1405
1406         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_users");
1407         depth++;
1408
1409         if(!prs_align(ps))
1410                 return False;
1411
1412         if(!prs_uint32("next_idx    ", ps, depth, &r_u->next_idx))
1413                 return False;
1414         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
1415                 return False;
1416
1417         if (r_u->ptr_entries1 != 0) {
1418                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
1419                         return False;
1420                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
1421                         return False;
1422                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
1423                         return False;
1424
1425                 if (UNMARSHALLING(ps) && (r_u->num_entries2 != 0)) {
1426                         r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY, r_u->num_entries2);
1427                         r_u->uni_acct_name = PRS_ALLOC_MEM(ps,UNISTR2, r_u->num_entries2);
1428                 }
1429
1430                 if ((r_u->sam == NULL || r_u->uni_acct_name == NULL) && r_u->num_entries2 != 0) {
1431                         DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_USERS\n"));
1432                         r_u->num_entries4 = 0;
1433                         r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
1434                         return False;
1435                 }
1436
1437                 for (i = 0; i < r_u->num_entries2; i++) {
1438                         if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
1439                                 return False;
1440                 }
1441
1442                 for (i = 0; i < r_u->num_entries2; i++) {
1443                         if(!smb_io_unistr2("", &r_u->uni_acct_name[i],r_u->sam[i].hdr_name.buffer, ps,depth))
1444                                 return False;
1445                 }
1446
1447         }
1448
1449         if(!prs_align(ps))
1450                 return False;
1451                 
1452         if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
1453                 return False;
1454         if(!prs_ntstatus("status", ps, depth, &r_u->status))
1455                 return False;
1456
1457         return True;
1458 }
1459
1460 /*******************************************************************
1461 inits a SAMR_Q_QUERY_DISPINFO structure.
1462 ********************************************************************/
1463
1464 void init_samr_q_query_dispinfo(SAMR_Q_QUERY_DISPINFO * q_e, POLICY_HND *pol,
1465                                 uint16 switch_level, uint32 start_idx,
1466                                 uint32 max_entries, uint32 max_size)
1467 {
1468         DEBUG(5, ("init_samr_q_query_dispinfo\n"));
1469
1470         q_e->domain_pol = *pol;
1471
1472         q_e->switch_level = switch_level;
1473
1474         q_e->start_idx = start_idx;
1475         q_e->max_entries = max_entries;
1476         q_e->max_size = max_size;
1477 }
1478
1479 /*******************************************************************
1480 reads or writes a structure.
1481 ********************************************************************/
1482
1483 BOOL samr_io_q_query_dispinfo(const char *desc, SAMR_Q_QUERY_DISPINFO * q_e,
1484                               prs_struct *ps, int depth)
1485 {
1486         if (q_e == NULL)
1487                 return False;
1488
1489         prs_debug(ps, depth, desc, "samr_io_q_query_dispinfo");
1490         depth++;
1491
1492         if(!prs_align(ps))
1493                 return False;
1494
1495         if(!smb_io_pol_hnd("domain_pol", &q_e->domain_pol, ps, depth))
1496                 return False;
1497
1498         if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
1499                 return False;
1500         if(!prs_align(ps))
1501                 return False;
1502
1503         if(!prs_uint32("start_idx   ", ps, depth, &q_e->start_idx))
1504                 return False;
1505         if(!prs_uint32("max_entries ", ps, depth, &q_e->max_entries))
1506                 return False;
1507         if(!prs_uint32("max_size    ", ps, depth, &q_e->max_size))
1508                 return False;
1509
1510         return True;
1511 }
1512
1513 /*******************************************************************
1514 inits a SAM_DISPINFO_1 structure.
1515 ********************************************************************/
1516
1517 NTSTATUS init_sam_dispinfo_1(TALLOC_CTX *ctx, SAM_DISPINFO_1 **sam,
1518                              uint32 num_entries, uint32 start_idx,
1519                              struct samr_displayentry *entries)
1520 {
1521         uint32 i;
1522
1523         DEBUG(10, ("init_sam_dispinfo_1: num_entries: %d\n", num_entries));
1524
1525         if (num_entries==0)
1526                 return NT_STATUS_OK;
1527
1528         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_1, num_entries);
1529         if (*sam == NULL)
1530                 return NT_STATUS_NO_MEMORY;
1531
1532         (*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY1, num_entries);
1533         if ((*sam)->sam == NULL)
1534                 return NT_STATUS_NO_MEMORY;
1535
1536         (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR1, num_entries);
1537         if ((*sam)->str == NULL)
1538                 return NT_STATUS_NO_MEMORY;
1539
1540         for (i = 0; i < num_entries ; i++) {
1541                 init_unistr2(&(*sam)->str[i].uni_acct_name,
1542                              entries[i].account_name, UNI_FLAGS_NONE);
1543                 init_unistr2(&(*sam)->str[i].uni_full_name,
1544                              entries[i].fullname, UNI_FLAGS_NONE);
1545                 init_unistr2(&(*sam)->str[i].uni_acct_desc,
1546                              entries[i].description, UNI_FLAGS_NONE);
1547
1548                 init_sam_entry1(&(*sam)->sam[i], start_idx+i+1,
1549                                 &(*sam)->str[i].uni_acct_name,
1550                                 &(*sam)->str[i].uni_full_name,
1551                                 &(*sam)->str[i].uni_acct_desc,
1552                                 entries[i].rid, entries[i].acct_flags);
1553         }
1554
1555         return NT_STATUS_OK;
1556 }
1557
1558 /*******************************************************************
1559 reads or writes a structure.
1560 ********************************************************************/
1561
1562 static BOOL sam_io_sam_dispinfo_1(const char *desc, SAM_DISPINFO_1 * sam,
1563                                   uint32 num_entries,
1564                                   prs_struct *ps, int depth)
1565 {
1566         uint32 i;
1567
1568         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_1");
1569         depth++;
1570
1571         if(!prs_align(ps))
1572                 return False;
1573
1574         if (UNMARSHALLING(ps) && num_entries > 0) {
1575
1576                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY1, num_entries)) == NULL) {
1577                         DEBUG(0, ("out of memory allocating SAM_ENTRY1\n"));
1578                         return False;
1579                 }
1580
1581                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR1, num_entries)) == NULL) {
1582                         DEBUG(0, ("out of memory allocating SAM_STR1\n"));
1583                         return False;
1584                 }
1585         }
1586
1587         for (i = 0; i < num_entries; i++) {
1588                 if(!sam_io_sam_entry1("", &sam->sam[i], ps, depth))
1589                         return False;
1590         }
1591
1592         for (i = 0; i < num_entries; i++) {
1593                 if(!sam_io_sam_str1("", &sam->str[i],
1594                               sam->sam[i].hdr_acct_name.buffer,
1595                               sam->sam[i].hdr_user_name.buffer,
1596                               sam->sam[i].hdr_user_desc.buffer, ps, depth))
1597                         return False;
1598         }
1599
1600         return True;
1601 }
1602
1603 /*******************************************************************
1604 inits a SAM_DISPINFO_2 structure.
1605 ********************************************************************/
1606
1607 NTSTATUS init_sam_dispinfo_2(TALLOC_CTX *ctx, SAM_DISPINFO_2 **sam,
1608                              uint32 num_entries, uint32 start_idx,
1609                              struct samr_displayentry *entries)
1610 {
1611         uint32 i;
1612
1613         DEBUG(10, ("init_sam_dispinfo_2: num_entries: %d\n", num_entries));
1614
1615         if (num_entries==0)
1616                 return NT_STATUS_OK;
1617
1618         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_2, num_entries);
1619         if (*sam == NULL)
1620                 return NT_STATUS_NO_MEMORY;
1621
1622         (*sam)->sam = TALLOC_ARRAY(ctx, SAM_ENTRY2, num_entries);
1623         if ((*sam)->sam == NULL)
1624                 return NT_STATUS_NO_MEMORY;
1625
1626         (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR2, num_entries);
1627         if ((*sam)->str == NULL)
1628                 return NT_STATUS_NO_MEMORY;
1629
1630         for (i = 0; i < num_entries; i++) {
1631                 init_unistr2(&(*sam)->str[i].uni_srv_name,
1632                              entries[i].account_name, UNI_FLAGS_NONE);
1633                 init_unistr2(&(*sam)->str[i].uni_srv_desc,
1634                              entries[i].description, UNI_FLAGS_NONE);
1635
1636                 init_sam_entry2(&(*sam)->sam[i], start_idx + i + 1,
1637                                 &(*sam)->str[i].uni_srv_name,
1638                                 &(*sam)->str[i].uni_srv_desc,
1639                                 entries[i].rid, entries[i].acct_flags);
1640         }
1641
1642         return NT_STATUS_OK;
1643 }
1644
1645 /*******************************************************************
1646 reads or writes a structure.
1647 ********************************************************************/
1648
1649 static BOOL sam_io_sam_dispinfo_2(const char *desc, SAM_DISPINFO_2 * sam,
1650                                   uint32 num_entries,
1651                                   prs_struct *ps, int depth)
1652 {
1653         uint32 i;
1654
1655         if (sam == NULL)
1656                 return False;
1657
1658         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_2");
1659         depth++;
1660
1661         if(!prs_align(ps))
1662                 return False;
1663
1664         if (UNMARSHALLING(ps) && num_entries > 0) {
1665
1666                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY2, num_entries)) == NULL) {
1667                         DEBUG(0, ("out of memory allocating SAM_ENTRY2\n"));
1668                         return False;
1669                 }
1670
1671                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR2, num_entries)) == NULL) {
1672                         DEBUG(0, ("out of memory allocating SAM_STR2\n"));
1673                         return False;
1674                 }
1675         }
1676
1677         for (i = 0; i < num_entries; i++) {
1678                 if(!sam_io_sam_entry2("", &sam->sam[i], ps, depth))
1679                         return False;
1680         }
1681
1682         for (i = 0; i < num_entries; i++) {
1683                 if(!sam_io_sam_str2("", &sam->str[i],
1684                               sam->sam[i].hdr_srv_name.buffer,
1685                               sam->sam[i].hdr_srv_desc.buffer, ps, depth))
1686                         return False;
1687         }
1688
1689         return True;
1690 }
1691
1692 /*******************************************************************
1693 inits a SAM_DISPINFO_3 structure.
1694 ********************************************************************/
1695
1696 NTSTATUS init_sam_dispinfo_3(TALLOC_CTX *ctx, SAM_DISPINFO_3 **sam,
1697                              uint32 num_entries, uint32 start_idx,
1698                              struct samr_displayentry *entries)
1699 {
1700         uint32 i;
1701
1702         DEBUG(5, ("init_sam_dispinfo_3: num_entries: %d\n", num_entries));
1703
1704         if (num_entries==0)
1705                 return NT_STATUS_OK;
1706
1707         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_3, num_entries);
1708         if (*sam == NULL)
1709                 return NT_STATUS_NO_MEMORY;
1710
1711         if (!((*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY3, num_entries)))
1712                 return NT_STATUS_NO_MEMORY;
1713
1714         if (!((*sam)->str=TALLOC_ARRAY(ctx, SAM_STR3, num_entries)))
1715                 return NT_STATUS_NO_MEMORY;
1716
1717         for (i = 0; i < num_entries; i++) {
1718                 DEBUG(11, ("init_sam_dispinfo_3: entry: %d\n",i));
1719
1720                 init_unistr2(&(*sam)->str[i].uni_grp_name,
1721                              entries[i].account_name, UNI_FLAGS_NONE);
1722                 init_unistr2(&(*sam)->str[i].uni_grp_desc,
1723                              entries[i].description, UNI_FLAGS_NONE);
1724
1725                 init_sam_entry3(&(*sam)->sam[i], start_idx+i+1,
1726                                 &(*sam)->str[i].uni_grp_name,
1727                                 &(*sam)->str[i].uni_grp_desc,
1728                                 entries[i].rid);
1729         }
1730
1731         return NT_STATUS_OK;
1732 }
1733
1734 /*******************************************************************
1735 reads or writes a structure.
1736 ********************************************************************/
1737
1738 static BOOL sam_io_sam_dispinfo_3(const char *desc, SAM_DISPINFO_3 * sam,
1739                                   uint32 num_entries,
1740                                   prs_struct *ps, int depth)
1741 {
1742         uint32 i;
1743
1744         if (sam == NULL)
1745                 return False;
1746
1747         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_3");
1748         depth++;
1749
1750         if(!prs_align(ps))
1751                 return False;
1752
1753         if (UNMARSHALLING(ps) && num_entries > 0) {
1754
1755                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY3, num_entries)) == NULL) {
1756                         DEBUG(0, ("out of memory allocating SAM_ENTRY3\n"));
1757                         return False;
1758                 }
1759
1760                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR3, num_entries)) == NULL) {
1761                         DEBUG(0, ("out of memory allocating SAM_STR3\n"));
1762                         return False;
1763                 }
1764         }
1765
1766         for (i = 0; i < num_entries; i++) {
1767                 if(!sam_io_sam_entry3("", &sam->sam[i], ps, depth))
1768                         return False;
1769         }
1770
1771         for (i = 0; i < num_entries; i++) {
1772                 if(!sam_io_sam_str3("", &sam->str[i],
1773                               sam->sam[i].hdr_grp_name.buffer,
1774                               sam->sam[i].hdr_grp_desc.buffer, ps, depth))
1775                         return False;
1776         }
1777
1778         return True;
1779 }
1780
1781 /*******************************************************************
1782 inits a SAM_DISPINFO_4 structure.
1783 ********************************************************************/
1784
1785 NTSTATUS init_sam_dispinfo_4(TALLOC_CTX *ctx, SAM_DISPINFO_4 **sam,
1786                              uint32 num_entries, uint32 start_idx,
1787                              struct samr_displayentry *entries)
1788 {
1789         uint32 i;
1790
1791         DEBUG(5, ("init_sam_dispinfo_4: num_entries: %d\n", num_entries));
1792
1793         if (num_entries==0)
1794                 return NT_STATUS_OK;
1795
1796         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_4, num_entries);
1797         if (*sam == NULL)
1798                 return NT_STATUS_NO_MEMORY;
1799
1800         (*sam)->sam = TALLOC_ARRAY(ctx, SAM_ENTRY4, num_entries);
1801         if ((*sam)->sam == NULL)
1802                 return NT_STATUS_NO_MEMORY;
1803
1804         (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR4, num_entries);
1805         if ((*sam)->str == NULL)
1806                 return NT_STATUS_NO_MEMORY;
1807
1808         for (i = 0; i < num_entries; i++) {
1809                 size_t len_sam_name = strlen(entries[i].account_name);
1810
1811                 DEBUG(11, ("init_sam_dispinfo_2: entry: %d\n",i));
1812           
1813                 init_sam_entry4(&(*sam)->sam[i], start_idx + i + 1,
1814                                 len_sam_name);
1815
1816                 init_string2(&(*sam)->str[i].acct_name,
1817                              entries[i].account_name, len_sam_name+1,
1818                              len_sam_name);
1819         }
1820         
1821         return NT_STATUS_OK;
1822 }
1823
1824 /*******************************************************************
1825 reads or writes a structure.
1826 ********************************************************************/
1827
1828 static BOOL sam_io_sam_dispinfo_4(const char *desc, SAM_DISPINFO_4 * sam,
1829                                   uint32 num_entries,
1830                                   prs_struct *ps, int depth)
1831 {
1832         uint32 i;
1833
1834         if (sam == NULL)
1835                 return False;
1836
1837         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_4");
1838         depth++;
1839
1840         if(!prs_align(ps))
1841                 return False;
1842
1843         if (UNMARSHALLING(ps) && num_entries > 0) {
1844
1845                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY4, num_entries)) == NULL) {
1846                         DEBUG(0, ("out of memory allocating SAM_ENTRY4\n"));
1847                         return False;
1848                 }
1849
1850                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR4, num_entries)) == NULL) {
1851                         DEBUG(0, ("out of memory allocating SAM_STR4\n"));
1852                         return False;
1853                 }
1854         }
1855
1856         for (i = 0; i < num_entries; i++) {
1857                 if(!sam_io_sam_entry4("", &sam->sam[i], ps, depth))
1858                         return False;
1859         }
1860
1861         for (i = 0; i < num_entries; i++) {
1862                 if(!smb_io_string2("acct_name", &sam->str[i].acct_name,
1863                              sam->sam[i].hdr_acct_name.buffer, ps, depth))
1864                         return False;
1865         }
1866
1867         return True;
1868 }
1869
1870 /*******************************************************************
1871 inits a SAM_DISPINFO_5 structure.
1872 ********************************************************************/
1873
1874 NTSTATUS init_sam_dispinfo_5(TALLOC_CTX *ctx, SAM_DISPINFO_5 **sam,
1875                              uint32 num_entries, uint32 start_idx,
1876                              struct samr_displayentry *entries)
1877 {
1878         uint32 len_sam_name;
1879         uint32 i;
1880
1881         DEBUG(5, ("init_sam_dispinfo_5: num_entries: %d\n", num_entries));
1882
1883         if (num_entries==0)
1884                 return NT_STATUS_OK;
1885
1886         *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_5, num_entries);
1887         if (*sam == NULL)
1888                 return NT_STATUS_NO_MEMORY;
1889
1890         if (!((*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY5, num_entries)))
1891                 return NT_STATUS_NO_MEMORY;
1892
1893         if (!((*sam)->str=TALLOC_ARRAY(ctx, SAM_STR5, num_entries)))
1894                 return NT_STATUS_NO_MEMORY;
1895
1896         for (i = 0; i < num_entries; i++) {
1897                 DEBUG(11, ("init_sam_dispinfo_5: entry: %d\n",i));
1898
1899                 len_sam_name = strlen(entries[i].account_name);
1900           
1901                 init_sam_entry5(&(*sam)->sam[i], start_idx+i+1, len_sam_name);
1902                 init_string2(&(*sam)->str[i].grp_name, entries[i].account_name,
1903                              len_sam_name+1, len_sam_name);
1904         }
1905
1906         return NT_STATUS_OK;
1907 }
1908
1909 /*******************************************************************
1910 reads or writes a structure.
1911 ********************************************************************/
1912
1913 static BOOL sam_io_sam_dispinfo_5(const char *desc, SAM_DISPINFO_5 * sam,
1914                                   uint32 num_entries,
1915                                   prs_struct *ps, int depth)
1916 {
1917         uint32 i;
1918
1919         if (sam == NULL)
1920                 return False;
1921
1922         prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_5");
1923         depth++;
1924
1925         if(!prs_align(ps))
1926                 return False;
1927
1928         if (UNMARSHALLING(ps) && num_entries > 0) {
1929
1930                 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY5, num_entries)) == NULL) {
1931                         DEBUG(0, ("out of memory allocating SAM_ENTRY5\n"));
1932                         return False;
1933                 }
1934
1935                 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR5, num_entries)) == NULL) {
1936                         DEBUG(0, ("out of memory allocating SAM_STR5\n"));
1937                         return False;
1938                 }
1939         }
1940
1941         for (i = 0; i < num_entries; i++) {
1942                 if(!sam_io_sam_entry5("", &sam->sam[i], ps, depth))
1943                         return False;
1944         }
1945
1946         for (i = 0; i < num_entries; i++) {
1947                 if(!smb_io_string2("grp_name", &sam->str[i].grp_name,
1948                              sam->sam[i].hdr_grp_name.buffer, ps, depth))
1949                         return False;
1950         }
1951
1952         return True;
1953 }
1954
1955 /*******************************************************************
1956 inits a SAMR_R_QUERY_DISPINFO structure.
1957 ********************************************************************/
1958
1959 void init_samr_r_query_dispinfo(SAMR_R_QUERY_DISPINFO * r_u,
1960                                 uint32 num_entries, uint32 total_size, uint32 data_size,
1961                                 uint16 switch_level, SAM_DISPINFO_CTR * ctr,
1962                                 NTSTATUS status)
1963 {
1964         DEBUG(5, ("init_samr_r_query_dispinfo: level %d\n", switch_level));
1965
1966         r_u->total_size = total_size;
1967
1968         r_u->data_size = data_size;
1969
1970         r_u->switch_level = switch_level;
1971         r_u->num_entries = num_entries;
1972
1973         if (num_entries==0)
1974                 r_u->ptr_entries = 0;
1975         else
1976                 r_u->ptr_entries = 1;
1977
1978         r_u->num_entries2 = num_entries;
1979         r_u->ctr = ctr;
1980
1981         r_u->status = status;
1982 }
1983
1984 /*******************************************************************
1985 reads or writes a structure.
1986 ********************************************************************/
1987
1988 BOOL samr_io_r_query_dispinfo(const char *desc, SAMR_R_QUERY_DISPINFO * r_u,
1989                               prs_struct *ps, int depth)
1990 {
1991         if (r_u == NULL)
1992                 return False;
1993
1994         prs_debug(ps, depth, desc, "samr_io_r_query_dispinfo");
1995         depth++;
1996
1997         if(!prs_align(ps))
1998                 return False;
1999
2000         if(!prs_uint32("total_size  ", ps, depth, &r_u->total_size))
2001                 return False;
2002         if(!prs_uint32("data_size   ", ps, depth, &r_u->data_size))
2003                 return False;
2004         if(!prs_uint16("switch_level", ps, depth, &r_u->switch_level))
2005                 return False;
2006         if(!prs_align(ps))
2007                 return False;
2008
2009         if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
2010                 return False;
2011         if(!prs_uint32("ptr_entries ", ps, depth, &r_u->ptr_entries))
2012                 return False;
2013
2014         if (r_u->ptr_entries==0) {
2015                 if(!prs_align(ps))
2016                         return False;
2017                 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2018                         return False;
2019
2020                 return True;
2021         }
2022
2023         if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
2024                 return False;
2025
2026         switch (r_u->switch_level) {
2027         case 0x1:
2028                 if(!sam_io_sam_dispinfo_1("users", r_u->ctr->sam.info1,
2029                                 r_u->num_entries, ps, depth))
2030                         return False;
2031                 break;
2032         case 0x2:
2033                 if(!sam_io_sam_dispinfo_2("servers", r_u->ctr->sam.info2,
2034                                 r_u->num_entries, ps, depth))
2035                         return False;
2036                 break;
2037         case 0x3:
2038                 if(!sam_io_sam_dispinfo_3("groups", r_u->ctr->sam.info3,
2039                                     r_u->num_entries, ps, depth))
2040                         return False;
2041                 break;
2042         case 0x4:
2043                 if(!sam_io_sam_dispinfo_4("user list",
2044                                     r_u->ctr->sam.info4,
2045                                     r_u->num_entries, ps, depth))
2046                         return False;
2047                 break;
2048         case 0x5:
2049                 if(!sam_io_sam_dispinfo_5("group list",
2050                                     r_u->ctr->sam.info5,
2051                                     r_u->num_entries, ps, depth))
2052                         return False;
2053                 break;
2054         default:
2055                 DEBUG(0,("samr_io_r_query_dispinfo: unknown switch value\n"));
2056                 break;
2057         }
2058         
2059         if(!prs_align(ps))
2060                 return False;
2061         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2062                 return False;
2063
2064         return True;
2065 }
2066
2067 /*******************************************************************
2068 inits a SAMR_Q_OPEN_GROUP structure.
2069 ********************************************************************/
2070
2071 void init_samr_q_open_group(SAMR_Q_OPEN_GROUP * q_c,
2072                             POLICY_HND *hnd,
2073                             uint32 access_mask, uint32 rid)
2074 {
2075         DEBUG(5, ("init_samr_q_open_group\n"));
2076
2077         q_c->domain_pol = *hnd;
2078         q_c->access_mask = access_mask;
2079         q_c->rid_group = rid;
2080 }
2081
2082 /*******************************************************************
2083 reads or writes a structure.
2084 ********************************************************************/
2085
2086 BOOL samr_io_q_open_group(const char *desc, SAMR_Q_OPEN_GROUP * q_u,
2087                           prs_struct *ps, int depth)
2088 {
2089         if (q_u == NULL)
2090                 return False;
2091
2092         prs_debug(ps, depth, desc, "samr_io_q_open_group");
2093         depth++;
2094
2095         if(!prs_align(ps))
2096                 return False;
2097
2098         if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
2099                 return False;
2100
2101         if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
2102                 return False;
2103         if(!prs_uint32("rid_group", ps, depth, &q_u->rid_group))
2104                 return False;
2105
2106         return True;
2107 }
2108
2109 /*******************************************************************
2110 reads or writes a structure.
2111 ********************************************************************/
2112
2113 BOOL samr_io_r_open_group(const char *desc, SAMR_R_OPEN_GROUP * r_u,
2114                           prs_struct *ps, int depth)
2115 {
2116         if (r_u == NULL)
2117                 return False;
2118
2119         prs_debug(ps, depth, desc, "samr_io_r_open_group");
2120         depth++;
2121
2122         if(!prs_align(ps))
2123                 return False;
2124
2125         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2126                 return False;
2127
2128         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2129                 return False;
2130
2131         return True;
2132 }
2133
2134 /*******************************************************************
2135 inits a GROUP_INFO1 structure.
2136 ********************************************************************/
2137
2138 void init_samr_group_info1(GROUP_INFO1 * gr1,
2139                            char *acct_name, char *acct_desc,
2140                            uint32 num_members)
2141 {
2142         DEBUG(5, ("init_samr_group_info1\n"));
2143
2144         gr1->group_attr = (SE_GROUP_MANDATORY|SE_GROUP_ENABLED_BY_DEFAULT); /* why not | SE_GROUP_ENABLED ? */
2145         gr1->num_members = num_members;
2146
2147         init_unistr2(&gr1->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2148         init_uni_hdr(&gr1->hdr_acct_name, &gr1->uni_acct_name);
2149         init_unistr2(&gr1->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2150         init_uni_hdr(&gr1->hdr_acct_desc, &gr1->uni_acct_desc);
2151 }
2152
2153 /*******************************************************************
2154 reads or writes a structure.
2155 ********************************************************************/
2156
2157 BOOL samr_io_group_info1(const char *desc, GROUP_INFO1 * gr1,
2158                          prs_struct *ps, int depth)
2159 {
2160         uint16 dummy = 1;
2161
2162         if (gr1 == NULL)
2163                 return False;
2164
2165         prs_debug(ps, depth, desc, "samr_io_group_info1");
2166         depth++;
2167
2168         if(!prs_uint16("level", ps, depth, &dummy))
2169                 return False;
2170
2171         if(!prs_align(ps))
2172                 return False;
2173
2174         if(!smb_io_unihdr("hdr_acct_name", &gr1->hdr_acct_name, ps, depth))
2175                 return False;
2176
2177         if(!prs_uint32("group_attr", ps, depth, &gr1->group_attr))
2178                 return False;
2179         if(!prs_uint32("num_members", ps, depth, &gr1->num_members))
2180                 return False;
2181
2182         if(!smb_io_unihdr("hdr_acct_desc", &gr1->hdr_acct_desc, ps, depth))
2183                 return False;
2184
2185         if(!smb_io_unistr2("uni_acct_name", &gr1->uni_acct_name,
2186                            gr1->hdr_acct_name.buffer, ps, depth))
2187                 return False;
2188
2189         if(!smb_io_unistr2("uni_acct_desc", &gr1->uni_acct_desc,
2190                            gr1->hdr_acct_desc.buffer, ps, depth))
2191                 return False;
2192
2193         return True;
2194 }
2195
2196 /*******************************************************************
2197 inits a GROUP_INFO2 structure.
2198 ********************************************************************/
2199
2200 void init_samr_group_info2(GROUP_INFO2 * gr2, const char *acct_name)
2201 {
2202         DEBUG(5, ("init_samr_group_info2\n"));
2203
2204         gr2->level = 2;
2205         init_unistr2(&gr2->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2206         init_uni_hdr(&gr2->hdr_acct_name, &gr2->uni_acct_name);
2207 }
2208
2209 /*******************************************************************
2210 reads or writes a structure.
2211 ********************************************************************/
2212
2213 BOOL samr_io_group_info2(const char *desc, GROUP_INFO2 *gr2, prs_struct *ps, int depth)
2214 {
2215         if (gr2 == NULL)
2216                 return False;
2217
2218         prs_debug(ps, depth, desc, "samr_io_group_info2");
2219         depth++;
2220
2221         if(!prs_uint16("hdr_level", ps, depth, &gr2->level))
2222                 return False;
2223
2224         if(!smb_io_unihdr("hdr_acct_name", &gr2->hdr_acct_name, ps, depth))
2225                 return False;
2226         if(!smb_io_unistr2("uni_acct_name", &gr2->uni_acct_name,
2227                            gr2->hdr_acct_name.buffer, ps, depth))
2228                 return False;
2229
2230         return True;
2231 }
2232
2233 /*******************************************************************
2234 inits a GROUP_INFO3 structure.
2235 ********************************************************************/
2236
2237 void init_samr_group_info3(GROUP_INFO3 *gr3)
2238 {
2239         DEBUG(5, ("init_samr_group_info3\n"));
2240
2241         gr3->group_attr = (SE_GROUP_MANDATORY|SE_GROUP_ENABLED_BY_DEFAULT); /* why not | SE_GROUP_ENABLED ? */
2242 }
2243
2244 /*******************************************************************
2245 reads or writes a structure.
2246 ********************************************************************/
2247
2248 BOOL samr_io_group_info3(const char *desc, GROUP_INFO3 *gr3, prs_struct *ps, int depth)
2249 {
2250         if (gr3 == NULL)
2251                 return False;
2252
2253         prs_debug(ps, depth, desc, "samr_io_group_info3");
2254         depth++;
2255
2256         if(!prs_align(ps))
2257                 return False;
2258
2259         if(!prs_uint32("group_attr", ps, depth, &gr3->group_attr))
2260                 return False;
2261
2262         return True;
2263 }
2264
2265 /*******************************************************************
2266 inits a GROUP_INFO4 structure.
2267 ********************************************************************/
2268
2269 void init_samr_group_info4(GROUP_INFO4 * gr4, const char *acct_desc)
2270 {
2271         DEBUG(5, ("init_samr_group_info4\n"));
2272
2273         gr4->level = 4;
2274         init_unistr2(&gr4->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2275         init_uni_hdr(&gr4->hdr_acct_desc, &gr4->uni_acct_desc);
2276 }
2277
2278 /*******************************************************************
2279 reads or writes a structure.
2280 ********************************************************************/
2281
2282 BOOL samr_io_group_info4(const char *desc, GROUP_INFO4 * gr4,
2283                          prs_struct *ps, int depth)
2284 {
2285         if (gr4 == NULL)
2286                 return False;
2287
2288         prs_debug(ps, depth, desc, "samr_io_group_info4");
2289         depth++;
2290
2291         if(!prs_uint16("hdr_level", ps, depth, &gr4->level))
2292                 return False;
2293         if(!smb_io_unihdr("hdr_acct_desc", &gr4->hdr_acct_desc, ps, depth))
2294                 return False;
2295         if(!smb_io_unistr2("uni_acct_desc", &gr4->uni_acct_desc,
2296                            gr4->hdr_acct_desc.buffer, ps, depth))
2297                 return False;
2298
2299         return True;
2300 }
2301
2302 /*******************************************************************
2303 reads or writes a structure.
2304 ********************************************************************/
2305
2306 static BOOL samr_group_info_ctr(const char *desc, GROUP_INFO_CTR **ctr,
2307                                 prs_struct *ps, int depth)
2308 {
2309         if (UNMARSHALLING(ps))
2310                 *ctr = PRS_ALLOC_MEM(ps,GROUP_INFO_CTR,1);
2311
2312         if (*ctr == NULL)
2313                 return False;
2314
2315         prs_debug(ps, depth, desc, "samr_group_info_ctr");
2316         depth++;
2317
2318         if(!prs_uint16("switch_value1", ps, depth, &(*ctr)->switch_value1))
2319                 return False;
2320
2321         switch ((*ctr)->switch_value1) {
2322         case 1:
2323                 if(!samr_io_group_info1("group_info1", &(*ctr)->group.info1, ps, depth))
2324                         return False;
2325                 break;
2326         case 2:
2327                 if(!samr_io_group_info2("group_info2", &(*ctr)->group.info2, ps, depth))
2328                         return False;
2329                 break;
2330         case 3:
2331                 if(!samr_io_group_info3("group_info3", &(*ctr)->group.info3, ps, depth))
2332                         return False;
2333                 break;
2334         case 4:
2335                 if(!samr_io_group_info4("group_info4", &(*ctr)->group.info4, ps, depth))
2336                         return False;
2337                 break;
2338         default:
2339                 DEBUG(0,("samr_group_info_ctr: unsupported switch level\n"));
2340                 break;
2341         }
2342
2343         return True;
2344 }
2345
2346 /*******************************************************************
2347 inits a SAMR_Q_CREATE_DOM_GROUP structure.
2348 ********************************************************************/
2349
2350 void init_samr_q_create_dom_group(SAMR_Q_CREATE_DOM_GROUP * q_e,
2351                                   POLICY_HND *pol, const char *acct_desc,
2352                                   uint32 access_mask)
2353 {
2354         DEBUG(5, ("init_samr_q_create_dom_group\n"));
2355
2356         q_e->pol = *pol;
2357
2358         init_unistr2(&q_e->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2359         init_uni_hdr(&q_e->hdr_acct_desc, &q_e->uni_acct_desc);
2360
2361         q_e->access_mask = access_mask;
2362 }
2363
2364 /*******************************************************************
2365 reads or writes a structure.
2366 ********************************************************************/
2367
2368 BOOL samr_io_q_create_dom_group(const char *desc, SAMR_Q_CREATE_DOM_GROUP * q_e,
2369                                 prs_struct *ps, int depth)
2370 {
2371         if (q_e == NULL)
2372                 return False;
2373
2374         prs_debug(ps, depth, desc, "samr_io_q_create_dom_group");
2375         depth++;
2376
2377         if(!prs_align(ps))
2378                 return False;
2379
2380         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2381                 return False;
2382
2383         if(!smb_io_unihdr("hdr_acct_desc", &q_e->hdr_acct_desc, ps, depth))
2384                 return False;
2385         if(!smb_io_unistr2("uni_acct_desc", &q_e->uni_acct_desc,
2386                        q_e->hdr_acct_desc.buffer, ps, depth))
2387                 return False;
2388
2389         if(!prs_align(ps))
2390                 return False;
2391         if(!prs_uint32("access", ps, depth, &q_e->access_mask))
2392                 return False;
2393
2394         return True;
2395 }
2396
2397 /*******************************************************************
2398 reads or writes a structure.
2399 ********************************************************************/
2400
2401 BOOL samr_io_r_create_dom_group(const char *desc, SAMR_R_CREATE_DOM_GROUP * r_u,
2402                                 prs_struct *ps, int depth)
2403 {
2404         if (r_u == NULL)
2405                 return False;
2406
2407         prs_debug(ps, depth, desc, "samr_io_r_create_dom_group");
2408         depth++;
2409
2410         if(!prs_align(ps))
2411                 return False;
2412
2413         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2414                 return False;
2415
2416         if(!prs_uint32("rid   ", ps, depth, &r_u->rid))
2417                 return False;
2418         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2419                 return False;
2420
2421         return True;
2422 }
2423
2424 /*******************************************************************
2425 inits a SAMR_Q_DELETE_DOM_GROUP structure.
2426 ********************************************************************/
2427
2428 void init_samr_q_delete_dom_group(SAMR_Q_DELETE_DOM_GROUP * q_c,
2429                                   POLICY_HND *hnd)
2430 {
2431         DEBUG(5, ("init_samr_q_delete_dom_group\n"));
2432
2433         q_c->group_pol = *hnd;
2434 }
2435
2436 /*******************************************************************
2437 reads or writes a structure.
2438 ********************************************************************/
2439
2440 BOOL samr_io_q_delete_dom_group(const char *desc, SAMR_Q_DELETE_DOM_GROUP * q_u,
2441                                 prs_struct *ps, int depth)
2442 {
2443         if (q_u == NULL)
2444                 return False;
2445
2446         prs_debug(ps, depth, desc, "samr_io_q_delete_dom_group");
2447         depth++;
2448
2449         if(!prs_align(ps))
2450                 return False;
2451
2452         if(!smb_io_pol_hnd("group_pol", &q_u->group_pol, ps, depth))
2453                 return False;
2454
2455         return True;
2456 }
2457
2458 /*******************************************************************
2459 reads or writes a structure.
2460 ********************************************************************/
2461
2462 BOOL samr_io_r_delete_dom_group(const char *desc, SAMR_R_DELETE_DOM_GROUP * r_u,
2463                                 prs_struct *ps, int depth)
2464 {
2465         if (r_u == NULL)
2466                 return False;
2467
2468         prs_debug(ps, depth, desc, "samr_io_r_delete_dom_group");
2469         depth++;
2470
2471         if(!prs_align(ps))
2472                 return False;
2473
2474         if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2475                 return False;
2476
2477         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2478                 return False;
2479
2480         return True;
2481 }
2482
2483 /*******************************************************************
2484 inits a SAMR_Q_DEL_GROUPMEM structure.
2485 ********************************************************************/
2486
2487 void init_samr_q_del_groupmem(SAMR_Q_DEL_GROUPMEM * q_e,
2488                               POLICY_HND *pol, uint32 rid)
2489 {
2490         DEBUG(5, ("init_samr_q_del_groupmem\n"));
2491
2492         q_e->pol = *pol;
2493         q_e->rid = rid;
2494 }
2495
2496 /*******************************************************************
2497 reads or writes a structure.
2498 ********************************************************************/
2499
2500 BOOL samr_io_q_del_groupmem(const char *desc, SAMR_Q_DEL_GROUPMEM * q_e,
2501                             prs_struct *ps, int depth)
2502 {
2503         if (q_e == NULL)
2504                 return False;
2505
2506         prs_debug(ps, depth, desc, "samr_io_q_del_groupmem");
2507         depth++;
2508
2509         if(!prs_align(ps))
2510                 return False;
2511
2512         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2513                 return False;
2514
2515         if(!prs_uint32("rid", ps, depth, &q_e->rid))
2516                 return False;
2517
2518         return True;
2519 }
2520
2521 /*******************************************************************
2522 inits a SAMR_R_DEL_GROUPMEM structure.
2523 ********************************************************************/
2524
2525 void init_samr_r_del_groupmem(SAMR_R_DEL_GROUPMEM * r_u, POLICY_HND *pol,
2526                               NTSTATUS status)
2527 {
2528         DEBUG(5, ("init_samr_r_del_groupmem\n"));
2529
2530         r_u->status = status;
2531 }
2532
2533 /*******************************************************************
2534 reads or writes a structure.
2535 ********************************************************************/
2536
2537 BOOL samr_io_r_del_groupmem(const char *desc, SAMR_R_DEL_GROUPMEM * r_u,
2538                             prs_struct *ps, int depth)
2539 {
2540         if (r_u == NULL)
2541                 return False;
2542
2543         prs_debug(ps, depth, desc, "samr_io_r_del_groupmem");
2544         depth++;
2545
2546         if(!prs_align(ps))
2547                 return False;
2548
2549         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2550                 return False;
2551
2552         return True;
2553 }
2554
2555 /*******************************************************************
2556 inits a SAMR_Q_ADD_GROUPMEM structure.
2557 ********************************************************************/
2558
2559 void init_samr_q_add_groupmem(SAMR_Q_ADD_GROUPMEM * q_e,
2560                               POLICY_HND *pol, uint32 rid)
2561 {
2562         DEBUG(5, ("init_samr_q_add_groupmem\n"));
2563
2564         q_e->pol = *pol;
2565         q_e->rid = rid;
2566         q_e->unknown = 0x0005;
2567 }
2568
2569 /*******************************************************************
2570 reads or writes a structure.
2571 ********************************************************************/
2572
2573 BOOL samr_io_q_add_groupmem(const char *desc, SAMR_Q_ADD_GROUPMEM * q_e,
2574                             prs_struct *ps, int depth)
2575 {
2576         if (q_e == NULL)
2577                 return False;
2578
2579         prs_debug(ps, depth, desc, "samr_io_q_add_groupmem");
2580         depth++;
2581
2582         if(!prs_align(ps))
2583                 return False;
2584
2585         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2586                 return False;
2587
2588         if(!prs_uint32("rid    ", ps, depth, &q_e->rid))
2589                 return False;
2590         if(!prs_uint32("unknown", ps, depth, &q_e->unknown))
2591                 return False;
2592
2593         return True;
2594 }
2595
2596 /*******************************************************************
2597 inits a SAMR_R_ADD_GROUPMEM structure.
2598 ********************************************************************/
2599
2600 void init_samr_r_add_groupmem(SAMR_R_ADD_GROUPMEM * r_u, POLICY_HND *pol,
2601                               NTSTATUS status)
2602 {
2603         DEBUG(5, ("init_samr_r_add_groupmem\n"));
2604
2605         r_u->status = status;
2606 }
2607
2608 /*******************************************************************
2609 reads or writes a structure.
2610 ********************************************************************/
2611
2612 BOOL samr_io_r_add_groupmem(const char *desc, SAMR_R_ADD_GROUPMEM * r_u,
2613                             prs_struct *ps, int depth)
2614 {
2615         if (r_u == NULL)
2616                 return False;
2617
2618         prs_debug(ps, depth, desc, "samr_io_r_add_groupmem");
2619         depth++;
2620
2621         if(!prs_align(ps))
2622                 return False;
2623
2624         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2625                 return False;
2626
2627         return True;
2628 }
2629
2630 /*******************************************************************
2631 inits a SAMR_Q_SET_GROUPINFO structure.
2632 ********************************************************************/
2633
2634 void init_samr_q_set_groupinfo(SAMR_Q_SET_GROUPINFO * q_e,
2635                                POLICY_HND *pol, GROUP_INFO_CTR * ctr)
2636 {
2637         DEBUG(5, ("init_samr_q_set_groupinfo\n"));
2638
2639         q_e->pol = *pol;
2640         q_e->ctr = ctr;
2641 }
2642
2643 /*******************************************************************
2644 reads or writes a structure.
2645 ********************************************************************/
2646
2647 BOOL samr_io_q_set_groupinfo(const char *desc, SAMR_Q_SET_GROUPINFO * q_e,
2648                              prs_struct *ps, int depth)
2649 {
2650         if (q_e == NULL)
2651                 return False;
2652
2653         prs_debug(ps, depth, desc, "samr_io_q_set_groupinfo");
2654         depth++;
2655
2656         if(!prs_align(ps))
2657                 return False;
2658
2659         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2660                 return False;
2661         
2662         if(!samr_group_info_ctr("ctr", &q_e->ctr, ps, depth))
2663                 return False;
2664
2665         return True;
2666 }
2667
2668 /*******************************************************************
2669 inits a SAMR_R_SET_GROUPINFO structure.
2670 ********************************************************************/
2671
2672 void init_samr_r_set_groupinfo(SAMR_R_SET_GROUPINFO * r_u, NTSTATUS status)
2673 {
2674         DEBUG(5, ("init_samr_r_set_groupinfo\n"));
2675
2676         r_u->status = status;
2677 }
2678
2679 /*******************************************************************
2680 reads or writes a structure.
2681 ********************************************************************/
2682
2683 BOOL samr_io_r_set_groupinfo(const char *desc, SAMR_R_SET_GROUPINFO * r_u,
2684                              prs_struct *ps, int depth)
2685 {
2686         if (r_u == NULL)
2687                 return False;
2688
2689         prs_debug(ps, depth, desc, "samr_io_r_set_groupinfo");
2690         depth++;
2691
2692         if(!prs_align(ps))
2693                 return False;
2694
2695         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2696                 return False;
2697
2698         return True;
2699 }
2700
2701 /*******************************************************************
2702 inits a SAMR_Q_QUERY_GROUPINFO structure.
2703 ********************************************************************/
2704
2705 void init_samr_q_query_groupinfo(SAMR_Q_QUERY_GROUPINFO * q_e,
2706                                  POLICY_HND *pol, uint16 switch_level)
2707 {
2708         DEBUG(5, ("init_samr_q_query_groupinfo\n"));
2709
2710         q_e->pol = *pol;
2711
2712         q_e->switch_level = switch_level;
2713 }
2714
2715 /*******************************************************************
2716 reads or writes a structure.
2717 ********************************************************************/
2718
2719 BOOL samr_io_q_query_groupinfo(const char *desc, SAMR_Q_QUERY_GROUPINFO * q_e,
2720                                prs_struct *ps, int depth)
2721 {
2722         if (q_e == NULL)
2723                 return False;
2724
2725         prs_debug(ps, depth, desc, "samr_io_q_query_groupinfo");
2726         depth++;
2727
2728         if(!prs_align(ps))
2729                 return False;
2730
2731         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2732                 return False;
2733
2734         if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
2735                 return False;
2736
2737         return True;
2738 }
2739
2740 /*******************************************************************
2741 inits a SAMR_R_QUERY_GROUPINFO structure.
2742 ********************************************************************/
2743
2744 void init_samr_r_query_groupinfo(SAMR_R_QUERY_GROUPINFO * r_u,
2745                                  GROUP_INFO_CTR * ctr, NTSTATUS status)
2746 {
2747         DEBUG(5, ("init_samr_r_query_groupinfo\n"));
2748
2749         r_u->ptr = (NT_STATUS_IS_OK(status) && ctr != NULL) ? 1 : 0;
2750         r_u->ctr = ctr;
2751         r_u->status = status;
2752 }
2753
2754 /*******************************************************************
2755 reads or writes a structure.
2756 ********************************************************************/
2757
2758 BOOL samr_io_r_query_groupinfo(const char *desc, SAMR_R_QUERY_GROUPINFO * r_u,
2759                                prs_struct *ps, int depth)
2760 {
2761         if (r_u == NULL)
2762                 return False;
2763
2764         prs_debug(ps, depth, desc, "samr_io_r_query_groupinfo");
2765         depth++;
2766
2767         if(!prs_align(ps))
2768                 return False;
2769
2770         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
2771                 return False;
2772
2773         if (r_u->ptr != 0) {
2774                 if(!samr_group_info_ctr("ctr", &r_u->ctr, ps, depth))
2775                         return False;
2776         }
2777
2778         if(!prs_align(ps))
2779                 return False;
2780         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2781                 return False;
2782
2783         return True;
2784 }
2785
2786 /*******************************************************************
2787 inits a SAMR_Q_QUERY_GROUPMEM structure.
2788 ********************************************************************/
2789
2790 void init_samr_q_query_groupmem(SAMR_Q_QUERY_GROUPMEM * q_c, POLICY_HND *hnd)
2791 {
2792         DEBUG(5, ("init_samr_q_query_groupmem\n"));
2793
2794         q_c->group_pol = *hnd;
2795 }
2796
2797 /*******************************************************************
2798 reads or writes a structure.
2799 ********************************************************************/
2800
2801 BOOL samr_io_q_query_groupmem(const char *desc, SAMR_Q_QUERY_GROUPMEM * q_u,
2802                               prs_struct *ps, int depth)
2803 {
2804         if (q_u == NULL)
2805                 return False;
2806
2807         prs_debug(ps, depth, desc, "samr_io_q_query_groupmem");
2808         depth++;
2809
2810         if(!prs_align(ps))
2811                 return False;
2812
2813         if(!smb_io_pol_hnd("group_pol", &q_u->group_pol, ps, depth))
2814                 return False;
2815
2816         return True;
2817 }
2818
2819 /*******************************************************************
2820 inits a SAMR_R_QUERY_GROUPMEM structure.
2821 ********************************************************************/
2822
2823 void init_samr_r_query_groupmem(SAMR_R_QUERY_GROUPMEM * r_u,
2824                                 uint32 num_entries, uint32 *rid,
2825                                 uint32 *attr, NTSTATUS status)
2826 {
2827         DEBUG(5, ("init_samr_r_query_groupmem\n"));
2828
2829         if (NT_STATUS_IS_OK(status)) {
2830                 r_u->ptr = 1;
2831                 r_u->num_entries = num_entries;
2832
2833                 r_u->ptr_attrs = attr != NULL ? 1 : 0;
2834                 r_u->ptr_rids = rid != NULL ? 1 : 0;
2835
2836                 r_u->num_rids = num_entries;
2837                 r_u->rid = rid;
2838
2839                 r_u->num_attrs = num_entries;
2840                 r_u->attr = attr;
2841         } else {
2842                 r_u->ptr = 0;
2843                 r_u->num_entries = 0;
2844         }
2845
2846         r_u->status = status;
2847 }
2848
2849 /*******************************************************************
2850 reads or writes a structure.
2851 ********************************************************************/
2852
2853 BOOL samr_io_r_query_groupmem(const char *desc, SAMR_R_QUERY_GROUPMEM * r_u,
2854                               prs_struct *ps, int depth)
2855 {
2856         uint32 i;
2857
2858         if (r_u == NULL)
2859                 return False;
2860
2861         if (UNMARSHALLING(ps))
2862                 ZERO_STRUCTP(r_u);
2863
2864         prs_debug(ps, depth, desc, "samr_io_r_query_groupmem");
2865         depth++;
2866
2867         if(!prs_align(ps))
2868                 return False;
2869
2870         if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
2871                 return False;
2872         if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
2873                 return False;
2874
2875         if (r_u->ptr != 0) {
2876                 if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids))
2877                         return False;
2878                 if(!prs_uint32("ptr_attrs", ps, depth, &r_u->ptr_attrs))
2879                         return False;
2880
2881                 if (r_u->ptr_rids != 0) {
2882                         if(!prs_uint32("num_rids", ps, depth, &r_u->num_rids))
2883                                 return False;
2884                         if (UNMARSHALLING(ps) && r_u->num_rids != 0) {
2885                                 r_u->rid = PRS_ALLOC_MEM(ps,uint32,r_u->num_rids);
2886                                 if (r_u->rid == NULL)
2887                                         return False;
2888                         }
2889
2890                         for (i = 0; i < r_u->num_rids; i++) {
2891                                 if(!prs_uint32("", ps, depth, &r_u->rid[i]))
2892                                         return False;
2893                         }
2894                 }
2895
2896                 if (r_u->ptr_attrs != 0) {
2897                         if(!prs_uint32("num_attrs", ps, depth, &r_u->num_attrs))
2898                                 return False;
2899
2900                         if (UNMARSHALLING(ps) && r_u->num_attrs != 0) {
2901                                 r_u->attr = PRS_ALLOC_MEM(ps,uint32,r_u->num_attrs);
2902                                 if (r_u->attr == NULL)
2903                                         return False;
2904                         }
2905
2906                         for (i = 0; i < r_u->num_attrs; i++) {
2907                                 if(!prs_uint32("", ps, depth, &r_u->attr[i]))
2908                                         return False;
2909                         }
2910                 }
2911         }
2912
2913         if(!prs_ntstatus("status", ps, depth, &r_u->status))
2914                 return False;
2915
2916         return True;
2917 }
2918
2919 /*******************************************************************
2920 inits a SAMR_Q_QUERY_USERGROUPS structure.
2921 ********************************************************************/
2922
2923 void init_samr_q_query_usergroups(SAMR_Q_QUERY_USERGROUPS * q_u,
2924                                   POLICY_HND *hnd)
2925 {
2926         DEBUG(5, ("init_samr_q_query_usergroups\n"));
2927
2928         q_u->pol = *hnd;
2929 }
2930
2931 /*******************************************************************
2932 reads or writes a structure.
2933 ********************************************************************/
2934
2935 BOOL samr_io_q_query_usergroups(const char *desc, SAMR_Q_QUERY_USERGROUPS * q_u,
2936                                 prs_struct *ps, int depth)
2937 {
2938         if (q_u == NULL)
2939                 return False;
2940
2941         prs_debug(ps, depth, desc, "samr_io_q_query_usergroups");
2942         depth++;
2943
2944         if(!prs_align(ps))
2945                 return False;
2946
2947         if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
2948                 return False;
2949
2950         return True;
2951 }
2952
2953 /*******************************************************************
2954 inits a SAMR_R_QUERY_USERGROUPS structure.
2955 ********************************************************************/
2956
2957 void init_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS * r_u,
2958                                   uint32 num_gids, DOM_GID * gid,
2959                                   NTSTATUS status)
2960 {
2961         DEBUG(5, ("init_samr_r_query_usergroups\n"));
2962
2963         if (NT_STATUS_IS_OK(status)) {
2964                 r_u->ptr_0 = 1;
2965                 r_u->num_entries = num_gids;
2966                 r_u->ptr_1 = (num_gids != 0) ? 1 : 0;
2967                 r_u->num_entries2 = num_gids;
2968
2969                 r_u->gid = gid;
2970         } else {
2971                 r_u->ptr_0 = 0;
2972                 r_u->num_entries = 0;
2973                 r_u->ptr_1 = 0;
2974                 r_u->gid = NULL;
2975         }
2976
2977         r_u->status = status;
2978 }
2979
2980 /*******************************************************************
2981 reads or writes a structure.
2982 ********************************************************************/
2983
2984 BOOL samr_io_gids(const char *desc, uint32 *num_gids, DOM_GID ** gid,
2985                   prs_struct *ps, int depth)
2986 {
2987         uint32 i;
2988         if (gid == NULL)
2989                 return False;
2990
2991         prs_debug(ps, depth, desc, "samr_io_gids");
2992         depth++;
2993
2994         if(!prs_align(ps))
2995                 return False;
2996
2997         if(!prs_uint32("num_gids", ps, depth, num_gids))
2998                 return False;
2999
3000         if ((*num_gids) != 0) {
3001                 if (UNMARSHALLING(ps)) {
3002                         (*gid) = PRS_ALLOC_MEM(ps,DOM_GID,*num_gids);
3003                 }
3004
3005                 if ((*gid) == NULL) {
3006                         return False;
3007                 }
3008
3009                 for (i = 0; i < (*num_gids); i++) {
3010                         if(!smb_io_gid("gids", &(*gid)[i], ps, depth))
3011                                 return False;
3012                 }
3013         }
3014
3015         return True;
3016 }
3017
3018 /*******************************************************************
3019 reads or writes a structure.
3020 ********************************************************************/
3021
3022 BOOL samr_io_r_query_usergroups(const char *desc, SAMR_R_QUERY_USERGROUPS * r_u,
3023                                 prs_struct *ps, int depth)
3024 {
3025         if (r_u == NULL)
3026                 return False;
3027
3028         prs_debug(ps, depth, desc, "samr_io_r_query_usergroups");
3029         depth++;
3030
3031         if(!prs_align(ps))
3032                 return False;
3033
3034         if(!prs_uint32("ptr_0       ", ps, depth, &r_u->ptr_0))
3035                 return False;
3036
3037         if (r_u->ptr_0 != 0) {
3038                 if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
3039                         return False;
3040                 if(!prs_uint32("ptr_1       ", ps, depth, &r_u->ptr_1))
3041                         return False;
3042
3043                 if (r_u->num_entries != 0 && r_u->ptr_1 != 0) {
3044                         if(!samr_io_gids("gids", &r_u->num_entries2, &r_u->gid, ps, depth))
3045                                 return False;
3046                 }
3047         }
3048
3049         if(!prs_align(ps))
3050                 return False;
3051         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3052           return False;
3053
3054         return True;
3055 }
3056
3057 /*******************************************************************
3058 inits a SAMR_Q_ENUM_DOMAINS structure.
3059 ********************************************************************/
3060
3061 void init_samr_q_enum_domains(SAMR_Q_ENUM_DOMAINS * q_e,
3062                               POLICY_HND *pol,
3063                               uint32 start_idx, uint32 size)
3064 {
3065         DEBUG(5, ("init_samr_q_enum_domains\n"));
3066
3067         q_e->pol = *pol;
3068
3069         q_e->start_idx = start_idx;
3070         q_e->max_size = size;
3071 }
3072
3073 /*******************************************************************
3074 reads or writes a structure.
3075 ********************************************************************/
3076
3077 BOOL samr_io_q_enum_domains(const char *desc, SAMR_Q_ENUM_DOMAINS * q_e,
3078                             prs_struct *ps, int depth)
3079 {
3080         if (q_e == NULL)
3081                 return False;
3082
3083         prs_debug(ps, depth, desc, "samr_io_q_enum_domains");
3084         depth++;
3085
3086         if(!prs_align(ps))
3087                 return False;
3088
3089         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
3090                 return False;
3091
3092         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3093                 return False;
3094         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3095                 return False;
3096
3097         return True;
3098 }
3099
3100 /*******************************************************************
3101 inits a SAMR_R_ENUM_DOMAINS structure.
3102 ********************************************************************/
3103
3104 void init_samr_r_enum_domains(SAMR_R_ENUM_DOMAINS * r_u,
3105                               uint32 next_idx, uint32 num_sam_entries)
3106 {
3107         DEBUG(5, ("init_samr_r_enum_domains\n"));
3108
3109         r_u->next_idx = next_idx;
3110
3111         if (num_sam_entries != 0) {
3112                 r_u->ptr_entries1 = 1;
3113                 r_u->ptr_entries2 = 1;
3114                 r_u->num_entries2 = num_sam_entries;
3115                 r_u->num_entries3 = num_sam_entries;
3116
3117                 r_u->num_entries4 = num_sam_entries;
3118         } else {
3119                 r_u->ptr_entries1 = 0;
3120                 r_u->num_entries2 = num_sam_entries;
3121                 r_u->ptr_entries2 = 1;
3122         }
3123 }
3124
3125 /*******************************************************************
3126 reads or writes a structure.
3127 ********************************************************************/
3128
3129 BOOL samr_io_r_enum_domains(const char *desc, SAMR_R_ENUM_DOMAINS * r_u,
3130                             prs_struct *ps, int depth)
3131 {
3132         uint32 i;
3133
3134         if (r_u == NULL)
3135                 return False;
3136
3137         prs_debug(ps, depth, desc, "samr_io_r_enum_domains");
3138         depth++;
3139
3140         if(!prs_align(ps))
3141                 return False;
3142
3143         if(!prs_uint32("next_idx    ", ps, depth, &r_u->next_idx))
3144                 return False;
3145         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3146                 return False;
3147
3148         if (r_u->ptr_entries1 != 0) {
3149                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3150                         return False;
3151                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3152                         return False;
3153                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3154                         return False;
3155
3156                 if (UNMARSHALLING(ps)) {
3157                         r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3158                         r_u->uni_dom_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3159                 }
3160
3161                 if ((r_u->sam == NULL || r_u->uni_dom_name == NULL) && r_u->num_entries2 != 0) {
3162                         DEBUG(0, ("NULL pointers in SAMR_R_ENUM_DOMAINS\n"));
3163                         r_u->num_entries4 = 0;
3164                         r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3165                         return False;
3166                 }
3167
3168                 for (i = 0; i < r_u->num_entries2; i++) {
3169                         fstring tmp;
3170                         slprintf(tmp, sizeof(tmp) - 1, "dom[%d]", i);
3171                         if(!sam_io_sam_entry(tmp, &r_u->sam[i], ps, depth))
3172                                 return False;
3173                 }
3174
3175                 for (i = 0; i < r_u->num_entries2; i++) {
3176                         fstring tmp;
3177                         slprintf(tmp, sizeof(tmp) - 1, "dom[%d]", i);
3178                         if(!smb_io_unistr2(tmp, &r_u->uni_dom_name[i],
3179                                        r_u->sam[i].hdr_name.buffer, ps,
3180                                        depth))
3181                                 return False;
3182                 }
3183
3184         }
3185
3186         if(!prs_align(ps))
3187                 return False;
3188         if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3189                 return False;
3190         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3191                 return False;
3192
3193         return True;
3194 }
3195
3196 /*******************************************************************
3197 inits a SAMR_Q_ENUM_DOM_GROUPS structure.
3198 ********************************************************************/
3199
3200 void init_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS * q_e,
3201                                  POLICY_HND *pol,
3202                                  uint32 start_idx, uint32 size)
3203 {
3204         DEBUG(5, ("init_samr_q_enum_dom_groups\n"));
3205
3206         q_e->pol = *pol;
3207
3208         q_e->start_idx = start_idx;
3209         q_e->max_size = size;
3210 }
3211
3212 /*******************************************************************
3213 reads or writes a structure.
3214 ********************************************************************/
3215
3216 BOOL samr_io_q_enum_dom_groups(const char *desc, SAMR_Q_ENUM_DOM_GROUPS * q_e,
3217                                prs_struct *ps, int depth)
3218 {
3219         if (q_e == NULL)
3220                 return False;
3221
3222         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_groups");
3223         depth++;
3224
3225         if(!prs_align(ps))
3226                 return False;
3227
3228         if(!smb_io_pol_hnd("pol", &(q_e->pol), ps, depth))
3229                 return False;
3230
3231         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3232                 return False;
3233         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3234                 return False;
3235
3236         return True;
3237 }
3238
3239 /*******************************************************************
3240 inits a SAMR_R_ENUM_DOM_GROUPS structure.
3241 ********************************************************************/
3242
3243 void init_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS * r_u,
3244                                  uint32 next_idx, uint32 num_sam_entries)
3245 {
3246         DEBUG(5, ("init_samr_r_enum_dom_groups\n"));
3247
3248         r_u->next_idx = next_idx;
3249
3250         if (num_sam_entries != 0) {
3251                 r_u->ptr_entries1 = 1;
3252                 r_u->ptr_entries2 = 1;
3253                 r_u->num_entries2 = num_sam_entries;
3254                 r_u->num_entries3 = num_sam_entries;
3255
3256                 r_u->num_entries4 = num_sam_entries;
3257         } else {
3258                 r_u->ptr_entries1 = 0;
3259                 r_u->num_entries2 = num_sam_entries;
3260                 r_u->ptr_entries2 = 1;
3261         }
3262 }
3263
3264 /*******************************************************************
3265 reads or writes a structure.
3266 ********************************************************************/
3267
3268 BOOL samr_io_r_enum_dom_groups(const char *desc, SAMR_R_ENUM_DOM_GROUPS * r_u,
3269                                prs_struct *ps, int depth)
3270 {
3271         uint32 i;
3272
3273         if (r_u == NULL)
3274                 return False;
3275
3276         prs_debug(ps, depth, desc, "samr_io_r_enum_dom_groups");
3277         depth++;
3278
3279         if(!prs_align(ps))
3280                 return False;
3281
3282         if(!prs_uint32("next_idx    ", ps, depth, &r_u->next_idx))
3283                 return False;
3284         if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3285                 return False;
3286
3287         if (r_u->ptr_entries1 != 0) {
3288                 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3289                         return False;
3290                 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3291                         return False;
3292                 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3293                         return False;
3294
3295                 if (UNMARSHALLING(ps)) {
3296                         r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3297                         r_u->uni_grp_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3298                 }
3299
3300                 if ((r_u->sam == NULL || r_u->uni_grp_name == NULL) && r_u->num_entries2 != 0) {
3301                         DEBUG(0,
3302                               ("NULL pointers in SAMR_R_ENUM_DOM_GROUPS\n"));
3303                         r_u->num_entries4 = 0;
3304                         r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3305                         return False;
3306                 }
3307
3308                 for (i = 0; i < r_u->num_entries2; i++) {
3309                         if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
3310                                 return False;
3311                 }
3312
3313                 for (i = 0; i < r_u->num_entries2; i++) {
3314                         if(!smb_io_unistr2("", &r_u->uni_grp_name[i],
3315                                        r_u->sam[i].hdr_name.buffer, ps, depth))
3316                                 return False;
3317                 }
3318         }
3319
3320         if(!prs_align(ps))
3321                 return False;
3322         if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3323                 return False;
3324         if(!prs_ntstatus("status", ps, depth, &r_u->status))
3325                 return False;
3326
3327         return True;
3328 }
3329
3330 /*******************************************************************
3331 inits a SAMR_Q_ENUM_DOM_ALIASES structure.
3332 ********************************************************************/
3333
3334 void init_samr_q_enum_dom_aliases(SAMR_Q_ENUM_DOM_ALIASES * q_e,
3335                                   POLICY_HND *pol, uint32 start_idx,
3336                                   uint32 size)
3337 {
3338         DEBUG(5, ("init_samr_q_enum_dom_aliases\n"));
3339
3340         q_e->pol = *pol;
3341
3342         q_e->start_idx = start_idx;
3343         q_e->max_size = size;
3344 }
3345
3346
3347 /*******************************************************************
3348 reads or writes a structure.
3349 ********************************************************************/
3350
3351 BOOL samr_io_q_enum_dom_aliases(const char *desc, SAMR_Q_ENUM_DOM_ALIASES * q_e,
3352                                 prs_struct *ps, int depth)
3353 {
3354         if (q_e == NULL)
3355                 return False;
3356
3357         prs_debug(ps, depth, desc, "samr_io_q_enum_dom_aliases");
3358         depth++;
3359
3360         if(!prs_align(ps))
3361                 return False;
3362
3363         if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
3364                 return False;
3365
3366         if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3367                 return False;
3368         if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3369                 return False;
3370
3371         return True;
3372 }
3373
3374 /*******************************************************************
3375 inits a SAMR_R_ENUM_DOM_ALIASES structure.
3376 ********************************************************************/
3377
3378 void init_samr_r_enum_dom_aliases(SAMR_R_ENUM_DOM_ALIASES *r_u, uint32 next_idx, uint32 num_sam_entries)
3379 {
3380         DEBUG(5, ("init_samr_r_enum_dom_aliases\n"));
3381
3382         r_u->next_idx = next_idx;
3383
3384         if (num_sam_entries != 0) {
3385        &nb