?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r6369: update release notes
[Samba.git] / source / rpc_parse / parse_samr.c
blobd3f709c352c839add06f539115b64b6693b75f2f
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 #include "rpc_parse.h"
29 #include "nterr.h"
30
31 #undef DBGC_CLASS
32 #define DBGC_CLASS DBGC_RPC_PARSE
33
34 /*******************************************************************
35 inits a SAMR_Q_CLOSE_HND structure.
36 ********************************************************************/
37
38 void init_samr_q_close_hnd(SAMR_Q_CLOSE_HND * q_c, POLICY_HND *hnd)
39 {
40 DEBUG(5, ("init_samr_q_close_hnd\n"));
41
42 q_c->pol = *hnd;
43 }
44
45 /*******************************************************************
46 reads or writes a structure.
47 ********************************************************************/
48
49 BOOL samr_io_q_close_hnd(const char *desc, SAMR_Q_CLOSE_HND * q_u,
50 prs_struct *ps, int depth)
51 {
52 if (q_u == NULL)
53 return False;
54
55 prs_debug(ps, depth, desc, "samr_io_q_close_hnd");
56 depth++;
57
58 if(!prs_align(ps))
59 return False;
60
61 return smb_io_pol_hnd("pol", &q_u->pol, ps, depth);
62 }
63
64 /*******************************************************************
65 reads or writes a structure.
66 ********************************************************************/
67
68 BOOL samr_io_r_close_hnd(const char *desc, SAMR_R_CLOSE_HND * r_u,
69 prs_struct *ps, int depth)
70 {
71 if (r_u == NULL)
72 return False;
73
74 prs_debug(ps, depth, desc, "samr_io_r_close_hnd");
75 depth++;
76
77 if(!prs_align(ps))
78 return False;
79
80 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
81 return False;
82
83 if(!prs_ntstatus("status", ps, depth, &r_u->status))
84 return False;
85
86 return True;
87 }
88
89 /*******************************************************************
90 inits a SAMR_Q_LOOKUP_DOMAIN structure.
91 ********************************************************************/
92
93 void init_samr_q_lookup_domain(SAMR_Q_LOOKUP_DOMAIN * q_u,
94 POLICY_HND *pol, char *dom_name)
95 {
96 DEBUG(5, ("init_samr_q_lookup_domain\n"));
97
98 q_u->connect_pol = *pol;
99
100 init_unistr2(&q_u->uni_domain, dom_name, UNI_FLAGS_NONE);
101 init_uni_hdr(&q_u->hdr_domain, &q_u->uni_domain);
102 }
103
104 /*******************************************************************
105 reads or writes a structure.
106 ********************************************************************/
107 BOOL samr_io_q_lookup_domain(const char *desc, SAMR_Q_LOOKUP_DOMAIN * q_u,
108 prs_struct *ps, int depth)
109 {
110 if (q_u == NULL)
111 return False;
112
113 prs_debug(ps, depth, desc, "samr_io_q_lookup_domain");
114 depth++;
115
116 if(!prs_align(ps))
117 return False;
118
119 if(!smb_io_pol_hnd("connect_pol", &q_u->connect_pol, ps, depth))
120 return False;
121
122 if(!smb_io_unihdr("hdr_domain", &q_u->hdr_domain, ps, depth))
123 return False;
124
125 if(!smb_io_unistr2("uni_domain", &q_u->uni_domain, q_u->hdr_domain.buffer, ps, depth))
126 return False;
127
128 return True;
129 }
130
131 /*******************************************************************
132 inits a SAMR_R_LOOKUP_DOMAIN structure.
133 ********************************************************************/
134
135 void init_samr_r_lookup_domain(SAMR_R_LOOKUP_DOMAIN * r_u,
136 DOM_SID *dom_sid, NTSTATUS status)
137 {
138 DEBUG(5, ("init_samr_r_lookup_domain\n"));
139
140 r_u->status = status;
141 r_u->ptr_sid = 0;
142 if (NT_STATUS_IS_OK(status)) {
143 r_u->ptr_sid = 1;
144 init_dom_sid2(&r_u->dom_sid, dom_sid);
145 }
146 }
147
148 /*******************************************************************
149 reads or writes a structure.
150 ********************************************************************/
151
152 BOOL samr_io_r_lookup_domain(const char *desc, SAMR_R_LOOKUP_DOMAIN * r_u,
153 prs_struct *ps, int depth)
154 {
155 if (r_u == NULL)
156 return False;
157
158 prs_debug(ps, depth, desc, "samr_io_r_lookup_domain");
159 depth++;
160
161 if(!prs_align(ps))
162 return False;
163
164 if(!prs_uint32("ptr", ps, depth, &r_u->ptr_sid))
165 return False;
166
167 if (r_u->ptr_sid != 0) {
168 if(!smb_io_dom_sid2("sid", &r_u->dom_sid, ps, depth))
169 return False;
170 if(!prs_align(ps))
171 return False;
172 }
173
174 if(!prs_ntstatus("status", ps, depth, &r_u->status))
175 return False;
176
177 return True;
178 }
179
180 /*******************************************************************
181 reads or writes a structure.
182 ********************************************************************/
183
184 void init_samr_q_remove_sid_foreign_domain(SAMR_Q_REMOVE_SID_FOREIGN_DOMAIN * q_u, POLICY_HND *dom_pol, DOM_SID *sid)
185 {
186 DEBUG(5, ("samr_init_samr_q_remove_sid_foreign_domain\n"));
187
188 q_u->dom_pol = *dom_pol;
189 init_dom_sid2(&q_u->sid, sid);
190 }
191
192 /*******************************************************************
193 reads or writes a structure.
194 ********************************************************************/
195
196 BOOL samr_io_q_remove_sid_foreign_domain(const char *desc, SAMR_Q_REMOVE_SID_FOREIGN_DOMAIN * q_u,
197 prs_struct *ps, int depth)
198 {
199 if (q_u == NULL)
200 return False;
201
202 prs_debug(ps, depth, desc, "samr_io_q_remove_sid_foreign_domain");
203 depth++;
204
205 if(!prs_align(ps))
206 return False;
207
208 if(!smb_io_pol_hnd("domain_pol", &q_u->dom_pol, ps, depth))
209 return False;
210
211 if(!smb_io_dom_sid2("sid", &q_u->sid, ps, depth))
212 return False;
213
214 if(!prs_align(ps))
215 return False;
216
217 return True;
218 }
219
220 /*******************************************************************
221 reads or writes a structure.
222 ********************************************************************/
223
224 BOOL samr_io_r_remove_sid_foreign_domain(const char *desc, SAMR_R_REMOVE_SID_FOREIGN_DOMAIN * r_u,
225 prs_struct *ps, int depth)
226 {
227 if (r_u == NULL)
228 return False;
229
230 prs_debug(ps, depth, desc, "samr_io_r_remove_sid_foreign_domain");
231 depth++;
232
233 if(!prs_align(ps))
234 return False;
235
236 if(!prs_ntstatus("status", ps, depth, &r_u->status))
237 return False;
238
239 return True;
240 }
241
242 /*******************************************************************
243 reads or writes a structure.
244 ********************************************************************/
245
246 void init_samr_q_open_domain(SAMR_Q_OPEN_DOMAIN * q_u,
247 POLICY_HND *pol, uint32 flags,
248 const DOM_SID *sid)
249 {
250 DEBUG(5, ("samr_init_samr_q_open_domain\n"));
251
252 q_u->pol = *pol;
253 q_u->flags = flags;
254 init_dom_sid2(&q_u->dom_sid, sid);
255 }
256
257 /*******************************************************************
258 reads or writes a structure.
259 ********************************************************************/
260
261 BOOL samr_io_q_open_domain(const char *desc, SAMR_Q_OPEN_DOMAIN * q_u,
262 prs_struct *ps, int depth)
263 {
264 if (q_u == NULL)
265 return False;
266
267 prs_debug(ps, depth, desc, "samr_io_q_open_domain");
268 depth++;
269
270 if(!prs_align(ps))
271 return False;
272
273 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
274 return False;
275
276 if(!prs_uint32("flags", ps, depth, &q_u->flags))
277 return False;
278
279 if(!smb_io_dom_sid2("sid", &q_u->dom_sid, ps, depth))
280 return False;
281
282 return True;
283 }
284
285 /*******************************************************************
286 reads or writes a structure.
287 ********************************************************************/
288
289 BOOL samr_io_r_open_domain(const char *desc, SAMR_R_OPEN_DOMAIN * r_u,
290 prs_struct *ps, int depth)
291 {
292 if (r_u == NULL)
293 return False;
294
295 prs_debug(ps, depth, desc, "samr_io_r_open_domain");
296 depth++;
297
298 if(!prs_align(ps))
299 return False;
300
301 if(!smb_io_pol_hnd("domain_pol", &r_u->domain_pol, ps, depth))
302 return False;
303
304 if(!prs_ntstatus("status", ps, depth, &r_u->status))
305 return False;
306
307 return True;
308 }
309
310 /*******************************************************************
311 reads or writes a structure.
312 ********************************************************************/
313
314 void init_samr_q_get_usrdom_pwinfo(SAMR_Q_GET_USRDOM_PWINFO * q_u,
315 POLICY_HND *user_pol)
316 {
317 DEBUG(5, ("samr_init_samr_q_get_usrdom_pwinfo\n"));
318
319 q_u->user_pol = *user_pol;
320 }
321
322 /*******************************************************************
323 reads or writes a structure.
324 ********************************************************************/
325
326 BOOL samr_io_q_get_usrdom_pwinfo(const char *desc, SAMR_Q_GET_USRDOM_PWINFO * q_u,
327 prs_struct *ps, int depth)
328 {
329 if (q_u == NULL)
330 return False;
331
332 prs_debug(ps, depth, desc, "samr_io_q_get_usrdom_pwinfo");
333 depth++;
334
335 if(!prs_align(ps))
336 return False;
337
338 return smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth);
339 }
340
341 /*******************************************************************
342 Init.
343 ********************************************************************/
344
345 void init_samr_r_get_usrdom_pwinfo(SAMR_R_GET_USRDOM_PWINFO *r_u, NTSTATUS status)
346 {
347 DEBUG(5, ("init_samr_r_get_usrdom_pwinfo\n"));
348
349 r_u->unknown_0 = 0x0000;
350
351 /*
352 * used to be
353 * r_u->unknown_1 = 0x0015;
354 * but for trusts.
355 */
356 r_u->unknown_1 = 0x01D1;
357 r_u->unknown_1 = 0x0015;
358
359 r_u->unknown_2 = 0x00000000;
360
361 r_u->status = status;
362 }
363
364 /*******************************************************************
365 reads or writes a structure.
366 ********************************************************************/
367
368 BOOL samr_io_r_get_usrdom_pwinfo(const char *desc, SAMR_R_GET_USRDOM_PWINFO * r_u,
369 prs_struct *ps, int depth)
370 {
371 if (r_u == NULL)
372 return False;
373
374 prs_debug(ps, depth, desc, "samr_io_r_get_usrdom_pwinfo");
375 depth++;
376
377 if(!prs_align(ps))
378 return False;
379
380 if(!prs_uint16("unknown_0", ps, depth, &r_u->unknown_0))
381 return False;
382 if(!prs_uint16("unknown_1", ps, depth, &r_u->unknown_1))
383 return False;
384 if(!prs_uint32("unknown_2", ps, depth, &r_u->unknown_2))
385 return False;
386 if(!prs_ntstatus("status ", ps, depth, &r_u->status))
387 return False;
388
389 return True;
390 }
391
392
393 /*******************************************************************
394 reads or writes a structure.
395 ********************************************************************/
396
397 BOOL samr_io_q_set_sec_obj(const char *desc, SAMR_Q_SET_SEC_OBJ * q_u,
398 prs_struct *ps, int depth)
399 {
400 if (q_u == NULL)
401 return False;
402
403 prs_debug(ps, depth, desc, "samr_io_q_set_sec_obj");
404 depth++;
405
406 if(!prs_align(ps))
407 return False;
408
409 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
410 return False;
411
412 if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
413 return False;
414
415 if(!sec_io_desc_buf("sec_desc", &q_u->buf, ps, depth))
416 return False;
417
418 return True;
419 }
420
421
422 /*******************************************************************
423 reads or writes a structure.
424 ********************************************************************/
425
426 void init_samr_q_query_sec_obj(SAMR_Q_QUERY_SEC_OBJ * q_u,
427 POLICY_HND *user_pol, uint32 sec_info)
428 {
429 DEBUG(5, ("samr_init_samr_q_query_sec_obj\n"));
430
431 q_u->user_pol = *user_pol;
432 q_u->sec_info = sec_info;
433 }
434
435
436 /*******************************************************************
437 reads or writes a structure.
438 ********************************************************************/
439
440 BOOL samr_io_q_query_sec_obj(const char *desc, SAMR_Q_QUERY_SEC_OBJ * q_u,
441 prs_struct *ps, int depth)
442 {
443 if (q_u == NULL)
444 return False;
445
446 prs_debug(ps, depth, desc, "samr_io_q_query_sec_obj");
447 depth++;
448
449 if(!prs_align(ps))
450 return False;
451
452 if(!smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth))
453 return False;
454
455 if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
456 return False;
457
458 return True;
459 }
460
461 /*******************************************************************
462 reads or writes a structure.
463 ********************************************************************/
464
465 void init_samr_q_query_dom_info(SAMR_Q_QUERY_DOMAIN_INFO * q_u,
466 POLICY_HND *domain_pol, uint16 switch_value)
467 {
468 DEBUG(5, ("samr_init_samr_q_query_dom_info\n"));
469
470 q_u->domain_pol = *domain_pol;
471 q_u->switch_value = switch_value;
472 }
473
474 /*******************************************************************
475 reads or writes a structure.
476 ********************************************************************/
477
478 BOOL samr_io_q_query_dom_info(const char *desc, SAMR_Q_QUERY_DOMAIN_INFO * q_u,
479 prs_struct *ps, int depth)
480 {
481 if (q_u == NULL)
482 return False;
483
484 prs_debug(ps, depth, desc, "samr_io_q_query_dom_info");
485 depth++;
486
487 if(!prs_align(ps))
488 return False;
489
490 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
491 return False;
492
493 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
494 return False;
495
496 return True;
497 }
498
499
500 /*******************************************************************
501 inits a structure.
502 ********************************************************************/
503
504 void init_unk_info3(SAM_UNK_INFO_3 *u_3, NTTIME nt_logout)
505 {
506 u_3->logout.low = nt_logout.low;
507 u_3->logout.high = nt_logout.high;
508 }
509
510 /*******************************************************************
511 reads or writes a structure.
512 ********************************************************************/
513
514 static BOOL sam_io_unk_info3(const char *desc, SAM_UNK_INFO_3 * u_3,
515 prs_struct *ps, int depth)
516 {
517 if (u_3 == NULL)
518 return False;
519
520 prs_debug(ps, depth, desc, "sam_io_unk_info3");
521 depth++;
522
523 if(!smb_io_time("logout", &u_3->logout, ps, depth))
524 return False;
525
526 return True;
527 }
528
529 /*******************************************************************
530 inits a structure.
531 ********************************************************************/
532
533 void init_unk_info6(SAM_UNK_INFO_6 * u_6)
534 {
535 u_6->unknown_0 = 0x00000000;
536 u_6->ptr_0 = 1;
537 memset(u_6->padding, 0, sizeof(u_6->padding)); /* 12 bytes zeros */
538 }
539
540 /*******************************************************************
541 reads or writes a structure.
542 ********************************************************************/
543
544 static BOOL sam_io_unk_info6(const char *desc, SAM_UNK_INFO_6 * u_6,
545 prs_struct *ps, int depth)
546 {
547 if (u_6 == NULL)
548 return False;
549
550 prs_debug(ps, depth, desc, "sam_io_unk_info6");
551 depth++;
552
553 if(!prs_uint32("unknown_0", ps, depth, &u_6->unknown_0)) /* 0x0000 0000 */
554 return False;
555 if(!prs_uint32("ptr_0", ps, depth, &u_6->ptr_0)) /* pointer to unknown structure */
556 return False;
557 if(!prs_uint8s(False, "padding", ps, depth, u_6->padding, sizeof(u_6->padding))) /* 12 bytes zeros */
558 return False;
559
560 return True;
561 }
562
563 /*******************************************************************
564 inits a structure.
565 ********************************************************************/
566
567 void init_unk_info7(SAM_UNK_INFO_7 * u_7, uint32 server_role)
568 {
569 u_7->server_role = server_role;
570 }
571
572 /*******************************************************************
573 reads or writes a structure.
574 ********************************************************************/
575
576 static BOOL sam_io_unk_info7(const char *desc, SAM_UNK_INFO_7 * u_7,
577 prs_struct *ps, int depth)
578 {
579 if (u_7 == NULL)
580 return False;
581
582 prs_debug(ps, depth, desc, "sam_io_unk_info7");
583 depth++;
584
585 if(!prs_uint16("server_role", ps, depth, &u_7->server_role))
586 return False;
587
588 return True;
589 }
590
591 /*******************************************************************
592 inits a structure.
593 ********************************************************************/
594
595 void init_unk_info8(SAM_UNK_INFO_8 * u_8, uint32 seq_num)
596 {
597 unix_to_nt_time(&u_8->domain_create_time, 0);
598 u_8->seq_num.low = seq_num;
599 u_8->seq_num.high = 0x0000;
600 }
601
602 /*******************************************************************
603 reads or writes a structure.
604 ********************************************************************/
605
606 static BOOL sam_io_unk_info8(const char *desc, SAM_UNK_INFO_8 * u_8,
607 prs_struct *ps, int depth)
608 {
609 if (u_8 == NULL)
610 return False;
611
612 prs_debug(ps, depth, desc, "sam_io_unk_info8");
613 depth++;
614
615 if (!prs_uint64("seq_num", ps, depth, &u_8->seq_num))
616 return False;
617
618 if(!smb_io_time("domain_create_time", &u_8->domain_create_time, ps, depth))
619 return False;
620
621 return True;
622 }
623
624
625 /*******************************************************************
626 inits a structure.
627 ********************************************************************/
628
629 void init_unk_info12(SAM_UNK_INFO_12 * u_12, NTTIME nt_lock_duration, NTTIME nt_reset_time, uint16 lockout)
630 {
631 u_12->duration.low = nt_lock_duration.low;
632 u_12->duration.high = nt_lock_duration.high;
633 u_12->reset_count.low = nt_reset_time.low;
634 u_12->reset_count.high = nt_reset_time.high;
635
636 u_12->bad_attempt_lockout = lockout;
637 }
638
639 /*******************************************************************
640 reads or writes a structure.
641 ********************************************************************/
642
643 static BOOL sam_io_unk_info12(const char *desc, SAM_UNK_INFO_12 * u_12,
644 prs_struct *ps, int depth)
645 {
646 if (u_12 == NULL)
647 return False;
648
649 prs_debug(ps, depth, desc, "sam_io_unk_info12");
650 depth++;
651
652 if(!smb_io_time("duration", &u_12->duration, ps, depth))
653 return False;
654 if(!smb_io_time("reset_count", &u_12->reset_count, ps, depth))
655 return False;
656 if(!prs_uint16("bad_attempt_lockout", ps, depth, &u_12->bad_attempt_lockout))
657 return False;
658
659 return True;
660 }
661
662 /*******************************************************************
663 inits a structure.
664 ********************************************************************/
665
666 void init_unk_info5(SAM_UNK_INFO_5 * u_5,const char *server)
667 {
668 init_unistr2(&u_5->uni_server, server, UNI_FLAGS_NONE);
669 init_uni_hdr(&u_5->hdr_server, &u_5->uni_server);
670 }
671
672 /*******************************************************************
673 reads or writes a structure.
674 ********************************************************************/
675
676 static BOOL sam_io_unk_info5(const char *desc, SAM_UNK_INFO_5 * u_5,
677 prs_struct *ps, int depth)
678 {
679 if (u_5 == NULL)
680 return False;
681
682 prs_debug(ps, depth, desc, "sam_io_unk_info5");
683 depth++;
684
685 if(!smb_io_unihdr("hdr_server", &u_5->hdr_server, ps, depth))
686 return False;
687
688 if(!smb_io_unistr2("uni_server", &u_5->uni_server, u_5->hdr_server.buffer, ps, depth))
689 return False;
690
691 return True;
692 }
693
694 /*******************************************************************
695 inits a structure.
696 ********************************************************************/
697
698 void init_unk_info2(SAM_UNK_INFO_2 * u_2,
699 const char *comment, const char *domain, const char *server,
700 uint32 seq_num, uint32 num_users, uint32 num_groups, uint32 num_alias, NTTIME nt_logout, uint32 server_role)
701 {
702 u_2->logout.low = nt_logout.low;
703 u_2->logout.high = nt_logout.high;
704
705 u_2->seq_num.low = seq_num;
706 u_2->seq_num.high = 0x00000000;
707
708
709 u_2->unknown_4 = 0x00000001;
710 u_2->server_role = server_role;
711 u_2->unknown_6 = 0x00000001;
712 u_2->num_domain_usrs = num_users;
713 u_2->num_domain_grps = num_groups;
714 u_2->num_local_grps = num_alias;
715
716 memset(u_2->padding, 0, sizeof(u_2->padding)); /* 12 bytes zeros */
717
718 init_unistr2(&u_2->uni_comment, comment, UNI_FLAGS_NONE);
719 init_uni_hdr(&u_2->hdr_comment, &u_2->uni_comment);
720 init_unistr2(&u_2->uni_domain, domain, UNI_FLAGS_NONE);
721 init_uni_hdr(&u_2->hdr_domain, &u_2->uni_domain);
722 init_unistr2(&u_2->uni_server, server, UNI_FLAGS_NONE);
723 init_uni_hdr(&u_2->hdr_server, &u_2->uni_server);
724 }
725
726 /*******************************************************************
727 reads or writes a structure.
728 ********************************************************************/
729
730 static BOOL sam_io_unk_info2(const char *desc, SAM_UNK_INFO_2 * u_2,
731 prs_struct *ps, int depth)
732 {
733 if (u_2 == NULL)
734 return False;
735
736 prs_debug(ps, depth, desc, "sam_io_unk_info2");
737 depth++;
738
739 if(!smb_io_time("logout", &u_2->logout, ps, depth))
740 return False;
741 if(!smb_io_unihdr("hdr_comment", &u_2->hdr_comment, ps, depth))
742 return False;
743 if(!smb_io_unihdr("hdr_domain", &u_2->hdr_domain, ps, depth))
744 return False;
745 if(!smb_io_unihdr("hdr_server", &u_2->hdr_server, ps, depth))
746 return False;
747
748 /* put all the data in here, at the moment, including what the above
749 pointer is referring to
750 */
751
752 if(!prs_uint64("seq_num ", ps, depth, &u_2->seq_num))
753 return False;
754
755 if(!prs_uint32("unknown_4 ", ps, depth, &u_2->unknown_4)) /* 0x0000 0001 */
756 return False;
757 if(!prs_uint32("server_role ", ps, depth, &u_2->server_role))
758 return False;
759 if(!prs_uint32("unknown_6 ", ps, depth, &u_2->unknown_6)) /* 0x0000 0001 */
760 return False;
761 if(!prs_uint32("num_domain_usrs ", ps, depth, &u_2->num_domain_usrs))
762 return False;
763 if(!prs_uint32("num_domain_grps", ps, depth, &u_2->num_domain_grps))
764 return False;
765 if(!prs_uint32("num_local_grps", ps, depth, &u_2->num_local_grps))
766 return False;
767
768 if(!smb_io_unistr2("uni_comment", &u_2->uni_comment, u_2->hdr_comment.buffer, ps, depth))
769 return False;
770 if(!smb_io_unistr2("uni_domain", &u_2->uni_domain, u_2->hdr_domain.buffer, ps, depth))
771 return False;
772 if(!smb_io_unistr2("uni_server", &u_2->uni_server, u_2->hdr_server.buffer, ps, depth))
773 return False;
774
775 return True;
776 }
777
778 /*******************************************************************
779 inits a structure.
780 ********************************************************************/
781
782 void init_unk_info1(SAM_UNK_INFO_1 *u_1, uint16 min_pass_len, uint16 pass_hist,
783 uint32 flag, NTTIME nt_expire, NTTIME nt_min_age)
784 {
785 u_1->min_length_password = min_pass_len;
786 u_1->password_history = pass_hist;
787 u_1->flag = flag;
788
789 /* password never expire */
790 u_1->expire.high = nt_expire.high;
791 u_1->expire.low = nt_expire.low;
792
793 /* can change the password now */
794 u_1->min_passwordage.high = nt_min_age.high;
795 u_1->min_passwordage.low = nt_min_age.low;
796
797 }
798
799 /*******************************************************************
800 reads or writes a structure.
801 ********************************************************************/
802
803 static BOOL sam_io_unk_info1(const char *desc, SAM_UNK_INFO_1 * u_1,
804 prs_struct *ps, int depth)
805 {
806 if (u_1 == NULL)
807 return False;
808
809 prs_debug(ps, depth, desc, "sam_io_unk_info1");
810 depth++;
811
812 if(!prs_uint16("min_length_password", ps, depth, &u_1->min_length_password))
813 return False;
814 if(!prs_uint16("password_history", ps, depth, &u_1->password_history))
815 return False;
816 if(!prs_uint32("flag", ps, depth, &u_1->flag))
817 return False;
818 if(!smb_io_time("expire", &u_1->expire, ps, depth))
819 return False;
820 if(!smb_io_time("min_passwordage", &u_1->min_passwordage, ps, depth))
821 return False;
822
823 return True;
824 }
825
826 /*******************************************************************
827 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
828 ********************************************************************/
829
830 void init_samr_r_query_dom_info(SAMR_R_QUERY_DOMAIN_INFO * r_u,
831 uint16 switch_value, SAM_UNK_CTR * ctr,
832 NTSTATUS status)
833 {
834 DEBUG(5, ("init_samr_r_query_dom_info\n"));
835
836 r_u->ptr_0 = 0;
837 r_u->switch_value = 0;
838 r_u->status = status; /* return status */
839
840 if (NT_STATUS_IS_OK(status)) {
841 r_u->switch_value = switch_value;
842 r_u->ptr_0 = 1;
843 r_u->ctr = ctr;
844 }
845 }
846
847 /*******************************************************************
848 reads or writes a structure.
849 ********************************************************************/
850
851 BOOL samr_io_r_query_dom_info(const char *desc, SAMR_R_QUERY_DOMAIN_INFO * r_u,
852 prs_struct *ps, int depth)
853 {
854 if (r_u == NULL)
855 return False;
856
857 prs_debug(ps, depth, desc, "samr_io_r_query_dom_info");
858 depth++;
859
860 if(!prs_align(ps))
861 return False;
862
863 if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
864 return False;
865
866 if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
867 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
868 return False;
869 if(!prs_align(ps))
870 return False;
871
872 switch (r_u->switch_value) {
873 case 0x0c:
874 if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
875 return False;
876 break;
877 case 0x08:
878 if(!sam_io_unk_info8("unk_inf8",&r_u->ctr->info.inf8, ps,depth))
879 return False;
880 break;
881 case 0x07:
882 if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
883 return False;
884 break;
885 case 0x06:
886 if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
887 return False;
888 break;
889 case 0x05:
890 if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
891 return False;
892 break;
893 case 0x03:
894 if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
895 return False;
896 break;
897 case 0x02:
898 if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
899 return False;
900 break;
901 case 0x01:
902 if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
903 return False;
904 break;
905 default:
906 DEBUG(0, ("samr_io_r_query_dom_info: unknown switch level 0x%x\n",
907 r_u->switch_value));
908 r_u->status = NT_STATUS_INVALID_INFO_CLASS;
909 return False;
910 }
911 }
912
913 if(!prs_align(ps))
914 return False;
915
916 if(!prs_ntstatus("status", ps, depth, &r_u->status))
917 return False;
918
919 return True;
920 }
921
922 /*******************************************************************
923 reads or writes a SAMR_R_SET_SEC_OBJ structure.
924 ********************************************************************/
925
926 BOOL samr_io_r_set_sec_obj(const char *desc, SAMR_R_SET_SEC_OBJ * r_u,
927 prs_struct *ps, int depth)
928 {
929 if (r_u == NULL)
930 return False;
931
932 prs_debug(ps, depth, desc, "samr_io_r_set_sec_obj");
933 depth++;
934
935 if(!prs_align(ps))
936 return False;
937
938 if(!prs_ntstatus("status", ps, depth, &r_u->status))
939 return False;
940
941 return True;
942 }
943
944 /*******************************************************************
945 reads or writes a SAMR_R_QUERY_SEC_OBJ structure.
946 ********************************************************************/
947
948 BOOL samr_io_r_query_sec_obj(const char *desc, SAMR_R_QUERY_SEC_OBJ * r_u,
949 prs_struct *ps, int depth)
950 {
951 if (r_u == NULL)
952 return False;
953
954 prs_debug(ps, depth, desc, "samr_io_r_query_sec_obj");
955 depth++;
956
957 if(!prs_align(ps))
958 return False;
959
960 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
961 return False;
962 if (r_u->ptr != 0) {
963 if(!sec_io_desc_buf("sec", &r_u->buf, ps, depth))
964 return False;
965 }
966
967 if(!prs_ntstatus("status", ps, depth, &r_u->status))
968 return False;
969
970 return True;
971 }
972
973 /*******************************************************************
974 reads or writes a SAM_STR1 structure.
975 ********************************************************************/
976
977 static BOOL sam_io_sam_str1(const char *desc, SAM_STR1 * sam, uint32 acct_buf,
978 uint32 name_buf, uint32 desc_buf,
979 prs_struct *ps, int depth)
980 {
981 if (sam == NULL)
982 return False;
983
984 prs_debug(ps, depth, desc, "sam_io_sam_str1");
985 depth++;
986
987 if(!prs_align(ps))
988 return False;
989 if (!smb_io_unistr2("name", &sam->uni_acct_name, acct_buf, ps, depth))
990 return False;
991
992 if (!smb_io_unistr2("desc", &sam->uni_acct_desc, desc_buf, ps, depth))
993 return False;
994
995 if (!smb_io_unistr2("full", &sam->uni_full_name, name_buf, ps, depth))
996 return False;
997
998 return True;
999 }
1000
1001 /*******************************************************************
1002 inits a SAM_ENTRY1 structure.
1003 ********************************************************************/
1004
1005 static void init_sam_entry1(SAM_ENTRY1 *sam, uint32 user_idx,
1006 UNISTR2 *sam_name, UNISTR2 *sam_full,
1007 UNISTR2 *sam_desc, uint32 rid_user,
1008 uint16 acb_info)
1009 {
1010 DEBUG(5, ("init_sam_entry1\n"));
1011
1012 ZERO_STRUCTP(sam);
1013
1014 sam->user_idx = user_idx;
1015 sam->rid_user = rid_user;
1016 sam->acb_info = acb_info;
1017
1018 init_uni_hdr(&sam->hdr_acct_name, sam_name);
1019 init_uni_hdr(&sam->hdr_user_name, sam_full);
1020 init_uni_hdr(&sam->hdr_user_desc, sam_desc);
1021 }
1022
1023 /*******************************************************************
1024 reads or writes a SAM_ENTRY1 structure.
1025 ********************************************************************/
1026
1027 static BOOL sam_io_sam_entry1(const char *desc, SAM_ENTRY1 * sam,
1028 prs_struct *ps, int depth)
1029 {
1030 if (sam == NULL)
1031 return False;
1032
1033 prs_debug(ps, depth, desc, "sam_io_sam_entry1");
1034 depth++;
1035
1036 if(!prs_align(ps))
1037 return False;
1038
1039 if(!prs_uint32("user_idx ", ps, depth, &sam->user_idx))
1040 return False;
1041
1042 if(!prs_uint32("rid_user ", ps, depth, &sam->rid_user))
1043 return False;
1044 if(!prs_uint16("acb_info ", ps, depth, &sam->acb_info))
1045 return False;
1046
1047 if(!prs_align(ps))
1048 return False;
1049
1050 if (!smb_io_unihdr("hdr_acct_name", &sam->hdr_acct_name, ps, depth))
1051 return False;
1052 if (!smb_io_unihdr("hdr_user_desc", &sam->hdr_user_desc, ps, depth))
1053 return False;
1054 if (!smb_io_unihdr("hdr_user_name", &sam->hdr_user_name, ps, depth))
1055 return False;
1056
1057 return True;
1058 }
1059
1060 /*******************************************************************
1061 reads or writes a SAM_STR2 structure.
1062 ********************************************************************/
1063
1064 static BOOL sam_io_sam_str2(const char *desc, SAM_STR2 * sam, uint32 acct_buf,
1065 uint32 desc_buf, prs_struct *ps, int depth)
1066 {
1067 if (sam == NULL)
1068 return False;
1069
1070 prs_debug(ps, depth, desc, "sam_io_sam_str2");
1071 depth++;
1072
1073 if(!prs_align(ps))
1074 return False;
1075
1076 if(!smb_io_unistr2("uni_srv_name", &sam->uni_srv_name, acct_buf, ps, depth)) /* account name unicode string */
1077 return False;
1078 if(!smb_io_unistr2("uni_srv_desc", &sam->uni_srv_desc, desc_buf, ps, depth)) /* account desc unicode string */
1079 return False;
1080
1081 return True;
1082 }
1083
1084 /*******************************************************************
1085 inits a SAM_ENTRY2 structure.
1086 ********************************************************************/
1087 static void init_sam_entry2(SAM_ENTRY2 * sam, uint32 user_idx,
1088 UNISTR2 *sam_name, UNISTR2 *sam_desc,
1089 uint32 rid_user, uint16 acb_info)
1090 {
1091 DEBUG(5, ("init_sam_entry2\n"));
1092
1093 sam->user_idx = user_idx;
1094 sam->rid_user = rid_user;
1095 sam->acb_info = acb_info;
1096
1097 init_uni_hdr(&sam->hdr_srv_name, sam_name);
1098 init_uni_hdr(&sam->hdr_srv_desc, sam_desc);
1099 }
1100
1101 /*******************************************************************
1102 reads or writes a SAM_ENTRY2 structure.
1103 ********************************************************************/
1104
1105 static BOOL sam_io_sam_entry2(const char *desc, SAM_ENTRY2 * sam,
1106 prs_struct *ps, int depth)
1107 {
1108 if (sam == NULL)
1109 return False;
1110
1111 prs_debug(ps, depth, desc, "sam_io_sam_entry2");
1112 depth++;
1113
1114 if(!prs_align(ps))
1115 return False;
1116
1117 if(!prs_uint32("user_idx ", ps, depth, &sam->user_idx))
1118 return False;
1119
1120 if(!prs_uint32("rid_user ", ps, depth, &sam->rid_user))
1121 return False;
1122 if(!prs_uint16("acb_info ", ps, depth, &sam->acb_info))
1123 return False;
1124
1125 if(!prs_align(ps))
1126 return False;
1127
1128 if(!smb_io_unihdr("unihdr", &sam->hdr_srv_name, ps, depth)) /* account name unicode string header */
1129 return False;
1130 if(!smb_io_unihdr("unihdr", &sam->hdr_srv_desc, ps, depth)) /* account name unicode string header */
1131 return False;
1132
1133 return True;
1134 }
1135
1136 /*******************************************************************
1137 reads or writes a SAM_STR3 structure.
1138 ********************************************************************/
1139
1140 static BOOL sam_io_sam_str3(const char *desc, SAM_STR3 * sam, uint32 acct_buf,
1141 uint32 desc_buf, prs_struct *ps, int depth)
1142 {
1143 if (sam == NULL)
1144 return False;
1145
1146 prs_debug(ps, depth, desc, "sam_io_sam_str3");
1147 depth++;
1148
1149 if(!prs_align(ps))
1150 return False;
1151
1152 if(!smb_io_unistr2("uni_grp_name", &sam->uni_grp_name, acct_buf, ps, depth)) /* account name unicode string */
1153 return False;
1154 if(!smb_io_unistr2("uni_grp_desc", &sam->uni_grp_desc, desc_buf, ps, depth)) /* account desc unicode string */
1155 return False;
1156
1157 return True;
1158 }
1159
1160 /*******************************************************************
1161 inits a SAM_ENTRY3 structure.
1162 ********************************************************************/
1163
1164 static void init_sam_entry3(SAM_ENTRY3 * sam, uint32 grp_idx,
1165 UNISTR2 *grp_name, UNISTR2 *grp_desc,
1166 uint32 rid_grp)
1167 {
1168 DEBUG(5, ("init_sam_entry3\n"));
1169
1170 sam->grp_idx = grp_idx;
1171 sam->rid_grp = rid_grp;
1172 sam->attr = 0x07; /* group rid attributes - gets ignored by nt 4.0 */
1173
1174 init_uni_hdr(&sam->hdr_grp_name, grp_name);
1175 init_uni_hdr(&sam->hdr_grp_desc, grp_desc);
1176 }
1177
1178 /*******************************************************************
1179 reads or writes a SAM_ENTRY3 structure.
1180 ********************************************************************/
1181
1182 static BOOL sam_io_sam_entry3(const char *desc, SAM_ENTRY3 * sam,
1183 prs_struct *ps, int depth)
1184 {
1185 if (sam == NULL)
1186 return False;
1187
1188 prs_debug(ps, depth, desc, "sam_io_sam_entry3");
1189 depth++;
1190
1191 if(!prs_align(ps))
1192 return False;
1193
1194 if(!prs_uint32("grp_idx", ps, depth, &sam->grp_idx))
1195 return False;
1196
1197 if(!prs_uint32("rid_grp", ps, depth, &sam->rid_grp))
1198 return False;
1199 if(!prs_uint32("attr ", ps, depth, &sam->attr))
1200 return False;
1201
1202 if(!smb_io_unihdr("unihdr", &sam->hdr_grp_name, ps, depth)) /* account name unicode string header */
1203 return False;
1204 if(!smb_io_unihdr("unihdr", &sam->hdr_grp_desc, ps, depth)) /* account name unicode string header */
1205 return False;
1206
1207 return True;
1208 }
1209
1210 /*******************************************************************
1211 inits a SAM_ENTRY4 structure.
1212 ********************************************************************/
1213
1214 static void init_sam_entry4(SAM_ENTRY4 * sam, uint32 user_idx,
1215 uint32 len_acct_name)
1216 {
1217 DEBUG(5, ("init_sam_entry4\n"));
1218
1219 sam->user_idx = user_idx;
1220 init_str_hdr(&sam->hdr_acct_name, len_acct_name+1, len_acct_name, len_acct_name != 0);
1221 }
1222
1223 /*******************************************************************
1224 reads or writes a SAM_ENTRY4 structure.
1225 ********************************************************************/
1226
1227 static BOOL sam_io_sam_entry4(const char *desc, SAM_ENTRY4 * sam,
1228 prs_struct *ps, int depth)
1229 {
1230 if (sam == NULL)
1231 return False;
1232
1233 prs_debug(ps, depth, desc, "sam_io_sam_entry4");
1234 depth++;
1235
1236 if(!prs_align(ps))
1237 return False;
1238
1239 if(!prs_uint32("user_idx", ps, depth, &sam->user_idx))
1240 return False;
1241 if(!smb_io_strhdr("strhdr", &sam->hdr_acct_name, ps, depth))
1242 return False;
1243
1244 return True;
1245 }
1246
1247 /*******************************************************************
1248 inits a SAM_ENTRY5 structure.
1249 ********************************************************************/
1250
1251 static void init_sam_entry5(SAM_ENTRY5 * sam, uint32 grp_idx,
1252 uint32 len_grp_name)
1253 {
1254 DEBUG(5, ("init_sam_entry5\n"));
1255
1256 sam->grp_idx = grp_idx;
1257 init_str_hdr(&sam->hdr_grp_name, len_grp_name, len_grp_name,
1258 len_grp_name != 0);
1259 }
1260
1261 /*******************************************************************
1262 reads or writes a SAM_ENTRY5 structure.
1263 ********************************************************************/
1264
1265 static BOOL sam_io_sam_entry5(const char *desc, SAM_ENTRY5 * sam,
1266 prs_struct *ps, int depth)
1267 {
1268 if (sam == NULL)
1269 return False;
1270
1271 prs_debug(ps, depth, desc, "sam_io_sam_entry5");
1272 depth++;
1273
1274 if(!prs_align(ps))
1275 return False;
1276
1277 if(!prs_uint32("grp_idx", ps, depth, &sam->grp_idx))
1278 return False;
1279 if(!smb_io_strhdr("strhdr", &sam->hdr_grp_name, ps, depth))
1280 return False;
1281
1282 return True;
1283 }
1284
1285 /*******************************************************************
1286 inits a SAM_ENTRY structure.
1287 ********************************************************************/
1288
1289 void init_sam_entry(SAM_ENTRY *sam, UNISTR2 *uni2, uint32 rid)
1290 {
1291 DEBUG(10, ("init_sam_entry: %d\n", rid));
1292
1293 sam->rid = rid;
1294 init_uni_hdr(&sam->hdr_name, uni2);
1295 }
1296
1297 /*******************************************************************
1298 reads or writes a SAM_ENTRY structure.
1299 ********************************************************************/
1300
1301 static BOOL sam_io_sam_entry(const char *desc, SAM_ENTRY * sam,
1302 prs_struct *ps, int depth)
1303 {
1304 if (sam == NULL)
1305 return False;
1306
1307 prs_debug(ps, depth, desc, "sam_io_sam_entry");
1308 depth++;
1309
1310 if(!prs_align(ps))
1311 return False;
1312 if(!prs_uint32("rid", ps, depth, &sam->rid))
1313 return False;
1314 if(!smb_io_unihdr("unihdr", &sam->hdr_name, ps, depth)) /* account name unicode string header */
1315 return False;
1316
1317 return True;
1318 }
1319
1320 /*******************************************************************
1321 inits a SAMR_Q_ENUM_DOM_USERS structure.
1322 ********************************************************************/
1323
1324 void init_samr_q_enum_dom_users(SAMR_Q_ENUM_DOM_USERS * q_e, POLICY_HND *pol,
1325 uint32 start_idx,
1326 uint16 acb_mask, uint16 unk_1, uint32 size)
1327 {
1328 DEBUG(5, ("init_samr_q_enum_dom_users\n"));
1329
1330 q_e->pol = *pol;
1331
1332 q_e->start_idx = start_idx; /* zero indicates lots */
1333 q_e->acb_mask = acb_mask;
1334 q_e->unknown_1 = unk_1;
1335 q_e->max_size = size;
1336 }
1337
1338 /*******************************************************************
1339 reads or writes a structure.
1340 ********************************************************************/
1341
1342 BOOL samr_io_q_enum_dom_users(const char *desc, SAMR_Q_ENUM_DOM_USERS * q_e,
1343 prs_struct *ps, int depth)
1344 {
1345 if (q_e == NULL)
1346 return False;
1347
1348 prs_debug(ps, depth, desc, "samr_io_q_enum_dom_users");
1349 depth++;
1350
1351 if(!prs_align(ps))
1352 return False;
1353
1354 if(!smb_io_pol_hnd("domain_pol", &q_e->pol, ps, depth))
1355 return False;
1356
1357 if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
1358 return False;
1359 if(!prs_uint16("acb_mask ", ps, depth, &q_e->acb_mask))
1360 return False;
1361 if(!prs_uint16("unknown_1", ps, depth, &q_e->unknown_1))
1362 return False;
1363
1364 if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
1365 return False;
1366
1367 return True;
1368 }
1369
1370
1371 /*******************************************************************
1372 inits a SAMR_R_ENUM_DOM_USERS structure.
1373 ********************************************************************/
1374
1375 void init_samr_r_enum_dom_users(SAMR_R_ENUM_DOM_USERS * r_u,
1376 uint32 next_idx, uint32 num_sam_entries)
1377 {
1378 DEBUG(5, ("init_samr_r_enum_dom_users\n"));
1379
1380 r_u->next_idx = next_idx;
1381
1382 if (num_sam_entries != 0) {
1383 r_u->ptr_entries1 = 1;
1384 r_u->ptr_entries2 = 1;
1385 r_u->num_entries2 = num_sam_entries;
1386 r_u->num_entries3 = num_sam_entries;
1387
1388 r_u->num_entries4 = num_sam_entries;
1389 } else {
1390 r_u->ptr_entries1 = 0;
1391 r_u->num_entries2 = num_sam_entries;
1392 r_u->ptr_entries2 = 1;
1393 }
1394 }
1395
1396 /*******************************************************************
1397 reads or writes a structure.
1398 ********************************************************************/
1399
1400 BOOL samr_io_r_enum_dom_users(const char *desc, SAMR_R_ENUM_DOM_USERS * r_u,
1401 prs_struct *ps, int depth)
1402 {
1403 uint32 i;
1404
1405 if (r_u == NULL)
1406 return False;
1407
1408 prs_debug(ps, depth, desc, "samr_io_r_enum_dom_users");
1409 depth++;
1410
1411 if(!prs_align(ps))
1412 return False;
1413
1414 if(!prs_uint32("next_idx ", ps, depth, &r_u->next_idx))
1415 return False;
1416 if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
1417 return False;
1418
1419 if (r_u->ptr_entries1 != 0) {
1420 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
1421 return False;
1422 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
1423 return False;
1424 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
1425 return False;
1426
1427 if (UNMARSHALLING(ps) && (r_u->num_entries2 != 0)) {
1428 r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY, r_u->num_entries2);
1429 r_u->uni_acct_name = PRS_ALLOC_MEM(ps,UNISTR2, r_u->num_entries2);
1430 }
1431
1432 if ((r_u->sam == NULL || r_u->uni_acct_name == NULL) && r_u->num_entries2 != 0) {
1433 DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_USERS\n"));
1434 r_u->num_entries4 = 0;
1435 r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
1436 return False;
1437 }
1438
1439 for (i = 0; i < r_u->num_entries2; i++) {
1440 if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
1441 return False;
1442 }
1443
1444 for (i = 0; i < r_u->num_entries2; i++) {
1445 if(!smb_io_unistr2("", &r_u->uni_acct_name[i],r_u->sam[i].hdr_name.buffer, ps,depth))
1446 return False;
1447 }
1448
1449 }
1450
1451 if(!prs_align(ps))
1452 return False;
1453
1454 if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
1455 return False;
1456 if(!prs_ntstatus("status", ps, depth, &r_u->status))
1457 return False;
1458
1459 return True;
1460 }
1461
1462 /*******************************************************************
1463 inits a SAMR_Q_QUERY_DISPINFO structure.
1464 ********************************************************************/
1465
1466 void init_samr_q_query_dispinfo(SAMR_Q_QUERY_DISPINFO * q_e, POLICY_HND *pol,
1467 uint16 switch_level, uint32 start_idx,
1468 uint32 max_entries, uint32 max_size)
1469 {
1470 DEBUG(5, ("init_samr_q_query_dispinfo\n"));
1471
1472 q_e->domain_pol = *pol;
1473
1474 q_e->switch_level = switch_level;
1475
1476 q_e->start_idx = start_idx;
1477 q_e->max_entries = max_entries;
1478 q_e->max_size = max_size;
1479 }
1480
1481 /*******************************************************************
1482 reads or writes a structure.
1483 ********************************************************************/
1484
1485 BOOL samr_io_q_query_dispinfo(const char *desc, SAMR_Q_QUERY_DISPINFO * q_e,
1486 prs_struct *ps, int depth)
1487 {
1488 if (q_e == NULL)
1489 return False;
1490
1491 prs_debug(ps, depth, desc, "samr_io_q_query_dispinfo");
1492 depth++;
1493
1494 if(!prs_align(ps))
1495 return False;
1496
1497 if(!smb_io_pol_hnd("domain_pol", &q_e->domain_pol, ps, depth))
1498 return False;
1499
1500 if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
1501 return False;
1502 if(!prs_align(ps))
1503 return False;
1504
1505 if(!prs_uint32("start_idx ", ps, depth, &q_e->start_idx))
1506 return False;
1507 if(!prs_uint32("max_entries ", ps, depth, &q_e->max_entries))
1508 return False;
1509 if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
1510 return False;
1511
1512 return True;
1513 }
1514
1515 /*******************************************************************
1516 inits a SAM_DISPINFO_1 structure.
1517 ********************************************************************/
1518
1519 NTSTATUS init_sam_dispinfo_1(TALLOC_CTX *ctx, SAM_DISPINFO_1 **sam,
1520 uint32 num_entries, uint32 start_idx,
1521 struct samr_displayentry *entries)
1522 {
1523 uint32 i;
1524
1525 DEBUG(10, ("init_sam_dispinfo_1: num_entries: %d\n", num_entries));
1526
1527 if (num_entries==0)
1528 return NT_STATUS_OK;
1529
1530 *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_1, num_entries);
1531 if (*sam == NULL)
1532 return NT_STATUS_NO_MEMORY;
1533
1534 (*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY1, num_entries);
1535 if ((*sam)->sam == NULL)
1536 return NT_STATUS_NO_MEMORY;
1537
1538 (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR1, num_entries);
1539 if ((*sam)->str == NULL)
1540 return NT_STATUS_NO_MEMORY;
1541
1542 for (i = 0; i < num_entries ; i++) {
1543 init_unistr2(&(*sam)->str[i].uni_acct_name,
1544 entries[i].account_name, UNI_FLAGS_NONE);
1545 init_unistr2(&(*sam)->str[i].uni_full_name,
1546 entries[i].fullname, UNI_FLAGS_NONE);
1547 init_unistr2(&(*sam)->str[i].uni_acct_desc,
1548 entries[i].description, UNI_FLAGS_NONE);
1549
1550 init_sam_entry1(&(*sam)->sam[i], start_idx+i+1,
1551 &(*sam)->str[i].uni_acct_name,
1552 &(*sam)->str[i].uni_full_name,
1553 &(*sam)->str[i].uni_acct_desc,
1554 entries[i].rid, entries[i].acct_flags);
1555 }
1556
1557 return NT_STATUS_OK;
1558 }
1559
1560 /*******************************************************************
1561 reads or writes a structure.
1562 ********************************************************************/
1563
1564 static BOOL sam_io_sam_dispinfo_1(const char *desc, SAM_DISPINFO_1 * sam,
1565 uint32 num_entries,
1566 prs_struct *ps, int depth)
1567 {
1568 uint32 i;
1569
1570 prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_1");
1571 depth++;
1572
1573 if(!prs_align(ps))
1574 return False;
1575
1576 if (UNMARSHALLING(ps) && num_entries > 0) {
1577
1578 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY1, num_entries)) == NULL) {
1579 DEBUG(0, ("out of memory allocating SAM_ENTRY1\n"));
1580 return False;
1581 }
1582
1583 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR1, num_entries)) == NULL) {
1584 DEBUG(0, ("out of memory allocating SAM_STR1\n"));
1585 return False;
1586 }
1587 }
1588
1589 for (i = 0; i < num_entries; i++) {
1590 if(!sam_io_sam_entry1("", &sam->sam[i], ps, depth))
1591 return False;
1592 }
1593
1594 for (i = 0; i < num_entries; i++) {
1595 if(!sam_io_sam_str1("", &sam->str[i],
1596 sam->sam[i].hdr_acct_name.buffer,
1597 sam->sam[i].hdr_user_name.buffer,
1598 sam->sam[i].hdr_user_desc.buffer, ps, depth))
1599 return False;
1600 }
1601
1602 return True;
1603 }
1604
1605 /*******************************************************************
1606 inits a SAM_DISPINFO_2 structure.
1607 ********************************************************************/
1608
1609 NTSTATUS init_sam_dispinfo_2(TALLOC_CTX *ctx, SAM_DISPINFO_2 **sam,
1610 uint32 num_entries, uint32 start_idx,
1611 struct samr_displayentry *entries)
1612 {
1613 uint32 i;
1614
1615 DEBUG(10, ("init_sam_dispinfo_2: num_entries: %d\n", num_entries));
1616
1617 if (num_entries==0)
1618 return NT_STATUS_OK;
1619
1620 *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_2, num_entries);
1621 if (*sam == NULL)
1622 return NT_STATUS_NO_MEMORY;
1623
1624 (*sam)->sam = TALLOC_ARRAY(ctx, SAM_ENTRY2, num_entries);
1625 if ((*sam)->sam == NULL)
1626 return NT_STATUS_NO_MEMORY;
1627
1628 (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR2, num_entries);
1629 if ((*sam)->str == NULL)
1630 return NT_STATUS_NO_MEMORY;
1631
1632 for (i = 0; i < num_entries; i++) {
1633 init_unistr2(&(*sam)->str[i].uni_srv_name,
1634 entries[i].account_name, UNI_FLAGS_NONE);
1635 init_unistr2(&(*sam)->str[i].uni_srv_desc,
1636 entries[i].description, UNI_FLAGS_NONE);
1637
1638 init_sam_entry2(&(*sam)->sam[i], start_idx + i + 1,
1639 &(*sam)->str[i].uni_srv_name,
1640 &(*sam)->str[i].uni_srv_desc,
1641 entries[i].rid, entries[i].acct_flags);
1642 }
1643
1644 return NT_STATUS_OK;
1645 }
1646
1647 /*******************************************************************
1648 reads or writes a structure.
1649 ********************************************************************/
1650
1651 static BOOL sam_io_sam_dispinfo_2(const char *desc, SAM_DISPINFO_2 * sam,
1652 uint32 num_entries,
1653 prs_struct *ps, int depth)
1654 {
1655 uint32 i;
1656
1657 if (sam == NULL)
1658 return False;
1659
1660 prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_2");
1661 depth++;
1662
1663 if(!prs_align(ps))
1664 return False;
1665
1666 if (UNMARSHALLING(ps) && num_entries > 0) {
1667
1668 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY2, num_entries)) == NULL) {
1669 DEBUG(0, ("out of memory allocating SAM_ENTRY2\n"));
1670 return False;
1671 }
1672
1673 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR2, num_entries)) == NULL) {
1674 DEBUG(0, ("out of memory allocating SAM_STR2\n"));
1675 return False;
1676 }
1677 }
1678
1679 for (i = 0; i < num_entries; i++) {
1680 if(!sam_io_sam_entry2("", &sam->sam[i], ps, depth))
1681 return False;
1682 }
1683
1684 for (i = 0; i < num_entries; i++) {
1685 if(!sam_io_sam_str2("", &sam->str[i],
1686 sam->sam[i].hdr_srv_name.buffer,
1687 sam->sam[i].hdr_srv_desc.buffer, ps, depth))
1688 return False;
1689 }
1690
1691 return True;
1692 }
1693
1694 /*******************************************************************
1695 inits a SAM_DISPINFO_3 structure.
1696 ********************************************************************/
1697
1698 NTSTATUS init_sam_dispinfo_3(TALLOC_CTX *ctx, SAM_DISPINFO_3 **sam,
1699 uint32 num_entries, uint32 start_idx,
1700 struct samr_displayentry *entries)
1701 {
1702 uint32 i;
1703
1704 DEBUG(5, ("init_sam_dispinfo_3: num_entries: %d\n", num_entries));
1705
1706 if (num_entries==0)
1707 return NT_STATUS_OK;
1708
1709 *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_3, num_entries);
1710 if (*sam == NULL)
1711 return NT_STATUS_NO_MEMORY;
1712
1713 if (!((*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY3, num_entries)))
1714 return NT_STATUS_NO_MEMORY;
1715
1716 if (!((*sam)->str=TALLOC_ARRAY(ctx, SAM_STR3, num_entries)))
1717 return NT_STATUS_NO_MEMORY;
1718
1719 for (i = 0; i < num_entries; i++) {
1720 DEBUG(11, ("init_sam_dispinfo_3: entry: %d\n",i));
1721
1722 init_unistr2(&(*sam)->str[i].uni_grp_name,
1723 entries[i].account_name, UNI_FLAGS_NONE);
1724 init_unistr2(&(*sam)->str[i].uni_grp_desc,
1725 entries[i].description, UNI_FLAGS_NONE);
1726
1727 init_sam_entry3(&(*sam)->sam[i], start_idx+i+1,
1728 &(*sam)->str[i].uni_grp_name,
1729 &(*sam)->str[i].uni_grp_desc,
1730 entries[i].rid);
1731 }
1732
1733 return NT_STATUS_OK;
1734 }
1735
1736 /*******************************************************************
1737 reads or writes a structure.
1738 ********************************************************************/
1739
1740 static BOOL sam_io_sam_dispinfo_3(const char *desc, SAM_DISPINFO_3 * sam,
1741 uint32 num_entries,
1742 prs_struct *ps, int depth)
1743 {
1744 uint32 i;
1745
1746 if (sam == NULL)
1747 return False;
1748
1749 prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_3");
1750 depth++;
1751
1752 if(!prs_align(ps))
1753 return False;
1754
1755 if (UNMARSHALLING(ps) && num_entries > 0) {
1756
1757 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY3, num_entries)) == NULL) {
1758 DEBUG(0, ("out of memory allocating SAM_ENTRY3\n"));
1759 return False;
1760 }
1761
1762 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR3, num_entries)) == NULL) {
1763 DEBUG(0, ("out of memory allocating SAM_STR3\n"));
1764 return False;
1765 }
1766 }
1767
1768 for (i = 0; i < num_entries; i++) {
1769 if(!sam_io_sam_entry3("", &sam->sam[i], ps, depth))
1770 return False;
1771 }
1772
1773 for (i = 0; i < num_entries; i++) {
1774 if(!sam_io_sam_str3("", &sam->str[i],
1775 sam->sam[i].hdr_grp_name.buffer,
1776 sam->sam[i].hdr_grp_desc.buffer, ps, depth))
1777 return False;
1778 }
1779
1780 return True;
1781 }
1782
1783 /*******************************************************************
1784 inits a SAM_DISPINFO_4 structure.
1785 ********************************************************************/
1786
1787 NTSTATUS init_sam_dispinfo_4(TALLOC_CTX *ctx, SAM_DISPINFO_4 **sam,
1788 uint32 num_entries, uint32 start_idx,
1789 struct samr_displayentry *entries)
1790 {
1791 uint32 i;
1792
1793 DEBUG(5, ("init_sam_dispinfo_4: num_entries: %d\n", num_entries));
1794
1795 if (num_entries==0)
1796 return NT_STATUS_OK;
1797
1798 *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_4, num_entries);
1799 if (*sam == NULL)
1800 return NT_STATUS_NO_MEMORY;
1801
1802 (*sam)->sam = TALLOC_ARRAY(ctx, SAM_ENTRY4, num_entries);
1803 if ((*sam)->sam == NULL)
1804 return NT_STATUS_NO_MEMORY;
1805
1806 (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR4, num_entries);
1807 if ((*sam)->str == NULL)
1808 return NT_STATUS_NO_MEMORY;
1809
1810 for (i = 0; i < num_entries; i++) {
1811 size_t len_sam_name = strlen(entries[i].account_name);
1812
1813 DEBUG(11, ("init_sam_dispinfo_2: entry: %d\n",i));
1814
1815 init_sam_entry4(&(*sam)->sam[i], start_idx + i + 1,
1816 len_sam_name);
1817
1818 init_string2(&(*sam)->str[i].acct_name,
1819 entries[i].account_name, len_sam_name+1,
1820 len_sam_name);
1821 }
1822
1823 return NT_STATUS_OK;
1824 }
1825
1826 /*******************************************************************
1827 reads or writes a structure.
1828 ********************************************************************/
1829
1830 static BOOL sam_io_sam_dispinfo_4(const char *desc, SAM_DISPINFO_4 * sam,
1831 uint32 num_entries,
1832 prs_struct *ps, int depth)
1833 {
1834 uint32 i;
1835
1836 if (sam == NULL)
1837 return False;
1838
1839 prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_4");
1840 depth++;
1841
1842 if(!prs_align(ps))
1843 return False;
1844
1845 if (UNMARSHALLING(ps) && num_entries > 0) {
1846
1847 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY4, num_entries)) == NULL) {
1848 DEBUG(0, ("out of memory allocating SAM_ENTRY4\n"));
1849 return False;
1850 }
1851
1852 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR4, num_entries)) == NULL) {
1853 DEBUG(0, ("out of memory allocating SAM_STR4\n"));
1854 return False;
1855 }
1856 }
1857
1858 for (i = 0; i < num_entries; i++) {
1859 if(!sam_io_sam_entry4("", &sam->sam[i], ps, depth))
1860 return False;
1861 }
1862
1863 for (i = 0; i < num_entries; i++) {
1864 if(!smb_io_string2("acct_name", &sam->str[i].acct_name,
1865 sam->sam[i].hdr_acct_name.buffer, ps, depth))
1866 return False;
1867 }
1868
1869 return True;
1870 }
1871
1872 /*******************************************************************
1873 inits a SAM_DISPINFO_5 structure.
1874 ********************************************************************/
1875
1876 NTSTATUS init_sam_dispinfo_5(TALLOC_CTX *ctx, SAM_DISPINFO_5 **sam,
1877 uint32 num_entries, uint32 start_idx,
1878 struct samr_displayentry *entries)
1879 {
1880 uint32 len_sam_name;
1881 uint32 i;
1882
1883 DEBUG(5, ("init_sam_dispinfo_5: num_entries: %d\n", num_entries));
1884
1885 if (num_entries==0)
1886 return NT_STATUS_OK;
1887
1888 *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_5, num_entries);
1889 if (*sam == NULL)
1890 return NT_STATUS_NO_MEMORY;
1891
1892 if (!((*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY5, num_entries)))
1893 return NT_STATUS_NO_MEMORY;
1894
1895 if (!((*sam)->str=TALLOC_ARRAY(ctx, SAM_STR5, num_entries)))
1896 return NT_STATUS_NO_MEMORY;
1897
1898 for (i = 0; i < num_entries; i++) {
1899 DEBUG(11, ("init_sam_dispinfo_5: entry: %d\n",i));
1900
1901 len_sam_name = strlen(entries[i].account_name);
1902
1903 init_sam_entry5(&(*sam)->sam[i], start_idx+i+1, len_sam_name);
1904 init_string2(&(*sam)->str[i].grp_name, entries[i].account_name,
1905 len_sam_name+1, len_sam_name);
1906 }
1907
1908 return NT_STATUS_OK;
1909 }
1910
1911 /*******************************************************************
1912 reads or writes a structure.
1913 ********************************************************************/
1914
1915 static BOOL sam_io_sam_dispinfo_5(const char *desc, SAM_DISPINFO_5 * sam,
1916 uint32 num_entries,
1917 prs_struct *ps, int depth)
1918 {
1919 uint32 i;
1920
1921 if (sam == NULL)
1922 return False;
1923
1924 prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_5");
1925 depth++;
1926
1927 if(!prs_align(ps))
1928 return False;
1929
1930 if (UNMARSHALLING(ps) && num_entries > 0) {
1931
1932 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY5, num_entries)) == NULL) {
1933 DEBUG(0, ("out of memory allocating SAM_ENTRY5\n"));
1934 return False;
1935 }
1936
1937 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR5, num_entries)) == NULL) {
1938 DEBUG(0, ("out of memory allocating SAM_STR5\n"));
1939 return False;
1940 }
1941 }
1942
1943 for (i = 0; i < num_entries; i++) {
1944 if(!sam_io_sam_entry5("", &sam->sam[i], ps, depth))
1945 return False;
1946 }
1947
1948 for (i = 0; i < num_entries; i++) {
1949 if(!smb_io_string2("grp_name", &sam->str[i].grp_name,
1950 sam->sam[i].hdr_grp_name.buffer, ps, depth))
1951 return False;
1952 }
1953
1954 return True;
1955 }
1956
1957 /*******************************************************************
1958 inits a SAMR_R_QUERY_DISPINFO structure.
1959 ********************************************************************/
1960
1961 void init_samr_r_query_dispinfo(SAMR_R_QUERY_DISPINFO * r_u,
1962 uint32 num_entries, uint32 total_size, uint32 data_size,
1963 uint16 switch_level, SAM_DISPINFO_CTR * ctr,
1964 NTSTATUS status)
1965 {
1966 DEBUG(5, ("init_samr_r_query_dispinfo: level %d\n", switch_level));
1967
1968 r_u->total_size = total_size;
1969
1970 r_u->data_size = data_size;
1971
1972 r_u->switch_level = switch_level;
1973 r_u->num_entries = num_entries;
1974
1975 if (num_entries==0)
1976 r_u->ptr_entries = 0;
1977 else
1978 r_u->ptr_entries = 1;
1979
1980 r_u->num_entries2 = num_entries;
1981 r_u->ctr = ctr;
1982
1983 r_u->status = status;
1984 }
1985
1986 /*******************************************************************
1987 reads or writes a structure.
1988 ********************************************************************/
1989
1990 BOOL samr_io_r_query_dispinfo(const char *desc, SAMR_R_QUERY_DISPINFO * r_u,
1991 prs_struct *ps, int depth)
1992 {
1993 if (r_u == NULL)
1994 return False;
1995
1996 prs_debug(ps, depth, desc, "samr_io_r_query_dispinfo");
1997 depth++;
1998
1999 if(!prs_align(ps))
2000 return False;
2001
2002 if(!prs_uint32("total_size ", ps, depth, &r_u->total_size))
2003 return False;
2004 if(!prs_uint32("data_size ", ps, depth, &r_u->data_size))
2005 return False;
2006 if(!prs_uint16("switch_level", ps, depth, &r_u->switch_level))
2007 return False;
2008 if(!prs_align(ps))
2009 return False;
2010
2011 if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
2012 return False;
2013 if(!prs_uint32("ptr_entries ", ps, depth, &r_u->ptr_entries))
2014 return False;
2015
2016 if (r_u->ptr_entries==0) {
2017 if(!prs_align(ps))
2018 return False;
2019 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2020 return False;
2021
2022 return True;
2023 }
2024
2025 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
2026 return False;
2027
2028 switch (r_u->switch_level) {
2029 case 0x1:
2030 if(!sam_io_sam_dispinfo_1("users", r_u->ctr->sam.info1,
2031 r_u->num_entries, ps, depth))
2032 return False;
2033 break;
2034 case 0x2:
2035 if(!sam_io_sam_dispinfo_2("servers", r_u->ctr->sam.info2,
2036 r_u->num_entries, ps, depth))
2037 return False;
2038 break;
2039 case 0x3:
2040 if(!sam_io_sam_dispinfo_3("groups", r_u->ctr->sam.info3,
2041 r_u->num_entries, ps, depth))
2042 return False;
2043 break;
2044 case 0x4:
2045 if(!sam_io_sam_dispinfo_4("user list",
2046 r_u->ctr->sam.info4,
2047 r_u->num_entries, ps, depth))
2048 return False;
2049 break;
2050 case 0x5:
2051 if(!sam_io_sam_dispinfo_5("group list",
2052 r_u->ctr->sam.info5,
2053 r_u->num_entries, ps, depth))
2054 return False;
2055 break;
2056 default:
2057 DEBUG(0,("samr_io_r_query_dispinfo: unknown switch value\n"));
2058 break;
2059 }
2060
2061 if(!prs_align(ps))
2062 return False;
2063 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2064 return False;
2065
2066 return True;
2067 }
2068
2069 /*******************************************************************
2070 inits a SAMR_Q_OPEN_GROUP structure.
2071 ********************************************************************/
2072
2073 void init_samr_q_open_group(SAMR_Q_OPEN_GROUP * q_c,
2074 POLICY_HND *hnd,
2075 uint32 access_mask, uint32 rid)
2076 {
2077 DEBUG(5, ("init_samr_q_open_group\n"));
2078
2079 q_c->domain_pol = *hnd;
2080 q_c->access_mask = access_mask;
2081 q_c->rid_group = rid;
2082 }
2083
2084 /*******************************************************************
2085 reads or writes a structure.
2086 ********************************************************************/
2087
2088 BOOL samr_io_q_open_group(const char *desc, SAMR_Q_OPEN_GROUP * q_u,
2089 prs_struct *ps, int depth)
2090 {
2091 if (q_u == NULL)
2092 return False;
2093
2094 prs_debug(ps, depth, desc, "samr_io_q_open_group");
2095 depth++;
2096
2097 if(!prs_align(ps))
2098 return False;
2099
2100 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
2101 return False;
2102
2103 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
2104 return False;
2105 if(!prs_uint32("rid_group", ps, depth, &q_u->rid_group))
2106 return False;
2107
2108 return True;
2109 }
2110
2111 /*******************************************************************
2112 reads or writes a structure.
2113 ********************************************************************/
2114
2115 BOOL samr_io_r_open_group(const char *desc, SAMR_R_OPEN_GROUP * r_u,
2116 prs_struct *ps, int depth)
2117 {
2118 if (r_u == NULL)
2119 return False;
2120
2121 prs_debug(ps, depth, desc, "samr_io_r_open_group");
2122 depth++;
2123
2124 if(!prs_align(ps))
2125 return False;
2126
2127 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2128 return False;
2129
2130 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2131 return False;
2132
2133 return True;
2134 }
2135
2136 /*******************************************************************
2137 inits a GROUP_INFO1 structure.
2138 ********************************************************************/
2139
2140 void init_samr_group_info1(GROUP_INFO1 * gr1,
2141 char *acct_name, char *acct_desc,
2142 uint32 num_members)
2143 {
2144 DEBUG(5, ("init_samr_group_info1\n"));
2145
2146 gr1->unknown_1 = 0x3;
2147 gr1->num_members = num_members;
2148
2149 init_unistr2(&gr1->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2150 init_uni_hdr(&gr1->hdr_acct_name, &gr1->uni_acct_name);
2151 init_unistr2(&gr1->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2152 init_uni_hdr(&gr1->hdr_acct_desc, &gr1->uni_acct_desc);
2153 }
2154
2155 /*******************************************************************
2156 reads or writes a structure.
2157 ********************************************************************/
2158
2159 BOOL samr_io_group_info1(const char *desc, GROUP_INFO1 * gr1,
2160 prs_struct *ps, int depth)
2161 {
2162 uint16 dummy = 1;
2163
2164 if (gr1 == NULL)
2165 return False;
2166
2167 prs_debug(ps, depth, desc, "samr_io_group_info1");
2168 depth++;
2169
2170 if(!prs_uint16("level", ps, depth, &dummy))
2171 return False;
2172
2173 if(!prs_align(ps))
2174 return False;
2175
2176 if(!smb_io_unihdr("hdr_acct_name", &gr1->hdr_acct_name, ps, depth))
2177 return False;
2178
2179 if(!prs_uint32("unknown_1", ps, depth, &gr1->unknown_1))
2180 return False;
2181 if(!prs_uint32("num_members", ps, depth, &gr1->num_members))
2182 return False;
2183
2184 if(!smb_io_unihdr("hdr_acct_desc", &gr1->hdr_acct_desc, ps, depth))
2185 return False;
2186
2187 if(!smb_io_unistr2("uni_acct_name", &gr1->uni_acct_name,
2188 gr1->hdr_acct_name.buffer, ps, depth))
2189 return False;
2190
2191 if(!smb_io_unistr2("uni_acct_desc", &gr1->uni_acct_desc,
2192 gr1->hdr_acct_desc.buffer, ps, depth))
2193 return False;
2194
2195 return True;
2196 }
2197
2198 /*******************************************************************
2199 inits a GROUP_INFO2 structure.
2200 ********************************************************************/
2201
2202 void init_samr_group_info2(GROUP_INFO2 * gr2, const char *acct_name)
2203 {
2204 DEBUG(5, ("init_samr_group_info2\n"));
2205
2206 gr2->level = 2;
2207 init_unistr2(&gr2->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2208 init_uni_hdr(&gr2->hdr_acct_name, &gr2->uni_acct_name);
2209 }
2210
2211 /*******************************************************************
2212 reads or writes a structure.
2213 ********************************************************************/
2214
2215 BOOL samr_io_group_info2(const char *desc, GROUP_INFO2 *gr2, prs_struct *ps, int depth)
2216 {
2217 if (gr2 == NULL)
2218 return False;
2219
2220 prs_debug(ps, depth, desc, "samr_io_group_info2");
2221 depth++;
2222
2223 if(!prs_uint16("hdr_level", ps, depth, &gr2->level))
2224 return False;
2225
2226 if(!smb_io_unihdr("hdr_acct_name", &gr2->hdr_acct_name, ps, depth))
2227 return False;
2228 if(!smb_io_unistr2("uni_acct_name", &gr2->uni_acct_name,
2229 gr2->hdr_acct_name.buffer, ps, depth))
2230 return False;
2231
2232 return True;
2233 }
2234
2235 /*******************************************************************
2236 inits a GROUP_INFO3 structure.
2237 ********************************************************************/
2238
2239 void init_samr_group_info3(GROUP_INFO3 *gr3)
2240 {
2241 DEBUG(5, ("init_samr_group_info3\n"));
2242
2243 gr3->unknown_1 = 0x3;
2244 }
2245
2246 /*******************************************************************
2247 reads or writes a structure.
2248 ********************************************************************/
2249
2250 BOOL samr_io_group_info3(const char *desc, GROUP_INFO3 *gr3, prs_struct *ps, int depth)
2251 {
2252 if (gr3 == NULL)
2253 return False;
2254
2255 prs_debug(ps, depth, desc, "samr_io_group_info3");
2256 depth++;
2257
2258 if(!prs_align(ps))
2259 return False;
2260
2261 if(!prs_uint32("unknown_1", ps, depth, &gr3->unknown_1))
2262 return False;
2263
2264 return True;
2265 }
2266
2267 /*******************************************************************
2268 inits a GROUP_INFO4 structure.
2269 ********************************************************************/
2270
2271 void init_samr_group_info4(GROUP_INFO4 * gr4, const char *acct_desc)
2272 {
2273 DEBUG(5, ("init_samr_group_info4\n"));
2274
2275 gr4->level = 4;
2276 init_unistr2(&gr4->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2277 init_uni_hdr(&gr4->hdr_acct_desc, &gr4->uni_acct_desc);
2278 }
2279
2280 /*******************************************************************
2281 reads or writes a structure.
2282 ********************************************************************/
2283
2284 BOOL samr_io_group_info4(const char *desc, GROUP_INFO4 * gr4,
2285 prs_struct *ps, int depth)
2286 {
2287 if (gr4 == NULL)
2288 return False;
2289
2290 prs_debug(ps, depth, desc, "samr_io_group_info4");
2291 depth++;
2292
2293 if(!prs_uint16("hdr_level", ps, depth, &gr4->level))
2294 return False;
2295 if(!smb_io_unihdr("hdr_acct_desc", &gr4->hdr_acct_desc, ps, depth))
2296 return False;
2297 if(!smb_io_unistr2("uni_acct_desc", &gr4->uni_acct_desc,
2298 gr4->hdr_acct_desc.buffer, ps, depth))
2299 return False;
2300
2301 return True;
2302 }
2303
2304 /*******************************************************************
2305 reads or writes a structure.
2306 ********************************************************************/
2307
2308 static BOOL samr_group_info_ctr(const char *desc, GROUP_INFO_CTR **ctr,
2309 prs_struct *ps, int depth)
2310 {
2311 if (UNMARSHALLING(ps))
2312 *ctr = PRS_ALLOC_MEM(ps,GROUP_INFO_CTR,1);
2313
2314 if (*ctr == NULL)
2315 return False;
2316
2317 prs_debug(ps, depth, desc, "samr_group_info_ctr");
2318 depth++;
2319
2320 if(!prs_uint16("switch_value1", ps, depth, &(*ctr)->switch_value1))
2321 return False;
2322
2323 switch ((*ctr)->switch_value1) {
2324 case 1:
2325 if(!samr_io_group_info1("group_info1", &(*ctr)->group.info1, ps, depth))
2326 return False;
2327 break;
2328 case 2:
2329 if(!samr_io_group_info2("group_info2", &(*ctr)->group.info2, ps, depth))
2330 return False;
2331 break;
2332 case 3:
2333 if(!samr_io_group_info3("group_info3", &(*ctr)->group.info3, ps, depth))
2334 return False;
2335 break;
2336 case 4:
2337 if(!samr_io_group_info4("group_info4", &(*ctr)->group.info4, ps, depth))
2338 return False;
2339 break;
2340 default:
2341 DEBUG(0,("samr_group_info_ctr: unsupported switch level\n"));
2342 break;
2343 }
2344
2345 return True;
2346 }
2347
2348 /*******************************************************************
2349 inits a SAMR_Q_CREATE_DOM_GROUP structure.
2350 ********************************************************************/
2351
2352 void init_samr_q_create_dom_group(SAMR_Q_CREATE_DOM_GROUP * q_e,
2353 POLICY_HND *pol, const char *acct_desc,
2354 uint32 access_mask)
2355 {
2356 DEBUG(5, ("init_samr_q_create_dom_group\n"));
2357
2358 q_e->pol = *pol;
2359
2360 init_unistr2(&q_e->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2361 init_uni_hdr(&q_e->hdr_acct_desc, &q_e->uni_acct_desc);
2362
2363 q_e->access_mask = access_mask;
2364 }
2365
2366 /*******************************************************************
2367 reads or writes a structure.
2368 ********************************************************************/
2369
2370 BOOL samr_io_q_create_dom_group(const char *desc, SAMR_Q_CREATE_DOM_GROUP * q_e,
2371 prs_struct *ps, int depth)
2372 {
2373 if (q_e == NULL)
2374 return False;
2375
2376 prs_debug(ps, depth, desc, "samr_io_q_create_dom_group");
2377 depth++;
2378
2379 if(!prs_align(ps))
2380 return False;
2381
2382 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2383 return False;
2384
2385 if(!smb_io_unihdr("hdr_acct_desc", &q_e->hdr_acct_desc, ps, depth))
2386 return False;
2387 if(!smb_io_unistr2("uni_acct_desc", &q_e->uni_acct_desc,
2388 q_e->hdr_acct_desc.buffer, ps, depth))
2389 return False;
2390
2391 if(!prs_align(ps))
2392 return False;
2393 if(!prs_uint32("access", ps, depth, &q_e->access_mask))
2394 return False;
2395
2396 return True;
2397 }
2398
2399 /*******************************************************************
2400 reads or writes a structure.
2401 ********************************************************************/
2402
2403 BOOL samr_io_r_create_dom_group(const char *desc, SAMR_R_CREATE_DOM_GROUP * r_u,
2404 prs_struct *ps, int depth)
2405 {
2406 if (r_u == NULL)
2407 return False;
2408
2409 prs_debug(ps, depth, desc, "samr_io_r_create_dom_group");
2410 depth++;
2411
2412 if(!prs_align(ps))
2413 return False;
2414
2415 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2416 return False;
2417
2418 if(!prs_uint32("rid ", ps, depth, &r_u->rid))
2419 return False;
2420 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2421 return False;
2422
2423 return True;
2424 }
2425
2426 /*******************************************************************
2427 inits a SAMR_Q_DELETE_DOM_GROUP structure.
2428 ********************************************************************/
2429
2430 void init_samr_q_delete_dom_group(SAMR_Q_DELETE_DOM_GROUP * q_c,
2431 POLICY_HND *hnd)
2432 {
2433 DEBUG(5, ("init_samr_q_delete_dom_group\n"));
2434
2435 q_c->group_pol = *hnd;
2436 }
2437
2438 /*******************************************************************
2439 reads or writes a structure.
2440 ********************************************************************/
2441
2442 BOOL samr_io_q_delete_dom_group(const char *desc, SAMR_Q_DELETE_DOM_GROUP * q_u,
2443 prs_struct *ps, int depth)
2444 {
2445 if (q_u == NULL)
2446 return False;
2447
2448 prs_debug(ps, depth, desc, "samr_io_q_delete_dom_group");
2449 depth++;
2450
2451 if(!prs_align(ps))
2452 return False;
2453
2454 if(!smb_io_pol_hnd("group_pol", &q_u->group_pol, ps, depth))
2455 return False;
2456
2457 return True;
2458 }
2459
2460 /*******************************************************************
2461 reads or writes a structure.
2462 ********************************************************************/
2463
2464 BOOL samr_io_r_delete_dom_group(const char *desc, SAMR_R_DELETE_DOM_GROUP * r_u,
2465 prs_struct *ps, int depth)
2466 {
2467 if (r_u == NULL)
2468 return False;
2469
2470 prs_debug(ps, depth, desc, "samr_io_r_delete_dom_group");
2471 depth++;
2472
2473 if(!prs_align(ps))
2474 return False;
2475
2476 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2477 return False;
2478
2479 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2480 return False;
2481
2482 return True;
2483 }
2484
2485 /*******************************************************************
2486 inits a SAMR_Q_DEL_GROUPMEM structure.
2487 ********************************************************************/
2488
2489 void init_samr_q_del_groupmem(SAMR_Q_DEL_GROUPMEM * q_e,
2490 POLICY_HND *pol, uint32 rid)
2491 {
2492 DEBUG(5, ("init_samr_q_del_groupmem\n"));
2493
2494 q_e->pol = *pol;
2495 q_e->rid = rid;
2496 }
2497
2498 /*******************************************************************
2499 reads or writes a structure.
2500 ********************************************************************/
2501
2502 BOOL samr_io_q_del_groupmem(const char *desc, SAMR_Q_DEL_GROUPMEM * q_e,
2503 prs_struct *ps, int depth)
2504 {
2505 if (q_e == NULL)
2506 return False;
2507
2508 prs_debug(ps, depth, desc, "samr_io_q_del_groupmem");
2509 depth++;
2510
2511 if(!prs_align(ps))
2512 return False;
2513
2514 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2515 return False;
2516
2517 if(!prs_uint32("rid", ps, depth, &q_e->rid))
2518 return False;
2519
2520 return True;
2521 }
2522
2523 /*******************************************************************
2524 inits a SAMR_R_DEL_GROUPMEM structure.
2525 ********************************************************************/
2526
2527 void init_samr_r_del_groupmem(SAMR_R_DEL_GROUPMEM * r_u, POLICY_HND *pol,
2528 NTSTATUS status)
2529 {
2530 DEBUG(5, ("init_samr_r_del_groupmem\n"));
2531
2532 r_u->status = status;
2533 }
2534
2535 /*******************************************************************
2536 reads or writes a structure.
2537 ********************************************************************/
2538
2539 BOOL samr_io_r_del_groupmem(const char *desc, SAMR_R_DEL_GROUPMEM * r_u,
2540 prs_struct *ps, int depth)
2541 {
2542 if (r_u == NULL)
2543 return False;
2544
2545 prs_debug(ps, depth, desc, "samr_io_r_del_groupmem");
2546 depth++;
2547
2548 if(!prs_align(ps))
2549 return False;
2550
2551 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2552 return False;
2553
2554 return True;
2555 }
2556
2557 /*******************************************************************
2558 inits a SAMR_Q_ADD_GROUPMEM structure.
2559 ********************************************************************/
2560
2561 void init_samr_q_add_groupmem(SAMR_Q_ADD_GROUPMEM * q_e,
2562 POLICY_HND *pol, uint32 rid)
2563 {
2564 DEBUG(5, ("init_samr_q_add_groupmem\n"));
2565
2566 q_e->pol = *pol;
2567 q_e->rid = rid;
2568 q_e->unknown = 0x0005;
2569 }
2570
2571 /*******************************************************************
2572 reads or writes a structure.
2573 ********************************************************************/
2574
2575 BOOL samr_io_q_add_groupmem(const char *desc, SAMR_Q_ADD_GROUPMEM * q_e,
2576 prs_struct *ps, int depth)
2577 {
2578 if (q_e == NULL)
2579 return False;
2580
2581 prs_debug(ps, depth, desc, "samr_io_q_add_groupmem");
2582 depth++;
2583
2584 if(!prs_align(ps))
2585 return False;
2586
2587 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2588 return False;
2589
2590 if(!prs_uint32("rid ", ps, depth, &q_e->rid))
2591 return False;
2592 if(!prs_uint32("unknown", ps, depth, &q_e->unknown))
2593 return False;
2594
2595 return True;
2596 }
2597
2598 /*******************************************************************
2599 inits a SAMR_R_ADD_GROUPMEM structure.
2600 ********************************************************************/
2601
2602 void init_samr_r_add_groupmem(SAMR_R_ADD_GROUPMEM * r_u, POLICY_HND *pol,
2603 NTSTATUS status)
2604 {
2605 DEBUG(5, ("init_samr_r_add_groupmem\n"));
2606
2607 r_u->status = status;
2608 }
2609
2610 /*******************************************************************
2611 reads or writes a structure.
2612 ********************************************************************/
2613
2614 BOOL samr_io_r_add_groupmem(const char *desc, SAMR_R_ADD_GROUPMEM * r_u,
2615 prs_struct *ps, int depth)
2616 {
2617 if (r_u == NULL)
2618 return False;
2619
2620 prs_debug(ps, depth, desc, "samr_io_r_add_groupmem");
2621 depth++;
2622
2623 if(!prs_align(ps))
2624 return False;
2625
2626 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2627 return False;
2628
2629 return True;
2630 }
2631
2632 /*******************************************************************
2633 inits a SAMR_Q_SET_GROUPINFO structure.
2634 ********************************************************************/
2635
2636 void init_samr_q_set_groupinfo(SAMR_Q_SET_GROUPINFO * q_e,
2637 POLICY_HND *pol, GROUP_INFO_CTR * ctr)
2638 {
2639 DEBUG(5, ("init_samr_q_set_groupinfo\n"));
2640
2641 q_e->pol = *pol;
2642 q_e->ctr = ctr;
2643 }
2644
2645 /*******************************************************************
2646 reads or writes a structure.
2647 ********************************************************************/
2648
2649 BOOL samr_io_q_set_groupinfo(const char *desc, SAMR_Q_SET_GROUPINFO * q_e,
2650 prs_struct *ps, int depth)
2651 {
2652 if (q_e == NULL)
2653 return False;
2654
2655 prs_debug(ps, depth, desc, "samr_io_q_set_groupinfo");
2656 depth++;
2657
2658 if(!prs_align(ps))
2659 return False;
2660
2661 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2662 return False;
2663
2664 if(!samr_group_info_ctr("ctr", &q_e->ctr, ps, depth))
2665 return False;
2666
2667 return True;
2668 }
2669
2670 /*******************************************************************
2671 inits a SAMR_R_SET_GROUPINFO structure.
2672 ********************************************************************/
2673
2674 void init_samr_r_set_groupinfo(SAMR_R_SET_GROUPINFO * r_u, NTSTATUS status)
2675 {
2676 DEBUG(5, ("init_samr_r_set_groupinfo\n"));
2677
2678 r_u->status = status;
2679 }
2680
2681 /*******************************************************************
2682 reads or writes a structure.
2683 ********************************************************************/
2684
2685 BOOL samr_io_r_set_groupinfo(const char *desc, SAMR_R_SET_GROUPINFO * r_u,
2686 prs_struct *ps, int depth)
2687 {
2688 if (r_u == NULL)
2689 return False;
2690
2691 prs_debug(ps, depth, desc, "samr_io_r_set_groupinfo");
2692 depth++;
2693
2694 if(!prs_align(ps))
2695 return False;
2696
2697 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2698 return False;
2699
2700 return True;
2701 }
2702
2703 /*******************************************************************
2704 inits a SAMR_Q_QUERY_GROUPINFO structure.
2705 ********************************************************************/
2706
2707 void init_samr_q_query_groupinfo(SAMR_Q_QUERY_GROUPINFO * q_e,
2708 POLICY_HND *pol, uint16 switch_level)
2709 {
2710 DEBUG(5, ("init_samr_q_query_groupinfo\n"));
2711
2712 q_e->pol = *pol;
2713
2714 q_e->switch_level = switch_level;
2715 }
2716
2717 /*******************************************************************
2718 reads or writes a structure.
2719 ********************************************************************/
2720
2721 BOOL samr_io_q_query_groupinfo(const char *desc, SAMR_Q_QUERY_GROUPINFO * q_e,
2722 prs_struct *ps, int depth)
2723 {
2724 if (q_e == NULL)
2725 return False;
2726
2727 prs_debug(ps, depth, desc, "samr_io_q_query_groupinfo");
2728 depth++;
2729
2730 if(!prs_align(ps))
2731 return False;
2732
2733 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2734 return False;
2735
2736 if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
2737 return False;
2738
2739 return True;
2740 }
2741
2742 /*******************************************************************
2743 inits a SAMR_R_QUERY_GROUPINFO structure.
2744 ********************************************************************/
2745
2746 void init_samr_r_query_groupinfo(SAMR_R_QUERY_GROUPINFO * r_u,
2747 GROUP_INFO_CTR * ctr, NTSTATUS status)
2748 {
2749 DEBUG(5, ("init_samr_r_query_groupinfo\n"));
2750
2751 r_u->ptr = (NT_STATUS_IS_OK(status) && ctr != NULL) ? 1 : 0;
2752 r_u->ctr = ctr;
2753 r_u->status = status;
2754 }
2755
2756 /*******************************************************************
2757 reads or writes a structure.
2758 ********************************************************************/
2759
2760 BOOL samr_io_r_query_groupinfo(const char *desc, SAMR_R_QUERY_GROUPINFO * r_u,
2761 prs_struct *ps, int depth)
2762 {
2763 if (r_u == NULL)
2764 return False;
2765
2766 prs_debug(ps, depth, desc, "samr_io_r_query_groupinfo");
2767 depth++;
2768
2769 if(!prs_align(ps))
2770 return False;
2771
2772 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
2773 return False;
2774
2775 if (r_u->ptr != 0) {
2776 if(!samr_group_info_ctr("ctr", &r_u->ctr, ps, depth))
2777 return False;
2778 }
2779
2780 if(!prs_align(ps))
2781 return False;
2782 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2783 return False;
2784
2785 return True;
2786 }
2787
2788 /*******************************************************************
2789 inits a SAMR_Q_QUERY_GROUPMEM structure.
2790 ********************************************************************/
2791
2792 void init_samr_q_query_groupmem(SAMR_Q_QUERY_GROUPMEM * q_c, POLICY_HND *hnd)
2793 {
2794 DEBUG(5, ("init_samr_q_query_groupmem\n"));
2795
2796 q_c->group_pol = *hnd;
2797 }
2798
2799 /*******************************************************************
2800 reads or writes a structure.
2801 ********************************************************************/
2802
2803 BOOL samr_io_q_query_groupmem(const char *desc, SAMR_Q_QUERY_GROUPMEM * q_u,
2804 prs_struct *ps, int depth)
2805 {
2806 if (q_u == NULL)
2807 return False;
2808
2809 prs_debug(ps, depth, desc, "samr_io_q_query_groupmem");
2810 depth++;
2811
2812 if(!prs_align(ps))
2813 return False;
2814
2815 if(!smb_io_pol_hnd("group_pol", &q_u->group_pol, ps, depth))
2816 return False;
2817
2818 return True;
2819 }
2820
2821 /*******************************************************************
2822 inits a SAMR_R_QUERY_GROUPMEM structure.
2823 ********************************************************************/
2824
2825 void init_samr_r_query_groupmem(SAMR_R_QUERY_GROUPMEM * r_u,
2826 uint32 num_entries, uint32 *rid,
2827 uint32 *attr, NTSTATUS status)
2828 {
2829 DEBUG(5, ("init_samr_r_query_groupmem\n"));
2830
2831 if (NT_STATUS_IS_OK(status)) {
2832 r_u->ptr = 1;
2833 r_u->num_entries = num_entries;
2834
2835 r_u->ptr_attrs = attr != NULL ? 1 : 0;
2836 r_u->ptr_rids = rid != NULL ? 1 : 0;
2837
2838 r_u->num_rids = num_entries;
2839 r_u->rid = rid;
2840
2841 r_u->num_attrs = num_entries;
2842 r_u->attr = attr;
2843 } else {
2844 r_u->ptr = 0;
2845 r_u->num_entries = 0;
2846 }
2847
2848 r_u->status = status;
2849 }
2850
2851 /*******************************************************************
2852 reads or writes a structure.
2853 ********************************************************************/
2854
2855 BOOL samr_io_r_query_groupmem(const char *desc, SAMR_R_QUERY_GROUPMEM * r_u,
2856 prs_struct *ps, int depth)
2857 {
2858 uint32 i;
2859
2860 if (r_u == NULL)
2861 return False;
2862
2863 if (UNMARSHALLING(ps))
2864 ZERO_STRUCTP(r_u);
2865
2866 prs_debug(ps, depth, desc, "samr_io_r_query_groupmem");
2867 depth++;
2868
2869 if(!prs_align(ps))
2870 return False;
2871
2872 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
2873 return False;
2874 if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
2875 return False;
2876
2877 if (r_u->ptr != 0) {
2878 if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids))
2879 return False;
2880 if(!prs_uint32("ptr_attrs", ps, depth, &r_u->ptr_attrs))
2881 return False;
2882
2883 if (r_u->ptr_rids != 0) {
2884 if(!prs_uint32("num_rids", ps, depth, &r_u->num_rids))
2885 return False;
2886 if (UNMARSHALLING(ps) && r_u->num_rids != 0) {
2887 r_u->rid = PRS_ALLOC_MEM(ps,uint32,r_u->num_rids);
2888 if (r_u->rid == NULL)
2889 return False;
2890 }
2891
2892 for (i = 0; i < r_u->num_rids; i++) {
2893 if(!prs_uint32("", ps, depth, &r_u->rid[i]))
2894 return False;
2895 }
2896 }
2897
2898 if (r_u->ptr_attrs != 0) {
2899 if(!prs_uint32("num_attrs", ps, depth, &r_u->num_attrs))
2900 return False;
2901
2902 if (UNMARSHALLING(ps) && r_u->num_attrs != 0) {
2903 r_u->attr = PRS_ALLOC_MEM(ps,uint32,r_u->num_attrs);
2904 if (r_u->attr == NULL)
2905 return False;
2906 }
2907
2908 for (i = 0; i < r_u->num_attrs; i++) {
2909 if(!prs_uint32("", ps, depth, &r_u->attr[i]))
2910 return False;
2911 }
2912 }
2913 }
2914
2915 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2916 return False;
2917
2918 return True;
2919 }
2920
2921 /*******************************************************************
2922 inits a SAMR_Q_QUERY_USERGROUPS structure.
2923 ********************************************************************/
2924
2925 void init_samr_q_query_usergroups(SAMR_Q_QUERY_USERGROUPS * q_u,
2926 POLICY_HND *hnd)
2927 {
2928 DEBUG(5, ("init_samr_q_query_usergroups\n"));
2929
2930 q_u->pol = *hnd;
2931 }
2932
2933 /*******************************************************************
2934 reads or writes a structure.
2935 ********************************************************************/
2936
2937 BOOL samr_io_q_query_usergroups(const char *desc, SAMR_Q_QUERY_USERGROUPS * q_u,
2938 prs_struct *ps, int depth)
2939 {
2940 if (q_u == NULL)
2941 return False;
2942
2943 prs_debug(ps, depth, desc, "samr_io_q_query_usergroups");
2944 depth++;
2945
2946 if(!prs_align(ps))
2947 return False;
2948
2949 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
2950 return False;
2951
2952 return True;
2953 }
2954
2955 /*******************************************************************
2956 inits a SAMR_R_QUERY_USERGROUPS structure.
2957 ********************************************************************/
2958
2959 void init_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS * r_u,
2960 uint32 num_gids, DOM_GID * gid,
2961 NTSTATUS status)
2962 {
2963 DEBUG(5, ("init_samr_r_query_usergroups\n"));
2964
2965 if (NT_STATUS_IS_OK(status)) {
2966 r_u->ptr_0 = 1;
2967 r_u->num_entries = num_gids;
2968 r_u->ptr_1 = (num_gids != 0) ? 1 : 0;
2969 r_u->num_entries2 = num_gids;
2970
2971 r_u->gid = gid;
2972 } else {
2973 r_u->ptr_0 = 0;
2974 r_u->num_entries = 0;
2975 r_u->ptr_1 = 0;
2976 r_u->gid = NULL;
2977 }
2978
2979 r_u->status = status;
2980 }
2981
2982 /*******************************************************************
2983 reads or writes a structure.
2984 ********************************************************************/
2985
2986 BOOL samr_io_gids(const char *desc, uint32 *num_gids, DOM_GID ** gid,
2987 prs_struct *ps, int depth)
2988 {
2989 uint32 i;
2990 if (gid == NULL)
2991 return False;
2992
2993 prs_debug(ps, depth, desc, "samr_io_gids");
2994 depth++;
2995
2996 if(!prs_align(ps))
2997 return False;
2998
2999 if(!prs_uint32("num_gids", ps, depth, num_gids))
3000 return False;
3001
3002 if ((*num_gids) != 0) {
3003 if (UNMARSHALLING(ps)) {
3004 (*gid) = PRS_ALLOC_MEM(ps,DOM_GID,*num_gids);
3005 }
3006
3007 if ((*gid) == NULL) {
3008 return False;
3009 }
3010
3011 for (i = 0; i < (*num_gids); i++) {
3012 if(!smb_io_gid("gids", &(*gid)[i], ps, depth))
3013 return False;
3014 }
3015 }
3016
3017 return True;
3018 }
3019
3020 /*******************************************************************
3021 reads or writes a structure.
3022 ********************************************************************/
3023
3024 BOOL samr_io_r_query_usergroups(const char *desc, SAMR_R_QUERY_USERGROUPS * r_u,
3025 prs_struct *ps, int depth)
3026 {
3027 if (r_u == NULL)
3028 return False;
3029
3030 prs_debug(ps, depth, desc, "samr_io_r_query_usergroups");
3031 depth++;
3032
3033 if(!prs_align(ps))
3034 return False;
3035
3036 if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
3037 return False;
3038
3039 if (r_u->ptr_0 != 0) {
3040 if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
3041 return False;
3042 if(!prs_uint32("ptr_1 ", ps, depth, &r_u->ptr_1))
3043 return False;
3044
3045 if (r_u->num_entries != 0 && r_u->ptr_1 != 0) {
3046 if(!samr_io_gids("gids", &r_u->num_entries2, &r_u->gid, ps, depth))
3047 return False;
3048 }
3049 }
3050
3051 if(!prs_align(ps))
3052 return False;
3053 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3054 return False;
3055
3056 return True;
3057 }
3058
3059 /*******************************************************************
3060 inits a SAMR_Q_ENUM_DOMAINS structure.
3061 ********************************************************************/
3062
3063 void init_samr_q_enum_domains(SAMR_Q_ENUM_DOMAINS * q_e,
3064 POLICY_HND *pol,
3065 uint32 start_idx, uint32 size)
3066 {
3067 DEBUG(5, ("init_samr_q_enum_domains\n"));
3068
3069 q_e->pol = *pol;
3070
3071 q_e->start_idx = start_idx;
3072 q_e->max_size = size;
3073 }
3074
3075 /*******************************************************************
3076 reads or writes a structure.
3077 ********************************************************************/
3078
3079 BOOL samr_io_q_enum_domains(const char *desc, SAMR_Q_ENUM_DOMAINS * q_e,
3080 prs_struct *ps, int depth)
3081 {
3082 if (q_e == NULL)
3083 return False;
3084
3085 prs_debug(ps, depth, desc, "samr_io_q_enum_domains");
3086 depth++;
3087
3088 if(!prs_align(ps))
3089 return False;
3090
3091 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
3092 return False;
3093
3094 if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3095 return False;
3096 if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3097 return False;
3098
3099 return True;
3100 }
3101
3102 /*******************************************************************
3103 inits a SAMR_R_ENUM_DOMAINS structure.
3104 ********************************************************************/
3105
3106 void init_samr_r_enum_domains(SAMR_R_ENUM_DOMAINS * r_u,
3107 uint32 next_idx, uint32 num_sam_entries)
3108 {
3109 DEBUG(5, ("init_samr_r_enum_domains\n"));
3110
3111 r_u->next_idx = next_idx;
3112
3113 if (num_sam_entries != 0) {
3114 r_u->ptr_entries1 = 1;
3115 r_u->ptr_entries2 = 1;
3116 r_u->num_entries2 = num_sam_entries;
3117 r_u->num_entries3 = num_sam_entries;
3118
3119 r_u->num_entries4 = num_sam_entries;
3120 } else {
3121 r_u->ptr_entries1 = 0;
3122 r_u->num_entries2 = num_sam_entries;
3123 r_u->ptr_entries2 = 1;
3124 }
3125 }
3126
3127 /*******************************************************************
3128 reads or writes a structure.
3129 ********************************************************************/
3130
3131 BOOL samr_io_r_enum_domains(const char *desc, SAMR_R_ENUM_DOMAINS * r_u,
3132 prs_struct *ps, int depth)
3133 {
3134 uint32 i;
3135
3136 if (r_u == NULL)
3137 return False;
3138
3139 prs_debug(ps, depth, desc, "samr_io_r_enum_domains");
3140 depth++;
3141
3142 if(!prs_align(ps))
3143 return False;
3144
3145 if(!prs_uint32("next_idx ", ps, depth, &r_u->next_idx))
3146 return False;
3147 if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3148 return False;
3149
3150 if (r_u->ptr_entries1 != 0) {
3151 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3152 return False;
3153 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3154 return False;
3155 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3156 return False;
3157
3158 if (UNMARSHALLING(ps)) {
3159 r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3160 r_u->uni_dom_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3161 }
3162
3163 if ((r_u->sam == NULL || r_u->uni_dom_name == NULL) && r_u->num_entries2 != 0) {
3164 DEBUG(0, ("NULL pointers in SAMR_R_ENUM_DOMAINS\n"));
3165 r_u->num_entries4 = 0;
3166 r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3167 return False;
3168 }
3169
3170 for (i = 0; i < r_u->num_entries2; i++) {
3171 fstring tmp;
3172 slprintf(tmp, sizeof(tmp) - 1, "dom[%d]", i);
3173 if(!sam_io_sam_entry(tmp, &r_u->sam[i], ps, depth))
3174 return False;
3175 }
3176
3177 for (i = 0; i < r_u->num_entries2; i++) {
3178 fstring tmp;
3179 slprintf(tmp, sizeof(tmp) - 1, "dom[%d]", i);
3180 if(!smb_io_unistr2(tmp, &r_u->uni_dom_name[i],
3181 r_u->sam[i].hdr_name.buffer, ps,
3182 depth))
3183 return False;
3184 }
3185
3186 }
3187
3188 if(!prs_align(ps))
3189 return False;
3190 if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3191 return False;
3192 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3193 return False;
3194
3195 return True;
3196 }
3197
3198 /*******************************************************************
3199 inits a SAMR_Q_ENUM_DOM_GROUPS structure.
3200 ********************************************************************/
3201
3202 void init_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS * q_e,
3203 POLICY_HND *pol,
3204 uint32 start_idx, uint32 size)
3205 {
3206 DEBUG(5, ("init_samr_q_enum_dom_groups\n"));
3207
3208 q_e->pol = *pol;
3209
3210 q_e->start_idx = start_idx;
3211 q_e->max_size = size;
3212 }
3213
3214 /*******************************************************************
3215 reads or writes a structure.
3216 ********************************************************************/
3217
3218 BOOL samr_io_q_enum_dom_groups(const char *desc, SAMR_Q_ENUM_DOM_GROUPS * q_e,
3219 prs_struct *ps, int depth)
3220 {
3221 if (q_e == NULL)
3222 return False;
3223
3224 prs_debug(ps, depth, desc, "samr_io_q_enum_dom_groups");
3225 depth++;
3226
3227 if(!prs_align(ps))
3228 return False;
3229
3230 if(!smb_io_pol_hnd("pol", &(q_e->pol), ps, depth))
3231 return False;
3232
3233 if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3234 return False;
3235 if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3236 return False;
3237
3238 return True;
3239 }
3240
3241 /*******************************************************************
3242 inits a SAMR_R_ENUM_DOM_GROUPS structure.
3243 ********************************************************************/
3244
3245 void init_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS * r_u,
3246 uint32 next_idx, uint32 num_sam_entries)
3247 {
3248 DEBUG(5, ("init_samr_r_enum_dom_groups\n"));
3249
3250 r_u->next_idx = next_idx;
3251
3252 if (num_sam_entries != 0) {
3253 r_u->ptr_entries1 = 1;
3254 r_u->ptr_entries2 = 1;
3255 r_u->num_entries2 = num_sam_entries;
3256 r_u->num_entries3 = num_sam_entries;
3257
3258 r_u->num_entries4 = num_sam_entries;
3259 } else {
3260 r_u->ptr_entries1 = 0;
3261 r_u->num_entries2 = num_sam_entries;
3262 r_u->ptr_entries2 = 1;
3263 }
3264 }
3265
3266 /*******************************************************************
3267 reads or writes a structure.
3268 ********************************************************************/
3269
3270 BOOL samr_io_r_enum_dom_groups(const char *desc, SAMR_R_ENUM_DOM_GROUPS * r_u,
3271 prs_struct *ps, int depth)
3272 {
3273 uint32 i;
3274
3275 if (r_u == NULL)
3276 return False;
3277
3278 prs_debug(ps, depth, desc, "samr_io_r_enum_dom_groups");
3279 depth++;
3280
3281 if(!prs_align(ps))
3282 return False;
3283
3284 if(!prs_uint32("next_idx ", ps, depth, &r_u->next_idx))
3285 return False;
3286 if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3287 return False;
3288
3289 if (r_u->ptr_entries1 != 0) {
3290 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3291 return False;
3292 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3293 return False;
3294 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3295 return False;
3296
3297 if (UNMARSHALLING(ps)) {
3298 r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3299 r_u->uni_grp_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3300 }
3301
3302 if ((r_u->sam == NULL || r_u->uni_grp_name == NULL) && r_u->num_entries2 != 0) {
3303 DEBUG(0,
3304 ("NULL pointers in SAMR_R_ENUM_DOM_GROUPS\n"));
3305 r_u->num_entries4 = 0;
3306 r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3307 return False;
3308 }
3309
3310 for (i = 0; i < r_u->num_entries2; i++) {
3311 if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
3312 return False;
3313 }
3314
3315 for (i = 0; i < r_u->num_entries2; i++) {
3316 if(!smb_io_unistr2("", &r_u->uni_grp_name[i],
3317 r_u->sam[i].hdr_name.buffer, ps, depth))
3318 return False;
3319 }
3320 }
3321
3322 if(!prs_align(ps))
3323 return False;
3324 if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3325 return False;
3326 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3327 return False;
3328
3329 return True;
3330 }
3331
3332 /*******************************************************************
3333 inits a SAMR_Q_ENUM_DOM_ALIASES structure.
3334 ********************************************************************/
3335
3336 void init_samr_q_enum_dom_aliases(SAMR_Q_ENUM_DOM_ALIASES * q_e,
3337 POLICY_HND *pol, uint32 start_idx,
3338 uint32 size)
3339 {
3340 DEBUG(5, ("init_samr_q_enum_dom_aliases\n"));
3341
3342 q_e->pol = *pol;
3343
3344 q_e->start_idx = start_idx;
3345 q_e->max_size = size;
3346 }
3347
3348
3349 /*******************************************************************
3350 reads or writes a structure.
3351 ********************************************************************/
3352
3353 BOOL samr_io_q_enum_dom_aliases(const char *desc, SAMR_Q_ENUM_DOM_ALIASES * q_e,
3354 prs_struct *ps, int depth)
3355 {
3356 if (q_e == NULL)
3357 return False;
3358
3359 prs_debug(ps, depth, desc, "samr_io_q_enum_dom_aliases");
3360 depth++;
3361
3362 if(!prs_align(ps))
3363 return False;
3364
3365 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
3366 return False;
3367
3368 if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3369 return False;
3370 if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3371 return False;
3372
3373 return True;
3374 }
3375
3376 /*******************************************************************
3377 inits a SAMR_R_ENUM_DOM_ALIASES structure.
3378 ********************************************************************/
3379
3380 void init_samr_r_enum_dom_aliases(SAMR_R_ENUM_DOM_ALIASES *r_u, uint32 next_idx, uint32 num_sam_entries)
3381 {
3382 DEBUG(5, ("init_samr_r_enum_dom_aliases\n"));
3383
3384 r_u->next_idx = next_idx;
3385
3386 if (num_sam_entries != 0) {
3387 r_u->ptr_entries1 = 1;
3388 r_u->ptr_entries2 = 1;
3389 r_u->num_entries2 = num_sam_entries;
3390 r_u->num_entries3 = num_sam_entries;
3391
3392 r_u->num_entries4 = num_sam_entries;
3393 } else {
3394 r_u->ptr_entries1 = 0;
3395 r_u->num_entries2 = num_sam_entries;
3396 r_u->ptr_entries2 = 1;
3397 }
3398 }
3399
3400 /*******************************************************************
3401 reads or writes a structure.
3402 ********************************************************************/
3403
3404 BOOL samr_io_r_enum_dom_aliases(const char *desc, SAMR_R_ENUM_DOM_ALIASES * r_u,
3405 prs_struct *ps, int depth)
3406 {
3407 uint32 i;
3408
3409 if (r_u == NULL)
3410 return False;
3411
3412 prs_debug(ps, depth, desc, "samr_io_r_enum_dom_aliases");
3413 depth++;
3414
3415 if(!prs_align(ps))
3416 return False;
3417
3418 if(!prs_uint32("next_idx ", ps, depth, &r_u->next_idx))
3419 return False;
3420 if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3421 return False;
3422
3423 if (r_u->ptr_entries1 != 0) {
3424 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3425 return False;
3426 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3427 return False;
3428 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3429 return False;
3430
3431 if (UNMARSHALLING(ps) && (r_u->num_entries2 > 0)) {
3432 r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3433 r_u->uni_grp_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3434 }
3435
3436 if (r_u->num_entries2 != 0 &&
3437 (r_u->sam == NULL || r_u->uni_grp_name == NULL)) {
3438 DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_ALIASES\n"));
3439 r_u->num_entries4 = 0;
3440 r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3441 return False;
3442 }
3443
3444 for (i = 0; i < r_u->num_entries2; i++) {
3445 if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
3446 return False;
3447 }
3448
3449 for (i = 0; i < r_u->num_entries2; i++) {
3450 if(!smb_io_unistr2("", &r_u->uni_grp_name[i],
3451 r_u->sam[i].hdr_name.buffer, ps,
3452 depth))
3453 return False;
3454 }
3455 }
3456
3457 if(!prs_align(ps))
3458 return False;
3459 if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3460 return False;
3461 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3462 return False;
3463
3464 return True;
3465 }
3466
3467 /*******************************************************************
3468 inits a ALIAS_INFO1 structure.
3469 ********************************************************************/
3470
3471 void init_samr_alias_info1(ALIAS_INFO1 * al1, char *acct_name, uint32 num_member, char *acct_desc)
3472 {
3473 DEBUG(5, ("init_samr_alias_info1\n"));
3474
3475 init_unistr2(&al1->uni_acct_name, acct_name, UNI_FLAGS_NONE);
3476 init_uni_hdr(&al1->hdr_acct_name, &al1->uni_acct_name);
3477
3478 al1->num_member=num_member;
3479
3480 init_unistr2(&al1->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
3481 init_uni_hdr(&al1->hdr_acct_desc, &al1->uni_acct_name);
3482 }
3483
3484 /*******************************************************************
3485 reads or writes a structure.
3486 ********************************************************************/
3487
3488 BOOL samr_io_alias_info1(const char *desc, ALIAS_INFO1 * al1,
3489 prs_struct *ps, int depth)
3490 {
3491 if (al1 == NULL)
3492 return False;
3493
3494 prs_debug(ps, depth, desc, "samr_io_alias_info1");
3495 depth++;
3496
3497 if(!prs_align(ps))
3498 return False;
3499
3500 if(!smb_io_unihdr("hdr_acct_name", &al1->hdr_acct_name, ps, depth))
3501 return False;
3502 if(!prs_uint32("num_member", ps, depth, &al1->num_member))
3503 return False;
3504 if(!smb_io_unihdr("hdr_acct_desc", &al1->hdr_acct_desc, ps, depth))
3505 return False;
3506
3507 if(!smb_io_unistr2("uni_acct_name", &al1->uni_acct_name,
3508 al1->hdr_acct_name.buffer, ps, depth))
3509 return False;
3510
3511 if(!prs_align(ps))
3512 return False;
3513
3514 if(!smb_io_unistr2("uni_acct_desc", &al1->uni_acct_desc,
3515 al1->hdr_acct_desc.buffer, ps, depth))
3516 return False;
3517
3518 return True;
3519 }
3520
3521 /*******************************************************************
3522 inits a ALIAS_INFO3 structure.
3523 ********************************************************************/
3524
3525 void init_samr_alias_info3(ALIAS_INFO3 * al3, const char *acct_desc)
3526 {
3527 DEBUG(5, ("init_samr_alias_info3\n"));
3528
3529 init_unistr2(&al3->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
3530 init_uni_hdr(&al3->hdr_acct_desc, &al3->uni_acct_desc);
3531 }
3532
3533 /*******************************************************************
3534 reads or writes a structure.
3535 ********************************************************************/
3536
3537 BOOL samr_io_alias_info3(const char *desc, ALIAS_INFO3 * al3,
3538 prs_struct *ps, int depth)
3539 {
3540 if (al3 == NULL)
3541 return False;
3542
3543 prs_debug(ps, depth, desc, "samr_io_alias_info3");
3544 depth++;
3545
3546 if(!prs_align(ps))
3547 return False;
3548
3549 if(!smb_io_unihdr("hdr_acct_desc", &al3->hdr_acct_desc, ps, depth))
3550 return False;
3551 if(!smb_io_unistr2("uni_acct_desc", &al3->uni_acct_desc,
3552 al3->hdr_acct_desc.buffer, ps, depth))
3553 return False;
3554
3555 return True;
3556 }
3557
3558 /*******************************************************************
3559 reads or writes a structure.
3560 ********************************************************************/
3561
3562 BOOL samr_alias_info_ctr(const char *desc, ALIAS_INFO_CTR * ctr,
3563 prs_struct *ps, int depth)
3564 {
3565 if (ctr == NULL)
3566 return False;
3567
3568 prs_debug(ps, depth, desc, "samr_alias_info_ctr");
3569 depth++;
3570
3571 if(!prs_uint16("switch_value1", ps, depth, &ctr->switch_value1))
3572 return False;
3573 if(!prs_uint16("switch_value2", ps, depth, &ctr->switch_value2))
3574 return False;
3575
3576 switch (ctr->switch_value1) {
3577 case 1:
3578 if(!samr_io_alias_info1("alias_info1", &ctr->alias.info1, ps, depth))
3579 return False;
3580 break;
3581 case 3:
3582 if(!samr_io_alias_info3("alias_info3", &ctr->alias.info3, ps, depth))
3583 return False;
3584 break;
3585 default:
3586 DEBUG(0,("samr_alias_info_ctr: unsupported switch level\n"));
3587 break;
3588 }
3589
3590 return True;
3591 }
3592
3593 /*******************************************************************
3594 inits a SAMR_Q_QUERY_ALIASINFO structure.
3595 ********************************************************************/
3596
3597 void init_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO * q_e,
3598 POLICY_HND *pol, uint16 switch_level)
3599 {
3600 DEBUG(5, ("init_samr_q_query_aliasinfo\n"));
3601
3602 q_e->pol = *pol;
3603 q_e->switch_level = switch_level;
3604 }
3605
3606 /*******************************************************************
3607 reads or writes a structure.
3608 ********************************************************************/
3609
3610 BOOL samr_io_q_query_aliasinfo(const char *desc, SAMR_Q_QUERY_ALIASINFO * q_e,
3611 prs_struct *ps, int depth)
3612 {
3613 if (q_e == NULL)
3614 return False;
3615
3616 prs_debug(ps, depth, desc, "samr_io_q_query_aliasinfo");
3617 depth++;
3618
3619 if(!prs_align(ps))
3620 return False;
3621
3622 if(!smb_io_pol_hnd("pol", &(q_e->pol), ps, depth))
3623 return False;
3624
3625 if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
3626 return False;
3627
3628 return True;
3629 }
3630
3631 /*******************************************************************
3632 inits a SAMR_R_QUERY_ALIASINFO structure.
3633 ********************************************************************/
3634
3635 void init_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO * r_u,
3636 ALIAS_INFO_CTR * ctr, NTSTATUS status)
3637 {
3638 DEBUG(5, ("init_samr_r_query_aliasinfo\n"));
3639
3640 r_u->ptr = (NT_STATUS_IS_OK(status) && ctr != NULL) ? 1 : 0;
3641 r_u->ctr = *ctr;
3642 r_u->status = status;
3643 }
3644
3645 /*******************************************************************
3646 reads or writes a structure.
3647 ********************************************************************/
3648
3649 BOOL samr_io_r_query_aliasinfo(const char *desc, SAMR_R_QUERY_ALIASINFO * r_u,
3650 prs_struct *ps, int depth)
3651 {
3652 if (r_u == NULL)
3653 return False;
3654
3655 prs_debug(ps, depth, desc, "samr_io_r_query_aliasinfo");
3656 depth++;
3657
3658 if(!prs_align(ps))
3659 return False;
3660
3661 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
3662 return False;
3663
3664 if (r_u->ptr != 0) {
3665 if(!samr_alias_info_ctr("ctr", &r_u->ctr, ps, depth))
3666 return False;
3667 }
3668
3669 if(!prs_align(ps))
3670 return False;
3671 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3672 return False;
3673
3674 return True;
3675 }
3676
3677 /*******************************************************************
3678 inits a SAMR_Q_SET_ALIASINFO structure.
3679 ********************************************************************/
3680
3681 void init_samr_q_set_aliasinfo(SAMR_Q_SET_ALIASINFO * q_u,
3682 POLICY_HND *hnd, ALIAS_INFO_CTR * ctr)
3683 {
3684 DEBUG(5, ("init_samr_q_set_aliasinfo\n"));
3685
3686 q_u->alias_pol = *hnd;
3687 q_u->ctr = *ctr;
3688 }
3689
3690 /*******************************************************************
3691 reads or writes a structure.
3692 ********************************************************************/
3693
3694 BOOL samr_io_q_set_aliasinfo(const char *desc, SAMR_Q_SET_ALIASINFO * q_u,
3695 prs_struct *ps, int depth)
3696 {
3697 if (q_u == NULL)
3698 return False;
3699
3700 prs_debug(ps, depth, desc, "samr_io_q_set_aliasinfo");
3701 depth++;
3702
3703 if(!prs_align(ps))
3704 return False;
3705
3706 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
3707 return False;
3708 if(!samr_alias_info_ctr("ctr", &q_u->ctr, ps, depth))
3709 return False;
3710
3711 return True;
3712 }
3713
3714 /*******************************************************************
3715 reads or writes a structure.
3716 ********************************************************************/
3717
3718 BOOL samr_io_r_set_aliasinfo(const char *desc, SAMR_R_SET_ALIASINFO * r_u,
3719 prs_struct *ps, int depth)
3720 {
3721 if (r_u == NULL)
3722 return False;
3723
3724 prs_debug(ps, depth, desc, "samr_io_r_set_aliasinfo");
3725 depth++;
3726
3727 if(!prs_align(ps))
3728 return False;
3729 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3730 return False;
3731
3732 return True;
3733 }
3734
3735 /*******************************************************************
3736 inits a SAMR_Q_QUERY_USERALIASES structure.
3737 ********************************************************************/
3738
3739 void init_samr_q_query_useraliases(SAMR_Q_QUERY_USERALIASES * q_u,
3740 POLICY_HND *hnd,
3741 uint32 num_sids,
3742 uint32 *ptr_sid, DOM_SID2 * sid)
3743 {
3744 DEBUG(5, ("init_samr_q_query_useraliases\n"));
3745
3746 q_u->pol = *hnd;
3747
3748 q_u->num_sids1 = num_sids;
3749 q_u->ptr = 1;
3750 q_u->num_sids2 = num_sids;
3751
3752 q_u->ptr_sid = ptr_sid;
3753 q_u->sid = sid;
3754 }
3755
3756 /*******************************************************************
3757 reads or writes a SAMR_Q_QUERY_USERALIASES structure.
3758 ********************************************************************/
3759
3760 BOOL samr_io_q_query_useraliases(const char *desc, SAMR_Q_QUERY_USERALIASES * q_u,
3761 prs_struct *ps, int depth)
3762 {
3763 fstring tmp;
3764 uint32 i;
3765
3766 if (q_u == NULL)
3767 return False;
3768
3769 prs_debug(ps, depth, desc, "samr_io_q_query_useraliases");
3770 depth++;
3771
3772 if(!prs_align(ps))
3773 return False;
3774
3775 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
3776 return False;
3777
3778 if(!prs_uint32("num_sids1", ps, depth, &q_u->num_sids1))
3779 return False;
3780 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
3781 return False;
3782
3783 if (q_u->ptr==0)
3784 return True;
3785
3786 if(!prs_uint32("num_sids2", ps, depth, &q_u->num_sids2))
3787 return False;
3788
3789 if (UNMARSHALLING(ps) && (q_u->num_sids2 != 0)) {
3790 q_u->ptr_sid = PRS_ALLOC_MEM(ps,uint32,q_u->num_sids2);
3791 if (q_u->ptr_sid == NULL)
3792 return False;
3793
3794 q_u->sid = PRS_ALLOC_MEM(ps, DOM_SID2, q_u->num_sids2);
3795 if (q_u->sid == NULL)
3796 return False;
3797 }
3798
3799 for (i = 0; i < q_u->num_sids2; i++) {
3800 slprintf(tmp, sizeof(tmp) - 1, "ptr[%02d]", i);
3801 if(!prs_uint32(tmp, ps, depth, &q_u->ptr_sid[i]))
3802 return False;
3803 }
3804
3805 for (i = 0; i < q_u->num_sids2; i++) {
3806 if (q_u->ptr_sid[i] != 0) {
3807 slprintf(tmp, sizeof(tmp) - 1, "sid[%02d]", i);
3808 if(!smb_io_dom_sid2(tmp, &q_u->sid[i], ps, depth))
3809 return False;
3810 }
3811 }
3812
3813 return True;
3814 }
3815
3816 /*******************************************************************
3817 inits a SAMR_R_QUERY_USERALIASES structure.
3818 ********************************************************************/
3819
3820 void init_samr_r_query_useraliases(SAMR_R_QUERY_USERALIASES * r_u,
3821 uint32 num_rids, uint32 *rid,
3822 NTSTATUS status)
3823 {
3824 DEBUG(5, ("init_samr_r_query_useraliases\n"));
3825
3826 if (NT_STATUS_IS_OK(status)) {
3827 r_u->num_entries = num_rids;
3828 r_u->ptr = 1;
3829 r_u->num_entries2 = num_rids;
3830
3831 r_u->rid = rid;
3832 } else {
3833 r_u->num_entries = 0;
3834 r_u->ptr = 0;
3835 r_u->num_entries2 = 0;
3836 }
3837
3838 r_u->status = status;
3839 }
3840
3841 /*******************************************************************
3842 reads or writes a structure.
3843 ********************************************************************/
3844
3845 BOOL samr_io_rids(const char *desc, uint32 *num_rids, uint32 **rid,
3846 prs_struct *ps, int depth)
3847 {
3848 fstring tmp;
3849 uint32 i;
3850 if (rid == NULL)
3851 return False;
3852
3853 prs_debug(ps, depth, desc, "samr_io_rids");
3854 depth++;
3855
3856 if(!prs_align(ps))
3857 return False;
3858
3859 if(!prs_uint32("num_rids", ps, depth, num_rids))
3860 return False;
3861
3862 if ((*num_rids) != 0) {
3863 if (UNMARSHALLING(ps)) {
3864 /* reading */
3865 (*rid) = PRS_ALLOC_MEM(ps,uint32, *num_rids);
3866 }
3867 if ((*rid) == NULL)
3868 return False;
3869
3870 for (i = 0; i < (*num_rids); i++) {
3871 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]", i);
3872 if(!prs_uint32(tmp, ps, depth, &((*rid)[i])))
3873 return False;
3874 }
3875 }
3876
3877 return True;
3878 }
3879
3880 /*******************************************************************
3881 reads or writes a structure.
3882 ********************************************************************/
3883
3884 BOOL samr_io_r_query_useraliases(const char *desc, SAMR_R_QUERY_USERALIASES * r_u,
3885 prs_struct *ps, int depth)
3886 {
3887 if (r_u == NULL)
3888 return False;
3889
3890 prs_debug(ps, depth, desc, "samr_io_r_query_useraliases");
3891 depth++;
3892
3893 if(!prs_align(ps))
3894 return False;
3895
3896 if(!prs_uint32("num_entries", ps, depth, &r_u->num_entries))
3897 return False;
3898 if(!prs_uint32("ptr ", ps, depth, &r_u->ptr))
3899 return False;
3900
3901 if (r_u->ptr != 0) {
3902 if(!samr_io_rids("rids", &r_u->num_entries2, &r_u->rid, ps, depth))
3903 return False;
3904 }
3905
3906 if(!prs_align(ps))
3907 return False;
3908 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3909 return False;
3910
3911 return True;
3912 }
3913
3914 /*******************************************************************
3915 inits a SAMR_Q_OPEN_ALIAS structure.
3916 ********************************************************************/
3917
3918 void init_samr_q_open_alias(SAMR_Q_OPEN_ALIAS * q_u, POLICY_HND *pol,
3919 uint32 access_mask, uint32 rid)
3920 {
3921 DEBUG(5, ("init_samr_q_open_alias\n"));
3922
3923 q_u->dom_pol = *pol;
3924 q_u->access_mask = access_mask;
3925 q_u->rid_alias = rid;
3926 }
3927
3928 /*******************************************************************
3929 reads or writes a structure.
3930 ********************************************************************/
3931
3932 BOOL samr_io_q_open_alias(const char *desc, SAMR_Q_OPEN_ALIAS * q_u,
3933 prs_struct *ps, int depth)
3934 {
3935 if (q_u == NULL)
3936 return False;
3937
3938 prs_debug(ps, depth, desc, "samr_io_q_open_alias");
3939 depth++;
3940
3941 if(!prs_align(ps))
3942 return False;
3943
3944 if(!smb_io_pol_hnd("domain_pol", &q_u->dom_pol, ps, depth))
3945 return False;
3946
3947 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
3948 return False;
3949 if(!prs_uint32("rid_alias", ps, depth, &q_u->rid_alias))
3950 return False;
3951
3952 return True;
3953 }
3954
3955 /*******************************************************************
3956 reads or writes a structure.
3957 ********************************************************************/
3958
3959 BOOL samr_io_r_open_alias(const char *desc, SAMR_R_OPEN_ALIAS * r_u,
3960 prs_struct *ps, int depth)
3961 {
3962 if (r_u == NULL)
3963 return False;
3964
3965 prs_debug(ps, depth, desc, "samr_io_r_open_alias");
3966 depth++;
3967
3968 if(!prs_align(ps))
3969 return False;
3970
3971 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
3972 return False;
3973
3974 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3975 return False;
3976
3977 return True;
3978 }
3979
3980 /*******************************************************************
3981 inits a SAMR_Q_LOOKUP_RIDS structure.
3982 ********************************************************************/
3983
3984 void init_samr_q_lookup_rids(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_RIDS * q_u,
3985 POLICY_HND *pol, uint32 flags,
3986 uint32 num_rids, uint32 *rid)
3987 {
3988 DEBUG(5, ("init_samr_q_lookup_rids\n"));
3989
3990 q_u->pol = *pol;
3991
3992 q_u->num_rids1 = num_rids;
3993 q_u->flags = flags;
3994 q_u->ptr = 0;
3995 q_u->num_rids2 = num_rids;
3996 q_u->rid = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids );
3997 if (q_u->rid == NULL) {
3998 q_u->num_rids1 = 0;
3999 q_u->num_rids2 = 0;
4000 } else {
4001 memcpy(q_u->rid, rid, num_rids * sizeof(q_u->rid[0]));
4002 }
4003 }
4004
4005 /*******************************************************************
4006 reads or writes a structure.
4007 ********************************************************************/
4008
4009 BOOL samr_io_q_lookup_rids(const char *desc, SAMR_Q_LOOKUP_RIDS * q_u,
4010 prs_struct *ps, int depth)
4011 {
4012 uint32 i;
4013 fstring tmp;
4014
4015 if (q_u == NULL)
4016 return False;
4017
4018 prs_debug(ps, depth, desc, "samr_io_q_lookup_rids");
4019 depth++;
4020
4021 if (UNMARSHALLING(ps))
4022 ZERO_STRUCTP(q_u);
4023
4024 if(!prs_align(ps))
4025 return False;
4026
4027 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4028 return False;
4029
4030 if(!prs_uint32("num_rids1", ps, depth, &q_u->num_rids1))
4031 return False;
4032 if(!prs_uint32("flags ", ps, depth, &q_u->flags))
4033 return False;
4034 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
4035 return False;
4036 if(!prs_uint32("num_rids2", ps, depth, &q_u->num_rids2))
4037 return False;
4038
4039 if (UNMARSHALLING(ps) && (q_u->num_rids2 != 0)) {
4040 q_u->rid = PRS_ALLOC_MEM(ps, uint32, q_u->num_rids2);
4041 if (q_u->rid == NULL)
4042 return False;
4043 }
4044
4045 for (i = 0; i < q_u->num_rids2; i++) {
4046 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d] ", i);
4047 if(!prs_uint32(tmp, ps, depth, &q_u->rid[i]))
4048 return False;
4049 }
4050
4051 return True;
4052 }
4053
4054 /*******************************************************************
4055 inits a SAMR_R_LOOKUP_RIDS structure.
4056 ********************************************************************/
4057
4058 void init_samr_r_lookup_rids(SAMR_R_LOOKUP_RIDS * r_u,
4059 uint32 num_names, UNIHDR * hdr_name,
4060 UNISTR2 *uni_name, uint32 *type)
4061 {
4062 DEBUG(5, ("init_samr_r_lookup_rids\n"));
4063
4064 r_u->hdr_name = NULL;
4065 r_u->uni_name = NULL;
4066 r_u->type = NULL;
4067
4068 if (num_names != 0) {
4069 r_u->num_names1 = num_names;
4070 r_u->ptr_names = 1;
4071 r_u->num_names2 = num_names;
4072
4073 r_u->num_types1 = num_names;
4074 r_u->ptr_types = 1;
4075 r_u->num_types2 = num_names;
4076
4077 r_u->hdr_name = hdr_name;
4078 r_u->uni_name = uni_name;
4079 r_u->type = type;
4080 } else {
4081 r_u->num_names1 = num_names;
4082 r_u->ptr_names = 0;
4083 r_u->num_names2 = num_names;
4084
4085 r_u->num_types1 = num_names;
4086 r_u->ptr_types = 0;
4087 r_u->num_types2 = num_names;
4088 }
4089 }
4090
4091 /*******************************************************************
4092 reads or writes a structure.
4093 ********************************************************************/
4094
4095 BOOL samr_io_r_lookup_rids(const char *desc, SAMR_R_LOOKUP_RIDS * r_u,
4096 prs_struct *ps, int depth)
4097 {
4098 uint32 i;
4099 fstring tmp;
4100 if (r_u == NULL)
4101 return False;
4102
4103 prs_debug(ps, depth, desc, "samr_io_r_lookup_rids");
4104 depth++;
4105
4106 if(!prs_align(ps))
4107 return False;
4108
4109 if(!prs_uint32("num_names1", ps, depth, &r_u->num_names1))
4110 return False;
4111 if(!prs_uint32("ptr_names ", ps, depth, &r_u->ptr_names))
4112 return False;
4113
4114 if (r_u->ptr_names != 0) {
4115
4116 if(!prs_uint32("num_names2", ps, depth, &r_u->num_names2))
4117 return False;
4118
4119
4120 if (UNMARSHALLING(ps) && (r_u->num_names2 != 0)) {
4121 r_u->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, r_u->num_names2);
4122 if (r_u->hdr_name == NULL)
4123 return False;
4124
4125 r_u->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, r_u->num_names2);
4126 if (r_u->uni_name == NULL)
4127 return False;
4128 }
4129
4130 for (i = 0; i < r_u->num_names2; i++) {
4131 slprintf(tmp, sizeof(tmp) - 1, "hdr[%02d] ", i);
4132 if(!smb_io_unihdr("", &r_u->hdr_name[i], ps, depth))
4133 return False;
4134 }
4135 for (i = 0; i < r_u->num_names2; i++) {
4136 slprintf(tmp, sizeof(tmp) - 1, "str[%02d] ", i);
4137 if(!smb_io_unistr2("", &r_u->uni_name[i], r_u->hdr_name[i].buffer, ps, depth))
4138 return False;
4139 }
4140
4141 }
4142
4143 if(!prs_align(ps))
4144 return False;
4145 if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
4146 return False;
4147 if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
4148 return False;
4149
4150 if (r_u->ptr_types != 0) {
4151
4152 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
4153 return False;
4154
4155 if (UNMARSHALLING(ps) && (r_u->num_types2 != 0)) {
4156 r_u->type = PRS_ALLOC_MEM(ps, uint32, r_u->num_types2);
4157 if (r_u->type == NULL)
4158 return False;
4159 }
4160
4161 for (i = 0; i < r_u->num_types2; i++) {
4162 slprintf(tmp, sizeof(tmp) - 1, "type[%02d] ", i);
4163 if(!prs_uint32(tmp, ps, depth, &r_u->type[i]))
4164 return False;
4165 }
4166 }
4167
4168 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4169 return False;
4170
4171 return True;
4172 }
4173
4174 /*******************************************************************
4175 inits a SAMR_Q_OPEN_ALIAS structure.
4176 ********************************************************************/
4177
4178 void init_samr_q_delete_alias(SAMR_Q_DELETE_DOM_ALIAS * q_u, POLICY_HND *hnd)
4179 {
4180 DEBUG(5, ("init_samr_q_delete_alias\n"));
4181
4182 q_u->alias_pol = *hnd;
4183 }
4184
4185 /*******************************************************************
4186 reads or writes a structure.
4187 ********************************************************************/
4188
4189 BOOL samr_io_q_delete_alias(const char *desc, SAMR_Q_DELETE_DOM_ALIAS * q_u,
4190 prs_struct *ps, int depth)
4191 {
4192 if (q_u == NULL)
4193 return False;
4194
4195 prs_debug(ps, depth, desc, "samr_io_q_delete_alias");
4196 depth++;
4197
4198 if(!prs_align(ps))
4199 return False;
4200
4201 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4202 return False;
4203
4204 return True;
4205 }
4206
4207 /*******************************************************************
4208 reads or writes a structure.
4209 ********************************************************************/
4210
4211 BOOL samr_io_r_delete_alias(const char *desc, SAMR_R_DELETE_DOM_ALIAS * r_u,
4212 prs_struct *ps, int depth)
4213 {
4214 if (r_u == NULL)
4215 return False;
4216
4217 prs_debug(ps, depth, desc, "samr_io_r_delete_alias");
4218 depth++;
4219
4220 if(!prs_align(ps))
4221 return False;
4222
4223 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4224 return False;
4225 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4226 return False;
4227
4228 return True;
4229 }
4230
4231 /*******************************************************************
4232 inits a SAMR_Q_CREATE_DOM_ALIAS structure.
4233 ********************************************************************/
4234
4235 void init_samr_q_create_dom_alias(SAMR_Q_CREATE_DOM_ALIAS * q_u,
4236 POLICY_HND *hnd, const char *acct_desc)
4237 {
4238 DEBUG(5, ("init_samr_q_create_dom_alias\n"));
4239
4240 q_u->dom_pol = *hnd;
4241
4242 init_unistr2(&q_u->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
4243 init_uni_hdr(&q_u->hdr_acct_desc, &q_u->uni_acct_desc);
4244
4245 q_u->access_mask = MAXIMUM_ALLOWED_ACCESS;
4246 }
4247
4248 /*******************************************************************
4249 reads or writes a structure.
4250 ********************************************************************/
4251
4252 BOOL samr_io_q_create_dom_alias(const char *desc, SAMR_Q_CREATE_DOM_ALIAS * q_u,
4253 prs_struct *ps, int depth)
4254 {
4255 if (q_u == NULL)
4256 return False;
4257
4258 prs_debug(ps, depth, desc, "samr_io_q_create_dom_alias");
4259 depth++;
4260
4261 if(!prs_align(ps))
4262 return False;
4263
4264 if(!smb_io_pol_hnd("dom_pol", &q_u->dom_pol, ps, depth))
4265 return False;
4266
4267 if(!smb_io_unihdr("hdr_acct_desc", &q_u->hdr_acct_desc, ps, depth))
4268 return False;
4269 if(!smb_io_unistr2("uni_acct_desc", &q_u->uni_acct_desc,
4270 q_u->hdr_acct_desc.buffer, ps, depth))
4271 return False;
4272
4273 if(!prs_align(ps))
4274 return False;
4275 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
4276 return False;
4277
4278 return True;
4279 }
4280
4281 /*******************************************************************
4282 reads or writes a structure.
4283 ********************************************************************/
4284
4285 BOOL samr_io_r_create_dom_alias(const char *desc, SAMR_R_CREATE_DOM_ALIAS * r_u,
4286 prs_struct *ps, int depth)
4287 {
4288 if (r_u == NULL)
4289 return False;
4290
4291 prs_debug(ps, depth, desc, "samr_io_r_create_dom_alias");
4292 depth++;
4293
4294 if(!prs_align(ps))
4295 return False;
4296
4297 if(!smb_io_pol_hnd("alias_pol", &r_u->alias_pol, ps, depth))
4298 return False;
4299
4300 if(!prs_uint32("rid", ps, depth, &r_u->rid))
4301 return False;
4302
4303 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4304 return False;
4305
4306 return True;
4307 }
4308
4309 /*******************************************************************
4310 inits a SAMR_Q_ADD_ALIASMEM structure.
4311 ********************************************************************/
4312
4313 void init_samr_q_add_aliasmem(SAMR_Q_ADD_ALIASMEM * q_u, POLICY_HND *hnd,
4314 DOM_SID *sid)
4315 {
4316 DEBUG(5, ("init_samr_q_add_aliasmem\n"));
4317
4318 q_u->alias_pol = *hnd;
4319 init_dom_sid2(&q_u->sid, sid);
4320 }
4321
4322 /*******************************************************************
4323 reads or writes a structure.
4324 ********************************************************************/
4325
4326 BOOL samr_io_q_add_aliasmem(const char *desc, SAMR_Q_ADD_ALIASMEM * q_u,
4327 prs_struct *ps, int depth)
4328 {
4329 if (q_u == NULL)
4330 return False;
4331
4332 prs_debug(ps, depth, desc, "samr_io_q_add_aliasmem");
4333 depth++;
4334
4335 if(!prs_align(ps))
4336 return False;
4337
4338 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4339 return False;
4340 if(!smb_io_dom_sid2("sid ", &q_u->sid, ps, depth))
4341 return False;
4342
4343 return True;
4344 }
4345
4346 /*******************************************************************
4347 reads or writes a structure.
4348 ********************************************************************/
4349
4350 BOOL samr_io_r_add_aliasmem(const char *desc, SAMR_R_ADD_ALIASMEM * r_u,
4351 prs_struct *ps, int depth)
4352 {
4353 if (r_u == NULL)
4354 return False;
4355
4356 prs_debug(ps, depth, desc, "samr_io_r_add_aliasmem");
4357 depth++;
4358
4359 if(!prs_align(ps))
4360 return False;
4361
4362 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4363 return False;
4364
4365 return True;
4366 }
4367
4368 /*******************************************************************
4369 inits a SAMR_Q_DEL_ALIASMEM structure.
4370 ********************************************************************/
4371
4372 void init_samr_q_del_aliasmem(SAMR_Q_DEL_ALIASMEM * q_u, POLICY_HND *hnd,
4373 DOM_SID *sid)
4374 {
4375 DEBUG(5, ("init_samr_q_del_aliasmem\n"));
4376
4377 q_u->alias_pol = *hnd;
4378 init_dom_sid2(&q_u->sid, sid);
4379 }
4380
4381 /*******************************************************************
4382 reads or writes a structure.
4383 ********************************************************************/
4384
4385 BOOL samr_io_q_del_aliasmem(const char *desc, SAMR_Q_DEL_ALIASMEM * q_u,
4386 prs_struct *ps, int depth)
4387 {
4388 if (q_u == NULL)
4389 return False;
4390
4391 prs_debug(ps, depth, desc, "samr_io_q_del_aliasmem");
4392 depth++;
4393
4394 if(!prs_align(ps))
4395 return False;
4396
4397 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4398 return False;
4399 if(!smb_io_dom_sid2("sid ", &q_u->sid, ps, depth))
4400 return False;
4401
4402 return True;
4403 }
4404
4405 /*******************************************************************
4406 reads or writes a structure.
4407 ********************************************************************/
4408
4409 BOOL samr_io_r_del_aliasmem(const char *desc, SAMR_R_DEL_ALIASMEM * r_u,
4410 prs_struct *ps, int depth)
4411 {
4412 if (r_u == NULL)
4413 return False;
4414
4415 prs_debug(ps, depth, desc, "samr_io_r_del_aliasmem");
4416 depth++;
4417
4418 if(!prs_align(ps))
4419 return False;
4420
4421 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4422 return False;
4423
4424 return True;
4425 }
4426
4427 /*******************************************************************
4428 inits a SAMR_Q_DELETE_DOM_ALIAS structure.
4429 ********************************************************************/
4430
4431 void init_samr_q_delete_dom_alias(SAMR_Q_DELETE_DOM_ALIAS * q_c,
4432 POLICY_HND *hnd)
4433 {
4434 DEBUG(5, ("init_samr_q_delete_dom_alias\n"));
4435
4436 q_c->alias_pol = *hnd;
4437 }
4438
4439 /*******************************************************************
4440 reads or writes a structure.
4441 ********************************************************************/
4442
4443 BOOL samr_io_q_delete_dom_alias(const char *desc, SAMR_Q_DELETE_DOM_ALIAS * q_u,
4444 prs_struct *ps, int depth)
4445 {
4446 if (q_u == NULL)
4447 return False;
4448
4449 prs_debug(ps, depth, desc, "samr_io_q_delete_dom_alias");
4450 depth++;
4451
4452 if(!prs_align(ps))
4453 return False;
4454
4455 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4456 return False;
4457
4458 return True;
4459 }
4460
4461 /*******************************************************************
4462 inits a SAMR_R_DELETE_DOM_ALIAS structure.
4463 ********************************************************************/
4464
4465 void init_samr_r_delete_dom_alias(SAMR_R_DELETE_DOM_ALIAS * r_u,
4466 NTSTATUS status)
4467 {
4468 DEBUG(5, ("init_samr_r_delete_dom_alias\n"));
4469
4470 r_u->status = status;
4471 }
4472
4473 /*******************************************************************
4474 reads or writes a structure.
4475 ********************************************************************/
4476
4477 BOOL samr_io_r_delete_dom_alias(const char *desc, SAMR_R_DELETE_DOM_ALIAS * r_u,
4478 prs_struct *ps, int depth)
4479 {
4480 if (r_u == NULL)
4481 return False;
4482
4483 prs_debug(ps, depth, desc, "samr_io_r_delete_dom_alias");
4484 depth++;
4485
4486 if(!prs_align(ps))
4487 return False;
4488
4489 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4490 return False;
4491
4492 return True;
4493 }
4494
4495 /*******************************************************************
4496 inits a SAMR_Q_QUERY_ALIASMEM structure.
4497 ********************************************************************/
4498
4499 void init_samr_q_query_aliasmem(SAMR_Q_QUERY_ALIASMEM * q_c,
4500 POLICY_HND *hnd)
4501 {
4502 DEBUG(5, ("init_samr_q_query_aliasmem\n"));
4503
4504 q_c->alias_pol = *hnd;
4505 }
4506
4507 /*******************************************************************
4508 reads or writes a structure.
4509 ********************************************************************/
4510
4511 BOOL samr_io_q_query_aliasmem(const char *desc, SAMR_Q_QUERY_ALIASMEM * q_u,
4512 prs_struct *ps, int depth)
4513 {
4514 if (q_u == NULL)
4515 return False;
4516
4517 prs_debug(ps, depth, desc, "samr_io_q_query_aliasmem");
4518 depth++;
4519
4520 if(!prs_align(ps))
4521 return False;
4522
4523 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4524 return False;
4525
4526 return True;
4527 }
4528
4529 /*******************************************************************
4530 inits a SAMR_R_QUERY_ALIASMEM structure.
4531 ********************************************************************/
4532
4533 void init_samr_r_query_aliasmem(SAMR_R_QUERY_ALIASMEM * r_u,
4534 uint32 num_sids, DOM_SID2 * sid,
4535 NTSTATUS status)
4536 {
4537 DEBUG(5, ("init_samr_r_query_aliasmem\n"));
4538
4539 if (NT_STATUS_IS_OK(status)) {
4540 r_u->num_sids = num_sids;
4541 r_u->ptr = (num_sids != 0) ? 1 : 0;
4542 r_u->num_sids1 = num_sids;
4543
4544 r_u->sid = sid;
4545 } else {
4546 r_u->ptr = 0;
4547 r_u->num_sids = 0;
4548 }
4549
4550 r_u->status = status;
4551 }
4552
4553 /*******************************************************************
4554 reads or writes a structure.
4555 ********************************************************************/
4556
4557 BOOL samr_io_r_query_aliasmem(const char *desc, SAMR_R_QUERY_ALIASMEM * r_u,
4558 prs_struct *ps, int depth)
4559 {
4560 uint32 i;
4561
4562 if (r_u == NULL)
4563 return False;
4564
4565 prs_debug(ps, depth, desc, "samr_io_r_query_aliasmem");
4566 depth++;
4567
4568 if(!prs_align(ps))
4569 return False;
4570
4571 if(!prs_uint32("num_sids ", ps, depth, &r_u->num_sids))
4572 return False;
4573 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
4574 return False;
4575
4576 if (r_u->ptr != 0 && r_u->num_sids != 0) {
4577 uint32 *ptr_sid = NULL;
4578
4579 if(!prs_uint32("num_sids1", ps, depth, &r_u->num_sids1))
4580 return False;
4581
4582 ptr_sid = TALLOC_ARRAY(ps->mem_ctx, uint32, r_u->num_sids1);
4583 if (!ptr_sid) {
4584 return False;
4585 }
4586
4587 for (i = 0; i < r_u->num_sids1; i++) {
4588 ptr_sid[i] = 1;
4589 if(!prs_uint32("ptr_sid", ps, depth, &ptr_sid[i]))
4590 return False;
4591 }
4592
4593 if (UNMARSHALLING(ps)) {
4594 r_u->sid = TALLOC_ARRAY(ps->mem_ctx, DOM_SID2, r_u->num_sids1);
4595 }
4596
4597 for (i = 0; i < r_u->num_sids1; i++) {
4598 if (ptr_sid[i] != 0) {
4599 if(!smb_io_dom_sid2("sid", &r_u->sid[i], ps, depth))
4600 return False;
4601 }
4602 }
4603 }
4604
4605 if(!prs_align(ps))
4606 return False;
4607 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4608 return False;
4609
4610 return True;
4611 }
4612
4613 /*******************************************************************
4614 inits a SAMR_Q_LOOKUP_NAMES structure.
4615 ********************************************************************/
4616
4617 NTSTATUS init_samr_q_lookup_names(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_NAMES * q_u,
4618 POLICY_HND *pol, uint32 flags,
4619 uint32 num_names, const char **name)
4620 {
4621 uint32 i;
4622
4623 DEBUG(5, ("init_samr_q_lookup_names\n"));
4624
4625 q_u->pol = *pol;
4626
4627 q_u->num_names1 = num_names;
4628 q_u->flags = flags;
4629 q_u->ptr = 0;
4630 q_u->num_names2 = num_names;
4631
4632 if (!(q_u->hdr_name = TALLOC_ZERO_ARRAY(ctx, UNIHDR, num_names)))
4633 return NT_STATUS_NO_MEMORY;
4634
4635 if (!(q_u->uni_name = TALLOC_ZERO_ARRAY(ctx, UNISTR2, num_names)))
4636 return NT_STATUS_NO_MEMORY;
4637
4638 for (i = 0; i < num_names; i++) {
4639 init_unistr2(&q_u->uni_name[i], name[i], UNI_FLAGS_NONE); /* unicode string for machine account */
4640 init_uni_hdr(&q_u->hdr_name[i], &q_u->uni_name[i]); /* unicode header for user_name */
4641 }
4642
4643 return NT_STATUS_OK;
4644 }
4645
4646 /*******************************************************************
4647 reads or writes a structure.
4648 ********************************************************************/
4649
4650 BOOL samr_io_q_lookup_names(const char *desc, SAMR_Q_LOOKUP_NAMES * q_u,
4651 prs_struct *ps, int depth)
4652 {
4653 uint32 i;
4654
4655 if (q_u == NULL)
4656 return False;
4657
4658 prs_debug(ps, depth, desc, "samr_io_q_lookup_names");
4659 depth++;
4660
4661 if (UNMARSHALLING(ps))
4662 ZERO_STRUCTP(q_u);
4663
4664 if(!prs_align(ps))
4665 return False;
4666
4667 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4668 return False;
4669
4670 if(!prs_uint32("num_names1", ps, depth, &q_u->num_names1))
4671 return False;
4672 if(!prs_uint32("flags ", ps, depth, &q_u->flags))
4673 return False;
4674 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
4675 return False;
4676 if(!prs_uint32("num_names2", ps, depth, &q_u->num_names2))
4677 return False;
4678
4679 if (UNMARSHALLING(ps) && (q_u->num_names2 != 0)) {
4680 q_u->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_u->num_names2);
4681 q_u->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_u->num_names2);
4682 if (!q_u->hdr_name || !q_u->uni_name)
4683 return False;
4684 }
4685
4686 for (i = 0; i < q_u->num_names2; i++) {
4687 if(!smb_io_unihdr("", &q_u->hdr_name[i], ps, depth))
4688 return False;
4689 }
4690
4691 for (i = 0; i < q_u->num_names2; i++) {
4692 if(!smb_io_unistr2("", &q_u->uni_name[i], q_u->hdr_name[i].buffer, ps, depth))
4693 return False;
4694 }
4695
4696 return True;
4697 }
4698
4699 /*******************************************************************
4700 inits a SAMR_R_LOOKUP_NAMES structure.
4701 ********************************************************************/
4702
4703 NTSTATUS init_samr_r_lookup_names(TALLOC_CTX *ctx, SAMR_R_LOOKUP_NAMES * r_u,
4704 uint32 num_rids,
4705 uint32 *rid, uint32 *type,
4706 NTSTATUS status)
4707 {
4708 DEBUG(5, ("init_samr_r_lookup_names\n"));
4709
4710 if (NT_STATUS_IS_OK(status) && (num_rids != 0)) {
4711 uint32 i;
4712
4713 r_u->num_types1 = num_rids;
4714 r_u->ptr_types = 1;
4715 r_u->num_types2 = num_rids;
4716
4717 r_u->num_rids1 = num_rids;
4718 r_u->ptr_rids = 1;
4719 r_u->num_rids2 = num_rids;
4720
4721 if (!(r_u->rids = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids)))
4722 return NT_STATUS_NO_MEMORY;
4723 if (!(r_u->types = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids)))
4724 return NT_STATUS_NO_MEMORY;
4725
4726 if (!r_u->rids || !r_u->types)
4727 goto empty;
4728
4729 for (i = 0; i < num_rids; i++) {
4730 r_u->rids[i] = rid[i];
4731 r_u->types[i] = type[i];
4732 }
4733 } else {
4734
4735 empty:
4736 r_u->num_types1 = 0;
4737 r_u->ptr_types = 0;
4738 r_u->num_types2 = 0;
4739
4740 r_u->num_rids1 = 0;
4741 r_u->ptr_rids = 0;
4742 r_u->num_rids2 = 0;
4743
4744 r_u->rids = NULL;
4745 r_u->types = NULL;
4746 }
4747
4748 r_u->status = status;
4749
4750 return NT_STATUS_OK;
4751 }
4752
4753 /*******************************************************************
4754 reads or writes a structure.
4755 ********************************************************************/
4756
4757 BOOL samr_io_r_lookup_names(const char *desc, SAMR_R_LOOKUP_NAMES * r_u,
4758 prs_struct *ps, int depth)
4759 {
4760 uint32 i;
4761 fstring tmp;
4762
4763 if (r_u == NULL)
4764 return False;
4765
4766 prs_debug(ps, depth, desc, "samr_io_r_lookup_names");
4767 depth++;
4768
4769 if (UNMARSHALLING(ps))
4770 ZERO_STRUCTP(r_u);
4771
4772 if(!prs_align(ps))
4773 return False;
4774
4775 if(!prs_uint32("num_rids1", ps, depth, &r_u->num_rids1))
4776 return False;
4777 if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids))
4778 return False;
4779
4780 if (r_u->ptr_rids != 0) {
4781 if(!prs_uint32("num_rids2", ps, depth, &r_u->num_rids2))
4782 return False;
4783
4784 if (r_u->num_rids2 != r_u->num_rids1) {
4785 /* RPC fault */
4786 return False;
4787 }
4788
4789 if (UNMARSHALLING(ps))
4790 r_u->rids = PRS_ALLOC_MEM(ps, uint32, r_u->num_rids2);
4791
4792 if (!r_u->rids) {
4793 DEBUG(0, ("NULL rids in samr_io_r_lookup_names\n"));
4794 return False;
4795 }
4796
4797 for (i = 0; i < r_u->num_rids2; i++) {
4798 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d] ", i);
4799 if(!prs_uint32(tmp, ps, depth, &r_u->rids[i]))
4800 return False;
4801 }
4802 }
4803
4804 if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
4805 return False;
4806 if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
4807 return False;
4808
4809 if (r_u->ptr_types != 0) {
4810 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
4811 return False;
4812
4813 if (r_u->num_types2 != r_u->num_types1) {
4814 /* RPC fault */
4815 return False;
4816 }
4817
4818 if (UNMARSHALLING(ps))
4819 r_u->types = PRS_ALLOC_MEM(ps, uint32, r_u->num_types2);
4820
4821 if (!r_u->types) {
4822 DEBUG(0, ("NULL types in samr_io_r_lookup_names\n"));
4823 return False;
4824 }
4825
4826 for (i = 0; i < r_u->num_types2; i++) {
4827 slprintf(tmp, sizeof(tmp) - 1, "type[%02d] ", i);
4828 if(!prs_uint32(tmp, ps, depth, &r_u->types[i]))
4829 return False;
4830 }
4831 }
4832
4833 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4834 return False;
4835
4836 return True;
4837 }
4838
4839 /*******************************************************************
4840 inits a SAMR_Q_DELETE_DOM_USER structure.
4841 ********************************************************************/
4842
4843 void init_samr_q_delete_dom_user(SAMR_Q_DELETE_DOM_USER * q_c,
4844 POLICY_HND *hnd)
4845 {
4846 DEBUG(5, ("init_samr_q_delete_dom_user\n"));
4847
4848 q_c->user_pol = *hnd;
4849 }
4850
4851 /*******************************************************************
4852 reads or writes a structure.
4853 ********************************************************************/
4854
4855 BOOL samr_io_q_delete_dom_user(const char *desc, SAMR_Q_DELETE_DOM_USER * q_u,
4856 prs_struct *ps, int depth)
4857 {
4858 if (q_u == NULL)
4859 return False;
4860
4861 prs_debug(ps, depth, desc, "samr_io_q_delete_dom_user");
4862 depth++;
4863
4864 if(!prs_align(ps))
4865 return False;
4866
4867 if(!smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth))
4868 return False;
4869
4870 return True;
4871 }
4872
4873 /*******************************************************************
4874 reads or writes a structure.
4875 ********************************************************************/
4876
4877 BOOL samr_io_r_delete_dom_user(const char *desc, SAMR_R_DELETE_DOM_USER * r_u,
4878 prs_struct *ps, int depth)
4879 {
4880 if (r_u == NULL)
4881 return False;
4882
4883 prs_debug(ps, depth, desc, "samr_io_r_delete_dom_user");
4884 depth++;
4885
4886 if(!prs_align(ps))
4887 return False;
4888
4889 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4890 return False;
4891 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4892 return False;
4893
4894 return True;
4895 }
4896
4897 /*******************************************************************
4898 reads or writes a structure.
4899 ********************************************************************/
4900
4901 void init_samr_q_open_user(SAMR_Q_OPEN_USER * q_u,
4902 POLICY_HND *pol,
4903 uint32 access_mask, uint32 rid)
4904 {
4905 DEBUG(5, ("samr_init_samr_q_open_user\n"));
4906
4907 q_u->domain_pol = *pol;
4908 q_u->access_mask = access_mask;
4909 q_u->user_rid = rid;
4910 }
4911
4912 /*******************************************************************
4913 reads or writes a structure.
4914 ********************************************************************/
4915
4916 BOOL samr_io_q_open_user(const char *desc, SAMR_Q_OPEN_USER * q_u,
4917 prs_struct *ps, int depth)
4918 {
4919 if (q_u == NULL)
4920 return False;
4921
4922 prs_debug(ps, depth, desc, "samr_io_q_open_user");
4923 depth++;
4924
4925 if(!prs_align(ps))
4926 return False;
4927
4928 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
4929 return False;
4930
4931 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
4932 return False;
4933 if(!prs_uint32("user_rid ", ps, depth, &q_u->user_rid))
4934 return False;
4935
4936 return True;
4937 }
4938
4939 /*******************************************************************
4940 reads or writes a structure.
4941 ********************************************************************/
4942
4943 BOOL samr_io_r_open_user(const char *desc, SAMR_R_OPEN_USER * r_u,
4944 prs_struct *ps, int depth)
4945 {
4946 if (r_u == NULL)
4947 return False;
4948
4949 prs_debug(ps, depth, desc, "samr_io_r_open_user");
4950 depth++;
4951
4952 if(!prs_align(ps))
4953 return False;
4954
4955 if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
4956 return False;
4957
4958 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4959 return False;
4960
4961 return True;
4962 }
4963
4964
4965 /*******************************************************************
4966 reads or writes a structure.
4967 ********************************************************************/
4968
4969 void init_samr_q_create_user(SAMR_Q_CREATE_USER * q_u,
4970 POLICY_HND *pol,
4971 const char *name,
4972 uint32 acb_info, uint32 access_mask)
4973 {
4974 DEBUG(5, ("samr_init_samr_q_create_user\n"));
4975
4976 q_u->domain_pol = *pol;
4977
4978 init_unistr2(&q_u->uni_name, name, UNI_FLAGS_NONE);
4979 init_uni_hdr(&q_u->hdr_name, &q_u->uni_name);
4980
4981 q_u->acb_info = acb_info;
4982 q_u->access_mask = access_mask;
4983 }
4984
4985 /*******************************************************************
4986 reads or writes a structure.
4987 ********************************************************************/
4988
4989 BOOL samr_io_q_create_user(const char *desc, SAMR_Q_CREATE_USER * q_u,
4990 prs_struct *ps, int depth)
4991 {
4992 if (q_u == NULL)
4993 return False;
4994
4995 prs_debug(ps, depth, desc, "samr_io_q_create_user");
4996 depth++;
4997
4998 if(!prs_align(ps))
4999 return False;
5000
5001 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
5002 return False;
5003
5004 if(!smb_io_unihdr("hdr_name", &q_u->hdr_name, ps, depth))
5005 return False;
5006 if(!smb_io_unistr2("uni_name", &q_u->uni_name, q_u->hdr_name.buffer, ps, depth))
5007 return False;
5008
5009 if(!prs_align(ps))
5010 return False;
5011 if(!prs_uint32("acb_info ", ps, depth, &q_u->acb_info))
5012 return False;
5013 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
5014 return False;
5015
5016 return True;
5017 }
5018
5019 /*******************************************************************
5020 reads or writes a structure.
5021 ********************************************************************/
5022
5023 BOOL samr_io_r_create_user(const char *desc, SAMR_R_CREATE_USER * r_u,
5024 prs_struct *ps, int depth)
5025 {
5026 if (r_u == NULL)
5027 return False;
5028
5029 prs_debug(ps, depth, desc, "samr_io_r_create_user");
5030 depth++;
5031
5032 if(!prs_align(ps))
5033 return False;
5034
5035 if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
5036 return False;
5037
5038 if(!prs_uint32("access_granted", ps, depth, &r_u->access_granted))
5039 return False;
5040 if(!prs_uint32("user_rid ", ps, depth, &r_u->user_rid))
5041 return False;
5042 if(!prs_ntstatus("status", ps, depth, &r_u->status))
5043 return False;
5044
5045 return True;
5046 }
5047
5048 /*******************************************************************
5049 inits a SAMR_Q_QUERY_USERINFO structure.
5050 ********************************************************************/
5051
5052 void init_samr_q_query_userinfo(SAMR_Q_QUERY_USERINFO * q_u,
5053 POLICY_HND *hnd, uint16 switch_value)
5054 {
5055 DEBUG(5, ("init_samr_q_query_userinfo\n"));
5056
5057 q_u->pol = *hnd;
5058 q_u->switch_value = switch_value;
5059 }
5060
5061 /*******************************************************************
5062 reads or writes a structure.
5063 ********************************************************************/
5064
5065 BOOL samr_io_q_query_userinfo(const char *desc, SAMR_Q_QUERY_USERINFO * q_u,
5066 prs_struct *ps, int depth)
5067 {
5068 if (q_u == NULL)
5069 return False;
5070
5071 prs_debug(ps, depth, desc, "samr_io_q_query_userinfo");
5072 depth++;
5073
5074 if(!prs_align(ps))
5075 return False;
5076
5077 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
5078 return False;
5079
5080 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value)) /* 0x0015 or 0x0011 */
5081 return False;
5082
5083 return True;
5084 }
5085
5086 /*******************************************************************
5087 reads or writes a LOGON_HRS structure.
5088 ********************************************************************/
5089
5090 static BOOL sam_io_logon_hrs(const char *desc, LOGON_HRS * hrs,
5091 prs_struct *ps, int depth)
5092 {
5093 if (hrs == NULL)
5094 return False;
5095
5096 prs_debug(ps, depth, desc, "sam_io_logon_hrs");
5097 depth++;
5098
5099 if(!prs_align(ps))
5100 return False;
5101
5102 if(!prs_uint32("maxlen", ps, depth, &hrs->max_len))
5103 return False;
5104
5105 if(!prs_uint32("offset", ps, depth, &hrs->offset))
5106 return False;
5107
5108 if(!prs_uint32("len ", ps, depth, &hrs->len))
5109 return False;
5110
5111 if (hrs->len > sizeof(hrs->hours)) {
5112 DEBUG(3, ("sam_io_logon_hrs: truncating length from %d\n", hrs->len));
5113 hrs->len = sizeof(hrs->hours);
5114 }
5115
5116 if(!prs_uint8s(False, "hours", ps, depth, hrs->hours, hrs->len))
5117 return False;
5118
5119 return True;
5120 }
5121
5122 /*******************************************************************
5123 inits a SAM_USER_INFO_12 structure.
5124 ********************************************************************/
5125
5126 void init_sam_user_info12(SAM_USER_INFO_12 * usr,
5127 const uint8 lm_pwd[16], const uint8 nt_pwd[16])
5128 {
5129 DEBUG(5, ("init_sam_user_info12\n"));
5130
5131 usr->lm_pwd_active =
5132 memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd)) ? 1 : 0;
5133 usr->nt_pwd_active =
5134 memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd)) ? 1 : 0;
5135 }
5136
5137 /*******************************************************************
5138 reads or writes a structure.
5139 ********************************************************************/
5140
5141 static BOOL sam_io_user_info12(const char *desc, SAM_USER_INFO_12 * u,
5142 prs_struct *ps, int depth)
5143 {
5144 if (u == NULL)
5145 return False;
5146
5147 prs_debug(ps, depth, desc, "samr_io_r_user_info12");
5148 depth++;
5149
5150 if(!prs_align(ps))
5151 return False;
5152
5153 if(!prs_uint8s(False, "lm_pwd", ps, depth, u->lm_pwd, sizeof(u->lm_pwd)))
5154 return False;
5155 if(!prs_uint8s(False, "nt_pwd", ps, depth, u->nt_pwd, sizeof(u->nt_pwd)))
5156 return False;
5157
5158 if(!prs_uint8("lm_pwd_active", ps, depth, &u->lm_pwd_active))
5159 return False;
5160 if(!prs_uint8("nt_pwd_active", ps, depth, &u->nt_pwd_active))
5161 return False;
5162
5163 return True;
5164 }
5165
5166 /*******************************************************************
5167 inits a SAM_USER_INFO_7 structure.
5168 ********************************************************************/
5169
5170 void init_sam_user_info7(SAM_USER_INFO_7 * usr, const char *name)
5171 {
5172 DEBUG(5, ("init_sam_user_info7\n"));
5173
5174 init_unistr2(&usr->uni_name, name, UNI_FLAGS_NONE); /* unicode string for name */
5175 init_uni_hdr(&usr->hdr_name, &usr->uni_name); /* unicode header for name */
5176
5177 }
5178
5179 /*******************************************************************
5180 reads or writes a structure.
5181 ********************************************************************/
5182
5183 static BOOL sam_io_user_info7(const char *desc, SAM_USER_INFO_7 * usr,
5184 prs_struct *ps, int depth)
5185 {
5186 if (usr == NULL)
5187 return False;
5188
5189 prs_debug(ps, depth, desc, "samr_io_r_user_info7");
5190 depth++;
5191
5192 if(!prs_align(ps))
5193 return False;
5194
5195 if(!smb_io_unihdr("unihdr", &usr->hdr_name, ps, depth))
5196 return False;
5197
5198 if(!smb_io_unistr2("unistr2", &usr->uni_name, True, ps, depth))
5199 return False;
5200
5201 return True;
5202 }
5203
5204 /*******************************************************************
5205 inits a SAM_USER_INFO_10 structure.
5206 ********************************************************************/
5207
5208 void init_sam_user_info10(SAM_USER_INFO_10 * usr, uint32 acb_info)
5209 {
5210 DEBUG(5, ("init_sam_user_info10\n"));
5211
5212 usr->acb_info = acb_info;
5213 }
5214
5215 /*******************************************************************
5216 reads or writes a structure.
5217 ********************************************************************/
5218
5219 static BOOL sam_io_user_info10(const char *desc, SAM_USER_INFO_10 * usr,
5220 prs_struct *ps, int depth)
5221 {
5222 if (usr == NULL)
5223 return False;
5224
5225 prs_debug(ps, depth, desc, "samr_io_r_user_info10");
5226 depth++;
5227
5228 if(!prs_align(ps))
5229 return False;
5230
5231 if(!prs_uint32("acb_info", ps, depth, &usr->acb_info))
5232 return False;
5233
5234 return True;
5235 }
5236
5237 /*******************************************************************
5238 inits a SAM_USER_INFO_11 structure.
5239 ********************************************************************/
5240
5241 void init_sam_user_info11(SAM_USER_INFO_11 * usr,
5242 NTTIME * expiry,
5243 char *mach_acct,
5244 uint32 rid_user, uint32 rid_group, uint16 acct_ctrl)
5245 {
5246 DEBUG(5, ("init_sam_user_info11\n"));
5247
5248 memcpy(&usr->expiry, expiry, sizeof(usr->expiry)); /* expiry time or something? */
5249 ZERO_STRUCT(usr->padding_1); /* 0 - padding 24 bytes */
5250
5251 usr->padding_2 = 0; /* 0 - padding 4 bytes */
5252
5253 usr->ptr_1 = 1; /* pointer */
5254 ZERO_STRUCT(usr->padding_3); /* 0 - padding 32 bytes */
5255 usr->padding_4 = 0; /* 0 - padding 4 bytes */
5256
5257 usr->ptr_2 = 1; /* pointer */
5258 usr->padding_5 = 0; /* 0 - padding 4 bytes */
5259
5260 usr->ptr_3 = 1; /* pointer */
5261 ZERO_STRUCT(usr->padding_6); /* 0 - padding 32 bytes */
5262
5263 usr->rid_user = rid_user;
5264 usr->rid_group = rid_group;
5265
5266 usr->acct_ctrl = acct_ctrl;
5267 usr->unknown_3 = 0x0000;
5268
5269 usr->unknown_4 = 0x003f; /* 0x003f - 16 bit unknown */
5270 usr->unknown_5 = 0x003c; /* 0x003c - 16 bit unknown */
5271
5272 ZERO_STRUCT(usr->padding_7); /* 0 - padding 16 bytes */
5273 usr->padding_8 = 0; /* 0 - padding 4 bytes */
5274
5275 init_unistr2(&usr->uni_mach_acct, mach_acct, UNI_FLAGS_NONE); /* unicode string for machine account */
5276 init_uni_hdr(&usr->hdr_mach_acct, &usr->uni_mach_acct); /* unicode header for machine account */
5277 }
5278
5279 /*******************************************************************
5280 reads or writes a structure.
5281 ********************************************************************/
5282
5283 static BOOL sam_io_user_info11(const char *desc, SAM_USER_INFO_11 * usr,
5284 prs_struct *ps, int depth)
5285 {
5286 if (usr == NULL)
5287 return False;
5288
5289 prs_debug(ps, depth, desc, "samr_io_r_unknown_11");
5290 depth++;
5291
5292 if(!prs_align(ps))
5293 return False;
5294
5295 if(!prs_uint8s(False, "padding_0", ps, depth, usr->padding_0, sizeof(usr->padding_0)))
5296 return False;
5297
5298 if(!smb_io_time("time", &usr->expiry, ps, depth))
5299 return False;
5300
5301 if(!prs_uint8s(False, "padding_1", ps, depth, usr->padding_1, sizeof(usr->padding_1)))
5302 return False;
5303
5304 if(!smb_io_unihdr("unihdr", &usr->hdr_mach_acct, ps, depth))
5305 return False;
5306
5307 if(!prs_uint32("padding_2", ps, depth, &usr->padding_2))
5308 return False;
5309
5310 if(!prs_uint32("ptr_1 ", ps, depth, &usr->ptr_1))
5311 return False;
5312 if(!prs_uint8s(False, "padding_3", ps, depth, usr->padding_3, sizeof(usr->padding_3)))
5313 return False;
5314
5315 if(!prs_uint32("padding_4", ps, depth, &usr->padding_4))
5316 return False;
5317
5318 if(!prs_uint32("ptr_2 ", ps, depth, &usr->ptr_2))
5319 return False;
5320 if(!prs_uint32("padding_5", ps, depth, &usr->padding_5))
5321 return False;
5322
5323 if(!prs_uint32("ptr_3 ", ps, depth, &usr->ptr_3))
5324 return False;
5325 if(!prs_uint8s(False, "padding_6", ps, depth, usr->padding_6,sizeof(usr->padding_6)))
5326 return False;
5327
5328 if(!prs_uint32("rid_user ", ps, depth, &usr->rid_user))
5329 return False;
5330 if(!prs_uint32("rid_group", ps, depth, &usr->rid_group))
5331 return False;
5332 if(!prs_uint16("acct_ctrl", ps, depth, &usr->acct_ctrl))
5333 return False;
5334 if(!prs_uint16("unknown_3", ps, depth, &usr->unknown_3))
5335 return False;
5336 if(!prs_uint16("unknown_4", ps, depth, &usr->unknown_4))
5337 return False;
5338 if(!prs_uint16("unknown_5", ps, depth, &usr->unknown_5))
5339 return False;
5340
5341 if(!prs_uint8s(False, "padding_7", ps, depth, usr->padding_7, sizeof(usr->padding_7)))
5342 return False;
5343
5344 if(!prs_uint32("padding_8", ps, depth, &(usr->padding_8)))
5345 return False;
5346
5347 if(!smb_io_unistr2("unistr2", &usr->uni_mach_acct, True, ps, depth))
5348 return False;
5349
5350 if(!prs_align(ps))
5351 return False;
5352
5353 if(!prs_uint8s(False, "padding_9", ps, depth, usr->padding_9, sizeof(usr->padding_9)))
5354 return False;
5355
5356 return True;
5357 }
5358
5359 /*************************************************************************
5360 init_sam_user_infoa
5361 *************************************************************************/
5362
5363 void init_sam_user_info24(SAM_USER_INFO_24 * usr, char newpass[516], uint16 pw_len)
5364 {
5365 DEBUG(10, ("init_sam_user_info24:\n"));
5366 memcpy(usr->pass, newpass, sizeof(usr->pass));
5367 usr->pw_len = pw_len;
5368 }
5369
5370 /*******************************************************************
5371 reads or writes a structure.
5372 ********************************************************************/
5373
5374 static BOOL sam_io_user_info24(const char *desc, SAM_USER_INFO_24 * usr,
5375 prs_struct *ps, int depth)
5376 {
5377 if (usr == NULL)
5378 return False;
5379
5380 prs_debug(ps, depth, desc, "sam_io_user_info24");
5381 depth++;
5382
5383 if(!prs_align(ps))
5384 return False;
5385
5386 if(!prs_uint8s(False, "password", ps, depth, usr->pass,
5387 sizeof(usr->pass)))
5388 return False;
5389
5390 if (MARSHALLING(ps) && (usr->pw_len != 0)) {
5391 if (!prs_uint16("pw_len", ps, depth, &usr->pw_len))
5392 return False;
5393 }
5394 if(!prs_align(ps))
5395 return False;
5396
5397 return True;
5398 }
5399
5400 /*************************************************************************
5401 init_sam_user_info23
5402
5403 unknown_6 = 0x0000 04ec
5404
5405 *************************************************************************/
5406
5407 void init_sam_user_info23W(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5408 NTTIME * logoff_time, /* all zeros */
5409 NTTIME * kickoff_time, /* all zeros */
5410 NTTIME * pass_last_set_time, /* all zeros */
5411 NTTIME * pass_can_change_time, /* all zeros */
5412 NTTIME * pass_must_change_time, /* all zeros */
5413 UNISTR2 *user_name,
5414 UNISTR2 *full_name,
5415 UNISTR2 *home_dir,
5416 UNISTR2 *dir_drive,
5417 UNISTR2 *log_scr,
5418 UNISTR2 *prof_path,
5419 UNISTR2 *desc,
5420 UNISTR2 *wkstas,
5421 UNISTR2 *unk_str,
5422 UNISTR2 *mung_dial,
5423 uint32 user_rid, /* 0x0000 0000 */
5424 uint32 group_rid,
5425 uint32 acb_info,
5426 uint32 fields_present,
5427 uint16 logon_divs,
5428 LOGON_HRS * hrs,
5429 uint16 bad_password_count,
5430 uint16 logon_count,
5431 char newpass[516])
5432 {
5433 usr->logon_time = *logon_time; /* all zeros */
5434 usr->logoff_time = *logoff_time; /* all zeros */
5435 usr->kickoff_time = *kickoff_time; /* all zeros */
5436 usr->pass_last_set_time = *pass_last_set_time; /* all zeros */
5437 usr->pass_can_change_time = *pass_can_change_time; /* all zeros */
5438 usr->pass_must_change_time = *pass_must_change_time; /* all zeros */
5439
5440 ZERO_STRUCT(usr->nt_pwd);
5441 ZERO_STRUCT(usr->lm_pwd);
5442
5443 usr->user_rid = user_rid; /* 0x0000 0000 */
5444 usr->group_rid = group_rid;
5445 usr->acb_info = acb_info;
5446 usr->fields_present = fields_present; /* 09f8 27fa */
5447
5448 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5449 usr->ptr_logon_hrs = hrs ? 1 : 0;
5450
5451 if (nt_time_is_zero(pass_must_change_time)) {
5452 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5453 } else {
5454 usr->passmustchange=0;
5455 }
5456
5457 ZERO_STRUCT(usr->padding1);
5458 ZERO_STRUCT(usr->padding2);
5459
5460 usr->bad_password_count = bad_password_count;
5461 usr->logon_count = logon_count;
5462
5463 memcpy(usr->pass, newpass, sizeof(usr->pass));
5464
5465 copy_unistr2(&usr->uni_user_name, user_name);
5466 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5467
5468 copy_unistr2(&usr->uni_full_name, full_name);
5469 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5470
5471 copy_unistr2(&usr->uni_home_dir, home_dir);
5472 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5473
5474 copy_unistr2(&usr->uni_dir_drive, dir_drive);
5475 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5476
5477 copy_unistr2(&usr->uni_logon_script, log_scr);
5478 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5479
5480 copy_unistr2(&usr->uni_profile_path, prof_path);
5481 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5482
5483 copy_unistr2(&usr->uni_acct_desc, desc);
5484 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5485
5486 copy_unistr2(&usr->uni_workstations, wkstas);
5487 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5488
5489 copy_unistr2(&usr->uni_unknown_str, unk_str);
5490 init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
5491
5492 copy_unistr2(&usr->uni_munged_dial, mung_dial);
5493 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5494
5495 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5496 }
5497
5498 /*************************************************************************
5499 init_sam_user_info23
5500
5501 unknown_6 = 0x0000 04ec
5502
5503 *************************************************************************/
5504
5505 void init_sam_user_info23A(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5506 NTTIME * logoff_time, /* all zeros */
5507 NTTIME * kickoff_time, /* all zeros */
5508 NTTIME * pass_last_set_time, /* all zeros */
5509 NTTIME * pass_can_change_time, /* all zeros */
5510 NTTIME * pass_must_change_time, /* all zeros */
5511 char *user_name, /* NULL */
5512 char *full_name,
5513 char *home_dir, char *dir_drive, char *log_scr,
5514 char *prof_path, const char *desc, char *wkstas,
5515 char *unk_str, char *mung_dial, uint32 user_rid, /* 0x0000 0000 */
5516 uint32 group_rid, uint32 acb_info,
5517 uint32 fields_present, uint16 logon_divs,
5518 LOGON_HRS * hrs, uint16 bad_password_count, uint16 logon_count,
5519 char newpass[516])
5520 {
5521 DATA_BLOB blob = base64_decode_data_blob(mung_dial);
5522
5523 usr->logon_time = *logon_time; /* all zeros */
5524 usr->logoff_time = *logoff_time; /* all zeros */
5525 usr->kickoff_time = *kickoff_time; /* all zeros */
5526 usr->pass_last_set_time = *pass_last_set_time; /* all zeros */
5527 usr->pass_can_change_time = *pass_can_change_time; /* all zeros */
5528 usr->pass_must_change_time = *pass_must_change_time; /* all zeros */
5529
5530 ZERO_STRUCT(usr->nt_pwd);
5531 ZERO_STRUCT(usr->lm_pwd);
5532
5533 usr->user_rid = user_rid; /* 0x0000 0000 */
5534 usr->group_rid = group_rid;
5535 usr->acb_info = acb_info;
5536 usr->fields_present = fields_present; /* 09f8 27fa */
5537
5538 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5539 usr->ptr_logon_hrs = hrs ? 1 : 0;
5540
5541 if (nt_time_is_zero(pass_must_change_time)) {
5542 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5543 } else {
5544 usr->passmustchange=0;
5545 }
5546
5547 ZERO_STRUCT(usr->padding1);
5548 ZERO_STRUCT(usr->padding2);
5549
5550 usr->bad_password_count = bad_password_count;
5551 usr->logon_count = logon_count;
5552
5553 memcpy(usr->pass, newpass, sizeof(usr->pass));
5554
5555 init_unistr2(&usr->uni_user_name, user_name, UNI_FLAGS_NONE);
5556 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5557
5558 init_unistr2(&usr->uni_full_name, full_name, UNI_FLAGS_NONE);
5559 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5560
5561 init_unistr2(&usr->uni_home_dir, home_dir, UNI_FLAGS_NONE);
5562 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5563
5564 init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_FLAGS_NONE);
5565 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5566
5567 init_unistr2(&usr->uni_logon_script, log_scr, UNI_FLAGS_NONE);
5568 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5569
5570 init_unistr2(&usr->uni_profile_path, prof_path, UNI_FLAGS_NONE);
5571 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5572
5573 init_unistr2(&usr->uni_acct_desc, desc, UNI_FLAGS_NONE);
5574 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5575
5576 init_unistr2(&usr->uni_workstations, wkstas, UNI_FLAGS_NONE);
5577 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5578
5579 init_unistr2(&usr->uni_unknown_str, unk_str, UNI_FLAGS_NONE);
5580 init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
5581
5582 init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
5583 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5584
5585 data_blob_free(&blob);
5586
5587 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5588 }
5589
5590 /*******************************************************************
5591 reads or writes a structure.
5592 ********************************************************************/
5593
5594 static BOOL sam_io_user_info23(const char *desc, SAM_USER_INFO_23 * usr,
5595 prs_struct *ps, int depth)
5596 {
5597 if (usr == NULL)
5598 return False;
5599
5600 prs_debug(ps, depth, desc, "sam_io_user_info23");
5601 depth++;
5602
5603 if(!prs_align(ps))
5604 return False;
5605
5606 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
5607 return False;
5608 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
5609 return False;
5610 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
5611 return False;
5612 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps, depth))
5613 return False;
5614 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
5615 return False;
5616 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
5617 return False;
5618
5619 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
5620 return False;
5621 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
5622 return False;
5623 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
5624 return False;
5625 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
5626 return False;
5627 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
5628 return False;
5629 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
5630 return False;
5631 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
5632 return False;
5633 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
5634 return False;
5635 if(!smb_io_unihdr("hdr_unknown_str ", &usr->hdr_unknown_str, ps, depth)) /* unknown string */
5636 return False;
5637 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
5638 return False;
5639
5640 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
5641 return False;
5642 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
5643 return False;
5644
5645 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
5646 return False;
5647 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
5648 return False;
5649 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
5650 return False;
5651
5652 if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
5653 return False;
5654 if(!prs_uint16("logon_divs ", ps, depth, &usr->logon_divs)) /* logon divisions per week */
5655 return False;
5656 if(!prs_align(ps))
5657 return False;
5658 if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
5659 return False;
5660
5661 if(!prs_uint16("bad_password_count ", ps, depth, &usr->bad_password_count))
5662 return False;
5663 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count))
5664 return False;
5665
5666 if(!prs_uint8s(False, "padding1 ", ps, depth, usr->padding1, sizeof(usr->padding1)))
5667 return False;
5668 if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
5669 return False;
5670 if(!prs_uint8("padding2 ", ps, depth, &usr->padding2))
5671 return False;
5672
5673
5674 if(!prs_uint8s(False, "password ", ps, depth, usr->pass, sizeof(usr->pass)))
5675 return False;
5676
5677 /* here begins pointed-to data */
5678
5679 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
5680 return False;
5681
5682 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
5683 return False;
5684
5685 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
5686 return False;
5687
5688 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
5689 return False;
5690
5691 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
5692 return False;
5693
5694 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
5695 return False;
5696
5697 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth)) /* user desc unicode string */
5698 return False;
5699
5700 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth)) /* worksations user can log on from */
5701 return False;
5702
5703 if(!smb_io_unistr2("uni_unknown_str ", &usr->uni_unknown_str, usr->hdr_unknown_str.buffer, ps, depth)) /* unknown string */
5704 return False;
5705
5706 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
5707 return False;
5708
5709 /* ok, this is only guess-work (as usual) */
5710 if (usr->ptr_logon_hrs) {
5711 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
5712 return False;
5713 }
5714
5715 return True;
5716 }
5717
5718 /*******************************************************************
5719 reads or writes a structure.
5720 NB. This structure is *definately* incorrect. It's my best guess
5721 currently for W2K SP2. The password field is encrypted in a different
5722 way than normal... And there are definately other problems. JRA.
5723 ********************************************************************/
5724
5725 static BOOL sam_io_user_info25(const char *desc, SAM_USER_INFO_25 * usr, prs_struct *ps, int depth)
5726 {
5727 if (usr == NULL)
5728 return False;
5729
5730 prs_debug(ps, depth, desc, "sam_io_user_info25");
5731 depth++;
5732
5733 if(!prs_align(ps))
5734 return False;
5735
5736 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
5737 return False;
5738 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
5739 return False;
5740 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
5741 return False;
5742 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps, depth))
5743 return False;
5744 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
5745 return False;
5746 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
5747 return False;
5748
5749 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
5750 return False;
5751 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
5752 return False;
5753 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
5754 return False;
5755 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
5756 return False;
5757 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
5758 return False;
5759 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
5760 return False;
5761 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
5762 return False;
5763 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
5764 return False;
5765 if(!smb_io_unihdr("hdr_unknown_str ", &usr->hdr_unknown_str, ps, depth)) /* unknown string */
5766 return False;
5767 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
5768 return False;
5769
5770 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
5771 return False;
5772 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
5773 return False;
5774
5775 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
5776 return False;
5777 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
5778 return False;
5779 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
5780 return False;
5781
5782 if(!prs_uint32s(False, "unknown_6 ", ps, depth, usr->unknown_6, 6))
5783 return False;
5784
5785 if(!prs_uint8s(False, "password ", ps, depth, usr->pass, sizeof(usr->pass)))
5786 return False;
5787
5788 /* here begins pointed-to data */
5789
5790 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
5791 return False;
5792
5793 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
5794 return False;
5795
5796 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
5797 return False;
5798
5799 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
5800 return False;
5801
5802 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
5803 return False;
5804
5805 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
5806 return False;
5807
5808 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth)) /* user desc unicode string */
5809 return False;
5810
5811 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth)) /* worksations user can log on from */
5812 return False;
5813
5814 if(!smb_io_unistr2("uni_unknown_str ", &usr->uni_unknown_str, usr->hdr_unknown_str.buffer, ps, depth)) /* unknown string */
5815 return False;
5816
5817 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
5818 return False;
5819
5820 #if 0 /* JRA - unknown... */
5821 /* ok, this is only guess-work (as usual) */
5822 if (usr->ptr_logon_hrs) {
5823 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
5824 return False;
5825 }
5826 #endif
5827
5828 return True;
5829 }
5830
5831
5832 /*************************************************************************
5833 init_sam_user_info21W
5834
5835 unknown_6 = 0x0000 04ec
5836
5837 *************************************************************************/
5838
5839 void init_sam_user_info21W(SAM_USER_INFO_21 * usr,
5840 NTTIME * logon_time,
5841 NTTIME * logoff_time,
5842 NTTIME * kickoff_time,
5843 NTTIME * pass_last_set_time,
5844 NTTIME * pass_can_change_time,
5845 NTTIME * pass_must_change_time,
5846 UNISTR2 *user_name,
5847 UNISTR2 *full_name,
5848 UNISTR2 *home_dir,
5849 UNISTR2 *dir_drive,
5850 UNISTR2 *log_scr,
5851 UNISTR2 *prof_path,
5852 UNISTR2 *desc,
5853 UNISTR2 *wkstas,
5854 UNISTR2 *unk_str,
5855 UNISTR2 *mung_dial,
5856 uchar lm_pwd[16],
5857 uchar nt_pwd[16],
5858 uint32 user_rid,
5859 uint32 group_rid,
5860 uint32 acb_info,
5861 uint32 fields_present,
5862 uint16 logon_divs,
5863 LOGON_HRS * hrs,
5864 uint16 bad_password_count,
5865 uint16 logon_count)
5866 {
5867 usr->logon_time = *logon_time;
5868 usr->logoff_time = *logoff_time;
5869 usr->kickoff_time = *kickoff_time;
5870 usr->pass_last_set_time = *pass_last_set_time;
5871 usr->pass_can_change_time = *pass_can_change_time;
5872 usr->pass_must_change_time = *pass_must_change_time;
5873
5874 memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd));
5875 memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd));
5876
5877 usr->user_rid = user_rid;
5878 usr->group_rid = group_rid;
5879 usr->acb_info = acb_info;
5880 usr->fields_present = fields_present; /* 0x00ff ffff */
5881
5882 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5883 usr->ptr_logon_hrs = hrs ? 1 : 0;
5884 usr->bad_password_count = bad_password_count;
5885 usr->logon_count = logon_count;
5886
5887 if (nt_time_is_zero(pass_must_change_time)) {
5888 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5889 } else {
5890 usr->passmustchange=0;
5891 }
5892
5893 ZERO_STRUCT(usr->padding1);
5894 ZERO_STRUCT(usr->padding2);
5895
5896 copy_unistr2(&usr->uni_user_name, user_name);
5897 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5898
5899 copy_unistr2(&usr->uni_full_name, full_name);
5900 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5901
5902 copy_unistr2(&usr->uni_home_dir, home_dir);
5903 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5904
5905 copy_unistr2(&usr->uni_dir_drive, dir_drive);
5906 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5907
5908 copy_unistr2(&usr->uni_logon_script, log_scr);
5909 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5910
5911 copy_unistr2(&usr->uni_profile_path, prof_path);
5912 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5913
5914 copy_unistr2(&usr->uni_acct_desc, desc);
5915 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5916
5917 copy_unistr2(&usr->uni_workstations, wkstas);
5918 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5919
5920 copy_unistr2(&usr->uni_unknown_str, unk_str);
5921 init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
5922
5923 copy_unistr2(&usr->uni_munged_dial, mung_dial);
5924 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5925
5926 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5927 }
5928
5929 /*************************************************************************
5930 init_sam_user_info21
5931
5932 unknown_6 = 0x0000 04ec
5933
5934 *************************************************************************/
5935
5936 NTSTATUS init_sam_user_info21A(SAM_USER_INFO_21 *usr, SAM_ACCOUNT *pw, DOM_SID *domain_sid)
5937 {
5938 NTTIME logon_time, logoff_time, kickoff_time,
5939 pass_last_set_time, pass_can_change_time,
5940 pass_must_change_time;
5941
5942 const char* user_name = pdb_get_username(pw);
5943 const char* full_name = pdb_get_fullname(pw);
5944 const char* home_dir = pdb_get_homedir(pw);
5945 const char* dir_drive = pdb_get_dir_drive(pw);
5946 const char* logon_script = pdb_get_logon_script(pw);
5947 const char* profile_path = pdb_get_profile_path(pw);
5948 const char* description = pdb_get_acct_desc(pw);
5949 const char* workstations = pdb_get_workstations(pw);
5950 const char* munged_dial = pdb_get_munged_dial(pw);
5951 DATA_BLOB munged_dial_blob;
5952
5953 uint32 user_rid;
5954 const DOM_SID *user_sid;
5955
5956 uint32 group_rid;
5957 const DOM_SID *group_sid;
5958
5959 if (munged_dial) {
5960 munged_dial_blob = base64_decode_data_blob(munged_dial);
5961 } else {
5962 munged_dial_blob = data_blob(NULL, 0);
5963 }
5964
5965 /* Create NTTIME structs */
5966 unix_to_nt_time (&logon_time, pdb_get_logon_time(pw));
5967 unix_to_nt_time (&logoff_time, pdb_get_logoff_time(pw));
5968 unix_to_nt_time (&kickoff_time, pdb_get_kickoff_time(pw));
5969 unix_to_nt_time (&pass_last_set_time, pdb_get_pass_last_set_time(pw));
5970 unix_to_nt_time (&pass_can_change_time, pdb_get_pass_can_change_time(pw));
5971 unix_to_nt_time (&pass_must_change_time,pdb_get_pass_must_change_time(pw));
5972
5973 /* structure assignment */
5974 usr->logon_time = logon_time;
5975 usr->logoff_time = logoff_time;
5976 usr->kickoff_time = kickoff_time;
5977 usr->pass_last_set_time = pass_last_set_time;
5978 usr->pass_can_change_time = pass_can_change_time;
5979 usr->pass_must_change_time = pass_must_change_time;
5980
5981 ZERO_STRUCT(usr->nt_pwd);
5982 ZERO_STRUCT(usr->lm_pwd);
5983
5984 user_sid = pdb_get_user_sid(pw);
5985
5986 if (!sid_peek_check_rid(domain_sid, user_sid, &user_rid)) {
5987 fstring user_sid_string;
5988 fstring domain_sid_string;
5989 DEBUG(0, ("init_sam_user_info_21A: User %s has SID %s, \nwhich conflicts with "
5990 "the domain sid %s. Failing operation.\n",
5991 user_name,
5992 sid_to_string(user_sid_string, user_sid),
5993 sid_to_string(domain_sid_string, domain_sid)));
5994 data_blob_free(&munged_dial_blob);
5995 return NT_STATUS_UNSUCCESSFUL;
5996 }
5997
5998 group_sid = pdb_get_group_sid(pw);
5999
6000 if (!sid_peek_check_rid(domain_sid, group_sid, &group_rid)) {
6001 fstring group_sid_string;
6002 fstring domain_sid_string;
6003 DEBUG(0, ("init_sam_user_info_21A: User %s has Primary Group SID %s, \n"
6004 "which conflicts with the domain sid %s. Failing operation.\n",
6005 user_name,
6006 sid_to_string(group_sid_string, group_sid),
6007 sid_to_string(domain_sid_string, domain_sid)));
6008 data_blob_free(&munged_dial_blob);
6009 return NT_STATUS_UNSUCCESSFUL;
6010 }
6011
6012 usr->user_rid = user_rid;
6013 usr->group_rid = group_rid;
6014 usr->acb_info = pdb_get_acct_ctrl(pw);
6015
6016 /*
6017 Look at a user on a real NT4 PDC with usrmgr, press
6018 'ok'. Then you will see that fields_present is set to
6019 0x08f827fa. Look at the user immediately after that again,
6020 and you will see that 0x00fffff is returned. This solves
6021 the problem that you get access denied after having looked
6022 at the user.
6023 -- Volker
6024 */
6025 usr->fields_present = pdb_build_fields_present(pw);
6026
6027 usr->logon_divs = pdb_get_logon_divs(pw);
6028 usr->ptr_logon_hrs = pdb_get_hours(pw) ? 1 : 0;
6029 usr->bad_password_count = pdb_get_bad_password_count(pw);
6030 usr->logon_count = pdb_get_logon_count(pw);
6031
6032 if (pdb_get_pass_must_change_time(pw) == 0) {
6033 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6034 } else {
6035 usr->passmustchange=0;
6036 }
6037
6038 ZERO_STRUCT(usr->padding1);
6039 ZERO_STRUCT(usr->padding2);
6040
6041 init_unistr2(&usr->uni_user_name, user_name, UNI_STR_TERMINATE);
6042 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6043
6044 init_unistr2(&usr->uni_full_name, full_name, UNI_STR_TERMINATE);
6045 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6046
6047 init_unistr2(&usr->uni_home_dir, home_dir, UNI_STR_TERMINATE);
6048 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6049
6050 init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_STR_TERMINATE);
6051 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6052
6053 init_unistr2(&usr->uni_logon_script, logon_script, UNI_STR_TERMINATE);
6054 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6055
6056 init_unistr2(&usr->uni_profile_path, profile_path, UNI_STR_TERMINATE);
6057 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6058
6059 init_unistr2(&usr->uni_acct_desc, description, UNI_STR_TERMINATE);
6060 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6061
6062 init_unistr2(&usr->uni_workstations, workstations, UNI_STR_TERMINATE);
6063 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6064
6065 init_unistr2(&usr->uni_unknown_str, NULL, UNI_STR_TERMINATE);
6066 init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
6067
6068 init_unistr2_from_datablob(&usr->uni_munged_dial, &munged_dial_blob);
6069 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6070 data_blob_free(&munged_dial_blob);
6071
6072 if (pdb_get_hours(pw)) {
6073 usr->logon_hrs.max_len = 1260;
6074 usr->logon_hrs.offset = 0;
6075 usr->logon_hrs.len = pdb_get_hours_len(pw);
6076 memcpy(&usr->logon_hrs.hours, pdb_get_hours(pw), MAX_HOURS_LEN);
6077 } else {
6078 usr->logon_hrs.max_len = 1260;
6079 usr->logon_hrs.offset = 0;
6080 usr->logon_hrs.len = 0;
6081 memset(&usr->logon_hrs, 0xff, sizeof(usr->logon_hrs));
6082 }
6083
6084 return NT_STATUS_OK;
6085 }
6086
6087 /*******************************************************************
6088 reads or writes a structure.
6089 ********************************************************************/
6090
6091 static BOOL sam_io_user_info21(const char *desc, SAM_USER_INFO_21 * usr,
6092 prs_struct *ps, int depth)
6093 {
6094 if (usr == NULL)
6095 return False;
6096
6097 prs_debug(ps, depth, desc, "sam_io_user_info21");
6098 depth++;
6099
6100 if(!prs_align(ps))
6101 return False;
6102
6103 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
6104 return False;
6105 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
6106 return False;
6107 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps,depth))
6108 return False;
6109 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
6110 return False;
6111 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps,depth))
6112 return False;
6113 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
6114 return False;
6115
6116 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
6117 return False;
6118 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
6119 return False;
6120 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
6121 return False;
6122 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
6123 return False;
6124 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
6125 return False;
6126 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
6127 return False;
6128 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
6129 return False;
6130 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
6131 return False;
6132 if(!smb_io_unihdr("hdr_unknown_str ", &usr->hdr_unknown_str, ps, depth)) /* unknown string */
6133 return False;
6134 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6135 return False;
6136
6137 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6138 return False;
6139 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6140 return False;
6141
6142 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
6143 return False;
6144 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
6145 return False;
6146 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
6147 return False;
6148
6149 if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6150 return False;
6151 if(!prs_uint16("logon_divs ", ps, depth, &usr->logon_divs)) /* logon divisions per week */
6152 return False;
6153 if(!prs_align(ps))
6154 return False;
6155 if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
6156 return False;
6157
6158 if(!prs_uint16("bad_password_count ", ps, depth, &usr->bad_password_count))
6159 return False;
6160 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count))
6161 return False;
6162
6163 if(!prs_uint8s(False, "padding1 ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6164 return False;
6165 if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6166 return False;
6167 if(!prs_uint8("padding2 ", ps, depth, &usr->padding2))
6168 return False;
6169
6170 /* here begins pointed-to data */
6171
6172 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name,usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
6173 return False;
6174 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
6175 return False;
6176 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
6177 return False;
6178 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
6179 return False;
6180 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
6181 return False;
6182 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
6183 return False;
6184 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth)) /* user desc unicode string */
6185 return False;
6186 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth)) /* worksations user can log on from */
6187 return False;
6188 if(!smb_io_unistr2("uni_unknown_str ", &usr->uni_unknown_str, usr->hdr_unknown_str.buffer, ps, depth)) /* unknown string */
6189 return False;
6190 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth)) /* worksations user can log on from */
6191 return False;
6192
6193 /* ok, this is only guess-work (as usual) */
6194 if (usr->ptr_logon_hrs) {
6195 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6196 return False;
6197 }
6198
6199 return True;
6200 }
6201
6202 void init_sam_user_info20A(SAM_USER_INFO_20 *usr, SAM_ACCOUNT *pw)
6203 {
6204 const char *munged_dial = pdb_get_munged_dial(pw);
6205 DATA_BLOB blob = base64_decode_data_blob(munged_dial);
6206
6207 init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
6208 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6209 data_blob_free(&blob);
6210 }
6211
6212 /*******************************************************************
6213 reads or writes a structure.
6214 ********************************************************************/
6215
6216 static BOOL sam_io_user_info20(const char *desc, SAM_USER_INFO_20 *usr,
6217 prs_struct *ps, int depth)
6218 {
6219 if (usr == NULL)
6220 return False;
6221
6222 prs_debug(ps, depth, desc, "sam_io_user_info20");
6223 depth++;
6224
6225 if(!prs_align(ps))
6226 return False;
6227
6228 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6229 return False;
6230
6231 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth)) /* worksations user can log on from */
6232 return False;
6233
6234 return True;
6235 }
6236
6237 /*******************************************************************
6238 inits a SAM_USERINFO_CTR structure.
6239 ********************************************************************/
6240
6241 NTSTATUS make_samr_userinfo_ctr_usr21(TALLOC_CTX *ctx, SAM_USERINFO_CTR * ctr,
6242 uint16 switch_value,
6243 SAM_USER_INFO_21 * usr)
6244 {
6245 DEBUG(5, ("make_samr_userinfo_ctr_usr21\n"));
6246
6247 ctr->switch_value = switch_value;
6248 ctr->info.id = NULL;
6249
6250 switch (switch_value) {
6251 case 0x10:
6252 ctr->info.id10 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_10);
6253 if (ctr->info.id10 == NULL)
6254 return NT_STATUS_NO_MEMORY;
6255
6256 init_sam_user_info10(ctr->info.id10, usr->acb_info);
6257 break;
6258 #if 0
6259 /* whoops - got this wrong. i think. or don't understand what's happening. */
6260 case 0x11:
6261 {
6262 NTTIME expire;
6263 info = (void *)&id11;
6264
6265 expire.low = 0xffffffff;
6266 expire.high = 0x7fffffff;
6267
6268 ctr->info.id = TALLOC_ZERO_P(ctx,SAM_USER_INFO_11);
6269 init_sam_user_info11(ctr->info.id11, &expire,
6270 "BROOKFIELDS$", /* name */
6271 0x03ef, /* user rid */
6272 0x201, /* group rid */
6273 0x0080); /* acb info */
6274
6275 break;
6276 }
6277 #endif
6278 case 0x12:
6279 ctr->info.id12 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_12);
6280 if (ctr->info.id12 == NULL)
6281 return NT_STATUS_NO_MEMORY;
6282
6283 init_sam_user_info12(ctr->info.id12, usr->lm_pwd, usr->nt_pwd);
6284 break;
6285 case 21:
6286 {
6287 SAM_USER_INFO_21 *cusr;
6288 cusr = TALLOC_ZERO_P(ctx,SAM_USER_INFO_21);
6289 ctr->info.id21 = cusr;
6290 if (ctr->info.id21 == NULL)
6291 return NT_STATUS_NO_MEMORY;
6292 memcpy(cusr, usr, sizeof(*usr));
6293 memset(cusr->lm_pwd, 0, sizeof(cusr->lm_pwd));
6294 memset(cusr->nt_pwd, 0, sizeof(cusr->nt_pwd));
6295 break;
6296 }
6297 default:
6298 DEBUG(4,("make_samr_userinfo_ctr: unsupported info\n"));
6299 return NT_STATUS_INVALID_INFO_CLASS;
6300 }
6301
6302 return NT_STATUS_OK;
6303 }
6304
6305 /*******************************************************************
6306 inits a SAM_USERINFO_CTR structure.
6307 ********************************************************************/
6308
6309 static void init_samr_userinfo_ctr(SAM_USERINFO_CTR * ctr, DATA_BLOB *sess_key,
6310 uint16 switch_value, void *info)
6311 {
6312 DEBUG(5, ("init_samr_userinfo_ctr\n"));
6313
6314 ctr->switch_value = switch_value;
6315 ctr->info.id = info;
6316
6317 switch (switch_value) {
6318 case 0x18:
6319 SamOEMhashBlob(ctr->info.id24->pass, 516, sess_key);
6320 dump_data(100, (char *)sess_key->data, sess_key->length);
6321 dump_data(100, (char *)ctr->info.id24->pass, 516);
6322 break;
6323 case 0x17:
6324 SamOEMhashBlob(ctr->info.id23->pass, 516, sess_key);
6325 dump_data(100, (char *)sess_key->data, sess_key->length);
6326 dump_data(100, (char *)ctr->info.id23->pass, 516);
6327 break;
6328 case 0x07:
6329 break;
6330 default:
6331 DEBUG(4,("init_samr_userinfo_ctr: unsupported switch level: %d\n", switch_value));
6332 }
6333 }
6334
6335 /*******************************************************************
6336 reads or writes a structure.
6337 ********************************************************************/
6338
6339 static BOOL samr_io_userinfo_ctr(const char *desc, SAM_USERINFO_CTR **ppctr,
6340 prs_struct *ps, int depth)
6341 {
6342 BOOL ret;
6343 SAM_USERINFO_CTR *ctr;
6344
6345 prs_debug(ps, depth, desc, "samr_io_userinfo_ctr");
6346 depth++;
6347
6348 if (UNMARSHALLING(ps)) {
6349 ctr = PRS_ALLOC_MEM(ps,SAM_USERINFO_CTR,1);
6350 if (ctr == NULL)
6351 return False;
6352 *ppctr = ctr;
6353 } else {
6354 ctr = *ppctr;
6355 }
6356
6357 /* lkclXXXX DO NOT ALIGN BEFORE READING SWITCH VALUE! */
6358
6359 if(!prs_uint16("switch_value", ps, depth, &ctr->switch_value))
6360 return False;
6361 if(!prs_align(ps))
6362 return False;
6363
6364 ret = False;
6365
6366 switch (ctr->switch_value) {
6367 case 0x07:
6368 if (UNMARSHALLING(ps))
6369 ctr->info.id7 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_7,1);
6370 if (ctr->info.id7 == NULL) {
6371 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6372 return False;
6373 }
6374 ret = sam_io_user_info7("", ctr->info.id7, ps, depth);
6375 break;
6376 case 0x10:
6377 if (UNMARSHALLING(ps))
6378 ctr->info.id10 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_10,1);
6379 if (ctr->info.id10 == NULL) {
6380 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6381 return False;
6382 }
6383 ret = sam_io_user_info10("", ctr->info.id10, ps, depth);
6384 break;
6385 case 0x11:
6386 if (UNMARSHALLING(ps))
6387 ctr->info.id11 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_11,1);
6388
6389 if (ctr->info.id11 == NULL) {
6390 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6391 return False;
6392 }
6393 ret = sam_io_user_info11("", ctr->info.id11, ps, depth);
6394 break;
6395 case 0x12:
6396 if (UNMARSHALLING(ps))
6397 ctr->info.id12 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_12,1);
6398
6399 if (ctr->info.id12 == NULL) {
6400 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6401 return False;
6402 }
6403 ret = sam_io_user_info12("", ctr->info.id12, ps, depth);
6404 break;
6405 case 20:
6406 if (UNMARSHALLING(ps))
6407 ctr->info.id20 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_20,1);
6408
6409 if (ctr->info.id20 == NULL) {
6410 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6411 return False;
6412 }
6413 ret = sam_io_user_info20("", ctr->info.id20, ps, depth);
6414 break;
6415 case 21:
6416 if (UNMARSHALLING(ps))
6417 ctr->info.id21 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_21,1);
6418
6419 if (ctr->info.id21 == NULL) {
6420 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6421 return False;
6422 }
6423 ret = sam_io_user_info21("", ctr->info.id21, ps, depth);
6424 break;
6425 case 23:
6426 if (UNMARSHALLING(ps))
6427 ctr->info.id23 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_23,1);
6428
6429 if (ctr->info.id23 == NULL) {
6430 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6431 return False;
6432 }
6433 ret = sam_io_user_info23("", ctr->info.id23, ps, depth);
6434 break;
6435 case 24:
6436 if (UNMARSHALLING(ps))
6437 ctr->info.id24 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_24,1);
6438
6439 if (ctr->info.id24 == NULL) {
6440 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6441 return False;
6442 }
6443 ret = sam_io_user_info24("", ctr->info.id24, ps, depth);
6444 break;
6445 case 25:
6446 if (UNMARSHALLING(ps))
6447 ctr->info.id25 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_25,1);
6448
6449 if (ctr->info.id25 == NULL) {
6450 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6451 return False;
6452 }
6453 ret = sam_io_user_info25("", ctr->info.id25, ps, depth);
6454 break;
6455 default:
6456 DEBUG(2, ("samr_io_userinfo_ctr: unknown switch level 0x%x\n", ctr->switch_value));
6457 ret = False;
6458 break;
6459 }
6460
6461 return ret;
6462 }
6463
6464 /*******************************************************************
6465 inits a SAMR_R_QUERY_USERINFO structure.
6466 ********************************************************************/
6467
6468 void init_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO * r_u,
6469 SAM_USERINFO_CTR * ctr, NTSTATUS status)
6470 {
6471 DEBUG(5, ("init_samr_r_query_userinfo\n"));
6472
6473 r_u->ptr = 0;
6474 r_u->ctr = NULL;
6475
6476 if (NT_STATUS_IS_OK(status)) {
6477 r_u->ptr = 1;
6478 r_u->ctr = ctr;
6479 }
6480
6481 r_u->status = status; /* return status */
6482 }
6483
6484 /*******************************************************************
6485 reads or writes a structure.
6486 ********************************************************************/
6487
6488 BOOL samr_io_r_query_userinfo(const char *desc, SAMR_R_QUERY_USERINFO * r_u,
6489 prs_struct *ps, int depth)
6490 {
6491 if (r_u == NULL)
6492 return False;
6493
6494 prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
6495 depth++;
6496
6497 if(!prs_align(ps))
6498 return False;
6499
6500 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
6501 return False;
6502
6503 if (r_u->ptr != 0) {
6504 if(!samr_io_userinfo_ctr("ctr", &r_u->ctr, ps, depth))
6505 return False;
6506 }
6507
6508 if(!prs_align(ps))
6509 return False;
6510 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6511 return False;
6512
6513 return True;
6514 }
6515
6516 /*******************************************************************
6517 inits a SAMR_Q_SET_USERINFO structure.
6518 ********************************************************************/
6519
6520 void init_samr_q_set_userinfo(SAMR_Q_SET_USERINFO * q_u,
6521 POLICY_HND *hnd, DATA_BLOB *sess_key,
6522 uint16 switch_value, void *info)
6523 {
6524 DEBUG(5, ("init_samr_q_set_userinfo\n"));
6525
6526 q_u->pol = *hnd;
6527 q_u->switch_value = switch_value;
6528 init_samr_userinfo_ctr(q_u->ctr, sess_key, switch_value, info);
6529 }
6530
6531 /*******************************************************************
6532 reads or writes a structure.
6533 ********************************************************************/
6534
6535 BOOL samr_io_q_set_userinfo(const char *desc, SAMR_Q_SET_USERINFO * q_u,
6536 prs_struct *ps, int depth)
6537 {
6538 if (q_u == NULL)
6539 return False;
6540
6541 prs_debug(ps, depth, desc, "samr_io_q_set_userinfo");
6542 depth++;
6543
6544 if(!prs_align(ps))
6545 return False;
6546
6547 smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
6548
6549 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6550 return False;
6551 if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6552 return False;
6553
6554 return True;
6555 }
6556
6557 /*******************************************************************
6558 inits a SAMR_R_SET_USERINFO structure.
6559 ********************************************************************/
6560
6561 void init_samr_r_set_userinfo(SAMR_R_SET_USERINFO * r_u, NTSTATUS status)
6562 {
6563 DEBUG(5, ("init_samr_r_set_userinfo\n"));
6564
6565 r_u->status = status; /* return status */
6566 }
6567
6568 /*******************************************************************
6569 reads or writes a structure.
6570 ********************************************************************/
6571
6572 BOOL samr_io_r_set_userinfo(const char *desc, SAMR_R_SET_USERINFO * r_u,
6573 prs_struct *ps, int depth)
6574 {
6575 if (r_u == NULL)
6576 return False;
6577
6578 prs_debug(ps, depth, desc, "samr_io_r_set_userinfo");
6579 depth++;
6580
6581 if(!prs_align(ps))
6582 return False;
6583
6584 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6585 return False;
6586
6587 return True;
6588 }
6589
6590 /*******************************************************************
6591 inits a SAMR_Q_SET_USERINFO2 structure.
6592 ********************************************************************/
6593
6594 void init_samr_q_set_userinfo2(SAMR_Q_SET_USERINFO2 * q_u,
6595 POLICY_HND *hnd, DATA_BLOB *sess_key,
6596 uint16 switch_value, SAM_USERINFO_CTR * ctr)
6597 {
6598 DEBUG(5, ("init_samr_q_set_userinfo2\n"));
6599
6600 q_u->pol = *hnd;
6601 q_u->switch_value = switch_value;
6602 q_u->ctr = ctr;
6603
6604 if (q_u->ctr != NULL)
6605 q_u->ctr->switch_value = switch_value;
6606
6607 switch (switch_value) {
6608 case 0x12:
6609 SamOEMhashBlob(ctr->info.id12->lm_pwd, 16, sess_key);
6610 SamOEMhashBlob(ctr->info.id12->nt_pwd, 16, sess_key);
6611 dump_data(100, (char *)sess_key->data, sess_key->length);
6612 dump_data(100, (char *)ctr->info.id12->lm_pwd, 16);
6613 dump_data(100, (char *)ctr->info.id12->nt_pwd, 16);
6614 break;
6615 }
6616 }
6617
6618 /*******************************************************************
6619 reads or writes a structure.
6620 ********************************************************************/
6621
6622 BOOL samr_io_q_set_userinfo2(const char *desc, SAMR_Q_SET_USERINFO2 * q_u,
6623 prs_struct *ps, int depth)
6624 {
6625 if (q_u == NULL)
6626 return False;
6627
6628 prs_debug(ps, depth, desc, "samr_io_q_set_userinfo2");
6629 depth++;
6630
6631 if(!prs_align(ps))
6632 return False;
6633
6634 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
6635 return False;
6636
6637 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6638 return False;
6639 if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6640 return False;
6641
6642 return True;
6643 }
6644
6645 /*******************************************************************
6646 inits a SAMR_R_SET_USERINFO2 structure.
6647 ********************************************************************/
6648
6649 void init_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2 * r_u, NTSTATUS status)
6650 {
6651 DEBUG(5, ("init_samr_r_set_userinfo2\n"));
6652
6653 r_u->status = status; /* return status */
6654 }
6655
6656 /*******************************************************************
6657 reads or writes a structure.
6658 ********************************************************************/
6659
6660 BOOL samr_io_r_set_userinfo2(const char *desc, SAMR_R_SET_USERINFO2 * r_u,
6661 prs_struct *ps, int depth)
6662 {
6663 if (r_u == NULL)
6664 return False;
6665
6666 prs_debug(ps, depth, desc, "samr_io_r_set_userinfo2");
6667 depth++;
6668
6669 if(!prs_align(ps))
6670 return False;
6671
6672 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6673 return False;
6674
6675 return True;
6676 }
6677
6678 /*******************************************************************
6679 inits a SAMR_Q_CONNECT structure.
6680 ********************************************************************/
6681
6682 void init_samr_q_connect(SAMR_Q_CONNECT * q_u,
6683 char *srv_name, uint32 access_mask)
6684 {
6685 DEBUG(5, ("init_samr_q_connect\n"));
6686
6687 /* make PDC server name \\server */
6688 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
6689 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
6690
6691 /* example values: 0x0000 0002 */
6692 q_u->access_mask = access_mask;
6693 }
6694
6695 /*******************************************************************
6696 reads or writes a structure.
6697 ********************************************************************/
6698
6699 BOOL samr_io_q_connect(const char *desc, SAMR_Q_CONNECT * q_u,
6700 prs_struct *ps, int depth)
6701 {
6702 if (q_u == NULL)
6703 return False;
6704
6705 prs_debug(ps, depth, desc, "samr_io_q_connect");
6706 depth++;
6707
6708 if(!prs_align(ps))
6709 return False;
6710
6711 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
6712 return False;
6713 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
6714 return False;
6715
6716 if(!prs_align(ps))
6717 return False;
6718 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6719 return False;
6720
6721 return True;
6722 }
6723
6724 /*******************************************************************
6725 reads or writes a structure.
6726 ********************************************************************/
6727
6728 BOOL samr_io_r_connect(const char *desc, SAMR_R_CONNECT * r_u,
6729 prs_struct *ps, int depth)
6730 {
6731 if (r_u == NULL)
6732 return False;
6733
6734 prs_debug(ps, depth, desc, "samr_io_r_connect");
6735 depth++;
6736
6737 if(!prs_align(ps))
6738 return False;
6739
6740 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6741 return False;
6742
6743 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6744 return False;
6745
6746 return True;
6747 }
6748
6749 /*******************************************************************
6750 inits a SAMR_Q_CONNECT4 structure.
6751 ********************************************************************/
6752
6753 void init_samr_q_connect4(SAMR_Q_CONNECT4 * q_u,
6754 char *srv_name, uint32 access_mask)
6755 {
6756 DEBUG(5, ("init_samr_q_connect\n"));
6757
6758 /* make PDC server name \\server */
6759 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
6760 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
6761
6762 /* Only value we've seen, possibly an address type ? */
6763 q_u->unk_0 = 2;
6764
6765 /* example values: 0x0000 0002 */
6766 q_u->access_mask = access_mask;
6767 }
6768
6769 /*******************************************************************
6770 reads or writes a structure.
6771 ********************************************************************/
6772
6773 BOOL samr_io_q_connect4(const char *desc, SAMR_Q_CONNECT4 * q_u,
6774 prs_struct *ps, int depth)
6775 {
6776 if (q_u == NULL)
6777 return False;
6778
6779 prs_debug(ps, depth, desc, "samr_io_q_connect4");
6780 depth++;
6781
6782 if(!prs_align(ps))
6783 return False;
6784
6785 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
6786 return False;
6787 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
6788 return False;
6789
6790 if(!prs_align(ps))
6791 return False;
6792 if(!prs_uint32("unk_0", ps, depth, &q_u->unk_0))
6793 return False;
6794 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6795 return False;
6796
6797 return True;
6798 }
6799
6800 /*******************************************************************
6801 reads or writes a structure.
6802 ********************************************************************/
6803
6804 BOOL samr_io_r_connect4(const char *desc, SAMR_R_CONNECT4 * r_u,
6805 prs_struct *ps, int depth)
6806 {
6807 if (r_u == NULL)
6808 return False;
6809
6810 prs_debug(ps, depth, desc, "samr_io_r_connect4");
6811 depth++;
6812
6813 if(!prs_align(ps))
6814 return False;
6815
6816 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6817 return False;
6818
6819 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6820 return False;
6821
6822 return True;
6823 }
6824
6825 /*******************************************************************
6826 inits a SAMR_Q_CONNECT_ANON structure.
6827 ********************************************************************/
6828
6829 void init_samr_q_connect_anon(SAMR_Q_CONNECT_ANON * q_u)
6830 {
6831 DEBUG(5, ("init_samr_q_connect_anon\n"));
6832
6833 q_u->ptr = 1;
6834 q_u->unknown_0 = 0x5c; /* server name (?!!) */
6835 q_u->unknown_1 = 0x01;
6836 q_u->access_mask = 0x20;
6837 }
6838
6839 /*******************************************************************
6840 reads or writes a structure.
6841 ********************************************************************/
6842
6843 BOOL samr_io_q_connect_anon(const char *desc, SAMR_Q_CONNECT_ANON * q_u,
6844 prs_struct *ps, int depth)
6845 {
6846 if (q_u == NULL)
6847 return False;
6848
6849 prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
6850 depth++;
6851
6852 if(!prs_align(ps))
6853 return False;
6854
6855 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
6856 return False;
6857 if(!prs_uint16("unknown_0", ps, depth, &q_u->unknown_0))
6858 return False;
6859 if(!prs_uint16("unknown_1", ps, depth, &q_u->unknown_1))
6860 return False;
6861 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6862 return False;
6863
6864 return True;
6865 }
6866
6867 /*******************************************************************
6868 reads or writes a structure.
6869 ********************************************************************/
6870
6871 BOOL samr_io_r_connect_anon(const char *desc, SAMR_R_CONNECT_ANON * r_u,
6872 prs_struct *ps, int depth)
6873 {
6874 if (r_u == NULL)
6875 return False;
6876
6877 prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
6878 depth++;
6879
6880 if(!prs_align(ps))
6881 return False;
6882
6883 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6884 return False;
6885
6886 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6887 return False;
6888
6889 return True;
6890 }
6891
6892 /*******************************************************************
6893 inits a SAMR_Q_GET_DOM_PWINFO structure.
6894 ********************************************************************/
6895
6896 void init_samr_q_get_dom_pwinfo(SAMR_Q_GET_DOM_PWINFO * q_u,
6897 char *srv_name)
6898 {
6899 DEBUG(5, ("init_samr_q_get_dom_pwinfo\n"));
6900
6901 q_u->ptr = 1;
6902 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_FLAGS_NONE);
6903 init_uni_hdr(&q_u->hdr_srv_name, &q_u->uni_srv_name);
6904 }
6905
6906 /*******************************************************************
6907 reads or writes a structure.
6908 ********************************************************************/
6909
6910 BOOL samr_io_q_get_dom_pwinfo(const char *desc, SAMR_Q_GET_DOM_PWINFO * q_u,
6911 prs_struct *ps, int depth)
6912 {
6913 if (q_u == NULL)
6914 return False;
6915
6916 prs_debug(ps, depth, desc, "samr_io_q_get_dom_pwinfo");
6917 depth++;
6918
6919 if(!prs_align(ps))
6920 return False;
6921
6922 if(!prs_uint32("ptr", ps, depth, &q_u->ptr))
6923 return False;
6924 if (q_u->ptr != 0) {
6925 if(!smb_io_unihdr("", &q_u->hdr_srv_name, ps, depth))
6926 return False;
6927 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->hdr_srv_name.buffer, ps, depth))
6928 return False;
6929 }
6930
6931 return True;
6932 }
6933
6934 /*******************************************************************
6935 reads or writes a structure.
6936 ********************************************************************/
6937
6938 BOOL samr_io_r_get_dom_pwinfo(const char *desc, SAMR_R_GET_DOM_PWINFO * r_u,
6939 prs_struct *ps, int depth)
6940 {
6941 if (r_u == NULL)
6942 return False;
6943
6944 prs_debug(ps, depth, desc, "samr_io_r_get_dom_pwinfo");
6945 depth++;
6946
6947 if(!prs_align(ps))
6948 return False;
6949
6950 /*
6951 * see the Samba4 IDL for what these actually are.
6952 */
6953
6954 if(!prs_uint16("unk_0", ps, depth, &r_u->unk_0))
6955 return False;
6956 if(!prs_align(ps))
6957 return False;
6958 if(!prs_uint32("unk_1", ps, depth, &r_u->unk_1))
6959 return False;
6960
6961 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6962 return False;
6963
6964 return True;
6965 }
6966
6967 /*******************************************************************
6968 make a SAMR_ENC_PASSWD structure.
6969 ********************************************************************/
6970
6971 void init_enc_passwd(SAMR_ENC_PASSWD * pwd, const char pass[512])
6972 {
6973 ZERO_STRUCTP(pwd);
6974
6975 if (pass == NULL) {
6976 pwd->ptr = 0;
6977 } else {
6978 pwd->ptr = 1;
6979 memcpy(pwd->pass, pass, sizeof(pwd->pass));
6980 }
6981 }
6982
6983 /*******************************************************************
6984 reads or writes a SAMR_ENC_PASSWD structure.
6985 ********************************************************************/
6986
6987 BOOL samr_io_enc_passwd(const char *desc, SAMR_ENC_PASSWD * pwd,
6988 prs_struct *ps, int depth)
6989 {
6990 if (pwd == NULL)
6991 return False;
6992
6993 prs_debug(ps, depth, desc, "samr_io_enc_passwd");
6994 depth++;
6995
6996 if(!prs_align(ps))
6997 return False;
6998
6999 if(!prs_uint32("ptr", ps, depth, &pwd->ptr))
7000 return False;
7001
7002 if (pwd->ptr != 0) {
7003 if(!prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass)))
7004 return False;
7005 }
7006
7007 return True;
7008 }
7009
7010 /*******************************************************************
7011 inits a SAMR_ENC_HASH structure.
7012 ********************************************************************/
7013
7014 void init_enc_hash(SAMR_ENC_HASH * hsh, const uchar hash[16])
7015 {
7016 ZERO_STRUCTP(hsh);
7017
7018 if (hash == NULL) {
7019 hsh->ptr = 0;
7020 } else {
7021 hsh->ptr = 1;
7022 memcpy(hsh->hash, hash, sizeof(hsh->hash));
7023 }
7024 }
7025
7026 /*******************************************************************
7027 reads or writes a SAMR_ENC_HASH structure.
7028 ********************************************************************/
7029
7030 BOOL samr_io_enc_hash(const char *desc, SAMR_ENC_HASH * hsh,
7031 prs_struct *ps, int depth)
7032 {
7033 if (hsh == NULL)
7034 return False;
7035
7036 prs_debug(ps, depth, desc, "samr_io_enc_hash");
7037 depth++;
7038
7039 if(!prs_align(ps))
7040 return False;
7041
7042 if(!prs_uint32("ptr ", ps, depth, &hsh->ptr))
7043 return False;
7044 if (hsh->ptr != 0) {
7045 if(!prs_uint8s(False, "hash", ps, depth, hsh->hash,sizeof(hsh->hash)))
7046 return False;
7047 }
7048
7049 return True;
7050 }
7051
7052 /*******************************************************************
7053 inits a SAMR_R_GET_DOM_PWINFO structure.
7054 ********************************************************************/
7055
7056 void init_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER * q_u,
7057 const char *dest_host, const char *user_name,
7058 const char nt_newpass[516],
7059 const uchar nt_oldhash[16],
7060 const char lm_newpass[516],
7061 const uchar lm_oldhash[16])
7062 {
7063 DEBUG(5, ("init_samr_q_chgpasswd_user\n"));
7064
7065 q_u->ptr_0 = 1;
7066 init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7067 init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7068
7069 init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7070 init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7071
7072 init_enc_passwd(&q_u->nt_newpass, nt_newpass);
7073 init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7074
7075 q_u->unknown = 0x01;
7076
7077 init_enc_passwd(&q_u->lm_newpass, lm_newpass);
7078 init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7079 }
7080
7081 /*******************************************************************
7082 reads or writes a structure.
7083 ********************************************************************/
7084
7085 BOOL samr_io_q_chgpasswd_user(const char *desc, SAMR_Q_CHGPASSWD_USER * q_u,
7086 prs_struct *ps, int depth)
7087 {
7088 if (q_u == NULL)
7089 return False;
7090
7091 prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
7092 depth++;
7093
7094 if(!prs_align(ps))
7095 return False;
7096
7097 if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7098 return False;
7099
7100 if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7101 return False;
7102 if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7103 return False;
7104
7105 if(!prs_align(ps))
7106 return False;
7107 if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7108 return False;
7109 if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7110 return False;
7111
7112 if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7113 return False;
7114 if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7115 return False;
7116
7117 if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
7118 return False;
7119
7120 if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7121 return False;
7122 if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7123 return False;
7124
7125 return True;
7126 }
7127
7128 /*******************************************************************
7129 inits a SAMR_R_CHGPASSWD_USER structure.
7130 ********************************************************************/
7131
7132 void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER * r_u, NTSTATUS status)
7133 {
7134 DEBUG(5, ("init_r_chgpasswd_user\n"));
7135
7136 r_u->status = status;
7137 }
7138
7139 /*******************************************************************
7140 reads or writes a structure.
7141 ********************************************************************/
7142
7143 BOOL samr_io_r_chgpasswd_user(const char *desc, SAMR_R_CHGPASSWD_USER * r_u,
7144 prs_struct *ps, int depth)
7145 {
7146 if (r_u == NULL)
7147 return False;
7148
7149 prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
7150 depth++;
7151
7152 if(!prs_align(ps))
7153 return False;
7154
7155 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7156 return False;
7157
7158 return True;
7159 }
7160
7161 /*******************************************************************
7162 reads or writes a structure.
7163 ********************************************************************/
7164
7165 void init_samr_q_unknown_2e(SAMR_Q_UNKNOWN_2E *q_u,
7166 POLICY_HND *domain_pol, uint16 switch_value)
7167 {
7168 DEBUG(5, ("init_samr_q_unknown_2e\n"));
7169
7170 q_u->domain_pol = *domain_pol;
7171 q_u->switch_value = switch_value;
7172 }
7173
7174 /*******************************************************************
7175 reads or writes a structure.
7176 ********************************************************************/
7177
7178 BOOL samr_io_q_unknown_2e(const char *desc, SAMR_Q_UNKNOWN_2E *q_u,
7179 prs_struct *ps, int depth)
7180 {
7181 if (q_u == NULL)
7182 return False;
7183
7184 prs_debug(ps, depth, desc, "samr_io_q_unknown_2e");
7185 depth++;
7186
7187 if(!prs_align(ps))
7188 return False;
7189
7190 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7191 return False;
7192
7193 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7194 return False;
7195
7196 return True;
7197 }
7198
7199 /*******************************************************************
7200 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7201 ********************************************************************/
7202
7203 void init_samr_r_samr_unknown_2e(SAMR_R_UNKNOWN_2E * r_u,
7204 uint16 switch_value, SAM_UNK_CTR * ctr,
7205 NTSTATUS status)
7206 {
7207 DEBUG(5, ("init_samr_r_samr_unknown_2e\n"));
7208
7209 r_u->ptr_0 = 0;
7210 r_u->switch_value = 0;
7211 r_u->status = status; /* return status */
7212
7213 if (NT_STATUS_IS_OK(status)) {
7214 r_u->switch_value = switch_value;
7215 r_u->ptr_0 = 1;
7216 r_u->ctr = ctr;
7217 }
7218 }
7219
7220 /*******************************************************************
7221 reads or writes a structure.
7222 ********************************************************************/
7223
7224 BOOL samr_io_r_samr_unknown_2e(const char *desc, SAMR_R_UNKNOWN_2E * r_u,
7225 prs_struct *ps, int depth)
7226 {
7227 if (r_u == NULL)
7228 return False;
7229
7230 prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
7231 depth++;
7232
7233 if(!prs_align(ps))
7234 return False;
7235
7236 if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
7237 return False;
7238
7239 if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
7240 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
7241 return False;
7242 if(!prs_align(ps))
7243 return False;
7244
7245 switch (r_u->switch_value) {
7246 case 0x0c:
7247 if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
7248 return False;
7249 break;
7250 case 0x07:
7251 if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
7252 return False;
7253 break;
7254 case 0x06:
7255 if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
7256 return False;
7257 break;
7258 case 0x05:
7259 if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
7260 return False;
7261 break;
7262 case 0x03:
7263 if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
7264 return False;
7265 break;
7266 case 0x02:
7267 if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
7268 return False;
7269 break;
7270 case 0x01:
7271 if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
7272 return False;
7273 break;
7274 default:
7275 DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
7276 r_u->switch_value));
7277 r_u->status = NT_STATUS_INVALID_INFO_CLASS;
7278 return False;
7279 }
7280 }
7281
7282 if(!prs_align(ps))
7283 return False;
7284
7285 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7286 return False;
7287
7288 return True;
7289 }
7290
7291
7292 /*******************************************************************
7293 reads or writes a structure.
7294 ********************************************************************/
7295
7296 void init_samr_q_set_domain_info(SAMR_Q_SET_DOMAIN_INFO *q_u,
7297 POLICY_HND *domain_pol, uint16 switch_value, SAM_UNK_CTR *ctr)
7298 {
7299 DEBUG(5, ("init_samr_q_set_domain_info\n"));
7300
7301 q_u->domain_pol = *domain_pol;
7302 q_u->switch_value0 = switch_value;
7303
7304 q_u->switch_value = switch_value;
7305 q_u->ctr = ctr;
7306
7307 }
7308
7309 /*******************************************************************
7310 reads or writes a structure.
7311 ********************************************************************/
7312
7313 BOOL samr_io_q_set_domain_info(const char *desc, SAMR_Q_SET_DOMAIN_INFO *q_u,
7314 prs_struct *ps, int depth)
7315 {
7316 if (q_u == NULL)
7317 return False;
7318
7319 prs_debug(ps, depth, desc, "samr_io_q_set_domain_info");
7320 depth++;
7321
7322 if(!prs_align(ps))
7323 return False;
7324
7325 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7326 return False;
7327
7328 if(!prs_uint16("switch_value0", ps, depth, &q_u->switch_value0))
7329 return False;
7330
7331 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7332 return False;
7333
7334 if(!prs_align(ps))
7335 return False;
7336
7337 if ((q_u->ctr = PRS_ALLOC_MEM(ps, SAM_UNK_CTR, 1)) == NULL)
7338 return False;
7339
7340 switch (q_u->switch_value) {
7341
7342 case 0x0c:
7343 if(!sam_io_unk_info12("unk_inf12", &q_u->ctr->info.inf12, ps, depth))
7344 return False;
7345 break;
7346 case 0x07:
7347 if(!sam_io_unk_info7("unk_inf7",&q_u->ctr->info.inf7, ps,depth))
7348 return False;
7349 break;
7350 case 0x06:
7351 if(!sam_io_unk_info6("unk_inf6",&q_u->ctr->info.inf6, ps,depth))
7352 return False;
7353 break;
7354 case 0x05:
7355 if(!sam_io_unk_info5("unk_inf5",&q_u->ctr->info.inf5, ps,depth))
7356 return False;
7357 break;
7358 case 0x03:
7359 if(!sam_io_unk_info3("unk_inf3",&q_u->ctr->info.inf3, ps,depth))
7360 return False;
7361 break;
7362 case 0x02:
7363 if(!sam_io_unk_info2("unk_inf2",&q_u->ctr->info.inf2, ps,depth))
7364 return False;
7365 break;
7366 case 0x01:
7367 if(!sam_io_unk_info1("unk_inf1",&q_u->ctr->info.inf1, ps,depth))
7368 return False;
7369 break;
7370 default:
7371 DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
7372 q_u->switch_value));
7373 return False;
7374 }
7375
7376 return True;
7377 }
7378
7379 /*******************************************************************
7380 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7381 ********************************************************************/
7382
7383 void init_samr_r_set_domain_info(SAMR_R_SET_DOMAIN_INFO * r_u, NTSTATUS status)
7384 {
7385 DEBUG(5, ("init_samr_r_set_domain_info\n"));
7386
7387 r_u->status = status; /* return status */
7388 }
7389
7390 /*******************************************************************
7391 reads or writes a structure.
7392 ********************************************************************/
7393
7394 BOOL samr_io_r_set_domain_info(const char *desc, SAMR_R_SET_DOMAIN_INFO * r_u,
7395 prs_struct *ps, int depth)
7396 {
7397 if (r_u == NULL)
7398 return False;
7399
7400 prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
7401 depth++;
7402
7403 if(!prs_align(ps))
7404 return False;
7405
7406 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7407 return False;
7408
7409 return True;
7410 }
Samba GIT mirror