?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r23084: Merge Jeremy's fix for BUG 4637. This is now the final
[Samba.git] / source / rpc_parse / parse_samr.c
blobfc35ccbe2bbedcb75e76fa939b40411c8022f2fd
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_uint32s(False, "unknown_5 ", ps, depth, usr->unknown_5, 5))
6068 return False;
6069
6070 if(!prs_uint8s(False, "password ", ps, depth, usr->pass, sizeof(usr->pass)))
6071 return False;
6072
6073 /* here begins pointed-to data */
6074
6075 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
6076 return False;
6077
6078 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
6079 return False;
6080
6081 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
6082 return False;
6083
6084 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
6085 return False;
6086
6087 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
6088 return False;
6089
6090 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
6091 return False;
6092
6093 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth)) /* user desc unicode string */
6094 return False;
6095
6096 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth)) /* worksations user can log on from */
6097 return False;
6098
6099 if(!smb_io_unistr2("uni_comment ", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth)) /* unknown string */
6100 return False;
6101
6102 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
6103 return False;
6104
6105 #if 0 /* JRA - unknown... */
6106 /* ok, this is only guess-work (as usual) */
6107 if (usr->ptr_logon_hrs) {
6108 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6109 return False;
6110 }
6111 #endif
6112
6113 return True;
6114 }
6115
6116
6117 /*************************************************************************
6118 init_sam_user_info21W
6119
6120 unknown_6 = 0x0000 04ec
6121
6122 *************************************************************************/
6123
6124 void init_sam_user_info21W(SAM_USER_INFO_21 * usr,
6125 NTTIME * logon_time,
6126 NTTIME * logoff_time,
6127 NTTIME * kickoff_time,
6128 NTTIME * pass_last_set_time,
6129 NTTIME * pass_can_change_time,
6130 NTTIME * pass_must_change_time,
6131 UNISTR2 *user_name,
6132 UNISTR2 *full_name,
6133 UNISTR2 *home_dir,
6134 UNISTR2 *dir_drive,
6135 UNISTR2 *log_scr,
6136 UNISTR2 *prof_path,
6137 UNISTR2 *desc,
6138 UNISTR2 *wkstas,
6139 UNISTR2 *unk_str,
6140 UNISTR2 *mung_dial,
6141 uchar lm_pwd[16],
6142 uchar nt_pwd[16],
6143 uint32 user_rid,
6144 uint32 group_rid,
6145 uint32 acb_info,
6146 uint32 fields_present,
6147 uint16 logon_divs,
6148 LOGON_HRS * hrs,
6149 uint16 bad_password_count,
6150 uint16 logon_count)
6151 {
6152 usr->logon_time = *logon_time;
6153 usr->logoff_time = *logoff_time;
6154 usr->kickoff_time = *kickoff_time;
6155 usr->pass_last_set_time = *pass_last_set_time;
6156 usr->pass_can_change_time = *pass_can_change_time;
6157 usr->pass_must_change_time = *pass_must_change_time;
6158
6159 memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd));
6160 memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd));
6161
6162 usr->user_rid = user_rid;
6163 usr->group_rid = group_rid;
6164 usr->acb_info = acb_info;
6165 usr->fields_present = fields_present; /* 0x00ff ffff */
6166
6167 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
6168 usr->ptr_logon_hrs = hrs ? 1 : 0;
6169 usr->bad_password_count = bad_password_count;
6170 usr->logon_count = logon_count;
6171
6172 if (nt_time_is_zero(pass_must_change_time)) {
6173 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6174 } else {
6175 usr->passmustchange=0;
6176 }
6177
6178 ZERO_STRUCT(usr->padding1);
6179 ZERO_STRUCT(usr->padding2);
6180
6181 copy_unistr2(&usr->uni_user_name, user_name);
6182 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6183
6184 copy_unistr2(&usr->uni_full_name, full_name);
6185 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6186
6187 copy_unistr2(&usr->uni_home_dir, home_dir);
6188 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6189
6190 copy_unistr2(&usr->uni_dir_drive, dir_drive);
6191 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6192
6193 copy_unistr2(&usr->uni_logon_script, log_scr);
6194 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6195
6196 copy_unistr2(&usr->uni_profile_path, prof_path);
6197 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6198
6199 copy_unistr2(&usr->uni_acct_desc, desc);
6200 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6201
6202 copy_unistr2(&usr->uni_workstations, wkstas);
6203 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6204
6205 copy_unistr2(&usr->uni_comment, unk_str);
6206 init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
6207
6208 copy_unistr2(&usr->uni_munged_dial, mung_dial);
6209 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6210
6211 if (hrs) {
6212 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
6213 } else {
6214 ZERO_STRUCT(usr->logon_hrs);
6215 }
6216 }
6217
6218 /*************************************************************************
6219 init_sam_user_info21
6220
6221 unknown_6 = 0x0000 04ec
6222
6223 *************************************************************************/
6224
6225 NTSTATUS init_sam_user_info21A(SAM_USER_INFO_21 *usr, struct samu *pw, DOM_SID *domain_sid)
6226 {
6227 NTTIME logon_time, logoff_time, kickoff_time,
6228 pass_last_set_time, pass_can_change_time,
6229 pass_must_change_time;
6230
6231 time_t must_change_time;
6232 const char* user_name = pdb_get_username(pw);
6233 const char* full_name = pdb_get_fullname(pw);
6234 const char* home_dir = pdb_get_homedir(pw);
6235 const char* dir_drive = pdb_get_dir_drive(pw);
6236 const char* logon_script = pdb_get_logon_script(pw);
6237 const char* profile_path = pdb_get_profile_path(pw);
6238 const char* description = pdb_get_acct_desc(pw);
6239 const char* workstations = pdb_get_workstations(pw);
6240 const char* munged_dial = pdb_get_munged_dial(pw);
6241 DATA_BLOB munged_dial_blob;
6242
6243 uint32 user_rid;
6244 const DOM_SID *user_sid;
6245
6246 uint32 group_rid;
6247 const DOM_SID *group_sid;
6248
6249 if (munged_dial) {
6250 munged_dial_blob = base64_decode_data_blob(munged_dial);
6251 } else {
6252 munged_dial_blob = data_blob(NULL, 0);
6253 }
6254
6255 /* Create NTTIME structs */
6256 unix_to_nt_time (&logon_time, pdb_get_logon_time(pw));
6257 unix_to_nt_time (&logoff_time, pdb_get_logoff_time(pw));
6258 unix_to_nt_time (&kickoff_time, pdb_get_kickoff_time(pw));
6259 unix_to_nt_time (&pass_last_set_time, pdb_get_pass_last_set_time(pw));
6260 unix_to_nt_time (&pass_can_change_time,pdb_get_pass_can_change_time(pw));
6261 must_change_time = pdb_get_pass_must_change_time(pw);
6262 if (must_change_time == get_time_t_max())
6263 unix_to_nt_time_abs(&pass_must_change_time, must_change_time);
6264 else
6265 unix_to_nt_time(&pass_must_change_time, must_change_time);
6266
6267 /* structure assignment */
6268 usr->logon_time = logon_time;
6269 usr->logoff_time = logoff_time;
6270 usr->kickoff_time = kickoff_time;
6271 usr->pass_last_set_time = pass_last_set_time;
6272 usr->pass_can_change_time = pass_can_change_time;
6273 usr->pass_must_change_time = pass_must_change_time;
6274
6275 ZERO_STRUCT(usr->nt_pwd);
6276 ZERO_STRUCT(usr->lm_pwd);
6277
6278 user_sid = pdb_get_user_sid(pw);
6279
6280 if (!sid_peek_check_rid(domain_sid, user_sid, &user_rid)) {
6281 fstring user_sid_string;
6282 fstring domain_sid_string;
6283 DEBUG(0, ("init_sam_user_info_21A: User %s has SID %s, \nwhich conflicts with "
6284 "the domain sid %s. Failing operation.\n",
6285 user_name,
6286 sid_to_string(user_sid_string, user_sid),
6287 sid_to_string(domain_sid_string, domain_sid)));
6288 data_blob_free(&munged_dial_blob);
6289 return NT_STATUS_UNSUCCESSFUL;
6290 }
6291
6292 become_root();
6293 group_sid = pdb_get_group_sid(pw);
6294 unbecome_root();
6295
6296 if (!sid_peek_check_rid(domain_sid, group_sid, &group_rid)) {
6297 fstring group_sid_string;
6298 fstring domain_sid_string;
6299 DEBUG(0, ("init_sam_user_info_21A: User %s has Primary Group SID %s, \n"
6300 "which conflicts with the domain sid %s. Failing operation.\n",
6301 user_name,
6302 sid_to_string(group_sid_string, group_sid),
6303 sid_to_string(domain_sid_string, domain_sid)));
6304 data_blob_free(&munged_dial_blob);
6305 return NT_STATUS_UNSUCCESSFUL;
6306 }
6307
6308 usr->user_rid = user_rid;
6309 usr->group_rid = group_rid;
6310 usr->acb_info = pdb_get_acct_ctrl(pw);
6311
6312 /*
6313 Look at a user on a real NT4 PDC with usrmgr, press
6314 'ok'. Then you will see that fields_present is set to
6315 0x08f827fa. Look at the user immediately after that again,
6316 and you will see that 0x00fffff is returned. This solves
6317 the problem that you get access denied after having looked
6318 at the user.
6319 -- Volker
6320 */
6321 usr->fields_present = pdb_build_fields_present(pw);
6322
6323 usr->logon_divs = pdb_get_logon_divs(pw);
6324 usr->ptr_logon_hrs = pdb_get_hours(pw) ? 1 : 0;
6325 usr->bad_password_count = pdb_get_bad_password_count(pw);
6326 usr->logon_count = pdb_get_logon_count(pw);
6327
6328 if (pdb_get_pass_must_change_time(pw) == 0) {
6329 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6330 } else {
6331 usr->passmustchange=0;
6332 }
6333
6334 ZERO_STRUCT(usr->padding1);
6335 ZERO_STRUCT(usr->padding2);
6336
6337 init_unistr2(&usr->uni_user_name, user_name, UNI_STR_TERMINATE);
6338 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6339
6340 init_unistr2(&usr->uni_full_name, full_name, UNI_STR_TERMINATE);
6341 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6342
6343 init_unistr2(&usr->uni_home_dir, home_dir, UNI_STR_TERMINATE);
6344 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6345
6346 init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_STR_TERMINATE);
6347 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6348
6349 init_unistr2(&usr->uni_logon_script, logon_script, UNI_STR_TERMINATE);
6350 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6351
6352 init_unistr2(&usr->uni_profile_path, profile_path, UNI_STR_TERMINATE);
6353 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6354
6355 init_unistr2(&usr->uni_acct_desc, description, UNI_STR_TERMINATE);
6356 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6357
6358 init_unistr2(&usr->uni_workstations, workstations, UNI_STR_TERMINATE);
6359 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6360
6361 init_unistr2(&usr->uni_comment, NULL, UNI_STR_TERMINATE);
6362 init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
6363
6364 init_unistr2_from_datablob(&usr->uni_munged_dial, &munged_dial_blob);
6365 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6366 data_blob_free(&munged_dial_blob);
6367
6368 if (pdb_get_hours(pw)) {
6369 usr->logon_hrs.max_len = 1260;
6370 usr->logon_hrs.offset = 0;
6371 usr->logon_hrs.len = pdb_get_hours_len(pw);
6372 memcpy(&usr->logon_hrs.hours, pdb_get_hours(pw), MAX_HOURS_LEN);
6373 } else {
6374 usr->logon_hrs.max_len = 1260;
6375 usr->logon_hrs.offset = 0;
6376 usr->logon_hrs.len = 0;
6377 memset(&usr->logon_hrs, 0xff, sizeof(usr->logon_hrs));
6378 }
6379
6380 return NT_STATUS_OK;
6381 }
6382
6383 /*******************************************************************
6384 reads or writes a structure.
6385 ********************************************************************/
6386
6387 static BOOL sam_io_user_info21(const char *desc, SAM_USER_INFO_21 * usr,
6388 prs_struct *ps, int depth)
6389 {
6390 if (usr == NULL)
6391 return False;
6392
6393 prs_debug(ps, depth, desc, "sam_io_user_info21");
6394 depth++;
6395
6396 if(!prs_align(ps))
6397 return False;
6398
6399 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
6400 return False;
6401 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
6402 return False;
6403 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps,depth))
6404 return False;
6405 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
6406 return False;
6407 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps,depth))
6408 return False;
6409 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
6410 return False;
6411
6412 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
6413 return False;
6414 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
6415 return False;
6416 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
6417 return False;
6418 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
6419 return False;
6420 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
6421 return False;
6422 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
6423 return False;
6424 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
6425 return False;
6426 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
6427 return False;
6428 if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth)) /* unknown string */
6429 return False;
6430 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6431 return False;
6432
6433 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6434 return False;
6435 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6436 return False;
6437
6438 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
6439 return False;
6440 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
6441 return False;
6442 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
6443 return False;
6444
6445 if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6446 return False;
6447 if(!prs_uint16("logon_divs ", ps, depth, &usr->logon_divs)) /* logon divisions per week */
6448 return False;
6449 if(!prs_align(ps))
6450 return False;
6451 if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
6452 return False;
6453
6454 if(!prs_uint16("bad_password_count ", ps, depth, &usr->bad_password_count))
6455 return False;
6456 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count))
6457 return False;
6458
6459 if(!prs_uint8s(False, "padding1 ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6460 return False;
6461 if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6462 return False;
6463 if(!prs_uint8("padding2 ", ps, depth, &usr->padding2))
6464 return False;
6465
6466 /* here begins pointed-to data */
6467
6468 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name,usr->hdr_user_name.buffer, ps, depth))
6469 return False;
6470 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))
6471 return False;
6472 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))
6473 return False;
6474 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))
6475 return False;
6476 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))
6477 return False;
6478 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))
6479 return False;
6480 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))
6481 return False;
6482 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))
6483 return False;
6484 if(!smb_io_unistr2("uni_comment", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth))
6485 return False;
6486 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth))
6487 return False;
6488
6489 /* ok, this is only guess-work (as usual) */
6490 if (usr->ptr_logon_hrs) {
6491 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6492 return False;
6493 }
6494
6495 return True;
6496 }
6497
6498 void init_sam_user_info20A(SAM_USER_INFO_20 *usr, struct samu *pw)
6499 {
6500 const char *munged_dial = pdb_get_munged_dial(pw);
6501 DATA_BLOB blob;
6502
6503 if (munged_dial) {
6504 blob = base64_decode_data_blob(munged_dial);
6505 } else {
6506 blob = data_blob(NULL, 0);
6507 }
6508
6509 init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
6510 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6511 data_blob_free(&blob);
6512 }
6513
6514 /*******************************************************************
6515 reads or writes a structure.
6516 ********************************************************************/
6517
6518 static BOOL sam_io_user_info20(const char *desc, SAM_USER_INFO_20 *usr,
6519 prs_struct *ps, int depth)
6520 {
6521 if (usr == NULL)
6522 return False;
6523
6524 prs_debug(ps, depth, desc, "sam_io_user_info20");
6525 depth++;
6526
6527 if(!prs_align(ps))
6528 return False;
6529
6530 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6531 return False;
6532
6533 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth)) /* worksations user can log on from */
6534 return False;
6535
6536 return True;
6537 }
6538
6539 /*******************************************************************
6540 inits a SAM_USERINFO_CTR structure.
6541 ********************************************************************/
6542
6543 NTSTATUS make_samr_userinfo_ctr_usr21(TALLOC_CTX *ctx, SAM_USERINFO_CTR * ctr,
6544 uint16 switch_value,
6545 SAM_USER_INFO_21 * usr)
6546 {
6547 DEBUG(5, ("make_samr_userinfo_ctr_usr21\n"));
6548
6549 ctr->switch_value = switch_value;
6550 ctr->info.id = NULL;
6551
6552 switch (switch_value) {
6553 case 16:
6554 ctr->info.id16 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_16);
6555 if (ctr->info.id16 == NULL)
6556 return NT_STATUS_NO_MEMORY;
6557
6558 init_sam_user_info16(ctr->info.id16, usr->acb_info);
6559 break;
6560 #if 0
6561 /* whoops - got this wrong. i think. or don't understand what's happening. */
6562 case 17:
6563 {
6564 NTTIME expire;
6565 info = (void *)&id11;
6566
6567 expire.low = 0xffffffff;
6568 expire.high = 0x7fffffff;
6569
6570 ctr->info.id = TALLOC_ZERO_P(ctx,SAM_USER_INFO_17);
6571 init_sam_user_info11(ctr->info.id17, &expire,
6572 "BROOKFIELDS$", /* name */
6573 0x03ef, /* user rid */
6574 0x201, /* group rid */
6575 0x0080); /* acb info */
6576
6577 break;
6578 }
6579 #endif
6580 case 18:
6581 ctr->info.id18 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_18);
6582 if (ctr->info.id18 == NULL)
6583 return NT_STATUS_NO_MEMORY;
6584
6585 init_sam_user_info18(ctr->info.id18, usr->lm_pwd, usr->nt_pwd);
6586 break;
6587 case 21:
6588 {
6589 SAM_USER_INFO_21 *cusr;
6590 cusr = TALLOC_ZERO_P(ctx,SAM_USER_INFO_21);
6591 ctr->info.id21 = cusr;
6592 if (ctr->info.id21 == NULL)
6593 return NT_STATUS_NO_MEMORY;
6594 memcpy(cusr, usr, sizeof(*usr));
6595 memset(cusr->lm_pwd, 0, sizeof(cusr->lm_pwd));
6596 memset(cusr->nt_pwd, 0, sizeof(cusr->nt_pwd));
6597 break;
6598 }
6599 default:
6600 DEBUG(4,("make_samr_userinfo_ctr: unsupported info\n"));
6601 return NT_STATUS_INVALID_INFO_CLASS;
6602 }
6603
6604 return NT_STATUS_OK;
6605 }
6606
6607 /*******************************************************************
6608 inits a SAM_USERINFO_CTR structure.
6609 ********************************************************************/
6610
6611 static void init_samr_userinfo_ctr(SAM_USERINFO_CTR * ctr, DATA_BLOB *sess_key,
6612 uint16 switch_value, void *info)
6613 {
6614 DEBUG(5, ("init_samr_userinfo_ctr\n"));
6615
6616 ctr->switch_value = switch_value;
6617 ctr->info.id = info;
6618
6619 switch (switch_value) {
6620 case 0x18:
6621 SamOEMhashBlob(ctr->info.id24->pass, 516, sess_key);
6622 dump_data(100, (char *)sess_key->data, sess_key->length);
6623 dump_data(100, (char *)ctr->info.id24->pass, 516);
6624 break;
6625 case 0x17:
6626 SamOEMhashBlob(ctr->info.id23->pass, 516, sess_key);
6627 dump_data(100, (char *)sess_key->data, sess_key->length);
6628 dump_data(100, (char *)ctr->info.id23->pass, 516);
6629 break;
6630 case 0x07:
6631 break;
6632 default:
6633 DEBUG(4,("init_samr_userinfo_ctr: unsupported switch level: %d\n", switch_value));
6634 }
6635 }
6636
6637 /*******************************************************************
6638 reads or writes a structure.
6639 ********************************************************************/
6640
6641 static BOOL samr_io_userinfo_ctr(const char *desc, SAM_USERINFO_CTR **ppctr,
6642 prs_struct *ps, int depth)
6643 {
6644 BOOL ret;
6645 SAM_USERINFO_CTR *ctr;
6646
6647 prs_debug(ps, depth, desc, "samr_io_userinfo_ctr");
6648 depth++;
6649
6650 if (UNMARSHALLING(ps)) {
6651 ctr = PRS_ALLOC_MEM(ps,SAM_USERINFO_CTR,1);
6652 if (ctr == NULL)
6653 return False;
6654 *ppctr = ctr;
6655 } else {
6656 ctr = *ppctr;
6657 }
6658
6659 /* lkclXXXX DO NOT ALIGN BEFORE READING SWITCH VALUE! */
6660
6661 if(!prs_uint16("switch_value", ps, depth, &ctr->switch_value))
6662 return False;
6663 if(!prs_align(ps))
6664 return False;
6665
6666 ret = False;
6667
6668 switch (ctr->switch_value) {
6669 case 7:
6670 if (UNMARSHALLING(ps))
6671 ctr->info.id7 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_7,1);
6672 if (ctr->info.id7 == NULL) {
6673 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6674 return False;
6675 }
6676 ret = sam_io_user_info7("", ctr->info.id7, ps, depth);
6677 break;
6678 case 9:
6679 if (UNMARSHALLING(ps))
6680 ctr->info.id9 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_9,1);
6681 if (ctr->info.id9 == NULL) {
6682 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6683 return False;
6684 }
6685 ret = sam_io_user_info9("", ctr->info.id9, ps, depth);
6686 break;
6687 case 16:
6688 if (UNMARSHALLING(ps))
6689 ctr->info.id16 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_16,1);
6690 if (ctr->info.id16 == NULL) {
6691 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6692 return False;
6693 }
6694 ret = sam_io_user_info16("", ctr->info.id16, ps, depth);
6695 break;
6696 case 17:
6697 if (UNMARSHALLING(ps))
6698 ctr->info.id17 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_17,1);
6699
6700 if (ctr->info.id17 == NULL) {
6701 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6702 return False;
6703 }
6704 ret = sam_io_user_info17("", ctr->info.id17, ps, depth);
6705 break;
6706 case 18:
6707 if (UNMARSHALLING(ps))
6708 ctr->info.id18 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_18,1);
6709
6710 if (ctr->info.id18 == NULL) {
6711 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6712 return False;
6713 }
6714 ret = sam_io_user_info18("", ctr->info.id18, ps, depth);
6715 break;
6716 case 20:
6717 if (UNMARSHALLING(ps))
6718 ctr->info.id20 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_20,1);
6719
6720 if (ctr->info.id20 == NULL) {
6721 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6722 return False;
6723 }
6724 ret = sam_io_user_info20("", ctr->info.id20, ps, depth);
6725 break;
6726 case 21:
6727 if (UNMARSHALLING(ps))
6728 ctr->info.id21 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_21,1);
6729
6730 if (ctr->info.id21 == NULL) {
6731 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6732 return False;
6733 }
6734 ret = sam_io_user_info21("", ctr->info.id21, ps, depth);
6735 break;
6736 case 23:
6737 if (UNMARSHALLING(ps))
6738 ctr->info.id23 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_23,1);
6739
6740 if (ctr->info.id23 == NULL) {
6741 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6742 return False;
6743 }
6744 ret = sam_io_user_info23("", ctr->info.id23, ps, depth);
6745 break;
6746 case 24:
6747 if (UNMARSHALLING(ps))
6748 ctr->info.id24 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_24,1);
6749
6750 if (ctr->info.id24 == NULL) {
6751 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6752 return False;
6753 }
6754 ret = sam_io_user_info24("", ctr->info.id24, ps, depth);
6755 break;
6756 case 25:
6757 if (UNMARSHALLING(ps))
6758 ctr->info.id25 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_25,1);
6759
6760 if (ctr->info.id25 == NULL) {
6761 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6762 return False;
6763 }
6764 ret = sam_io_user_info25("", ctr->info.id25, ps, depth);
6765 break;
6766 case 26:
6767 if (UNMARSHALLING(ps))
6768 ctr->info.id26 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_26,1);
6769
6770 if (ctr->info.id26 == NULL) {
6771 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6772 return False;
6773 }
6774 ret = sam_io_user_info26("", ctr->info.id26, ps, depth);
6775 break;
6776 default:
6777 DEBUG(2, ("samr_io_userinfo_ctr: unknown switch level 0x%x\n", ctr->switch_value));
6778 ret = False;
6779 break;
6780 }
6781
6782 return ret;
6783 }
6784
6785 /*******************************************************************
6786 inits a SAMR_R_QUERY_USERINFO structure.
6787 ********************************************************************/
6788
6789 void init_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO * r_u,
6790 SAM_USERINFO_CTR * ctr, NTSTATUS status)
6791 {
6792 DEBUG(5, ("init_samr_r_query_userinfo\n"));
6793
6794 r_u->ptr = 0;
6795 r_u->ctr = NULL;
6796
6797 if (NT_STATUS_IS_OK(status)) {
6798 r_u->ptr = 1;
6799 r_u->ctr = ctr;
6800 }
6801
6802 r_u->status = status; /* return status */
6803 }
6804
6805 /*******************************************************************
6806 reads or writes a structure.
6807 ********************************************************************/
6808
6809 BOOL samr_io_r_query_userinfo(const char *desc, SAMR_R_QUERY_USERINFO * r_u,
6810 prs_struct *ps, int depth)
6811 {
6812 if (r_u == NULL)
6813 return False;
6814
6815 prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
6816 depth++;
6817
6818 if(!prs_align(ps))
6819 return False;
6820
6821 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
6822 return False;
6823
6824 if (r_u->ptr != 0) {
6825 if(!samr_io_userinfo_ctr("ctr", &r_u->ctr, ps, depth))
6826 return False;
6827 }
6828
6829 if(!prs_align(ps))
6830 return False;
6831 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6832 return False;
6833
6834 return True;
6835 }
6836
6837 /*******************************************************************
6838 inits a SAMR_Q_SET_USERINFO structure.
6839 ********************************************************************/
6840
6841 void init_samr_q_set_userinfo(SAMR_Q_SET_USERINFO * q_u,
6842 const POLICY_HND *hnd, DATA_BLOB *sess_key,
6843 uint16 switch_value, void *info)
6844 {
6845 DEBUG(5, ("init_samr_q_set_userinfo\n"));
6846
6847 q_u->pol = *hnd;
6848 q_u->switch_value = switch_value;
6849 init_samr_userinfo_ctr(q_u->ctr, sess_key, switch_value, info);
6850 }
6851
6852 /*******************************************************************
6853 reads or writes a structure.
6854 ********************************************************************/
6855
6856 BOOL samr_io_q_set_userinfo(const char *desc, SAMR_Q_SET_USERINFO * q_u,
6857 prs_struct *ps, int depth)
6858 {
6859 if (q_u == NULL)
6860 return False;
6861
6862 prs_debug(ps, depth, desc, "samr_io_q_set_userinfo");
6863 depth++;
6864
6865 if(!prs_align(ps))
6866 return False;
6867
6868 smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
6869
6870 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6871 return False;
6872 if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6873 return False;
6874
6875 return True;
6876 }
6877
6878 /*******************************************************************
6879 inits a SAMR_R_SET_USERINFO structure.
6880 ********************************************************************/
6881
6882 void init_samr_r_set_userinfo(SAMR_R_SET_USERINFO * r_u, NTSTATUS status)
6883 {
6884 DEBUG(5, ("init_samr_r_set_userinfo\n"));
6885
6886 r_u->status = status; /* return status */
6887 }
6888
6889 /*******************************************************************
6890 reads or writes a structure.
6891 ********************************************************************/
6892
6893 BOOL samr_io_r_set_userinfo(const char *desc, SAMR_R_SET_USERINFO * r_u,
6894 prs_struct *ps, int depth)
6895 {
6896 if (r_u == NULL)
6897 return False;
6898
6899 prs_debug(ps, depth, desc, "samr_io_r_set_userinfo");
6900 depth++;
6901
6902 if(!prs_align(ps))
6903 return False;
6904
6905 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6906 return False;
6907
6908 return True;
6909 }
6910
6911 /*******************************************************************
6912 inits a SAMR_Q_SET_USERINFO2 structure.
6913 ********************************************************************/
6914
6915 void init_samr_q_set_userinfo2(SAMR_Q_SET_USERINFO2 * q_u,
6916 const POLICY_HND *hnd, DATA_BLOB *sess_key,
6917 uint16 switch_value, SAM_USERINFO_CTR * ctr)
6918 {
6919 DEBUG(5, ("init_samr_q_set_userinfo2\n"));
6920
6921 q_u->pol = *hnd;
6922 q_u->switch_value = switch_value;
6923 q_u->ctr = ctr;
6924
6925 q_u->ctr->switch_value = switch_value;
6926
6927 switch (switch_value) {
6928 case 18:
6929 SamOEMhashBlob(ctr->info.id18->lm_pwd, 16, sess_key);
6930 SamOEMhashBlob(ctr->info.id18->nt_pwd, 16, sess_key);
6931 dump_data(100, (char *)sess_key->data, sess_key->length);
6932 dump_data(100, (char *)ctr->info.id18->lm_pwd, 16);
6933 dump_data(100, (char *)ctr->info.id18->nt_pwd, 16);
6934 break;
6935 }
6936 }
6937
6938 /*******************************************************************
6939 reads or writes a structure.
6940 ********************************************************************/
6941
6942 BOOL samr_io_q_set_userinfo2(const char *desc, SAMR_Q_SET_USERINFO2 * q_u,
6943 prs_struct *ps, int depth)
6944 {
6945 if (q_u == NULL)
6946 return False;
6947
6948 prs_debug(ps, depth, desc, "samr_io_q_set_userinfo2");
6949 depth++;
6950
6951 if(!prs_align(ps))
6952 return False;
6953
6954 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
6955 return False;
6956
6957 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6958 return False;
6959 if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6960 return False;
6961
6962 return True;
6963 }
6964
6965 /*******************************************************************
6966 inits a SAMR_R_SET_USERINFO2 structure.
6967 ********************************************************************/
6968
6969 void init_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2 * r_u, NTSTATUS status)
6970 {
6971 DEBUG(5, ("init_samr_r_set_userinfo2\n"));
6972
6973 r_u->status = status; /* return status */
6974 }
6975
6976 /*******************************************************************
6977 reads or writes a structure.
6978 ********************************************************************/
6979
6980 BOOL samr_io_r_set_userinfo2(const char *desc, SAMR_R_SET_USERINFO2 * r_u,
6981 prs_struct *ps, int depth)
6982 {
6983 if (r_u == NULL)
6984 return False;
6985
6986 prs_debug(ps, depth, desc, "samr_io_r_set_userinfo2");
6987 depth++;
6988
6989 if(!prs_align(ps))
6990 return False;
6991
6992 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6993 return False;
6994
6995 return True;
6996 }
6997
6998 /*******************************************************************
6999 inits a SAMR_Q_CONNECT structure.
7000 ********************************************************************/
7001
7002 void init_samr_q_connect(SAMR_Q_CONNECT * q_u,
7003 char *srv_name, uint32 access_mask)
7004 {
7005 DEBUG(5, ("init_samr_q_connect\n"));
7006
7007 /* make PDC server name \\server */
7008 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7009 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7010
7011 /* example values: 0x0000 0002 */
7012 q_u->access_mask = access_mask;
7013 }
7014
7015 /*******************************************************************
7016 reads or writes a structure.
7017 ********************************************************************/
7018
7019 BOOL samr_io_q_connect(const char *desc, SAMR_Q_CONNECT * q_u,
7020 prs_struct *ps, int depth)
7021 {
7022 if (q_u == NULL)
7023 return False;
7024
7025 prs_debug(ps, depth, desc, "samr_io_q_connect");
7026 depth++;
7027
7028 if(!prs_align(ps))
7029 return False;
7030
7031 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7032 return False;
7033 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7034 return False;
7035
7036 if(!prs_align(ps))
7037 return False;
7038 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7039 return False;
7040
7041 return True;
7042 }
7043
7044 /*******************************************************************
7045 reads or writes a structure.
7046 ********************************************************************/
7047
7048 BOOL samr_io_r_connect(const char *desc, SAMR_R_CONNECT * r_u,
7049 prs_struct *ps, int depth)
7050 {
7051 if (r_u == NULL)
7052 return False;
7053
7054 prs_debug(ps, depth, desc, "samr_io_r_connect");
7055 depth++;
7056
7057 if(!prs_align(ps))
7058 return False;
7059
7060 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7061 return False;
7062
7063 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7064 return False;
7065
7066 return True;
7067 }
7068
7069 /*******************************************************************
7070 inits a SAMR_Q_CONNECT4 structure.
7071 ********************************************************************/
7072
7073 void init_samr_q_connect4(SAMR_Q_CONNECT4 * q_u,
7074 char *srv_name, uint32 access_mask)
7075 {
7076 DEBUG(5, ("init_samr_q_connect4\n"));
7077
7078 /* make PDC server name \\server */
7079 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7080 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7081
7082 /* Only value we've seen, possibly an address type ? */
7083 q_u->unk_0 = 2;
7084
7085 /* example values: 0x0000 0002 */
7086 q_u->access_mask = access_mask;
7087 }
7088
7089 /*******************************************************************
7090 reads or writes a structure.
7091 ********************************************************************/
7092
7093 BOOL samr_io_q_connect4(const char *desc, SAMR_Q_CONNECT4 * q_u,
7094 prs_struct *ps, int depth)
7095 {
7096 if (q_u == NULL)
7097 return False;
7098
7099 prs_debug(ps, depth, desc, "samr_io_q_connect4");
7100 depth++;
7101
7102 if(!prs_align(ps))
7103 return False;
7104
7105 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7106 return False;
7107 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7108 return False;
7109
7110 if(!prs_align(ps))
7111 return False;
7112 if(!prs_uint32("unk_0", ps, depth, &q_u->unk_0))
7113 return False;
7114 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7115 return False;
7116
7117 return True;
7118 }
7119
7120 /*******************************************************************
7121 reads or writes a structure.
7122 ********************************************************************/
7123
7124 BOOL samr_io_r_connect4(const char *desc, SAMR_R_CONNECT4 * r_u,
7125 prs_struct *ps, int depth)
7126 {
7127 if (r_u == NULL)
7128 return False;
7129
7130 prs_debug(ps, depth, desc, "samr_io_r_connect4");
7131 depth++;
7132
7133 if(!prs_align(ps))
7134 return False;
7135
7136 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7137 return False;
7138
7139 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7140 return False;
7141
7142 return True;
7143 }
7144
7145 /*******************************************************************
7146 inits a SAMR_Q_CONNECT5 structure.
7147 ********************************************************************/
7148
7149 void init_samr_q_connect5(SAMR_Q_CONNECT5 * q_u,
7150 char *srv_name, uint32 access_mask)
7151 {
7152 DEBUG(5, ("init_samr_q_connect5\n"));
7153
7154 /* make PDC server name \\server */
7155 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7156 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7157
7158 /* example values: 0x0000 0002 */
7159 q_u->access_mask = access_mask;
7160
7161 q_u->level = 1;
7162 q_u->info1_unk1 = 3;
7163 q_u->info1_unk2 = 0;
7164 }
7165
7166 /*******************************************************************
7167 inits a SAMR_R_CONNECT5 structure.
7168 ********************************************************************/
7169
7170 void init_samr_r_connect5(SAMR_R_CONNECT5 * r_u, POLICY_HND *pol, NTSTATUS status)
7171 {
7172 DEBUG(5, ("init_samr_q_connect5\n"));
7173
7174 r_u->level = 1;
7175 r_u->info1_unk1 = 3;
7176 r_u->info1_unk2 = 0;
7177
7178 r_u->connect_pol = *pol;
7179 r_u->status = status;
7180 }
7181
7182 /*******************************************************************
7183 reads or writes a structure.
7184 ********************************************************************/
7185
7186 BOOL samr_io_q_connect5(const char *desc, SAMR_Q_CONNECT5 * q_u,
7187 prs_struct *ps, int depth)
7188 {
7189 if (q_u == NULL)
7190 return False;
7191
7192 prs_debug(ps, depth, desc, "samr_io_q_connect5");
7193 depth++;
7194
7195 if(!prs_align(ps))
7196 return False;
7197
7198 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7199 return False;
7200 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7201 return False;
7202
7203 if(!prs_align(ps))
7204 return False;
7205 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7206 return False;
7207
7208 if(!prs_uint32("level", ps, depth, &q_u->level))
7209 return False;
7210 if(!prs_uint32("level", ps, depth, &q_u->level))
7211 return False;
7212
7213 if(!prs_uint32("info1_unk1", ps, depth, &q_u->info1_unk1))
7214 return False;
7215 if(!prs_uint32("info1_unk2", ps, depth, &q_u->info1_unk2))
7216 return False;
7217
7218 return True;
7219 }
7220
7221 /*******************************************************************
7222 reads or writes a structure.
7223 ********************************************************************/
7224
7225 BOOL samr_io_r_connect5(const char *desc, SAMR_R_CONNECT5 * r_u,
7226 prs_struct *ps, int depth)
7227 {
7228 if (r_u == NULL)
7229 return False;
7230
7231 prs_debug(ps, depth, desc, "samr_io_r_connect5");
7232 depth++;
7233
7234 if(!prs_align(ps))
7235 return False;
7236
7237 if(!prs_uint32("level", ps, depth, &r_u->level))
7238 return False;
7239 if(!prs_uint32("level", ps, depth, &r_u->level))
7240 return False;
7241 if(!prs_uint32("info1_unk1", ps, depth, &r_u->info1_unk1))
7242 return False;
7243 if(!prs_uint32("info1_unk2", ps, depth, &r_u->info1_unk2))
7244 return False;
7245
7246 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7247 return False;
7248
7249 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7250 return False;
7251
7252 return True;
7253 }
7254
7255 /*******************************************************************
7256 inits a SAMR_Q_CONNECT_ANON structure.
7257 ********************************************************************/
7258
7259 void init_samr_q_connect_anon(SAMR_Q_CONNECT_ANON * q_u)
7260 {
7261 DEBUG(5, ("init_samr_q_connect_anon\n"));
7262
7263 q_u->ptr = 1;
7264 q_u->unknown_0 = 0x5c; /* server name (?!!) */
7265 q_u->access_mask = MAXIMUM_ALLOWED_ACCESS;
7266 }
7267
7268 /*******************************************************************
7269 reads or writes a structure.
7270 ********************************************************************/
7271
7272 BOOL samr_io_q_connect_anon(const char *desc, SAMR_Q_CONNECT_ANON * q_u,
7273 prs_struct *ps, int depth)
7274 {
7275 if (q_u == NULL)
7276 return False;
7277
7278 prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
7279 depth++;
7280
7281 if(!prs_align(ps))
7282 return False;
7283
7284 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
7285 return False;
7286 if (q_u->ptr) {
7287 if(!prs_uint16("unknown_0", ps, depth, &q_u->unknown_0))
7288 return False;
7289 }
7290 if(!prs_align(ps))
7291 return False;
7292 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7293 return False;
7294
7295 return True;
7296 }
7297
7298 /*******************************************************************
7299 reads or writes a structure.
7300 ********************************************************************/
7301
7302 BOOL samr_io_r_connect_anon(const char *desc, SAMR_R_CONNECT_ANON * r_u,
7303 prs_struct *ps, int depth)
7304 {
7305 if (r_u == NULL)
7306 return False;
7307
7308 prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
7309 depth++;
7310
7311 if(!prs_align(ps))
7312 return False;
7313
7314 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7315 return False;
7316
7317 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7318 return False;
7319
7320 return True;
7321 }
7322
7323 /*******************************************************************
7324 inits a SAMR_Q_GET_DOM_PWINFO structure.
7325 ********************************************************************/
7326
7327 void init_samr_q_get_dom_pwinfo(SAMR_Q_GET_DOM_PWINFO * q_u,
7328 char *srv_name)
7329 {
7330 DEBUG(5, ("init_samr_q_get_dom_pwinfo\n"));
7331
7332 q_u->ptr = 1;
7333 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_FLAGS_NONE);
7334 init_uni_hdr(&q_u->hdr_srv_name, &q_u->uni_srv_name);
7335 }
7336
7337 /*******************************************************************
7338 reads or writes a structure.
7339 ********************************************************************/
7340
7341 BOOL samr_io_q_get_dom_pwinfo(const char *desc, SAMR_Q_GET_DOM_PWINFO * q_u,
7342 prs_struct *ps, int depth)
7343 {
7344 if (q_u == NULL)
7345 return False;
7346
7347 prs_debug(ps, depth, desc, "samr_io_q_get_dom_pwinfo");
7348 depth++;
7349
7350 if(!prs_align(ps))
7351 return False;
7352
7353 if(!prs_uint32("ptr", ps, depth, &q_u->ptr))
7354 return False;
7355 if (q_u->ptr != 0) {
7356 if(!smb_io_unihdr("", &q_u->hdr_srv_name, ps, depth))
7357 return False;
7358 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->hdr_srv_name.buffer, ps, depth))
7359 return False;
7360 }
7361
7362 return True;
7363 }
7364
7365 /*******************************************************************
7366 reads or writes a structure.
7367 ********************************************************************/
7368
7369 BOOL samr_io_r_get_dom_pwinfo(const char *desc, SAMR_R_GET_DOM_PWINFO * r_u,
7370 prs_struct *ps, int depth)
7371 {
7372 if (r_u == NULL)
7373 return False;
7374
7375 prs_debug(ps, depth, desc, "samr_io_r_get_dom_pwinfo");
7376 depth++;
7377
7378 if(!prs_align(ps))
7379 return False;
7380
7381 if(!prs_uint16("min_pwd_length", ps, depth, &r_u->min_pwd_length))
7382 return False;
7383 if(!prs_align(ps))
7384 return False;
7385 if(!prs_uint32("password_properties", ps, depth, &r_u->password_properties))
7386 return False;
7387
7388 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7389 return False;
7390
7391 return True;
7392 }
7393
7394 /*******************************************************************
7395 make a SAMR_ENC_PASSWD structure.
7396 ********************************************************************/
7397
7398 void init_enc_passwd(SAMR_ENC_PASSWD * pwd, const char pass[512])
7399 {
7400 ZERO_STRUCTP(pwd);
7401
7402 if (pass == NULL) {
7403 pwd->ptr = 0;
7404 } else {
7405 pwd->ptr = 1;
7406 memcpy(pwd->pass, pass, sizeof(pwd->pass));
7407 }
7408 }
7409
7410 /*******************************************************************
7411 reads or writes a SAMR_ENC_PASSWD structure.
7412 ********************************************************************/
7413
7414 BOOL samr_io_enc_passwd(const char *desc, SAMR_ENC_PASSWD * pwd,
7415 prs_struct *ps, int depth)
7416 {
7417 if (pwd == NULL)
7418 return False;
7419
7420 prs_debug(ps, depth, desc, "samr_io_enc_passwd");
7421 depth++;
7422
7423 if(!prs_align(ps))
7424 return False;
7425
7426 if(!prs_uint32("ptr", ps, depth, &pwd->ptr))
7427 return False;
7428
7429 if (pwd->ptr != 0) {
7430 if(!prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass)))
7431 return False;
7432 }
7433
7434 return True;
7435 }
7436
7437 /*******************************************************************
7438 inits a SAMR_ENC_HASH structure.
7439 ********************************************************************/
7440
7441 void init_enc_hash(SAMR_ENC_HASH * hsh, const uchar hash[16])
7442 {
7443 ZERO_STRUCTP(hsh);
7444
7445 if (hash == NULL) {
7446 hsh->ptr = 0;
7447 } else {
7448 hsh->ptr = 1;
7449 memcpy(hsh->hash, hash, sizeof(hsh->hash));
7450 }
7451 }
7452
7453 /*******************************************************************
7454 reads or writes a SAMR_ENC_HASH structure.
7455 ********************************************************************/
7456
7457 BOOL samr_io_enc_hash(const char *desc, SAMR_ENC_HASH * hsh,
7458 prs_struct *ps, int depth)
7459 {
7460 if (hsh == NULL)
7461 return False;
7462
7463 prs_debug(ps, depth, desc, "samr_io_enc_hash");
7464 depth++;
7465
7466 if(!prs_align(ps))
7467 return False;
7468
7469 if(!prs_uint32("ptr ", ps, depth, &hsh->ptr))
7470 return False;
7471 if (hsh->ptr != 0) {
7472 if(!prs_uint8s(False, "hash", ps, depth, hsh->hash,sizeof(hsh->hash)))
7473 return False;
7474 }
7475
7476 return True;
7477 }
7478
7479 /*******************************************************************
7480 inits a SAMR_Q_CHGPASSWD_USER structure.
7481 ********************************************************************/
7482
7483 void init_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER * q_u,
7484 const char *dest_host, const char *user_name,
7485 const uchar nt_newpass[516],
7486 const uchar nt_oldhash[16],
7487 const uchar lm_newpass[516],
7488 const uchar lm_oldhash[16])
7489 {
7490 DEBUG(5, ("init_samr_q_chgpasswd_user\n"));
7491
7492 q_u->ptr_0 = 1;
7493 init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7494 init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7495
7496 init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7497 init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7498
7499 init_enc_passwd(&q_u->nt_newpass, (const char *)nt_newpass);
7500 init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7501
7502 q_u->unknown = 0x01;
7503
7504 init_enc_passwd(&q_u->lm_newpass, (const char *)lm_newpass);
7505 init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7506 }
7507
7508 /*******************************************************************
7509 reads or writes a structure.
7510 ********************************************************************/
7511
7512 BOOL samr_io_q_chgpasswd_user(const char *desc, SAMR_Q_CHGPASSWD_USER * q_u,
7513 prs_struct *ps, int depth)
7514 {
7515 if (q_u == NULL)
7516 return False;
7517
7518 prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
7519 depth++;
7520
7521 if(!prs_align(ps))
7522 return False;
7523
7524 if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7525 return False;
7526
7527 if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7528 return False;
7529 if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7530 return False;
7531
7532 if(!prs_align(ps))
7533 return False;
7534 if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7535 return False;
7536 if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7537 return False;
7538
7539 if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7540 return False;
7541 if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7542 return False;
7543
7544 if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
7545 return False;
7546
7547 if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7548 return False;
7549 if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7550 return False;
7551
7552 return True;
7553 }
7554
7555 /*******************************************************************
7556 inits a SAMR_R_CHGPASSWD_USER structure.
7557 ********************************************************************/
7558
7559 void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER * r_u, NTSTATUS status)
7560 {
7561 DEBUG(5, ("init_samr_r_chgpasswd_user\n"));
7562
7563 r_u->status = status;
7564 }
7565
7566 /*******************************************************************
7567 reads or writes a structure.
7568 ********************************************************************/
7569
7570 BOOL samr_io_r_chgpasswd_user(const char *desc, SAMR_R_CHGPASSWD_USER * r_u,
7571 prs_struct *ps, int depth)
7572 {
7573 if (r_u == NULL)
7574 return False;
7575
7576 prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
7577 depth++;
7578
7579 if(!prs_align(ps))
7580 return False;
7581
7582 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7583 return False;
7584
7585 return True;
7586 }
7587
7588 /*******************************************************************
7589 inits a SAMR_Q_CHGPASSWD3 structure.
7590 ********************************************************************/
7591
7592 void init_samr_q_chgpasswd_user3(SAMR_Q_CHGPASSWD_USER3 * q_u,
7593 const char *dest_host, const char *user_name,
7594 const uchar nt_newpass[516],
7595 const uchar nt_oldhash[16],
7596 const uchar lm_newpass[516],
7597 const uchar lm_oldhash[16])
7598 {
7599 DEBUG(5, ("init_samr_q_chgpasswd_user3\n"));
7600
7601 q_u->ptr_0 = 1;
7602 init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7603 init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7604
7605 init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7606 init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7607
7608 init_enc_passwd(&q_u->nt_newpass, (const char *)nt_newpass);
7609 init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7610
7611 q_u->lm_change = 0x01;
7612
7613 init_enc_passwd(&q_u->lm_newpass, (const char *)lm_newpass);
7614 init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7615
7616 init_enc_passwd(&q_u->password3, NULL);
7617 }
7618
7619 /*******************************************************************
7620 reads or writes a structure.
7621 ********************************************************************/
7622
7623 BOOL samr_io_q_chgpasswd_user3(const char *desc, SAMR_Q_CHGPASSWD_USER3 * q_u,
7624 prs_struct *ps, int depth)
7625 {
7626 if (q_u == NULL)
7627 return False;
7628
7629 prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user3");
7630 depth++;
7631
7632 if(!prs_align(ps))
7633 return False;
7634
7635 if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7636 return False;
7637
7638 if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7639 return False;
7640 if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7641 return False;
7642
7643 if(!prs_align(ps))
7644 return False;
7645 if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7646 return False;
7647 if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7648 return False;
7649
7650 if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7651 return False;
7652 if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7653 return False;
7654
7655 if(!prs_uint32("lm_change", ps, depth, &q_u->lm_change))
7656 return False;
7657
7658 if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7659 return False;
7660 if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7661 return False;
7662
7663 if(!samr_io_enc_passwd("password3", &q_u->password3, ps, depth))
7664 return False;
7665
7666 return True;
7667 }
7668
7669 /*******************************************************************
7670 inits a SAMR_R_CHGPASSWD_USER3 structure.
7671 ********************************************************************/
7672
7673 void init_samr_r_chgpasswd_user3(SAMR_R_CHGPASSWD_USER3 *r_u, NTSTATUS status,
7674 SAMR_CHANGE_REJECT *reject, SAM_UNK_INFO_1 *info)
7675 {
7676 DEBUG(5, ("init_samr_r_chgpasswd_user3\n"));
7677
7678 r_u->status = status;
7679 r_u->info = 0;
7680 r_u->ptr_info = 0;
7681 r_u->reject = 0;
7682 r_u->ptr_reject = 0;
7683
7684 if (info) {
7685 r_u->info = info;
7686 r_u->ptr_info = 1;
7687 }
7688 if (reject && (reject->reject_reason != Undefined)) {
7689 r_u->reject = reject;
7690 r_u->ptr_reject = 1;
7691 }
7692 }
7693
7694 /*******************************************************************
7695 Reads or writes an SAMR_CHANGE_REJECT structure.
7696 ********************************************************************/
7697
7698 BOOL samr_io_change_reject(const char *desc, SAMR_CHANGE_REJECT *reject, prs_struct *ps, int depth)
7699 {
7700 if (reject == NULL)
7701 return False;
7702
7703 prs_debug(ps, depth, desc, "samr_io_change_reject");
7704 depth++;
7705
7706 if(!prs_align(ps))
7707 return False;
7708
7709 if(UNMARSHALLING(ps))
7710 ZERO_STRUCTP(reject);
7711
7712 if (!prs_uint32("reject_reason", ps, depth, &reject->reject_reason))
7713 return False;
7714
7715 if (!prs_uint32("unknown1", ps, depth, &reject->unknown1))
7716 return False;
7717
7718 if (!prs_uint32("unknown2", ps, depth, &reject->unknown2))
7719 return False;
7720
7721 return True;
7722 }
7723
7724 /*******************************************************************
7725 reads or writes a structure.
7726 ********************************************************************/
7727
7728 BOOL samr_io_r_chgpasswd_user3(const char *desc, SAMR_R_CHGPASSWD_USER3 *r_u,
7729 prs_struct *ps, int depth)
7730 {
7731 if (r_u == NULL)
7732 return False;
7733
7734 prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user3");
7735 depth++;
7736
7737 if (!prs_align(ps))
7738 return False;
7739
7740 if (!prs_uint32("ptr_info", ps, depth, &r_u->ptr_info))
7741 return False;
7742
7743 /* special case: Windows 2000 can return stub data here saying
7744 NT_STATUS_NOT_SUPPORTED */
7745
7746 if ( NT_STATUS_EQUAL( NT_STATUS_NOT_SUPPORTED, NT_STATUS(r_u->ptr_info)) ) {
7747 r_u->status = NT_STATUS_NOT_SUPPORTED;
7748 return True;
7749 }
7750
7751 if (r_u->ptr_info && r_u->info != NULL) {
7752 /* SAM_UNK_INFO_1 */
7753 if (!sam_io_unk_info1("info", r_u->info, ps, depth))
7754 return False;
7755 }
7756
7757 if (!prs_uint32("ptr_reject", ps, depth, &r_u->ptr_reject))
7758 return False;
7759
7760 if (r_u->ptr_reject && r_u->reject != NULL) {
7761 /* SAMR_CHANGE_REJECT */
7762 if (!samr_io_change_reject("reject", r_u->reject, ps, depth))
7763 return False;
7764 }
7765
7766 if (!prs_ntstatus("status", ps, depth, &r_u->status))
7767 return False;
7768
7769 return True;
7770 }
7771
7772 /*******************************************************************
7773 reads or writes a structure.
7774 ********************************************************************/
7775
7776 void init_samr_q_query_domain_info2(SAMR_Q_QUERY_DOMAIN_INFO2 *q_u,
7777 POLICY_HND *domain_pol, uint16 switch_value)
7778 {
7779 DEBUG(5, ("init_samr_q_query_domain_info2\n"));
7780
7781 q_u->domain_pol = *domain_pol;
7782 q_u->switch_value = switch_value;
7783 }
7784
7785 /*******************************************************************
7786 reads or writes a structure.
7787 ********************************************************************/
7788
7789 BOOL samr_io_q_query_domain_info2(const char *desc, SAMR_Q_QUERY_DOMAIN_INFO2 *q_u,
7790 prs_struct *ps, int depth)
7791 {
7792 if (q_u == NULL)
7793 return False;
7794
7795 prs_debug(ps, depth, desc, "samr_io_q_query_domain_info2");
7796 depth++;
7797
7798 if(!prs_align(ps))
7799 return False;
7800
7801 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7802 return False;
7803
7804 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7805 return False;
7806
7807 return True;
7808 }
7809
7810 /*******************************************************************
7811 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7812 ********************************************************************/
7813
7814 void init_samr_r_query_domain_info2(SAMR_R_QUERY_DOMAIN_INFO2 * r_u,
7815 uint16 switch_value, SAM_UNK_CTR * ctr,
7816 NTSTATUS status)
7817 {
7818 DEBUG(5, ("init_samr_r_query_domain_info2\n"));
7819
7820 r_u->ptr_0 = 0;
7821 r_u->switch_value = 0;
7822 r_u->status = status; /* return status */
7823
7824 if (NT_STATUS_IS_OK(status)) {
7825 r_u->switch_value = switch_value;
7826 r_u->ptr_0 = 1;
7827 r_u->ctr = ctr;
7828 }
7829 }
7830
7831 /*******************************************************************
7832 reads or writes a structure.
7833 ********************************************************************/
7834
7835 BOOL samr_io_r_query_domain_info2(const char *desc, SAMR_R_QUERY_DOMAIN_INFO2 * r_u,
7836 prs_struct *ps, int depth)
7837 {
7838 if (r_u == NULL)
7839 return False;
7840
7841 prs_debug(ps, depth, desc, "samr_io_r_query_domain_info2");
7842 depth++;
7843
7844 if(!prs_align(ps))
7845 return False;
7846
7847 if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
7848 return False;
7849
7850 if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
7851 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
7852 return False;
7853 if(!prs_align(ps))
7854 return False;
7855
7856 switch (r_u->switch_value) {
7857 case 0x0d:
7858 if(!sam_io_unk_info13("unk_inf13", &r_u->ctr->info.inf13, ps, depth))
7859 return False;
7860 break;
7861 case 0x0c:
7862 if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
7863 return False;
7864 break;
7865 case 0x09:
7866 if(!sam_io_unk_info9("unk_inf9",&r_u->ctr->info.inf9, ps,depth))
7867 return False;
7868 break;
7869 case 0x08:
7870 if(!sam_io_unk_info8("unk_inf8",&r_u->ctr->info.inf8, ps,depth))
7871 return False;
7872 break;
7873 case 0x07:
7874 if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
7875 return False;
7876 break;
7877 case 0x06:
7878 if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
7879 return False;
7880 break;
7881 case 0x05:
7882 if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
7883 return False;
7884 break;
7885 case 0x04:
7886 if(!sam_io_unk_info4("unk_inf4",&r_u->ctr->info.inf4, ps,depth))
7887 return False;
7888 break;
7889 case 0x03:
7890 if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
7891 return False;
7892 break;
7893 case 0x02:
7894 if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
7895 return False;
7896 break;
7897 case 0x01:
7898 if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
7899 return False;
7900 break;
7901 default:
7902 DEBUG(0, ("samr_io_r_query_domain_info2: unknown switch level 0x%x\n",
7903 r_u->switch_value));
7904 r_u->status = NT_STATUS_INVALID_INFO_CLASS;
7905 return False;
7906 }
7907 }
7908
7909 if(!prs_align(ps))
7910 return False;
7911
7912 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7913 return False;
7914
7915 return True;
7916 }
7917
7918
7919 /*******************************************************************
7920 reads or writes a structure.
7921 ********************************************************************/
7922
7923 void init_samr_q_set_domain_info(SAMR_Q_SET_DOMAIN_INFO *q_u,
7924 POLICY_HND *domain_pol, uint16 switch_value, SAM_UNK_CTR *ctr)
7925 {
7926 DEBUG(5, ("init_samr_q_set_domain_info\n"));
7927
7928 q_u->domain_pol = *domain_pol;
7929 q_u->switch_value0 = switch_value;
7930
7931 q_u->switch_value = switch_value;
7932 q_u->ctr = ctr;
7933
7934 }
7935
7936 /*******************************************************************
7937 reads or writes a structure.
7938 ********************************************************************/
7939
7940 BOOL samr_io_q_set_domain_info(const char *desc, SAMR_Q_SET_DOMAIN_INFO *q_u,
7941 prs_struct *ps, int depth)
7942 {
7943 if (q_u == NULL)
7944 return False;
7945
7946 prs_debug(ps, depth, desc, "samr_io_q_set_domain_info");
7947 depth++;
7948
7949 if(!prs_align(ps))
7950 return False;
7951
7952 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7953 return False;
7954
7955 if(!prs_uint16("switch_value0", ps, depth, &q_u->switch_value0))
7956 return False;
7957
7958 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7959 return False;
7960
7961 if(!prs_align(ps))
7962 return False;
7963
7964 if (UNMARSHALLING(ps)) {
7965 if ((q_u->ctr = PRS_ALLOC_MEM(ps, SAM_UNK_CTR, 1)) == NULL)
7966 return False;
7967 }
7968
7969 switch (q_u->switch_value) {
7970
7971 case 0x0c:
7972 if(!sam_io_unk_info12("unk_inf12", &q_u->ctr->info.inf12, ps, depth))
7973 return False;
7974 break;
7975 case 0x07:
7976 if(!sam_io_unk_info7("unk_inf7",&q_u->ctr->info.inf7, ps,depth))
7977 return False;
7978 break;
7979 case 0x06:
7980 if(!sam_io_unk_info6("unk_inf6",&q_u->ctr->info.inf6, ps,depth))
7981 return False;
7982 break;
7983 case 0x05:
7984 if(!sam_io_unk_info5("unk_inf5",&q_u->ctr->info.inf5, ps,depth))
7985 return False;
7986 break;
7987 case 0x03:
7988 if(!sam_io_unk_info3("unk_inf3",&q_u->ctr->info.inf3, ps,depth))
7989 return False;
7990 break;
7991 case 0x02:
7992 if(!sam_io_unk_info2("unk_inf2",&q_u->ctr->info.inf2, ps,depth))
7993 return False;
7994 break;
7995 case 0x01:
7996 if(!sam_io_unk_info1("unk_inf1",&q_u->ctr->info.inf1, ps,depth))
7997 return False;
7998 break;
7999 default:
8000 DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
8001 q_u->switch_value));
8002 return False;
8003 }
8004
8005 return True;
8006 }
8007
8008 /*******************************************************************
8009 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
8010 ********************************************************************/
8011
8012 void init_samr_r_set_domain_info(SAMR_R_SET_DOMAIN_INFO * r_u, NTSTATUS status)
8013 {
8014 DEBUG(5, ("init_samr_r_set_domain_info\n"));
8015
8016 r_u->status = status; /* return status */
8017 }
8018
8019 /*******************************************************************
8020 reads or writes a structure.
8021 ********************************************************************/
8022
8023 BOOL samr_io_r_set_domain_info(const char *desc, SAMR_R_SET_DOMAIN_INFO * r_u,
8024 prs_struct *ps, int depth)
8025 {
8026 if (r_u == NULL)
8027 return False;
8028
8029 prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
8030 depth++;
8031
8032 if(!prs_align(ps))
8033 return False;
8034
8035 if(!prs_ntstatus("status", ps, depth, &r_u->status))
8036 return False;
8037
8038 return True;
8039 }
Samba GIT mirror