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