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