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