?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add 'net rpc group [add|del]mem' for domain groups and aliases.
[Samba/gebeck_regimport.git] / source / rpc_parse / parse_samr.c
blob34b0cf28481d596c46e9d03ebe6cecb0a94ff58b
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, const char *acct_desc)
2275 {
2276 DEBUG(5, ("init_samr_group_info4\n"));
2277
2278 gr4->level = 4;
2279 init_unistr2(&gr4->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2280 init_uni_hdr(&gr4->hdr_acct_desc, &gr4->uni_acct_desc);
2281 }
2282
2283 /*******************************************************************
2284 reads or writes a structure.
2285 ********************************************************************/
2286
2287 BOOL samr_io_group_info4(const char *desc, GROUP_INFO4 * gr4,
2288 prs_struct *ps, int depth)
2289 {
2290 if (gr4 == NULL)
2291 return False;
2292
2293 prs_debug(ps, depth, desc, "samr_io_group_info4");
2294 depth++;
2295
2296 if(!prs_uint16("hdr_level", ps, depth, &gr4->level))
2297 return False;
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, const 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, const 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, const 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 = MAXIMUM_ALLOWED_ACCESS;
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 unknown_5 = 0x0001 0000
5320 unknown_6 = 0x0000 04ec
5321
5322 *************************************************************************/
5323
5324 void init_sam_user_info24(SAM_USER_INFO_24 * usr, char newpass[516], uint16 pw_len)
5325 {
5326 DEBUG(10, ("init_sam_user_info24:\n"));
5327 memcpy(usr->pass, newpass, sizeof(usr->pass));
5328 usr->pw_len = pw_len;
5329 }
5330
5331 /*******************************************************************
5332 reads or writes a structure.
5333 ********************************************************************/
5334
5335 static BOOL sam_io_user_info24(const char *desc, SAM_USER_INFO_24 * usr,
5336 prs_struct *ps, int depth)
5337 {
5338 if (usr == NULL)
5339 return False;
5340
5341 prs_debug(ps, depth, desc, "sam_io_user_info24");
5342 depth++;
5343
5344 if(!prs_align(ps))
5345 return False;
5346
5347 if(!prs_uint8s(False, "password", ps, depth, usr->pass,
5348 sizeof(usr->pass)))
5349 return False;
5350
5351 if (MARSHALLING(ps) && (usr->pw_len != 0)) {
5352 if (!prs_uint16("pw_len", ps, depth, &usr->pw_len))
5353 return False;
5354 }
5355 if(!prs_align(ps))
5356 return False;
5357
5358 return True;
5359 }
5360
5361 /*************************************************************************
5362 init_sam_user_info23
5363
5364 unknown_6 = 0x0000 04ec
5365
5366 *************************************************************************/
5367
5368 void init_sam_user_info23W(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5369 NTTIME * logoff_time, /* all zeros */
5370 NTTIME * kickoff_time, /* all zeros */
5371 NTTIME * pass_last_set_time, /* all zeros */
5372 NTTIME * pass_can_change_time, /* all zeros */
5373 NTTIME * pass_must_change_time, /* all zeros */
5374 UNISTR2 *user_name,
5375 UNISTR2 *full_name,
5376 UNISTR2 *home_dir,
5377 UNISTR2 *dir_drive,
5378 UNISTR2 *log_scr,
5379 UNISTR2 *prof_path,
5380 UNISTR2 *desc,
5381 UNISTR2 *wkstas,
5382 UNISTR2 *unk_str,
5383 UNISTR2 *mung_dial,
5384 uint32 user_rid, /* 0x0000 0000 */
5385 uint32 group_rid,
5386 uint32 acb_info,
5387 uint32 fields_present,
5388 uint16 logon_divs,
5389 LOGON_HRS * hrs,
5390 uint16 bad_password_count,
5391 uint16 logon_count,
5392 char newpass[516], uint32 unknown_6)
5393 {
5394 usr->logon_time = *logon_time; /* all zeros */
5395 usr->logoff_time = *logoff_time; /* all zeros */
5396 usr->kickoff_time = *kickoff_time; /* all zeros */
5397 usr->pass_last_set_time = *pass_last_set_time; /* all zeros */
5398 usr->pass_can_change_time = *pass_can_change_time; /* all zeros */
5399 usr->pass_must_change_time = *pass_must_change_time; /* all zeros */
5400
5401 ZERO_STRUCT(usr->nt_pwd);
5402 ZERO_STRUCT(usr->lm_pwd);
5403
5404 usr->user_rid = user_rid; /* 0x0000 0000 */
5405 usr->group_rid = group_rid;
5406 usr->acb_info = acb_info;
5407 usr->fields_present = fields_present; /* 09f8 27fa */
5408
5409 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5410 usr->ptr_logon_hrs = hrs ? 1 : 0;
5411
5412 if (nt_time_is_zero(pass_must_change_time)) {
5413 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5414 } else {
5415 usr->passmustchange=0;
5416 }
5417
5418 ZERO_STRUCT(usr->padding1);
5419 ZERO_STRUCT(usr->padding2);
5420
5421 usr->bad_password_count = bad_password_count;
5422 usr->logon_count = logon_count;
5423
5424 memcpy(usr->pass, newpass, sizeof(usr->pass));
5425
5426 copy_unistr2(&usr->uni_user_name, user_name);
5427 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5428
5429 copy_unistr2(&usr->uni_full_name, full_name);
5430 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5431
5432 copy_unistr2(&usr->uni_home_dir, home_dir);
5433 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5434
5435 copy_unistr2(&usr->uni_dir_drive, dir_drive);
5436 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5437
5438 copy_unistr2(&usr->uni_logon_script, log_scr);
5439 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5440
5441 copy_unistr2(&usr->uni_profile_path, prof_path);
5442 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5443
5444 copy_unistr2(&usr->uni_acct_desc, desc);
5445 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5446
5447 copy_unistr2(&usr->uni_workstations, wkstas);
5448 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5449
5450 copy_unistr2(&usr->uni_unknown_str, unk_str);
5451 init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
5452
5453 copy_unistr2(&usr->uni_munged_dial, mung_dial);
5454 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5455
5456 usr->unknown_6 = unknown_6; /* 0x0000 04ec */
5457 usr->padding4 = 0;
5458
5459 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5460 }
5461
5462 /*************************************************************************
5463 init_sam_user_info23
5464
5465 unknown_6 = 0x0000 04ec
5466
5467 *************************************************************************/
5468
5469 void init_sam_user_info23A(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5470 NTTIME * logoff_time, /* all zeros */
5471 NTTIME * kickoff_time, /* all zeros */
5472 NTTIME * pass_last_set_time, /* all zeros */
5473 NTTIME * pass_can_change_time, /* all zeros */
5474 NTTIME * pass_must_change_time, /* all zeros */
5475 char *user_name, /* NULL */
5476 char *full_name,
5477 char *home_dir, char *dir_drive, char *log_scr,
5478 char *prof_path, const char *desc, char *wkstas,
5479 char *unk_str, char *mung_dial, uint32 user_rid, /* 0x0000 0000 */
5480 uint32 group_rid, uint32 acb_info,
5481 uint32 fields_present, uint16 logon_divs,
5482 LOGON_HRS * hrs, uint16 bad_password_count, uint16 logon_count,
5483 char newpass[516], uint32 unknown_6)
5484 {
5485 DATA_BLOB blob = base64_decode_data_blob(mung_dial);
5486
5487 usr->logon_time = *logon_time; /* all zeros */
5488 usr->logoff_time = *logoff_time; /* all zeros */
5489 usr->kickoff_time = *kickoff_time; /* all zeros */
5490 usr->pass_last_set_time = *pass_last_set_time; /* all zeros */
5491 usr->pass_can_change_time = *pass_can_change_time; /* all zeros */
5492 usr->pass_must_change_time = *pass_must_change_time; /* all zeros */
5493
5494 ZERO_STRUCT(usr->nt_pwd);
5495 ZERO_STRUCT(usr->lm_pwd);
5496
5497 usr->user_rid = user_rid; /* 0x0000 0000 */
5498 usr->group_rid = group_rid;
5499 usr->acb_info = acb_info;
5500 usr->fields_present = fields_present; /* 09f8 27fa */
5501
5502 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5503 usr->ptr_logon_hrs = hrs ? 1 : 0;
5504
5505 if (nt_time_is_zero(pass_must_change_time)) {
5506 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5507 } else {
5508 usr->passmustchange=0;
5509 }
5510
5511 ZERO_STRUCT(usr->padding1);
5512 ZERO_STRUCT(usr->padding2);
5513
5514 usr->bad_password_count = bad_password_count;
5515 usr->logon_count = logon_count;
5516
5517 memcpy(usr->pass, newpass, sizeof(usr->pass));
5518
5519 init_unistr2(&usr->uni_user_name, user_name, UNI_FLAGS_NONE);
5520 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5521
5522 init_unistr2(&usr->uni_full_name, full_name, UNI_FLAGS_NONE);
5523 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5524
5525 init_unistr2(&usr->uni_home_dir, home_dir, UNI_FLAGS_NONE);
5526 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5527
5528 init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_FLAGS_NONE);
5529 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5530
5531 init_unistr2(&usr->uni_logon_script, log_scr, UNI_FLAGS_NONE);
5532 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5533
5534 init_unistr2(&usr->uni_profile_path, prof_path, UNI_FLAGS_NONE);
5535 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5536
5537 init_unistr2(&usr->uni_acct_desc, desc, UNI_FLAGS_NONE);
5538 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5539
5540 init_unistr2(&usr->uni_workstations, wkstas, UNI_FLAGS_NONE);
5541 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5542
5543 init_unistr2(&usr->uni_unknown_str, unk_str, UNI_FLAGS_NONE);
5544 init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
5545
5546 init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
5547 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5548
5549 data_blob_free(&blob);
5550
5551 usr->unknown_6 = unknown_6; /* 0x0000 04ec */
5552 usr->padding4 = 0;
5553
5554 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5555 }
5556
5557 /*******************************************************************
5558 reads or writes a structure.
5559 ********************************************************************/
5560
5561 static BOOL sam_io_user_info23(const char *desc, SAM_USER_INFO_23 * usr,
5562 prs_struct *ps, int depth)
5563 {
5564 if (usr == NULL)
5565 return False;
5566
5567 prs_debug(ps, depth, desc, "sam_io_user_info23");
5568 depth++;
5569
5570 if(!prs_align(ps))
5571 return False;
5572
5573 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
5574 return False;
5575 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
5576 return False;
5577 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
5578 return False;
5579 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps, depth))
5580 return False;
5581 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
5582 return False;
5583 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
5584 return False;
5585
5586 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
5587 return False;
5588 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
5589 return False;
5590 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
5591 return False;
5592 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
5593 return False;
5594 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
5595 return False;
5596 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
5597 return False;
5598 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
5599 return False;
5600 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
5601 return False;
5602 if(!smb_io_unihdr("hdr_unknown_str ", &usr->hdr_unknown_str, ps, depth)) /* unknown string */
5603 return False;
5604 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
5605 return False;
5606
5607 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
5608 return False;
5609 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
5610 return False;
5611
5612 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
5613 return False;
5614 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
5615 return False;
5616 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
5617 return False;
5618
5619 if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
5620 return False;
5621 if(!prs_uint16("logon_divs ", ps, depth, &usr->logon_divs)) /* logon divisions per week */
5622 return False;
5623 if(!prs_align(ps))
5624 return False;
5625 if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
5626 return False;
5627
5628 if(!prs_uint16("bad_password_count ", ps, depth, &usr->bad_password_count))
5629 return False;
5630 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count))
5631 return False;
5632
5633 if(!prs_uint8s(False, "padding1 ", ps, depth, usr->padding1, sizeof(usr->padding1)))
5634 return False;
5635 if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
5636 return False;
5637 if(!prs_uint8("padding2 ", ps, depth, &usr->padding2))
5638 return False;
5639
5640
5641 if(!prs_uint8s(False, "password ", ps, depth, usr->pass, sizeof(usr->pass)))
5642 return False;
5643
5644 /* here begins pointed-to data */
5645
5646 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
5647 return False;
5648
5649 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
5650 return False;
5651
5652 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
5653 return False;
5654
5655 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
5656 return False;
5657
5658 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
5659 return False;
5660
5661 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
5662 return False;
5663
5664 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth)) /* user desc unicode string */
5665 return False;
5666
5667 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth)) /* worksations user can log on from */
5668 return False;
5669
5670 if(!smb_io_unistr2("uni_unknown_str ", &usr->uni_unknown_str, usr->hdr_unknown_str.buffer, ps, depth)) /* unknown string */
5671 return False;
5672
5673 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
5674 return False;
5675
5676 /* ok, this is only guess-work (as usual) */
5677 if (usr->ptr_logon_hrs) {
5678 if(!prs_uint32("unknown_6 ", ps, depth, &usr->unknown_6))
5679 return False;
5680 if(!prs_uint32("padding4 ", ps, depth, &usr->padding4))
5681 return False;
5682 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
5683 return False;
5684 } else if (UNMARSHALLING(ps)) {
5685 usr->unknown_6 = 0;
5686 usr->padding4 = 0;
5687 }
5688
5689 return True;
5690 }
5691
5692 /*******************************************************************
5693 reads or writes a structure.
5694 NB. This structure is *definately* incorrect. It's my best guess
5695 currently for W2K SP2. The password field is encrypted in a different
5696 way than normal... And there are definately other problems. JRA.
5697 ********************************************************************/
5698
5699 static BOOL sam_io_user_info25(const char *desc, SAM_USER_INFO_25 * usr, prs_struct *ps, int depth)
5700 {
5701 if (usr == NULL)
5702 return False;
5703
5704 prs_debug(ps, depth, desc, "sam_io_user_info25");
5705 depth++;
5706
5707 if(!prs_align(ps))
5708 return False;
5709
5710 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
5711 return False;
5712 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
5713 return False;
5714 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
5715 return False;
5716 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps, depth))
5717 return False;
5718 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
5719 return False;
5720 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
5721 return False;
5722
5723 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
5724 return False;
5725 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
5726 return False;
5727 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
5728 return False;
5729 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
5730 return False;
5731 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
5732 return False;
5733 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
5734 return False;
5735 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
5736 return False;
5737 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
5738 return False;
5739 if(!smb_io_unihdr("hdr_unknown_str ", &usr->hdr_unknown_str, ps, depth)) /* unknown string */
5740 return False;
5741 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
5742 return False;
5743
5744 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
5745 return False;
5746 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
5747 return False;
5748
5749 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
5750 return False;
5751 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
5752 return False;
5753 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
5754 return False;
5755
5756 if(!prs_uint32s(False, "unknown_6 ", ps, depth, usr->unknown_6, 6))
5757 return False;
5758
5759 if(!prs_uint8s(False, "password ", ps, depth, usr->pass, sizeof(usr->pass)))
5760 return False;
5761
5762 /* here begins pointed-to data */
5763
5764 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
5765 return False;
5766
5767 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
5768 return False;
5769
5770 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
5771 return False;
5772
5773 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
5774 return False;
5775
5776 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
5777 return False;
5778
5779 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
5780 return False;
5781
5782 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth)) /* user desc unicode string */
5783 return False;
5784
5785 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth)) /* worksations user can log on from */
5786 return False;
5787
5788 if(!smb_io_unistr2("uni_unknown_str ", &usr->uni_unknown_str, usr->hdr_unknown_str.buffer, ps, depth)) /* unknown string */
5789 return False;
5790
5791 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
5792 return False;
5793
5794 #if 0 /* JRA - unknown... */
5795 /* ok, this is only guess-work (as usual) */
5796 if (usr->ptr_logon_hrs) {
5797 if(!prs_uint32("unknown_6 ", ps, depth, &usr->unknown_6))
5798 return False;
5799 if(!prs_uint32("padding4 ", ps, depth, &usr->padding4))
5800 return False;
5801 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
5802 return False;
5803 } else if (UNMARSHALLING(ps)) {
5804 usr->unknown_6 = 0;
5805 usr->padding4 = 0;
5806 }
5807 #endif
5808
5809 return True;
5810 }
5811
5812
5813 /*************************************************************************
5814 init_sam_user_info21W
5815
5816 unknown_6 = 0x0000 04ec
5817
5818 *************************************************************************/
5819
5820 void init_sam_user_info21W(SAM_USER_INFO_21 * usr,
5821 NTTIME * logon_time,
5822 NTTIME * logoff_time,
5823 NTTIME * kickoff_time,
5824 NTTIME * pass_last_set_time,
5825 NTTIME * pass_can_change_time,
5826 NTTIME * pass_must_change_time,
5827 UNISTR2 *user_name,
5828 UNISTR2 *full_name,
5829 UNISTR2 *home_dir,
5830 UNISTR2 *dir_drive,
5831 UNISTR2 *log_scr,
5832 UNISTR2 *prof_path,
5833 UNISTR2 *desc,
5834 UNISTR2 *wkstas,
5835 UNISTR2 *unk_str,
5836 UNISTR2 *mung_dial,
5837 uchar lm_pwd[16],
5838 uchar nt_pwd[16],
5839 uint32 user_rid,
5840 uint32 group_rid,
5841 uint32 acb_info,
5842 uint32 fields_present,
5843 uint16 logon_divs,
5844 LOGON_HRS * hrs,
5845 uint16 bad_password_count,
5846 uint16 logon_count,
5847 uint32 unknown_6)
5848 {
5849 usr->logon_time = *logon_time;
5850 usr->logoff_time = *logoff_time;
5851 usr->kickoff_time = *kickoff_time;
5852 usr->pass_last_set_time = *pass_last_set_time;
5853 usr->pass_can_change_time = *pass_can_change_time;
5854 usr->pass_must_change_time = *pass_must_change_time;
5855
5856 memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd));
5857 memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd));
5858
5859 usr->user_rid = user_rid;
5860 usr->group_rid = group_rid;
5861 usr->acb_info = acb_info;
5862 usr->fields_present = fields_present; /* 0x00ff ffff */
5863
5864 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5865 usr->ptr_logon_hrs = hrs ? 1 : 0;
5866 usr->bad_password_count = bad_password_count;
5867 usr->logon_count = logon_count;
5868
5869 if (nt_time_is_zero(pass_must_change_time)) {
5870 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5871 } else {
5872 usr->passmustchange=0;
5873 }
5874
5875 ZERO_STRUCT(usr->padding1);
5876 ZERO_STRUCT(usr->padding2);
5877
5878 copy_unistr2(&usr->uni_user_name, user_name);
5879 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5880
5881 copy_unistr2(&usr->uni_full_name, full_name);
5882 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5883
5884 copy_unistr2(&usr->uni_home_dir, home_dir);
5885 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5886
5887 copy_unistr2(&usr->uni_dir_drive, dir_drive);
5888 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5889
5890 copy_unistr2(&usr->uni_logon_script, log_scr);
5891 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5892
5893 copy_unistr2(&usr->uni_profile_path, prof_path);
5894 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5895
5896 copy_unistr2(&usr->uni_acct_desc, desc);
5897 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5898
5899 copy_unistr2(&usr->uni_workstations, wkstas);
5900 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5901
5902 copy_unistr2(&usr->uni_unknown_str, unk_str);
5903 init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
5904
5905 copy_unistr2(&usr->uni_munged_dial, mung_dial);
5906 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5907
5908 usr->unknown_6 = unknown_6; /* 0x0000 04ec */
5909 usr->padding4 = 0;
5910
5911 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5912 }
5913
5914 /*************************************************************************
5915 init_sam_user_info21
5916
5917 unknown_6 = 0x0000 04ec
5918
5919 *************************************************************************/
5920
5921 NTSTATUS init_sam_user_info21A(SAM_USER_INFO_21 *usr, SAM_ACCOUNT *pw, DOM_SID *domain_sid)
5922 {
5923 NTTIME logon_time, logoff_time, kickoff_time,
5924 pass_last_set_time, pass_can_change_time,
5925 pass_must_change_time;
5926
5927 const char* user_name = pdb_get_username(pw);
5928 const char* full_name = pdb_get_fullname(pw);
5929 const char* home_dir = pdb_get_homedir(pw);
5930 const char* dir_drive = pdb_get_dir_drive(pw);
5931 const char* logon_script = pdb_get_logon_script(pw);
5932 const char* profile_path = pdb_get_profile_path(pw);
5933 const char* description = pdb_get_acct_desc(pw);
5934 const char* workstations = pdb_get_workstations(pw);
5935 const char* munged_dial = pdb_get_munged_dial(pw);
5936 DATA_BLOB munged_dial_blob;
5937
5938 uint32 user_rid;
5939 const DOM_SID *user_sid;
5940
5941 uint32 group_rid;
5942 const DOM_SID *group_sid;
5943
5944 if (munged_dial) {
5945 munged_dial_blob = base64_decode_data_blob(munged_dial);
5946 } else {
5947 munged_dial_blob = data_blob(NULL, 0);
5948 }
5949
5950 /* Create NTTIME structs */
5951 unix_to_nt_time (&logon_time, pdb_get_logon_time(pw));
5952 unix_to_nt_time (&logoff_time, pdb_get_logoff_time(pw));
5953 unix_to_nt_time (&kickoff_time, pdb_get_kickoff_time(pw));
5954 unix_to_nt_time (&pass_last_set_time, pdb_get_pass_last_set_time(pw));
5955 unix_to_nt_time (&pass_can_change_time, pdb_get_pass_can_change_time(pw));
5956 unix_to_nt_time (&pass_must_change_time,pdb_get_pass_must_change_time(pw));
5957
5958 /* structure assignment */
5959 usr->logon_time = logon_time;
5960 usr->logoff_time = logoff_time;
5961 usr->kickoff_time = kickoff_time;
5962 usr->pass_last_set_time = pass_last_set_time;
5963 usr->pass_can_change_time = pass_can_change_time;
5964 usr->pass_must_change_time = pass_must_change_time;
5965
5966 ZERO_STRUCT(usr->nt_pwd);
5967 ZERO_STRUCT(usr->lm_pwd);
5968
5969 user_sid = pdb_get_user_sid(pw);
5970
5971 if (!sid_peek_check_rid(domain_sid, user_sid, &user_rid)) {
5972 fstring user_sid_string;
5973 fstring domain_sid_string;
5974 DEBUG(0, ("init_sam_user_info_21A: User %s has SID %s, \nwhich conflicts with "
5975 "the domain sid %s. Failing operation.\n",
5976 user_name,
5977 sid_to_string(user_sid_string, user_sid),
5978 sid_to_string(domain_sid_string, domain_sid)));
5979 data_blob_free(&munged_dial_blob);
5980 return NT_STATUS_UNSUCCESSFUL;
5981 }
5982
5983 group_sid = pdb_get_group_sid(pw);
5984
5985 if (!sid_peek_check_rid(domain_sid, group_sid, &group_rid)) {
5986 fstring group_sid_string;
5987 fstring domain_sid_string;
5988 DEBUG(0, ("init_sam_user_info_21A: User %s has Primary Group SID %s, \n"
5989 "which conflicts with the domain sid %s. Failing operation.\n",
5990 user_name,
5991 sid_to_string(group_sid_string, group_sid),
5992 sid_to_string(domain_sid_string, domain_sid)));
5993 data_blob_free(&munged_dial_blob);
5994 return NT_STATUS_UNSUCCESSFUL;
5995 }
5996
5997 usr->user_rid = user_rid;
5998 usr->group_rid = group_rid;
5999 usr->acb_info = pdb_get_acct_ctrl(pw);
6000
6001 /*
6002 Look at a user on a real NT4 PDC with usrmgr, press
6003 'ok'. Then you will see that fields_present is set to
6004 0x08f827fa. Look at the user immediately after that again,
6005 and you will see that 0x00fffff is returned. This solves
6006 the problem that you get access denied after having looked
6007 at the user.
6008 -- Volker
6009 */
6010 usr->fields_present = pdb_build_fields_present(pw);
6011
6012 usr->logon_divs = pdb_get_logon_divs(pw);
6013 usr->ptr_logon_hrs = pdb_get_hours(pw) ? 1 : 0;
6014 usr->bad_password_count = pdb_get_bad_password_count(pw);
6015 usr->logon_count = pdb_get_logon_count(pw);
6016
6017 if (pdb_get_pass_must_change_time(pw) == 0) {
6018 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6019 } else {
6020 usr->passmustchange=0;
6021 }
6022
6023 ZERO_STRUCT(usr->padding1);
6024 ZERO_STRUCT(usr->padding2);
6025
6026 init_unistr2(&usr->uni_user_name, user_name, UNI_STR_TERMINATE);
6027 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6028
6029 init_unistr2(&usr->uni_full_name, full_name, UNI_STR_TERMINATE);
6030 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6031
6032 init_unistr2(&usr->uni_home_dir, home_dir, UNI_STR_TERMINATE);
6033 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6034
6035 init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_STR_TERMINATE);
6036 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6037
6038 init_unistr2(&usr->uni_logon_script, logon_script, UNI_STR_TERMINATE);
6039 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6040
6041 init_unistr2(&usr->uni_profile_path, profile_path, UNI_STR_TERMINATE);
6042 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6043
6044 init_unistr2(&usr->uni_acct_desc, description, UNI_STR_TERMINATE);
6045 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6046
6047 init_unistr2(&usr->uni_workstations, workstations, UNI_STR_TERMINATE);
6048 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6049
6050 init_unistr2(&usr->uni_unknown_str, NULL, UNI_STR_TERMINATE);
6051 init_uni_hdr(&usr->hdr_unknown_str, &usr->uni_unknown_str);
6052
6053 init_unistr2_from_datablob(&usr->uni_munged_dial, &munged_dial_blob);
6054 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6055 data_blob_free(&munged_dial_blob);
6056
6057 usr->unknown_6 = pdb_get_unknown_6(pw);
6058 usr->padding4 = 0;
6059
6060 if (pdb_get_hours(pw)) {
6061 usr->logon_hrs.len = pdb_get_hours_len(pw);
6062 memcpy(&usr->logon_hrs.hours, pdb_get_hours(pw), MAX_HOURS_LEN);
6063 } else
6064 memset(&usr->logon_hrs, 0xff, sizeof(usr->logon_hrs));
6065
6066 return NT_STATUS_OK;
6067 }
6068
6069 /*******************************************************************
6070 reads or writes a structure.
6071 ********************************************************************/
6072
6073 static BOOL sam_io_user_info21(const char *desc, SAM_USER_INFO_21 * usr,
6074 prs_struct *ps, int depth)
6075 {
6076 if (usr == NULL)
6077 return False;
6078
6079 prs_debug(ps, depth, desc, "sam_io_user_info21");
6080 depth++;
6081
6082 if(!prs_align(ps))
6083 return False;
6084
6085 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
6086 return False;
6087 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
6088 return False;
6089 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps,depth))
6090 return False;
6091 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
6092 return False;
6093 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps,depth))
6094 return False;
6095 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
6096 return False;
6097
6098 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
6099 return False;
6100 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
6101 return False;
6102 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
6103 return False;
6104 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
6105 return False;
6106 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
6107 return False;
6108 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
6109 return False;
6110 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
6111 return False;
6112 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
6113 return False;
6114 if(!smb_io_unihdr("hdr_unknown_str ", &usr->hdr_unknown_str, ps, depth)) /* unknown string */
6115 return False;
6116 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6117 return False;
6118
6119 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6120 return False;
6121 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6122 return False;
6123
6124 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
6125 return False;
6126 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
6127 return False;
6128 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
6129 return False;
6130
6131 if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6132 return False;
6133 if(!prs_uint16("logon_divs ", ps, depth, &usr->logon_divs)) /* logon divisions per week */
6134 return False;
6135 if(!prs_align(ps))
6136 return False;
6137 if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
6138 return False;
6139
6140 if(!prs_uint16("bad_password_count ", ps, depth, &usr->bad_password_count))
6141 return False;
6142 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count))
6143 return False;
6144
6145 if(!prs_uint8s(False, "padding1 ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6146 return False;
6147 if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6148 return False;
6149 if(!prs_uint8("padding2 ", ps, depth, &usr->padding2))
6150 return False;
6151
6152 /* here begins pointed-to data */
6153
6154 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name,usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
6155 return False;
6156 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
6157 return False;
6158 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
6159 return False;
6160 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
6161 return False;
6162 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
6163 return False;
6164 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
6165 return False;
6166 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth)) /* user desc unicode string */
6167 return False;
6168 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth)) /* worksations user can log on from */
6169 return False;
6170 if(!smb_io_unistr2("uni_unknown_str ", &usr->uni_unknown_str, usr->hdr_unknown_str.buffer, ps, depth)) /* unknown string */
6171 return False;
6172 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth)) /* worksations user can log on from */
6173 return False;
6174
6175 /* ok, this is only guess-work (as usual) */
6176 if (usr->ptr_logon_hrs) {
6177 if(!prs_align(ps))
6178 return False;
6179 if(!prs_uint32("unknown_6 ", ps, depth, &usr->unknown_6))
6180 return False;
6181 if(!prs_uint32("padding4 ", ps, depth, &usr->padding4))
6182 return False;
6183 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6184 return False;
6185 } else if (UNMARSHALLING(ps)) {
6186 usr->unknown_6 = 0;
6187 usr->padding4 = 0;
6188 }
6189
6190 return True;
6191 }
6192
6193 void init_sam_user_info20A(SAM_USER_INFO_20 *usr, SAM_ACCOUNT *pw)
6194 {
6195 const char *munged_dial = pdb_get_munged_dial(pw);
6196 DATA_BLOB blob = base64_decode_data_blob(munged_dial);
6197
6198 init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
6199 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6200 data_blob_free(&blob);
6201 }
6202
6203 /*******************************************************************
6204 reads or writes a structure.
6205 ********************************************************************/
6206
6207 static BOOL sam_io_user_info20(const char *desc, SAM_USER_INFO_20 *usr,
6208 prs_struct *ps, int depth)
6209 {
6210 if (usr == NULL)
6211 return False;
6212
6213 prs_debug(ps, depth, desc, "sam_io_user_info20");
6214 depth++;
6215
6216 if(!prs_align(ps))
6217 return False;
6218
6219 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6220 return False;
6221
6222 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth)) /* worksations user can log on from */
6223 return False;
6224
6225 return True;
6226 }
6227
6228 /*******************************************************************
6229 inits a SAM_USERINFO_CTR structure.
6230 ********************************************************************/
6231
6232 NTSTATUS make_samr_userinfo_ctr_usr21(TALLOC_CTX *ctx, SAM_USERINFO_CTR * ctr,
6233 uint16 switch_value,
6234 SAM_USER_INFO_21 * usr)
6235 {
6236 DEBUG(5, ("init_samr_userinfo_ctr\n"));
6237
6238 ctr->switch_value = switch_value;
6239 ctr->info.id = NULL;
6240
6241 switch (switch_value) {
6242 case 0x10:
6243 ctr->info.id10 = (SAM_USER_INFO_10 *)talloc_zero(ctx,sizeof(SAM_USER_INFO_10));
6244 if (ctr->info.id10 == NULL)
6245 return NT_STATUS_NO_MEMORY;
6246
6247 init_sam_user_info10(ctr->info.id10, usr->acb_info);
6248 break;
6249 #if 0
6250 /* whoops - got this wrong. i think. or don't understand what's happening. */
6251 case 0x11:
6252 {
6253 NTTIME expire;
6254 info = (void *)&id11;
6255
6256 expire.low = 0xffffffff;
6257 expire.high = 0x7fffffff;
6258
6259 ctr->info.id = (SAM_USER_INFO_11 *) talloc_zero(ctx,sizeof(*ctr->info.id11));
6260 init_sam_user_info11(ctr->info.id11, &expire,
6261 "BROOKFIELDS$", /* name */
6262 0x03ef, /* user rid */
6263 0x201, /* group rid */
6264 0x0080); /* acb info */
6265
6266 break;
6267 }
6268 #endif
6269 case 0x12:
6270 ctr->info.id12 = (SAM_USER_INFO_12 *)talloc_zero(ctx,sizeof(SAM_USER_INFO_12));
6271 if (ctr->info.id12 == NULL)
6272 return NT_STATUS_NO_MEMORY;
6273
6274 init_sam_user_info12(ctr->info.id12, usr->lm_pwd, usr->nt_pwd);
6275 break;
6276 case 21:
6277 {
6278 SAM_USER_INFO_21 *cusr;
6279 cusr = (SAM_USER_INFO_21 *)talloc_zero(ctx,sizeof(SAM_USER_INFO_21));
6280 ctr->info.id21 = cusr;
6281 if (ctr->info.id21 == NULL)
6282 return NT_STATUS_NO_MEMORY;
6283 memcpy(cusr, usr, sizeof(*usr));
6284 memset(cusr->lm_pwd, 0, sizeof(cusr->lm_pwd));
6285 memset(cusr->nt_pwd, 0, sizeof(cusr->nt_pwd));
6286 break;
6287 }
6288 default:
6289 DEBUG(4,("make_samr_userinfo_ctr: unsupported info\n"));
6290 return NT_STATUS_INVALID_INFO_CLASS;
6291 }
6292
6293 return NT_STATUS_OK;
6294 }
6295
6296 /*******************************************************************
6297 inits a SAM_USERINFO_CTR structure.
6298 ********************************************************************/
6299
6300 static void init_samr_userinfo_ctr(SAM_USERINFO_CTR * ctr, DATA_BLOB *sess_key,
6301 uint16 switch_value, void *info)
6302 {
6303 DEBUG(5, ("init_samr_userinfo_ctr\n"));
6304
6305 ctr->switch_value = switch_value;
6306 ctr->info.id = info;
6307
6308 switch (switch_value) {
6309 case 0x18:
6310 SamOEMhashBlob(ctr->info.id24->pass, 516, sess_key);
6311 dump_data(100, (char *)sess_key->data, sess_key->length);
6312 dump_data(100, (char *)ctr->info.id24->pass, 516);
6313 break;
6314 case 0x17:
6315 SamOEMhashBlob(ctr->info.id23->pass, 516, sess_key);
6316 dump_data(100, (char *)sess_key->data, sess_key->length);
6317 dump_data(100, (char *)ctr->info.id23->pass, 516);
6318 break;
6319 default:
6320 DEBUG(4,("init_samr_userinfo_ctr: unsupported switch level\n"));
6321 }
6322 }
6323
6324 /*******************************************************************
6325 reads or writes a structure.
6326 ********************************************************************/
6327
6328 static BOOL samr_io_userinfo_ctr(const char *desc, SAM_USERINFO_CTR **ppctr,
6329 prs_struct *ps, int depth)
6330 {
6331 BOOL ret;
6332 SAM_USERINFO_CTR *ctr;
6333
6334 prs_debug(ps, depth, desc, "samr_io_userinfo_ctr");
6335 depth++;
6336
6337 if (UNMARSHALLING(ps)) {
6338 ctr = (SAM_USERINFO_CTR *)prs_alloc_mem(ps,sizeof(SAM_USERINFO_CTR));
6339 if (ctr == NULL)
6340 return False;
6341 *ppctr = ctr;
6342 } else {
6343 ctr = *ppctr;
6344 }
6345
6346 /* lkclXXXX DO NOT ALIGN BEFORE READING SWITCH VALUE! */
6347
6348 if(!prs_uint16("switch_value", ps, depth, &ctr->switch_value))
6349 return False;
6350 if(!prs_align(ps))
6351 return False;
6352
6353 ret = False;
6354
6355 switch (ctr->switch_value) {
6356 case 0x10:
6357 if (UNMARSHALLING(ps))
6358 ctr->info.id10 = (SAM_USER_INFO_10 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_10));
6359 if (ctr->info.id10 == NULL) {
6360 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6361 return False;
6362 }
6363 ret = sam_io_user_info10("", ctr->info.id10, ps, depth);
6364 break;
6365 case 0x11:
6366 if (UNMARSHALLING(ps))
6367 ctr->info.id11 = (SAM_USER_INFO_11 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_11));
6368
6369 if (ctr->info.id11 == NULL) {
6370 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6371 return False;
6372 }
6373 ret = sam_io_user_info11("", ctr->info.id11, ps, depth);
6374 break;
6375 case 0x12:
6376 if (UNMARSHALLING(ps))
6377 ctr->info.id12 = (SAM_USER_INFO_12 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_12));
6378
6379 if (ctr->info.id12 == NULL) {
6380 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6381 return False;
6382 }
6383 ret = sam_io_user_info12("", ctr->info.id12, ps, depth);
6384 break;
6385 case 20:
6386 if (UNMARSHALLING(ps))
6387 ctr->info.id20 = (SAM_USER_INFO_20 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_20));
6388
6389 if (ctr->info.id20 == NULL) {
6390 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6391 return False;
6392 }
6393 ret = sam_io_user_info20("", ctr->info.id20, ps, depth);
6394 break;
6395 case 21:
6396 if (UNMARSHALLING(ps))
6397 ctr->info.id21 = (SAM_USER_INFO_21 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_21));
6398
6399 if (ctr->info.id21 == NULL) {
6400 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6401 return False;
6402 }
6403 ret = sam_io_user_info21("", ctr->info.id21, ps, depth);
6404 break;
6405 case 23:
6406 if (UNMARSHALLING(ps))
6407 ctr->info.id23 = (SAM_USER_INFO_23 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_23));
6408
6409 if (ctr->info.id23 == NULL) {
6410 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6411 return False;
6412 }
6413 ret = sam_io_user_info23("", ctr->info.id23, ps, depth);
6414 break;
6415 case 24:
6416 if (UNMARSHALLING(ps))
6417 ctr->info.id24 = (SAM_USER_INFO_24 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_24));
6418
6419 if (ctr->info.id24 == NULL) {
6420 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6421 return False;
6422 }
6423 ret = sam_io_user_info24("", ctr->info.id24, ps, depth);
6424 break;
6425 case 25:
6426 if (UNMARSHALLING(ps))
6427 ctr->info.id25 = (SAM_USER_INFO_25 *)prs_alloc_mem(ps,sizeof(SAM_USER_INFO_25));
6428
6429 if (ctr->info.id25 == NULL) {
6430 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6431 return False;
6432 }
6433 ret = sam_io_user_info25("", ctr->info.id25, ps, depth);
6434 break;
6435 default:
6436 DEBUG(2, ("samr_io_userinfo_ctr: unknown switch level 0x%x\n", ctr->switch_value));
6437 ret = False;
6438 break;
6439 }
6440
6441 return ret;
6442 }
6443
6444 /*******************************************************************
6445 inits a SAMR_R_QUERY_USERINFO structure.
6446 ********************************************************************/
6447
6448 void init_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO * r_u,
6449 SAM_USERINFO_CTR * ctr, NTSTATUS status)
6450 {
6451 DEBUG(5, ("init_samr_r_query_userinfo\n"));
6452
6453 r_u->ptr = 0;
6454 r_u->ctr = NULL;
6455
6456 if (NT_STATUS_IS_OK(status)) {
6457 r_u->ptr = 1;
6458 r_u->ctr = ctr;
6459 }
6460
6461 r_u->status = status; /* return status */
6462 }
6463
6464 /*******************************************************************
6465 reads or writes a structure.
6466 ********************************************************************/
6467
6468 BOOL samr_io_r_query_userinfo(const char *desc, SAMR_R_QUERY_USERINFO * r_u,
6469 prs_struct *ps, int depth)
6470 {
6471 if (r_u == NULL)
6472 return False;
6473
6474 prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
6475 depth++;
6476
6477 if(!prs_align(ps))
6478 return False;
6479
6480 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
6481 return False;
6482
6483 if (r_u->ptr != 0) {
6484 if(!samr_io_userinfo_ctr("ctr", &r_u->ctr, ps, depth))
6485 return False;
6486 }
6487
6488 if(!prs_align(ps))
6489 return False;
6490 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6491 return False;
6492
6493 return True;
6494 }
6495
6496 /*******************************************************************
6497 inits a SAMR_Q_SET_USERINFO structure.
6498 ********************************************************************/
6499
6500 void init_samr_q_set_userinfo(SAMR_Q_SET_USERINFO * q_u,
6501 POLICY_HND *hnd, DATA_BLOB *sess_key,
6502 uint16 switch_value, void *info)
6503 {
6504 DEBUG(5, ("init_samr_q_set_userinfo\n"));
6505
6506 q_u->pol = *hnd;
6507 q_u->switch_value = switch_value;
6508 init_samr_userinfo_ctr(q_u->ctr, sess_key, switch_value, info);
6509 }
6510
6511 /*******************************************************************
6512 reads or writes a structure.
6513 ********************************************************************/
6514
6515 BOOL samr_io_q_set_userinfo(const char *desc, SAMR_Q_SET_USERINFO * q_u,
6516 prs_struct *ps, int depth)
6517 {
6518 if (q_u == NULL)
6519 return False;
6520
6521 prs_debug(ps, depth, desc, "samr_io_q_set_userinfo");
6522 depth++;
6523
6524 if(!prs_align(ps))
6525 return False;
6526
6527 smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
6528
6529 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6530 return False;
6531 if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6532 return False;
6533
6534 return True;
6535 }
6536
6537 /*******************************************************************
6538 inits a SAMR_R_SET_USERINFO structure.
6539 ********************************************************************/
6540
6541 void init_samr_r_set_userinfo(SAMR_R_SET_USERINFO * r_u, NTSTATUS status)
6542 {
6543 DEBUG(5, ("init_samr_r_set_userinfo\n"));
6544
6545 r_u->status = status; /* return status */
6546 }
6547
6548 /*******************************************************************
6549 reads or writes a structure.
6550 ********************************************************************/
6551
6552 BOOL samr_io_r_set_userinfo(const char *desc, SAMR_R_SET_USERINFO * r_u,
6553 prs_struct *ps, int depth)
6554 {
6555 if (r_u == NULL)
6556 return False;
6557
6558 prs_debug(ps, depth, desc, "samr_io_r_set_userinfo");
6559 depth++;
6560
6561 if(!prs_align(ps))
6562 return False;
6563
6564 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6565 return False;
6566
6567 return True;
6568 }
6569
6570 /*******************************************************************
6571 inits a SAMR_Q_SET_USERINFO2 structure.
6572 ********************************************************************/
6573
6574 void init_samr_q_set_userinfo2(SAMR_Q_SET_USERINFO2 * q_u,
6575 POLICY_HND *hnd, DATA_BLOB *sess_key,
6576 uint16 switch_value, SAM_USERINFO_CTR * ctr)
6577 {
6578 DEBUG(5, ("init_samr_q_set_userinfo2\n"));
6579
6580 q_u->pol = *hnd;
6581 q_u->switch_value = switch_value;
6582 q_u->ctr = ctr;
6583
6584 if (q_u->ctr != NULL)
6585 q_u->ctr->switch_value = switch_value;
6586
6587 switch (switch_value) {
6588 case 0x12:
6589 SamOEMhashBlob(ctr->info.id12->lm_pwd, 16, sess_key);
6590 SamOEMhashBlob(ctr->info.id12->nt_pwd, 16, sess_key);
6591 dump_data(100, (char *)sess_key->data, sess_key->length);
6592 dump_data(100, (char *)ctr->info.id12->lm_pwd, 16);
6593 dump_data(100, (char *)ctr->info.id12->nt_pwd, 16);
6594 break;
6595 }
6596 }
6597
6598 /*******************************************************************
6599 reads or writes a structure.
6600 ********************************************************************/
6601
6602 BOOL samr_io_q_set_userinfo2(const char *desc, SAMR_Q_SET_USERINFO2 * q_u,
6603 prs_struct *ps, int depth)
6604 {
6605 if (q_u == NULL)
6606 return False;
6607
6608 prs_debug(ps, depth, desc, "samr_io_q_set_userinfo2");
6609 depth++;
6610
6611 if(!prs_align(ps))
6612 return False;
6613
6614 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
6615 return False;
6616
6617 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6618 return False;
6619 if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6620 return False;
6621
6622 return True;
6623 }
6624
6625 /*******************************************************************
6626 inits a SAMR_R_SET_USERINFO2 structure.
6627 ********************************************************************/
6628
6629 void init_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2 * r_u, NTSTATUS status)
6630 {
6631 DEBUG(5, ("init_samr_r_set_userinfo2\n"));
6632
6633 r_u->status = status; /* return status */
6634 }
6635
6636 /*******************************************************************
6637 reads or writes a structure.
6638 ********************************************************************/
6639
6640 BOOL samr_io_r_set_userinfo2(const char *desc, SAMR_R_SET_USERINFO2 * r_u,
6641 prs_struct *ps, int depth)
6642 {
6643 if (r_u == NULL)
6644 return False;
6645
6646 prs_debug(ps, depth, desc, "samr_io_r_set_userinfo2");
6647 depth++;
6648
6649 if(!prs_align(ps))
6650 return False;
6651
6652 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6653 return False;
6654
6655 return True;
6656 }
6657
6658 /*******************************************************************
6659 inits a SAMR_Q_CONNECT structure.
6660 ********************************************************************/
6661
6662 void init_samr_q_connect(SAMR_Q_CONNECT * q_u,
6663 char *srv_name, uint32 access_mask)
6664 {
6665 DEBUG(5, ("init_samr_q_connect\n"));
6666
6667 /* make PDC server name \\server */
6668 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
6669 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
6670
6671 /* example values: 0x0000 0002 */
6672 q_u->access_mask = access_mask;
6673 }
6674
6675 /*******************************************************************
6676 reads or writes a structure.
6677 ********************************************************************/
6678
6679 BOOL samr_io_q_connect(const char *desc, SAMR_Q_CONNECT * q_u,
6680 prs_struct *ps, int depth)
6681 {
6682 if (q_u == NULL)
6683 return False;
6684
6685 prs_debug(ps, depth, desc, "samr_io_q_connect");
6686 depth++;
6687
6688 if(!prs_align(ps))
6689 return False;
6690
6691 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
6692 return False;
6693 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
6694 return False;
6695
6696 if(!prs_align(ps))
6697 return False;
6698 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6699 return False;
6700
6701 return True;
6702 }
6703
6704 /*******************************************************************
6705 reads or writes a structure.
6706 ********************************************************************/
6707
6708 BOOL samr_io_r_connect(const char *desc, SAMR_R_CONNECT * r_u,
6709 prs_struct *ps, int depth)
6710 {
6711 if (r_u == NULL)
6712 return False;
6713
6714 prs_debug(ps, depth, desc, "samr_io_r_connect");
6715 depth++;
6716
6717 if(!prs_align(ps))
6718 return False;
6719
6720 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6721 return False;
6722
6723 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6724 return False;
6725
6726 return True;
6727 }
6728
6729 /*******************************************************************
6730 inits a SAMR_Q_CONNECT4 structure.
6731 ********************************************************************/
6732
6733 void init_samr_q_connect4(SAMR_Q_CONNECT4 * q_u,
6734 char *srv_name, uint32 access_mask)
6735 {
6736 DEBUG(5, ("init_samr_q_connect\n"));
6737
6738 /* make PDC server name \\server */
6739 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
6740 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
6741
6742 /* Only value we've seen, possibly an address type ? */
6743 q_u->unk_0 = 2;
6744
6745 /* example values: 0x0000 0002 */
6746 q_u->access_mask = access_mask;
6747 }
6748
6749 /*******************************************************************
6750 reads or writes a structure.
6751 ********************************************************************/
6752
6753 BOOL samr_io_q_connect4(const char *desc, SAMR_Q_CONNECT4 * q_u,
6754 prs_struct *ps, int depth)
6755 {
6756 if (q_u == NULL)
6757 return False;
6758
6759 prs_debug(ps, depth, desc, "samr_io_q_connect4");
6760 depth++;
6761
6762 if(!prs_align(ps))
6763 return False;
6764
6765 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
6766 return False;
6767 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
6768 return False;
6769
6770 if(!prs_align(ps))
6771 return False;
6772 if(!prs_uint32("unk_0", ps, depth, &q_u->unk_0))
6773 return False;
6774 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6775 return False;
6776
6777 return True;
6778 }
6779
6780 /*******************************************************************
6781 reads or writes a structure.
6782 ********************************************************************/
6783
6784 BOOL samr_io_r_connect4(const char *desc, SAMR_R_CONNECT4 * r_u,
6785 prs_struct *ps, int depth)
6786 {
6787 if (r_u == NULL)
6788 return False;
6789
6790 prs_debug(ps, depth, desc, "samr_io_r_connect4");
6791 depth++;
6792
6793 if(!prs_align(ps))
6794 return False;
6795
6796 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6797 return False;
6798
6799 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6800 return False;
6801
6802 return True;
6803 }
6804
6805 /*******************************************************************
6806 inits a SAMR_Q_CONNECT_ANON structure.
6807 ********************************************************************/
6808
6809 void init_samr_q_connect_anon(SAMR_Q_CONNECT_ANON * q_u)
6810 {
6811 DEBUG(5, ("init_samr_q_connect_anon\n"));
6812
6813 q_u->ptr = 1;
6814 q_u->unknown_0 = 0x5c; /* server name (?!!) */
6815 q_u->unknown_1 = 0x01;
6816 q_u->access_mask = 0x20;
6817 }
6818
6819 /*******************************************************************
6820 reads or writes a structure.
6821 ********************************************************************/
6822
6823 BOOL samr_io_q_connect_anon(const char *desc, SAMR_Q_CONNECT_ANON * q_u,
6824 prs_struct *ps, int depth)
6825 {
6826 if (q_u == NULL)
6827 return False;
6828
6829 prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
6830 depth++;
6831
6832 if(!prs_align(ps))
6833 return False;
6834
6835 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
6836 return False;
6837 if(!prs_uint16("unknown_0", ps, depth, &q_u->unknown_0))
6838 return False;
6839 if(!prs_uint16("unknown_1", ps, depth, &q_u->unknown_1))
6840 return False;
6841 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
6842 return False;
6843
6844 return True;
6845 }
6846
6847 /*******************************************************************
6848 reads or writes a structure.
6849 ********************************************************************/
6850
6851 BOOL samr_io_r_connect_anon(const char *desc, SAMR_R_CONNECT_ANON * r_u,
6852 prs_struct *ps, int depth)
6853 {
6854 if (r_u == NULL)
6855 return False;
6856
6857 prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
6858 depth++;
6859
6860 if(!prs_align(ps))
6861 return False;
6862
6863 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
6864 return False;
6865
6866 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6867 return False;
6868
6869 return True;
6870 }
6871
6872 /*******************************************************************
6873 inits a SAMR_Q_GET_DOM_PWINFO structure.
6874 ********************************************************************/
6875
6876 void init_samr_q_get_dom_pwinfo(SAMR_Q_GET_DOM_PWINFO * q_u,
6877 char *srv_name)
6878 {
6879 DEBUG(5, ("init_samr_q_get_dom_pwinfo\n"));
6880
6881 q_u->ptr = 1;
6882 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_FLAGS_NONE);
6883 init_uni_hdr(&q_u->hdr_srv_name, &q_u->uni_srv_name);
6884 }
6885
6886 /*******************************************************************
6887 reads or writes a structure.
6888 ********************************************************************/
6889
6890 BOOL samr_io_q_get_dom_pwinfo(const char *desc, SAMR_Q_GET_DOM_PWINFO * q_u,
6891 prs_struct *ps, int depth)
6892 {
6893 if (q_u == NULL)
6894 return False;
6895
6896 prs_debug(ps, depth, desc, "samr_io_q_get_dom_pwinfo");
6897 depth++;
6898
6899 if(!prs_align(ps))
6900 return False;
6901
6902 if(!prs_uint32("ptr", ps, depth, &q_u->ptr))
6903 return False;
6904 if (q_u->ptr != 0) {
6905 if(!smb_io_unihdr("", &q_u->hdr_srv_name, ps, depth))
6906 return False;
6907 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->hdr_srv_name.buffer, ps, depth))
6908 return False;
6909 }
6910
6911 return True;
6912 }
6913
6914 /*******************************************************************
6915 reads or writes a structure.
6916 ********************************************************************/
6917
6918 BOOL samr_io_r_get_dom_pwinfo(const char *desc, SAMR_R_GET_DOM_PWINFO * r_u,
6919 prs_struct *ps, int depth)
6920 {
6921 if (r_u == NULL)
6922 return False;
6923
6924 prs_debug(ps, depth, desc, "samr_io_r_get_dom_pwinfo");
6925 depth++;
6926
6927 if(!prs_align(ps))
6928 return False;
6929
6930 /*
6931 * We need 16 bytes here according to tests. Don't know
6932 * what they are, but the length is important for the singing
6933 */
6934
6935 if(!prs_uint32("unk_0", ps, depth, &r_u->unk_0))
6936 return False;
6937 if(!prs_uint32("unk_1", ps, depth, &r_u->unk_1))
6938 return False;
6939 if(!prs_uint32("unk_2", ps, depth, &r_u->unk_2))
6940 return False;
6941
6942 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6943 return False;
6944
6945 return True;
6946 }
6947
6948 /*******************************************************************
6949 make a SAMR_ENC_PASSWD structure.
6950 ********************************************************************/
6951
6952 void init_enc_passwd(SAMR_ENC_PASSWD * pwd, const char pass[512])
6953 {
6954 ZERO_STRUCTP(pwd);
6955
6956 if (pass == NULL) {
6957 pwd->ptr = 0;
6958 } else {
6959 pwd->ptr = 1;
6960 memcpy(pwd->pass, pass, sizeof(pwd->pass));
6961 }
6962 }
6963
6964 /*******************************************************************
6965 reads or writes a SAMR_ENC_PASSWD structure.
6966 ********************************************************************/
6967
6968 BOOL samr_io_enc_passwd(const char *desc, SAMR_ENC_PASSWD * pwd,
6969 prs_struct *ps, int depth)
6970 {
6971 if (pwd == NULL)
6972 return False;
6973
6974 prs_debug(ps, depth, desc, "samr_io_enc_passwd");
6975 depth++;
6976
6977 if(!prs_align(ps))
6978 return False;
6979
6980 if(!prs_uint32("ptr", ps, depth, &pwd->ptr))
6981 return False;
6982
6983 if (pwd->ptr != 0) {
6984 if(!prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass)))
6985 return False;
6986 }
6987
6988 return True;
6989 }
6990
6991 /*******************************************************************
6992 inits a SAMR_ENC_HASH structure.
6993 ********************************************************************/
6994
6995 void init_enc_hash(SAMR_ENC_HASH * hsh, const uchar hash[16])
6996 {
6997 ZERO_STRUCTP(hsh);
6998
6999 if (hash == NULL) {
7000 hsh->ptr = 0;
7001 } else {
7002 hsh->ptr = 1;
7003 memcpy(hsh->hash, hash, sizeof(hsh->hash));
7004 }
7005 }
7006
7007 /*******************************************************************
7008 reads or writes a SAMR_ENC_HASH structure.
7009 ********************************************************************/
7010
7011 BOOL samr_io_enc_hash(const char *desc, SAMR_ENC_HASH * hsh,
7012 prs_struct *ps, int depth)
7013 {
7014 if (hsh == NULL)
7015 return False;
7016
7017 prs_debug(ps, depth, desc, "samr_io_enc_hash");
7018 depth++;
7019
7020 if(!prs_align(ps))
7021 return False;
7022
7023 if(!prs_uint32("ptr ", ps, depth, &hsh->ptr))
7024 return False;
7025 if (hsh->ptr != 0) {
7026 if(!prs_uint8s(False, "hash", ps, depth, hsh->hash,sizeof(hsh->hash)))
7027 return False;
7028 }
7029
7030 return True;
7031 }
7032
7033 /*******************************************************************
7034 inits a SAMR_R_GET_DOM_PWINFO structure.
7035 ********************************************************************/
7036
7037 void init_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER * q_u,
7038 const char *dest_host, const char *user_name,
7039 const char nt_newpass[516],
7040 const uchar nt_oldhash[16],
7041 const char lm_newpass[516],
7042 const uchar lm_oldhash[16])
7043 {
7044 DEBUG(5, ("init_samr_q_chgpasswd_user\n"));
7045
7046 q_u->ptr_0 = 1;
7047 init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7048 init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7049
7050 init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7051 init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7052
7053 init_enc_passwd(&q_u->nt_newpass, nt_newpass);
7054 init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7055
7056 q_u->unknown = 0x01;
7057
7058 init_enc_passwd(&q_u->lm_newpass, lm_newpass);
7059 init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7060 }
7061
7062 /*******************************************************************
7063 reads or writes a structure.
7064 ********************************************************************/
7065
7066 BOOL samr_io_q_chgpasswd_user(const char *desc, SAMR_Q_CHGPASSWD_USER * q_u,
7067 prs_struct *ps, int depth)
7068 {
7069 if (q_u == NULL)
7070 return False;
7071
7072 prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
7073 depth++;
7074
7075 if(!prs_align(ps))
7076 return False;
7077
7078 if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7079 return False;
7080
7081 if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7082 return False;
7083 if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7084 return False;
7085
7086 if(!prs_align(ps))
7087 return False;
7088 if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7089 return False;
7090 if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7091 return False;
7092
7093 if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7094 return False;
7095 if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7096 return False;
7097
7098 if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
7099 return False;
7100
7101 if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7102 return False;
7103 if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7104 return False;
7105
7106 return True;
7107 }
7108
7109 /*******************************************************************
7110 inits a SAMR_R_CHGPASSWD_USER structure.
7111 ********************************************************************/
7112
7113 void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER * r_u, NTSTATUS status)
7114 {
7115 DEBUG(5, ("init_r_chgpasswd_user\n"));
7116
7117 r_u->status = status;
7118 }
7119
7120 /*******************************************************************
7121 reads or writes a structure.
7122 ********************************************************************/
7123
7124 BOOL samr_io_r_chgpasswd_user(const char *desc, SAMR_R_CHGPASSWD_USER * r_u,
7125 prs_struct *ps, int depth)
7126 {
7127 if (r_u == NULL)
7128 return False;
7129
7130 prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
7131 depth++;
7132
7133 if(!prs_align(ps))
7134 return False;
7135
7136 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7137 return False;
7138
7139 return True;
7140 }
7141
7142 /*******************************************************************
7143 reads or writes a structure.
7144 ********************************************************************/
7145
7146 void init_samr_q_unknown_2e(SAMR_Q_UNKNOWN_2E *q_u,
7147 POLICY_HND *domain_pol, uint16 switch_value)
7148 {
7149 DEBUG(5, ("init_samr_q_unknown_2e\n"));
7150
7151 q_u->domain_pol = *domain_pol;
7152 q_u->switch_value = switch_value;
7153 }
7154
7155 /*******************************************************************
7156 reads or writes a structure.
7157 ********************************************************************/
7158
7159 BOOL samr_io_q_unknown_2e(const char *desc, SAMR_Q_UNKNOWN_2E *q_u,
7160 prs_struct *ps, int depth)
7161 {
7162 if (q_u == NULL)
7163 return False;
7164
7165 prs_debug(ps, depth, desc, "samr_io_q_unknown_2e");
7166 depth++;
7167
7168 if(!prs_align(ps))
7169 return False;
7170
7171 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7172 return False;
7173
7174 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7175 return False;
7176
7177 return True;
7178 }
7179
7180 /*******************************************************************
7181 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7182 ********************************************************************/
7183
7184 void init_samr_r_samr_unknown_2e(SAMR_R_UNKNOWN_2E * r_u,
7185 uint16 switch_value, SAM_UNK_CTR * ctr,
7186 NTSTATUS status)
7187 {
7188 DEBUG(5, ("init_samr_r_samr_unknown_2e\n"));
7189
7190 r_u->ptr_0 = 0;
7191 r_u->switch_value = 0;
7192 r_u->status = status; /* return status */
7193
7194 if (NT_STATUS_IS_OK(status)) {
7195 r_u->switch_value = switch_value;
7196 r_u->ptr_0 = 1;
7197 r_u->ctr = ctr;
7198 }
7199 }
7200
7201 /*******************************************************************
7202 reads or writes a structure.
7203 ********************************************************************/
7204
7205 BOOL samr_io_r_samr_unknown_2e(const char *desc, SAMR_R_UNKNOWN_2E * r_u,
7206 prs_struct *ps, int depth)
7207 {
7208 if (r_u == NULL)
7209 return False;
7210
7211 prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
7212 depth++;
7213
7214 if(!prs_align(ps))
7215 return False;
7216
7217 if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
7218 return False;
7219
7220 if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
7221 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
7222 return False;
7223 if(!prs_align(ps))
7224 return False;
7225
7226 switch (r_u->switch_value) {
7227 case 0x0c:
7228 if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
7229 return False;
7230 break;
7231 case 0x07:
7232 if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
7233 return False;
7234 break;
7235 case 0x06:
7236 if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
7237 return False;
7238 break;
7239 case 0x05:
7240 if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
7241 return False;
7242 break;
7243 case 0x03:
7244 if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
7245 return False;
7246 break;
7247 case 0x02:
7248 if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
7249 return False;
7250 break;
7251 case 0x01:
7252 if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
7253 return False;
7254 break;
7255 default:
7256 DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
7257 r_u->switch_value));
7258 r_u->status = NT_STATUS_INVALID_INFO_CLASS;
7259 return False;
7260 }
7261 }
7262
7263 if(!prs_align(ps))
7264 return False;
7265
7266 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7267 return False;
7268
7269 return True;
7270 }
7271
7272
7273 /*******************************************************************
7274 reads or writes a structure.
7275 ********************************************************************/
7276
7277 void init_samr_q_set_domain_info(SAMR_Q_SET_DOMAIN_INFO *q_u,
7278 POLICY_HND *domain_pol, uint16 switch_value, SAM_UNK_CTR *ctr)
7279 {
7280 DEBUG(5, ("init_samr_q_set_domain_info\n"));
7281
7282 q_u->domain_pol = *domain_pol;
7283 q_u->switch_value0 = switch_value;
7284
7285 q_u->switch_value = switch_value;
7286 q_u->ctr = ctr;
7287
7288 }
7289
7290 /*******************************************************************
7291 reads or writes a structure.
7292 ********************************************************************/
7293
7294 BOOL samr_io_q_set_domain_info(const char *desc, SAMR_Q_SET_DOMAIN_INFO *q_u,
7295 prs_struct *ps, int depth)
7296 {
7297 if (q_u == NULL)
7298 return False;
7299
7300 prs_debug(ps, depth, desc, "samr_io_q_set_domain_info");
7301 depth++;
7302
7303 if(!prs_align(ps))
7304 return False;
7305
7306 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7307 return False;
7308
7309 if(!prs_uint16("switch_value0", ps, depth, &q_u->switch_value0))
7310 return False;
7311
7312 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7313 return False;
7314
7315 if(!prs_align(ps))
7316 return False;
7317
7318 if ((q_u->ctr = (SAM_UNK_CTR *)prs_alloc_mem(ps, sizeof(SAM_UNK_CTR))) == NULL)
7319 return False;
7320
7321 switch (q_u->switch_value) {
7322
7323 case 0x0c:
7324 if(!sam_io_unk_info12("unk_inf12", &q_u->ctr->info.inf12, ps, depth))
7325 return False;
7326 break;
7327 case 0x07:
7328 if(!sam_io_unk_info7("unk_inf7",&q_u->ctr->info.inf7, ps,depth))
7329 return False;
7330 break;
7331 case 0x06:
7332 if(!sam_io_unk_info6("unk_inf6",&q_u->ctr->info.inf6, ps,depth))
7333 return False;
7334 break;
7335 case 0x05:
7336 if(!sam_io_unk_info5("unk_inf5",&q_u->ctr->info.inf5, ps,depth))
7337 return False;
7338 break;
7339 case 0x03:
7340 if(!sam_io_unk_info3("unk_inf3",&q_u->ctr->info.inf3, ps,depth))
7341 return False;
7342 break;
7343 case 0x02:
7344 if(!sam_io_unk_info2("unk_inf2",&q_u->ctr->info.inf2, ps,depth))
7345 return False;
7346 break;
7347 case 0x01:
7348 if(!sam_io_unk_info1("unk_inf1",&q_u->ctr->info.inf1, ps,depth))
7349 return False;
7350 break;
7351 default:
7352 DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
7353 q_u->switch_value));
7354 return False;
7355 }
7356
7357 return True;
7358 }
7359
7360 /*******************************************************************
7361 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7362 ********************************************************************/
7363
7364 void init_samr_r_set_domain_info(SAMR_R_SET_DOMAIN_INFO * r_u, NTSTATUS status)
7365 {
7366 DEBUG(5, ("init_samr_r_set_domain_info\n"));
7367
7368 r_u->status = status; /* return status */
7369 }
7370
7371 /*******************************************************************
7372 reads or writes a structure.
7373 ********************************************************************/
7374
7375 BOOL samr_io_r_set_domain_info(const char *desc, SAMR_R_SET_DOMAIN_INFO * r_u,
7376 prs_struct *ps, int depth)
7377 {
7378 if (r_u == NULL)
7379 return False;
7380
7381 prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
7382 depth++;
7383
7384 if(!prs_align(ps))
7385 return False;
7386
7387 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7388 return False;
7389
7390 return True;
7391 }
reg import