?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[GLUE] Rsync SAMBA_3_0 SVN r25598 in order to create the v3-0-test branch.
[Samba.git] / source / rpc_parse / parse_samr.c
blob4410348abeee31b89aedbaa884d69c2546d3f4da
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_OPEN_GROUP structure.
2177 ********************************************************************/
2178
2179 void init_samr_q_open_group(SAMR_Q_OPEN_GROUP * q_c,
2180 POLICY_HND *hnd,
2181 uint32 access_mask, uint32 rid)
2182 {
2183 DEBUG(5, ("init_samr_q_open_group\n"));
2184
2185 q_c->domain_pol = *hnd;
2186 q_c->access_mask = access_mask;
2187 q_c->rid_group = rid;
2188 }
2189
2190 /*******************************************************************
2191 reads or writes a structure.
2192 ********************************************************************/
2193
2194 BOOL samr_io_q_open_group(const char *desc, SAMR_Q_OPEN_GROUP * q_u,
2195 prs_struct *ps, int depth)
2196 {
2197 if (q_u == NULL)
2198 return False;
2199
2200 prs_debug(ps, depth, desc, "samr_io_q_open_group");
2201 depth++;
2202
2203 if(!prs_align(ps))
2204 return False;
2205
2206 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
2207 return False;
2208
2209 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
2210 return False;
2211 if(!prs_uint32("rid_group", ps, depth, &q_u->rid_group))
2212 return False;
2213
2214 return True;
2215 }
2216
2217 /*******************************************************************
2218 reads or writes a structure.
2219 ********************************************************************/
2220
2221 BOOL samr_io_r_open_group(const char *desc, SAMR_R_OPEN_GROUP * r_u,
2222 prs_struct *ps, int depth)
2223 {
2224 if (r_u == NULL)
2225 return False;
2226
2227 prs_debug(ps, depth, desc, "samr_io_r_open_group");
2228 depth++;
2229
2230 if(!prs_align(ps))
2231 return False;
2232
2233 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2234 return False;
2235
2236 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2237 return False;
2238
2239 return True;
2240 }
2241
2242 /*******************************************************************
2243 inits a GROUP_INFO1 structure.
2244 ********************************************************************/
2245
2246 void init_samr_group_info1(GROUP_INFO1 * gr1,
2247 char *acct_name, char *acct_desc,
2248 uint32 num_members)
2249 {
2250 DEBUG(5, ("init_samr_group_info1\n"));
2251
2252 gr1->group_attr = (SE_GROUP_MANDATORY|SE_GROUP_ENABLED_BY_DEFAULT); /* why not | SE_GROUP_ENABLED ? */
2253 gr1->num_members = num_members;
2254
2255 init_unistr2(&gr1->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2256 init_uni_hdr(&gr1->hdr_acct_name, &gr1->uni_acct_name);
2257 init_unistr2(&gr1->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2258 init_uni_hdr(&gr1->hdr_acct_desc, &gr1->uni_acct_desc);
2259 }
2260
2261 /*******************************************************************
2262 reads or writes a structure.
2263 ********************************************************************/
2264
2265 BOOL samr_io_group_info1(const char *desc, GROUP_INFO1 * gr1,
2266 prs_struct *ps, int depth)
2267 {
2268 uint16 dummy = 1;
2269
2270 if (gr1 == NULL)
2271 return False;
2272
2273 prs_debug(ps, depth, desc, "samr_io_group_info1");
2274 depth++;
2275
2276 if(!prs_uint16("level", ps, depth, &dummy))
2277 return False;
2278
2279 if(!prs_align(ps))
2280 return False;
2281
2282 if(!smb_io_unihdr("hdr_acct_name", &gr1->hdr_acct_name, ps, depth))
2283 return False;
2284
2285 if(!prs_uint32("group_attr", ps, depth, &gr1->group_attr))
2286 return False;
2287 if(!prs_uint32("num_members", ps, depth, &gr1->num_members))
2288 return False;
2289
2290 if(!smb_io_unihdr("hdr_acct_desc", &gr1->hdr_acct_desc, ps, depth))
2291 return False;
2292
2293 if(!smb_io_unistr2("uni_acct_name", &gr1->uni_acct_name,
2294 gr1->hdr_acct_name.buffer, ps, depth))
2295 return False;
2296
2297 if(!smb_io_unistr2("uni_acct_desc", &gr1->uni_acct_desc,
2298 gr1->hdr_acct_desc.buffer, ps, depth))
2299 return False;
2300
2301 return True;
2302 }
2303
2304 /*******************************************************************
2305 inits a GROUP_INFO2 structure.
2306 ********************************************************************/
2307
2308 void init_samr_group_info2(GROUP_INFO2 * gr2, const char *acct_name)
2309 {
2310 DEBUG(5, ("init_samr_group_info2\n"));
2311
2312 gr2->level = 2;
2313 init_unistr2(&gr2->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2314 init_uni_hdr(&gr2->hdr_acct_name, &gr2->uni_acct_name);
2315 }
2316
2317 /*******************************************************************
2318 reads or writes a structure.
2319 ********************************************************************/
2320
2321 BOOL samr_io_group_info2(const char *desc, GROUP_INFO2 *gr2, prs_struct *ps, int depth)
2322 {
2323 if (gr2 == NULL)
2324 return False;
2325
2326 prs_debug(ps, depth, desc, "samr_io_group_info2");
2327 depth++;
2328
2329 if(!prs_uint16("hdr_level", ps, depth, &gr2->level))
2330 return False;
2331
2332 if(!smb_io_unihdr("hdr_acct_name", &gr2->hdr_acct_name, ps, depth))
2333 return False;
2334 if(!smb_io_unistr2("uni_acct_name", &gr2->uni_acct_name,
2335 gr2->hdr_acct_name.buffer, ps, depth))
2336 return False;
2337
2338 return True;
2339 }
2340
2341 /*******************************************************************
2342 inits a GROUP_INFO3 structure.
2343 ********************************************************************/
2344
2345 void init_samr_group_info3(GROUP_INFO3 *gr3)
2346 {
2347 DEBUG(5, ("init_samr_group_info3\n"));
2348
2349 gr3->group_attr = (SE_GROUP_MANDATORY|SE_GROUP_ENABLED_BY_DEFAULT); /* why not | SE_GROUP_ENABLED ? */
2350 }
2351
2352 /*******************************************************************
2353 reads or writes a structure.
2354 ********************************************************************/
2355
2356 BOOL samr_io_group_info3(const char *desc, GROUP_INFO3 *gr3, prs_struct *ps, int depth)
2357 {
2358 if (gr3 == NULL)
2359 return False;
2360
2361 prs_debug(ps, depth, desc, "samr_io_group_info3");
2362 depth++;
2363
2364 if(!prs_align(ps))
2365 return False;
2366
2367 if(!prs_uint32("group_attr", ps, depth, &gr3->group_attr))
2368 return False;
2369
2370 return True;
2371 }
2372
2373 /*******************************************************************
2374 inits a GROUP_INFO4 structure.
2375 ********************************************************************/
2376
2377 void init_samr_group_info4(GROUP_INFO4 * gr4, const char *acct_desc)
2378 {
2379 DEBUG(5, ("init_samr_group_info4\n"));
2380
2381 gr4->level = 4;
2382 init_unistr2(&gr4->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2383 init_uni_hdr(&gr4->hdr_acct_desc, &gr4->uni_acct_desc);
2384 }
2385
2386 /*******************************************************************
2387 reads or writes a structure.
2388 ********************************************************************/
2389
2390 BOOL samr_io_group_info4(const char *desc, GROUP_INFO4 * gr4,
2391 prs_struct *ps, int depth)
2392 {
2393 if (gr4 == NULL)
2394 return False;
2395
2396 prs_debug(ps, depth, desc, "samr_io_group_info4");
2397 depth++;
2398
2399 if(!prs_uint16("hdr_level", ps, depth, &gr4->level))
2400 return False;
2401 if(!smb_io_unihdr("hdr_acct_desc", &gr4->hdr_acct_desc, ps, depth))
2402 return False;
2403 if(!smb_io_unistr2("uni_acct_desc", &gr4->uni_acct_desc,
2404 gr4->hdr_acct_desc.buffer, ps, depth))
2405 return False;
2406
2407 return True;
2408 }
2409
2410 /*******************************************************************
2411 inits a GROUP_INFO5 structure.
2412 ********************************************************************/
2413
2414 void init_samr_group_info5(GROUP_INFO5 * gr5,
2415 char *acct_name, char *acct_desc,
2416 uint32 num_members)
2417 {
2418 DEBUG(5, ("init_samr_group_info5\n"));
2419
2420 gr5->group_attr = (SE_GROUP_MANDATORY|SE_GROUP_ENABLED_BY_DEFAULT); /* why not | SE_GROUP_ENABLED ? */
2421 gr5->num_members = num_members;
2422
2423 init_unistr2(&gr5->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2424 init_uni_hdr(&gr5->hdr_acct_name, &gr5->uni_acct_name);
2425 init_unistr2(&gr5->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2426 init_uni_hdr(&gr5->hdr_acct_desc, &gr5->uni_acct_desc);
2427 }
2428
2429 /*******************************************************************
2430 reads or writes a structure.
2431 ********************************************************************/
2432
2433 BOOL samr_io_group_info5(const char *desc, GROUP_INFO5 * gr5,
2434 prs_struct *ps, int depth)
2435 {
2436 uint16 dummy = 1;
2437
2438 if (gr5 == NULL)
2439 return False;
2440
2441 prs_debug(ps, depth, desc, "samr_io_group_info5");
2442 depth++;
2443
2444 if(!prs_uint16("level", ps, depth, &dummy))
2445 return False;
2446
2447 if(!prs_align(ps))
2448 return False;
2449
2450 if(!smb_io_unihdr("hdr_acct_name", &gr5->hdr_acct_name, ps, depth))
2451 return False;
2452
2453 if(!prs_uint32("group_attr", ps, depth, &gr5->group_attr))
2454 return False;
2455 if(!prs_uint32("num_members", ps, depth, &gr5->num_members))
2456 return False;
2457
2458 if(!smb_io_unihdr("hdr_acct_desc", &gr5->hdr_acct_desc, ps, depth))
2459 return False;
2460
2461 if(!smb_io_unistr2("uni_acct_name", &gr5->uni_acct_name,
2462 gr5->hdr_acct_name.buffer, ps, depth))
2463 return False;
2464
2465 if(!smb_io_unistr2("uni_acct_desc", &gr5->uni_acct_desc,
2466 gr5->hdr_acct_desc.buffer, ps, depth))
2467 return False;
2468
2469 return True;
2470 }
2471
2472
2473 /*******************************************************************
2474 reads or writes a structure.
2475 ********************************************************************/
2476
2477 static BOOL samr_group_info_ctr(const char *desc, GROUP_INFO_CTR **ctr,
2478 prs_struct *ps, int depth)
2479 {
2480 if (UNMARSHALLING(ps))
2481 *ctr = PRS_ALLOC_MEM(ps,GROUP_INFO_CTR,1);
2482
2483 if (*ctr == NULL)
2484 return False;
2485
2486 prs_debug(ps, depth, desc, "samr_group_info_ctr");
2487 depth++;
2488
2489 if(!prs_uint16("switch_value1", ps, depth, &(*ctr)->switch_value1))
2490 return False;
2491
2492 switch ((*ctr)->switch_value1) {
2493 case 1:
2494 if(!samr_io_group_info1("group_info1", &(*ctr)->group.info1, ps, depth))
2495 return False;
2496 break;
2497 case 2:
2498 if(!samr_io_group_info2("group_info2", &(*ctr)->group.info2, ps, depth))
2499 return False;
2500 break;
2501 case 3:
2502 if(!samr_io_group_info3("group_info3", &(*ctr)->group.info3, ps, depth))
2503 return False;
2504 break;
2505 case 4:
2506 if(!samr_io_group_info4("group_info4", &(*ctr)->group.info4, ps, depth))
2507 return False;
2508 break;
2509 case 5:
2510 if(!samr_io_group_info5("group_info5", &(*ctr)->group.info5, ps, depth))
2511 return False;
2512 break;
2513 default:
2514 DEBUG(0,("samr_group_info_ctr: unsupported switch level\n"));
2515 break;
2516 }
2517
2518 return True;
2519 }
2520
2521 /*******************************************************************
2522 inits a SAMR_Q_CREATE_DOM_GROUP structure.
2523 ********************************************************************/
2524
2525 void init_samr_q_create_dom_group(SAMR_Q_CREATE_DOM_GROUP * q_e,
2526 POLICY_HND *pol, const char *acct_desc,
2527 uint32 access_mask)
2528 {
2529 DEBUG(5, ("init_samr_q_create_dom_group\n"));
2530
2531 q_e->pol = *pol;
2532
2533 init_unistr2(&q_e->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2534 init_uni_hdr(&q_e->hdr_acct_desc, &q_e->uni_acct_desc);
2535
2536 q_e->access_mask = access_mask;
2537 }
2538
2539 /*******************************************************************
2540 reads or writes a structure.
2541 ********************************************************************/
2542
2543 BOOL samr_io_q_create_dom_group(const char *desc, SAMR_Q_CREATE_DOM_GROUP * q_e,
2544 prs_struct *ps, int depth)
2545 {
2546 if (q_e == NULL)
2547 return False;
2548
2549 prs_debug(ps, depth, desc, "samr_io_q_create_dom_group");
2550 depth++;
2551
2552 if(!prs_align(ps))
2553 return False;
2554
2555 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2556 return False;
2557
2558 if(!smb_io_unihdr("hdr_acct_desc", &q_e->hdr_acct_desc, ps, depth))
2559 return False;
2560 if(!smb_io_unistr2("uni_acct_desc", &q_e->uni_acct_desc,
2561 q_e->hdr_acct_desc.buffer, ps, depth))
2562 return False;
2563
2564 if(!prs_align(ps))
2565 return False;
2566 if(!prs_uint32("access", ps, depth, &q_e->access_mask))
2567 return False;
2568
2569 return True;
2570 }
2571
2572 /*******************************************************************
2573 reads or writes a structure.
2574 ********************************************************************/
2575
2576 BOOL samr_io_r_create_dom_group(const char *desc, SAMR_R_CREATE_DOM_GROUP * r_u,
2577 prs_struct *ps, int depth)
2578 {
2579 if (r_u == NULL)
2580 return False;
2581
2582 prs_debug(ps, depth, desc, "samr_io_r_create_dom_group");
2583 depth++;
2584
2585 if(!prs_align(ps))
2586 return False;
2587
2588 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2589 return False;
2590
2591 if(!prs_uint32("rid ", ps, depth, &r_u->rid))
2592 return False;
2593 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2594 return False;
2595
2596 return True;
2597 }
2598
2599 /*******************************************************************
2600 inits a SAMR_Q_DELETE_DOM_GROUP structure.
2601 ********************************************************************/
2602
2603 void init_samr_q_delete_dom_group(SAMR_Q_DELETE_DOM_GROUP * q_c,
2604 POLICY_HND *hnd)
2605 {
2606 DEBUG(5, ("init_samr_q_delete_dom_group\n"));
2607
2608 q_c->group_pol = *hnd;
2609 }
2610
2611 /*******************************************************************
2612 reads or writes a structure.
2613 ********************************************************************/
2614
2615 BOOL samr_io_q_delete_dom_group(const char *desc, SAMR_Q_DELETE_DOM_GROUP * q_u,
2616 prs_struct *ps, int depth)
2617 {
2618 if (q_u == NULL)
2619 return False;
2620
2621 prs_debug(ps, depth, desc, "samr_io_q_delete_dom_group");
2622 depth++;
2623
2624 if(!prs_align(ps))
2625 return False;
2626
2627 if(!smb_io_pol_hnd("group_pol", &q_u->group_pol, ps, depth))
2628 return False;
2629
2630 return True;
2631 }
2632
2633 /*******************************************************************
2634 reads or writes a structure.
2635 ********************************************************************/
2636
2637 BOOL samr_io_r_delete_dom_group(const char *desc, SAMR_R_DELETE_DOM_GROUP * r_u,
2638 prs_struct *ps, int depth)
2639 {
2640 if (r_u == NULL)
2641 return False;
2642
2643 prs_debug(ps, depth, desc, "samr_io_r_delete_dom_group");
2644 depth++;
2645
2646 if(!prs_align(ps))
2647 return False;
2648
2649 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2650 return False;
2651
2652 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2653 return False;
2654
2655 return True;
2656 }
2657
2658 /*******************************************************************
2659 inits a SAMR_Q_DEL_GROUPMEM structure.
2660 ********************************************************************/
2661
2662 void init_samr_q_del_groupmem(SAMR_Q_DEL_GROUPMEM * q_e,
2663 POLICY_HND *pol, uint32 rid)
2664 {
2665 DEBUG(5, ("init_samr_q_del_groupmem\n"));
2666
2667 q_e->pol = *pol;
2668 q_e->rid = rid;
2669 }
2670
2671 /*******************************************************************
2672 reads or writes a structure.
2673 ********************************************************************/
2674
2675 BOOL samr_io_q_del_groupmem(const char *desc, SAMR_Q_DEL_GROUPMEM * q_e,
2676 prs_struct *ps, int depth)
2677 {
2678 if (q_e == NULL)
2679 return False;
2680
2681 prs_debug(ps, depth, desc, "samr_io_q_del_groupmem");
2682 depth++;
2683
2684 if(!prs_align(ps))
2685 return False;
2686
2687 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2688 return False;
2689
2690 if(!prs_uint32("rid", ps, depth, &q_e->rid))
2691 return False;
2692
2693 return True;
2694 }
2695
2696 /*******************************************************************
2697 inits a SAMR_R_DEL_GROUPMEM structure.
2698 ********************************************************************/
2699
2700 void init_samr_r_del_groupmem(SAMR_R_DEL_GROUPMEM * r_u, POLICY_HND *pol,
2701 NTSTATUS status)
2702 {
2703 DEBUG(5, ("init_samr_r_del_groupmem\n"));
2704
2705 r_u->status = status;
2706 }
2707
2708 /*******************************************************************
2709 reads or writes a structure.
2710 ********************************************************************/
2711
2712 BOOL samr_io_r_del_groupmem(const char *desc, SAMR_R_DEL_GROUPMEM * r_u,
2713 prs_struct *ps, int depth)
2714 {
2715 if (r_u == NULL)
2716 return False;
2717
2718 prs_debug(ps, depth, desc, "samr_io_r_del_groupmem");
2719 depth++;
2720
2721 if(!prs_align(ps))
2722 return False;
2723
2724 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2725 return False;
2726
2727 return True;
2728 }
2729
2730 /*******************************************************************
2731 inits a SAMR_Q_ADD_GROUPMEM structure.
2732 ********************************************************************/
2733
2734 void init_samr_q_add_groupmem(SAMR_Q_ADD_GROUPMEM * q_e,
2735 POLICY_HND *pol, uint32 rid)
2736 {
2737 DEBUG(5, ("init_samr_q_add_groupmem\n"));
2738
2739 q_e->pol = *pol;
2740 q_e->rid = rid;
2741 q_e->unknown = 0x0005;
2742 }
2743
2744 /*******************************************************************
2745 reads or writes a structure.
2746 ********************************************************************/
2747
2748 BOOL samr_io_q_add_groupmem(const char *desc, SAMR_Q_ADD_GROUPMEM * q_e,
2749 prs_struct *ps, int depth)
2750 {
2751 if (q_e == NULL)
2752 return False;
2753
2754 prs_debug(ps, depth, desc, "samr_io_q_add_groupmem");
2755 depth++;
2756
2757 if(!prs_align(ps))
2758 return False;
2759
2760 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2761 return False;
2762
2763 if(!prs_uint32("rid ", ps, depth, &q_e->rid))
2764 return False;
2765 if(!prs_uint32("unknown", ps, depth, &q_e->unknown))
2766 return False;
2767
2768 return True;
2769 }
2770
2771 /*******************************************************************
2772 inits a SAMR_R_ADD_GROUPMEM structure.
2773 ********************************************************************/
2774
2775 void init_samr_r_add_groupmem(SAMR_R_ADD_GROUPMEM * r_u, POLICY_HND *pol,
2776 NTSTATUS status)
2777 {
2778 DEBUG(5, ("init_samr_r_add_groupmem\n"));
2779
2780 r_u->status = status;
2781 }
2782
2783 /*******************************************************************
2784 reads or writes a structure.
2785 ********************************************************************/
2786
2787 BOOL samr_io_r_add_groupmem(const char *desc, SAMR_R_ADD_GROUPMEM * r_u,
2788 prs_struct *ps, int depth)
2789 {
2790 if (r_u == NULL)
2791 return False;
2792
2793 prs_debug(ps, depth, desc, "samr_io_r_add_groupmem");
2794 depth++;
2795
2796 if(!prs_align(ps))
2797 return False;
2798
2799 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2800 return False;
2801
2802 return True;
2803 }
2804
2805 /*******************************************************************
2806 inits a SAMR_Q_SET_GROUPINFO structure.
2807 ********************************************************************/
2808
2809 void init_samr_q_set_groupinfo(SAMR_Q_SET_GROUPINFO * q_e,
2810 POLICY_HND *pol, GROUP_INFO_CTR * ctr)
2811 {
2812 DEBUG(5, ("init_samr_q_set_groupinfo\n"));
2813
2814 q_e->pol = *pol;
2815 q_e->ctr = ctr;
2816 }
2817
2818 /*******************************************************************
2819 reads or writes a structure.
2820 ********************************************************************/
2821
2822 BOOL samr_io_q_set_groupinfo(const char *desc, SAMR_Q_SET_GROUPINFO * q_e,
2823 prs_struct *ps, int depth)
2824 {
2825 if (q_e == NULL)
2826 return False;
2827
2828 prs_debug(ps, depth, desc, "samr_io_q_set_groupinfo");
2829 depth++;
2830
2831 if(!prs_align(ps))
2832 return False;
2833
2834 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2835 return False;
2836
2837 if(!samr_group_info_ctr("ctr", &q_e->ctr, ps, depth))
2838 return False;
2839
2840 return True;
2841 }
2842
2843 /*******************************************************************
2844 inits a SAMR_R_SET_GROUPINFO structure.
2845 ********************************************************************/
2846
2847 void init_samr_r_set_groupinfo(SAMR_R_SET_GROUPINFO * r_u, NTSTATUS status)
2848 {
2849 DEBUG(5, ("init_samr_r_set_groupinfo\n"));
2850
2851 r_u->status = status;
2852 }
2853
2854 /*******************************************************************
2855 reads or writes a structure.
2856 ********************************************************************/
2857
2858 BOOL samr_io_r_set_groupinfo(const char *desc, SAMR_R_SET_GROUPINFO * r_u,
2859 prs_struct *ps, int depth)
2860 {
2861 if (r_u == NULL)
2862 return False;
2863
2864 prs_debug(ps, depth, desc, "samr_io_r_set_groupinfo");
2865 depth++;
2866
2867 if(!prs_align(ps))
2868 return False;
2869
2870 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2871 return False;
2872
2873 return True;
2874 }
2875
2876 /*******************************************************************
2877 inits a SAMR_Q_QUERY_GROUPINFO structure.
2878 ********************************************************************/
2879
2880 void init_samr_q_query_groupinfo(SAMR_Q_QUERY_GROUPINFO * q_e,
2881 POLICY_HND *pol, uint16 switch_level)
2882 {
2883 DEBUG(5, ("init_samr_q_query_groupinfo\n"));
2884
2885 q_e->pol = *pol;
2886
2887 q_e->switch_level = switch_level;
2888 }
2889
2890 /*******************************************************************
2891 reads or writes a structure.
2892 ********************************************************************/
2893
2894 BOOL samr_io_q_query_groupinfo(const char *desc, SAMR_Q_QUERY_GROUPINFO * q_e,
2895 prs_struct *ps, int depth)
2896 {
2897 if (q_e == NULL)
2898 return False;
2899
2900 prs_debug(ps, depth, desc, "samr_io_q_query_groupinfo");
2901 depth++;
2902
2903 if(!prs_align(ps))
2904 return False;
2905
2906 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2907 return False;
2908
2909 if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
2910 return False;
2911
2912 return True;
2913 }
2914
2915 /*******************************************************************
2916 inits a SAMR_R_QUERY_GROUPINFO structure.
2917 ********************************************************************/
2918
2919 void init_samr_r_query_groupinfo(SAMR_R_QUERY_GROUPINFO * r_u,
2920 GROUP_INFO_CTR * ctr, NTSTATUS status)
2921 {
2922 DEBUG(5, ("init_samr_r_query_groupinfo\n"));
2923
2924 r_u->ptr = (NT_STATUS_IS_OK(status) && ctr != NULL) ? 1 : 0;
2925 r_u->ctr = ctr;
2926 r_u->status = status;
2927 }
2928
2929 /*******************************************************************
2930 reads or writes a structure.
2931 ********************************************************************/
2932
2933 BOOL samr_io_r_query_groupinfo(const char *desc, SAMR_R_QUERY_GROUPINFO * r_u,
2934 prs_struct *ps, int depth)
2935 {
2936 if (r_u == NULL)
2937 return False;
2938
2939 prs_debug(ps, depth, desc, "samr_io_r_query_groupinfo");
2940 depth++;
2941
2942 if(!prs_align(ps))
2943 return False;
2944
2945 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
2946 return False;
2947
2948 if (r_u->ptr != 0) {
2949 if(!samr_group_info_ctr("ctr", &r_u->ctr, ps, depth))
2950 return False;
2951 }
2952
2953 if(!prs_align(ps))
2954 return False;
2955 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2956 return False;
2957
2958 return True;
2959 }
2960
2961 /*******************************************************************
2962 inits a SAMR_Q_QUERY_GROUPMEM structure.
2963 ********************************************************************/
2964
2965 void init_samr_q_query_groupmem(SAMR_Q_QUERY_GROUPMEM * q_c, POLICY_HND *hnd)
2966 {
2967 DEBUG(5, ("init_samr_q_query_groupmem\n"));
2968
2969 q_c->group_pol = *hnd;
2970 }
2971
2972 /*******************************************************************
2973 reads or writes a structure.
2974 ********************************************************************/
2975
2976 BOOL samr_io_q_query_groupmem(const char *desc, SAMR_Q_QUERY_GROUPMEM * q_u,
2977 prs_struct *ps, int depth)
2978 {
2979 if (q_u == NULL)
2980 return False;
2981
2982 prs_debug(ps, depth, desc, "samr_io_q_query_groupmem");
2983 depth++;
2984
2985 if(!prs_align(ps))
2986 return False;
2987
2988 if(!smb_io_pol_hnd("group_pol", &q_u->group_pol, ps, depth))
2989 return False;
2990
2991 return True;
2992 }
2993
2994 /*******************************************************************
2995 inits a SAMR_R_QUERY_GROUPMEM structure.
2996 ********************************************************************/
2997
2998 void init_samr_r_query_groupmem(SAMR_R_QUERY_GROUPMEM * r_u,
2999 uint32 num_entries, uint32 *rid,
3000 uint32 *attr, NTSTATUS status)
3001 {
3002 DEBUG(5, ("init_samr_r_query_groupmem\n"));
3003
3004 if (NT_STATUS_IS_OK(status)) {
3005 r_u->ptr = 1;
3006 r_u->num_entries = num_entries;
3007
3008 r_u->ptr_attrs = attr != NULL ? 1 : 0;
3009 r_u->ptr_rids = rid != NULL ? 1 : 0;
3010
3011 r_u->num_rids = num_entries;
3012 r_u->rid = rid;
3013
3014 r_u->num_attrs = num_entries;
3015 r_u->attr = attr;
3016 } else {
3017 r_u->ptr = 0;
3018 r_u->num_entries = 0;
3019 }
3020
3021 r_u->status = status;
3022 }
3023
3024 /*******************************************************************
3025 reads or writes a structure.
3026 ********************************************************************/
3027
3028 BOOL samr_io_r_query_groupmem(const char *desc, SAMR_R_QUERY_GROUPMEM * r_u,
3029 prs_struct *ps, int depth)
3030 {
3031 uint32 i;
3032
3033 if (r_u == NULL)
3034 return False;
3035
3036 if (UNMARSHALLING(ps))
3037 ZERO_STRUCTP(r_u);
3038
3039 prs_debug(ps, depth, desc, "samr_io_r_query_groupmem");
3040 depth++;
3041
3042 if(!prs_align(ps))
3043 return False;
3044
3045 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
3046 return False;
3047 if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
3048 return False;
3049
3050 if (r_u->ptr != 0) {
3051 if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids))
3052 return False;
3053 if(!prs_uint32("ptr_attrs", ps, depth, &r_u->ptr_attrs))
3054 return False;
3055
3056 if (r_u->ptr_rids != 0) {
3057 if(!prs_uint32("num_rids", ps, depth, &r_u->num_rids))
3058 return False;
3059 if (UNMARSHALLING(ps) && r_u->num_rids != 0) {
3060 r_u->rid = PRS_ALLOC_MEM(ps,uint32,r_u->num_rids);
3061 if (r_u->rid == NULL)
3062 return False;
3063 }
3064
3065 for (i = 0; i < r_u->num_rids; i++) {
3066 if(!prs_uint32("", ps, depth, &r_u->rid[i]))
3067 return False;
3068 }
3069 }
3070
3071 if (r_u->ptr_attrs != 0) {
3072 if(!prs_uint32("num_attrs", ps, depth, &r_u->num_attrs))
3073 return False;
3074
3075 if (UNMARSHALLING(ps) && r_u->num_attrs != 0) {
3076 r_u->attr = PRS_ALLOC_MEM(ps,uint32,r_u->num_attrs);
3077 if (r_u->attr == NULL)
3078 return False;
3079 }
3080
3081 for (i = 0; i < r_u->num_attrs; i++) {
3082 if(!prs_uint32("", ps, depth, &r_u->attr[i]))
3083 return False;
3084 }
3085 }
3086 }
3087
3088 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3089 return False;
3090
3091 return True;
3092 }
3093
3094 /*******************************************************************
3095 inits a SAMR_Q_QUERY_USERGROUPS structure.
3096 ********************************************************************/
3097
3098 void init_samr_q_query_usergroups(SAMR_Q_QUERY_USERGROUPS * q_u,
3099 POLICY_HND *hnd)
3100 {
3101 DEBUG(5, ("init_samr_q_query_usergroups\n"));
3102
3103 q_u->pol = *hnd;
3104 }
3105
3106 /*******************************************************************
3107 reads or writes a structure.
3108 ********************************************************************/
3109
3110 BOOL samr_io_q_query_usergroups(const char *desc, SAMR_Q_QUERY_USERGROUPS * q_u,
3111 prs_struct *ps, int depth)
3112 {
3113 if (q_u == NULL)
3114 return False;
3115
3116 prs_debug(ps, depth, desc, "samr_io_q_query_usergroups");
3117 depth++;
3118
3119 if(!prs_align(ps))
3120 return False;
3121
3122 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
3123 return False;
3124
3125 return True;
3126 }
3127
3128 /*******************************************************************
3129 inits a SAMR_R_QUERY_USERGROUPS structure.
3130 ********************************************************************/
3131
3132 void init_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS * r_u,
3133 uint32 num_gids, DOM_GID * gid,
3134 NTSTATUS status)
3135 {
3136 DEBUG(5, ("init_samr_r_query_usergroups\n"));
3137
3138 if (NT_STATUS_IS_OK(status)) {
3139 r_u->ptr_0 = 1;
3140 r_u->num_entries = num_gids;
3141 r_u->ptr_1 = (num_gids != 0) ? 1 : 0;
3142 r_u->num_entries2 = num_gids;
3143
3144 r_u->gid = gid;
3145 } else {
3146 r_u->ptr_0 = 0;
3147 r_u->num_entries = 0;
3148 r_u->ptr_1 = 0;
3149 r_u->gid = NULL;
3150 }
3151
3152 r_u->status = status;
3153 }
3154
3155 /*******************************************************************
3156 reads or writes a structure.
3157 ********************************************************************/
3158
3159 BOOL samr_io_gids(const char *desc, uint32 *num_gids, DOM_GID ** gid,
3160 prs_struct *ps, int depth)
3161 {
3162 uint32 i;
3163 if (gid == NULL)
3164 return False;
3165
3166 prs_debug(ps, depth, desc, "samr_io_gids");
3167 depth++;
3168
3169 if(!prs_align(ps))
3170 return False;
3171
3172 if(!prs_uint32("num_gids", ps, depth, num_gids))
3173 return False;
3174
3175 if ((*num_gids) != 0) {
3176 if (UNMARSHALLING(ps)) {
3177 (*gid) = PRS_ALLOC_MEM(ps,DOM_GID,*num_gids);
3178 }
3179
3180 if ((*gid) == NULL) {
3181 return False;
3182 }
3183
3184 for (i = 0; i < (*num_gids); i++) {
3185 if(!smb_io_gid("gids", &(*gid)[i], ps, depth))
3186 return False;
3187 }
3188 }
3189
3190 return True;
3191 }
3192
3193 /*******************************************************************
3194 reads or writes a structure.
3195 ********************************************************************/
3196
3197 BOOL samr_io_r_query_usergroups(const char *desc, SAMR_R_QUERY_USERGROUPS * r_u,
3198 prs_struct *ps, int depth)
3199 {
3200 if (r_u == NULL)
3201 return False;
3202
3203 prs_debug(ps, depth, desc, "samr_io_r_query_usergroups");
3204 depth++;
3205
3206 if(!prs_align(ps))
3207 return False;
3208
3209 if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
3210 return False;
3211
3212 if (r_u->ptr_0 != 0) {
3213 if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
3214 return False;
3215 if(!prs_uint32("ptr_1 ", ps, depth, &r_u->ptr_1))
3216 return False;
3217
3218 if (r_u->num_entries != 0 && r_u->ptr_1 != 0) {
3219 if(!samr_io_gids("gids", &r_u->num_entries2, &r_u->gid, ps, depth))
3220 return False;
3221 }
3222 }
3223
3224 if(!prs_align(ps))
3225 return False;
3226 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3227 return False;
3228
3229 return True;
3230 }
3231
3232 /*******************************************************************
3233 inits a SAMR_Q_ENUM_DOMAINS structure.
3234 ********************************************************************/
3235
3236 void init_samr_q_enum_domains(SAMR_Q_ENUM_DOMAINS * q_e,
3237 POLICY_HND *pol,
3238 uint32 start_idx, uint32 size)
3239 {
3240 DEBUG(5, ("init_samr_q_enum_domains\n"));
3241
3242 q_e->pol = *pol;
3243
3244 q_e->start_idx = start_idx;
3245 q_e->max_size = size;
3246 }
3247
3248 /*******************************************************************
3249 reads or writes a structure.
3250 ********************************************************************/
3251
3252 BOOL samr_io_q_enum_domains(const char *desc, SAMR_Q_ENUM_DOMAINS * q_e,
3253 prs_struct *ps, int depth)
3254 {
3255 if (q_e == NULL)
3256 return False;
3257
3258 prs_debug(ps, depth, desc, "samr_io_q_enum_domains");
3259 depth++;
3260
3261 if(!prs_align(ps))
3262 return False;
3263
3264 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
3265 return False;
3266
3267 if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3268 return False;
3269 if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3270 return False;
3271
3272 return True;
3273 }
3274
3275 /*******************************************************************
3276 inits a SAMR_R_ENUM_DOMAINS structure.
3277 ********************************************************************/
3278
3279 void init_samr_r_enum_domains(SAMR_R_ENUM_DOMAINS * r_u,
3280 uint32 next_idx, uint32 num_sam_entries)
3281 {
3282 DEBUG(5, ("init_samr_r_enum_domains\n"));
3283
3284 r_u->next_idx = next_idx;
3285
3286 if (num_sam_entries != 0) {
3287 r_u->ptr_entries1 = 1;
3288 r_u->ptr_entries2 = 1;
3289 r_u->num_entries2 = num_sam_entries;
3290 r_u->num_entries3 = num_sam_entries;
3291
3292 r_u->num_entries4 = num_sam_entries;
3293 } else {
3294 r_u->ptr_entries1 = 0;
3295 r_u->num_entries2 = num_sam_entries;
3296 r_u->ptr_entries2 = 1;
3297 }
3298 }
3299
3300 /*******************************************************************
3301 reads or writes a structure.
3302 ********************************************************************/
3303
3304 BOOL samr_io_r_enum_domains(const char *desc, SAMR_R_ENUM_DOMAINS * r_u,
3305 prs_struct *ps, int depth)
3306 {
3307 uint32 i;
3308
3309 if (r_u == NULL)
3310 return False;
3311
3312 prs_debug(ps, depth, desc, "samr_io_r_enum_domains");
3313 depth++;
3314
3315 if(!prs_align(ps))
3316 return False;
3317
3318 if(!prs_uint32("next_idx ", ps, depth, &r_u->next_idx))
3319 return False;
3320 if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3321 return False;
3322
3323 if (r_u->ptr_entries1 != 0) {
3324 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3325 return False;
3326 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3327 return False;
3328 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3329 return False;
3330
3331 if (UNMARSHALLING(ps) && r_u->num_entries2) {
3332 r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3333 r_u->uni_dom_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3334 }
3335
3336 if ((r_u->sam == NULL || r_u->uni_dom_name == NULL) && r_u->num_entries2 != 0) {
3337 DEBUG(0, ("NULL pointers in SAMR_R_ENUM_DOMAINS\n"));
3338 r_u->num_entries4 = 0;
3339 r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3340 return False;
3341 }
3342
3343 for (i = 0; i < r_u->num_entries2; i++) {
3344 fstring tmp;
3345 slprintf(tmp, sizeof(tmp) - 1, "dom[%d]", i);
3346 if(!sam_io_sam_entry(tmp, &r_u->sam[i], ps, depth))
3347 return False;
3348 }
3349
3350 for (i = 0; i < r_u->num_entries2; i++) {
3351 fstring tmp;
3352 slprintf(tmp, sizeof(tmp) - 1, "dom[%d]", i);
3353 if(!smb_io_unistr2(tmp, &r_u->uni_dom_name[i],
3354 r_u->sam[i].hdr_name.buffer, ps,
3355 depth))
3356 return False;
3357 }
3358
3359 }
3360
3361 if(!prs_align(ps))
3362 return False;
3363 if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3364 return False;
3365 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3366 return False;
3367
3368 return True;
3369 }
3370
3371 /*******************************************************************
3372 inits a SAMR_Q_ENUM_DOM_GROUPS structure.
3373 ********************************************************************/
3374
3375 void init_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS * q_e,
3376 POLICY_HND *pol,
3377 uint32 start_idx, uint32 size)
3378 {
3379 DEBUG(5, ("init_samr_q_enum_dom_groups\n"));
3380
3381 q_e->pol = *pol;
3382
3383 q_e->start_idx = start_idx;
3384 q_e->max_size = size;
3385 }
3386
3387 /*******************************************************************
3388 reads or writes a structure.
3389 ********************************************************************/
3390
3391 BOOL samr_io_q_enum_dom_groups(const char *desc, SAMR_Q_ENUM_DOM_GROUPS * q_e,
3392 prs_struct *ps, int depth)
3393 {
3394 if (q_e == NULL)
3395 return False;
3396
3397 prs_debug(ps, depth, desc, "samr_io_q_enum_dom_groups");
3398 depth++;
3399
3400 if(!prs_align(ps))
3401 return False;
3402
3403 if(!smb_io_pol_hnd("pol", &(q_e->pol), ps, depth))
3404 return False;
3405
3406 if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3407 return False;
3408 if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3409 return False;
3410
3411 return True;
3412 }
3413
3414 /*******************************************************************
3415 inits a SAMR_R_ENUM_DOM_GROUPS structure.
3416 ********************************************************************/
3417
3418 void init_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS * r_u,
3419 uint32 next_idx, uint32 num_sam_entries)
3420 {
3421 DEBUG(5, ("init_samr_r_enum_dom_groups\n"));
3422
3423 r_u->next_idx = next_idx;
3424
3425 if (num_sam_entries != 0) {
3426 r_u->ptr_entries1 = 1;
3427 r_u->ptr_entries2 = 1;
3428 r_u->num_entries2 = num_sam_entries;
3429 r_u->num_entries3 = num_sam_entries;
3430
3431 r_u->num_entries4 = num_sam_entries;
3432 } else {
3433 r_u->ptr_entries1 = 0;
3434 r_u->num_entries2 = num_sam_entries;
3435 r_u->ptr_entries2 = 1;
3436 }
3437 }
3438
3439 /*******************************************************************
3440 reads or writes a structure.
3441 ********************************************************************/
3442
3443 BOOL samr_io_r_enum_dom_groups(const char *desc, SAMR_R_ENUM_DOM_GROUPS * r_u,
3444 prs_struct *ps, int depth)
3445 {
3446 uint32 i;
3447
3448 if (r_u == NULL)
3449 return False;
3450
3451 prs_debug(ps, depth, desc, "samr_io_r_enum_dom_groups");
3452 depth++;
3453
3454 if(!prs_align(ps))
3455 return False;
3456
3457 if(!prs_uint32("next_idx ", ps, depth, &r_u->next_idx))
3458 return False;
3459 if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3460 return False;
3461
3462 if (r_u->ptr_entries1 != 0) {
3463 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3464 return False;
3465 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3466 return False;
3467 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3468 return False;
3469
3470 if (UNMARSHALLING(ps) && r_u->num_entries2) {
3471 r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3472 r_u->uni_grp_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3473 }
3474
3475 if ((r_u->sam == NULL || r_u->uni_grp_name == NULL) && r_u->num_entries2 != 0) {
3476 DEBUG(0,
3477 ("NULL pointers in SAMR_R_ENUM_DOM_GROUPS\n"));
3478 r_u->num_entries4 = 0;
3479 r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3480 return False;
3481 }
3482
3483 for (i = 0; i < r_u->num_entries2; i++) {
3484 if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
3485 return False;
3486 }
3487
3488 for (i = 0; i < r_u->num_entries2; i++) {
3489 if(!smb_io_unistr2("", &r_u->uni_grp_name[i],
3490 r_u->sam[i].hdr_name.buffer, ps, depth))
3491 return False;
3492 }
3493 }
3494
3495 if(!prs_align(ps))
3496 return False;
3497 if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3498 return False;
3499 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3500 return False;
3501
3502 return True;
3503 }
3504
3505 /*******************************************************************
3506 inits a SAMR_Q_ENUM_DOM_ALIASES structure.
3507 ********************************************************************/
3508
3509 void init_samr_q_enum_dom_aliases(SAMR_Q_ENUM_DOM_ALIASES * q_e,
3510 POLICY_HND *pol, uint32 start_idx,
3511 uint32 size)
3512 {
3513 DEBUG(5, ("init_samr_q_enum_dom_aliases\n"));
3514
3515 q_e->pol = *pol;
3516
3517 q_e->start_idx = start_idx;
3518 q_e->max_size = size;
3519 }
3520
3521
3522 /*******************************************************************
3523 reads or writes a structure.
3524 ********************************************************************/
3525
3526 BOOL samr_io_q_enum_dom_aliases(const char *desc, SAMR_Q_ENUM_DOM_ALIASES * q_e,
3527 prs_struct *ps, int depth)
3528 {
3529 if (q_e == NULL)
3530 return False;
3531
3532 prs_debug(ps, depth, desc, "samr_io_q_enum_dom_aliases");
3533 depth++;
3534
3535 if(!prs_align(ps))
3536 return False;
3537
3538 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
3539 return False;
3540
3541 if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3542 return False;
3543 if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3544 return False;
3545
3546 return True;
3547 }
3548
3549 /*******************************************************************
3550 inits a SAMR_R_ENUM_DOM_ALIASES structure.
3551 ********************************************************************/
3552
3553 void init_samr_r_enum_dom_aliases(SAMR_R_ENUM_DOM_ALIASES *r_u, uint32 next_idx, uint32 num_sam_entries)
3554 {
3555 DEBUG(5, ("init_samr_r_enum_dom_aliases\n"));
3556
3557 r_u->next_idx = next_idx;
3558
3559 if (num_sam_entries != 0) {
3560 r_u->ptr_entries1 = 1;
3561 r_u->ptr_entries2 = 1;
3562 r_u->num_entries2 = num_sam_entries;
3563 r_u->num_entries3 = num_sam_entries;
3564
3565 r_u->num_entries4 = num_sam_entries;
3566 } else {
3567 r_u->ptr_entries1 = 0;
3568 r_u->num_entries2 = num_sam_entries;
3569 r_u->ptr_entries2 = 1;
3570 }
3571 }
3572
3573 /*******************************************************************
3574 reads or writes a structure.
3575 ********************************************************************/
3576
3577 BOOL samr_io_r_enum_dom_aliases(const char *desc, SAMR_R_ENUM_DOM_ALIASES * r_u,
3578 prs_struct *ps, int depth)
3579 {
3580 uint32 i;
3581
3582 if (r_u == NULL)
3583 return False;
3584
3585 prs_debug(ps, depth, desc, "samr_io_r_enum_dom_aliases");
3586 depth++;
3587
3588 if(!prs_align(ps))
3589 return False;
3590
3591 if(!prs_uint32("next_idx ", ps, depth, &r_u->next_idx))
3592 return False;
3593 if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3594 return False;
3595
3596 if (r_u->ptr_entries1 != 0) {
3597 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3598 return False;
3599 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3600 return False;
3601 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3602 return False;
3603
3604 if (UNMARSHALLING(ps) && (r_u->num_entries2 > 0)) {
3605 r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3606 r_u->uni_grp_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3607 }
3608
3609 if (r_u->num_entries2 != 0 &&
3610 (r_u->sam == NULL || r_u->uni_grp_name == NULL)) {
3611 DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_ALIASES\n"));
3612 r_u->num_entries4 = 0;
3613 r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3614 return False;
3615 }
3616
3617 for (i = 0; i < r_u->num_entries2; i++) {
3618 if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
3619 return False;
3620 }
3621
3622 for (i = 0; i < r_u->num_entries2; i++) {
3623 if(!smb_io_unistr2("", &r_u->uni_grp_name[i],
3624 r_u->sam[i].hdr_name.buffer, ps,
3625 depth))
3626 return False;
3627 }
3628 }
3629
3630 if(!prs_align(ps))
3631 return False;
3632 if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3633 return False;
3634 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3635 return False;
3636
3637 return True;
3638 }
3639
3640 /*******************************************************************
3641 inits a ALIAS_INFO1 structure.
3642 ********************************************************************/
3643
3644 void init_samr_alias_info1(ALIAS_INFO1 * al1, char *acct_name, uint32 num_member, char *acct_desc)
3645 {
3646 DEBUG(5, ("init_samr_alias_info1\n"));
3647
3648 init_unistr4(&al1->name, acct_name, UNI_FLAGS_NONE);
3649 al1->num_member = num_member;
3650 init_unistr4(&al1->description, acct_desc, UNI_FLAGS_NONE);
3651 }
3652
3653 /*******************************************************************
3654 reads or writes a structure.
3655 ********************************************************************/
3656
3657 BOOL samr_io_alias_info1(const char *desc, ALIAS_INFO1 * al1,
3658 prs_struct *ps, int depth)
3659 {
3660 if (al1 == NULL)
3661 return False;
3662
3663 prs_debug(ps, depth, desc, "samr_io_alias_info1");
3664 depth++;
3665
3666 if(!prs_align(ps))
3667 return False;
3668
3669 if ( !prs_unistr4_hdr("name", ps, depth, &al1->name) )
3670 return False;
3671 if ( !prs_uint32("num_member", ps, depth, &al1->num_member) )
3672 return False;
3673 if ( !prs_unistr4_hdr("description", ps, depth, &al1->description) )
3674 return False;
3675
3676 if ( !prs_unistr4_str("name", ps, depth, &al1->name) )
3677 return False;
3678 if ( !prs_align(ps) )
3679 return False;
3680 if ( !prs_unistr4_str("description", ps, depth, &al1->description) )
3681 return False;
3682 if ( !prs_align(ps) )
3683 return False;
3684
3685 return True;
3686 }
3687
3688 /*******************************************************************
3689 inits a ALIAS_INFO3 structure.
3690 ********************************************************************/
3691
3692 void init_samr_alias_info3(ALIAS_INFO3 * al3, const char *acct_desc)
3693 {
3694 DEBUG(5, ("init_samr_alias_info3\n"));
3695
3696 init_unistr4(&al3->description, acct_desc, UNI_FLAGS_NONE);
3697 }
3698
3699 /*******************************************************************
3700 reads or writes a structure.
3701 ********************************************************************/
3702
3703 BOOL samr_io_alias_info3(const char *desc, ALIAS_INFO3 *al3,
3704 prs_struct *ps, int depth)
3705 {
3706 if (al3 == NULL)
3707 return False;
3708
3709 prs_debug(ps, depth, desc, "samr_io_alias_info3");
3710 depth++;
3711
3712 if(!prs_align(ps))
3713 return False;
3714
3715 if (!prs_unistr4("description", ps, depth, &al3->description))
3716 return False;
3717
3718 return True;
3719 }
3720
3721 /*******************************************************************
3722 reads or writes a structure.
3723 ********************************************************************/
3724
3725 BOOL samr_io_alias_info2(const char *desc, ALIAS_INFO2 *al2,
3726 prs_struct *ps, int depth)
3727 {
3728 if (al2 == NULL)
3729 return False;
3730
3731 prs_debug(ps, depth, desc, "samr_io_alias_info2");
3732 depth++;
3733
3734 if(!prs_align(ps))
3735 return False;
3736
3737 if (!prs_unistr4("name", ps, depth, &al2->name))
3738 return False;
3739
3740 return True;
3741 }
3742
3743 /*******************************************************************
3744 reads or writes a structure.
3745 ********************************************************************/
3746
3747 BOOL samr_alias_info_ctr(const char *desc, prs_struct *ps, int depth, ALIAS_INFO_CTR * ctr)
3748 {
3749 if ( !ctr )
3750 return False;
3751
3752 prs_debug(ps, depth, desc, "samr_alias_info_ctr");
3753 depth++;
3754
3755 if ( !prs_uint16("level", ps, depth, &ctr->level) )
3756 return False;
3757
3758 if(!prs_align(ps))
3759 return False;
3760 switch (ctr->level) {
3761 case 1:
3762 if(!samr_io_alias_info1("alias_info1", &ctr->alias.info1, ps, depth))
3763 return False;
3764 break;
3765 case 2:
3766 if(!samr_io_alias_info2("alias_info2", &ctr->alias.info2, ps, depth))
3767 return False;
3768 break;
3769 case 3:
3770 if(!samr_io_alias_info3("alias_info3", &ctr->alias.info3, ps, depth))
3771 return False;
3772 break;
3773 default:
3774 DEBUG(0,("samr_alias_info_ctr: unsupported switch level\n"));
3775 break;
3776 }
3777
3778 return True;
3779 }
3780
3781 /*******************************************************************
3782 inits a SAMR_Q_QUERY_ALIASINFO structure.
3783 ********************************************************************/
3784
3785 void init_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO * q_e,
3786 POLICY_HND *pol, uint32 switch_level)
3787 {
3788 DEBUG(5, ("init_samr_q_query_aliasinfo\n"));
3789
3790 q_e->pol = *pol;
3791 q_e->level = switch_level;
3792 }
3793
3794 /*******************************************************************
3795 reads or writes a structure.
3796 ********************************************************************/
3797
3798 BOOL samr_io_q_query_aliasinfo(const char *desc, SAMR_Q_QUERY_ALIASINFO *in,
3799 prs_struct *ps, int depth)
3800 {
3801 if ( !in )
3802 return False;
3803
3804 prs_debug(ps, depth, desc, "samr_io_q_query_aliasinfo");
3805 depth++;
3806
3807 if(!prs_align(ps))
3808 return False;
3809
3810 if ( !smb_io_pol_hnd("pol", &(in->pol), ps, depth) )
3811 return False;
3812
3813 if ( !prs_uint16("level", ps, depth, &in->level) )
3814 return False;
3815
3816 return True;
3817 }
3818
3819 /*******************************************************************
3820 inits a SAMR_R_QUERY_ALIASINFO structure.
3821 ********************************************************************/
3822
3823 void init_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *out,
3824 ALIAS_INFO_CTR * ctr, NTSTATUS status)
3825 {
3826 DEBUG(5, ("init_samr_r_query_aliasinfo\n"));
3827
3828 out->ctr = ctr;
3829 out->status = status;
3830 }
3831
3832 /*******************************************************************
3833 reads or writes a structure.
3834 ********************************************************************/
3835
3836 BOOL samr_io_r_query_aliasinfo(const char *desc, SAMR_R_QUERY_ALIASINFO *out,
3837 prs_struct *ps, int depth)
3838 {
3839 if ( !out )
3840 return False;
3841
3842 prs_debug(ps, depth, desc, "samr_io_r_query_aliasinfo");
3843 depth++;
3844
3845 if(!prs_align(ps))
3846 return False;
3847
3848 if ( !prs_pointer("alias", ps, depth, (void*)&out->ctr, sizeof(ALIAS_INFO_CTR), (PRS_POINTER_CAST)samr_alias_info_ctr))
3849 return False;
3850 if(!prs_align(ps))
3851 return False;
3852
3853 if(!prs_ntstatus("status", ps, depth, &out->status))
3854 return False;
3855
3856 return True;
3857 }
3858
3859 /*******************************************************************
3860 inits a SAMR_Q_SET_ALIASINFO structure.
3861 ********************************************************************/
3862
3863 void init_samr_q_set_aliasinfo(SAMR_Q_SET_ALIASINFO * q_u,
3864 POLICY_HND *hnd, ALIAS_INFO_CTR * ctr)
3865 {
3866 DEBUG(5, ("init_samr_q_set_aliasinfo\n"));
3867
3868 q_u->alias_pol = *hnd;
3869 q_u->ctr = *ctr;
3870 }
3871
3872 /*******************************************************************
3873 reads or writes a structure.
3874 ********************************************************************/
3875
3876 BOOL samr_io_q_set_aliasinfo(const char *desc, SAMR_Q_SET_ALIASINFO * q_u,
3877 prs_struct *ps, int depth)
3878 {
3879 if (q_u == NULL)
3880 return False;
3881
3882 prs_debug(ps, depth, desc, "samr_io_q_set_aliasinfo");
3883 depth++;
3884
3885 if(!prs_align(ps))
3886 return False;
3887
3888 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
3889 return False;
3890 if(!samr_alias_info_ctr("ctr", ps, depth, &q_u->ctr))
3891 return False;
3892
3893 return True;
3894 }
3895
3896 /*******************************************************************
3897 reads or writes a structure.
3898 ********************************************************************/
3899
3900 BOOL samr_io_r_set_aliasinfo(const char *desc, SAMR_R_SET_ALIASINFO * r_u,
3901 prs_struct *ps, int depth)
3902 {
3903 if (r_u == NULL)
3904 return False;
3905
3906 prs_debug(ps, depth, desc, "samr_io_r_set_aliasinfo");
3907 depth++;
3908
3909 if(!prs_align(ps))
3910 return False;
3911 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3912 return False;
3913
3914 return True;
3915 }
3916
3917 /*******************************************************************
3918 inits a SAMR_Q_QUERY_USERALIASES structure.
3919 ********************************************************************/
3920
3921 void init_samr_q_query_useraliases(SAMR_Q_QUERY_USERALIASES * q_u,
3922 POLICY_HND *hnd,
3923 uint32 num_sids,
3924 uint32 *ptr_sid, DOM_SID2 * sid)
3925 {
3926 DEBUG(5, ("init_samr_q_query_useraliases\n"));
3927
3928 q_u->pol = *hnd;
3929
3930 q_u->num_sids1 = num_sids;
3931 q_u->ptr = 1;
3932 q_u->num_sids2 = num_sids;
3933
3934 q_u->ptr_sid = ptr_sid;
3935 q_u->sid = sid;
3936 }
3937
3938 /*******************************************************************
3939 reads or writes a SAMR_Q_QUERY_USERALIASES structure.
3940 ********************************************************************/
3941
3942 BOOL samr_io_q_query_useraliases(const char *desc, SAMR_Q_QUERY_USERALIASES * q_u,
3943 prs_struct *ps, int depth)
3944 {
3945 fstring tmp;
3946 uint32 i;
3947
3948 if (q_u == NULL)
3949 return False;
3950
3951 prs_debug(ps, depth, desc, "samr_io_q_query_useraliases");
3952 depth++;
3953
3954 if(!prs_align(ps))
3955 return False;
3956
3957 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
3958 return False;
3959
3960 if(!prs_uint32("num_sids1", ps, depth, &q_u->num_sids1))
3961 return False;
3962 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
3963 return False;
3964
3965 if (q_u->ptr==0)
3966 return True;
3967
3968 if(!prs_uint32("num_sids2", ps, depth, &q_u->num_sids2))
3969 return False;
3970
3971 if (UNMARSHALLING(ps) && (q_u->num_sids2 != 0)) {
3972 q_u->ptr_sid = PRS_ALLOC_MEM(ps,uint32,q_u->num_sids2);
3973 if (q_u->ptr_sid == NULL)
3974 return False;
3975
3976 q_u->sid = PRS_ALLOC_MEM(ps, DOM_SID2, q_u->num_sids2);
3977 if (q_u->sid == NULL)
3978 return False;
3979 }
3980
3981 for (i = 0; i < q_u->num_sids2; i++) {
3982 slprintf(tmp, sizeof(tmp) - 1, "ptr[%02d]", i);
3983 if(!prs_uint32(tmp, ps, depth, &q_u->ptr_sid[i]))
3984 return False;
3985 }
3986
3987 for (i = 0; i < q_u->num_sids2; i++) {
3988 if (q_u->ptr_sid[i] != 0) {
3989 slprintf(tmp, sizeof(tmp) - 1, "sid[%02d]", i);
3990 if(!smb_io_dom_sid2(tmp, &q_u->sid[i], ps, depth))
3991 return False;
3992 }
3993 }
3994
3995 return True;
3996 }
3997
3998 /*******************************************************************
3999 inits a SAMR_R_QUERY_USERALIASES structure.
4000 ********************************************************************/
4001
4002 void init_samr_r_query_useraliases(SAMR_R_QUERY_USERALIASES * r_u,
4003 uint32 num_rids, uint32 *rid,
4004 NTSTATUS status)
4005 {
4006 DEBUG(5, ("init_samr_r_query_useraliases\n"));
4007
4008 if (NT_STATUS_IS_OK(status)) {
4009 r_u->num_entries = num_rids;
4010 r_u->ptr = 1;
4011 r_u->num_entries2 = num_rids;
4012
4013 r_u->rid = rid;
4014 } else {
4015 r_u->num_entries = 0;
4016 r_u->ptr = 0;
4017 r_u->num_entries2 = 0;
4018 }
4019
4020 r_u->status = status;
4021 }
4022
4023 /*******************************************************************
4024 reads or writes a structure.
4025 ********************************************************************/
4026
4027 BOOL samr_io_rids(const char *desc, uint32 *num_rids, uint32 **rid,
4028 prs_struct *ps, int depth)
4029 {
4030 fstring tmp;
4031 uint32 i;
4032 if (rid == NULL)
4033 return False;
4034
4035 prs_debug(ps, depth, desc, "samr_io_rids");
4036 depth++;
4037
4038 if(!prs_align(ps))
4039 return False;
4040
4041 if(!prs_uint32("num_rids", ps, depth, num_rids))
4042 return False;
4043
4044 if ((*num_rids) != 0) {
4045 if (UNMARSHALLING(ps)) {
4046 /* reading */
4047 (*rid) = PRS_ALLOC_MEM(ps,uint32, *num_rids);
4048 }
4049 if ((*rid) == NULL)
4050 return False;
4051
4052 for (i = 0; i < (*num_rids); i++) {
4053 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]", i);
4054 if(!prs_uint32(tmp, ps, depth, &((*rid)[i])))
4055 return False;
4056 }
4057 }
4058
4059 return True;
4060 }
4061
4062 /*******************************************************************
4063 reads or writes a structure.
4064 ********************************************************************/
4065
4066 BOOL samr_io_r_query_useraliases(const char *desc, SAMR_R_QUERY_USERALIASES * r_u,
4067 prs_struct *ps, int depth)
4068 {
4069 if (r_u == NULL)
4070 return False;
4071
4072 prs_debug(ps, depth, desc, "samr_io_r_query_useraliases");
4073 depth++;
4074
4075 if(!prs_align(ps))
4076 return False;
4077
4078 if(!prs_uint32("num_entries", ps, depth, &r_u->num_entries))
4079 return False;
4080 if(!prs_uint32("ptr ", ps, depth, &r_u->ptr))
4081 return False;
4082
4083 if (r_u->ptr != 0) {
4084 if(!samr_io_rids("rids", &r_u->num_entries2, &r_u->rid, ps, depth))
4085 return False;
4086 }
4087
4088 if(!prs_align(ps))
4089 return False;
4090 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4091 return False;
4092
4093 return True;
4094 }
4095
4096 /*******************************************************************
4097 inits a SAMR_Q_OPEN_ALIAS structure.
4098 ********************************************************************/
4099
4100 void init_samr_q_open_alias(SAMR_Q_OPEN_ALIAS * q_u, POLICY_HND *pol,
4101 uint32 access_mask, uint32 rid)
4102 {
4103 DEBUG(5, ("init_samr_q_open_alias\n"));
4104
4105 q_u->dom_pol = *pol;
4106 q_u->access_mask = access_mask;
4107 q_u->rid_alias = rid;
4108 }
4109
4110 /*******************************************************************
4111 reads or writes a structure.
4112 ********************************************************************/
4113
4114 BOOL samr_io_q_open_alias(const char *desc, SAMR_Q_OPEN_ALIAS * q_u,
4115 prs_struct *ps, int depth)
4116 {
4117 if (q_u == NULL)
4118 return False;
4119
4120 prs_debug(ps, depth, desc, "samr_io_q_open_alias");
4121 depth++;
4122
4123 if(!prs_align(ps))
4124 return False;
4125
4126 if(!smb_io_pol_hnd("domain_pol", &q_u->dom_pol, ps, depth))
4127 return False;
4128
4129 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
4130 return False;
4131 if(!prs_uint32("rid_alias", ps, depth, &q_u->rid_alias))
4132 return False;
4133
4134 return True;
4135 }
4136
4137 /*******************************************************************
4138 reads or writes a structure.
4139 ********************************************************************/
4140
4141 BOOL samr_io_r_open_alias(const char *desc, SAMR_R_OPEN_ALIAS * r_u,
4142 prs_struct *ps, int depth)
4143 {
4144 if (r_u == NULL)
4145 return False;
4146
4147 prs_debug(ps, depth, desc, "samr_io_r_open_alias");
4148 depth++;
4149
4150 if(!prs_align(ps))
4151 return False;
4152
4153 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4154 return False;
4155
4156 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4157 return False;
4158
4159 return True;
4160 }
4161
4162 /*******************************************************************
4163 inits a SAMR_Q_LOOKUP_RIDS structure.
4164 ********************************************************************/
4165
4166 void init_samr_q_lookup_rids(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_RIDS * q_u,
4167 POLICY_HND *pol, uint32 flags,
4168 uint32 num_rids, uint32 *rid)
4169 {
4170 DEBUG(5, ("init_samr_q_lookup_rids\n"));
4171
4172 q_u->pol = *pol;
4173
4174 q_u->num_rids1 = num_rids;
4175 q_u->flags = flags;
4176 q_u->ptr = 0;
4177 q_u->num_rids2 = num_rids;
4178 if (num_rids) {
4179 q_u->rid = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids );
4180 } else {
4181 q_u->rid = NULL;
4182 }
4183 if (q_u->rid == NULL) {
4184 q_u->num_rids1 = 0;
4185 q_u->num_rids2 = 0;
4186 } else {
4187 memcpy(q_u->rid, rid, num_rids * sizeof(q_u->rid[0]));
4188 }
4189 }
4190
4191 /*******************************************************************
4192 reads or writes a structure.
4193 ********************************************************************/
4194
4195 BOOL samr_io_q_lookup_rids(const char *desc, SAMR_Q_LOOKUP_RIDS * q_u,
4196 prs_struct *ps, int depth)
4197 {
4198 uint32 i;
4199 fstring tmp;
4200
4201 if (q_u == NULL)
4202 return False;
4203
4204 prs_debug(ps, depth, desc, "samr_io_q_lookup_rids");
4205 depth++;
4206
4207 if (UNMARSHALLING(ps))
4208 ZERO_STRUCTP(q_u);
4209
4210 if(!prs_align(ps))
4211 return False;
4212
4213 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4214 return False;
4215
4216 if(!prs_uint32("num_rids1", ps, depth, &q_u->num_rids1))
4217 return False;
4218 if(!prs_uint32("flags ", ps, depth, &q_u->flags))
4219 return False;
4220 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
4221 return False;
4222 if(!prs_uint32("num_rids2", ps, depth, &q_u->num_rids2))
4223 return False;
4224
4225 if (UNMARSHALLING(ps) && (q_u->num_rids2 != 0)) {
4226 q_u->rid = PRS_ALLOC_MEM(ps, uint32, q_u->num_rids2);
4227 if (q_u->rid == NULL)
4228 return False;
4229 }
4230
4231 for (i = 0; i < q_u->num_rids2; i++) {
4232 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d] ", i);
4233 if(!prs_uint32(tmp, ps, depth, &q_u->rid[i]))
4234 return False;
4235 }
4236
4237 return True;
4238 }
4239
4240 /*******************************************************************
4241 inits a SAMR_R_LOOKUP_RIDS structure.
4242 ********************************************************************/
4243
4244 void init_samr_r_lookup_rids(SAMR_R_LOOKUP_RIDS * r_u,
4245 uint32 num_names, UNIHDR * hdr_name,
4246 UNISTR2 *uni_name, uint32 *type)
4247 {
4248 DEBUG(5, ("init_samr_r_lookup_rids\n"));
4249
4250 r_u->hdr_name = NULL;
4251 r_u->uni_name = NULL;
4252 r_u->type = NULL;
4253
4254 if (num_names != 0) {
4255 r_u->num_names1 = num_names;
4256 r_u->ptr_names = 1;
4257 r_u->num_names2 = num_names;
4258
4259 r_u->num_types1 = num_names;
4260 r_u->ptr_types = 1;
4261 r_u->num_types2 = num_names;
4262
4263 r_u->hdr_name = hdr_name;
4264 r_u->uni_name = uni_name;
4265 r_u->type = type;
4266 } else {
4267 r_u->num_names1 = num_names;
4268 r_u->ptr_names = 0;
4269 r_u->num_names2 = num_names;
4270
4271 r_u->num_types1 = num_names;
4272 r_u->ptr_types = 0;
4273 r_u->num_types2 = num_names;
4274 }
4275 }
4276
4277 /*******************************************************************
4278 reads or writes a structure.
4279 ********************************************************************/
4280
4281 BOOL samr_io_r_lookup_rids(const char *desc, SAMR_R_LOOKUP_RIDS * r_u,
4282 prs_struct *ps, int depth)
4283 {
4284 uint32 i;
4285 fstring tmp;
4286 if (r_u == NULL)
4287 return False;
4288
4289 prs_debug(ps, depth, desc, "samr_io_r_lookup_rids");
4290 depth++;
4291
4292 if(!prs_align(ps))
4293 return False;
4294
4295 if(!prs_uint32("num_names1", ps, depth, &r_u->num_names1))
4296 return False;
4297 if(!prs_uint32("ptr_names ", ps, depth, &r_u->ptr_names))
4298 return False;
4299
4300 if (r_u->ptr_names != 0) {
4301
4302 if(!prs_uint32("num_names2", ps, depth, &r_u->num_names2))
4303 return False;
4304
4305
4306 if (UNMARSHALLING(ps) && (r_u->num_names2 != 0)) {
4307 r_u->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, r_u->num_names2);
4308 if (r_u->hdr_name == NULL)
4309 return False;
4310
4311 r_u->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, r_u->num_names2);
4312 if (r_u->uni_name == NULL)
4313 return False;
4314 }
4315
4316 for (i = 0; i < r_u->num_names2; i++) {
4317 slprintf(tmp, sizeof(tmp) - 1, "hdr[%02d] ", i);
4318 if(!smb_io_unihdr("", &r_u->hdr_name[i], ps, depth))
4319 return False;
4320 }
4321 for (i = 0; i < r_u->num_names2; i++) {
4322 slprintf(tmp, sizeof(tmp) - 1, "str[%02d] ", i);
4323 if(!smb_io_unistr2("", &r_u->uni_name[i], r_u->hdr_name[i].buffer, ps, depth))
4324 return False;
4325 }
4326
4327 }
4328
4329 if(!prs_align(ps))
4330 return False;
4331 if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
4332 return False;
4333 if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
4334 return False;
4335
4336 if (r_u->ptr_types != 0) {
4337
4338 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
4339 return False;
4340
4341 if (UNMARSHALLING(ps) && (r_u->num_types2 != 0)) {
4342 r_u->type = PRS_ALLOC_MEM(ps, uint32, r_u->num_types2);
4343 if (r_u->type == NULL)
4344 return False;
4345 }
4346
4347 for (i = 0; i < r_u->num_types2; i++) {
4348 slprintf(tmp, sizeof(tmp) - 1, "type[%02d] ", i);
4349 if(!prs_uint32(tmp, ps, depth, &r_u->type[i]))
4350 return False;
4351 }
4352 }
4353
4354 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4355 return False;
4356
4357 return True;
4358 }
4359
4360 /*******************************************************************
4361 inits a SAMR_Q_OPEN_ALIAS structure.
4362 ********************************************************************/
4363
4364 void init_samr_q_delete_alias(SAMR_Q_DELETE_DOM_ALIAS * q_u, POLICY_HND *hnd)
4365 {
4366 DEBUG(5, ("init_samr_q_delete_alias\n"));
4367
4368 q_u->alias_pol = *hnd;
4369 }
4370
4371 /*******************************************************************
4372 reads or writes a structure.
4373 ********************************************************************/
4374
4375 BOOL samr_io_q_delete_alias(const char *desc, SAMR_Q_DELETE_DOM_ALIAS * q_u,
4376 prs_struct *ps, int depth)
4377 {
4378 if (q_u == NULL)
4379 return False;
4380
4381 prs_debug(ps, depth, desc, "samr_io_q_delete_alias");
4382 depth++;
4383
4384 if(!prs_align(ps))
4385 return False;
4386
4387 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4388 return False;
4389
4390 return True;
4391 }
4392
4393 /*******************************************************************
4394 reads or writes a structure.
4395 ********************************************************************/
4396
4397 BOOL samr_io_r_delete_alias(const char *desc, SAMR_R_DELETE_DOM_ALIAS * r_u,
4398 prs_struct *ps, int depth)
4399 {
4400 if (r_u == NULL)
4401 return False;
4402
4403 prs_debug(ps, depth, desc, "samr_io_r_delete_alias");
4404 depth++;
4405
4406 if(!prs_align(ps))
4407 return False;
4408
4409 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4410 return False;
4411 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4412 return False;
4413
4414 return True;
4415 }
4416
4417 /*******************************************************************
4418 inits a SAMR_Q_CREATE_DOM_ALIAS structure.
4419 ********************************************************************/
4420
4421 void init_samr_q_create_dom_alias(SAMR_Q_CREATE_DOM_ALIAS * q_u,
4422 POLICY_HND *hnd, const char *acct_desc)
4423 {
4424 DEBUG(5, ("init_samr_q_create_dom_alias\n"));
4425
4426 q_u->dom_pol = *hnd;
4427
4428 init_unistr2(&q_u->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
4429 init_uni_hdr(&q_u->hdr_acct_desc, &q_u->uni_acct_desc);
4430
4431 q_u->access_mask = MAXIMUM_ALLOWED_ACCESS;
4432 }
4433
4434 /*******************************************************************
4435 reads or writes a structure.
4436 ********************************************************************/
4437
4438 BOOL samr_io_q_create_dom_alias(const char *desc, SAMR_Q_CREATE_DOM_ALIAS * q_u,
4439 prs_struct *ps, int depth)
4440 {
4441 if (q_u == NULL)
4442 return False;
4443
4444 prs_debug(ps, depth, desc, "samr_io_q_create_dom_alias");
4445 depth++;
4446
4447 if(!prs_align(ps))
4448 return False;
4449
4450 if(!smb_io_pol_hnd("dom_pol", &q_u->dom_pol, ps, depth))
4451 return False;
4452
4453 if(!smb_io_unihdr("hdr_acct_desc", &q_u->hdr_acct_desc, ps, depth))
4454 return False;
4455 if(!smb_io_unistr2("uni_acct_desc", &q_u->uni_acct_desc,
4456 q_u->hdr_acct_desc.buffer, ps, depth))
4457 return False;
4458
4459 if(!prs_align(ps))
4460 return False;
4461 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
4462 return False;
4463
4464 return True;
4465 }
4466
4467 /*******************************************************************
4468 reads or writes a structure.
4469 ********************************************************************/
4470
4471 BOOL samr_io_r_create_dom_alias(const char *desc, SAMR_R_CREATE_DOM_ALIAS * r_u,
4472 prs_struct *ps, int depth)
4473 {
4474 if (r_u == NULL)
4475 return False;
4476
4477 prs_debug(ps, depth, desc, "samr_io_r_create_dom_alias");
4478 depth++;
4479
4480 if(!prs_align(ps))
4481 return False;
4482
4483 if(!smb_io_pol_hnd("alias_pol", &r_u->alias_pol, ps, depth))
4484 return False;
4485
4486 if(!prs_uint32("rid", ps, depth, &r_u->rid))
4487 return False;
4488
4489 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4490 return False;
4491
4492 return True;
4493 }
4494
4495 /*******************************************************************
4496 inits a SAMR_Q_ADD_ALIASMEM structure.
4497 ********************************************************************/
4498
4499 void init_samr_q_add_aliasmem(SAMR_Q_ADD_ALIASMEM * q_u, POLICY_HND *hnd,
4500 DOM_SID *sid)
4501 {
4502 DEBUG(5, ("init_samr_q_add_aliasmem\n"));
4503
4504 q_u->alias_pol = *hnd;
4505 init_dom_sid2(&q_u->sid, sid);
4506 }
4507
4508 /*******************************************************************
4509 reads or writes a structure.
4510 ********************************************************************/
4511
4512 BOOL samr_io_q_add_aliasmem(const char *desc, SAMR_Q_ADD_ALIASMEM * q_u,
4513 prs_struct *ps, int depth)
4514 {
4515 if (q_u == NULL)
4516 return False;
4517
4518 prs_debug(ps, depth, desc, "samr_io_q_add_aliasmem");
4519 depth++;
4520
4521 if(!prs_align(ps))
4522 return False;
4523
4524 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4525 return False;
4526 if(!smb_io_dom_sid2("sid ", &q_u->sid, ps, depth))
4527 return False;
4528
4529 return True;
4530 }
4531
4532 /*******************************************************************
4533 reads or writes a structure.
4534 ********************************************************************/
4535
4536 BOOL samr_io_r_add_aliasmem(const char *desc, SAMR_R_ADD_ALIASMEM * r_u,
4537 prs_struct *ps, int depth)
4538 {
4539 if (r_u == NULL)
4540 return False;
4541
4542 prs_debug(ps, depth, desc, "samr_io_r_add_aliasmem");
4543 depth++;
4544
4545 if(!prs_align(ps))
4546 return False;
4547
4548 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4549 return False;
4550
4551 return True;
4552 }
4553
4554 /*******************************************************************
4555 inits a SAMR_Q_DEL_ALIASMEM structure.
4556 ********************************************************************/
4557
4558 void init_samr_q_del_aliasmem(SAMR_Q_DEL_ALIASMEM * q_u, POLICY_HND *hnd,
4559 DOM_SID *sid)
4560 {
4561 DEBUG(5, ("init_samr_q_del_aliasmem\n"));
4562
4563 q_u->alias_pol = *hnd;
4564 init_dom_sid2(&q_u->sid, sid);
4565 }
4566
4567 /*******************************************************************
4568 reads or writes a structure.
4569 ********************************************************************/
4570
4571 BOOL samr_io_q_del_aliasmem(const char *desc, SAMR_Q_DEL_ALIASMEM * q_u,
4572 prs_struct *ps, int depth)
4573 {
4574 if (q_u == NULL)
4575 return False;
4576
4577 prs_debug(ps, depth, desc, "samr_io_q_del_aliasmem");
4578 depth++;
4579
4580 if(!prs_align(ps))
4581 return False;
4582
4583 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4584 return False;
4585 if(!smb_io_dom_sid2("sid ", &q_u->sid, ps, depth))
4586 return False;
4587
4588 return True;
4589 }
4590
4591 /*******************************************************************
4592 reads or writes a structure.
4593 ********************************************************************/
4594
4595 BOOL samr_io_r_del_aliasmem(const char *desc, SAMR_R_DEL_ALIASMEM * r_u,
4596 prs_struct *ps, int depth)
4597 {
4598 if (r_u == NULL)
4599 return False;
4600
4601 prs_debug(ps, depth, desc, "samr_io_r_del_aliasmem");
4602 depth++;
4603
4604 if(!prs_align(ps))
4605 return False;
4606
4607 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4608 return False;
4609
4610 return True;
4611 }
4612
4613 /*******************************************************************
4614 inits a SAMR_Q_DELETE_DOM_ALIAS structure.
4615 ********************************************************************/
4616
4617 void init_samr_q_delete_dom_alias(SAMR_Q_DELETE_DOM_ALIAS * q_c,
4618 POLICY_HND *hnd)
4619 {
4620 DEBUG(5, ("init_samr_q_delete_dom_alias\n"));
4621
4622 q_c->alias_pol = *hnd;
4623 }
4624
4625 /*******************************************************************
4626 reads or writes a structure.
4627 ********************************************************************/
4628
4629 BOOL samr_io_q_delete_dom_alias(const char *desc, SAMR_Q_DELETE_DOM_ALIAS * q_u,
4630 prs_struct *ps, int depth)
4631 {
4632 if (q_u == NULL)
4633 return False;
4634
4635 prs_debug(ps, depth, desc, "samr_io_q_delete_dom_alias");
4636 depth++;
4637
4638 if(!prs_align(ps))
4639 return False;
4640
4641 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4642 return False;
4643
4644 return True;
4645 }
4646
4647 /*******************************************************************
4648 inits a SAMR_R_DELETE_DOM_ALIAS structure.
4649 ********************************************************************/
4650
4651 void init_samr_r_delete_dom_alias(SAMR_R_DELETE_DOM_ALIAS * r_u,
4652 NTSTATUS status)
4653 {
4654 DEBUG(5, ("init_samr_r_delete_dom_alias\n"));
4655
4656 r_u->status = status;
4657 }
4658
4659 /*******************************************************************
4660 reads or writes a structure.
4661 ********************************************************************/
4662
4663 BOOL samr_io_r_delete_dom_alias(const char *desc, SAMR_R_DELETE_DOM_ALIAS * r_u,
4664 prs_struct *ps, int depth)
4665 {
4666 if (r_u == NULL)
4667 return False;
4668
4669 prs_debug(ps, depth, desc, "samr_io_r_delete_dom_alias");
4670 depth++;
4671
4672 if(!prs_align(ps))
4673 return False;
4674
4675 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4676 return False;
4677
4678 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4679 return False;
4680
4681 return True;
4682 }
4683
4684 /*******************************************************************
4685 inits a SAMR_Q_QUERY_ALIASMEM structure.
4686 ********************************************************************/
4687
4688 void init_samr_q_query_aliasmem(SAMR_Q_QUERY_ALIASMEM * q_c,
4689 POLICY_HND *hnd)
4690 {
4691 DEBUG(5, ("init_samr_q_query_aliasmem\n"));
4692
4693 q_c->alias_pol = *hnd;
4694 }
4695
4696 /*******************************************************************
4697 reads or writes a structure.
4698 ********************************************************************/
4699
4700 BOOL samr_io_q_query_aliasmem(const char *desc, SAMR_Q_QUERY_ALIASMEM * q_u,
4701 prs_struct *ps, int depth)
4702 {
4703 if (q_u == NULL)
4704 return False;
4705
4706 prs_debug(ps, depth, desc, "samr_io_q_query_aliasmem");
4707 depth++;
4708
4709 if(!prs_align(ps))
4710 return False;
4711
4712 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4713 return False;
4714
4715 return True;
4716 }
4717
4718 /*******************************************************************
4719 inits a SAMR_R_QUERY_ALIASMEM structure.
4720 ********************************************************************/
4721
4722 void init_samr_r_query_aliasmem(SAMR_R_QUERY_ALIASMEM * r_u,
4723 uint32 num_sids, DOM_SID2 * sid,
4724 NTSTATUS status)
4725 {
4726 DEBUG(5, ("init_samr_r_query_aliasmem\n"));
4727
4728 if (NT_STATUS_IS_OK(status)) {
4729 r_u->num_sids = num_sids;
4730 r_u->ptr = (num_sids != 0) ? 1 : 0;
4731 r_u->num_sids1 = num_sids;
4732
4733 r_u->sid = sid;
4734 } else {
4735 r_u->ptr = 0;
4736 r_u->num_sids = 0;
4737 }
4738
4739 r_u->status = status;
4740 }
4741
4742 /*******************************************************************
4743 reads or writes a structure.
4744 ********************************************************************/
4745
4746 BOOL samr_io_r_query_aliasmem(const char *desc, SAMR_R_QUERY_ALIASMEM * r_u,
4747 prs_struct *ps, int depth)
4748 {
4749 uint32 i;
4750
4751 if (r_u == NULL)
4752 return False;
4753
4754 prs_debug(ps, depth, desc, "samr_io_r_query_aliasmem");
4755 depth++;
4756
4757 if(!prs_align(ps))
4758 return False;
4759
4760 if(!prs_uint32("num_sids ", ps, depth, &r_u->num_sids))
4761 return False;
4762 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
4763 return False;
4764
4765 if (r_u->ptr != 0 && r_u->num_sids != 0) {
4766 uint32 *ptr_sid = NULL;
4767
4768 if(!prs_uint32("num_sids1", ps, depth, &r_u->num_sids1))
4769 return False;
4770
4771 /* We must always use talloc here even when marshalling. */
4772 if (r_u->num_sids1) {
4773 ptr_sid = TALLOC_ARRAY(ps->mem_ctx, uint32, r_u->num_sids1);
4774 if (!ptr_sid) {
4775 return False;
4776 }
4777 } else {
4778 ptr_sid = NULL;
4779 }
4780
4781 for (i = 0; i < r_u->num_sids1; i++) {
4782 ptr_sid[i] = 1;
4783 if(!prs_uint32("ptr_sid", ps, depth, &ptr_sid[i]))
4784 return False;
4785 }
4786
4787 if (UNMARSHALLING(ps)) {
4788 if (r_u->num_sids1) {
4789 r_u->sid = TALLOC_ARRAY(ps->mem_ctx, DOM_SID2, r_u->num_sids1);
4790 if (!r_u->sid) {
4791 return False;
4792 }
4793 } else {
4794 r_u->sid = NULL;
4795 }
4796 }
4797
4798 for (i = 0; i < r_u->num_sids1; i++) {
4799 if (ptr_sid[i] != 0) {
4800 if(!smb_io_dom_sid2("sid", &r_u->sid[i], ps, depth))
4801 return False;
4802 }
4803 }
4804 }
4805
4806 if(!prs_align(ps))
4807 return False;
4808 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4809 return False;
4810
4811 return True;
4812 }
4813
4814 /*******************************************************************
4815 inits a SAMR_Q_LOOKUP_NAMES structure.
4816 ********************************************************************/
4817
4818 NTSTATUS init_samr_q_lookup_names(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_NAMES * q_u,
4819 POLICY_HND *pol, uint32 flags,
4820 uint32 num_names, const char **name)
4821 {
4822 uint32 i;
4823
4824 DEBUG(5, ("init_samr_q_lookup_names\n"));
4825
4826 q_u->pol = *pol;
4827
4828 q_u->num_names1 = num_names;
4829 q_u->flags = flags;
4830 q_u->ptr = 0;
4831 q_u->num_names2 = num_names;
4832
4833 if (num_names) {
4834 if (!(q_u->hdr_name = TALLOC_ZERO_ARRAY(ctx, UNIHDR, num_names)))
4835 return NT_STATUS_NO_MEMORY;
4836
4837 if (!(q_u->uni_name = TALLOC_ZERO_ARRAY(ctx, UNISTR2, num_names)))
4838 return NT_STATUS_NO_MEMORY;
4839 } else {
4840 q_u->hdr_name = NULL;
4841 q_u->uni_name = NULL;
4842 }
4843
4844 for (i = 0; i < num_names; i++) {
4845 init_unistr2(&q_u->uni_name[i], name[i], UNI_FLAGS_NONE); /* unicode string for machine account */
4846 init_uni_hdr(&q_u->hdr_name[i], &q_u->uni_name[i]); /* unicode header for user_name */
4847 }
4848
4849 return NT_STATUS_OK;
4850 }
4851
4852 /*******************************************************************
4853 reads or writes a structure.
4854 ********************************************************************/
4855
4856 BOOL samr_io_q_lookup_names(const char *desc, SAMR_Q_LOOKUP_NAMES * q_u,
4857 prs_struct *ps, int depth)
4858 {
4859 uint32 i;
4860
4861 if (q_u == NULL)
4862 return False;
4863
4864 prs_debug(ps, depth, desc, "samr_io_q_lookup_names");
4865 depth++;
4866
4867 if (UNMARSHALLING(ps))
4868 ZERO_STRUCTP(q_u);
4869
4870 if(!prs_align(ps))
4871 return False;
4872
4873 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4874 return False;
4875
4876 if(!prs_uint32("num_names1", ps, depth, &q_u->num_names1))
4877 return False;
4878 if(!prs_uint32("flags ", ps, depth, &q_u->flags))
4879 return False;
4880 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
4881 return False;
4882 if(!prs_uint32("num_names2", ps, depth, &q_u->num_names2))
4883 return False;
4884
4885 if (UNMARSHALLING(ps) && (q_u->num_names2 != 0)) {
4886 q_u->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_u->num_names2);
4887 q_u->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_u->num_names2);
4888 if (!q_u->hdr_name || !q_u->uni_name)
4889 return False;
4890 }
4891
4892 for (i = 0; i < q_u->num_names2; i++) {
4893 if(!smb_io_unihdr("", &q_u->hdr_name[i], ps, depth))
4894 return False;
4895 }
4896
4897 for (i = 0; i < q_u->num_names2; i++) {
4898 if(!smb_io_unistr2("", &q_u->uni_name[i], q_u->hdr_name[i].buffer, ps, depth))
4899 return False;
4900 }
4901
4902 return True;
4903 }
4904
4905 /*******************************************************************
4906 inits a SAMR_R_LOOKUP_NAMES structure.
4907 ********************************************************************/
4908
4909 NTSTATUS init_samr_r_lookup_names(TALLOC_CTX *ctx, SAMR_R_LOOKUP_NAMES * r_u,
4910 uint32 num_rids,
4911 uint32 *rid, enum lsa_SidType *type,
4912 NTSTATUS status)
4913 {
4914 DEBUG(5, ("init_samr_r_lookup_names\n"));
4915
4916 if (NT_STATUS_IS_OK(status) && (num_rids != 0)) {
4917 uint32 i;
4918
4919 r_u->num_types1 = num_rids;
4920 r_u->ptr_types = 1;
4921 r_u->num_types2 = num_rids;
4922
4923 r_u->num_rids1 = num_rids;
4924 r_u->ptr_rids = 1;
4925 r_u->num_rids2 = num_rids;
4926
4927 if (num_rids) {
4928 if (!(r_u->rids = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids)))
4929 return NT_STATUS_NO_MEMORY;
4930 if (!(r_u->types = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids)))
4931 return NT_STATUS_NO_MEMORY;
4932 } else {
4933 r_u->rids = NULL;
4934 r_u->types = NULL;
4935 }
4936
4937 if (!r_u->rids || !r_u->types)
4938 goto empty;
4939
4940 for (i = 0; i < num_rids; i++) {
4941 r_u->rids[i] = rid[i];
4942 r_u->types[i] = type[i];
4943 }
4944 } else {
4945
4946 empty:
4947 r_u->num_types1 = 0;
4948 r_u->ptr_types = 0;
4949 r_u->num_types2 = 0;
4950
4951 r_u->num_rids1 = 0;
4952 r_u->ptr_rids = 0;
4953 r_u->num_rids2 = 0;
4954
4955 r_u->rids = NULL;
4956 r_u->types = NULL;
4957 }
4958
4959 r_u->status = status;
4960
4961 return NT_STATUS_OK;
4962 }
4963
4964 /*******************************************************************
4965 reads or writes a structure.
4966 ********************************************************************/
4967
4968 BOOL samr_io_r_lookup_names(const char *desc, SAMR_R_LOOKUP_NAMES * r_u,
4969 prs_struct *ps, int depth)
4970 {
4971 uint32 i;
4972 fstring tmp;
4973
4974 if (r_u == NULL)
4975 return False;
4976
4977 prs_debug(ps, depth, desc, "samr_io_r_lookup_names");
4978 depth++;
4979
4980 if (UNMARSHALLING(ps))
4981 ZERO_STRUCTP(r_u);
4982
4983 if(!prs_align(ps))
4984 return False;
4985
4986 if(!prs_uint32("num_rids1", ps, depth, &r_u->num_rids1))
4987 return False;
4988 if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids))
4989 return False;
4990
4991 if (r_u->ptr_rids != 0) {
4992 if(!prs_uint32("num_rids2", ps, depth, &r_u->num_rids2))
4993 return False;
4994
4995 if (r_u->num_rids2 != r_u->num_rids1) {
4996 /* RPC fault */
4997 return False;
4998 }
4999
5000 if (UNMARSHALLING(ps) && r_u->num_rids2) {
5001 r_u->rids = PRS_ALLOC_MEM(ps, uint32, r_u->num_rids2);
5002
5003 if (!r_u->rids) {
5004 DEBUG(0, ("NULL rids in samr_io_r_lookup_names\n"));
5005 return False;
5006 }
5007 }
5008
5009 for (i = 0; i < r_u->num_rids2; i++) {
5010 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d] ", i);
5011 if(!prs_uint32(tmp, ps, depth, &r_u->rids[i]))
5012 return False;
5013 }
5014 }
5015
5016 if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
5017 return False;
5018 if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
5019 return False;
5020
5021 if (r_u->ptr_types != 0) {
5022 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
5023 return False;
5024
5025 if (r_u->num_types2 != r_u->num_types1) {
5026 /* RPC fault */
5027 return False;
5028 }
5029
5030 if (UNMARSHALLING(ps) && r_u->num_types2) {
5031 r_u->types = PRS_ALLOC_MEM(ps, uint32, r_u->num_types2);
5032
5033 if (!r_u->types) {
5034 DEBUG(0, ("NULL types in samr_io_r_lookup_names\n"));
5035 return False;
5036 }
5037 }
5038
5039 for (i = 0; i < r_u->num_types2; i++) {
5040 slprintf(tmp, sizeof(tmp) - 1, "type[%02d] ", i);
5041 if(!prs_uint32(tmp, ps, depth, &r_u->types[i]))
5042 return False;
5043 }
5044 }
5045
5046 if(!prs_ntstatus("status", ps, depth, &r_u->status))
5047 return False;
5048
5049 return True;
5050 }
5051
5052 /*******************************************************************
5053 inits a SAMR_Q_DELETE_DOM_USER structure.
5054 ********************************************************************/
5055
5056 void init_samr_q_delete_dom_user(SAMR_Q_DELETE_DOM_USER * q_c,
5057 POLICY_HND *hnd)
5058 {
5059 DEBUG(5, ("init_samr_q_delete_dom_user\n"));
5060
5061 q_c->user_pol = *hnd;
5062 }
5063
5064 /*******************************************************************
5065 reads or writes a structure.
5066 ********************************************************************/
5067
5068 BOOL samr_io_q_delete_dom_user(const char *desc, SAMR_Q_DELETE_DOM_USER * q_u,
5069 prs_struct *ps, int depth)
5070 {
5071 if (q_u == NULL)
5072 return False;
5073
5074 prs_debug(ps, depth, desc, "samr_io_q_delete_dom_user");
5075 depth++;
5076
5077 if(!prs_align(ps))
5078 return False;
5079
5080 if(!smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth))
5081 return False;
5082
5083 return True;
5084 }
5085
5086 /*******************************************************************
5087 reads or writes a structure.
5088 ********************************************************************/
5089
5090 BOOL samr_io_r_delete_dom_user(const char *desc, SAMR_R_DELETE_DOM_USER * r_u,
5091 prs_struct *ps, int depth)
5092 {
5093 if (r_u == NULL)
5094 return False;
5095
5096 prs_debug(ps, depth, desc, "samr_io_r_delete_dom_user");
5097 depth++;
5098
5099 if(!prs_align(ps))
5100 return False;
5101
5102 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
5103 return False;
5104 if(!prs_ntstatus("status", ps, depth, &r_u->status))
5105 return False;
5106
5107 return True;
5108 }
5109
5110 /*******************************************************************
5111 reads or writes a structure.
5112 ********************************************************************/
5113
5114 void init_samr_q_open_user(SAMR_Q_OPEN_USER * q_u,
5115 POLICY_HND *pol,
5116 uint32 access_mask, uint32 rid)
5117 {
5118 DEBUG(5, ("samr_init_samr_q_open_user\n"));
5119
5120 q_u->domain_pol = *pol;
5121 q_u->access_mask = access_mask;
5122 q_u->user_rid = rid;
5123 }
5124
5125 /*******************************************************************
5126 reads or writes a structure.
5127 ********************************************************************/
5128
5129 BOOL samr_io_q_open_user(const char *desc, SAMR_Q_OPEN_USER * q_u,
5130 prs_struct *ps, int depth)
5131 {
5132 if (q_u == NULL)
5133 return False;
5134
5135 prs_debug(ps, depth, desc, "samr_io_q_open_user");
5136 depth++;
5137
5138 if(!prs_align(ps))
5139 return False;
5140
5141 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
5142 return False;
5143
5144 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
5145 return False;
5146 if(!prs_uint32("user_rid ", ps, depth, &q_u->user_rid))
5147 return False;
5148
5149 return True;
5150 }
5151
5152 /*******************************************************************
5153 reads or writes a structure.
5154 ********************************************************************/
5155
5156 BOOL samr_io_r_open_user(const char *desc, SAMR_R_OPEN_USER * r_u,
5157 prs_struct *ps, int depth)
5158 {
5159 if (r_u == NULL)
5160 return False;
5161
5162 prs_debug(ps, depth, desc, "samr_io_r_open_user");
5163 depth++;
5164
5165 if(!prs_align(ps))
5166 return False;
5167
5168 if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
5169 return False;
5170
5171 if(!prs_ntstatus("status", ps, depth, &r_u->status))
5172 return False;
5173
5174 return True;
5175 }
5176
5177
5178 /*******************************************************************
5179 reads or writes a structure.
5180 ********************************************************************/
5181
5182 void init_samr_q_create_user(SAMR_Q_CREATE_USER * q_u,
5183 POLICY_HND *pol,
5184 const char *name,
5185 uint32 acb_info, uint32 access_mask)
5186 {
5187 DEBUG(5, ("samr_init_samr_q_create_user\n"));
5188
5189 q_u->domain_pol = *pol;
5190
5191 init_unistr2(&q_u->uni_name, name, UNI_FLAGS_NONE);
5192 init_uni_hdr(&q_u->hdr_name, &q_u->uni_name);
5193
5194 q_u->acb_info = acb_info;
5195 q_u->access_mask = access_mask;
5196 }
5197
5198 /*******************************************************************
5199 reads or writes a structure.
5200 ********************************************************************/
5201
5202 BOOL samr_io_q_create_user(const char *desc, SAMR_Q_CREATE_USER * q_u,
5203 prs_struct *ps, int depth)
5204 {
5205 if (q_u == NULL)
5206 return False;
5207
5208 prs_debug(ps, depth, desc, "samr_io_q_create_user");
5209 depth++;
5210
5211 if(!prs_align(ps))
5212 return False;
5213
5214 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
5215 return False;
5216
5217 if(!smb_io_unihdr("hdr_name", &q_u->hdr_name, ps, depth))
5218 return False;
5219 if(!smb_io_unistr2("uni_name", &q_u->uni_name, q_u->hdr_name.buffer, ps, depth))
5220 return False;
5221
5222 if(!prs_align(ps))
5223 return False;
5224 if(!prs_uint32("acb_info ", ps, depth, &q_u->acb_info))
5225 return False;
5226 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
5227 return False;
5228
5229 return True;
5230 }
5231
5232 /*******************************************************************
5233 reads or writes a structure.
5234 ********************************************************************/
5235
5236 BOOL samr_io_r_create_user(const char *desc, SAMR_R_CREATE_USER * r_u,
5237 prs_struct *ps, int depth)
5238 {
5239 if (r_u == NULL)
5240 return False;
5241
5242 prs_debug(ps, depth, desc, "samr_io_r_create_user");
5243 depth++;
5244
5245 if(!prs_align(ps))
5246 return False;
5247
5248 if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
5249 return False;
5250
5251 if(!prs_uint32("access_granted", ps, depth, &r_u->access_granted))
5252 return False;
5253 if(!prs_uint32("user_rid ", ps, depth, &r_u->user_rid))
5254 return False;
5255 if(!prs_ntstatus("status", ps, depth, &r_u->status))
5256 return False;
5257
5258 return True;
5259 }
5260
5261 /*******************************************************************
5262 inits a SAMR_Q_QUERY_USERINFO structure.
5263 ********************************************************************/
5264
5265 void init_samr_q_query_userinfo(SAMR_Q_QUERY_USERINFO * q_u,
5266 const POLICY_HND *hnd, uint16 switch_value)
5267 {
5268 DEBUG(5, ("init_samr_q_query_userinfo\n"));
5269
5270 q_u->pol = *hnd;
5271 q_u->switch_value = switch_value;
5272 }
5273
5274 /*******************************************************************
5275 reads or writes a structure.
5276 ********************************************************************/
5277
5278 BOOL samr_io_q_query_userinfo(const char *desc, SAMR_Q_QUERY_USERINFO * q_u,
5279 prs_struct *ps, int depth)
5280 {
5281 if (q_u == NULL)
5282 return False;
5283
5284 prs_debug(ps, depth, desc, "samr_io_q_query_userinfo");
5285 depth++;
5286
5287 if(!prs_align(ps))
5288 return False;
5289
5290 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
5291 return False;
5292
5293 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value)) /* 0x0015 or 0x0011 */
5294 return False;
5295
5296 return True;
5297 }
5298
5299 /*******************************************************************
5300 reads or writes a LOGON_HRS structure.
5301 ********************************************************************/
5302
5303 static BOOL sam_io_logon_hrs(const char *desc, LOGON_HRS * hrs,
5304 prs_struct *ps, int depth)
5305 {
5306 if (hrs == NULL)
5307 return False;
5308
5309 prs_debug(ps, depth, desc, "sam_io_logon_hrs");
5310 depth++;
5311
5312 if(!prs_align(ps))
5313 return False;
5314
5315 if(!prs_uint32("maxlen", ps, depth, &hrs->max_len))
5316 return False;
5317
5318 if(!prs_uint32("offset", ps, depth, &hrs->offset))
5319 return False;
5320
5321 if(!prs_uint32("len ", ps, depth, &hrs->len))
5322 return False;
5323
5324 if (hrs->len > sizeof(hrs->hours)) {
5325 DEBUG(3, ("sam_io_logon_hrs: truncating length from %d\n", hrs->len));
5326 hrs->len = sizeof(hrs->hours);
5327 }
5328
5329 if(!prs_uint8s(False, "hours", ps, depth, hrs->hours, hrs->len))
5330 return False;
5331
5332 return True;
5333 }
5334
5335 /*******************************************************************
5336 inits a SAM_USER_INFO_18 structure.
5337 ********************************************************************/
5338
5339 void init_sam_user_info18(SAM_USER_INFO_18 * usr,
5340 const uint8 lm_pwd[16], const uint8 nt_pwd[16])
5341 {
5342 DEBUG(5, ("init_sam_user_info18\n"));
5343
5344 usr->lm_pwd_active =
5345 memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd)) ? 1 : 0;
5346 usr->nt_pwd_active =
5347 memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd)) ? 1 : 0;
5348 }
5349
5350 /*******************************************************************
5351 reads or writes a structure.
5352 ********************************************************************/
5353
5354 static BOOL sam_io_user_info18(const char *desc, SAM_USER_INFO_18 * u,
5355 prs_struct *ps, int depth)
5356 {
5357 if (u == NULL)
5358 return False;
5359
5360 prs_debug(ps, depth, desc, "samr_io_r_user_info18");
5361 depth++;
5362
5363 if(!prs_align(ps))
5364 return False;
5365
5366 if(!prs_uint8s(False, "lm_pwd", ps, depth, u->lm_pwd, sizeof(u->lm_pwd)))
5367 return False;
5368 if(!prs_uint8s(False, "nt_pwd", ps, depth, u->nt_pwd, sizeof(u->nt_pwd)))
5369 return False;
5370
5371 if(!prs_uint8("lm_pwd_active", ps, depth, &u->lm_pwd_active))
5372 return False;
5373 if(!prs_uint8("nt_pwd_active", ps, depth, &u->nt_pwd_active))
5374 return False;
5375
5376 return True;
5377 }
5378
5379 /*******************************************************************
5380 inits a SAM_USER_INFO_7 structure.
5381 ********************************************************************/
5382
5383 void init_sam_user_info7(SAM_USER_INFO_7 * usr, const char *name)
5384 {
5385 DEBUG(5, ("init_sam_user_info7\n"));
5386
5387 init_unistr2(&usr->uni_name, name, UNI_FLAGS_NONE); /* unicode string for name */
5388 init_uni_hdr(&usr->hdr_name, &usr->uni_name); /* unicode header for name */
5389
5390 }
5391
5392 /*******************************************************************
5393 reads or writes a structure.
5394 ********************************************************************/
5395
5396 static BOOL sam_io_user_info7(const char *desc, SAM_USER_INFO_7 * usr,
5397 prs_struct *ps, int depth)
5398 {
5399 if (usr == NULL)
5400 return False;
5401
5402 prs_debug(ps, depth, desc, "samr_io_r_user_info7");
5403 depth++;
5404
5405 if(!prs_align(ps))
5406 return False;
5407
5408 if(!smb_io_unihdr("unihdr", &usr->hdr_name, ps, depth))
5409 return False;
5410
5411 if(!smb_io_unistr2("unistr2", &usr->uni_name, True, ps, depth))
5412 return False;
5413
5414 return True;
5415 }
5416
5417 /*******************************************************************
5418 inits a SAM_USER_INFO_9 structure.
5419 ********************************************************************/
5420
5421 void init_sam_user_info9(SAM_USER_INFO_9 * usr, uint32 rid_group)
5422 {
5423 DEBUG(5, ("init_sam_user_info9\n"));
5424
5425 usr->rid_group = rid_group;
5426 }
5427
5428 /*******************************************************************
5429 reads or writes a structure.
5430 ********************************************************************/
5431
5432 static BOOL sam_io_user_info9(const char *desc, SAM_USER_INFO_9 * usr,
5433 prs_struct *ps, int depth)
5434 {
5435 if (usr == NULL)
5436 return False;
5437
5438 prs_debug(ps, depth, desc, "samr_io_r_user_info9");
5439 depth++;
5440
5441 if(!prs_align(ps))
5442 return False;
5443
5444 if(!prs_uint32("rid_group", ps, depth, &usr->rid_group))
5445 return False;
5446
5447 return True;
5448 }
5449
5450 /*******************************************************************
5451 inits a SAM_USER_INFO_16 structure.
5452 ********************************************************************/
5453
5454 void init_sam_user_info16(SAM_USER_INFO_16 * usr, uint32 acb_info)
5455 {
5456 DEBUG(5, ("init_sam_user_info16\n"));
5457
5458 usr->acb_info = acb_info;
5459 }
5460
5461 /*******************************************************************
5462 reads or writes a structure.
5463 ********************************************************************/
5464
5465 static BOOL sam_io_user_info16(const char *desc, SAM_USER_INFO_16 * usr,
5466 prs_struct *ps, int depth)
5467 {
5468 if (usr == NULL)
5469 return False;
5470
5471 prs_debug(ps, depth, desc, "samr_io_r_user_info16");
5472 depth++;
5473
5474 if(!prs_align(ps))
5475 return False;
5476
5477 if(!prs_uint32("acb_info", ps, depth, &usr->acb_info))
5478 return False;
5479
5480 return True;
5481 }
5482
5483 /*******************************************************************
5484 inits a SAM_USER_INFO_17 structure.
5485 ********************************************************************/
5486
5487 void init_sam_user_info17(SAM_USER_INFO_17 * usr,
5488 NTTIME * expiry,
5489 char *mach_acct,
5490 uint32 rid_user, uint32 rid_group, uint16 acct_ctrl)
5491 {
5492 DEBUG(5, ("init_sam_user_info17\n"));
5493
5494 memcpy(&usr->expiry, expiry, sizeof(usr->expiry)); /* expiry time or something? */
5495 ZERO_STRUCT(usr->padding_1); /* 0 - padding 24 bytes */
5496
5497 usr->padding_2 = 0; /* 0 - padding 4 bytes */
5498
5499 usr->ptr_1 = 1; /* pointer */
5500 ZERO_STRUCT(usr->padding_3); /* 0 - padding 32 bytes */
5501 usr->padding_4 = 0; /* 0 - padding 4 bytes */
5502
5503 usr->ptr_2 = 1; /* pointer */
5504 usr->padding_5 = 0; /* 0 - padding 4 bytes */
5505
5506 usr->ptr_3 = 1; /* pointer */
5507 ZERO_STRUCT(usr->padding_6); /* 0 - padding 32 bytes */
5508
5509 usr->rid_user = rid_user;
5510 usr->rid_group = rid_group;
5511
5512 usr->acct_ctrl = acct_ctrl;
5513 usr->unknown_3 = 0x0000;
5514
5515 usr->unknown_4 = 0x003f; /* 0x003f - 16 bit unknown */
5516 usr->unknown_5 = 0x003c; /* 0x003c - 16 bit unknown */
5517
5518 ZERO_STRUCT(usr->padding_7); /* 0 - padding 16 bytes */
5519 usr->padding_8 = 0; /* 0 - padding 4 bytes */
5520
5521 init_unistr2(&usr->uni_mach_acct, mach_acct, UNI_FLAGS_NONE); /* unicode string for machine account */
5522 init_uni_hdr(&usr->hdr_mach_acct, &usr->uni_mach_acct); /* unicode header for machine account */
5523 }
5524
5525 /*******************************************************************
5526 reads or writes a structure.
5527 ********************************************************************/
5528
5529 static BOOL sam_io_user_info17(const char *desc, SAM_USER_INFO_17 * usr,
5530 prs_struct *ps, int depth)
5531 {
5532 if (usr == NULL)
5533 return False;
5534
5535 prs_debug(ps, depth, desc, "samr_io_r_unknown_17");
5536 depth++;
5537
5538 if(!prs_align(ps))
5539 return False;
5540
5541 if(!prs_uint8s(False, "padding_0", ps, depth, usr->padding_0, sizeof(usr->padding_0)))
5542 return False;
5543
5544 if(!smb_io_time("time", &usr->expiry, ps, depth))
5545 return False;
5546
5547 if(!prs_uint8s(False, "padding_1", ps, depth, usr->padding_1, sizeof(usr->padding_1)))
5548 return False;
5549
5550 if(!smb_io_unihdr("unihdr", &usr->hdr_mach_acct, ps, depth))
5551 return False;
5552
5553 if(!prs_uint32("padding_2", ps, depth, &usr->padding_2))
5554 return False;
5555
5556 if(!prs_uint32("ptr_1 ", ps, depth, &usr->ptr_1))
5557 return False;
5558 if(!prs_uint8s(False, "padding_3", ps, depth, usr->padding_3, sizeof(usr->padding_3)))
5559 return False;
5560
5561 if(!prs_uint32("padding_4", ps, depth, &usr->padding_4))
5562 return False;
5563
5564 if(!prs_uint32("ptr_2 ", ps, depth, &usr->ptr_2))
5565 return False;
5566 if(!prs_uint32("padding_5", ps, depth, &usr->padding_5))
5567 return False;
5568
5569 if(!prs_uint32("ptr_3 ", ps, depth, &usr->ptr_3))
5570 return False;
5571 if(!prs_uint8s(False, "padding_6", ps, depth, usr->padding_6,sizeof(usr->padding_6)))
5572 return False;
5573
5574 if(!prs_uint32("rid_user ", ps, depth, &usr->rid_user))
5575 return False;
5576 if(!prs_uint32("rid_group", ps, depth, &usr->rid_group))
5577 return False;
5578 if(!prs_uint16("acct_ctrl", ps, depth, &usr->acct_ctrl))
5579 return False;
5580 if(!prs_uint16("unknown_3", ps, depth, &usr->unknown_3))
5581 return False;
5582 if(!prs_uint16("unknown_4", ps, depth, &usr->unknown_4))
5583 return False;
5584 if(!prs_uint16("unknown_5", ps, depth, &usr->unknown_5))
5585 return False;
5586
5587 if(!prs_uint8s(False, "padding_7", ps, depth, usr->padding_7, sizeof(usr->padding_7)))
5588 return False;
5589
5590 if(!prs_uint32("padding_8", ps, depth, &(usr->padding_8)))
5591 return False;
5592
5593 if(!smb_io_unistr2("unistr2", &usr->uni_mach_acct, True, ps, depth))
5594 return False;
5595
5596 if(!prs_align(ps))
5597 return False;
5598
5599 if(!prs_uint8s(False, "padding_9", ps, depth, usr->padding_9, sizeof(usr->padding_9)))
5600 return False;
5601
5602 return True;
5603 }
5604
5605 /*************************************************************************
5606 init_sam_user_infoa
5607 *************************************************************************/
5608
5609 void init_sam_user_info24(SAM_USER_INFO_24 * usr, char newpass[516],
5610 uint8 pw_len)
5611 {
5612 DEBUG(10, ("init_sam_user_info24:\n"));
5613 memcpy(usr->pass, newpass, sizeof(usr->pass));
5614 usr->pw_len = pw_len;
5615 }
5616
5617 /*******************************************************************
5618 reads or writes a structure.
5619 ********************************************************************/
5620
5621 static BOOL sam_io_user_info24(const char *desc, SAM_USER_INFO_24 * usr,
5622 prs_struct *ps, int depth)
5623 {
5624 if (usr == NULL)
5625 return False;
5626
5627 prs_debug(ps, depth, desc, "sam_io_user_info24");
5628 depth++;
5629
5630 if(!prs_align(ps))
5631 return False;
5632
5633 if(!prs_uint8s(False, "password", ps, depth, usr->pass,
5634 sizeof(usr->pass)))
5635 return False;
5636
5637 if (MARSHALLING(ps) && (usr->pw_len != 0)) {
5638 if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5639 return False;
5640 } else if (UNMARSHALLING(ps)) {
5641 if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5642 return False;
5643 }
5644
5645 return True;
5646 }
5647
5648 /*******************************************************************
5649 reads or writes a structure.
5650 ********************************************************************/
5651
5652 static BOOL sam_io_user_info26(const char *desc, SAM_USER_INFO_26 * usr,
5653 prs_struct *ps, int depth)
5654 {
5655 if (usr == NULL)
5656 return False;
5657
5658 prs_debug(ps, depth, desc, "sam_io_user_info26");
5659 depth++;
5660
5661 if(!prs_align(ps))
5662 return False;
5663
5664 if(!prs_uint8s(False, "password", ps, depth, usr->pass,
5665 sizeof(usr->pass)))
5666 return False;
5667
5668 if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5669 return False;
5670
5671 return True;
5672 }
5673
5674
5675 /*************************************************************************
5676 init_sam_user_info23
5677
5678 unknown_6 = 0x0000 04ec
5679
5680 *************************************************************************/
5681
5682 void init_sam_user_info23W(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5683 NTTIME * logoff_time, /* all zeros */
5684 NTTIME * kickoff_time, /* all zeros */
5685 NTTIME * pass_last_set_time, /* all zeros */
5686 NTTIME * pass_can_change_time, /* all zeros */
5687 NTTIME * pass_must_change_time, /* all zeros */
5688 UNISTR2 *user_name,
5689 UNISTR2 *full_name,
5690 UNISTR2 *home_dir,
5691 UNISTR2 *dir_drive,
5692 UNISTR2 *log_scr,
5693 UNISTR2 *prof_path,
5694 UNISTR2 *desc,
5695 UNISTR2 *wkstas,
5696 UNISTR2 *unk_str,
5697 UNISTR2 *mung_dial,
5698 uint32 user_rid, /* 0x0000 0000 */
5699 uint32 group_rid,
5700 uint32 acb_info,
5701 uint32 fields_present,
5702 uint16 logon_divs,
5703 LOGON_HRS * hrs,
5704 uint16 bad_password_count,
5705 uint16 logon_count,
5706 char newpass[516])
5707 {
5708 usr->logon_time = *logon_time; /* all zeros */
5709 usr->logoff_time = *logoff_time; /* all zeros */
5710 usr->kickoff_time = *kickoff_time; /* all zeros */
5711 usr->pass_last_set_time = *pass_last_set_time; /* all zeros */
5712 usr->pass_can_change_time = *pass_can_change_time; /* all zeros */
5713 usr->pass_must_change_time = *pass_must_change_time; /* all zeros */
5714
5715 ZERO_STRUCT(usr->nt_pwd);
5716 ZERO_STRUCT(usr->lm_pwd);
5717
5718 usr->user_rid = user_rid; /* 0x0000 0000 */
5719 usr->group_rid = group_rid;
5720 usr->acb_info = acb_info;
5721 usr->fields_present = fields_present; /* 09f8 27fa */
5722
5723 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5724 usr->ptr_logon_hrs = hrs ? 1 : 0;
5725
5726 if (nt_time_is_zero(pass_must_change_time)) {
5727 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5728 } else {
5729 usr->passmustchange=0;
5730 }
5731
5732 ZERO_STRUCT(usr->padding1);
5733 ZERO_STRUCT(usr->padding2);
5734
5735 usr->bad_password_count = bad_password_count;
5736 usr->logon_count = logon_count;
5737
5738 memcpy(usr->pass, newpass, sizeof(usr->pass));
5739
5740 copy_unistr2(&usr->uni_user_name, user_name);
5741 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5742
5743 copy_unistr2(&usr->uni_full_name, full_name);
5744 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5745
5746 copy_unistr2(&usr->uni_home_dir, home_dir);
5747 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5748
5749 copy_unistr2(&usr->uni_dir_drive, dir_drive);
5750 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5751
5752 copy_unistr2(&usr->uni_logon_script, log_scr);
5753 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5754
5755 copy_unistr2(&usr->uni_profile_path, prof_path);
5756 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5757
5758 copy_unistr2(&usr->uni_acct_desc, desc);
5759 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5760
5761 copy_unistr2(&usr->uni_workstations, wkstas);
5762 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5763
5764 copy_unistr2(&usr->uni_comment, unk_str);
5765 init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
5766
5767 copy_unistr2(&usr->uni_munged_dial, mung_dial);
5768 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5769
5770 if (hrs) {
5771 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5772 } else {
5773 ZERO_STRUCT(usr->logon_hrs);
5774 }
5775 }
5776
5777 /*************************************************************************
5778 init_sam_user_info23
5779
5780 unknown_6 = 0x0000 04ec
5781
5782 *************************************************************************/
5783
5784 void init_sam_user_info23A(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5785 NTTIME * logoff_time, /* all zeros */
5786 NTTIME * kickoff_time, /* all zeros */
5787 NTTIME * pass_last_set_time, /* all zeros */
5788 NTTIME * pass_can_change_time, /* all zeros */
5789 NTTIME * pass_must_change_time, /* all zeros */
5790 char *user_name, /* NULL */
5791 char *full_name,
5792 char *home_dir, char *dir_drive, char *log_scr,
5793 char *prof_path, const char *desc, char *wkstas,
5794 char *unk_str, char *mung_dial, uint32 user_rid, /* 0x0000 0000 */
5795 uint32 group_rid, uint32 acb_info,
5796 uint32 fields_present, uint16 logon_divs,
5797 LOGON_HRS * hrs, uint16 bad_password_count, uint16 logon_count,
5798 char newpass[516])
5799 {
5800 DATA_BLOB blob = base64_decode_data_blob(mung_dial);
5801
5802 usr->logon_time = *logon_time; /* all zeros */
5803 usr->logoff_time = *logoff_time; /* all zeros */
5804 usr->kickoff_time = *kickoff_time; /* all zeros */
5805 usr->pass_last_set_time = *pass_last_set_time; /* all zeros */
5806 usr->pass_can_change_time = *pass_can_change_time; /* all zeros */
5807 usr->pass_must_change_time = *pass_must_change_time; /* all zeros */
5808
5809 ZERO_STRUCT(usr->nt_pwd);
5810 ZERO_STRUCT(usr->lm_pwd);
5811
5812 usr->user_rid = user_rid; /* 0x0000 0000 */
5813 usr->group_rid = group_rid;
5814 usr->acb_info = acb_info;
5815 usr->fields_present = fields_present; /* 09f8 27fa */
5816
5817 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5818 usr->ptr_logon_hrs = hrs ? 1 : 0;
5819
5820 if (nt_time_is_zero(pass_must_change_time)) {
5821 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5822 } else {
5823 usr->passmustchange=0;
5824 }
5825
5826 ZERO_STRUCT(usr->padding1);
5827 ZERO_STRUCT(usr->padding2);
5828
5829 usr->bad_password_count = bad_password_count;
5830 usr->logon_count = logon_count;
5831
5832 memcpy(usr->pass, newpass, sizeof(usr->pass));
5833
5834 init_unistr2(&usr->uni_user_name, user_name, UNI_FLAGS_NONE);
5835 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5836
5837 init_unistr2(&usr->uni_full_name, full_name, UNI_FLAGS_NONE);
5838 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5839
5840 init_unistr2(&usr->uni_home_dir, home_dir, UNI_FLAGS_NONE);
5841 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5842
5843 init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_FLAGS_NONE);
5844 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5845
5846 init_unistr2(&usr->uni_logon_script, log_scr, UNI_FLAGS_NONE);
5847 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5848
5849 init_unistr2(&usr->uni_profile_path, prof_path, UNI_FLAGS_NONE);
5850 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5851
5852 init_unistr2(&usr->uni_acct_desc, desc, UNI_FLAGS_NONE);
5853 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5854
5855 init_unistr2(&usr->uni_workstations, wkstas, UNI_FLAGS_NONE);
5856 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5857
5858 init_unistr2(&usr->uni_comment, unk_str, UNI_FLAGS_NONE);
5859 init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
5860
5861 init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
5862 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5863
5864 data_blob_free(&blob);
5865
5866 if (hrs) {
5867 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5868 } else {
5869 ZERO_STRUCT(usr->logon_hrs);
5870 }
5871 }
5872
5873 /*******************************************************************
5874 reads or writes a structure.
5875 ********************************************************************/
5876
5877 static BOOL sam_io_user_info23(const char *desc, SAM_USER_INFO_23 * usr,
5878 prs_struct *ps, int depth)
5879 {
5880 if (usr == NULL)
5881 return False;
5882
5883 prs_debug(ps, depth, desc, "sam_io_user_info23");
5884 depth++;
5885
5886 if(!prs_align(ps))
5887 return False;
5888
5889 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
5890 return False;
5891 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
5892 return False;
5893 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
5894 return False;
5895 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps, depth))
5896 return False;
5897 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
5898 return False;
5899 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
5900 return False;
5901
5902 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
5903 return False;
5904 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
5905 return False;
5906 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
5907 return False;
5908 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
5909 return False;
5910 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
5911 return False;
5912 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
5913 return False;
5914 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
5915 return False;
5916 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
5917 return False;
5918 if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth)) /* unknown string */
5919 return False;
5920 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
5921 return False;
5922
5923 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
5924 return False;
5925 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
5926 return False;
5927
5928 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
5929 return False;
5930 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
5931 return False;
5932 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
5933 return False;
5934
5935 if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
5936 return False;
5937 if(!prs_uint16("logon_divs ", ps, depth, &usr->logon_divs)) /* logon divisions per week */
5938 return False;
5939 if(!prs_align(ps))
5940 return False;
5941 if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
5942 return False;
5943
5944 if(!prs_uint16("bad_password_count ", ps, depth, &usr->bad_password_count))
5945 return False;
5946 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count))
5947 return False;
5948
5949 if(!prs_uint8s(False, "padding1 ", ps, depth, usr->padding1, sizeof(usr->padding1)))
5950 return False;
5951 if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
5952 return False;
5953 if(!prs_uint8("padding2 ", ps, depth, &usr->padding2))
5954 return False;
5955
5956
5957 if(!prs_uint8s(False, "password ", ps, depth, usr->pass, sizeof(usr->pass)))
5958 return False;
5959
5960 /* here begins pointed-to data */
5961
5962 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
5963 return False;
5964
5965 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
5966 return False;
5967
5968 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
5969 return False;
5970
5971 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
5972 return False;
5973
5974 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
5975 return False;
5976
5977 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
5978 return False;
5979
5980 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth)) /* user desc unicode string */
5981 return False;
5982
5983 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth)) /* worksations user can log on from */
5984 return False;
5985
5986 if(!smb_io_unistr2("uni_comment ", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth)) /* unknown string */
5987 return False;
5988
5989 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
5990 return False;
5991
5992 /* ok, this is only guess-work (as usual) */
5993 if (usr->ptr_logon_hrs) {
5994 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
5995 return False;
5996 }
5997
5998 return True;
5999 }
6000
6001 /*******************************************************************
6002 reads or writes a structure.
6003 NB. This structure is *definately* incorrect. It's my best guess
6004 currently for W2K SP2. The password field is encrypted in a different
6005 way than normal... And there are definately other problems. JRA.
6006 ********************************************************************/
6007
6008 static BOOL sam_io_user_info25(const char *desc, SAM_USER_INFO_25 * usr, prs_struct *ps, int depth)
6009 {
6010 if (usr == NULL)
6011 return False;
6012
6013 prs_debug(ps, depth, desc, "sam_io_user_info25");
6014 depth++;
6015
6016 if(!prs_align(ps))
6017 return False;
6018
6019 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
6020 return False;
6021 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
6022 return False;
6023 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
6024 return False;
6025 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps, depth))
6026 return False;
6027 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
6028 return False;
6029 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
6030 return False;
6031
6032 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
6033 return False;
6034 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
6035 return False;
6036 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
6037 return False;
6038 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
6039 return False;
6040 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
6041 return False;
6042 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
6043 return False;
6044 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
6045 return False;
6046 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
6047 return False;
6048 if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth)) /* unknown string */
6049 return False;
6050 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6051 return False;
6052
6053 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6054 return False;
6055 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6056 return False;
6057
6058 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
6059 return False;
6060 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
6061 return False;
6062 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
6063 return False;
6064 if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6065 return False;
6066
6067 if(!prs_uint16("logon_divs ", ps, depth, &usr->logon_divs)) /* logon divisions per week */
6068 return False;
6069 if(!prs_align(ps))
6070 return False;
6071 if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
6072 return False;
6073
6074 if(!prs_uint16("bad_password_count ", ps, depth, &usr->bad_password_count))
6075 return False;
6076 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count))
6077 return False;
6078
6079 if(!prs_uint8s(False, "padding1 ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6080 return False;
6081 if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6082 return False;
6083 if(!prs_uint8("padding2 ", ps, depth, &usr->padding2))
6084 return False;
6085
6086
6087 if(!prs_uint8s(False, "password ", ps, depth, usr->pass, sizeof(usr->pass)))
6088 return False;
6089
6090 /* here begins pointed-to data */
6091
6092 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
6093 return False;
6094
6095 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
6096 return False;
6097
6098 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
6099 return False;
6100
6101 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
6102 return False;
6103
6104 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
6105 return False;
6106
6107 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
6108 return False;
6109
6110 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth)) /* user desc unicode string */
6111 return False;
6112
6113 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth)) /* worksations user can log on from */
6114 return False;
6115
6116 if(!smb_io_unistr2("uni_comment ", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth)) /* unknown string */
6117 return False;
6118
6119 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
6120 return False;
6121
6122 /* ok, this is only guess-work (as usual) */
6123 if (usr->ptr_logon_hrs) {
6124 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6125 return False;
6126 }
6127
6128 return True;
6129 }
6130
6131
6132 /*************************************************************************
6133 init_sam_user_info21W
6134
6135 unknown_6 = 0x0000 04ec
6136
6137 *************************************************************************/
6138
6139 void init_sam_user_info21W(SAM_USER_INFO_21 * usr,
6140 NTTIME * logon_time,
6141 NTTIME * logoff_time,
6142 NTTIME * kickoff_time,
6143 NTTIME * pass_last_set_time,
6144 NTTIME * pass_can_change_time,
6145 NTTIME * pass_must_change_time,
6146 UNISTR2 *user_name,
6147 UNISTR2 *full_name,
6148 UNISTR2 *home_dir,
6149 UNISTR2 *dir_drive,
6150 UNISTR2 *log_scr,
6151 UNISTR2 *prof_path,
6152 UNISTR2 *desc,
6153 UNISTR2 *wkstas,
6154 UNISTR2 *unk_str,
6155 UNISTR2 *mung_dial,
6156 uchar lm_pwd[16],
6157 uchar nt_pwd[16],
6158 uint32 user_rid,
6159 uint32 group_rid,
6160 uint32 acb_info,
6161 uint32 fields_present,
6162 uint16 logon_divs,
6163 LOGON_HRS * hrs,
6164 uint16 bad_password_count,
6165 uint16 logon_count)
6166 {
6167 usr->logon_time = *logon_time;
6168 usr->logoff_time = *logoff_time;
6169 usr->kickoff_time = *kickoff_time;
6170 usr->pass_last_set_time = *pass_last_set_time;
6171 usr->pass_can_change_time = *pass_can_change_time;
6172 usr->pass_must_change_time = *pass_must_change_time;
6173
6174 memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd));
6175 memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd));
6176
6177 usr->user_rid = user_rid;
6178 usr->group_rid = group_rid;
6179 usr->acb_info = acb_info;
6180 usr->fields_present = fields_present; /* 0x00ff ffff */
6181
6182 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
6183 usr->ptr_logon_hrs = hrs ? 1 : 0;
6184 usr->bad_password_count = bad_password_count;
6185 usr->logon_count = logon_count;
6186
6187 if (nt_time_is_zero(pass_must_change_time)) {
6188 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6189 } else {
6190 usr->passmustchange=0;
6191 }
6192
6193 ZERO_STRUCT(usr->padding1);
6194 ZERO_STRUCT(usr->padding2);
6195
6196 copy_unistr2(&usr->uni_user_name, user_name);
6197 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6198
6199 copy_unistr2(&usr->uni_full_name, full_name);
6200 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6201
6202 copy_unistr2(&usr->uni_home_dir, home_dir);
6203 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6204
6205 copy_unistr2(&usr->uni_dir_drive, dir_drive);
6206 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6207
6208 copy_unistr2(&usr->uni_logon_script, log_scr);
6209 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6210
6211 copy_unistr2(&usr->uni_profile_path, prof_path);
6212 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6213
6214 copy_unistr2(&usr->uni_acct_desc, desc);
6215 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6216
6217 copy_unistr2(&usr->uni_workstations, wkstas);
6218 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6219
6220 copy_unistr2(&usr->uni_comment, unk_str);
6221 init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
6222
6223 copy_unistr2(&usr->uni_munged_dial, mung_dial);
6224 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6225
6226 if (hrs) {
6227 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
6228 } else {
6229 ZERO_STRUCT(usr->logon_hrs);
6230 }
6231 }
6232
6233 /*************************************************************************
6234 init_sam_user_info21
6235
6236 unknown_6 = 0x0000 04ec
6237
6238 *************************************************************************/
6239
6240 NTSTATUS init_sam_user_info21A(SAM_USER_INFO_21 *usr, struct samu *pw, DOM_SID *domain_sid)
6241 {
6242 NTTIME logon_time, logoff_time, kickoff_time,
6243 pass_last_set_time, pass_can_change_time,
6244 pass_must_change_time;
6245
6246 time_t must_change_time;
6247 const char* user_name = pdb_get_username(pw);
6248 const char* full_name = pdb_get_fullname(pw);
6249 const char* home_dir = pdb_get_homedir(pw);
6250 const char* dir_drive = pdb_get_dir_drive(pw);
6251 const char* logon_script = pdb_get_logon_script(pw);
6252 const char* profile_path = pdb_get_profile_path(pw);
6253 const char* description = pdb_get_acct_desc(pw);
6254 const char* workstations = pdb_get_workstations(pw);
6255 const char* munged_dial = pdb_get_munged_dial(pw);
6256 DATA_BLOB munged_dial_blob;
6257
6258 uint32 user_rid;
6259 const DOM_SID *user_sid;
6260
6261 uint32 group_rid;
6262 const DOM_SID *group_sid;
6263
6264 if (munged_dial) {
6265 munged_dial_blob = base64_decode_data_blob(munged_dial);
6266 } else {
6267 munged_dial_blob = data_blob(NULL, 0);
6268 }
6269
6270 /* Create NTTIME structs */
6271 unix_to_nt_time (&logon_time, pdb_get_logon_time(pw));
6272 unix_to_nt_time (&logoff_time, pdb_get_logoff_time(pw));
6273 unix_to_nt_time (&kickoff_time, pdb_get_kickoff_time(pw));
6274 unix_to_nt_time (&pass_last_set_time, pdb_get_pass_last_set_time(pw));
6275 unix_to_nt_time (&pass_can_change_time,pdb_get_pass_can_change_time(pw));
6276 must_change_time = pdb_get_pass_must_change_time(pw);
6277 if (must_change_time == get_time_t_max())
6278 unix_to_nt_time_abs(&pass_must_change_time, must_change_time);
6279 else
6280 unix_to_nt_time(&pass_must_change_time, must_change_time);
6281
6282 /* structure assignment */
6283 usr->logon_time = logon_time;
6284 usr->logoff_time = logoff_time;
6285 usr->kickoff_time = kickoff_time;
6286 usr->pass_last_set_time = pass_last_set_time;
6287 usr->pass_can_change_time = pass_can_change_time;
6288 usr->pass_must_change_time = pass_must_change_time;
6289
6290 ZERO_STRUCT(usr->nt_pwd);
6291 ZERO_STRUCT(usr->lm_pwd);
6292
6293 user_sid = pdb_get_user_sid(pw);
6294
6295 if (!sid_peek_check_rid(domain_sid, user_sid, &user_rid)) {
6296 fstring user_sid_string;
6297 fstring domain_sid_string;
6298 DEBUG(0, ("init_sam_user_info_21A: User %s has SID %s, \nwhich conflicts with "
6299 "the domain sid %s. Failing operation.\n",
6300 user_name,
6301 sid_to_string(user_sid_string, user_sid),
6302 sid_to_string(domain_sid_string, domain_sid)));
6303 data_blob_free(&munged_dial_blob);
6304 return NT_STATUS_UNSUCCESSFUL;
6305 }
6306
6307 become_root();
6308 group_sid = pdb_get_group_sid(pw);
6309 unbecome_root();
6310
6311 if (!sid_peek_check_rid(domain_sid, group_sid, &group_rid)) {
6312 fstring group_sid_string;
6313 fstring domain_sid_string;
6314 DEBUG(0, ("init_sam_user_info_21A: User %s has Primary Group SID %s, \n"
6315 "which conflicts with the domain sid %s. Failing operation.\n",
6316 user_name,
6317 sid_to_string(group_sid_string, group_sid),
6318 sid_to_string(domain_sid_string, domain_sid)));
6319 data_blob_free(&munged_dial_blob);
6320 return NT_STATUS_UNSUCCESSFUL;
6321 }
6322
6323 usr->user_rid = user_rid;
6324 usr->group_rid = group_rid;
6325 usr->acb_info = pdb_get_acct_ctrl(pw);
6326
6327 /*
6328 Look at a user on a real NT4 PDC with usrmgr, press
6329 'ok'. Then you will see that fields_present is set to
6330 0x08f827fa. Look at the user immediately after that again,
6331 and you will see that 0x00fffff is returned. This solves
6332 the problem that you get access denied after having looked
6333 at the user.
6334 -- Volker
6335 */
6336 usr->fields_present = pdb_build_fields_present(pw);
6337
6338 usr->logon_divs = pdb_get_logon_divs(pw);
6339 usr->ptr_logon_hrs = pdb_get_hours(pw) ? 1 : 0;
6340 usr->bad_password_count = pdb_get_bad_password_count(pw);
6341 usr->logon_count = pdb_get_logon_count(pw);
6342
6343 if (pdb_get_pass_must_change_time(pw) == 0) {
6344 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6345 } else {
6346 usr->passmustchange=0;
6347 }
6348
6349 ZERO_STRUCT(usr->padding1);
6350 ZERO_STRUCT(usr->padding2);
6351
6352 init_unistr2(&usr->uni_user_name, user_name, UNI_STR_TERMINATE);
6353 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6354
6355 init_unistr2(&usr->uni_full_name, full_name, UNI_STR_TERMINATE);
6356 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6357
6358 init_unistr2(&usr->uni_home_dir, home_dir, UNI_STR_TERMINATE);
6359 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6360
6361 init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_STR_TERMINATE);
6362 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6363
6364 init_unistr2(&usr->uni_logon_script, logon_script, UNI_STR_TERMINATE);
6365 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6366
6367 init_unistr2(&usr->uni_profile_path, profile_path, UNI_STR_TERMINATE);
6368 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6369
6370 init_unistr2(&usr->uni_acct_desc, description, UNI_STR_TERMINATE);
6371 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6372
6373 init_unistr2(&usr->uni_workstations, workstations, UNI_STR_TERMINATE);
6374 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6375
6376 init_unistr2(&usr->uni_comment, NULL, UNI_STR_TERMINATE);
6377 init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
6378
6379 init_unistr2_from_datablob(&usr->uni_munged_dial, &munged_dial_blob);
6380 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6381 data_blob_free(&munged_dial_blob);
6382
6383 if (pdb_get_hours(pw)) {
6384 usr->logon_hrs.max_len = 1260;
6385 usr->logon_hrs.offset = 0;
6386 usr->logon_hrs.len = pdb_get_hours_len(pw);
6387 memcpy(&usr->logon_hrs.hours, pdb_get_hours(pw), MAX_HOURS_LEN);
6388 } else {
6389 usr->logon_hrs.max_len = 1260;
6390 usr->logon_hrs.offset = 0;
6391 usr->logon_hrs.len = 0;
6392 memset(&usr->logon_hrs, 0xff, sizeof(usr->logon_hrs));
6393 }
6394
6395 return NT_STATUS_OK;
6396 }
6397
6398 /*******************************************************************
6399 reads or writes a structure.
6400 ********************************************************************/
6401
6402 static BOOL sam_io_user_info21(const char *desc, SAM_USER_INFO_21 * usr,
6403 prs_struct *ps, int depth)
6404 {
6405 if (usr == NULL)
6406 return False;
6407
6408 prs_debug(ps, depth, desc, "sam_io_user_info21");
6409 depth++;
6410
6411 if(!prs_align(ps))
6412 return False;
6413
6414 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
6415 return False;
6416 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
6417 return False;
6418 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps,depth))
6419 return False;
6420 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
6421 return False;
6422 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps,depth))
6423 return False;
6424 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
6425 return False;
6426
6427 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
6428 return False;
6429 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
6430 return False;
6431 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
6432 return False;
6433 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
6434 return False;
6435 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
6436 return False;
6437 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
6438 return False;
6439 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
6440 return False;
6441 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
6442 return False;
6443 if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth)) /* unknown string */
6444 return False;
6445 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6446 return False;
6447
6448 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6449 return False;
6450 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6451 return False;
6452
6453 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
6454 return False;
6455 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
6456 return False;
6457 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
6458 return False;
6459
6460 if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6461 return False;
6462 if(!prs_uint16("logon_divs ", ps, depth, &usr->logon_divs)) /* logon divisions per week */
6463 return False;
6464 if(!prs_align(ps))
6465 return False;
6466 if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
6467 return False;
6468
6469 if(!prs_uint16("bad_password_count ", ps, depth, &usr->bad_password_count))
6470 return False;
6471 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count))
6472 return False;
6473
6474 if(!prs_uint8s(False, "padding1 ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6475 return False;
6476 if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6477 return False;
6478 if(!prs_uint8("padding2 ", ps, depth, &usr->padding2))
6479 return False;
6480
6481 /* here begins pointed-to data */
6482
6483 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name,usr->hdr_user_name.buffer, ps, depth))
6484 return False;
6485 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))
6486 return False;
6487 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))
6488 return False;
6489 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))
6490 return False;
6491 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))
6492 return False;
6493 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))
6494 return False;
6495 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))
6496 return False;
6497 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))
6498 return False;
6499 if(!smb_io_unistr2("uni_comment", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth))
6500 return False;
6501 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth))
6502 return False;
6503
6504 /* ok, this is only guess-work (as usual) */
6505 if (usr->ptr_logon_hrs) {
6506 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6507 return False;
6508 }
6509
6510 return True;
6511 }
6512
6513 void init_sam_user_info20A(SAM_USER_INFO_20 *usr, struct samu *pw)
6514 {
6515 const char *munged_dial = pdb_get_munged_dial(pw);
6516 DATA_BLOB blob;
6517
6518 if (munged_dial) {
6519 blob = base64_decode_data_blob(munged_dial);
6520 } else {
6521 blob = data_blob(NULL, 0);
6522 }
6523
6524 init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
6525 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6526 data_blob_free(&blob);
6527 }
6528
6529 /*******************************************************************
6530 reads or writes a structure.
6531 ********************************************************************/
6532
6533 static BOOL sam_io_user_info20(const char *desc, SAM_USER_INFO_20 *usr,
6534 prs_struct *ps, int depth)
6535 {
6536 if (usr == NULL)
6537 return False;
6538
6539 prs_debug(ps, depth, desc, "sam_io_user_info20");
6540 depth++;
6541
6542 if(!prs_align(ps))
6543 return False;
6544
6545 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6546 return False;
6547
6548 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth)) /* worksations user can log on from */
6549 return False;
6550
6551 return True;
6552 }
6553
6554 /*******************************************************************
6555 inits a SAM_USERINFO_CTR structure.
6556 ********************************************************************/
6557
6558 NTSTATUS make_samr_userinfo_ctr_usr21(TALLOC_CTX *ctx, SAM_USERINFO_CTR * ctr,
6559 uint16 switch_value,
6560 SAM_USER_INFO_21 * usr)
6561 {
6562 DEBUG(5, ("make_samr_userinfo_ctr_usr21\n"));
6563
6564 ctr->switch_value = switch_value;
6565 ctr->info.id = NULL;
6566
6567 switch (switch_value) {
6568 case 16:
6569 ctr->info.id16 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_16);
6570 if (ctr->info.id16 == NULL)
6571 return NT_STATUS_NO_MEMORY;
6572
6573 init_sam_user_info16(ctr->info.id16, usr->acb_info);
6574 break;
6575 #if 0
6576 /* whoops - got this wrong. i think. or don't understand what's happening. */
6577 case 17:
6578 {
6579 NTTIME expire;
6580 info = (void *)&id11;
6581
6582 expire.low = 0xffffffff;
6583 expire.high = 0x7fffffff;
6584
6585 ctr->info.id = TALLOC_ZERO_P(ctx,SAM_USER_INFO_17);
6586 init_sam_user_info11(ctr->info.id17, &expire,
6587 "BROOKFIELDS$", /* name */
6588 0x03ef, /* user rid */
6589 0x201, /* group rid */
6590 0x0080); /* acb info */
6591
6592 break;
6593 }
6594 #endif
6595 case 18:
6596 ctr->info.id18 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_18);
6597 if (ctr->info.id18 == NULL)
6598 return NT_STATUS_NO_MEMORY;
6599
6600 init_sam_user_info18(ctr->info.id18, usr->lm_pwd, usr->nt_pwd);
6601 break;
6602 case 21:
6603 {
6604 SAM_USER_INFO_21 *cusr;
6605 cusr = TALLOC_ZERO_P(ctx,SAM_USER_INFO_21);
6606 ctr->info.id21 = cusr;
6607 if (ctr->info.id21 == NULL)
6608 return NT_STATUS_NO_MEMORY;
6609 memcpy(cusr, usr, sizeof(*usr));
6610 memset(cusr->lm_pwd, 0, sizeof(cusr->lm_pwd));
6611 memset(cusr->nt_pwd, 0, sizeof(cusr->nt_pwd));
6612 break;
6613 }
6614 default:
6615 DEBUG(4,("make_samr_userinfo_ctr: unsupported info\n"));
6616 return NT_STATUS_INVALID_INFO_CLASS;
6617 }
6618
6619 return NT_STATUS_OK;
6620 }
6621
6622 /*******************************************************************
6623 inits a SAM_USERINFO_CTR structure.
6624 ********************************************************************/
6625
6626 static void init_samr_userinfo_ctr(SAM_USERINFO_CTR * ctr, DATA_BLOB *sess_key,
6627 uint16 switch_value, void *info)
6628 {
6629 DEBUG(5, ("init_samr_userinfo_ctr\n"));
6630
6631 ctr->switch_value = switch_value;
6632 ctr->info.id = info;
6633
6634 switch (switch_value) {
6635 case 0x18:
6636 SamOEMhashBlob(ctr->info.id24->pass, 516, sess_key);
6637 dump_data(100, (char *)sess_key->data, sess_key->length);
6638 dump_data(100, (char *)ctr->info.id24->pass, 516);
6639 break;
6640 case 0x17:
6641 SamOEMhashBlob(ctr->info.id23->pass, 516, sess_key);
6642 dump_data(100, (char *)sess_key->data, sess_key->length);
6643 dump_data(100, (char *)ctr->info.id23->pass, 516);
6644 break;
6645 case 0x07:
6646 break;
6647 default:
6648 DEBUG(4,("init_samr_userinfo_ctr: unsupported switch level: %d\n", switch_value));
6649 }
6650 }
6651
6652 /*******************************************************************
6653 reads or writes a structure.
6654 ********************************************************************/
6655
6656 static BOOL samr_io_userinfo_ctr(const char *desc, SAM_USERINFO_CTR **ppctr,
6657 prs_struct *ps, int depth)
6658 {
6659 BOOL ret;
6660 SAM_USERINFO_CTR *ctr;
6661
6662 prs_debug(ps, depth, desc, "samr_io_userinfo_ctr");
6663 depth++;
6664
6665 if (UNMARSHALLING(ps)) {
6666 ctr = PRS_ALLOC_MEM(ps,SAM_USERINFO_CTR,1);
6667 if (ctr == NULL)
6668 return False;
6669 *ppctr = ctr;
6670 } else {
6671 ctr = *ppctr;
6672 }
6673
6674 /* lkclXXXX DO NOT ALIGN BEFORE READING SWITCH VALUE! */
6675
6676 if(!prs_uint16("switch_value", ps, depth, &ctr->switch_value))
6677 return False;
6678 if(!prs_align(ps))
6679 return False;
6680
6681 ret = False;
6682
6683 switch (ctr->switch_value) {
6684 case 7:
6685 if (UNMARSHALLING(ps))
6686 ctr->info.id7 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_7,1);
6687 if (ctr->info.id7 == NULL) {
6688 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6689 return False;
6690 }
6691 ret = sam_io_user_info7("", ctr->info.id7, ps, depth);
6692 break;
6693 case 9:
6694 if (UNMARSHALLING(ps))
6695 ctr->info.id9 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_9,1);
6696 if (ctr->info.id9 == NULL) {
6697 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6698 return False;
6699 }
6700 ret = sam_io_user_info9("", ctr->info.id9, ps, depth);
6701 break;
6702 case 16:
6703 if (UNMARSHALLING(ps))
6704 ctr->info.id16 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_16,1);
6705 if (ctr->info.id16 == NULL) {
6706 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6707 return False;
6708 }
6709 ret = sam_io_user_info16("", ctr->info.id16, ps, depth);
6710 break;
6711 case 17:
6712 if (UNMARSHALLING(ps))
6713 ctr->info.id17 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_17,1);
6714
6715 if (ctr->info.id17 == NULL) {
6716 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6717 return False;
6718 }
6719 ret = sam_io_user_info17("", ctr->info.id17, ps, depth);
6720 break;
6721 case 18:
6722 if (UNMARSHALLING(ps))
6723 ctr->info.id18 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_18,1);
6724
6725 if (ctr->info.id18 == NULL) {
6726 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6727 return False;
6728 }
6729 ret = sam_io_user_info18("", ctr->info.id18, ps, depth);
6730 break;
6731 case 20:
6732 if (UNMARSHALLING(ps))
6733 ctr->info.id20 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_20,1);
6734
6735 if (ctr->info.id20 == NULL) {
6736 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6737 return False;
6738 }
6739 ret = sam_io_user_info20("", ctr->info.id20, ps, depth);
6740 break;
6741 case 21:
6742 if (UNMARSHALLING(ps))
6743 ctr->info.id21 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_21,1);
6744
6745 if (ctr->info.id21 == NULL) {
6746 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6747 return False;
6748 }
6749 ret = sam_io_user_info21("", ctr->info.id21, ps, depth);
6750 break;
6751 case 23:
6752 if (UNMARSHALLING(ps))
6753 ctr->info.id23 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_23,1);
6754
6755 if (ctr->info.id23 == NULL) {
6756 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6757 return False;
6758 }
6759 ret = sam_io_user_info23("", ctr->info.id23, ps, depth);
6760 break;
6761 case 24:
6762 if (UNMARSHALLING(ps))
6763 ctr->info.id24 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_24,1);
6764
6765 if (ctr->info.id24 == NULL) {
6766 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6767 return False;
6768 }
6769 ret = sam_io_user_info24("", ctr->info.id24, ps, depth);
6770 break;
6771 case 25:
6772 if (UNMARSHALLING(ps))
6773 ctr->info.id25 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_25,1);
6774
6775 if (ctr->info.id25 == NULL) {
6776 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6777 return False;
6778 }
6779 ret = sam_io_user_info25("", ctr->info.id25, ps, depth);
6780 break;
6781 case 26:
6782 if (UNMARSHALLING(ps))
6783 ctr->info.id26 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_26,1);
6784
6785 if (ctr->info.id26 == NULL) {
6786 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6787 return False;
6788 }
6789 ret = sam_io_user_info26("", ctr->info.id26, ps, depth);
6790 break;
6791 default:
6792 DEBUG(2, ("samr_io_userinfo_ctr: unknown switch level 0x%x\n", ctr->switch_value));
6793 ret = False;
6794 break;
6795 }
6796
6797 return ret;
6798 }
6799
6800 /*******************************************************************
6801 inits a SAMR_R_QUERY_USERINFO structure.
6802 ********************************************************************/
6803
6804 void init_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO * r_u,
6805 SAM_USERINFO_CTR * ctr, NTSTATUS status)
6806 {
6807 DEBUG(5, ("init_samr_r_query_userinfo\n"));
6808
6809 r_u->ptr = 0;
6810 r_u->ctr = NULL;
6811
6812 if (NT_STATUS_IS_OK(status)) {
6813 r_u->ptr = 1;
6814 r_u->ctr = ctr;
6815 }
6816
6817 r_u->status = status; /* return status */
6818 }
6819
6820 /*******************************************************************
6821 reads or writes a structure.
6822 ********************************************************************/
6823
6824 BOOL samr_io_r_query_userinfo(const char *desc, SAMR_R_QUERY_USERINFO * r_u,
6825 prs_struct *ps, int depth)
6826 {
6827 if (r_u == NULL)
6828 return False;
6829
6830 prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
6831 depth++;
6832
6833 if(!prs_align(ps))
6834 return False;
6835
6836 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
6837 return False;
6838
6839 if (r_u->ptr != 0) {
6840 if(!samr_io_userinfo_ctr("ctr", &r_u->ctr, ps, depth))
6841 return False;
6842 }
6843
6844 if(!prs_align(ps))
6845 return False;
6846 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6847 return False;
6848
6849 return True;
6850 }
6851
6852 /*******************************************************************
6853 inits a SAMR_Q_SET_USERINFO structure.
6854 ********************************************************************/
6855
6856 void init_samr_q_set_userinfo(SAMR_Q_SET_USERINFO * q_u,
6857 const POLICY_HND *hnd, DATA_BLOB *sess_key,
6858 uint16 switch_value, void *info)
6859 {
6860 DEBUG(5, ("init_samr_q_set_userinfo\n"));
6861
6862 q_u->pol = *hnd;
6863 q_u->switch_value = switch_value;
6864 init_samr_userinfo_ctr(q_u->ctr, sess_key, switch_value, info);
6865 }
6866
6867 /*******************************************************************
6868 reads or writes a structure.
6869 ********************************************************************/
6870
6871 BOOL samr_io_q_set_userinfo(const char *desc, SAMR_Q_SET_USERINFO * q_u,
6872 prs_struct *ps, int depth)
6873 {
6874 if (q_u == NULL)
6875 return False;
6876
6877 prs_debug(ps, depth, desc, "samr_io_q_set_userinfo");
6878 depth++;
6879
6880 if(!prs_align(ps))
6881 return False;
6882
6883 smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
6884
6885 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6886 return False;
6887 if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6888 return False;
6889
6890 return True;
6891 }
6892
6893 /*******************************************************************
6894 inits a SAMR_R_SET_USERINFO structure.
6895 ********************************************************************/
6896
6897 void init_samr_r_set_userinfo(SAMR_R_SET_USERINFO * r_u, NTSTATUS status)
6898 {
6899 DEBUG(5, ("init_samr_r_set_userinfo\n"));
6900
6901 r_u->status = status; /* return status */
6902 }
6903
6904 /*******************************************************************
6905 reads or writes a structure.
6906 ********************************************************************/
6907
6908 BOOL samr_io_r_set_userinfo(const char *desc, SAMR_R_SET_USERINFO * r_u,
6909 prs_struct *ps, int depth)
6910 {
6911 if (r_u == NULL)
6912 return False;
6913
6914 prs_debug(ps, depth, desc, "samr_io_r_set_userinfo");
6915 depth++;
6916
6917 if(!prs_align(ps))
6918 return False;
6919
6920 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6921 return False;
6922
6923 return True;
6924 }
6925
6926 /*******************************************************************
6927 inits a SAMR_Q_SET_USERINFO2 structure.
6928 ********************************************************************/
6929
6930 void init_samr_q_set_userinfo2(SAMR_Q_SET_USERINFO2 * q_u,
6931 const POLICY_HND *hnd, DATA_BLOB *sess_key,
6932 uint16 switch_value, SAM_USERINFO_CTR * ctr)
6933 {
6934 DEBUG(5, ("init_samr_q_set_userinfo2\n"));
6935
6936 q_u->pol = *hnd;
6937 q_u->switch_value = switch_value;
6938 q_u->ctr = ctr;
6939
6940 q_u->ctr->switch_value = switch_value;
6941
6942 switch (switch_value) {
6943 case 18:
6944 SamOEMhashBlob(ctr->info.id18->lm_pwd, 16, sess_key);
6945 SamOEMhashBlob(ctr->info.id18->nt_pwd, 16, sess_key);
6946 dump_data(100, (char *)sess_key->data, sess_key->length);
6947 dump_data(100, (char *)ctr->info.id18->lm_pwd, 16);
6948 dump_data(100, (char *)ctr->info.id18->nt_pwd, 16);
6949 break;
6950 }
6951 }
6952
6953 /*******************************************************************
6954 reads or writes a structure.
6955 ********************************************************************/
6956
6957 BOOL samr_io_q_set_userinfo2(const char *desc, SAMR_Q_SET_USERINFO2 * q_u,
6958 prs_struct *ps, int depth)
6959 {
6960 if (q_u == NULL)
6961 return False;
6962
6963 prs_debug(ps, depth, desc, "samr_io_q_set_userinfo2");
6964 depth++;
6965
6966 if(!prs_align(ps))
6967 return False;
6968
6969 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
6970 return False;
6971
6972 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6973 return False;
6974 if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6975 return False;
6976
6977 return True;
6978 }
6979
6980 /*******************************************************************
6981 inits a SAMR_R_SET_USERINFO2 structure.
6982 ********************************************************************/
6983
6984 void init_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2 * r_u, NTSTATUS status)
6985 {
6986 DEBUG(5, ("init_samr_r_set_userinfo2\n"));
6987
6988 r_u->status = status; /* return status */
6989 }
6990
6991 /*******************************************************************
6992 reads or writes a structure.
6993 ********************************************************************/
6994
6995 BOOL samr_io_r_set_userinfo2(const char *desc, SAMR_R_SET_USERINFO2 * r_u,
6996 prs_struct *ps, int depth)
6997 {
6998 if (r_u == NULL)
6999 return False;
7000
7001 prs_debug(ps, depth, desc, "samr_io_r_set_userinfo2");
7002 depth++;
7003
7004 if(!prs_align(ps))
7005 return False;
7006
7007 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7008 return False;
7009
7010 return True;
7011 }
7012
7013 /*******************************************************************
7014 inits a SAMR_Q_CONNECT structure.
7015 ********************************************************************/
7016
7017 void init_samr_q_connect(SAMR_Q_CONNECT * q_u,
7018 char *srv_name, uint32 access_mask)
7019 {
7020 DEBUG(5, ("init_samr_q_connect\n"));
7021
7022 /* make PDC server name \\server */
7023 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7024 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7025
7026 /* example values: 0x0000 0002 */
7027 q_u->access_mask = access_mask;
7028 }
7029
7030 /*******************************************************************
7031 reads or writes a structure.
7032 ********************************************************************/
7033
7034 BOOL samr_io_q_connect(const char *desc, SAMR_Q_CONNECT * q_u,
7035 prs_struct *ps, int depth)
7036 {
7037 if (q_u == NULL)
7038 return False;
7039
7040 prs_debug(ps, depth, desc, "samr_io_q_connect");
7041 depth++;
7042
7043 if(!prs_align(ps))
7044 return False;
7045
7046 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7047 return False;
7048 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7049 return False;
7050
7051 if(!prs_align(ps))
7052 return False;
7053 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7054 return False;
7055
7056 return True;
7057 }
7058
7059 /*******************************************************************
7060 reads or writes a structure.
7061 ********************************************************************/
7062
7063 BOOL samr_io_r_connect(const char *desc, SAMR_R_CONNECT * r_u,
7064 prs_struct *ps, int depth)
7065 {
7066 if (r_u == NULL)
7067 return False;
7068
7069 prs_debug(ps, depth, desc, "samr_io_r_connect");
7070 depth++;
7071
7072 if(!prs_align(ps))
7073 return False;
7074
7075 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7076 return False;
7077
7078 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7079 return False;
7080
7081 return True;
7082 }
7083
7084 /*******************************************************************
7085 inits a SAMR_Q_CONNECT4 structure.
7086 ********************************************************************/
7087
7088 void init_samr_q_connect4(SAMR_Q_CONNECT4 * q_u,
7089 char *srv_name, uint32 access_mask)
7090 {
7091 DEBUG(5, ("init_samr_q_connect4\n"));
7092
7093 /* make PDC server name \\server */
7094 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7095 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7096
7097 /* Only value we've seen, possibly an address type ? */
7098 q_u->unk_0 = 2;
7099
7100 /* example values: 0x0000 0002 */
7101 q_u->access_mask = access_mask;
7102 }
7103
7104 /*******************************************************************
7105 reads or writes a structure.
7106 ********************************************************************/
7107
7108 BOOL samr_io_q_connect4(const char *desc, SAMR_Q_CONNECT4 * q_u,
7109 prs_struct *ps, int depth)
7110 {
7111 if (q_u == NULL)
7112 return False;
7113
7114 prs_debug(ps, depth, desc, "samr_io_q_connect4");
7115 depth++;
7116
7117 if(!prs_align(ps))
7118 return False;
7119
7120 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7121 return False;
7122 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7123 return False;
7124
7125 if(!prs_align(ps))
7126 return False;
7127 if(!prs_uint32("unk_0", ps, depth, &q_u->unk_0))
7128 return False;
7129 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7130 return False;
7131
7132 return True;
7133 }
7134
7135 /*******************************************************************
7136 reads or writes a structure.
7137 ********************************************************************/
7138
7139 BOOL samr_io_r_connect4(const char *desc, SAMR_R_CONNECT4 * r_u,
7140 prs_struct *ps, int depth)
7141 {
7142 if (r_u == NULL)
7143 return False;
7144
7145 prs_debug(ps, depth, desc, "samr_io_r_connect4");
7146 depth++;
7147
7148 if(!prs_align(ps))
7149 return False;
7150
7151 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7152 return False;
7153
7154 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7155 return False;
7156
7157 return True;
7158 }
7159
7160 /*******************************************************************
7161 inits a SAMR_Q_CONNECT5 structure.
7162 ********************************************************************/
7163
7164 void init_samr_q_connect5(SAMR_Q_CONNECT5 * q_u,
7165 char *srv_name, uint32 access_mask)
7166 {
7167 DEBUG(5, ("init_samr_q_connect5\n"));
7168
7169 /* make PDC server name \\server */
7170 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7171 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7172
7173 /* example values: 0x0000 0002 */
7174 q_u->access_mask = access_mask;
7175
7176 q_u->level = 1;
7177 q_u->info1_unk1 = 3;
7178 q_u->info1_unk2 = 0;
7179 }
7180
7181 /*******************************************************************
7182 inits a SAMR_R_CONNECT5 structure.
7183 ********************************************************************/
7184
7185 void init_samr_r_connect5(SAMR_R_CONNECT5 * r_u, POLICY_HND *pol, NTSTATUS status)
7186 {
7187 DEBUG(5, ("init_samr_q_connect5\n"));
7188
7189 r_u->level = 1;
7190 r_u->info1_unk1 = 3;
7191 r_u->info1_unk2 = 0;
7192
7193 r_u->connect_pol = *pol;
7194 r_u->status = status;
7195 }
7196
7197 /*******************************************************************
7198 reads or writes a structure.
7199 ********************************************************************/
7200
7201 BOOL samr_io_q_connect5(const char *desc, SAMR_Q_CONNECT5 * q_u,
7202 prs_struct *ps, int depth)
7203 {
7204 if (q_u == NULL)
7205 return False;
7206
7207 prs_debug(ps, depth, desc, "samr_io_q_connect5");
7208 depth++;
7209
7210 if(!prs_align(ps))
7211 return False;
7212
7213 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7214 return False;
7215 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7216 return False;
7217
7218 if(!prs_align(ps))
7219 return False;
7220 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7221 return False;
7222
7223 if(!prs_uint32("level", ps, depth, &q_u->level))
7224 return False;
7225 if(!prs_uint32("level", ps, depth, &q_u->level))
7226 return False;
7227
7228 if(!prs_uint32("info1_unk1", ps, depth, &q_u->info1_unk1))
7229 return False;
7230 if(!prs_uint32("info1_unk2", ps, depth, &q_u->info1_unk2))
7231 return False;
7232
7233 return True;
7234 }
7235
7236 /*******************************************************************
7237 reads or writes a structure.
7238 ********************************************************************/
7239
7240 BOOL samr_io_r_connect5(const char *desc, SAMR_R_CONNECT5 * r_u,
7241 prs_struct *ps, int depth)
7242 {
7243 if (r_u == NULL)
7244 return False;
7245
7246 prs_debug(ps, depth, desc, "samr_io_r_connect5");
7247 depth++;
7248
7249 if(!prs_align(ps))
7250 return False;
7251
7252 if(!prs_uint32("level", ps, depth, &r_u->level))
7253 return False;
7254 if(!prs_uint32("level", ps, depth, &r_u->level))
7255 return False;
7256 if(!prs_uint32("info1_unk1", ps, depth, &r_u->info1_unk1))
7257 return False;
7258 if(!prs_uint32("info1_unk2", ps, depth, &r_u->info1_unk2))
7259 return False;
7260
7261 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7262 return False;
7263
7264 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7265 return False;
7266
7267 return True;
7268 }
7269
7270 /*******************************************************************
7271 inits a SAMR_Q_CONNECT_ANON structure.
7272 ********************************************************************/
7273
7274 void init_samr_q_connect_anon(SAMR_Q_CONNECT_ANON * q_u)
7275 {
7276 DEBUG(5, ("init_samr_q_connect_anon\n"));
7277
7278 q_u->ptr = 1;
7279 q_u->unknown_0 = 0x5c; /* server name (?!!) */
7280 q_u->access_mask = MAXIMUM_ALLOWED_ACCESS;
7281 }
7282
7283 /*******************************************************************
7284 reads or writes a structure.
7285 ********************************************************************/
7286
7287 BOOL samr_io_q_connect_anon(const char *desc, SAMR_Q_CONNECT_ANON * q_u,
7288 prs_struct *ps, int depth)
7289 {
7290 if (q_u == NULL)
7291 return False;
7292
7293 prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
7294 depth++;
7295
7296 if(!prs_align(ps))
7297 return False;
7298
7299 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
7300 return False;
7301 if (q_u->ptr) {
7302 if(!prs_uint16("unknown_0", ps, depth, &q_u->unknown_0))
7303 return False;
7304 }
7305 if(!prs_align(ps))
7306 return False;
7307 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7308 return False;
7309
7310 return True;
7311 }
7312
7313 /*******************************************************************
7314 reads or writes a structure.
7315 ********************************************************************/
7316
7317 BOOL samr_io_r_connect_anon(const char *desc, SAMR_R_CONNECT_ANON * r_u,
7318 prs_struct *ps, int depth)
7319 {
7320 if (r_u == NULL)
7321 return False;
7322
7323 prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
7324 depth++;
7325
7326 if(!prs_align(ps))
7327 return False;
7328
7329 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7330 return False;
7331
7332 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7333 return False;
7334
7335 return True;
7336 }
7337
7338 /*******************************************************************
7339 inits a SAMR_Q_GET_DOM_PWINFO structure.
7340 ********************************************************************/
7341
7342 void init_samr_q_get_dom_pwinfo(SAMR_Q_GET_DOM_PWINFO * q_u,
7343 char *srv_name)
7344 {
7345 DEBUG(5, ("init_samr_q_get_dom_pwinfo\n"));
7346
7347 q_u->ptr = 1;
7348 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_FLAGS_NONE);
7349 init_uni_hdr(&q_u->hdr_srv_name, &q_u->uni_srv_name);
7350 }
7351
7352 /*******************************************************************
7353 reads or writes a structure.
7354 ********************************************************************/
7355
7356 BOOL samr_io_q_get_dom_pwinfo(const char *desc, SAMR_Q_GET_DOM_PWINFO * q_u,
7357 prs_struct *ps, int depth)
7358 {
7359 if (q_u == NULL)
7360 return False;
7361
7362 prs_debug(ps, depth, desc, "samr_io_q_get_dom_pwinfo");
7363 depth++;
7364
7365 if(!prs_align(ps))
7366 return False;
7367
7368 if(!prs_uint32("ptr", ps, depth, &q_u->ptr))
7369 return False;
7370 if (q_u->ptr != 0) {
7371 if(!smb_io_unihdr("", &q_u->hdr_srv_name, ps, depth))
7372 return False;
7373 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->hdr_srv_name.buffer, ps, depth))
7374 return False;
7375 }
7376
7377 return True;
7378 }
7379
7380 /*******************************************************************
7381 reads or writes a structure.
7382 ********************************************************************/
7383
7384 BOOL samr_io_r_get_dom_pwinfo(const char *desc, SAMR_R_GET_DOM_PWINFO * r_u,
7385 prs_struct *ps, int depth)
7386 {
7387 if (r_u == NULL)
7388 return False;
7389
7390 prs_debug(ps, depth, desc, "samr_io_r_get_dom_pwinfo");
7391 depth++;
7392
7393 if(!prs_align(ps))
7394 return False;
7395
7396 if(!prs_uint16("min_pwd_length", ps, depth, &r_u->min_pwd_length))
7397 return False;
7398 if(!prs_align(ps))
7399 return False;
7400 if(!prs_uint32("password_properties", ps, depth, &r_u->password_properties))
7401 return False;
7402
7403 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7404 return False;
7405
7406 return True;
7407 }
7408
7409 /*******************************************************************
7410 make a SAMR_ENC_PASSWD structure.
7411 ********************************************************************/
7412
7413 void init_enc_passwd(SAMR_ENC_PASSWD * pwd, const char pass[512])
7414 {
7415 ZERO_STRUCTP(pwd);
7416
7417 if (pass == NULL) {
7418 pwd->ptr = 0;
7419 } else {
7420 pwd->ptr = 1;
7421 memcpy(pwd->pass, pass, sizeof(pwd->pass));
7422 }
7423 }
7424
7425 /*******************************************************************
7426 reads or writes a SAMR_ENC_PASSWD structure.
7427 ********************************************************************/
7428
7429 BOOL samr_io_enc_passwd(const char *desc, SAMR_ENC_PASSWD * pwd,
7430 prs_struct *ps, int depth)
7431 {
7432 if (pwd == NULL)
7433 return False;
7434
7435 prs_debug(ps, depth, desc, "samr_io_enc_passwd");
7436 depth++;
7437
7438 if(!prs_align(ps))
7439 return False;
7440
7441 if(!prs_uint32("ptr", ps, depth, &pwd->ptr))
7442 return False;
7443
7444 if (pwd->ptr != 0) {
7445 if(!prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass)))
7446 return False;
7447 }
7448
7449 return True;
7450 }
7451
7452 /*******************************************************************
7453 inits a SAMR_ENC_HASH structure.
7454 ********************************************************************/
7455
7456 void init_enc_hash(SAMR_ENC_HASH * hsh, const uchar hash[16])
7457 {
7458 ZERO_STRUCTP(hsh);
7459
7460 if (hash == NULL) {
7461 hsh->ptr = 0;
7462 } else {
7463 hsh->ptr = 1;
7464 memcpy(hsh->hash, hash, sizeof(hsh->hash));
7465 }
7466 }
7467
7468 /*******************************************************************
7469 reads or writes a SAMR_ENC_HASH structure.
7470 ********************************************************************/
7471
7472 BOOL samr_io_enc_hash(const char *desc, SAMR_ENC_HASH * hsh,
7473 prs_struct *ps, int depth)
7474 {
7475 if (hsh == NULL)
7476 return False;
7477
7478 prs_debug(ps, depth, desc, "samr_io_enc_hash");
7479 depth++;
7480
7481 if(!prs_align(ps))
7482 return False;
7483
7484 if(!prs_uint32("ptr ", ps, depth, &hsh->ptr))
7485 return False;
7486 if (hsh->ptr != 0) {
7487 if(!prs_uint8s(False, "hash", ps, depth, hsh->hash,sizeof(hsh->hash)))
7488 return False;
7489 }
7490
7491 return True;
7492 }
7493
7494 /*******************************************************************
7495 inits a SAMR_Q_CHGPASSWD_USER structure.
7496 ********************************************************************/
7497
7498 void init_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER * q_u,
7499 const char *dest_host, const char *user_name,
7500 const uchar nt_newpass[516],
7501 const uchar nt_oldhash[16],
7502 const uchar lm_newpass[516],
7503 const uchar lm_oldhash[16])
7504 {
7505 DEBUG(5, ("init_samr_q_chgpasswd_user\n"));
7506
7507 q_u->ptr_0 = 1;
7508 init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7509 init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7510
7511 init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7512 init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7513
7514 init_enc_passwd(&q_u->nt_newpass, (const char *)nt_newpass);
7515 init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7516
7517 q_u->unknown = 0x01;
7518
7519 init_enc_passwd(&q_u->lm_newpass, (const char *)lm_newpass);
7520 init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7521 }
7522
7523 /*******************************************************************
7524 reads or writes a structure.
7525 ********************************************************************/
7526
7527 BOOL samr_io_q_chgpasswd_user(const char *desc, SAMR_Q_CHGPASSWD_USER * q_u,
7528 prs_struct *ps, int depth)
7529 {
7530 if (q_u == NULL)
7531 return False;
7532
7533 prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
7534 depth++;
7535
7536 if(!prs_align(ps))
7537 return False;
7538
7539 if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7540 return False;
7541
7542 if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7543 return False;
7544 if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7545 return False;
7546
7547 if(!prs_align(ps))
7548 return False;
7549 if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7550 return False;
7551 if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7552 return False;
7553
7554 if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7555 return False;
7556 if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7557 return False;
7558
7559 if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
7560 return False;
7561
7562 if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7563 return False;
7564 if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7565 return False;
7566
7567 return True;
7568 }
7569
7570 /*******************************************************************
7571 inits a SAMR_R_CHGPASSWD_USER structure.
7572 ********************************************************************/
7573
7574 void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER * r_u, NTSTATUS status)
7575 {
7576 DEBUG(5, ("init_samr_r_chgpasswd_user\n"));
7577
7578 r_u->status = status;
7579 }
7580
7581 /*******************************************************************
7582 reads or writes a structure.
7583 ********************************************************************/
7584
7585 BOOL samr_io_r_chgpasswd_user(const char *desc, SAMR_R_CHGPASSWD_USER * r_u,
7586 prs_struct *ps, int depth)
7587 {
7588 if (r_u == NULL)
7589 return False;
7590
7591 prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
7592 depth++;
7593
7594 if(!prs_align(ps))
7595 return False;
7596
7597 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7598 return False;
7599
7600 return True;
7601 }
7602
7603 /*******************************************************************
7604 inits a SAMR_Q_CHGPASSWD3 structure.
7605 ********************************************************************/
7606
7607 void init_samr_q_chgpasswd_user3(SAMR_Q_CHGPASSWD_USER3 * q_u,
7608 const char *dest_host, const char *user_name,
7609 const uchar nt_newpass[516],
7610 const uchar nt_oldhash[16],
7611 const uchar lm_newpass[516],
7612 const uchar lm_oldhash[16])
7613 {
7614 DEBUG(5, ("init_samr_q_chgpasswd_user3\n"));
7615
7616 q_u->ptr_0 = 1;
7617 init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7618 init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7619
7620 init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7621 init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7622
7623 init_enc_passwd(&q_u->nt_newpass, (const char *)nt_newpass);
7624 init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7625
7626 q_u->lm_change = 0x01;
7627
7628 init_enc_passwd(&q_u->lm_newpass, (const char *)lm_newpass);
7629 init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7630
7631 init_enc_passwd(&q_u->password3, NULL);
7632 }
7633
7634 /*******************************************************************
7635 reads or writes a structure.
7636 ********************************************************************/
7637
7638 BOOL samr_io_q_chgpasswd_user3(const char *desc, SAMR_Q_CHGPASSWD_USER3 * q_u,
7639 prs_struct *ps, int depth)
7640 {
7641 if (q_u == NULL)
7642 return False;
7643
7644 prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user3");
7645 depth++;
7646
7647 if(!prs_align(ps))
7648 return False;
7649
7650 if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7651 return False;
7652
7653 if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7654 return False;
7655 if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7656 return False;
7657
7658 if(!prs_align(ps))
7659 return False;
7660 if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7661 return False;
7662 if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7663 return False;
7664
7665 if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7666 return False;
7667 if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7668 return False;
7669
7670 if(!prs_uint32("lm_change", ps, depth, &q_u->lm_change))
7671 return False;
7672
7673 if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7674 return False;
7675 if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7676 return False;
7677
7678 if(!samr_io_enc_passwd("password3", &q_u->password3, ps, depth))
7679 return False;
7680
7681 return True;
7682 }
7683
7684 /*******************************************************************
7685 inits a SAMR_R_CHGPASSWD_USER3 structure.
7686 ********************************************************************/
7687
7688 void init_samr_r_chgpasswd_user3(SAMR_R_CHGPASSWD_USER3 *r_u, NTSTATUS status,
7689 SAMR_CHANGE_REJECT *reject, SAM_UNK_INFO_1 *info)
7690 {
7691 DEBUG(5, ("init_samr_r_chgpasswd_user3\n"));
7692
7693 r_u->status = status;
7694 r_u->info = 0;
7695 r_u->ptr_info = 0;
7696 r_u->reject = 0;
7697 r_u->ptr_reject = 0;
7698
7699 if (info) {
7700 r_u->info = info;
7701 r_u->ptr_info = 1;
7702 }
7703 if (reject && (reject->reject_reason != Undefined)) {
7704 r_u->reject = reject;
7705 r_u->ptr_reject = 1;
7706 }
7707 }
7708
7709 /*******************************************************************
7710 Reads or writes an SAMR_CHANGE_REJECT structure.
7711 ********************************************************************/
7712
7713 BOOL samr_io_change_reject(const char *desc, SAMR_CHANGE_REJECT *reject, prs_struct *ps, int depth)
7714 {
7715 if (reject == NULL)
7716 return False;
7717
7718 prs_debug(ps, depth, desc, "samr_io_change_reject");
7719 depth++;
7720
7721 if(!prs_align(ps))
7722 return False;
7723
7724 if(UNMARSHALLING(ps))
7725 ZERO_STRUCTP(reject);
7726
7727 if (!prs_uint32("reject_reason", ps, depth, &reject->reject_reason))
7728 return False;
7729
7730 if (!prs_uint32("unknown1", ps, depth, &reject->unknown1))
7731 return False;
7732
7733 if (!prs_uint32("unknown2", ps, depth, &reject->unknown2))
7734 return False;
7735
7736 return True;
7737 }
7738
7739 /*******************************************************************
7740 reads or writes a structure.
7741 ********************************************************************/
7742
7743 BOOL samr_io_r_chgpasswd_user3(const char *desc, SAMR_R_CHGPASSWD_USER3 *r_u,
7744 prs_struct *ps, int depth)
7745 {
7746 if (r_u == NULL)
7747 return False;
7748
7749 prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user3");
7750 depth++;
7751
7752 if (!prs_align(ps))
7753 return False;
7754
7755 if (!prs_uint32("ptr_info", ps, depth, &r_u->ptr_info))
7756 return False;
7757
7758 /* special case: Windows 2000 can return stub data here saying
7759 NT_STATUS_NOT_SUPPORTED */
7760
7761 if ( NT_STATUS_EQUAL( NT_STATUS_NOT_SUPPORTED, NT_STATUS(r_u->ptr_info)) ) {
7762 r_u->status = NT_STATUS_NOT_SUPPORTED;
7763 return True;
7764 }
7765
7766 if (r_u->ptr_info && r_u->info != NULL) {
7767 /* SAM_UNK_INFO_1 */
7768 if (!sam_io_unk_info1("info", r_u->info, ps, depth))
7769 return False;
7770 }
7771
7772 if (!prs_uint32("ptr_reject", ps, depth, &r_u->ptr_reject))
7773 return False;
7774
7775 if (r_u->ptr_reject && r_u->reject != NULL) {
7776 /* SAMR_CHANGE_REJECT */
7777 if (!samr_io_change_reject("reject", r_u->reject, ps, depth))
7778 return False;
7779 }
7780
7781 if (!prs_ntstatus("status", ps, depth, &r_u->status))
7782 return False;
7783
7784 return True;
7785 }
7786
7787 /*******************************************************************
7788 reads or writes a structure.
7789 ********************************************************************/
7790
7791 void init_samr_q_query_domain_info2(SAMR_Q_QUERY_DOMAIN_INFO2 *q_u,
7792 POLICY_HND *domain_pol, uint16 switch_value)
7793 {
7794 DEBUG(5, ("init_samr_q_query_domain_info2\n"));
7795
7796 q_u->domain_pol = *domain_pol;
7797 q_u->switch_value = switch_value;
7798 }
7799
7800 /*******************************************************************
7801 reads or writes a structure.
7802 ********************************************************************/
7803
7804 BOOL samr_io_q_query_domain_info2(const char *desc, SAMR_Q_QUERY_DOMAIN_INFO2 *q_u,
7805 prs_struct *ps, int depth)
7806 {
7807 if (q_u == NULL)
7808 return False;
7809
7810 prs_debug(ps, depth, desc, "samr_io_q_query_domain_info2");
7811 depth++;
7812
7813 if(!prs_align(ps))
7814 return False;
7815
7816 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7817 return False;
7818
7819 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7820 return False;
7821
7822 return True;
7823 }
7824
7825 /*******************************************************************
7826 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7827 ********************************************************************/
7828
7829 void init_samr_r_query_domain_info2(SAMR_R_QUERY_DOMAIN_INFO2 * r_u,
7830 uint16 switch_value, SAM_UNK_CTR * ctr,
7831 NTSTATUS status)
7832 {
7833 DEBUG(5, ("init_samr_r_query_domain_info2\n"));
7834
7835 r_u->ptr_0 = 0;
7836 r_u->switch_value = 0;
7837 r_u->status = status; /* return status */
7838
7839 if (NT_STATUS_IS_OK(status)) {
7840 r_u->switch_value = switch_value;
7841 r_u->ptr_0 = 1;
7842 r_u->ctr = ctr;
7843 }
7844 }
7845
7846 /*******************************************************************
7847 reads or writes a structure.
7848 ********************************************************************/
7849
7850 BOOL samr_io_r_query_domain_info2(const char *desc, SAMR_R_QUERY_DOMAIN_INFO2 * r_u,
7851 prs_struct *ps, int depth)
7852 {
7853 if (r_u == NULL)
7854 return False;
7855
7856 prs_debug(ps, depth, desc, "samr_io_r_query_domain_info2");
7857 depth++;
7858
7859 if(!prs_align(ps))
7860 return False;
7861
7862 if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
7863 return False;
7864
7865 if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
7866 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
7867 return False;
7868 if(!prs_align(ps))
7869 return False;
7870
7871 switch (r_u->switch_value) {
7872 case 0x0d:
7873 if(!sam_io_unk_info13("unk_inf13", &r_u->ctr->info.inf13, ps, depth))
7874 return False;
7875 break;
7876 case 0x0c:
7877 if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
7878 return False;
7879 break;
7880 case 0x09:
7881 if(!sam_io_unk_info9("unk_inf9",&r_u->ctr->info.inf9, ps,depth))
7882 return False;
7883 break;
7884 case 0x08:
7885 if(!sam_io_unk_info8("unk_inf8",&r_u->ctr->info.inf8, ps,depth))
7886 return False;
7887 break;
7888 case 0x07:
7889 if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
7890 return False;
7891 break;
7892 case 0x06:
7893 if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
7894 return False;
7895 break;
7896 case 0x05:
7897 if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
7898 return False;
7899 break;
7900 case 0x04:
7901 if(!sam_io_unk_info4("unk_inf4",&r_u->ctr->info.inf4, ps,depth))
7902 return False;
7903 break;
7904 case 0x03:
7905 if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
7906 return False;
7907 break;
7908 case 0x02:
7909 if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
7910 return False;
7911 break;
7912 case 0x01:
7913 if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
7914 return False;
7915 break;
7916 default:
7917 DEBUG(0, ("samr_io_r_query_domain_info2: unknown switch level 0x%x\n",
7918 r_u->switch_value));
7919 r_u->status = NT_STATUS_INVALID_INFO_CLASS;
7920 return False;
7921 }
7922 }
7923
7924 if(!prs_align(ps))
7925 return False;
7926
7927 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7928 return False;
7929
7930 return True;
7931 }
7932
7933
7934 /*******************************************************************
7935 reads or writes a structure.
7936 ********************************************************************/
7937
7938 void init_samr_q_set_domain_info(SAMR_Q_SET_DOMAIN_INFO *q_u,
7939 POLICY_HND *domain_pol, uint16 switch_value, SAM_UNK_CTR *ctr)
7940 {
7941 DEBUG(5, ("init_samr_q_set_domain_info\n"));
7942
7943 q_u->domain_pol = *domain_pol;
7944 q_u->switch_value0 = switch_value;
7945
7946 q_u->switch_value = switch_value;
7947 q_u->ctr = ctr;
7948
7949 }
7950
7951 /*******************************************************************
7952 reads or writes a structure.
7953 ********************************************************************/
7954
7955 BOOL samr_io_q_set_domain_info(const char *desc, SAMR_Q_SET_DOMAIN_INFO *q_u,
7956 prs_struct *ps, int depth)
7957 {
7958 if (q_u == NULL)
7959 return False;
7960
7961 prs_debug(ps, depth, desc, "samr_io_q_set_domain_info");
7962 depth++;
7963
7964 if(!prs_align(ps))
7965 return False;
7966
7967 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7968 return False;
7969
7970 if(!prs_uint16("switch_value0", ps, depth, &q_u->switch_value0))
7971 return False;
7972
7973 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7974 return False;
7975
7976 if(!prs_align(ps))
7977 return False;
7978
7979 if (UNMARSHALLING(ps)) {
7980 if ((q_u->ctr = PRS_ALLOC_MEM(ps, SAM_UNK_CTR, 1)) == NULL)
7981 return False;
7982 }
7983
7984 switch (q_u->switch_value) {
7985
7986 case 0x0c:
7987 if(!sam_io_unk_info12("unk_inf12", &q_u->ctr->info.inf12, ps, depth))
7988 return False;
7989 break;
7990 case 0x07:
7991 if(!sam_io_unk_info7("unk_inf7",&q_u->ctr->info.inf7, ps,depth))
7992 return False;
7993 break;
7994 case 0x06:
7995 if(!sam_io_unk_info6("unk_inf6",&q_u->ctr->info.inf6, ps,depth))
7996 return False;
7997 break;
7998 case 0x05:
7999 if(!sam_io_unk_info5("unk_inf5",&q_u->ctr->info.inf5, ps,depth))
8000 return False;
8001 break;
8002 case 0x03:
8003 if(!sam_io_unk_info3("unk_inf3",&q_u->ctr->info.inf3, ps,depth))
8004 return False;
8005 break;
8006 case 0x02:
8007 if(!sam_io_unk_info2("unk_inf2",&q_u->ctr->info.inf2, ps,depth))
8008 return False;
8009 break;
8010 case 0x01:
8011 if(!sam_io_unk_info1("unk_inf1",&q_u->ctr->info.inf1, ps,depth))
8012 return False;
8013 break;
8014 default:
8015 DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
8016 q_u->switch_value));
8017 return False;
8018 }
8019
8020 return True;
8021 }
8022
8023 /*******************************************************************
8024 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
8025 ********************************************************************/
8026
8027 void init_samr_r_set_domain_info(SAMR_R_SET_DOMAIN_INFO * r_u, NTSTATUS status)
8028 {
8029 DEBUG(5, ("init_samr_r_set_domain_info\n"));
8030
8031 r_u->status = status; /* return status */
8032 }
8033
8034 /*******************************************************************
8035 reads or writes a structure.
8036 ********************************************************************/
8037
8038 BOOL samr_io_r_set_domain_info(const char *desc, SAMR_R_SET_DOMAIN_INFO * r_u,
8039 prs_struct *ps, int depth)
8040 {
8041 if (r_u == NULL)
8042 return False;
8043
8044 prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
8045 depth++;
8046
8047 if(!prs_align(ps))
8048 return False;
8049
8050 if(!prs_ntstatus("status", ps, depth, &r_u->status))
8051 return False;
8052
8053 return True;
8054 }
Samba GIT mirror