?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r18369: I've got a sniff where NT4 sends just a single byte after the 516 byte
[Samba/bb.git] / source / rpc_parse / parse_samr.c
blob58ba3e8689954c8008a4eb4bbcc4598259588240
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)) {
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)) {
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 q_u->rid = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids );
4179 if (q_u->rid == NULL) {
4180 q_u->num_rids1 = 0;
4181 q_u->num_rids2 = 0;
4182 } else {
4183 memcpy(q_u->rid, rid, num_rids * sizeof(q_u->rid[0]));
4184 }
4185 }
4186
4187 /*******************************************************************
4188 reads or writes a structure.
4189 ********************************************************************/
4190
4191 BOOL samr_io_q_lookup_rids(const char *desc, SAMR_Q_LOOKUP_RIDS * q_u,
4192 prs_struct *ps, int depth)
4193 {
4194 uint32 i;
4195 fstring tmp;
4196
4197 if (q_u == NULL)
4198 return False;
4199
4200 prs_debug(ps, depth, desc, "samr_io_q_lookup_rids");
4201 depth++;
4202
4203 if (UNMARSHALLING(ps))
4204 ZERO_STRUCTP(q_u);
4205
4206 if(!prs_align(ps))
4207 return False;
4208
4209 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4210 return False;
4211
4212 if(!prs_uint32("num_rids1", ps, depth, &q_u->num_rids1))
4213 return False;
4214 if(!prs_uint32("flags ", ps, depth, &q_u->flags))
4215 return False;
4216 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
4217 return False;
4218 if(!prs_uint32("num_rids2", ps, depth, &q_u->num_rids2))
4219 return False;
4220
4221 if (UNMARSHALLING(ps) && (q_u->num_rids2 != 0)) {
4222 q_u->rid = PRS_ALLOC_MEM(ps, uint32, q_u->num_rids2);
4223 if (q_u->rid == NULL)
4224 return False;
4225 }
4226
4227 for (i = 0; i < q_u->num_rids2; i++) {
4228 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d] ", i);
4229 if(!prs_uint32(tmp, ps, depth, &q_u->rid[i]))
4230 return False;
4231 }
4232
4233 return True;
4234 }
4235
4236 /*******************************************************************
4237 inits a SAMR_R_LOOKUP_RIDS structure.
4238 ********************************************************************/
4239
4240 void init_samr_r_lookup_rids(SAMR_R_LOOKUP_RIDS * r_u,
4241 uint32 num_names, UNIHDR * hdr_name,
4242 UNISTR2 *uni_name, uint32 *type)
4243 {
4244 DEBUG(5, ("init_samr_r_lookup_rids\n"));
4245
4246 r_u->hdr_name = NULL;
4247 r_u->uni_name = NULL;
4248 r_u->type = NULL;
4249
4250 if (num_names != 0) {
4251 r_u->num_names1 = num_names;
4252 r_u->ptr_names = 1;
4253 r_u->num_names2 = num_names;
4254
4255 r_u->num_types1 = num_names;
4256 r_u->ptr_types = 1;
4257 r_u->num_types2 = num_names;
4258
4259 r_u->hdr_name = hdr_name;
4260 r_u->uni_name = uni_name;
4261 r_u->type = type;
4262 } else {
4263 r_u->num_names1 = num_names;
4264 r_u->ptr_names = 0;
4265 r_u->num_names2 = num_names;
4266
4267 r_u->num_types1 = num_names;
4268 r_u->ptr_types = 0;
4269 r_u->num_types2 = num_names;
4270 }
4271 }
4272
4273 /*******************************************************************
4274 reads or writes a structure.
4275 ********************************************************************/
4276
4277 BOOL samr_io_r_lookup_rids(const char *desc, SAMR_R_LOOKUP_RIDS * r_u,
4278 prs_struct *ps, int depth)
4279 {
4280 uint32 i;
4281 fstring tmp;
4282 if (r_u == NULL)
4283 return False;
4284
4285 prs_debug(ps, depth, desc, "samr_io_r_lookup_rids");
4286 depth++;
4287
4288 if(!prs_align(ps))
4289 return False;
4290
4291 if(!prs_uint32("num_names1", ps, depth, &r_u->num_names1))
4292 return False;
4293 if(!prs_uint32("ptr_names ", ps, depth, &r_u->ptr_names))
4294 return False;
4295
4296 if (r_u->ptr_names != 0) {
4297
4298 if(!prs_uint32("num_names2", ps, depth, &r_u->num_names2))
4299 return False;
4300
4301
4302 if (UNMARSHALLING(ps) && (r_u->num_names2 != 0)) {
4303 r_u->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, r_u->num_names2);
4304 if (r_u->hdr_name == NULL)
4305 return False;
4306
4307 r_u->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, r_u->num_names2);
4308 if (r_u->uni_name == NULL)
4309 return False;
4310 }
4311
4312 for (i = 0; i < r_u->num_names2; i++) {
4313 slprintf(tmp, sizeof(tmp) - 1, "hdr[%02d] ", i);
4314 if(!smb_io_unihdr("", &r_u->hdr_name[i], ps, depth))
4315 return False;
4316 }
4317 for (i = 0; i < r_u->num_names2; i++) {
4318 slprintf(tmp, sizeof(tmp) - 1, "str[%02d] ", i);
4319 if(!smb_io_unistr2("", &r_u->uni_name[i], r_u->hdr_name[i].buffer, ps, depth))
4320 return False;
4321 }
4322
4323 }
4324
4325 if(!prs_align(ps))
4326 return False;
4327 if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
4328 return False;
4329 if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
4330 return False;
4331
4332 if (r_u->ptr_types != 0) {
4333
4334 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
4335 return False;
4336
4337 if (UNMARSHALLING(ps) && (r_u->num_types2 != 0)) {
4338 r_u->type = PRS_ALLOC_MEM(ps, uint32, r_u->num_types2);
4339 if (r_u->type == NULL)
4340 return False;
4341 }
4342
4343 for (i = 0; i < r_u->num_types2; i++) {
4344 slprintf(tmp, sizeof(tmp) - 1, "type[%02d] ", i);
4345 if(!prs_uint32(tmp, ps, depth, &r_u->type[i]))
4346 return False;
4347 }
4348 }
4349
4350 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4351 return False;
4352
4353 return True;
4354 }
4355
4356 /*******************************************************************
4357 inits a SAMR_Q_OPEN_ALIAS structure.
4358 ********************************************************************/
4359
4360 void init_samr_q_delete_alias(SAMR_Q_DELETE_DOM_ALIAS * q_u, POLICY_HND *hnd)
4361 {
4362 DEBUG(5, ("init_samr_q_delete_alias\n"));
4363
4364 q_u->alias_pol = *hnd;
4365 }
4366
4367 /*******************************************************************
4368 reads or writes a structure.
4369 ********************************************************************/
4370
4371 BOOL samr_io_q_delete_alias(const char *desc, SAMR_Q_DELETE_DOM_ALIAS * q_u,
4372 prs_struct *ps, int depth)
4373 {
4374 if (q_u == NULL)
4375 return False;
4376
4377 prs_debug(ps, depth, desc, "samr_io_q_delete_alias");
4378 depth++;
4379
4380 if(!prs_align(ps))
4381 return False;
4382
4383 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4384 return False;
4385
4386 return True;
4387 }
4388
4389 /*******************************************************************
4390 reads or writes a structure.
4391 ********************************************************************/
4392
4393 BOOL samr_io_r_delete_alias(const char *desc, SAMR_R_DELETE_DOM_ALIAS * r_u,
4394 prs_struct *ps, int depth)
4395 {
4396 if (r_u == NULL)
4397 return False;
4398
4399 prs_debug(ps, depth, desc, "samr_io_r_delete_alias");
4400 depth++;
4401
4402 if(!prs_align(ps))
4403 return False;
4404
4405 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4406 return False;
4407 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4408 return False;
4409
4410 return True;
4411 }
4412
4413 /*******************************************************************
4414 inits a SAMR_Q_CREATE_DOM_ALIAS structure.
4415 ********************************************************************/
4416
4417 void init_samr_q_create_dom_alias(SAMR_Q_CREATE_DOM_ALIAS * q_u,
4418 POLICY_HND *hnd, const char *acct_desc)
4419 {
4420 DEBUG(5, ("init_samr_q_create_dom_alias\n"));
4421
4422 q_u->dom_pol = *hnd;
4423
4424 init_unistr2(&q_u->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
4425 init_uni_hdr(&q_u->hdr_acct_desc, &q_u->uni_acct_desc);
4426
4427 q_u->access_mask = MAXIMUM_ALLOWED_ACCESS;
4428 }
4429
4430 /*******************************************************************
4431 reads or writes a structure.
4432 ********************************************************************/
4433
4434 BOOL samr_io_q_create_dom_alias(const char *desc, SAMR_Q_CREATE_DOM_ALIAS * q_u,
4435 prs_struct *ps, int depth)
4436 {
4437 if (q_u == NULL)
4438 return False;
4439
4440 prs_debug(ps, depth, desc, "samr_io_q_create_dom_alias");
4441 depth++;
4442
4443 if(!prs_align(ps))
4444 return False;
4445
4446 if(!smb_io_pol_hnd("dom_pol", &q_u->dom_pol, ps, depth))
4447 return False;
4448
4449 if(!smb_io_unihdr("hdr_acct_desc", &q_u->hdr_acct_desc, ps, depth))
4450 return False;
4451 if(!smb_io_unistr2("uni_acct_desc", &q_u->uni_acct_desc,
4452 q_u->hdr_acct_desc.buffer, ps, depth))
4453 return False;
4454
4455 if(!prs_align(ps))
4456 return False;
4457 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
4458 return False;
4459
4460 return True;
4461 }
4462
4463 /*******************************************************************
4464 reads or writes a structure.
4465 ********************************************************************/
4466
4467 BOOL samr_io_r_create_dom_alias(const char *desc, SAMR_R_CREATE_DOM_ALIAS * r_u,
4468 prs_struct *ps, int depth)
4469 {
4470 if (r_u == NULL)
4471 return False;
4472
4473 prs_debug(ps, depth, desc, "samr_io_r_create_dom_alias");
4474 depth++;
4475
4476 if(!prs_align(ps))
4477 return False;
4478
4479 if(!smb_io_pol_hnd("alias_pol", &r_u->alias_pol, ps, depth))
4480 return False;
4481
4482 if(!prs_uint32("rid", ps, depth, &r_u->rid))
4483 return False;
4484
4485 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4486 return False;
4487
4488 return True;
4489 }
4490
4491 /*******************************************************************
4492 inits a SAMR_Q_ADD_ALIASMEM structure.
4493 ********************************************************************/
4494
4495 void init_samr_q_add_aliasmem(SAMR_Q_ADD_ALIASMEM * q_u, POLICY_HND *hnd,
4496 DOM_SID *sid)
4497 {
4498 DEBUG(5, ("init_samr_q_add_aliasmem\n"));
4499
4500 q_u->alias_pol = *hnd;
4501 init_dom_sid2(&q_u->sid, sid);
4502 }
4503
4504 /*******************************************************************
4505 reads or writes a structure.
4506 ********************************************************************/
4507
4508 BOOL samr_io_q_add_aliasmem(const char *desc, SAMR_Q_ADD_ALIASMEM * q_u,
4509 prs_struct *ps, int depth)
4510 {
4511 if (q_u == NULL)
4512 return False;
4513
4514 prs_debug(ps, depth, desc, "samr_io_q_add_aliasmem");
4515 depth++;
4516
4517 if(!prs_align(ps))
4518 return False;
4519
4520 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4521 return False;
4522 if(!smb_io_dom_sid2("sid ", &q_u->sid, ps, depth))
4523 return False;
4524
4525 return True;
4526 }
4527
4528 /*******************************************************************
4529 reads or writes a structure.
4530 ********************************************************************/
4531
4532 BOOL samr_io_r_add_aliasmem(const char *desc, SAMR_R_ADD_ALIASMEM * r_u,
4533 prs_struct *ps, int depth)
4534 {
4535 if (r_u == NULL)
4536 return False;
4537
4538 prs_debug(ps, depth, desc, "samr_io_r_add_aliasmem");
4539 depth++;
4540
4541 if(!prs_align(ps))
4542 return False;
4543
4544 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4545 return False;
4546
4547 return True;
4548 }
4549
4550 /*******************************************************************
4551 inits a SAMR_Q_DEL_ALIASMEM structure.
4552 ********************************************************************/
4553
4554 void init_samr_q_del_aliasmem(SAMR_Q_DEL_ALIASMEM * q_u, POLICY_HND *hnd,
4555 DOM_SID *sid)
4556 {
4557 DEBUG(5, ("init_samr_q_del_aliasmem\n"));
4558
4559 q_u->alias_pol = *hnd;
4560 init_dom_sid2(&q_u->sid, sid);
4561 }
4562
4563 /*******************************************************************
4564 reads or writes a structure.
4565 ********************************************************************/
4566
4567 BOOL samr_io_q_del_aliasmem(const char *desc, SAMR_Q_DEL_ALIASMEM * q_u,
4568 prs_struct *ps, int depth)
4569 {
4570 if (q_u == NULL)
4571 return False;
4572
4573 prs_debug(ps, depth, desc, "samr_io_q_del_aliasmem");
4574 depth++;
4575
4576 if(!prs_align(ps))
4577 return False;
4578
4579 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4580 return False;
4581 if(!smb_io_dom_sid2("sid ", &q_u->sid, ps, depth))
4582 return False;
4583
4584 return True;
4585 }
4586
4587 /*******************************************************************
4588 reads or writes a structure.
4589 ********************************************************************/
4590
4591 BOOL samr_io_r_del_aliasmem(const char *desc, SAMR_R_DEL_ALIASMEM * r_u,
4592 prs_struct *ps, int depth)
4593 {
4594 if (r_u == NULL)
4595 return False;
4596
4597 prs_debug(ps, depth, desc, "samr_io_r_del_aliasmem");
4598 depth++;
4599
4600 if(!prs_align(ps))
4601 return False;
4602
4603 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4604 return False;
4605
4606 return True;
4607 }
4608
4609 /*******************************************************************
4610 inits a SAMR_Q_DELETE_DOM_ALIAS structure.
4611 ********************************************************************/
4612
4613 void init_samr_q_delete_dom_alias(SAMR_Q_DELETE_DOM_ALIAS * q_c,
4614 POLICY_HND *hnd)
4615 {
4616 DEBUG(5, ("init_samr_q_delete_dom_alias\n"));
4617
4618 q_c->alias_pol = *hnd;
4619 }
4620
4621 /*******************************************************************
4622 reads or writes a structure.
4623 ********************************************************************/
4624
4625 BOOL samr_io_q_delete_dom_alias(const char *desc, SAMR_Q_DELETE_DOM_ALIAS * q_u,
4626 prs_struct *ps, int depth)
4627 {
4628 if (q_u == NULL)
4629 return False;
4630
4631 prs_debug(ps, depth, desc, "samr_io_q_delete_dom_alias");
4632 depth++;
4633
4634 if(!prs_align(ps))
4635 return False;
4636
4637 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4638 return False;
4639
4640 return True;
4641 }
4642
4643 /*******************************************************************
4644 inits a SAMR_R_DELETE_DOM_ALIAS structure.
4645 ********************************************************************/
4646
4647 void init_samr_r_delete_dom_alias(SAMR_R_DELETE_DOM_ALIAS * r_u,
4648 NTSTATUS status)
4649 {
4650 DEBUG(5, ("init_samr_r_delete_dom_alias\n"));
4651
4652 r_u->status = status;
4653 }
4654
4655 /*******************************************************************
4656 reads or writes a structure.
4657 ********************************************************************/
4658
4659 BOOL samr_io_r_delete_dom_alias(const char *desc, SAMR_R_DELETE_DOM_ALIAS * r_u,
4660 prs_struct *ps, int depth)
4661 {
4662 if (r_u == NULL)
4663 return False;
4664
4665 prs_debug(ps, depth, desc, "samr_io_r_delete_dom_alias");
4666 depth++;
4667
4668 if(!prs_align(ps))
4669 return False;
4670
4671 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4672 return False;
4673
4674 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4675 return False;
4676
4677 return True;
4678 }
4679
4680 /*******************************************************************
4681 inits a SAMR_Q_QUERY_ALIASMEM structure.
4682 ********************************************************************/
4683
4684 void init_samr_q_query_aliasmem(SAMR_Q_QUERY_ALIASMEM * q_c,
4685 POLICY_HND *hnd)
4686 {
4687 DEBUG(5, ("init_samr_q_query_aliasmem\n"));
4688
4689 q_c->alias_pol = *hnd;
4690 }
4691
4692 /*******************************************************************
4693 reads or writes a structure.
4694 ********************************************************************/
4695
4696 BOOL samr_io_q_query_aliasmem(const char *desc, SAMR_Q_QUERY_ALIASMEM * q_u,
4697 prs_struct *ps, int depth)
4698 {
4699 if (q_u == NULL)
4700 return False;
4701
4702 prs_debug(ps, depth, desc, "samr_io_q_query_aliasmem");
4703 depth++;
4704
4705 if(!prs_align(ps))
4706 return False;
4707
4708 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4709 return False;
4710
4711 return True;
4712 }
4713
4714 /*******************************************************************
4715 inits a SAMR_R_QUERY_ALIASMEM structure.
4716 ********************************************************************/
4717
4718 void init_samr_r_query_aliasmem(SAMR_R_QUERY_ALIASMEM * r_u,
4719 uint32 num_sids, DOM_SID2 * sid,
4720 NTSTATUS status)
4721 {
4722 DEBUG(5, ("init_samr_r_query_aliasmem\n"));
4723
4724 if (NT_STATUS_IS_OK(status)) {
4725 r_u->num_sids = num_sids;
4726 r_u->ptr = (num_sids != 0) ? 1 : 0;
4727 r_u->num_sids1 = num_sids;
4728
4729 r_u->sid = sid;
4730 } else {
4731 r_u->ptr = 0;
4732 r_u->num_sids = 0;
4733 }
4734
4735 r_u->status = status;
4736 }
4737
4738 /*******************************************************************
4739 reads or writes a structure.
4740 ********************************************************************/
4741
4742 BOOL samr_io_r_query_aliasmem(const char *desc, SAMR_R_QUERY_ALIASMEM * r_u,
4743 prs_struct *ps, int depth)
4744 {
4745 uint32 i;
4746
4747 if (r_u == NULL)
4748 return False;
4749
4750 prs_debug(ps, depth, desc, "samr_io_r_query_aliasmem");
4751 depth++;
4752
4753 if(!prs_align(ps))
4754 return False;
4755
4756 if(!prs_uint32("num_sids ", ps, depth, &r_u->num_sids))
4757 return False;
4758 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
4759 return False;
4760
4761 if (r_u->ptr != 0 && r_u->num_sids != 0) {
4762 uint32 *ptr_sid = NULL;
4763
4764 if(!prs_uint32("num_sids1", ps, depth, &r_u->num_sids1))
4765 return False;
4766
4767 ptr_sid = TALLOC_ARRAY(ps->mem_ctx, uint32, r_u->num_sids1);
4768 if (!ptr_sid) {
4769 return False;
4770 }
4771
4772 for (i = 0; i < r_u->num_sids1; i++) {
4773 ptr_sid[i] = 1;
4774 if(!prs_uint32("ptr_sid", ps, depth, &ptr_sid[i]))
4775 return False;
4776 }
4777
4778 if (UNMARSHALLING(ps)) {
4779 r_u->sid = TALLOC_ARRAY(ps->mem_ctx, DOM_SID2, r_u->num_sids1);
4780 }
4781
4782 for (i = 0; i < r_u->num_sids1; i++) {
4783 if (ptr_sid[i] != 0) {
4784 if(!smb_io_dom_sid2("sid", &r_u->sid[i], ps, depth))
4785 return False;
4786 }
4787 }
4788 }
4789
4790 if(!prs_align(ps))
4791 return False;
4792 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4793 return False;
4794
4795 return True;
4796 }
4797
4798 /*******************************************************************
4799 inits a SAMR_Q_LOOKUP_NAMES structure.
4800 ********************************************************************/
4801
4802 NTSTATUS init_samr_q_lookup_names(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_NAMES * q_u,
4803 POLICY_HND *pol, uint32 flags,
4804 uint32 num_names, const char **name)
4805 {
4806 uint32 i;
4807
4808 DEBUG(5, ("init_samr_q_lookup_names\n"));
4809
4810 q_u->pol = *pol;
4811
4812 q_u->num_names1 = num_names;
4813 q_u->flags = flags;
4814 q_u->ptr = 0;
4815 q_u->num_names2 = num_names;
4816
4817 if (!(q_u->hdr_name = TALLOC_ZERO_ARRAY(ctx, UNIHDR, num_names)))
4818 return NT_STATUS_NO_MEMORY;
4819
4820 if (!(q_u->uni_name = TALLOC_ZERO_ARRAY(ctx, UNISTR2, num_names)))
4821 return NT_STATUS_NO_MEMORY;
4822
4823 for (i = 0; i < num_names; i++) {
4824 init_unistr2(&q_u->uni_name[i], name[i], UNI_FLAGS_NONE); /* unicode string for machine account */
4825 init_uni_hdr(&q_u->hdr_name[i], &q_u->uni_name[i]); /* unicode header for user_name */
4826 }
4827
4828 return NT_STATUS_OK;
4829 }
4830
4831 /*******************************************************************
4832 reads or writes a structure.
4833 ********************************************************************/
4834
4835 BOOL samr_io_q_lookup_names(const char *desc, SAMR_Q_LOOKUP_NAMES * q_u,
4836 prs_struct *ps, int depth)
4837 {
4838 uint32 i;
4839
4840 if (q_u == NULL)
4841 return False;
4842
4843 prs_debug(ps, depth, desc, "samr_io_q_lookup_names");
4844 depth++;
4845
4846 if (UNMARSHALLING(ps))
4847 ZERO_STRUCTP(q_u);
4848
4849 if(!prs_align(ps))
4850 return False;
4851
4852 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4853 return False;
4854
4855 if(!prs_uint32("num_names1", ps, depth, &q_u->num_names1))
4856 return False;
4857 if(!prs_uint32("flags ", ps, depth, &q_u->flags))
4858 return False;
4859 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
4860 return False;
4861 if(!prs_uint32("num_names2", ps, depth, &q_u->num_names2))
4862 return False;
4863
4864 if (UNMARSHALLING(ps) && (q_u->num_names2 != 0)) {
4865 q_u->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_u->num_names2);
4866 q_u->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_u->num_names2);
4867 if (!q_u->hdr_name || !q_u->uni_name)
4868 return False;
4869 }
4870
4871 for (i = 0; i < q_u->num_names2; i++) {
4872 if(!smb_io_unihdr("", &q_u->hdr_name[i], ps, depth))
4873 return False;
4874 }
4875
4876 for (i = 0; i < q_u->num_names2; i++) {
4877 if(!smb_io_unistr2("", &q_u->uni_name[i], q_u->hdr_name[i].buffer, ps, depth))
4878 return False;
4879 }
4880
4881 return True;
4882 }
4883
4884 /*******************************************************************
4885 inits a SAMR_R_LOOKUP_NAMES structure.
4886 ********************************************************************/
4887
4888 NTSTATUS init_samr_r_lookup_names(TALLOC_CTX *ctx, SAMR_R_LOOKUP_NAMES * r_u,
4889 uint32 num_rids,
4890 uint32 *rid, enum lsa_SidType *type,
4891 NTSTATUS status)
4892 {
4893 DEBUG(5, ("init_samr_r_lookup_names\n"));
4894
4895 if (NT_STATUS_IS_OK(status) && (num_rids != 0)) {
4896 uint32 i;
4897
4898 r_u->num_types1 = num_rids;
4899 r_u->ptr_types = 1;
4900 r_u->num_types2 = num_rids;
4901
4902 r_u->num_rids1 = num_rids;
4903 r_u->ptr_rids = 1;
4904 r_u->num_rids2 = num_rids;
4905
4906 if (!(r_u->rids = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids)))
4907 return NT_STATUS_NO_MEMORY;
4908 if (!(r_u->types = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids)))
4909 return NT_STATUS_NO_MEMORY;
4910
4911 if (!r_u->rids || !r_u->types)
4912 goto empty;
4913
4914 for (i = 0; i < num_rids; i++) {
4915 r_u->rids[i] = rid[i];
4916 r_u->types[i] = type[i];
4917 }
4918 } else {
4919
4920 empty:
4921 r_u->num_types1 = 0;
4922 r_u->ptr_types = 0;
4923 r_u->num_types2 = 0;
4924
4925 r_u->num_rids1 = 0;
4926 r_u->ptr_rids = 0;
4927 r_u->num_rids2 = 0;
4928
4929 r_u->rids = NULL;
4930 r_u->types = NULL;
4931 }
4932
4933 r_u->status = status;
4934
4935 return NT_STATUS_OK;
4936 }
4937
4938 /*******************************************************************
4939 reads or writes a structure.
4940 ********************************************************************/
4941
4942 BOOL samr_io_r_lookup_names(const char *desc, SAMR_R_LOOKUP_NAMES * r_u,
4943 prs_struct *ps, int depth)
4944 {
4945 uint32 i;
4946 fstring tmp;
4947
4948 if (r_u == NULL)
4949 return False;
4950
4951 prs_debug(ps, depth, desc, "samr_io_r_lookup_names");
4952 depth++;
4953
4954 if (UNMARSHALLING(ps))
4955 ZERO_STRUCTP(r_u);
4956
4957 if(!prs_align(ps))
4958 return False;
4959
4960 if(!prs_uint32("num_rids1", ps, depth, &r_u->num_rids1))
4961 return False;
4962 if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids))
4963 return False;
4964
4965 if (r_u->ptr_rids != 0) {
4966 if(!prs_uint32("num_rids2", ps, depth, &r_u->num_rids2))
4967 return False;
4968
4969 if (r_u->num_rids2 != r_u->num_rids1) {
4970 /* RPC fault */
4971 return False;
4972 }
4973
4974 if (UNMARSHALLING(ps))
4975 r_u->rids = PRS_ALLOC_MEM(ps, uint32, r_u->num_rids2);
4976
4977 if (!r_u->rids) {
4978 DEBUG(0, ("NULL rids in samr_io_r_lookup_names\n"));
4979 return False;
4980 }
4981
4982 for (i = 0; i < r_u->num_rids2; i++) {
4983 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d] ", i);
4984 if(!prs_uint32(tmp, ps, depth, &r_u->rids[i]))
4985 return False;
4986 }
4987 }
4988
4989 if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
4990 return False;
4991 if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
4992 return False;
4993
4994 if (r_u->ptr_types != 0) {
4995 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
4996 return False;
4997
4998 if (r_u->num_types2 != r_u->num_types1) {
4999 /* RPC fault */
5000 return False;
5001 }
5002
5003 if (UNMARSHALLING(ps))
5004 r_u->types = PRS_ALLOC_MEM(ps, uint32, r_u->num_types2);
5005
5006 if (!r_u->types) {
5007 DEBUG(0, ("NULL types in samr_io_r_lookup_names\n"));
5008 return False;
5009 }
5010
5011 for (i = 0; i < r_u->num_types2; i++) {
5012 slprintf(tmp, sizeof(tmp) - 1, "type[%02d] ", i);
5013 if(!prs_uint32(tmp, ps, depth, &r_u->types[i]))
5014 return False;
5015 }
5016 }
5017
5018 if(!prs_ntstatus("status", ps, depth, &r_u->status))
5019 return False;
5020
5021 return True;
5022 }
5023
5024 /*******************************************************************
5025 inits a SAMR_Q_DELETE_DOM_USER structure.
5026 ********************************************************************/
5027
5028 void init_samr_q_delete_dom_user(SAMR_Q_DELETE_DOM_USER * q_c,
5029 POLICY_HND *hnd)
5030 {
5031 DEBUG(5, ("init_samr_q_delete_dom_user\n"));
5032
5033 q_c->user_pol = *hnd;
5034 }
5035
5036 /*******************************************************************
5037 reads or writes a structure.
5038 ********************************************************************/
5039
5040 BOOL samr_io_q_delete_dom_user(const char *desc, SAMR_Q_DELETE_DOM_USER * q_u,
5041 prs_struct *ps, int depth)
5042 {
5043 if (q_u == NULL)
5044 return False;
5045
5046 prs_debug(ps, depth, desc, "samr_io_q_delete_dom_user");
5047 depth++;
5048
5049 if(!prs_align(ps))
5050 return False;
5051
5052 if(!smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth))
5053 return False;
5054
5055 return True;
5056 }
5057
5058 /*******************************************************************
5059 reads or writes a structure.
5060 ********************************************************************/
5061
5062 BOOL samr_io_r_delete_dom_user(const char *desc, SAMR_R_DELETE_DOM_USER * r_u,
5063 prs_struct *ps, int depth)
5064 {
5065 if (r_u == NULL)
5066 return False;
5067
5068 prs_debug(ps, depth, desc, "samr_io_r_delete_dom_user");
5069 depth++;
5070
5071 if(!prs_align(ps))
5072 return False;
5073
5074 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
5075 return False;
5076 if(!prs_ntstatus("status", ps, depth, &r_u->status))
5077 return False;
5078
5079 return True;
5080 }
5081
5082 /*******************************************************************
5083 reads or writes a structure.
5084 ********************************************************************/
5085
5086 void init_samr_q_open_user(SAMR_Q_OPEN_USER * q_u,
5087 POLICY_HND *pol,
5088 uint32 access_mask, uint32 rid)
5089 {
5090 DEBUG(5, ("samr_init_samr_q_open_user\n"));
5091
5092 q_u->domain_pol = *pol;
5093 q_u->access_mask = access_mask;
5094 q_u->user_rid = rid;
5095 }
5096
5097 /*******************************************************************
5098 reads or writes a structure.
5099 ********************************************************************/
5100
5101 BOOL samr_io_q_open_user(const char *desc, SAMR_Q_OPEN_USER * q_u,
5102 prs_struct *ps, int depth)
5103 {
5104 if (q_u == NULL)
5105 return False;
5106
5107 prs_debug(ps, depth, desc, "samr_io_q_open_user");
5108 depth++;
5109
5110 if(!prs_align(ps))
5111 return False;
5112
5113 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
5114 return False;
5115
5116 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
5117 return False;
5118 if(!prs_uint32("user_rid ", ps, depth, &q_u->user_rid))
5119 return False;
5120
5121 return True;
5122 }
5123
5124 /*******************************************************************
5125 reads or writes a structure.
5126 ********************************************************************/
5127
5128 BOOL samr_io_r_open_user(const char *desc, SAMR_R_OPEN_USER * r_u,
5129 prs_struct *ps, int depth)
5130 {
5131 if (r_u == NULL)
5132 return False;
5133
5134 prs_debug(ps, depth, desc, "samr_io_r_open_user");
5135 depth++;
5136
5137 if(!prs_align(ps))
5138 return False;
5139
5140 if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
5141 return False;
5142
5143 if(!prs_ntstatus("status", ps, depth, &r_u->status))
5144 return False;
5145
5146 return True;
5147 }
5148
5149
5150 /*******************************************************************
5151 reads or writes a structure.
5152 ********************************************************************/
5153
5154 void init_samr_q_create_user(SAMR_Q_CREATE_USER * q_u,
5155 POLICY_HND *pol,
5156 const char *name,
5157 uint32 acb_info, uint32 access_mask)
5158 {
5159 DEBUG(5, ("samr_init_samr_q_create_user\n"));
5160
5161 q_u->domain_pol = *pol;
5162
5163 init_unistr2(&q_u->uni_name, name, UNI_FLAGS_NONE);
5164 init_uni_hdr(&q_u->hdr_name, &q_u->uni_name);
5165
5166 q_u->acb_info = acb_info;
5167 q_u->access_mask = access_mask;
5168 }
5169
5170 /*******************************************************************
5171 reads or writes a structure.
5172 ********************************************************************/
5173
5174 BOOL samr_io_q_create_user(const char *desc, SAMR_Q_CREATE_USER * q_u,
5175 prs_struct *ps, int depth)
5176 {
5177 if (q_u == NULL)
5178 return False;
5179
5180 prs_debug(ps, depth, desc, "samr_io_q_create_user");
5181 depth++;
5182
5183 if(!prs_align(ps))
5184 return False;
5185
5186 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
5187 return False;
5188
5189 if(!smb_io_unihdr("hdr_name", &q_u->hdr_name, ps, depth))
5190 return False;
5191 if(!smb_io_unistr2("uni_name", &q_u->uni_name, q_u->hdr_name.buffer, ps, depth))
5192 return False;
5193
5194 if(!prs_align(ps))
5195 return False;
5196 if(!prs_uint32("acb_info ", ps, depth, &q_u->acb_info))
5197 return False;
5198 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
5199 return False;
5200
5201 return True;
5202 }
5203
5204 /*******************************************************************
5205 reads or writes a structure.
5206 ********************************************************************/
5207
5208 BOOL samr_io_r_create_user(const char *desc, SAMR_R_CREATE_USER * r_u,
5209 prs_struct *ps, int depth)
5210 {
5211 if (r_u == NULL)
5212 return False;
5213
5214 prs_debug(ps, depth, desc, "samr_io_r_create_user");
5215 depth++;
5216
5217 if(!prs_align(ps))
5218 return False;
5219
5220 if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
5221 return False;
5222
5223 if(!prs_uint32("access_granted", ps, depth, &r_u->access_granted))
5224 return False;
5225 if(!prs_uint32("user_rid ", ps, depth, &r_u->user_rid))
5226 return False;
5227 if(!prs_ntstatus("status", ps, depth, &r_u->status))
5228 return False;
5229
5230 return True;
5231 }
5232
5233 /*******************************************************************
5234 inits a SAMR_Q_QUERY_USERINFO structure.
5235 ********************************************************************/
5236
5237 void init_samr_q_query_userinfo(SAMR_Q_QUERY_USERINFO * q_u,
5238 const POLICY_HND *hnd, uint16 switch_value)
5239 {
5240 DEBUG(5, ("init_samr_q_query_userinfo\n"));
5241
5242 q_u->pol = *hnd;
5243 q_u->switch_value = switch_value;
5244 }
5245
5246 /*******************************************************************
5247 reads or writes a structure.
5248 ********************************************************************/
5249
5250 BOOL samr_io_q_query_userinfo(const char *desc, SAMR_Q_QUERY_USERINFO * q_u,
5251 prs_struct *ps, int depth)
5252 {
5253 if (q_u == NULL)
5254 return False;
5255
5256 prs_debug(ps, depth, desc, "samr_io_q_query_userinfo");
5257 depth++;
5258
5259 if(!prs_align(ps))
5260 return False;
5261
5262 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
5263 return False;
5264
5265 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value)) /* 0x0015 or 0x0011 */
5266 return False;
5267
5268 return True;
5269 }
5270
5271 /*******************************************************************
5272 reads or writes a LOGON_HRS structure.
5273 ********************************************************************/
5274
5275 static BOOL sam_io_logon_hrs(const char *desc, LOGON_HRS * hrs,
5276 prs_struct *ps, int depth)
5277 {
5278 if (hrs == NULL)
5279 return False;
5280
5281 prs_debug(ps, depth, desc, "sam_io_logon_hrs");
5282 depth++;
5283
5284 if(!prs_align(ps))
5285 return False;
5286
5287 if(!prs_uint32("maxlen", ps, depth, &hrs->max_len))
5288 return False;
5289
5290 if(!prs_uint32("offset", ps, depth, &hrs->offset))
5291 return False;
5292
5293 if(!prs_uint32("len ", ps, depth, &hrs->len))
5294 return False;
5295
5296 if (hrs->len > sizeof(hrs->hours)) {
5297 DEBUG(3, ("sam_io_logon_hrs: truncating length from %d\n", hrs->len));
5298 hrs->len = sizeof(hrs->hours);
5299 }
5300
5301 if(!prs_uint8s(False, "hours", ps, depth, hrs->hours, hrs->len))
5302 return False;
5303
5304 return True;
5305 }
5306
5307 /*******************************************************************
5308 inits a SAM_USER_INFO_18 structure.
5309 ********************************************************************/
5310
5311 void init_sam_user_info18(SAM_USER_INFO_18 * usr,
5312 const uint8 lm_pwd[16], const uint8 nt_pwd[16])
5313 {
5314 DEBUG(5, ("init_sam_user_info18\n"));
5315
5316 usr->lm_pwd_active =
5317 memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd)) ? 1 : 0;
5318 usr->nt_pwd_active =
5319 memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd)) ? 1 : 0;
5320 }
5321
5322 /*******************************************************************
5323 reads or writes a structure.
5324 ********************************************************************/
5325
5326 static BOOL sam_io_user_info18(const char *desc, SAM_USER_INFO_18 * u,
5327 prs_struct *ps, int depth)
5328 {
5329 if (u == NULL)
5330 return False;
5331
5332 prs_debug(ps, depth, desc, "samr_io_r_user_info18");
5333 depth++;
5334
5335 if(!prs_align(ps))
5336 return False;
5337
5338 if(!prs_uint8s(False, "lm_pwd", ps, depth, u->lm_pwd, sizeof(u->lm_pwd)))
5339 return False;
5340 if(!prs_uint8s(False, "nt_pwd", ps, depth, u->nt_pwd, sizeof(u->nt_pwd)))
5341 return False;
5342
5343 if(!prs_uint8("lm_pwd_active", ps, depth, &u->lm_pwd_active))
5344 return False;
5345 if(!prs_uint8("nt_pwd_active", ps, depth, &u->nt_pwd_active))
5346 return False;
5347
5348 return True;
5349 }
5350
5351 /*******************************************************************
5352 inits a SAM_USER_INFO_7 structure.
5353 ********************************************************************/
5354
5355 void init_sam_user_info7(SAM_USER_INFO_7 * usr, const char *name)
5356 {
5357 DEBUG(5, ("init_sam_user_info7\n"));
5358
5359 init_unistr2(&usr->uni_name, name, UNI_FLAGS_NONE); /* unicode string for name */
5360 init_uni_hdr(&usr->hdr_name, &usr->uni_name); /* unicode header for name */
5361
5362 }
5363
5364 /*******************************************************************
5365 reads or writes a structure.
5366 ********************************************************************/
5367
5368 static BOOL sam_io_user_info7(const char *desc, SAM_USER_INFO_7 * usr,
5369 prs_struct *ps, int depth)
5370 {
5371 if (usr == NULL)
5372 return False;
5373
5374 prs_debug(ps, depth, desc, "samr_io_r_user_info7");
5375 depth++;
5376
5377 if(!prs_align(ps))
5378 return False;
5379
5380 if(!smb_io_unihdr("unihdr", &usr->hdr_name, ps, depth))
5381 return False;
5382
5383 if(!smb_io_unistr2("unistr2", &usr->uni_name, True, ps, depth))
5384 return False;
5385
5386 return True;
5387 }
5388
5389 /*******************************************************************
5390 inits a SAM_USER_INFO_9 structure.
5391 ********************************************************************/
5392
5393 void init_sam_user_info9(SAM_USER_INFO_9 * usr, uint32 rid_group)
5394 {
5395 DEBUG(5, ("init_sam_user_info9\n"));
5396
5397 usr->rid_group = rid_group;
5398 }
5399
5400 /*******************************************************************
5401 reads or writes a structure.
5402 ********************************************************************/
5403
5404 static BOOL sam_io_user_info9(const char *desc, SAM_USER_INFO_9 * usr,
5405 prs_struct *ps, int depth)
5406 {
5407 if (usr == NULL)
5408 return False;
5409
5410 prs_debug(ps, depth, desc, "samr_io_r_user_info9");
5411 depth++;
5412
5413 if(!prs_align(ps))
5414 return False;
5415
5416 if(!prs_uint32("rid_group", ps, depth, &usr->rid_group))
5417 return False;
5418
5419 return True;
5420 }
5421
5422 /*******************************************************************
5423 inits a SAM_USER_INFO_16 structure.
5424 ********************************************************************/
5425
5426 void init_sam_user_info16(SAM_USER_INFO_16 * usr, uint32 acb_info)
5427 {
5428 DEBUG(5, ("init_sam_user_info16\n"));
5429
5430 usr->acb_info = acb_info;
5431 }
5432
5433 /*******************************************************************
5434 reads or writes a structure.
5435 ********************************************************************/
5436
5437 static BOOL sam_io_user_info16(const char *desc, SAM_USER_INFO_16 * usr,
5438 prs_struct *ps, int depth)
5439 {
5440 if (usr == NULL)
5441 return False;
5442
5443 prs_debug(ps, depth, desc, "samr_io_r_user_info16");
5444 depth++;
5445
5446 if(!prs_align(ps))
5447 return False;
5448
5449 if(!prs_uint32("acb_info", ps, depth, &usr->acb_info))
5450 return False;
5451
5452 return True;
5453 }
5454
5455 /*******************************************************************
5456 inits a SAM_USER_INFO_17 structure.
5457 ********************************************************************/
5458
5459 void init_sam_user_info17(SAM_USER_INFO_17 * usr,
5460 NTTIME * expiry,
5461 char *mach_acct,
5462 uint32 rid_user, uint32 rid_group, uint16 acct_ctrl)
5463 {
5464 DEBUG(5, ("init_sam_user_info17\n"));
5465
5466 memcpy(&usr->expiry, expiry, sizeof(usr->expiry)); /* expiry time or something? */
5467 ZERO_STRUCT(usr->padding_1); /* 0 - padding 24 bytes */
5468
5469 usr->padding_2 = 0; /* 0 - padding 4 bytes */
5470
5471 usr->ptr_1 = 1; /* pointer */
5472 ZERO_STRUCT(usr->padding_3); /* 0 - padding 32 bytes */
5473 usr->padding_4 = 0; /* 0 - padding 4 bytes */
5474
5475 usr->ptr_2 = 1; /* pointer */
5476 usr->padding_5 = 0; /* 0 - padding 4 bytes */
5477
5478 usr->ptr_3 = 1; /* pointer */
5479 ZERO_STRUCT(usr->padding_6); /* 0 - padding 32 bytes */
5480
5481 usr->rid_user = rid_user;
5482 usr->rid_group = rid_group;
5483
5484 usr->acct_ctrl = acct_ctrl;
5485 usr->unknown_3 = 0x0000;
5486
5487 usr->unknown_4 = 0x003f; /* 0x003f - 16 bit unknown */
5488 usr->unknown_5 = 0x003c; /* 0x003c - 16 bit unknown */
5489
5490 ZERO_STRUCT(usr->padding_7); /* 0 - padding 16 bytes */
5491 usr->padding_8 = 0; /* 0 - padding 4 bytes */
5492
5493 init_unistr2(&usr->uni_mach_acct, mach_acct, UNI_FLAGS_NONE); /* unicode string for machine account */
5494 init_uni_hdr(&usr->hdr_mach_acct, &usr->uni_mach_acct); /* unicode header for machine account */
5495 }
5496
5497 /*******************************************************************
5498 reads or writes a structure.
5499 ********************************************************************/
5500
5501 static BOOL sam_io_user_info17(const char *desc, SAM_USER_INFO_17 * usr,
5502 prs_struct *ps, int depth)
5503 {
5504 if (usr == NULL)
5505 return False;
5506
5507 prs_debug(ps, depth, desc, "samr_io_r_unknown_17");
5508 depth++;
5509
5510 if(!prs_align(ps))
5511 return False;
5512
5513 if(!prs_uint8s(False, "padding_0", ps, depth, usr->padding_0, sizeof(usr->padding_0)))
5514 return False;
5515
5516 if(!smb_io_time("time", &usr->expiry, ps, depth))
5517 return False;
5518
5519 if(!prs_uint8s(False, "padding_1", ps, depth, usr->padding_1, sizeof(usr->padding_1)))
5520 return False;
5521
5522 if(!smb_io_unihdr("unihdr", &usr->hdr_mach_acct, ps, depth))
5523 return False;
5524
5525 if(!prs_uint32("padding_2", ps, depth, &usr->padding_2))
5526 return False;
5527
5528 if(!prs_uint32("ptr_1 ", ps, depth, &usr->ptr_1))
5529 return False;
5530 if(!prs_uint8s(False, "padding_3", ps, depth, usr->padding_3, sizeof(usr->padding_3)))
5531 return False;
5532
5533 if(!prs_uint32("padding_4", ps, depth, &usr->padding_4))
5534 return False;
5535
5536 if(!prs_uint32("ptr_2 ", ps, depth, &usr->ptr_2))
5537 return False;
5538 if(!prs_uint32("padding_5", ps, depth, &usr->padding_5))
5539 return False;
5540
5541 if(!prs_uint32("ptr_3 ", ps, depth, &usr->ptr_3))
5542 return False;
5543 if(!prs_uint8s(False, "padding_6", ps, depth, usr->padding_6,sizeof(usr->padding_6)))
5544 return False;
5545
5546 if(!prs_uint32("rid_user ", ps, depth, &usr->rid_user))
5547 return False;
5548 if(!prs_uint32("rid_group", ps, depth, &usr->rid_group))
5549 return False;
5550 if(!prs_uint16("acct_ctrl", ps, depth, &usr->acct_ctrl))
5551 return False;
5552 if(!prs_uint16("unknown_3", ps, depth, &usr->unknown_3))
5553 return False;
5554 if(!prs_uint16("unknown_4", ps, depth, &usr->unknown_4))
5555 return False;
5556 if(!prs_uint16("unknown_5", ps, depth, &usr->unknown_5))
5557 return False;
5558
5559 if(!prs_uint8s(False, "padding_7", ps, depth, usr->padding_7, sizeof(usr->padding_7)))
5560 return False;
5561
5562 if(!prs_uint32("padding_8", ps, depth, &(usr->padding_8)))
5563 return False;
5564
5565 if(!smb_io_unistr2("unistr2", &usr->uni_mach_acct, True, ps, depth))
5566 return False;
5567
5568 if(!prs_align(ps))
5569 return False;
5570
5571 if(!prs_uint8s(False, "padding_9", ps, depth, usr->padding_9, sizeof(usr->padding_9)))
5572 return False;
5573
5574 return True;
5575 }
5576
5577 /*************************************************************************
5578 init_sam_user_infoa
5579 *************************************************************************/
5580
5581 void init_sam_user_info24(SAM_USER_INFO_24 * usr, char newpass[516],
5582 uint8 pw_len)
5583 {
5584 DEBUG(10, ("init_sam_user_info24:\n"));
5585 memcpy(usr->pass, newpass, sizeof(usr->pass));
5586 usr->pw_len = pw_len;
5587 }
5588
5589 /*******************************************************************
5590 reads or writes a structure.
5591 ********************************************************************/
5592
5593 static BOOL sam_io_user_info24(const char *desc, SAM_USER_INFO_24 * usr,
5594 prs_struct *ps, int depth)
5595 {
5596 if (usr == NULL)
5597 return False;
5598
5599 prs_debug(ps, depth, desc, "sam_io_user_info24");
5600 depth++;
5601
5602 if(!prs_align(ps))
5603 return False;
5604
5605 if(!prs_uint8s(False, "password", ps, depth, usr->pass,
5606 sizeof(usr->pass)))
5607 return False;
5608
5609 if (MARSHALLING(ps) && (usr->pw_len != 0)) {
5610 if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5611 return False;
5612 } else if (UNMARSHALLING(ps)) {
5613 if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5614 return False;
5615 }
5616
5617 return True;
5618 }
5619
5620 /*******************************************************************
5621 reads or writes a structure.
5622 ********************************************************************/
5623
5624 static BOOL sam_io_user_info26(const char *desc, SAM_USER_INFO_26 * usr,
5625 prs_struct *ps, int depth)
5626 {
5627 if (usr == NULL)
5628 return False;
5629
5630 prs_debug(ps, depth, desc, "sam_io_user_info26");
5631 depth++;
5632
5633 if(!prs_align(ps))
5634 return False;
5635
5636 if(!prs_uint8s(False, "password", ps, depth, usr->pass,
5637 sizeof(usr->pass)))
5638 return False;
5639
5640 if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5641 return False;
5642
5643 return True;
5644 }
5645
5646
5647 /*************************************************************************
5648 init_sam_user_info23
5649
5650 unknown_6 = 0x0000 04ec
5651
5652 *************************************************************************/
5653
5654 void init_sam_user_info23W(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5655 NTTIME * logoff_time, /* all zeros */
5656 NTTIME * kickoff_time, /* all zeros */
5657 NTTIME * pass_last_set_time, /* all zeros */
5658 NTTIME * pass_can_change_time, /* all zeros */
5659 NTTIME * pass_must_change_time, /* all zeros */
5660 UNISTR2 *user_name,
5661 UNISTR2 *full_name,
5662 UNISTR2 *home_dir,
5663 UNISTR2 *dir_drive,
5664 UNISTR2 *log_scr,
5665 UNISTR2 *prof_path,
5666 UNISTR2 *desc,
5667 UNISTR2 *wkstas,
5668 UNISTR2 *unk_str,
5669 UNISTR2 *mung_dial,
5670 uint32 user_rid, /* 0x0000 0000 */
5671 uint32 group_rid,
5672 uint32 acb_info,
5673 uint32 fields_present,
5674 uint16 logon_divs,
5675 LOGON_HRS * hrs,
5676 uint16 bad_password_count,
5677 uint16 logon_count,
5678 char newpass[516])
5679 {
5680 usr->logon_time = *logon_time; /* all zeros */
5681 usr->logoff_time = *logoff_time; /* all zeros */
5682 usr->kickoff_time = *kickoff_time; /* all zeros */
5683 usr->pass_last_set_time = *pass_last_set_time; /* all zeros */
5684 usr->pass_can_change_time = *pass_can_change_time; /* all zeros */
5685 usr->pass_must_change_time = *pass_must_change_time; /* all zeros */
5686
5687 ZERO_STRUCT(usr->nt_pwd);
5688 ZERO_STRUCT(usr->lm_pwd);
5689
5690 usr->user_rid = user_rid; /* 0x0000 0000 */
5691 usr->group_rid = group_rid;
5692 usr->acb_info = acb_info;
5693 usr->fields_present = fields_present; /* 09f8 27fa */
5694
5695 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5696 usr->ptr_logon_hrs = hrs ? 1 : 0;
5697
5698 if (nt_time_is_zero(pass_must_change_time)) {
5699 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5700 } else {
5701 usr->passmustchange=0;
5702 }
5703
5704 ZERO_STRUCT(usr->padding1);
5705 ZERO_STRUCT(usr->padding2);
5706
5707 usr->bad_password_count = bad_password_count;
5708 usr->logon_count = logon_count;
5709
5710 memcpy(usr->pass, newpass, sizeof(usr->pass));
5711
5712 copy_unistr2(&usr->uni_user_name, user_name);
5713 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5714
5715 copy_unistr2(&usr->uni_full_name, full_name);
5716 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5717
5718 copy_unistr2(&usr->uni_home_dir, home_dir);
5719 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5720
5721 copy_unistr2(&usr->uni_dir_drive, dir_drive);
5722 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5723
5724 copy_unistr2(&usr->uni_logon_script, log_scr);
5725 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5726
5727 copy_unistr2(&usr->uni_profile_path, prof_path);
5728 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5729
5730 copy_unistr2(&usr->uni_acct_desc, desc);
5731 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5732
5733 copy_unistr2(&usr->uni_workstations, wkstas);
5734 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5735
5736 copy_unistr2(&usr->uni_comment, unk_str);
5737 init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
5738
5739 copy_unistr2(&usr->uni_munged_dial, mung_dial);
5740 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5741
5742 if (hrs) {
5743 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5744 } else {
5745 ZERO_STRUCT(usr->logon_hrs);
5746 }
5747 }
5748
5749 /*************************************************************************
5750 init_sam_user_info23
5751
5752 unknown_6 = 0x0000 04ec
5753
5754 *************************************************************************/
5755
5756 void init_sam_user_info23A(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5757 NTTIME * logoff_time, /* all zeros */
5758 NTTIME * kickoff_time, /* all zeros */
5759 NTTIME * pass_last_set_time, /* all zeros */
5760 NTTIME * pass_can_change_time, /* all zeros */
5761 NTTIME * pass_must_change_time, /* all zeros */
5762 char *user_name, /* NULL */
5763 char *full_name,
5764 char *home_dir, char *dir_drive, char *log_scr,
5765 char *prof_path, const char *desc, char *wkstas,
5766 char *unk_str, char *mung_dial, uint32 user_rid, /* 0x0000 0000 */
5767 uint32 group_rid, uint32 acb_info,
5768 uint32 fields_present, uint16 logon_divs,
5769 LOGON_HRS * hrs, uint16 bad_password_count, uint16 logon_count,
5770 char newpass[516])
5771 {
5772 DATA_BLOB blob = base64_decode_data_blob(mung_dial);
5773
5774 usr->logon_time = *logon_time; /* all zeros */
5775 usr->logoff_time = *logoff_time; /* all zeros */
5776 usr->kickoff_time = *kickoff_time; /* all zeros */
5777 usr->pass_last_set_time = *pass_last_set_time; /* all zeros */
5778 usr->pass_can_change_time = *pass_can_change_time; /* all zeros */
5779 usr->pass_must_change_time = *pass_must_change_time; /* all zeros */
5780
5781 ZERO_STRUCT(usr->nt_pwd);
5782 ZERO_STRUCT(usr->lm_pwd);
5783
5784 usr->user_rid = user_rid; /* 0x0000 0000 */
5785 usr->group_rid = group_rid;
5786 usr->acb_info = acb_info;
5787 usr->fields_present = fields_present; /* 09f8 27fa */
5788
5789 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5790 usr->ptr_logon_hrs = hrs ? 1 : 0;
5791
5792 if (nt_time_is_zero(pass_must_change_time)) {
5793 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5794 } else {
5795 usr->passmustchange=0;
5796 }
5797
5798 ZERO_STRUCT(usr->padding1);
5799 ZERO_STRUCT(usr->padding2);
5800
5801 usr->bad_password_count = bad_password_count;
5802 usr->logon_count = logon_count;
5803
5804 memcpy(usr->pass, newpass, sizeof(usr->pass));
5805
5806 init_unistr2(&usr->uni_user_name, user_name, UNI_FLAGS_NONE);
5807 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5808
5809 init_unistr2(&usr->uni_full_name, full_name, UNI_FLAGS_NONE);
5810 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5811
5812 init_unistr2(&usr->uni_home_dir, home_dir, UNI_FLAGS_NONE);
5813 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5814
5815 init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_FLAGS_NONE);
5816 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5817
5818 init_unistr2(&usr->uni_logon_script, log_scr, UNI_FLAGS_NONE);
5819 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5820
5821 init_unistr2(&usr->uni_profile_path, prof_path, UNI_FLAGS_NONE);
5822 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5823
5824 init_unistr2(&usr->uni_acct_desc, desc, UNI_FLAGS_NONE);
5825 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5826
5827 init_unistr2(&usr->uni_workstations, wkstas, UNI_FLAGS_NONE);
5828 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5829
5830 init_unistr2(&usr->uni_comment, unk_str, UNI_FLAGS_NONE);
5831 init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
5832
5833 init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
5834 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5835
5836 data_blob_free(&blob);
5837
5838 if (hrs) {
5839 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5840 } else {
5841 ZERO_STRUCT(usr->logon_hrs);
5842 }
5843 }
5844
5845 /*******************************************************************
5846 reads or writes a structure.
5847 ********************************************************************/
5848
5849 static BOOL sam_io_user_info23(const char *desc, SAM_USER_INFO_23 * usr,
5850 prs_struct *ps, int depth)
5851 {
5852 if (usr == NULL)
5853 return False;
5854
5855 prs_debug(ps, depth, desc, "sam_io_user_info23");
5856 depth++;
5857
5858 if(!prs_align(ps))
5859 return False;
5860
5861 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
5862 return False;
5863 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
5864 return False;
5865 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
5866 return False;
5867 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps, depth))
5868 return False;
5869 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
5870 return False;
5871 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
5872 return False;
5873
5874 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
5875 return False;
5876 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
5877 return False;
5878 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
5879 return False;
5880 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
5881 return False;
5882 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
5883 return False;
5884 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
5885 return False;
5886 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
5887 return False;
5888 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
5889 return False;
5890 if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth)) /* unknown string */
5891 return False;
5892 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
5893 return False;
5894
5895 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
5896 return False;
5897 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
5898 return False;
5899
5900 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
5901 return False;
5902 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
5903 return False;
5904 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
5905 return False;
5906
5907 if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
5908 return False;
5909 if(!prs_uint16("logon_divs ", ps, depth, &usr->logon_divs)) /* logon divisions per week */
5910 return False;
5911 if(!prs_align(ps))
5912 return False;
5913 if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
5914 return False;
5915
5916 if(!prs_uint16("bad_password_count ", ps, depth, &usr->bad_password_count))
5917 return False;
5918 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count))
5919 return False;
5920
5921 if(!prs_uint8s(False, "padding1 ", ps, depth, usr->padding1, sizeof(usr->padding1)))
5922 return False;
5923 if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
5924 return False;
5925 if(!prs_uint8("padding2 ", ps, depth, &usr->padding2))
5926 return False;
5927
5928
5929 if(!prs_uint8s(False, "password ", ps, depth, usr->pass, sizeof(usr->pass)))
5930 return False;
5931
5932 /* here begins pointed-to data */
5933
5934 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
5935 return False;
5936
5937 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
5938 return False;
5939
5940 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
5941 return False;
5942
5943 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
5944 return False;
5945
5946 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
5947 return False;
5948
5949 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
5950 return False;
5951
5952 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth)) /* user desc unicode string */
5953 return False;
5954
5955 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth)) /* worksations user can log on from */
5956 return False;
5957
5958 if(!smb_io_unistr2("uni_comment ", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth)) /* unknown string */
5959 return False;
5960
5961 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
5962 return False;
5963
5964 /* ok, this is only guess-work (as usual) */
5965 if (usr->ptr_logon_hrs) {
5966 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
5967 return False;
5968 }
5969
5970 return True;
5971 }
5972
5973 /*******************************************************************
5974 reads or writes a structure.
5975 NB. This structure is *definately* incorrect. It's my best guess
5976 currently for W2K SP2. The password field is encrypted in a different
5977 way than normal... And there are definately other problems. JRA.
5978 ********************************************************************/
5979
5980 static BOOL sam_io_user_info25(const char *desc, SAM_USER_INFO_25 * usr, prs_struct *ps, int depth)
5981 {
5982 if (usr == NULL)
5983 return False;
5984
5985 prs_debug(ps, depth, desc, "sam_io_user_info25");
5986 depth++;
5987
5988 if(!prs_align(ps))
5989 return False;
5990
5991 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
5992 return False;
5993 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
5994 return False;
5995 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
5996 return False;
5997 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps, depth))
5998 return False;
5999 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
6000 return False;
6001 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
6002 return False;
6003
6004 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
6005 return False;
6006 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
6007 return False;
6008 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
6009 return False;
6010 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
6011 return False;
6012 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
6013 return False;
6014 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
6015 return False;
6016 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
6017 return False;
6018 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
6019 return False;
6020 if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth)) /* unknown string */
6021 return False;
6022 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6023 return False;
6024
6025 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6026 return False;
6027 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6028 return False;
6029
6030 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
6031 return False;
6032 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
6033 return False;
6034 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
6035 return False;
6036 if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6037 return False;
6038
6039 if(!prs_uint32s(False, "unknown_5 ", ps, depth, usr->unknown_5, 5))
6040 return False;
6041
6042 if(!prs_uint8s(False, "password ", ps, depth, usr->pass, sizeof(usr->pass)))
6043 return False;
6044
6045 /* here begins pointed-to data */
6046
6047 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
6048 return False;
6049
6050 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
6051 return False;
6052
6053 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
6054 return False;
6055
6056 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
6057 return False;
6058
6059 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
6060 return False;
6061
6062 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
6063 return False;
6064
6065 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth)) /* user desc unicode string */
6066 return False;
6067
6068 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth)) /* worksations user can log on from */
6069 return False;
6070
6071 if(!smb_io_unistr2("uni_comment ", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth)) /* unknown string */
6072 return False;
6073
6074 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
6075 return False;
6076
6077 #if 0 /* JRA - unknown... */
6078 /* ok, this is only guess-work (as usual) */
6079 if (usr->ptr_logon_hrs) {
6080 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6081 return False;
6082 }
6083 #endif
6084
6085 return True;
6086 }
6087
6088
6089 /*************************************************************************
6090 init_sam_user_info21W
6091
6092 unknown_6 = 0x0000 04ec
6093
6094 *************************************************************************/
6095
6096 void init_sam_user_info21W(SAM_USER_INFO_21 * usr,
6097 NTTIME * logon_time,
6098 NTTIME * logoff_time,
6099 NTTIME * kickoff_time,
6100 NTTIME * pass_last_set_time,
6101 NTTIME * pass_can_change_time,
6102 NTTIME * pass_must_change_time,
6103 UNISTR2 *user_name,
6104 UNISTR2 *full_name,
6105 UNISTR2 *home_dir,
6106 UNISTR2 *dir_drive,
6107 UNISTR2 *log_scr,
6108 UNISTR2 *prof_path,
6109 UNISTR2 *desc,
6110 UNISTR2 *wkstas,
6111 UNISTR2 *unk_str,
6112 UNISTR2 *mung_dial,
6113 uchar lm_pwd[16],
6114 uchar nt_pwd[16],
6115 uint32 user_rid,
6116 uint32 group_rid,
6117 uint32 acb_info,
6118 uint32 fields_present,
6119 uint16 logon_divs,
6120 LOGON_HRS * hrs,
6121 uint16 bad_password_count,
6122 uint16 logon_count)
6123 {
6124 usr->logon_time = *logon_time;
6125 usr->logoff_time = *logoff_time;
6126 usr->kickoff_time = *kickoff_time;
6127 usr->pass_last_set_time = *pass_last_set_time;
6128 usr->pass_can_change_time = *pass_can_change_time;
6129 usr->pass_must_change_time = *pass_must_change_time;
6130
6131 memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd));
6132 memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd));
6133
6134 usr->user_rid = user_rid;
6135 usr->group_rid = group_rid;
6136 usr->acb_info = acb_info;
6137 usr->fields_present = fields_present; /* 0x00ff ffff */
6138
6139 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
6140 usr->ptr_logon_hrs = hrs ? 1 : 0;
6141 usr->bad_password_count = bad_password_count;
6142 usr->logon_count = logon_count;
6143
6144 if (nt_time_is_zero(pass_must_change_time)) {
6145 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6146 } else {
6147 usr->passmustchange=0;
6148 }
6149
6150 ZERO_STRUCT(usr->padding1);
6151 ZERO_STRUCT(usr->padding2);
6152
6153 copy_unistr2(&usr->uni_user_name, user_name);
6154 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6155
6156 copy_unistr2(&usr->uni_full_name, full_name);
6157 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6158
6159 copy_unistr2(&usr->uni_home_dir, home_dir);
6160 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6161
6162 copy_unistr2(&usr->uni_dir_drive, dir_drive);
6163 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6164
6165 copy_unistr2(&usr->uni_logon_script, log_scr);
6166 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6167
6168 copy_unistr2(&usr->uni_profile_path, prof_path);
6169 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6170
6171 copy_unistr2(&usr->uni_acct_desc, desc);
6172 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6173
6174 copy_unistr2(&usr->uni_workstations, wkstas);
6175 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6176
6177 copy_unistr2(&usr->uni_comment, unk_str);
6178 init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
6179
6180 copy_unistr2(&usr->uni_munged_dial, mung_dial);
6181 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6182
6183 if (hrs) {
6184 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
6185 } else {
6186 ZERO_STRUCT(usr->logon_hrs);
6187 }
6188 }
6189
6190 /*************************************************************************
6191 init_sam_user_info21
6192
6193 unknown_6 = 0x0000 04ec
6194
6195 *************************************************************************/
6196
6197 NTSTATUS init_sam_user_info21A(SAM_USER_INFO_21 *usr, struct samu *pw, DOM_SID *domain_sid)
6198 {
6199 NTTIME logon_time, logoff_time, kickoff_time,
6200 pass_last_set_time, pass_can_change_time,
6201 pass_must_change_time;
6202
6203 const char* user_name = pdb_get_username(pw);
6204 const char* full_name = pdb_get_fullname(pw);
6205 const char* home_dir = pdb_get_homedir(pw);
6206 const char* dir_drive = pdb_get_dir_drive(pw);
6207 const char* logon_script = pdb_get_logon_script(pw);
6208 const char* profile_path = pdb_get_profile_path(pw);
6209 const char* description = pdb_get_acct_desc(pw);
6210 const char* workstations = pdb_get_workstations(pw);
6211 const char* munged_dial = pdb_get_munged_dial(pw);
6212 DATA_BLOB munged_dial_blob;
6213
6214 uint32 user_rid;
6215 const DOM_SID *user_sid;
6216
6217 uint32 group_rid;
6218 const DOM_SID *group_sid;
6219
6220 if (munged_dial) {
6221 munged_dial_blob = base64_decode_data_blob(munged_dial);
6222 } else {
6223 munged_dial_blob = data_blob(NULL, 0);
6224 }
6225
6226 /* Create NTTIME structs */
6227 unix_to_nt_time (&logon_time, pdb_get_logon_time(pw));
6228 unix_to_nt_time (&logoff_time, pdb_get_logoff_time(pw));
6229 unix_to_nt_time (&kickoff_time, pdb_get_kickoff_time(pw));
6230 unix_to_nt_time (&pass_last_set_time, pdb_get_pass_last_set_time(pw));
6231 unix_to_nt_time (&pass_can_change_time, pdb_get_pass_can_change_time(pw));
6232 unix_to_nt_time (&pass_must_change_time,pdb_get_pass_must_change_time(pw));
6233
6234 /* structure assignment */
6235 usr->logon_time = logon_time;
6236 usr->logoff_time = logoff_time;
6237 usr->kickoff_time = kickoff_time;
6238 usr->pass_last_set_time = pass_last_set_time;
6239 usr->pass_can_change_time = pass_can_change_time;
6240 usr->pass_must_change_time = pass_must_change_time;
6241
6242 ZERO_STRUCT(usr->nt_pwd);
6243 ZERO_STRUCT(usr->lm_pwd);
6244
6245 user_sid = pdb_get_user_sid(pw);
6246
6247 if (!sid_peek_check_rid(domain_sid, user_sid, &user_rid)) {
6248 fstring user_sid_string;
6249 fstring domain_sid_string;
6250 DEBUG(0, ("init_sam_user_info_21A: User %s has SID %s, \nwhich conflicts with "
6251 "the domain sid %s. Failing operation.\n",
6252 user_name,
6253 sid_to_string(user_sid_string, user_sid),
6254 sid_to_string(domain_sid_string, domain_sid)));
6255 data_blob_free(&munged_dial_blob);
6256 return NT_STATUS_UNSUCCESSFUL;
6257 }
6258
6259 group_sid = pdb_get_group_sid(pw);
6260
6261 if (!sid_peek_check_rid(domain_sid, group_sid, &group_rid)) {
6262 fstring group_sid_string;
6263 fstring domain_sid_string;
6264 DEBUG(0, ("init_sam_user_info_21A: User %s has Primary Group SID %s, \n"
6265 "which conflicts with the domain sid %s. Failing operation.\n",
6266 user_name,
6267 sid_to_string(group_sid_string, group_sid),
6268 sid_to_string(domain_sid_string, domain_sid)));
6269 data_blob_free(&munged_dial_blob);
6270 return NT_STATUS_UNSUCCESSFUL;
6271 }
6272
6273 usr->user_rid = user_rid;
6274 usr->group_rid = group_rid;
6275 usr->acb_info = pdb_get_acct_ctrl(pw);
6276
6277 /*
6278 Look at a user on a real NT4 PDC with usrmgr, press
6279 'ok'. Then you will see that fields_present is set to
6280 0x08f827fa. Look at the user immediately after that again,
6281 and you will see that 0x00fffff is returned. This solves
6282 the problem that you get access denied after having looked
6283 at the user.
6284 -- Volker
6285 */
6286 usr->fields_present = pdb_build_fields_present(pw);
6287
6288 usr->logon_divs = pdb_get_logon_divs(pw);
6289 usr->ptr_logon_hrs = pdb_get_hours(pw) ? 1 : 0;
6290 usr->bad_password_count = pdb_get_bad_password_count(pw);
6291 usr->logon_count = pdb_get_logon_count(pw);
6292
6293 if (pdb_get_pass_must_change_time(pw) == 0) {
6294 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6295 } else {
6296 usr->passmustchange=0;
6297 }
6298
6299 ZERO_STRUCT(usr->padding1);
6300 ZERO_STRUCT(usr->padding2);
6301
6302 init_unistr2(&usr->uni_user_name, user_name, UNI_STR_TERMINATE);
6303 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6304
6305 init_unistr2(&usr->uni_full_name, full_name, UNI_STR_TERMINATE);
6306 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6307
6308 init_unistr2(&usr->uni_home_dir, home_dir, UNI_STR_TERMINATE);
6309 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6310
6311 init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_STR_TERMINATE);
6312 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6313
6314 init_unistr2(&usr->uni_logon_script, logon_script, UNI_STR_TERMINATE);
6315 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6316
6317 init_unistr2(&usr->uni_profile_path, profile_path, UNI_STR_TERMINATE);
6318 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6319
6320 init_unistr2(&usr->uni_acct_desc, description, UNI_STR_TERMINATE);
6321 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6322
6323 init_unistr2(&usr->uni_workstations, workstations, UNI_STR_TERMINATE);
6324 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6325
6326 init_unistr2(&usr->uni_comment, NULL, UNI_STR_TERMINATE);
6327 init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
6328
6329 init_unistr2_from_datablob(&usr->uni_munged_dial, &munged_dial_blob);
6330 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6331 data_blob_free(&munged_dial_blob);
6332
6333 if (pdb_get_hours(pw)) {
6334 usr->logon_hrs.max_len = 1260;
6335 usr->logon_hrs.offset = 0;
6336 usr->logon_hrs.len = pdb_get_hours_len(pw);
6337 memcpy(&usr->logon_hrs.hours, pdb_get_hours(pw), MAX_HOURS_LEN);
6338 } else {
6339 usr->logon_hrs.max_len = 1260;
6340 usr->logon_hrs.offset = 0;
6341 usr->logon_hrs.len = 0;
6342 memset(&usr->logon_hrs, 0xff, sizeof(usr->logon_hrs));
6343 }
6344
6345 return NT_STATUS_OK;
6346 }
6347
6348 /*******************************************************************
6349 reads or writes a structure.
6350 ********************************************************************/
6351
6352 static BOOL sam_io_user_info21(const char *desc, SAM_USER_INFO_21 * usr,
6353 prs_struct *ps, int depth)
6354 {
6355 if (usr == NULL)
6356 return False;
6357
6358 prs_debug(ps, depth, desc, "sam_io_user_info21");
6359 depth++;
6360
6361 if(!prs_align(ps))
6362 return False;
6363
6364 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
6365 return False;
6366 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
6367 return False;
6368 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps,depth))
6369 return False;
6370 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
6371 return False;
6372 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps,depth))
6373 return False;
6374 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
6375 return False;
6376
6377 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
6378 return False;
6379 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
6380 return False;
6381 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
6382 return False;
6383 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
6384 return False;
6385 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
6386 return False;
6387 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
6388 return False;
6389 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
6390 return False;
6391 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
6392 return False;
6393 if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth)) /* unknown string */
6394 return False;
6395 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6396 return False;
6397
6398 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6399 return False;
6400 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6401 return False;
6402
6403 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
6404 return False;
6405 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
6406 return False;
6407 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
6408 return False;
6409
6410 if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6411 return False;
6412 if(!prs_uint16("logon_divs ", ps, depth, &usr->logon_divs)) /* logon divisions per week */
6413 return False;
6414 if(!prs_align(ps))
6415 return False;
6416 if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
6417 return False;
6418
6419 if(!prs_uint16("bad_password_count ", ps, depth, &usr->bad_password_count))
6420 return False;
6421 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count))
6422 return False;
6423
6424 if(!prs_uint8s(False, "padding1 ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6425 return False;
6426 if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6427 return False;
6428 if(!prs_uint8("padding2 ", ps, depth, &usr->padding2))
6429 return False;
6430
6431 /* here begins pointed-to data */
6432
6433 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name,usr->hdr_user_name.buffer, ps, depth))
6434 return False;
6435 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))
6436 return False;
6437 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))
6438 return False;
6439 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))
6440 return False;
6441 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))
6442 return False;
6443 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))
6444 return False;
6445 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))
6446 return False;
6447 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))
6448 return False;
6449 if(!smb_io_unistr2("uni_comment", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth))
6450 return False;
6451 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth))
6452 return False;
6453
6454 /* ok, this is only guess-work (as usual) */
6455 if (usr->ptr_logon_hrs) {
6456 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6457 return False;
6458 }
6459
6460 return True;
6461 }
6462
6463 void init_sam_user_info20A(SAM_USER_INFO_20 *usr, struct samu *pw)
6464 {
6465 const char *munged_dial = pdb_get_munged_dial(pw);
6466 DATA_BLOB blob;
6467
6468 if (munged_dial) {
6469 blob = base64_decode_data_blob(munged_dial);
6470 } else {
6471 blob = data_blob(NULL, 0);
6472 }
6473
6474 init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
6475 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6476 data_blob_free(&blob);
6477 }
6478
6479 /*******************************************************************
6480 reads or writes a structure.
6481 ********************************************************************/
6482
6483 static BOOL sam_io_user_info20(const char *desc, SAM_USER_INFO_20 *usr,
6484 prs_struct *ps, int depth)
6485 {
6486 if (usr == NULL)
6487 return False;
6488
6489 prs_debug(ps, depth, desc, "sam_io_user_info20");
6490 depth++;
6491
6492 if(!prs_align(ps))
6493 return False;
6494
6495 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6496 return False;
6497
6498 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth)) /* worksations user can log on from */
6499 return False;
6500
6501 return True;
6502 }
6503
6504 /*******************************************************************
6505 inits a SAM_USERINFO_CTR structure.
6506 ********************************************************************/
6507
6508 NTSTATUS make_samr_userinfo_ctr_usr21(TALLOC_CTX *ctx, SAM_USERINFO_CTR * ctr,
6509 uint16 switch_value,
6510 SAM_USER_INFO_21 * usr)
6511 {
6512 DEBUG(5, ("make_samr_userinfo_ctr_usr21\n"));
6513
6514 ctr->switch_value = switch_value;
6515 ctr->info.id = NULL;
6516
6517 switch (switch_value) {
6518 case 16:
6519 ctr->info.id16 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_16);
6520 if (ctr->info.id16 == NULL)
6521 return NT_STATUS_NO_MEMORY;
6522
6523 init_sam_user_info16(ctr->info.id16, usr->acb_info);
6524 break;
6525 #if 0
6526 /* whoops - got this wrong. i think. or don't understand what's happening. */
6527 case 17:
6528 {
6529 NTTIME expire;
6530 info = (void *)&id11;
6531
6532 expire.low = 0xffffffff;
6533 expire.high = 0x7fffffff;
6534
6535 ctr->info.id = TALLOC_ZERO_P(ctx,SAM_USER_INFO_17);
6536 init_sam_user_info11(ctr->info.id17, &expire,
6537 "BROOKFIELDS$", /* name */
6538 0x03ef, /* user rid */
6539 0x201, /* group rid */
6540 0x0080); /* acb info */
6541
6542 break;
6543 }
6544 #endif
6545 case 18:
6546 ctr->info.id18 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_18);
6547 if (ctr->info.id18 == NULL)
6548 return NT_STATUS_NO_MEMORY;
6549
6550 init_sam_user_info18(ctr->info.id18, usr->lm_pwd, usr->nt_pwd);
6551 break;
6552 case 21:
6553 {
6554 SAM_USER_INFO_21 *cusr;
6555 cusr = TALLOC_ZERO_P(ctx,SAM_USER_INFO_21);
6556 ctr->info.id21 = cusr;
6557 if (ctr->info.id21 == NULL)
6558 return NT_STATUS_NO_MEMORY;
6559 memcpy(cusr, usr, sizeof(*usr));
6560 memset(cusr->lm_pwd, 0, sizeof(cusr->lm_pwd));
6561 memset(cusr->nt_pwd, 0, sizeof(cusr->nt_pwd));
6562 break;
6563 }
6564 default:
6565 DEBUG(4,("make_samr_userinfo_ctr: unsupported info\n"));
6566 return NT_STATUS_INVALID_INFO_CLASS;
6567 }
6568
6569 return NT_STATUS_OK;
6570 }
6571
6572 /*******************************************************************
6573 inits a SAM_USERINFO_CTR structure.
6574 ********************************************************************/
6575
6576 static void init_samr_userinfo_ctr(SAM_USERINFO_CTR * ctr, DATA_BLOB *sess_key,
6577 uint16 switch_value, void *info)
6578 {
6579 DEBUG(5, ("init_samr_userinfo_ctr\n"));
6580
6581 ctr->switch_value = switch_value;
6582 ctr->info.id = info;
6583
6584 switch (switch_value) {
6585 case 0x18:
6586 SamOEMhashBlob(ctr->info.id24->pass, 516, sess_key);
6587 dump_data(100, (char *)sess_key->data, sess_key->length);
6588 dump_data(100, (char *)ctr->info.id24->pass, 516);
6589 break;
6590 case 0x17:
6591 SamOEMhashBlob(ctr->info.id23->pass, 516, sess_key);
6592 dump_data(100, (char *)sess_key->data, sess_key->length);
6593 dump_data(100, (char *)ctr->info.id23->pass, 516);
6594 break;
6595 case 0x07:
6596 break;
6597 default:
6598 DEBUG(4,("init_samr_userinfo_ctr: unsupported switch level: %d\n", switch_value));
6599 }
6600 }
6601
6602 /*******************************************************************
6603 reads or writes a structure.
6604 ********************************************************************/
6605
6606 static BOOL samr_io_userinfo_ctr(const char *desc, SAM_USERINFO_CTR **ppctr,
6607 prs_struct *ps, int depth)
6608 {
6609 BOOL ret;
6610 SAM_USERINFO_CTR *ctr;
6611
6612 prs_debug(ps, depth, desc, "samr_io_userinfo_ctr");
6613 depth++;
6614
6615 if (UNMARSHALLING(ps)) {
6616 ctr = PRS_ALLOC_MEM(ps,SAM_USERINFO_CTR,1);
6617 if (ctr == NULL)
6618 return False;
6619 *ppctr = ctr;
6620 } else {
6621 ctr = *ppctr;
6622 }
6623
6624 /* lkclXXXX DO NOT ALIGN BEFORE READING SWITCH VALUE! */
6625
6626 if(!prs_uint16("switch_value", ps, depth, &ctr->switch_value))
6627 return False;
6628 if(!prs_align(ps))
6629 return False;
6630
6631 ret = False;
6632
6633 switch (ctr->switch_value) {
6634 case 7:
6635 if (UNMARSHALLING(ps))
6636 ctr->info.id7 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_7,1);
6637 if (ctr->info.id7 == NULL) {
6638 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6639 return False;
6640 }
6641 ret = sam_io_user_info7("", ctr->info.id7, ps, depth);
6642 break;
6643 case 9:
6644 if (UNMARSHALLING(ps))
6645 ctr->info.id9 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_9,1);
6646 if (ctr->info.id9 == NULL) {
6647 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6648 return False;
6649 }
6650 ret = sam_io_user_info9("", ctr->info.id9, ps, depth);
6651 break;
6652 case 16:
6653 if (UNMARSHALLING(ps))
6654 ctr->info.id16 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_16,1);
6655 if (ctr->info.id16 == NULL) {
6656 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6657 return False;
6658 }
6659 ret = sam_io_user_info16("", ctr->info.id16, ps, depth);
6660 break;
6661 case 17:
6662 if (UNMARSHALLING(ps))
6663 ctr->info.id17 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_17,1);
6664
6665 if (ctr->info.id17 == NULL) {
6666 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6667 return False;
6668 }
6669 ret = sam_io_user_info17("", ctr->info.id17, ps, depth);
6670 break;
6671 case 18:
6672 if (UNMARSHALLING(ps))
6673 ctr->info.id18 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_18,1);
6674
6675 if (ctr->info.id18 == NULL) {
6676 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6677 return False;
6678 }
6679 ret = sam_io_user_info18("", ctr->info.id18, ps, depth);
6680 break;
6681 case 20:
6682 if (UNMARSHALLING(ps))
6683 ctr->info.id20 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_20,1);
6684
6685 if (ctr->info.id20 == NULL) {
6686 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6687 return False;
6688 }
6689 ret = sam_io_user_info20("", ctr->info.id20, ps, depth);
6690 break;
6691 case 21:
6692 if (UNMARSHALLING(ps))
6693 ctr->info.id21 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_21,1);
6694
6695 if (ctr->info.id21 == NULL) {
6696 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6697 return False;
6698 }
6699 ret = sam_io_user_info21("", ctr->info.id21, ps, depth);
6700 break;
6701 case 23:
6702 if (UNMARSHALLING(ps))
6703 ctr->info.id23 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_23,1);
6704
6705 if (ctr->info.id23 == NULL) {
6706 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6707 return False;
6708 }
6709 ret = sam_io_user_info23("", ctr->info.id23, ps, depth);
6710 break;
6711 case 24:
6712 if (UNMARSHALLING(ps))
6713 ctr->info.id24 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_24,1);
6714
6715 if (ctr->info.id24 == NULL) {
6716 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6717 return False;
6718 }
6719 ret = sam_io_user_info24("", ctr->info.id24, ps, depth);
6720 break;
6721 case 25:
6722 if (UNMARSHALLING(ps))
6723 ctr->info.id25 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_25,1);
6724
6725 if (ctr->info.id25 == NULL) {
6726 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6727 return False;
6728 }
6729 ret = sam_io_user_info25("", ctr->info.id25, ps, depth);
6730 break;
6731 case 26:
6732 if (UNMARSHALLING(ps))
6733 ctr->info.id26 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_26,1);
6734
6735 if (ctr->info.id26 == NULL) {
6736 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6737 return False;
6738 }
6739 ret = sam_io_user_info26("", ctr->info.id26, ps, depth);
6740 break;
6741 default:
6742 DEBUG(2, ("samr_io_userinfo_ctr: unknown switch level 0x%x\n", ctr->switch_value));
6743 ret = False;
6744 break;
6745 }
6746
6747 return ret;
6748 }
6749
6750 /*******************************************************************
6751 inits a SAMR_R_QUERY_USERINFO structure.
6752 ********************************************************************/
6753
6754 void init_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO * r_u,
6755 SAM_USERINFO_CTR * ctr, NTSTATUS status)
6756 {
6757 DEBUG(5, ("init_samr_r_query_userinfo\n"));
6758
6759 r_u->ptr = 0;
6760 r_u->ctr = NULL;
6761
6762 if (NT_STATUS_IS_OK(status)) {
6763 r_u->ptr = 1;
6764 r_u->ctr = ctr;
6765 }
6766
6767 r_u->status = status; /* return status */
6768 }
6769
6770 /*******************************************************************
6771 reads or writes a structure.
6772 ********************************************************************/
6773
6774 BOOL samr_io_r_query_userinfo(const char *desc, SAMR_R_QUERY_USERINFO * r_u,
6775 prs_struct *ps, int depth)
6776 {
6777 if (r_u == NULL)
6778 return False;
6779
6780 prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
6781 depth++;
6782
6783 if(!prs_align(ps))
6784 return False;
6785
6786 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
6787 return False;
6788
6789 if (r_u->ptr != 0) {
6790 if(!samr_io_userinfo_ctr("ctr", &r_u->ctr, ps, depth))
6791 return False;
6792 }
6793
6794 if(!prs_align(ps))
6795 return False;
6796 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6797 return False;
6798
6799 return True;
6800 }
6801
6802 /*******************************************************************
6803 inits a SAMR_Q_SET_USERINFO structure.
6804 ********************************************************************/
6805
6806 void init_samr_q_set_userinfo(SAMR_Q_SET_USERINFO * q_u,
6807 const POLICY_HND *hnd, DATA_BLOB *sess_key,
6808 uint16 switch_value, void *info)
6809 {
6810 DEBUG(5, ("init_samr_q_set_userinfo\n"));
6811
6812 q_u->pol = *hnd;
6813 q_u->switch_value = switch_value;
6814 init_samr_userinfo_ctr(q_u->ctr, sess_key, switch_value, info);
6815 }
6816
6817 /*******************************************************************
6818 reads or writes a structure.
6819 ********************************************************************/
6820
6821 BOOL samr_io_q_set_userinfo(const char *desc, SAMR_Q_SET_USERINFO * q_u,
6822 prs_struct *ps, int depth)
6823 {
6824 if (q_u == NULL)
6825 return False;
6826
6827 prs_debug(ps, depth, desc, "samr_io_q_set_userinfo");
6828 depth++;
6829
6830 if(!prs_align(ps))
6831 return False;
6832
6833 smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
6834
6835 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6836 return False;
6837 if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6838 return False;
6839
6840 return True;
6841 }
6842
6843 /*******************************************************************
6844 inits a SAMR_R_SET_USERINFO structure.
6845 ********************************************************************/
6846
6847 void init_samr_r_set_userinfo(SAMR_R_SET_USERINFO * r_u, NTSTATUS status)
6848 {
6849 DEBUG(5, ("init_samr_r_set_userinfo\n"));
6850
6851 r_u->status = status; /* return status */
6852 }
6853
6854 /*******************************************************************
6855 reads or writes a structure.
6856 ********************************************************************/
6857
6858 BOOL samr_io_r_set_userinfo(const char *desc, SAMR_R_SET_USERINFO * r_u,
6859 prs_struct *ps, int depth)
6860 {
6861 if (r_u == NULL)
6862 return False;
6863
6864 prs_debug(ps, depth, desc, "samr_io_r_set_userinfo");
6865 depth++;
6866
6867 if(!prs_align(ps))
6868 return False;
6869
6870 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6871 return False;
6872
6873 return True;
6874 }
6875
6876 /*******************************************************************
6877 inits a SAMR_Q_SET_USERINFO2 structure.
6878 ********************************************************************/
6879
6880 void init_samr_q_set_userinfo2(SAMR_Q_SET_USERINFO2 * q_u,
6881 const POLICY_HND *hnd, DATA_BLOB *sess_key,
6882 uint16 switch_value, SAM_USERINFO_CTR * ctr)
6883 {
6884 DEBUG(5, ("init_samr_q_set_userinfo2\n"));
6885
6886 q_u->pol = *hnd;
6887 q_u->switch_value = switch_value;
6888 q_u->ctr = ctr;
6889
6890 q_u->ctr->switch_value = switch_value;
6891
6892 switch (switch_value) {
6893 case 18:
6894 SamOEMhashBlob(ctr->info.id18->lm_pwd, 16, sess_key);
6895 SamOEMhashBlob(ctr->info.id18->nt_pwd, 16, sess_key);
6896 dump_data(100, (char *)sess_key->data, sess_key->length);
6897 dump_data(100, (char *)ctr->info.id18->lm_pwd, 16);
6898 dump_data(100, (char *)ctr->info.id18->nt_pwd, 16);
6899 break;
6900 }
6901 }
6902
6903 /*******************************************************************
6904 reads or writes a structure.
6905 ********************************************************************/
6906
6907 BOOL samr_io_q_set_userinfo2(const char *desc, SAMR_Q_SET_USERINFO2 * q_u,
6908 prs_struct *ps, int depth)
6909 {
6910 if (q_u == NULL)
6911 return False;
6912
6913 prs_debug(ps, depth, desc, "samr_io_q_set_userinfo2");
6914 depth++;
6915
6916 if(!prs_align(ps))
6917 return False;
6918
6919 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
6920 return False;
6921
6922 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6923 return False;
6924 if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6925 return False;
6926
6927 return True;
6928 }
6929
6930 /*******************************************************************
6931 inits a SAMR_R_SET_USERINFO2 structure.
6932 ********************************************************************/
6933
6934 void init_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2 * r_u, NTSTATUS status)
6935 {
6936 DEBUG(5, ("init_samr_r_set_userinfo2\n"));
6937
6938 r_u->status = status; /* return status */
6939 }
6940
6941 /*******************************************************************
6942 reads or writes a structure.
6943 ********************************************************************/
6944
6945 BOOL samr_io_r_set_userinfo2(const char *desc, SAMR_R_SET_USERINFO2 * r_u,
6946 prs_struct *ps, int depth)
6947 {
6948 if (r_u == NULL)
6949 return False;
6950
6951 prs_debug(ps, depth, desc, "samr_io_r_set_userinfo2");
6952 depth++;
6953
6954 if(!prs_align(ps))
6955 return False;
6956
6957 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6958 return False;
6959
6960 return True;
6961 }
6962
6963 /*******************************************************************
6964 inits a SAMR_Q_CONNECT structure.
6965 ********************************************************************/
6966
6967 void init_samr_q_connect(SAMR_Q_CONNECT * q_u,
6968 char *srv_name, uint32 access_mask)
6969 {
6970 DEBUG(5, ("init_samr_q_connect\n"));
6971
6972 /* make PDC server name \\server */
6973 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
6974 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
6975
6976 /* example values: 0x0000 0002 */
6977 q_u->access_mask = access_mask;
6978 }
6979
6980 /*******************************************************************
6981 reads or writes a structure.
6982 ********************************************************************/
6983
6984 BOOL samr_io_q_connect(const char *desc, SAMR_Q_CONNECT * q_u,
6985 prs_struct *ps, int depth)
6986 {
6987 if (q_u == NULL)
6988 return False;
6989
6990 prs_debug(ps, depth, desc, "samr_io_q_connect");
6991 depth++;
6992
6993 if(!prs_align(ps))
6994 return False;
6995
6996 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
6997 return False;
6998 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
6999 return False;
7000
7001 if(!prs_align(ps))
7002 return False;
7003 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7004 return False;
7005
7006 return True;
7007 }
7008
7009 /*******************************************************************
7010 reads or writes a structure.
7011 ********************************************************************/
7012
7013 BOOL samr_io_r_connect(const char *desc, SAMR_R_CONNECT * r_u,
7014 prs_struct *ps, int depth)
7015 {
7016 if (r_u == NULL)
7017 return False;
7018
7019 prs_debug(ps, depth, desc, "samr_io_r_connect");
7020 depth++;
7021
7022 if(!prs_align(ps))
7023 return False;
7024
7025 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7026 return False;
7027
7028 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7029 return False;
7030
7031 return True;
7032 }
7033
7034 /*******************************************************************
7035 inits a SAMR_Q_CONNECT4 structure.
7036 ********************************************************************/
7037
7038 void init_samr_q_connect4(SAMR_Q_CONNECT4 * q_u,
7039 char *srv_name, uint32 access_mask)
7040 {
7041 DEBUG(5, ("init_samr_q_connect4\n"));
7042
7043 /* make PDC server name \\server */
7044 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7045 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7046
7047 /* Only value we've seen, possibly an address type ? */
7048 q_u->unk_0 = 2;
7049
7050 /* example values: 0x0000 0002 */
7051 q_u->access_mask = access_mask;
7052 }
7053
7054 /*******************************************************************
7055 reads or writes a structure.
7056 ********************************************************************/
7057
7058 BOOL samr_io_q_connect4(const char *desc, SAMR_Q_CONNECT4 * q_u,
7059 prs_struct *ps, int depth)
7060 {
7061 if (q_u == NULL)
7062 return False;
7063
7064 prs_debug(ps, depth, desc, "samr_io_q_connect4");
7065 depth++;
7066
7067 if(!prs_align(ps))
7068 return False;
7069
7070 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7071 return False;
7072 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7073 return False;
7074
7075 if(!prs_align(ps))
7076 return False;
7077 if(!prs_uint32("unk_0", ps, depth, &q_u->unk_0))
7078 return False;
7079 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7080 return False;
7081
7082 return True;
7083 }
7084
7085 /*******************************************************************
7086 reads or writes a structure.
7087 ********************************************************************/
7088
7089 BOOL samr_io_r_connect4(const char *desc, SAMR_R_CONNECT4 * r_u,
7090 prs_struct *ps, int depth)
7091 {
7092 if (r_u == NULL)
7093 return False;
7094
7095 prs_debug(ps, depth, desc, "samr_io_r_connect4");
7096 depth++;
7097
7098 if(!prs_align(ps))
7099 return False;
7100
7101 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7102 return False;
7103
7104 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7105 return False;
7106
7107 return True;
7108 }
7109
7110 /*******************************************************************
7111 inits a SAMR_Q_CONNECT5 structure.
7112 ********************************************************************/
7113
7114 void init_samr_q_connect5(SAMR_Q_CONNECT5 * q_u,
7115 char *srv_name, uint32 access_mask)
7116 {
7117 DEBUG(5, ("init_samr_q_connect5\n"));
7118
7119 /* make PDC server name \\server */
7120 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7121 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7122
7123 /* example values: 0x0000 0002 */
7124 q_u->access_mask = access_mask;
7125
7126 q_u->level = 1;
7127 q_u->info1_unk1 = 3;
7128 q_u->info1_unk2 = 0;
7129 }
7130
7131 /*******************************************************************
7132 inits a SAMR_R_CONNECT5 structure.
7133 ********************************************************************/
7134
7135 void init_samr_r_connect5(SAMR_R_CONNECT5 * r_u, POLICY_HND *pol, NTSTATUS status)
7136 {
7137 DEBUG(5, ("init_samr_q_connect5\n"));
7138
7139 r_u->level = 1;
7140 r_u->info1_unk1 = 3;
7141 r_u->info1_unk2 = 0;
7142
7143 r_u->connect_pol = *pol;
7144 r_u->status = status;
7145 }
7146
7147 /*******************************************************************
7148 reads or writes a structure.
7149 ********************************************************************/
7150
7151 BOOL samr_io_q_connect5(const char *desc, SAMR_Q_CONNECT5 * q_u,
7152 prs_struct *ps, int depth)
7153 {
7154 if (q_u == NULL)
7155 return False;
7156
7157 prs_debug(ps, depth, desc, "samr_io_q_connect5");
7158 depth++;
7159
7160 if(!prs_align(ps))
7161 return False;
7162
7163 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7164 return False;
7165 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7166 return False;
7167
7168 if(!prs_align(ps))
7169 return False;
7170 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7171 return False;
7172
7173 if(!prs_uint32("level", ps, depth, &q_u->level))
7174 return False;
7175 if(!prs_uint32("level", ps, depth, &q_u->level))
7176 return False;
7177
7178 if(!prs_uint32("info1_unk1", ps, depth, &q_u->info1_unk1))
7179 return False;
7180 if(!prs_uint32("info1_unk2", ps, depth, &q_u->info1_unk2))
7181 return False;
7182
7183 return True;
7184 }
7185
7186 /*******************************************************************
7187 reads or writes a structure.
7188 ********************************************************************/
7189
7190 BOOL samr_io_r_connect5(const char *desc, SAMR_R_CONNECT5 * r_u,
7191 prs_struct *ps, int depth)
7192 {
7193 if (r_u == NULL)
7194 return False;
7195
7196 prs_debug(ps, depth, desc, "samr_io_r_connect5");
7197 depth++;
7198
7199 if(!prs_align(ps))
7200 return False;
7201
7202 if(!prs_uint32("level", ps, depth, &r_u->level))
7203 return False;
7204 if(!prs_uint32("level", ps, depth, &r_u->level))
7205 return False;
7206 if(!prs_uint32("info1_unk1", ps, depth, &r_u->info1_unk1))
7207 return False;
7208 if(!prs_uint32("info1_unk2", ps, depth, &r_u->info1_unk2))
7209 return False;
7210
7211 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7212 return False;
7213
7214 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7215 return False;
7216
7217 return True;
7218 }
7219
7220 /*******************************************************************
7221 inits a SAMR_Q_CONNECT_ANON structure.
7222 ********************************************************************/
7223
7224 void init_samr_q_connect_anon(SAMR_Q_CONNECT_ANON * q_u)
7225 {
7226 DEBUG(5, ("init_samr_q_connect_anon\n"));
7227
7228 q_u->ptr = 1;
7229 q_u->unknown_0 = 0x5c; /* server name (?!!) */
7230 q_u->access_mask = MAXIMUM_ALLOWED_ACCESS;
7231 }
7232
7233 /*******************************************************************
7234 reads or writes a structure.
7235 ********************************************************************/
7236
7237 BOOL samr_io_q_connect_anon(const char *desc, SAMR_Q_CONNECT_ANON * q_u,
7238 prs_struct *ps, int depth)
7239 {
7240 if (q_u == NULL)
7241 return False;
7242
7243 prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
7244 depth++;
7245
7246 if(!prs_align(ps))
7247 return False;
7248
7249 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
7250 return False;
7251 if (q_u->ptr) {
7252 if(!prs_uint16("unknown_0", ps, depth, &q_u->unknown_0))
7253 return False;
7254 }
7255 if(!prs_align(ps))
7256 return False;
7257 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7258 return False;
7259
7260 return True;
7261 }
7262
7263 /*******************************************************************
7264 reads or writes a structure.
7265 ********************************************************************/
7266
7267 BOOL samr_io_r_connect_anon(const char *desc, SAMR_R_CONNECT_ANON * r_u,
7268 prs_struct *ps, int depth)
7269 {
7270 if (r_u == NULL)
7271 return False;
7272
7273 prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
7274 depth++;
7275
7276 if(!prs_align(ps))
7277 return False;
7278
7279 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7280 return False;
7281
7282 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7283 return False;
7284
7285 return True;
7286 }
7287
7288 /*******************************************************************
7289 inits a SAMR_Q_GET_DOM_PWINFO structure.
7290 ********************************************************************/
7291
7292 void init_samr_q_get_dom_pwinfo(SAMR_Q_GET_DOM_PWINFO * q_u,
7293 char *srv_name)
7294 {
7295 DEBUG(5, ("init_samr_q_get_dom_pwinfo\n"));
7296
7297 q_u->ptr = 1;
7298 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_FLAGS_NONE);
7299 init_uni_hdr(&q_u->hdr_srv_name, &q_u->uni_srv_name);
7300 }
7301
7302 /*******************************************************************
7303 reads or writes a structure.
7304 ********************************************************************/
7305
7306 BOOL samr_io_q_get_dom_pwinfo(const char *desc, SAMR_Q_GET_DOM_PWINFO * q_u,
7307 prs_struct *ps, int depth)
7308 {
7309 if (q_u == NULL)
7310 return False;
7311
7312 prs_debug(ps, depth, desc, "samr_io_q_get_dom_pwinfo");
7313 depth++;
7314
7315 if(!prs_align(ps))
7316 return False;
7317
7318 if(!prs_uint32("ptr", ps, depth, &q_u->ptr))
7319 return False;
7320 if (q_u->ptr != 0) {
7321 if(!smb_io_unihdr("", &q_u->hdr_srv_name, ps, depth))
7322 return False;
7323 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->hdr_srv_name.buffer, ps, depth))
7324 return False;
7325 }
7326
7327 return True;
7328 }
7329
7330 /*******************************************************************
7331 reads or writes a structure.
7332 ********************************************************************/
7333
7334 BOOL samr_io_r_get_dom_pwinfo(const char *desc, SAMR_R_GET_DOM_PWINFO * r_u,
7335 prs_struct *ps, int depth)
7336 {
7337 if (r_u == NULL)
7338 return False;
7339
7340 prs_debug(ps, depth, desc, "samr_io_r_get_dom_pwinfo");
7341 depth++;
7342
7343 if(!prs_align(ps))
7344 return False;
7345
7346 if(!prs_uint16("min_pwd_length", ps, depth, &r_u->min_pwd_length))
7347 return False;
7348 if(!prs_align(ps))
7349 return False;
7350 if(!prs_uint32("password_properties", ps, depth, &r_u->password_properties))
7351 return False;
7352
7353 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7354 return False;
7355
7356 return True;
7357 }
7358
7359 /*******************************************************************
7360 make a SAMR_ENC_PASSWD structure.
7361 ********************************************************************/
7362
7363 void init_enc_passwd(SAMR_ENC_PASSWD * pwd, const char pass[512])
7364 {
7365 ZERO_STRUCTP(pwd);
7366
7367 if (pass == NULL) {
7368 pwd->ptr = 0;
7369 } else {
7370 pwd->ptr = 1;
7371 memcpy(pwd->pass, pass, sizeof(pwd->pass));
7372 }
7373 }
7374
7375 /*******************************************************************
7376 reads or writes a SAMR_ENC_PASSWD structure.
7377 ********************************************************************/
7378
7379 BOOL samr_io_enc_passwd(const char *desc, SAMR_ENC_PASSWD * pwd,
7380 prs_struct *ps, int depth)
7381 {
7382 if (pwd == NULL)
7383 return False;
7384
7385 prs_debug(ps, depth, desc, "samr_io_enc_passwd");
7386 depth++;
7387
7388 if(!prs_align(ps))
7389 return False;
7390
7391 if(!prs_uint32("ptr", ps, depth, &pwd->ptr))
7392 return False;
7393
7394 if (pwd->ptr != 0) {
7395 if(!prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass)))
7396 return False;
7397 }
7398
7399 return True;
7400 }
7401
7402 /*******************************************************************
7403 inits a SAMR_ENC_HASH structure.
7404 ********************************************************************/
7405
7406 void init_enc_hash(SAMR_ENC_HASH * hsh, const uchar hash[16])
7407 {
7408 ZERO_STRUCTP(hsh);
7409
7410 if (hash == NULL) {
7411 hsh->ptr = 0;
7412 } else {
7413 hsh->ptr = 1;
7414 memcpy(hsh->hash, hash, sizeof(hsh->hash));
7415 }
7416 }
7417
7418 /*******************************************************************
7419 reads or writes a SAMR_ENC_HASH structure.
7420 ********************************************************************/
7421
7422 BOOL samr_io_enc_hash(const char *desc, SAMR_ENC_HASH * hsh,
7423 prs_struct *ps, int depth)
7424 {
7425 if (hsh == NULL)
7426 return False;
7427
7428 prs_debug(ps, depth, desc, "samr_io_enc_hash");
7429 depth++;
7430
7431 if(!prs_align(ps))
7432 return False;
7433
7434 if(!prs_uint32("ptr ", ps, depth, &hsh->ptr))
7435 return False;
7436 if (hsh->ptr != 0) {
7437 if(!prs_uint8s(False, "hash", ps, depth, hsh->hash,sizeof(hsh->hash)))
7438 return False;
7439 }
7440
7441 return True;
7442 }
7443
7444 /*******************************************************************
7445 inits a SAMR_Q_CHGPASSWD_USER structure.
7446 ********************************************************************/
7447
7448 void init_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER * q_u,
7449 const char *dest_host, const char *user_name,
7450 const uchar nt_newpass[516],
7451 const uchar nt_oldhash[16],
7452 const uchar lm_newpass[516],
7453 const uchar lm_oldhash[16])
7454 {
7455 DEBUG(5, ("init_samr_q_chgpasswd_user\n"));
7456
7457 q_u->ptr_0 = 1;
7458 init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7459 init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7460
7461 init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7462 init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7463
7464 init_enc_passwd(&q_u->nt_newpass, (const char *)nt_newpass);
7465 init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7466
7467 q_u->unknown = 0x01;
7468
7469 init_enc_passwd(&q_u->lm_newpass, (const char *)lm_newpass);
7470 init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7471 }
7472
7473 /*******************************************************************
7474 reads or writes a structure.
7475 ********************************************************************/
7476
7477 BOOL samr_io_q_chgpasswd_user(const char *desc, SAMR_Q_CHGPASSWD_USER * q_u,
7478 prs_struct *ps, int depth)
7479 {
7480 if (q_u == NULL)
7481 return False;
7482
7483 prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
7484 depth++;
7485
7486 if(!prs_align(ps))
7487 return False;
7488
7489 if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7490 return False;
7491
7492 if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7493 return False;
7494 if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7495 return False;
7496
7497 if(!prs_align(ps))
7498 return False;
7499 if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7500 return False;
7501 if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7502 return False;
7503
7504 if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7505 return False;
7506 if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7507 return False;
7508
7509 if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
7510 return False;
7511
7512 if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7513 return False;
7514 if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7515 return False;
7516
7517 return True;
7518 }
7519
7520 /*******************************************************************
7521 inits a SAMR_R_CHGPASSWD_USER structure.
7522 ********************************************************************/
7523
7524 void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER * r_u, NTSTATUS status)
7525 {
7526 DEBUG(5, ("init_samr_r_chgpasswd_user\n"));
7527
7528 r_u->status = status;
7529 }
7530
7531 /*******************************************************************
7532 reads or writes a structure.
7533 ********************************************************************/
7534
7535 BOOL samr_io_r_chgpasswd_user(const char *desc, SAMR_R_CHGPASSWD_USER * r_u,
7536 prs_struct *ps, int depth)
7537 {
7538 if (r_u == NULL)
7539 return False;
7540
7541 prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
7542 depth++;
7543
7544 if(!prs_align(ps))
7545 return False;
7546
7547 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7548 return False;
7549
7550 return True;
7551 }
7552
7553 /*******************************************************************
7554 inits a SAMR_Q_CHGPASSWD3 structure.
7555 ********************************************************************/
7556
7557 void init_samr_q_chgpasswd_user3(SAMR_Q_CHGPASSWD_USER3 * q_u,
7558 const char *dest_host, const char *user_name,
7559 const uchar nt_newpass[516],
7560 const uchar nt_oldhash[16],
7561 const uchar lm_newpass[516],
7562 const uchar lm_oldhash[16])
7563 {
7564 DEBUG(5, ("init_samr_q_chgpasswd_user3\n"));
7565
7566 q_u->ptr_0 = 1;
7567 init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7568 init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7569
7570 init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7571 init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7572
7573 init_enc_passwd(&q_u->nt_newpass, (const char *)nt_newpass);
7574 init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7575
7576 q_u->lm_change = 0x01;
7577
7578 init_enc_passwd(&q_u->lm_newpass, (const char *)lm_newpass);
7579 init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7580
7581 init_enc_passwd(&q_u->password3, NULL);
7582 }
7583
7584 /*******************************************************************
7585 reads or writes a structure.
7586 ********************************************************************/
7587
7588 BOOL samr_io_q_chgpasswd_user3(const char *desc, SAMR_Q_CHGPASSWD_USER3 * q_u,
7589 prs_struct *ps, int depth)
7590 {
7591 if (q_u == NULL)
7592 return False;
7593
7594 prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user3");
7595 depth++;
7596
7597 if(!prs_align(ps))
7598 return False;
7599
7600 if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7601 return False;
7602
7603 if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7604 return False;
7605 if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7606 return False;
7607
7608 if(!prs_align(ps))
7609 return False;
7610 if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7611 return False;
7612 if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7613 return False;
7614
7615 if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7616 return False;
7617 if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7618 return False;
7619
7620 if(!prs_uint32("lm_change", ps, depth, &q_u->lm_change))
7621 return False;
7622
7623 if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7624 return False;
7625 if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7626 return False;
7627
7628 if(!samr_io_enc_passwd("password3", &q_u->password3, ps, depth))
7629 return False;
7630
7631 return True;
7632 }
7633
7634 /*******************************************************************
7635 inits a SAMR_R_CHGPASSWD_USER3 structure.
7636 ********************************************************************/
7637
7638 void init_samr_r_chgpasswd_user3(SAMR_R_CHGPASSWD_USER3 *r_u, NTSTATUS status,
7639 SAMR_CHANGE_REJECT *reject, SAM_UNK_INFO_1 *info)
7640 {
7641 DEBUG(5, ("init_samr_r_chgpasswd_user3\n"));
7642
7643 r_u->status = status;
7644 r_u->info = 0;
7645 r_u->ptr_info = 0;
7646 r_u->reject = 0;
7647 r_u->ptr_reject = 0;
7648
7649 if (info) {
7650 r_u->info = info;
7651 r_u->ptr_info = 1;
7652 }
7653 if (reject && (reject->reject_reason != Undefined)) {
7654 r_u->reject = reject;
7655 r_u->ptr_reject = 1;
7656 }
7657 }
7658
7659 /*******************************************************************
7660 Reads or writes an SAMR_CHANGE_REJECT structure.
7661 ********************************************************************/
7662
7663 BOOL samr_io_change_reject(const char *desc, SAMR_CHANGE_REJECT *reject, prs_struct *ps, int depth)
7664 {
7665 if (reject == NULL)
7666 return False;
7667
7668 prs_debug(ps, depth, desc, "samr_io_change_reject");
7669 depth++;
7670
7671 if(!prs_align(ps))
7672 return False;
7673
7674 if(UNMARSHALLING(ps))
7675 ZERO_STRUCTP(reject);
7676
7677 if (!prs_uint32("reject_reason", ps, depth, &reject->reject_reason))
7678 return False;
7679
7680 if (!prs_uint32("unknown1", ps, depth, &reject->unknown1))
7681 return False;
7682
7683 if (!prs_uint32("unknown2", ps, depth, &reject->unknown2))
7684 return False;
7685
7686 return True;
7687 }
7688
7689 /*******************************************************************
7690 reads or writes a structure.
7691 ********************************************************************/
7692
7693 BOOL samr_io_r_chgpasswd_user3(const char *desc, SAMR_R_CHGPASSWD_USER3 *r_u,
7694 prs_struct *ps, int depth)
7695 {
7696 if (r_u == NULL)
7697 return False;
7698
7699 prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user3");
7700 depth++;
7701
7702 if (!prs_align(ps))
7703 return False;
7704
7705 if (!prs_uint32("ptr_info", ps, depth, &r_u->ptr_info))
7706 return False;
7707
7708 if (r_u->ptr_info && r_u->info != NULL) {
7709 /* SAM_UNK_INFO_1 */
7710 if (!sam_io_unk_info1("info", r_u->info, ps, depth))
7711 return False;
7712 }
7713
7714 if (!prs_uint32("ptr_reject", ps, depth, &r_u->ptr_reject))
7715 return False;
7716
7717 if (r_u->ptr_reject && r_u->reject != NULL) {
7718 /* SAMR_CHANGE_REJECT */
7719 if (!samr_io_change_reject("reject", r_u->reject, ps, depth))
7720 return False;
7721 }
7722
7723 if (!prs_ntstatus("status", ps, depth, &r_u->status))
7724 return False;
7725
7726 return True;
7727 }
7728
7729 /*******************************************************************
7730 reads or writes a structure.
7731 ********************************************************************/
7732
7733 void init_samr_q_query_domain_info2(SAMR_Q_QUERY_DOMAIN_INFO2 *q_u,
7734 POLICY_HND *domain_pol, uint16 switch_value)
7735 {
7736 DEBUG(5, ("init_samr_q_query_domain_info2\n"));
7737
7738 q_u->domain_pol = *domain_pol;
7739 q_u->switch_value = switch_value;
7740 }
7741
7742 /*******************************************************************
7743 reads or writes a structure.
7744 ********************************************************************/
7745
7746 BOOL samr_io_q_query_domain_info2(const char *desc, SAMR_Q_QUERY_DOMAIN_INFO2 *q_u,
7747 prs_struct *ps, int depth)
7748 {
7749 if (q_u == NULL)
7750 return False;
7751
7752 prs_debug(ps, depth, desc, "samr_io_q_query_domain_info2");
7753 depth++;
7754
7755 if(!prs_align(ps))
7756 return False;
7757
7758 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7759 return False;
7760
7761 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7762 return False;
7763
7764 return True;
7765 }
7766
7767 /*******************************************************************
7768 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7769 ********************************************************************/
7770
7771 void init_samr_r_query_domain_info2(SAMR_R_QUERY_DOMAIN_INFO2 * r_u,
7772 uint16 switch_value, SAM_UNK_CTR * ctr,
7773 NTSTATUS status)
7774 {
7775 DEBUG(5, ("init_samr_r_query_domain_info2\n"));
7776
7777 r_u->ptr_0 = 0;
7778 r_u->switch_value = 0;
7779 r_u->status = status; /* return status */
7780
7781 if (NT_STATUS_IS_OK(status)) {
7782 r_u->switch_value = switch_value;
7783 r_u->ptr_0 = 1;
7784 r_u->ctr = ctr;
7785 }
7786 }
7787
7788 /*******************************************************************
7789 reads or writes a structure.
7790 ********************************************************************/
7791
7792 BOOL samr_io_r_query_domain_info2(const char *desc, SAMR_R_QUERY_DOMAIN_INFO2 * r_u,
7793 prs_struct *ps, int depth)
7794 {
7795 if (r_u == NULL)
7796 return False;
7797
7798 prs_debug(ps, depth, desc, "samr_io_r_query_domain_info2");
7799 depth++;
7800
7801 if(!prs_align(ps))
7802 return False;
7803
7804 if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
7805 return False;
7806
7807 if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
7808 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
7809 return False;
7810 if(!prs_align(ps))
7811 return False;
7812
7813 switch (r_u->switch_value) {
7814 case 0x0d:
7815 if(!sam_io_unk_info13("unk_inf13", &r_u->ctr->info.inf13, ps, depth))
7816 return False;
7817 break;
7818 case 0x0c:
7819 if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
7820 return False;
7821 break;
7822 case 0x09:
7823 if(!sam_io_unk_info9("unk_inf9",&r_u->ctr->info.inf9, ps,depth))
7824 return False;
7825 break;
7826 case 0x08:
7827 if(!sam_io_unk_info8("unk_inf8",&r_u->ctr->info.inf8, ps,depth))
7828 return False;
7829 break;
7830 case 0x07:
7831 if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
7832 return False;
7833 break;
7834 case 0x06:
7835 if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
7836 return False;
7837 break;
7838 case 0x05:
7839 if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
7840 return False;
7841 break;
7842 case 0x04:
7843 if(!sam_io_unk_info4("unk_inf4",&r_u->ctr->info.inf4, ps,depth))
7844 return False;
7845 break;
7846 case 0x03:
7847 if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
7848 return False;
7849 break;
7850 case 0x02:
7851 if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
7852 return False;
7853 break;
7854 case 0x01:
7855 if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
7856 return False;
7857 break;
7858 default:
7859 DEBUG(0, ("samr_io_r_query_domain_info2: unknown switch level 0x%x\n",
7860 r_u->switch_value));
7861 r_u->status = NT_STATUS_INVALID_INFO_CLASS;
7862 return False;
7863 }
7864 }
7865
7866 if(!prs_align(ps))
7867 return False;
7868
7869 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7870 return False;
7871
7872 return True;
7873 }
7874
7875
7876 /*******************************************************************
7877 reads or writes a structure.
7878 ********************************************************************/
7879
7880 void init_samr_q_set_domain_info(SAMR_Q_SET_DOMAIN_INFO *q_u,
7881 POLICY_HND *domain_pol, uint16 switch_value, SAM_UNK_CTR *ctr)
7882 {
7883 DEBUG(5, ("init_samr_q_set_domain_info\n"));
7884
7885 q_u->domain_pol = *domain_pol;
7886 q_u->switch_value0 = switch_value;
7887
7888 q_u->switch_value = switch_value;
7889 q_u->ctr = ctr;
7890
7891 }
7892
7893 /*******************************************************************
7894 reads or writes a structure.
7895 ********************************************************************/
7896
7897 BOOL samr_io_q_set_domain_info(const char *desc, SAMR_Q_SET_DOMAIN_INFO *q_u,
7898 prs_struct *ps, int depth)
7899 {
7900 if (q_u == NULL)
7901 return False;
7902
7903 prs_debug(ps, depth, desc, "samr_io_q_set_domain_info");
7904 depth++;
7905
7906 if(!prs_align(ps))
7907 return False;
7908
7909 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7910 return False;
7911
7912 if(!prs_uint16("switch_value0", ps, depth, &q_u->switch_value0))
7913 return False;
7914
7915 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7916 return False;
7917
7918 if(!prs_align(ps))
7919 return False;
7920
7921 if (UNMARSHALLING(ps)) {
7922 if ((q_u->ctr = PRS_ALLOC_MEM(ps, SAM_UNK_CTR, 1)) == NULL)
7923 return False;
7924 }
7925
7926 switch (q_u->switch_value) {
7927
7928 case 0x0c:
7929 if(!sam_io_unk_info12("unk_inf12", &q_u->ctr->info.inf12, ps, depth))
7930 return False;
7931 break;
7932 case 0x07:
7933 if(!sam_io_unk_info7("unk_inf7",&q_u->ctr->info.inf7, ps,depth))
7934 return False;
7935 break;
7936 case 0x06:
7937 if(!sam_io_unk_info6("unk_inf6",&q_u->ctr->info.inf6, ps,depth))
7938 return False;
7939 break;
7940 case 0x05:
7941 if(!sam_io_unk_info5("unk_inf5",&q_u->ctr->info.inf5, ps,depth))
7942 return False;
7943 break;
7944 case 0x03:
7945 if(!sam_io_unk_info3("unk_inf3",&q_u->ctr->info.inf3, ps,depth))
7946 return False;
7947 break;
7948 case 0x02:
7949 if(!sam_io_unk_info2("unk_inf2",&q_u->ctr->info.inf2, ps,depth))
7950 return False;
7951 break;
7952 case 0x01:
7953 if(!sam_io_unk_info1("unk_inf1",&q_u->ctr->info.inf1, ps,depth))
7954 return False;
7955 break;
7956 default:
7957 DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
7958 q_u->switch_value));
7959 return False;
7960 }
7961
7962 return True;
7963 }
7964
7965 /*******************************************************************
7966 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7967 ********************************************************************/
7968
7969 void init_samr_r_set_domain_info(SAMR_R_SET_DOMAIN_INFO * r_u, NTSTATUS status)
7970 {
7971 DEBUG(5, ("init_samr_r_set_domain_info\n"));
7972
7973 r_u->status = status; /* return status */
7974 }
7975
7976 /*******************************************************************
7977 reads or writes a structure.
7978 ********************************************************************/
7979
7980 BOOL samr_io_r_set_domain_info(const char *desc, SAMR_R_SET_DOMAIN_INFO * r_u,
7981 prs_struct *ps, int depth)
7982 {
7983 if (r_u == NULL)
7984 return False;
7985
7986 prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
7987 depth++;
7988
7989 if(!prs_align(ps))
7990 return False;
7991
7992 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7993 return False;
7994
7995 return True;
7996 }