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