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