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