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.
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.
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.
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.
30 #define DBGC_CLASS DBGC_RPC_PARSE
32 /*******************************************************************
33 inits a SAMR_Q_CLOSE_HND structure.
34 ********************************************************************/
36 void init_samr_q_close_hnd(SAMR_Q_CLOSE_HND * q_c, POLICY_HND *hnd)
38 DEBUG(5, ("init_samr_q_close_hnd\n"));
43 /*******************************************************************
44 reads or writes a structure.
45 ********************************************************************/
47 BOOL samr_io_q_close_hnd(const char *desc, SAMR_Q_CLOSE_HND * q_u,
48 prs_struct *ps, int depth)
53 prs_debug(ps, depth, desc, "samr_io_q_close_hnd");
59 return smb_io_pol_hnd("pol", &q_u->pol, ps, depth);
62 /*******************************************************************
63 reads or writes a structure.
64 ********************************************************************/
66 BOOL samr_io_r_close_hnd(const char *desc, SAMR_R_CLOSE_HND * r_u,
67 prs_struct *ps, int depth)
72 prs_debug(ps, depth, desc, "samr_io_r_close_hnd");
78 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
81 if(!prs_ntstatus("status", ps, depth, &r_u->status))
87 /*******************************************************************
88 inits a SAMR_Q_LOOKUP_DOMAIN structure.
89 ********************************************************************/
91 void init_samr_q_lookup_domain(SAMR_Q_LOOKUP_DOMAIN * q_u,
92 POLICY_HND *pol, char *dom_name)
94 DEBUG(5, ("init_samr_q_lookup_domain\n"));
96 q_u->connect_pol = *pol;
98 init_unistr2(&q_u->uni_domain, dom_name, UNI_FLAGS_NONE);
99 init_uni_hdr(&q_u->hdr_domain, &q_u->uni_domain);
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)
111 prs_debug(ps, depth, desc, "samr_io_q_lookup_domain");
117 if(!smb_io_pol_hnd("connect_pol", &q_u->connect_pol, ps, depth))
120 if(!smb_io_unihdr("hdr_domain", &q_u->hdr_domain, ps, depth))
123 if(!smb_io_unistr2("uni_domain", &q_u->uni_domain, q_u->hdr_domain.buffer, ps, depth))
129 /*******************************************************************
130 inits a SAMR_R_LOOKUP_DOMAIN structure.
131 ********************************************************************/
133 void init_samr_r_lookup_domain(SAMR_R_LOOKUP_DOMAIN * r_u,
134 DOM_SID *dom_sid, NTSTATUS status)
136 DEBUG(5, ("init_samr_r_lookup_domain\n"));
138 r_u->status = status;
140 if (NT_STATUS_IS_OK(status)) {
142 init_dom_sid2(&r_u->dom_sid, dom_sid);
146 /*******************************************************************
147 reads or writes a structure.
148 ********************************************************************/
150 BOOL samr_io_r_lookup_domain(const char *desc, SAMR_R_LOOKUP_DOMAIN * r_u,
151 prs_struct *ps, int depth)
156 prs_debug(ps, depth, desc, "samr_io_r_lookup_domain");
162 if(!prs_uint32("ptr", ps, depth, &r_u->ptr_sid))
165 if (r_u->ptr_sid != 0) {
166 if(!smb_io_dom_sid2("sid", &r_u->dom_sid, ps, depth))
172 if(!prs_ntstatus("status", ps, depth, &r_u->status))
178 /*******************************************************************
179 reads or writes a structure.
180 ********************************************************************/
182 void init_samr_q_remove_sid_foreign_domain(SAMR_Q_REMOVE_SID_FOREIGN_DOMAIN * q_u, POLICY_HND *dom_pol, DOM_SID *sid)
184 DEBUG(5, ("samr_init_samr_q_remove_sid_foreign_domain\n"));
186 q_u->dom_pol = *dom_pol;
187 init_dom_sid2(&q_u->sid, sid);
190 /*******************************************************************
191 reads or writes a structure.
192 ********************************************************************/
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)
200 prs_debug(ps, depth, desc, "samr_io_q_remove_sid_foreign_domain");
206 if(!smb_io_pol_hnd("domain_pol", &q_u->dom_pol, ps, depth))
209 if(!smb_io_dom_sid2("sid", &q_u->sid, ps, depth))
218 /*******************************************************************
219 reads or writes a structure.
220 ********************************************************************/
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)
228 prs_debug(ps, depth, desc, "samr_io_r_remove_sid_foreign_domain");
234 if(!prs_ntstatus("status", ps, depth, &r_u->status))
240 /*******************************************************************
241 reads or writes a structure.
242 ********************************************************************/
244 void init_samr_q_open_domain(SAMR_Q_OPEN_DOMAIN * q_u,
245 POLICY_HND *pol, uint32 flags,
248 DEBUG(5, ("samr_init_samr_q_open_domain\n"));
252 init_dom_sid2(&q_u->dom_sid, sid);
255 /*******************************************************************
256 reads or writes a structure.
257 ********************************************************************/
259 BOOL samr_io_q_open_domain(const char *desc, SAMR_Q_OPEN_DOMAIN * q_u,
260 prs_struct *ps, int depth)
265 prs_debug(ps, depth, desc, "samr_io_q_open_domain");
271 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
274 if(!prs_uint32("flags", ps, depth, &q_u->flags))
277 if(!smb_io_dom_sid2("sid", &q_u->dom_sid, ps, depth))
283 /*******************************************************************
284 reads or writes a structure.
285 ********************************************************************/
287 BOOL samr_io_r_open_domain(const char *desc, SAMR_R_OPEN_DOMAIN * r_u,
288 prs_struct *ps, int depth)
293 prs_debug(ps, depth, desc, "samr_io_r_open_domain");
299 if(!smb_io_pol_hnd("domain_pol", &r_u->domain_pol, ps, depth))
302 if(!prs_ntstatus("status", ps, depth, &r_u->status))
308 /*******************************************************************
309 reads or writes a structure.
310 ********************************************************************/
312 void init_samr_q_get_usrdom_pwinfo(SAMR_Q_GET_USRDOM_PWINFO * q_u,
313 POLICY_HND *user_pol)
315 DEBUG(5, ("samr_init_samr_q_get_usrdom_pwinfo\n"));
317 q_u->user_pol = *user_pol;
320 /*******************************************************************
321 reads or writes a structure.
322 ********************************************************************/
324 BOOL samr_io_q_get_usrdom_pwinfo(const char *desc, SAMR_Q_GET_USRDOM_PWINFO * q_u,
325 prs_struct *ps, int depth)
330 prs_debug(ps, depth, desc, "samr_io_q_get_usrdom_pwinfo");
336 return smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth);
339 /*******************************************************************
341 ********************************************************************/
343 void init_samr_r_get_usrdom_pwinfo(SAMR_R_GET_USRDOM_PWINFO *r_u, NTSTATUS status)
345 DEBUG(5, ("init_samr_r_get_usrdom_pwinfo\n"));
347 r_u->min_pwd_length = 0x0000;
351 * r_u->unknown_1 = 0x0015;
354 r_u->unknown_1 = 0x01D1;
355 r_u->unknown_1 = 0x0015;
357 r_u->password_properties = 0x00000000;
359 r_u->status = status;
362 /*******************************************************************
363 reads or writes a structure.
364 ********************************************************************/
366 BOOL samr_io_r_get_usrdom_pwinfo(const char *desc, SAMR_R_GET_USRDOM_PWINFO * r_u,
367 prs_struct *ps, int depth)
372 prs_debug(ps, depth, desc, "samr_io_r_get_usrdom_pwinfo");
378 if(!prs_uint16("min_pwd_length", ps, depth, &r_u->min_pwd_length))
380 if(!prs_uint16("unknown_1", ps, depth, &r_u->unknown_1))
382 if(!prs_uint32("password_properties", ps, depth, &r_u->password_properties))
385 if(!prs_ntstatus("status ", ps, depth, &r_u->status))
392 /*******************************************************************
393 reads or writes a structure.
394 ********************************************************************/
396 BOOL samr_io_q_set_sec_obj(const char *desc, SAMR_Q_SET_SEC_OBJ * q_u,
397 prs_struct *ps, int depth)
402 prs_debug(ps, depth, desc, "samr_io_q_set_sec_obj");
408 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
411 if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
414 if(!sec_io_desc_buf("sec_desc", &q_u->buf, ps, depth))
421 /*******************************************************************
422 reads or writes a structure.
423 ********************************************************************/
425 void init_samr_q_query_sec_obj(SAMR_Q_QUERY_SEC_OBJ * q_u,
426 POLICY_HND *user_pol, uint32 sec_info)
428 DEBUG(5, ("samr_init_samr_q_query_sec_obj\n"));
430 q_u->user_pol = *user_pol;
431 q_u->sec_info = sec_info;
435 /*******************************************************************
436 reads or writes a structure.
437 ********************************************************************/
439 BOOL samr_io_q_query_sec_obj(const char *desc, SAMR_Q_QUERY_SEC_OBJ * q_u,
440 prs_struct *ps, int depth)
445 prs_debug(ps, depth, desc, "samr_io_q_query_sec_obj");
451 if(!smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth))
454 if(!prs_uint32("sec_info", ps, depth, &q_u->sec_info))
460 /*******************************************************************
461 reads or writes a structure.
462 ********************************************************************/
464 void init_samr_q_query_domain_info(SAMR_Q_QUERY_DOMAIN_INFO * q_u,
465 POLICY_HND *domain_pol, uint16 switch_value)
467 DEBUG(5, ("samr_init_samr_q_query_domain_info\n"));
469 q_u->domain_pol = *domain_pol;
470 q_u->switch_value = switch_value;
473 /*******************************************************************
474 reads or writes a structure.
475 ********************************************************************/
477 BOOL samr_io_q_query_domain_info(const char *desc, SAMR_Q_QUERY_DOMAIN_INFO * q_u,
478 prs_struct *ps, int depth)
483 prs_debug(ps, depth, desc, "samr_io_q_query_domain_info");
489 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
492 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
498 /*******************************************************************
500 ********************************************************************/
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)
505 u_1->min_length_password = min_pass_len;
506 u_1->password_history = pass_hist;
508 if (lp_check_password_script() && *lp_check_password_script()) {
509 password_properties |= DOMAIN_PASSWORD_COMPLEX;
511 u_1->password_properties = password_properties;
513 /* password never expire */
514 u_1->expire = nt_expire;
516 /* can change the password now */
517 u_1->min_passwordage = nt_min_age;
521 /*******************************************************************
522 reads or writes a structure.
523 ********************************************************************/
525 static BOOL sam_io_unk_info1(const char *desc, SAM_UNK_INFO_1 * u_1,
526 prs_struct *ps, int depth)
531 prs_debug(ps, depth, desc, "sam_io_unk_info1");
534 if(!prs_uint16("min_length_password", ps, depth, &u_1->min_length_password))
536 if(!prs_uint16("password_history", ps, depth, &u_1->password_history))
538 if(!prs_uint32("password_properties", ps, depth, &u_1->password_properties))
540 if(!smb_io_time("expire", &u_1->expire, ps, depth))
542 if(!smb_io_time("min_passwordage", &u_1->min_passwordage, ps, depth))
548 /*******************************************************************
550 ********************************************************************/
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)
556 u_2->logout = nt_logout;
558 u_2->seq_num = seq_num;
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;
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);
576 /*******************************************************************
577 reads or writes a structure.
578 ********************************************************************/
580 static BOOL sam_io_unk_info2(const char *desc, SAM_UNK_INFO_2 * u_2,
581 prs_struct *ps, int depth)
586 prs_debug(ps, depth, desc, "sam_io_unk_info2");
589 if(!smb_io_time("logout", &u_2->logout, ps, depth))
591 if(!smb_io_unihdr("hdr_comment", &u_2->hdr_comment, ps, depth))
593 if(!smb_io_unihdr("hdr_domain", &u_2->hdr_domain, ps, depth))
595 if(!smb_io_unihdr("hdr_server", &u_2->hdr_server, ps, depth))
598 /* put all the data in here, at the moment, including what the above
599 pointer is referring to
602 if(!prs_uint64("seq_num ", ps, depth, &u_2->seq_num))
605 if(!prs_uint32("unknown_4 ", ps, depth, &u_2->unknown_4)) /* 0x0000 0001 */
607 if(!prs_uint32("server_role ", ps, depth, &u_2->server_role))
609 if(!prs_uint32("unknown_6 ", ps, depth, &u_2->unknown_6)) /* 0x0000 0001 */
611 if(!prs_uint32("num_domain_usrs ", ps, depth, &u_2->num_domain_usrs))
613 if(!prs_uint32("num_domain_grps", ps, depth, &u_2->num_domain_grps))
615 if(!prs_uint32("num_local_grps", ps, depth, &u_2->num_local_grps))
618 if(!smb_io_unistr2("uni_comment", &u_2->uni_comment, u_2->hdr_comment.buffer, ps, depth))
620 if(!smb_io_unistr2("uni_domain", &u_2->uni_domain, u_2->hdr_domain.buffer, ps, depth))
622 if(!smb_io_unistr2("uni_server", &u_2->uni_server, u_2->hdr_server.buffer, ps, depth))
628 /*******************************************************************
630 ********************************************************************/
632 void init_unk_info3(SAM_UNK_INFO_3 *u_3, NTTIME nt_logout)
634 u_3->logout = nt_logout;
637 /*******************************************************************
638 reads or writes a structure.
639 ********************************************************************/
641 static BOOL sam_io_unk_info3(const char *desc, SAM_UNK_INFO_3 * u_3,
642 prs_struct *ps, int depth)
647 prs_debug(ps, depth, desc, "sam_io_unk_info3");
650 if(!smb_io_time("logout", &u_3->logout, ps, depth))
656 /*******************************************************************
658 ********************************************************************/
660 void init_unk_info4(SAM_UNK_INFO_4 * u_4,const char *comment)
662 init_unistr2(&u_4->uni_comment, comment, UNI_FLAGS_NONE);
663 init_uni_hdr(&u_4->hdr_comment, &u_4->uni_comment);
666 /*******************************************************************
667 reads or writes a structure.
668 ********************************************************************/
670 static BOOL sam_io_unk_info4(const char *desc, SAM_UNK_INFO_4 * u_4,
671 prs_struct *ps, int depth)
676 prs_debug(ps, depth, desc, "sam_io_unk_info4");
679 if(!smb_io_unihdr("hdr_comment", &u_4->hdr_comment, ps, depth))
682 if(!smb_io_unistr2("uni_comment", &u_4->uni_comment, u_4->hdr_comment.buffer, ps, depth))
688 /*******************************************************************
690 ********************************************************************/
692 void init_unk_info5(SAM_UNK_INFO_5 * u_5,const char *domain)
694 init_unistr2(&u_5->uni_domain, domain, UNI_FLAGS_NONE);
695 init_uni_hdr(&u_5->hdr_domain, &u_5->uni_domain);
698 /*******************************************************************
699 reads or writes a structure.
700 ********************************************************************/
702 static BOOL sam_io_unk_info5(const char *desc, SAM_UNK_INFO_5 * u_5,
703 prs_struct *ps, int depth)
708 prs_debug(ps, depth, desc, "sam_io_unk_info5");
711 if(!smb_io_unihdr("hdr_domain", &u_5->hdr_domain, ps, depth))
714 if(!smb_io_unistr2("uni_domain", &u_5->uni_domain, u_5->hdr_domain.buffer, ps, depth))
720 /*******************************************************************
722 ********************************************************************/
724 void init_unk_info6(SAM_UNK_INFO_6 * u_6, const char *server)
726 init_unistr2(&u_6->uni_server, server, UNI_FLAGS_NONE);
727 init_uni_hdr(&u_6->hdr_server, &u_6->uni_server);
730 /*******************************************************************
731 reads or writes a structure.
732 ********************************************************************/
734 static BOOL sam_io_unk_info6(const char *desc, SAM_UNK_INFO_6 * u_6,
735 prs_struct *ps, int depth)
740 prs_debug(ps, depth, desc, "sam_io_unk_info6");
743 if(!smb_io_unihdr("hdr_server", &u_6->hdr_server, ps, depth))
746 if(!smb_io_unistr2("uni_server", &u_6->uni_server, u_6->hdr_server.buffer, ps, depth))
752 /*******************************************************************
754 ********************************************************************/
756 void init_unk_info7(SAM_UNK_INFO_7 * u_7, uint32 server_role)
758 u_7->server_role = server_role;
761 /*******************************************************************
762 reads or writes a structure.
763 ********************************************************************/
765 static BOOL sam_io_unk_info7(const char *desc, SAM_UNK_INFO_7 * u_7,
766 prs_struct *ps, int depth)
771 prs_debug(ps, depth, desc, "sam_io_unk_info7");
774 if(!prs_uint16("server_role", ps, depth, &u_7->server_role))
780 /*******************************************************************
782 ********************************************************************/
784 void init_unk_info8(SAM_UNK_INFO_8 * u_8, uint32 seq_num)
786 unix_to_nt_time(&u_8->domain_create_time, 0);
787 u_8->seq_num = seq_num;
790 /*******************************************************************
791 reads or writes a structure.
792 ********************************************************************/
794 static BOOL sam_io_unk_info8(const char *desc, SAM_UNK_INFO_8 * u_8,
795 prs_struct *ps, int depth)
800 prs_debug(ps, depth, desc, "sam_io_unk_info8");
803 if (!prs_uint64("seq_num", ps, depth, &u_8->seq_num))
806 if(!smb_io_time("domain_create_time", &u_8->domain_create_time, ps, depth))
812 /*******************************************************************
814 ********************************************************************/
816 void init_unk_info9(SAM_UNK_INFO_9 * u_9, uint32 unknown)
818 u_9->unknown = unknown;
821 /*******************************************************************
822 reads or writes a structure.
823 ********************************************************************/
825 static BOOL sam_io_unk_info9(const char *desc, SAM_UNK_INFO_9 * u_9,
826 prs_struct *ps, int depth)
831 prs_debug(ps, depth, desc, "sam_io_unk_info9");
834 if (!prs_uint32("unknown", ps, depth, &u_9->unknown))
840 /*******************************************************************
842 ********************************************************************/
844 void init_unk_info12(SAM_UNK_INFO_12 * u_12, NTTIME nt_lock_duration, NTTIME nt_reset_time, uint16 lockout)
846 u_12->duration = nt_lock_duration;
847 u_12->reset_count = nt_reset_time;
849 u_12->bad_attempt_lockout = lockout;
852 /*******************************************************************
853 reads or writes a structure.
854 ********************************************************************/
856 static BOOL sam_io_unk_info12(const char *desc, SAM_UNK_INFO_12 * u_12,
857 prs_struct *ps, int depth)
862 prs_debug(ps, depth, desc, "sam_io_unk_info12");
865 if(!smb_io_time("duration", &u_12->duration, ps, depth))
867 if(!smb_io_time("reset_count", &u_12->reset_count, ps, depth))
869 if(!prs_uint16("bad_attempt_lockout", ps, depth, &u_12->bad_attempt_lockout))
875 /*******************************************************************
877 ********************************************************************/
879 void init_unk_info13(SAM_UNK_INFO_13 * u_13, uint32 seq_num)
881 unix_to_nt_time(&u_13->domain_create_time, 0);
882 u_13->seq_num = seq_num;
887 /*******************************************************************
888 reads or writes a structure.
889 ********************************************************************/
891 static BOOL sam_io_unk_info13(const char *desc, SAM_UNK_INFO_13 * u_13,
892 prs_struct *ps, int depth)
897 prs_debug(ps, depth, desc, "sam_io_unk_info13");
900 if (!prs_uint64("seq_num", ps, depth, &u_13->seq_num))
903 if(!smb_io_time("domain_create_time", &u_13->domain_create_time, ps, depth))
906 if (!prs_uint32("unknown1", ps, depth, &u_13->unknown1))
908 if (!prs_uint32("unknown2", ps, depth, &u_13->unknown2))
914 /*******************************************************************
915 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
916 ********************************************************************/
918 void init_samr_r_query_domain_info(SAMR_R_QUERY_DOMAIN_INFO * r_u,
919 uint16 switch_value, SAM_UNK_CTR * ctr,
922 DEBUG(5, ("init_samr_r_query_domain_info\n"));
925 r_u->switch_value = 0;
926 r_u->status = status; /* return status */
928 if (NT_STATUS_IS_OK(status)) {
929 r_u->switch_value = switch_value;
935 /*******************************************************************
936 reads or writes a structure.
937 ********************************************************************/
939 BOOL samr_io_r_query_domain_info(const char *desc, SAMR_R_QUERY_DOMAIN_INFO * r_u,
940 prs_struct *ps, int depth)
945 prs_debug(ps, depth, desc, "samr_io_r_query_domain_info");
951 if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
954 if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
955 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
960 switch (r_u->switch_value) {
962 if(!sam_io_unk_info13("unk_inf13", &r_u->ctr->info.inf13, ps, depth))
966 if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
970 if(!sam_io_unk_info9("unk_inf9",&r_u->ctr->info.inf9, ps,depth))
974 if(!sam_io_unk_info8("unk_inf8",&r_u->ctr->info.inf8, ps,depth))
978 if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
982 if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
986 if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
990 if(!sam_io_unk_info4("unk_inf4",&r_u->ctr->info.inf4, ps,depth))
994 if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
998 if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
1002 if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
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;
1016 if(!prs_ntstatus("status", ps, depth, &r_u->status))
1022 /*******************************************************************
1023 reads or writes a structure.
1024 ********************************************************************/
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)
1029 DEBUG(5, ("samr_init_samr_q_set_sec_obj\n"));
1032 q_u->sec_info = sec_info;
1037 /*******************************************************************
1038 reads or writes a SAMR_R_SET_SEC_OBJ structure.
1039 ********************************************************************/
1041 BOOL samr_io_r_set_sec_obj(const char *desc, SAMR_R_SET_SEC_OBJ * r_u,
1042 prs_struct *ps, int depth)
1047 prs_debug(ps, depth, desc, "samr_io_r_set_sec_obj");
1053 if(!prs_ntstatus("status", ps, depth, &r_u->status))
1059 /*******************************************************************
1060 reads or writes a SAMR_R_QUERY_SEC_OBJ structure.
1061 ********************************************************************/
1063 BOOL samr_io_r_query_sec_obj(const char *desc, SAMR_R_QUERY_SEC_OBJ * r_u,
1064 prs_struct *ps, int depth)
1069 prs_debug(ps, depth, desc, "samr_io_r_query_sec_obj");
1075 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
1077 if (r_u->ptr != 0) {
1078 if(!sec_io_desc_buf("sec", &r_u->buf, ps, depth))
1082 if(!prs_ntstatus("status", ps, depth, &r_u->status))
1088 /*******************************************************************
1089 reads or writes a SAM_STR1 structure.
1090 ********************************************************************/
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)
1099 prs_debug(ps, depth, desc, "sam_io_sam_str1");
1104 if (!smb_io_unistr2("name", &sam->uni_acct_name, acct_buf, ps, depth))
1107 if (!smb_io_unistr2("desc", &sam->uni_acct_desc, desc_buf, ps, depth))
1110 if (!smb_io_unistr2("full", &sam->uni_full_name, name_buf, ps, depth))
1116 /*******************************************************************
1117 inits a SAM_ENTRY1 structure.
1118 ********************************************************************/
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,
1125 DEBUG(5, ("init_sam_entry1\n"));
1129 sam->user_idx = user_idx;
1130 sam->rid_user = rid_user;
1131 sam->acb_info = acb_info;
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);
1138 /*******************************************************************
1139 reads or writes a SAM_ENTRY1 structure.
1140 ********************************************************************/
1142 static BOOL sam_io_sam_entry1(const char *desc, SAM_ENTRY1 * sam,
1143 prs_struct *ps, int depth)
1148 prs_debug(ps, depth, desc, "sam_io_sam_entry1");
1154 if(!prs_uint32("user_idx ", ps, depth, &sam->user_idx))
1157 if(!prs_uint32("rid_user ", ps, depth, &sam->rid_user))
1159 if(!prs_uint32("acb_info ", ps, depth, &sam->acb_info))
1162 if (!smb_io_unihdr("hdr_acct_name", &sam->hdr_acct_name, ps, depth))
1164 if (!smb_io_unihdr("hdr_user_desc", &sam->hdr_user_desc, ps, depth))
1166 if (!smb_io_unihdr("hdr_user_name", &sam->hdr_user_name, ps, depth))
1172 /*******************************************************************
1173 reads or writes a SAM_STR2 structure.
1174 ********************************************************************/
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)
1182 prs_debug(ps, depth, desc, "sam_io_sam_str2");
1188 if(!smb_io_unistr2("uni_srv_name", &sam->uni_srv_name, acct_buf, ps, depth)) /* account name unicode string */
1190 if(!smb_io_unistr2("uni_srv_desc", &sam->uni_srv_desc, desc_buf, ps, depth)) /* account desc unicode string */
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)
1203 DEBUG(5, ("init_sam_entry2\n"));
1205 sam->user_idx = user_idx;
1206 sam->rid_user = rid_user;
1207 sam->acb_info = acb_info;
1209 init_uni_hdr(&sam->hdr_srv_name, sam_name);
1210 init_uni_hdr(&sam->hdr_srv_desc, sam_desc);
1213 /*******************************************************************
1214 reads or writes a SAM_ENTRY2 structure.
1215 ********************************************************************/
1217 static BOOL sam_io_sam_entry2(const char *desc, SAM_ENTRY2 * sam,
1218 prs_struct *ps, int depth)
1223 prs_debug(ps, depth, desc, "sam_io_sam_entry2");
1229 if(!prs_uint32("user_idx ", ps, depth, &sam->user_idx))
1232 if(!prs_uint32("rid_user ", ps, depth, &sam->rid_user))
1234 if(!prs_uint32("acb_info ", ps, depth, &sam->acb_info))
1237 if(!smb_io_unihdr("unihdr", &sam->hdr_srv_name, ps, depth)) /* account name unicode string header */
1239 if(!smb_io_unihdr("unihdr", &sam->hdr_srv_desc, ps, depth)) /* account name unicode string header */
1245 /*******************************************************************
1246 reads or writes a SAM_STR3 structure.
1247 ********************************************************************/
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)
1255 prs_debug(ps, depth, desc, "sam_io_sam_str3");
1261 if(!smb_io_unistr2("uni_grp_name", &sam->uni_grp_name, acct_buf, ps, depth)) /* account name unicode string */
1263 if(!smb_io_unistr2("uni_grp_desc", &sam->uni_grp_desc, desc_buf, ps, depth)) /* account desc unicode string */
1269 /*******************************************************************
1270 inits a SAM_ENTRY3 structure.
1271 ********************************************************************/
1273 static void init_sam_entry3(SAM_ENTRY3 * sam, uint32 grp_idx,
1274 UNISTR2 *grp_name, UNISTR2 *grp_desc,
1277 DEBUG(5, ("init_sam_entry3\n"));
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 */
1283 init_uni_hdr(&sam->hdr_grp_name, grp_name);
1284 init_uni_hdr(&sam->hdr_grp_desc, grp_desc);
1287 /*******************************************************************
1288 reads or writes a SAM_ENTRY3 structure.
1289 ********************************************************************/
1291 static BOOL sam_io_sam_entry3(const char *desc, SAM_ENTRY3 * sam,
1292 prs_struct *ps, int depth)
1297 prs_debug(ps, depth, desc, "sam_io_sam_entry3");
1303 if(!prs_uint32("grp_idx", ps, depth, &sam->grp_idx))
1306 if(!prs_uint32("rid_grp", ps, depth, &sam->rid_grp))
1308 if(!prs_uint32("attr ", ps, depth, &sam->attr))
1311 if(!smb_io_unihdr("unihdr", &sam->hdr_grp_name, ps, depth)) /* account name unicode string header */
1313 if(!smb_io_unihdr("unihdr", &sam->hdr_grp_desc, ps, depth)) /* account name unicode string header */
1319 /*******************************************************************
1320 inits a SAM_ENTRY4 structure.
1321 ********************************************************************/
1323 static void init_sam_entry4(SAM_ENTRY4 * sam, uint32 user_idx,
1324 uint32 len_acct_name)
1326 DEBUG(5, ("init_sam_entry4\n"));
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);
1332 /*******************************************************************
1333 reads or writes a SAM_ENTRY4 structure.
1334 ********************************************************************/
1336 static BOOL sam_io_sam_entry4(const char *desc, SAM_ENTRY4 * sam,
1337 prs_struct *ps, int depth)
1342 prs_debug(ps, depth, desc, "sam_io_sam_entry4");
1348 if(!prs_uint32("user_idx", ps, depth, &sam->user_idx))
1350 if(!smb_io_strhdr("strhdr", &sam->hdr_acct_name, ps, depth))
1356 /*******************************************************************
1357 inits a SAM_ENTRY5 structure.
1358 ********************************************************************/
1360 static void init_sam_entry5(SAM_ENTRY5 * sam, uint32 grp_idx,
1361 uint32 len_grp_name)
1363 DEBUG(5, ("init_sam_entry5\n"));
1365 sam->grp_idx = grp_idx;
1366 init_str_hdr(&sam->hdr_grp_name, len_grp_name, len_grp_name,
1370 /*******************************************************************
1371 reads or writes a SAM_ENTRY5 structure.
1372 ********************************************************************/
1374 static BOOL sam_io_sam_entry5(const char *desc, SAM_ENTRY5 * sam,
1375 prs_struct *ps, int depth)
1380 prs_debug(ps, depth, desc, "sam_io_sam_entry5");
1386 if(!prs_uint32("grp_idx", ps, depth, &sam->grp_idx))
1388 if(!smb_io_strhdr("strhdr", &sam->hdr_grp_name, ps, depth))
1394 /*******************************************************************
1395 inits a SAM_ENTRY structure.
1396 ********************************************************************/
1398 void init_sam_entry(SAM_ENTRY *sam, UNISTR2 *uni2, uint32 rid)
1400 DEBUG(10, ("init_sam_entry: %d\n", rid));
1403 init_uni_hdr(&sam->hdr_name, uni2);
1406 /*******************************************************************
1407 reads or writes a SAM_ENTRY structure.
1408 ********************************************************************/
1410 static BOOL sam_io_sam_entry(const char *desc, SAM_ENTRY * sam,
1411 prs_struct *ps, int depth)
1416 prs_debug(ps, depth, desc, "sam_io_sam_entry");
1421 if(!prs_uint32("rid", ps, depth, &sam->rid))
1423 if(!smb_io_unihdr("unihdr", &sam->hdr_name, ps, depth)) /* account name unicode string header */
1429 /*******************************************************************
1430 inits a SAMR_Q_ENUM_DOM_USERS structure.
1431 ********************************************************************/
1433 void init_samr_q_enum_dom_users(SAMR_Q_ENUM_DOM_USERS * q_e, POLICY_HND *pol,
1435 uint32 acb_mask, uint32 size)
1437 DEBUG(5, ("init_samr_q_enum_dom_users\n"));
1441 q_e->start_idx = start_idx; /* zero indicates lots */
1442 q_e->acb_mask = acb_mask;
1443 q_e->max_size = size;
1446 /*******************************************************************
1447 reads or writes a structure.
1448 ********************************************************************/
1450 BOOL samr_io_q_enum_dom_users(const char *desc, SAMR_Q_ENUM_DOM_USERS * q_e,
1451 prs_struct *ps, int depth)
1456 prs_debug(ps, depth, desc, "samr_io_q_enum_dom_users");
1462 if(!smb_io_pol_hnd("domain_pol", &q_e->pol, ps, depth))
1465 if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
1467 if(!prs_uint32("acb_mask ", ps, depth, &q_e->acb_mask))
1470 if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
1477 /*******************************************************************
1478 inits a SAMR_R_ENUM_DOM_USERS structure.
1479 ********************************************************************/
1481 void init_samr_r_enum_dom_users(SAMR_R_ENUM_DOM_USERS * r_u,
1482 uint32 next_idx, uint32 num_sam_entries)
1484 DEBUG(5, ("init_samr_r_enum_dom_users\n"));
1486 r_u->next_idx = next_idx;
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;
1494 r_u->num_entries4 = num_sam_entries;
1496 r_u->ptr_entries1 = 0;
1497 r_u->num_entries2 = num_sam_entries;
1498 r_u->ptr_entries2 = 1;
1502 /*******************************************************************
1503 reads or writes a structure.
1504 ********************************************************************/
1506 BOOL samr_io_r_enum_dom_users(const char *desc, SAMR_R_ENUM_DOM_USERS * r_u,
1507 prs_struct *ps, int depth)
1514 prs_debug(ps, depth, desc, "samr_io_r_enum_dom_users");
1520 if(!prs_uint32("next_idx ", ps, depth, &r_u->next_idx))
1522 if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
1525 if (r_u->ptr_entries1 != 0) {
1526 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
1528 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
1530 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
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);
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;
1545 for (i = 0; i < r_u->num_entries2; i++) {
1546 if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
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))
1560 if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
1562 if(!prs_ntstatus("status", ps, depth, &r_u->status))
1568 /*******************************************************************
1569 inits a SAMR_Q_QUERY_DISPINFO structure.
1570 ********************************************************************/
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)
1576 DEBUG(5, ("init_samr_q_query_dispinfo\n"));
1578 q_e->domain_pol = *pol;
1580 q_e->switch_level = switch_level;
1582 q_e->start_idx = start_idx;
1583 q_e->max_entries = max_entries;
1584 q_e->max_size = max_size;
1587 /*******************************************************************
1588 reads or writes a structure.
1589 ********************************************************************/
1591 BOOL samr_io_q_query_dispinfo(const char *desc, SAMR_Q_QUERY_DISPINFO * q_e,
1592 prs_struct *ps, int depth)
1597 prs_debug(ps, depth, desc, "samr_io_q_query_dispinfo");
1603 if(!smb_io_pol_hnd("domain_pol", &q_e->domain_pol, ps, depth))
1606 if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
1611 if(!prs_uint32("start_idx ", ps, depth, &q_e->start_idx))
1613 if(!prs_uint32("max_entries ", ps, depth, &q_e->max_entries))
1615 if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
1621 /*******************************************************************
1622 inits a SAM_DISPINFO_1 structure.
1623 ********************************************************************/
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)
1631 DEBUG(10, ("init_sam_dispinfo_1: num_entries: %d\n", num_entries));
1634 return NT_STATUS_OK;
1636 *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_1, num_entries);
1638 return NT_STATUS_NO_MEMORY;
1640 (*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY1, num_entries);
1641 if ((*sam)->sam == NULL)
1642 return NT_STATUS_NO_MEMORY;
1644 (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR1, num_entries);
1645 if ((*sam)->str == NULL)
1646 return NT_STATUS_NO_MEMORY;
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);
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);
1663 return NT_STATUS_OK;
1666 /*******************************************************************
1667 reads or writes a structure.
1668 ********************************************************************/
1670 static BOOL sam_io_sam_dispinfo_1(const char *desc, SAM_DISPINFO_1 * sam,
1672 prs_struct *ps, int depth)
1676 prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_1");
1682 if (UNMARSHALLING(ps) && num_entries > 0) {
1684 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY1, num_entries)) == NULL) {
1685 DEBUG(0, ("out of memory allocating SAM_ENTRY1\n"));
1689 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR1, num_entries)) == NULL) {
1690 DEBUG(0, ("out of memory allocating SAM_STR1\n"));
1695 for (i = 0; i < num_entries; i++) {
1696 if(!sam_io_sam_entry1("", &sam->sam[i], ps, depth))
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))
1711 /*******************************************************************
1712 inits a SAM_DISPINFO_2 structure.
1713 ********************************************************************/
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)
1721 DEBUG(10, ("init_sam_dispinfo_2: num_entries: %d\n", num_entries));
1724 return NT_STATUS_OK;
1726 *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_2, num_entries);
1728 return NT_STATUS_NO_MEMORY;
1730 (*sam)->sam = TALLOC_ARRAY(ctx, SAM_ENTRY2, num_entries);
1731 if ((*sam)->sam == NULL)
1732 return NT_STATUS_NO_MEMORY;
1734 (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR2, num_entries);
1735 if ((*sam)->str == NULL)
1736 return NT_STATUS_NO_MEMORY;
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);
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);
1750 return NT_STATUS_OK;
1753 /*******************************************************************
1754 reads or writes a structure.
1755 ********************************************************************/
1757 static BOOL sam_io_sam_dispinfo_2(const char *desc, SAM_DISPINFO_2 * sam,
1759 prs_struct *ps, int depth)
1766 prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_2");
1772 if (UNMARSHALLING(ps) && num_entries > 0) {
1774 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY2, num_entries)) == NULL) {
1775 DEBUG(0, ("out of memory allocating SAM_ENTRY2\n"));
1779 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR2, num_entries)) == NULL) {
1780 DEBUG(0, ("out of memory allocating SAM_STR2\n"));
1785 for (i = 0; i < num_entries; i++) {
1786 if(!sam_io_sam_entry2("", &sam->sam[i], ps, depth))
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))
1800 /*******************************************************************
1801 inits a SAM_DISPINFO_3 structure.
1802 ********************************************************************/
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)
1810 DEBUG(5, ("init_sam_dispinfo_3: num_entries: %d\n", num_entries));
1813 return NT_STATUS_OK;
1815 *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_3, num_entries);
1817 return NT_STATUS_NO_MEMORY;
1819 if (!((*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY3, num_entries)))
1820 return NT_STATUS_NO_MEMORY;
1822 if (!((*sam)->str=TALLOC_ARRAY(ctx, SAM_STR3, num_entries)))
1823 return NT_STATUS_NO_MEMORY;
1825 for (i = 0; i < num_entries; i++) {
1826 DEBUG(11, ("init_sam_dispinfo_3: entry: %d\n",i));
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);
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,
1839 return NT_STATUS_OK;
1842 /*******************************************************************
1843 reads or writes a structure.
1844 ********************************************************************/
1846 static BOOL sam_io_sam_dispinfo_3(const char *desc, SAM_DISPINFO_3 * sam,
1848 prs_struct *ps, int depth)
1855 prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_3");
1861 if (UNMARSHALLING(ps) && num_entries > 0) {
1863 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY3, num_entries)) == NULL) {
1864 DEBUG(0, ("out of memory allocating SAM_ENTRY3\n"));
1868 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR3, num_entries)) == NULL) {
1869 DEBUG(0, ("out of memory allocating SAM_STR3\n"));
1874 for (i = 0; i < num_entries; i++) {
1875 if(!sam_io_sam_entry3("", &sam->sam[i], ps, depth))
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))
1889 /*******************************************************************
1890 inits a SAM_DISPINFO_4 structure.
1891 ********************************************************************/
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)
1899 DEBUG(5, ("init_sam_dispinfo_4: num_entries: %d\n", num_entries));
1902 return NT_STATUS_OK;
1904 *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_4, num_entries);
1906 return NT_STATUS_NO_MEMORY;
1908 (*sam)->sam = TALLOC_ARRAY(ctx, SAM_ENTRY4, num_entries);
1909 if ((*sam)->sam == NULL)
1910 return NT_STATUS_NO_MEMORY;
1912 (*sam)->str=TALLOC_ARRAY(ctx, SAM_STR4, num_entries);
1913 if ((*sam)->str == NULL)
1914 return NT_STATUS_NO_MEMORY;
1916 for (i = 0; i < num_entries; i++) {
1917 size_t len_sam_name = strlen(entries[i].account_name);
1919 DEBUG(11, ("init_sam_dispinfo_2: entry: %d\n",i));
1921 init_sam_entry4(&(*sam)->sam[i], start_idx + i + 1,
1924 init_string2(&(*sam)->str[i].acct_name,
1925 entries[i].account_name, len_sam_name+1,
1929 return NT_STATUS_OK;
1932 /*******************************************************************
1933 reads or writes a structure.
1934 ********************************************************************/
1936 static BOOL sam_io_sam_dispinfo_4(const char *desc, SAM_DISPINFO_4 * sam,
1938 prs_struct *ps, int depth)
1945 prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_4");
1951 if (UNMARSHALLING(ps) && num_entries > 0) {
1953 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY4, num_entries)) == NULL) {
1954 DEBUG(0, ("out of memory allocating SAM_ENTRY4\n"));
1958 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR4, num_entries)) == NULL) {
1959 DEBUG(0, ("out of memory allocating SAM_STR4\n"));
1964 for (i = 0; i < num_entries; i++) {
1965 if(!sam_io_sam_entry4("", &sam->sam[i], ps, depth))
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))
1978 /*******************************************************************
1979 inits a SAM_DISPINFO_5 structure.
1980 ********************************************************************/
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)
1986 uint32 len_sam_name;
1989 DEBUG(5, ("init_sam_dispinfo_5: num_entries: %d\n", num_entries));
1992 return NT_STATUS_OK;
1994 *sam = TALLOC_ZERO_ARRAY(ctx, SAM_DISPINFO_5, num_entries);
1996 return NT_STATUS_NO_MEMORY;
1998 if (!((*sam)->sam=TALLOC_ARRAY(ctx, SAM_ENTRY5, num_entries)))
1999 return NT_STATUS_NO_MEMORY;
2001 if (!((*sam)->str=TALLOC_ARRAY(ctx, SAM_STR5, num_entries)))
2002 return NT_STATUS_NO_MEMORY;
2004 for (i = 0; i < num_entries; i++) {
2005 DEBUG(11, ("init_sam_dispinfo_5: entry: %d\n",i));
2007 len_sam_name = strlen(entries[i].account_name);
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);
2014 return NT_STATUS_OK;
2017 /*******************************************************************
2018 reads or writes a structure.
2019 ********************************************************************/
2021 static BOOL sam_io_sam_dispinfo_5(const char *desc, SAM_DISPINFO_5 * sam,
2023 prs_struct *ps, int depth)
2030 prs_debug(ps, depth, desc, "sam_io_sam_dispinfo_5");
2036 if (UNMARSHALLING(ps) && num_entries > 0) {
2038 if ((sam->sam = PRS_ALLOC_MEM(ps, SAM_ENTRY5, num_entries)) == NULL) {
2039 DEBUG(0, ("out of memory allocating SAM_ENTRY5\n"));
2043 if ((sam->str = PRS_ALLOC_MEM(ps, SAM_STR5, num_entries)) == NULL) {
2044 DEBUG(0, ("out of memory allocating SAM_STR5\n"));
2049 for (i = 0; i < num_entries; i++) {
2050 if(!sam_io_sam_entry5("", &sam->sam[i], ps, depth))
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))
2063 /*******************************************************************
2064 inits a SAMR_R_QUERY_DISPINFO structure.
2065 ********************************************************************/
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,
2072 DEBUG(5, ("init_samr_r_query_dispinfo: level %d\n", switch_level));
2074 r_u->total_size = total_size;
2076 r_u->data_size = data_size;
2078 r_u->switch_level = switch_level;
2079 r_u->num_entries = num_entries;
2082 r_u->ptr_entries = 0;
2084 r_u->ptr_entries = 1;
2086 r_u->num_entries2 = num_entries;
2089 r_u->status = status;
2092 /*******************************************************************
2093 reads or writes a structure.
2094 ********************************************************************/
2096 BOOL samr_io_r_query_dispinfo(const char *desc, SAMR_R_QUERY_DISPINFO * r_u,
2097 prs_struct *ps, int depth)
2102 prs_debug(ps, depth, desc, "samr_io_r_query_dispinfo");
2108 if(!prs_uint32("total_size ", ps, depth, &r_u->total_size))
2110 if(!prs_uint32("data_size ", ps, depth, &r_u->data_size))
2112 if(!prs_uint16("switch_level", ps, depth, &r_u->switch_level))
2117 if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
2119 if(!prs_uint32("ptr_entries ", ps, depth, &r_u->ptr_entries))
2122 if (r_u->ptr_entries==0) {
2125 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2131 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
2134 switch (r_u->switch_level) {
2136 if(!sam_io_sam_dispinfo_1("users", r_u->ctr->sam.info1,
2137 r_u->num_entries, ps, depth))
2141 if(!sam_io_sam_dispinfo_2("servers", r_u->ctr->sam.info2,
2142 r_u->num_entries, ps, depth))
2146 if(!sam_io_sam_dispinfo_3("groups", r_u->ctr->sam.info3,
2147 r_u->num_entries, ps, depth))
2151 if(!sam_io_sam_dispinfo_4("user list",
2152 r_u->ctr->sam.info4,
2153 r_u->num_entries, ps, depth))
2157 if(!sam_io_sam_dispinfo_5("group list",
2158 r_u->ctr->sam.info5,
2159 r_u->num_entries, ps, depth))
2163 DEBUG(0,("samr_io_r_query_dispinfo: unknown switch value\n"));
2169 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2175 /*******************************************************************
2176 inits a SAMR_Q_GET_DISPENUM_INDEX structure.
2177 ********************************************************************/
2179 void init_samr_q_get_dispenum_index(SAMR_Q_GET_DISPENUM_INDEX * q_e, POLICY_HND *pol,
2180 uint16 switch_level, const char *name)
2182 DEBUG(5, ("init_samr_q_get_dispenum_index\n"));
2184 q_e->domain_pol = *pol;
2186 q_e->switch_level = switch_level;
2188 init_lsa_string(&q_e->name, name);
2191 /*******************************************************************
2192 reads or writes a structure.
2193 ********************************************************************/
2195 BOOL samr_io_q_get_dispenum_index(const char *desc, SAMR_Q_GET_DISPENUM_INDEX * q_e,
2196 prs_struct *ps, int depth)
2201 prs_debug(ps, depth, desc, "samr_io_q_get_dispenum_index");
2207 if(!smb_io_pol_hnd("domain_pol", &q_e->domain_pol, ps, depth))
2210 if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
2213 if (!smb_io_lsa_string("name", &q_e->name, ps, depth))
2219 /*******************************************************************
2220 reads or writes a structure.
2221 ********************************************************************/
2223 BOOL samr_io_r_get_dispenum_index(const char *desc, SAMR_R_GET_DISPENUM_INDEX * r_u,
2224 prs_struct *ps, int depth)
2229 prs_debug(ps, depth, desc, "samr_io_r_get_dispenum_index");
2235 if(!prs_uint32("idx", ps, depth, &r_u->idx))
2238 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2245 /*******************************************************************
2246 inits a SAMR_Q_OPEN_GROUP structure.
2247 ********************************************************************/
2249 void init_samr_q_open_group(SAMR_Q_OPEN_GROUP * q_c,
2251 uint32 access_mask, uint32 rid)
2253 DEBUG(5, ("init_samr_q_open_group\n"));
2255 q_c->domain_pol = *hnd;
2256 q_c->access_mask = access_mask;
2257 q_c->rid_group = rid;
2260 /*******************************************************************
2261 reads or writes a structure.
2262 ********************************************************************/
2264 BOOL samr_io_q_open_group(const char *desc, SAMR_Q_OPEN_GROUP * q_u,
2265 prs_struct *ps, int depth)
2270 prs_debug(ps, depth, desc, "samr_io_q_open_group");
2276 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
2279 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
2281 if(!prs_uint32("rid_group", ps, depth, &q_u->rid_group))
2287 /*******************************************************************
2288 reads or writes a structure.
2289 ********************************************************************/
2291 BOOL samr_io_r_open_group(const char *desc, SAMR_R_OPEN_GROUP * r_u,
2292 prs_struct *ps, int depth)
2297 prs_debug(ps, depth, desc, "samr_io_r_open_group");
2303 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2306 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2312 /*******************************************************************
2313 inits a GROUP_INFO1 structure.
2314 ********************************************************************/
2316 void init_samr_group_info1(GROUP_INFO1 * gr1,
2317 char *acct_name, char *acct_desc,
2320 DEBUG(5, ("init_samr_group_info1\n"));
2322 gr1->group_attr = (SE_GROUP_MANDATORY|SE_GROUP_ENABLED_BY_DEFAULT); /* why not | SE_GROUP_ENABLED ? */
2323 gr1->num_members = num_members;
2325 init_unistr2(&gr1->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2326 init_uni_hdr(&gr1->hdr_acct_name, &gr1->uni_acct_name);
2327 init_unistr2(&gr1->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2328 init_uni_hdr(&gr1->hdr_acct_desc, &gr1->uni_acct_desc);
2331 /*******************************************************************
2332 reads or writes a structure.
2333 ********************************************************************/
2335 BOOL samr_io_group_info1(const char *desc, GROUP_INFO1 * gr1,
2336 prs_struct *ps, int depth)
2343 prs_debug(ps, depth, desc, "samr_io_group_info1");
2346 if(!prs_uint16("level", ps, depth, &dummy))
2352 if(!smb_io_unihdr("hdr_acct_name", &gr1->hdr_acct_name, ps, depth))
2355 if(!prs_uint32("group_attr", ps, depth, &gr1->group_attr))
2357 if(!prs_uint32("num_members", ps, depth, &gr1->num_members))
2360 if(!smb_io_unihdr("hdr_acct_desc", &gr1->hdr_acct_desc, ps, depth))
2363 if(!smb_io_unistr2("uni_acct_name", &gr1->uni_acct_name,
2364 gr1->hdr_acct_name.buffer, ps, depth))
2367 if(!smb_io_unistr2("uni_acct_desc", &gr1->uni_acct_desc,
2368 gr1->hdr_acct_desc.buffer, ps, depth))
2374 /*******************************************************************
2375 inits a GROUP_INFO2 structure.
2376 ********************************************************************/
2378 void init_samr_group_info2(GROUP_INFO2 * gr2, const char *acct_name)
2380 DEBUG(5, ("init_samr_group_info2\n"));
2383 init_unistr2(&gr2->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2384 init_uni_hdr(&gr2->hdr_acct_name, &gr2->uni_acct_name);
2387 /*******************************************************************
2388 reads or writes a structure.
2389 ********************************************************************/
2391 BOOL samr_io_group_info2(const char *desc, GROUP_INFO2 *gr2, prs_struct *ps, int depth)
2396 prs_debug(ps, depth, desc, "samr_io_group_info2");
2399 if(!prs_uint16("hdr_level", ps, depth, &gr2->level))
2402 if(!smb_io_unihdr("hdr_acct_name", &gr2->hdr_acct_name, ps, depth))
2404 if(!smb_io_unistr2("uni_acct_name", &gr2->uni_acct_name,
2405 gr2->hdr_acct_name.buffer, ps, depth))
2411 /*******************************************************************
2412 inits a GROUP_INFO3 structure.
2413 ********************************************************************/
2415 void init_samr_group_info3(GROUP_INFO3 *gr3)
2417 DEBUG(5, ("init_samr_group_info3\n"));
2419 gr3->group_attr = (SE_GROUP_MANDATORY|SE_GROUP_ENABLED_BY_DEFAULT); /* why not | SE_GROUP_ENABLED ? */
2422 /*******************************************************************
2423 reads or writes a structure.
2424 ********************************************************************/
2426 BOOL samr_io_group_info3(const char *desc, GROUP_INFO3 *gr3, prs_struct *ps, int depth)
2431 prs_debug(ps, depth, desc, "samr_io_group_info3");
2437 if(!prs_uint32("group_attr", ps, depth, &gr3->group_attr))
2443 /*******************************************************************
2444 inits a GROUP_INFO4 structure.
2445 ********************************************************************/
2447 void init_samr_group_info4(GROUP_INFO4 * gr4, const char *acct_desc)
2449 DEBUG(5, ("init_samr_group_info4\n"));
2452 init_unistr2(&gr4->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2453 init_uni_hdr(&gr4->hdr_acct_desc, &gr4->uni_acct_desc);
2456 /*******************************************************************
2457 reads or writes a structure.
2458 ********************************************************************/
2460 BOOL samr_io_group_info4(const char *desc, GROUP_INFO4 * gr4,
2461 prs_struct *ps, int depth)
2466 prs_debug(ps, depth, desc, "samr_io_group_info4");
2469 if(!prs_uint16("hdr_level", ps, depth, &gr4->level))
2471 if(!smb_io_unihdr("hdr_acct_desc", &gr4->hdr_acct_desc, ps, depth))
2473 if(!smb_io_unistr2("uni_acct_desc", &gr4->uni_acct_desc,
2474 gr4->hdr_acct_desc.buffer, ps, depth))
2480 /*******************************************************************
2481 inits a GROUP_INFO5 structure.
2482 ********************************************************************/
2484 void init_samr_group_info5(GROUP_INFO5 * gr5,
2485 char *acct_name, char *acct_desc,
2488 DEBUG(5, ("init_samr_group_info5\n"));
2490 gr5->group_attr = (SE_GROUP_MANDATORY|SE_GROUP_ENABLED_BY_DEFAULT); /* why not | SE_GROUP_ENABLED ? */
2491 gr5->num_members = num_members;
2493 init_unistr2(&gr5->uni_acct_name, acct_name, UNI_FLAGS_NONE);
2494 init_uni_hdr(&gr5->hdr_acct_name, &gr5->uni_acct_name);
2495 init_unistr2(&gr5->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2496 init_uni_hdr(&gr5->hdr_acct_desc, &gr5->uni_acct_desc);
2499 /*******************************************************************
2500 reads or writes a structure.
2501 ********************************************************************/
2503 BOOL samr_io_group_info5(const char *desc, GROUP_INFO5 * gr5,
2504 prs_struct *ps, int depth)
2511 prs_debug(ps, depth, desc, "samr_io_group_info5");
2514 if(!prs_uint16("level", ps, depth, &dummy))
2520 if(!smb_io_unihdr("hdr_acct_name", &gr5->hdr_acct_name, ps, depth))
2523 if(!prs_uint32("group_attr", ps, depth, &gr5->group_attr))
2525 if(!prs_uint32("num_members", ps, depth, &gr5->num_members))
2528 if(!smb_io_unihdr("hdr_acct_desc", &gr5->hdr_acct_desc, ps, depth))
2531 if(!smb_io_unistr2("uni_acct_name", &gr5->uni_acct_name,
2532 gr5->hdr_acct_name.buffer, ps, depth))
2535 if(!smb_io_unistr2("uni_acct_desc", &gr5->uni_acct_desc,
2536 gr5->hdr_acct_desc.buffer, ps, depth))
2543 /*******************************************************************
2544 reads or writes a structure.
2545 ********************************************************************/
2547 static BOOL samr_group_info_ctr(const char *desc, GROUP_INFO_CTR **ctr,
2548 prs_struct *ps, int depth)
2550 if (UNMARSHALLING(ps))
2551 *ctr = PRS_ALLOC_MEM(ps,GROUP_INFO_CTR,1);
2556 prs_debug(ps, depth, desc, "samr_group_info_ctr");
2559 if(!prs_uint16("switch_value1", ps, depth, &(*ctr)->switch_value1))
2562 switch ((*ctr)->switch_value1) {
2564 if(!samr_io_group_info1("group_info1", &(*ctr)->group.info1, ps, depth))
2568 if(!samr_io_group_info2("group_info2", &(*ctr)->group.info2, ps, depth))
2572 if(!samr_io_group_info3("group_info3", &(*ctr)->group.info3, ps, depth))
2576 if(!samr_io_group_info4("group_info4", &(*ctr)->group.info4, ps, depth))
2580 if(!samr_io_group_info5("group_info5", &(*ctr)->group.info5, ps, depth))
2584 DEBUG(0,("samr_group_info_ctr: unsupported switch level\n"));
2591 /*******************************************************************
2592 inits a SAMR_Q_CREATE_DOM_GROUP structure.
2593 ********************************************************************/
2595 void init_samr_q_create_dom_group(SAMR_Q_CREATE_DOM_GROUP * q_e,
2596 POLICY_HND *pol, const char *acct_desc,
2599 DEBUG(5, ("init_samr_q_create_dom_group\n"));
2603 init_unistr2(&q_e->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
2604 init_uni_hdr(&q_e->hdr_acct_desc, &q_e->uni_acct_desc);
2606 q_e->access_mask = access_mask;
2609 /*******************************************************************
2610 reads or writes a structure.
2611 ********************************************************************/
2613 BOOL samr_io_q_create_dom_group(const char *desc, SAMR_Q_CREATE_DOM_GROUP * q_e,
2614 prs_struct *ps, int depth)
2619 prs_debug(ps, depth, desc, "samr_io_q_create_dom_group");
2625 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2628 if(!smb_io_unihdr("hdr_acct_desc", &q_e->hdr_acct_desc, ps, depth))
2630 if(!smb_io_unistr2("uni_acct_desc", &q_e->uni_acct_desc,
2631 q_e->hdr_acct_desc.buffer, ps, depth))
2636 if(!prs_uint32("access", ps, depth, &q_e->access_mask))
2642 /*******************************************************************
2643 reads or writes a structure.
2644 ********************************************************************/
2646 BOOL samr_io_r_create_dom_group(const char *desc, SAMR_R_CREATE_DOM_GROUP * r_u,
2647 prs_struct *ps, int depth)
2652 prs_debug(ps, depth, desc, "samr_io_r_create_dom_group");
2658 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2661 if(!prs_uint32("rid ", ps, depth, &r_u->rid))
2663 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2669 /*******************************************************************
2670 inits a SAMR_Q_DELETE_DOM_GROUP structure.
2671 ********************************************************************/
2673 void init_samr_q_delete_dom_group(SAMR_Q_DELETE_DOM_GROUP * q_c,
2676 DEBUG(5, ("init_samr_q_delete_dom_group\n"));
2678 q_c->group_pol = *hnd;
2681 /*******************************************************************
2682 reads or writes a structure.
2683 ********************************************************************/
2685 BOOL samr_io_q_delete_dom_group(const char *desc, SAMR_Q_DELETE_DOM_GROUP * q_u,
2686 prs_struct *ps, int depth)
2691 prs_debug(ps, depth, desc, "samr_io_q_delete_dom_group");
2697 if(!smb_io_pol_hnd("group_pol", &q_u->group_pol, ps, depth))
2703 /*******************************************************************
2704 reads or writes a structure.
2705 ********************************************************************/
2707 BOOL samr_io_r_delete_dom_group(const char *desc, SAMR_R_DELETE_DOM_GROUP * r_u,
2708 prs_struct *ps, int depth)
2713 prs_debug(ps, depth, desc, "samr_io_r_delete_dom_group");
2719 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
2722 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2728 /*******************************************************************
2729 inits a SAMR_Q_DEL_GROUPMEM structure.
2730 ********************************************************************/
2732 void init_samr_q_del_groupmem(SAMR_Q_DEL_GROUPMEM * q_e,
2733 POLICY_HND *pol, uint32 rid)
2735 DEBUG(5, ("init_samr_q_del_groupmem\n"));
2741 /*******************************************************************
2742 reads or writes a structure.
2743 ********************************************************************/
2745 BOOL samr_io_q_del_groupmem(const char *desc, SAMR_Q_DEL_GROUPMEM * q_e,
2746 prs_struct *ps, int depth)
2751 prs_debug(ps, depth, desc, "samr_io_q_del_groupmem");
2757 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2760 if(!prs_uint32("rid", ps, depth, &q_e->rid))
2766 /*******************************************************************
2767 inits a SAMR_R_DEL_GROUPMEM structure.
2768 ********************************************************************/
2770 void init_samr_r_del_groupmem(SAMR_R_DEL_GROUPMEM * r_u, POLICY_HND *pol,
2773 DEBUG(5, ("init_samr_r_del_groupmem\n"));
2775 r_u->status = status;
2778 /*******************************************************************
2779 reads or writes a structure.
2780 ********************************************************************/
2782 BOOL samr_io_r_del_groupmem(const char *desc, SAMR_R_DEL_GROUPMEM * r_u,
2783 prs_struct *ps, int depth)
2788 prs_debug(ps, depth, desc, "samr_io_r_del_groupmem");
2794 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2800 /*******************************************************************
2801 inits a SAMR_Q_ADD_GROUPMEM structure.
2802 ********************************************************************/
2804 void init_samr_q_add_groupmem(SAMR_Q_ADD_GROUPMEM * q_e,
2805 POLICY_HND *pol, uint32 rid)
2807 DEBUG(5, ("init_samr_q_add_groupmem\n"));
2811 q_e->unknown = 0x0005;
2814 /*******************************************************************
2815 reads or writes a structure.
2816 ********************************************************************/
2818 BOOL samr_io_q_add_groupmem(const char *desc, SAMR_Q_ADD_GROUPMEM * q_e,
2819 prs_struct *ps, int depth)
2824 prs_debug(ps, depth, desc, "samr_io_q_add_groupmem");
2830 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2833 if(!prs_uint32("rid ", ps, depth, &q_e->rid))
2835 if(!prs_uint32("unknown", ps, depth, &q_e->unknown))
2841 /*******************************************************************
2842 inits a SAMR_R_ADD_GROUPMEM structure.
2843 ********************************************************************/
2845 void init_samr_r_add_groupmem(SAMR_R_ADD_GROUPMEM * r_u, POLICY_HND *pol,
2848 DEBUG(5, ("init_samr_r_add_groupmem\n"));
2850 r_u->status = status;
2853 /*******************************************************************
2854 reads or writes a structure.
2855 ********************************************************************/
2857 BOOL samr_io_r_add_groupmem(const char *desc, SAMR_R_ADD_GROUPMEM * r_u,
2858 prs_struct *ps, int depth)
2863 prs_debug(ps, depth, desc, "samr_io_r_add_groupmem");
2869 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2875 /*******************************************************************
2876 inits a SAMR_Q_SET_GROUPINFO structure.
2877 ********************************************************************/
2879 void init_samr_q_set_groupinfo(SAMR_Q_SET_GROUPINFO * q_e,
2880 POLICY_HND *pol, GROUP_INFO_CTR * ctr)
2882 DEBUG(5, ("init_samr_q_set_groupinfo\n"));
2888 /*******************************************************************
2889 reads or writes a structure.
2890 ********************************************************************/
2892 BOOL samr_io_q_set_groupinfo(const char *desc, SAMR_Q_SET_GROUPINFO * q_e,
2893 prs_struct *ps, int depth)
2898 prs_debug(ps, depth, desc, "samr_io_q_set_groupinfo");
2904 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2907 if(!samr_group_info_ctr("ctr", &q_e->ctr, ps, depth))
2913 /*******************************************************************
2914 inits a SAMR_R_SET_GROUPINFO structure.
2915 ********************************************************************/
2917 void init_samr_r_set_groupinfo(SAMR_R_SET_GROUPINFO * r_u, NTSTATUS status)
2919 DEBUG(5, ("init_samr_r_set_groupinfo\n"));
2921 r_u->status = status;
2924 /*******************************************************************
2925 reads or writes a structure.
2926 ********************************************************************/
2928 BOOL samr_io_r_set_groupinfo(const char *desc, SAMR_R_SET_GROUPINFO * r_u,
2929 prs_struct *ps, int depth)
2934 prs_debug(ps, depth, desc, "samr_io_r_set_groupinfo");
2940 if(!prs_ntstatus("status", ps, depth, &r_u->status))
2946 /*******************************************************************
2947 inits a SAMR_Q_QUERY_GROUPINFO structure.
2948 ********************************************************************/
2950 void init_samr_q_query_groupinfo(SAMR_Q_QUERY_GROUPINFO * q_e,
2951 POLICY_HND *pol, uint16 switch_level)
2953 DEBUG(5, ("init_samr_q_query_groupinfo\n"));
2957 q_e->switch_level = switch_level;
2960 /*******************************************************************
2961 reads or writes a structure.
2962 ********************************************************************/
2964 BOOL samr_io_q_query_groupinfo(const char *desc, SAMR_Q_QUERY_GROUPINFO * q_e,
2965 prs_struct *ps, int depth)
2970 prs_debug(ps, depth, desc, "samr_io_q_query_groupinfo");
2976 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
2979 if(!prs_uint16("switch_level", ps, depth, &q_e->switch_level))
2985 /*******************************************************************
2986 inits a SAMR_R_QUERY_GROUPINFO structure.
2987 ********************************************************************/
2989 void init_samr_r_query_groupinfo(SAMR_R_QUERY_GROUPINFO * r_u,
2990 GROUP_INFO_CTR * ctr, NTSTATUS status)
2992 DEBUG(5, ("init_samr_r_query_groupinfo\n"));
2994 r_u->ptr = (NT_STATUS_IS_OK(status) && ctr != NULL) ? 1 : 0;
2996 r_u->status = status;
2999 /*******************************************************************
3000 reads or writes a structure.
3001 ********************************************************************/
3003 BOOL samr_io_r_query_groupinfo(const char *desc, SAMR_R_QUERY_GROUPINFO * r_u,
3004 prs_struct *ps, int depth)
3009 prs_debug(ps, depth, desc, "samr_io_r_query_groupinfo");
3015 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
3018 if (r_u->ptr != 0) {
3019 if(!samr_group_info_ctr("ctr", &r_u->ctr, ps, depth))
3025 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3031 /*******************************************************************
3032 inits a SAMR_Q_QUERY_GROUPMEM structure.
3033 ********************************************************************/
3035 void init_samr_q_query_groupmem(SAMR_Q_QUERY_GROUPMEM * q_c, POLICY_HND *hnd)
3037 DEBUG(5, ("init_samr_q_query_groupmem\n"));
3039 q_c->group_pol = *hnd;
3042 /*******************************************************************
3043 reads or writes a structure.
3044 ********************************************************************/
3046 BOOL samr_io_q_query_groupmem(const char *desc, SAMR_Q_QUERY_GROUPMEM * q_u,
3047 prs_struct *ps, int depth)
3052 prs_debug(ps, depth, desc, "samr_io_q_query_groupmem");
3058 if(!smb_io_pol_hnd("group_pol", &q_u->group_pol, ps, depth))
3064 /*******************************************************************
3065 inits a SAMR_R_QUERY_GROUPMEM structure.
3066 ********************************************************************/
3068 void init_samr_r_query_groupmem(SAMR_R_QUERY_GROUPMEM * r_u,
3069 uint32 num_entries, uint32 *rid,
3070 uint32 *attr, NTSTATUS status)
3072 DEBUG(5, ("init_samr_r_query_groupmem\n"));
3074 if (NT_STATUS_IS_OK(status)) {
3076 r_u->num_entries = num_entries;
3078 r_u->ptr_attrs = attr != NULL ? 1 : 0;
3079 r_u->ptr_rids = rid != NULL ? 1 : 0;
3081 r_u->num_rids = num_entries;
3084 r_u->num_attrs = num_entries;
3088 r_u->num_entries = 0;
3091 r_u->status = status;
3094 /*******************************************************************
3095 reads or writes a structure.
3096 ********************************************************************/
3098 BOOL samr_io_r_query_groupmem(const char *desc, SAMR_R_QUERY_GROUPMEM * r_u,
3099 prs_struct *ps, int depth)
3106 if (UNMARSHALLING(ps))
3109 prs_debug(ps, depth, desc, "samr_io_r_query_groupmem");
3115 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
3117 if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
3120 if (r_u->ptr != 0) {
3121 if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids))
3123 if(!prs_uint32("ptr_attrs", ps, depth, &r_u->ptr_attrs))
3126 if (r_u->ptr_rids != 0) {
3127 if(!prs_uint32("num_rids", ps, depth, &r_u->num_rids))
3129 if (UNMARSHALLING(ps) && r_u->num_rids != 0) {
3130 r_u->rid = PRS_ALLOC_MEM(ps,uint32,r_u->num_rids);
3131 if (r_u->rid == NULL)
3135 for (i = 0; i < r_u->num_rids; i++) {
3136 if(!prs_uint32("", ps, depth, &r_u->rid[i]))
3141 if (r_u->ptr_attrs != 0) {
3142 if(!prs_uint32("num_attrs", ps, depth, &r_u->num_attrs))
3145 if (UNMARSHALLING(ps) && r_u->num_attrs != 0) {
3146 r_u->attr = PRS_ALLOC_MEM(ps,uint32,r_u->num_attrs);
3147 if (r_u->attr == NULL)
3151 for (i = 0; i < r_u->num_attrs; i++) {
3152 if(!prs_uint32("", ps, depth, &r_u->attr[i]))
3158 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3164 /*******************************************************************
3165 inits a SAMR_Q_QUERY_USERGROUPS structure.
3166 ********************************************************************/
3168 void init_samr_q_query_usergroups(SAMR_Q_QUERY_USERGROUPS * q_u,
3171 DEBUG(5, ("init_samr_q_query_usergroups\n"));
3176 /*******************************************************************
3177 reads or writes a structure.
3178 ********************************************************************/
3180 BOOL samr_io_q_query_usergroups(const char *desc, SAMR_Q_QUERY_USERGROUPS * q_u,
3181 prs_struct *ps, int depth)
3186 prs_debug(ps, depth, desc, "samr_io_q_query_usergroups");
3192 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
3198 /*******************************************************************
3199 inits a SAMR_R_QUERY_USERGROUPS structure.
3200 ********************************************************************/
3202 void init_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS * r_u,
3203 uint32 num_gids, DOM_GID * gid,
3206 DEBUG(5, ("init_samr_r_query_usergroups\n"));
3208 if (NT_STATUS_IS_OK(status)) {
3210 r_u->num_entries = num_gids;
3211 r_u->ptr_1 = (num_gids != 0) ? 1 : 0;
3212 r_u->num_entries2 = num_gids;
3217 r_u->num_entries = 0;
3222 r_u->status = status;
3225 /*******************************************************************
3226 reads or writes a structure.
3227 ********************************************************************/
3229 BOOL samr_io_gids(const char *desc, uint32 *num_gids, DOM_GID ** gid,
3230 prs_struct *ps, int depth)
3236 prs_debug(ps, depth, desc, "samr_io_gids");
3242 if(!prs_uint32("num_gids", ps, depth, num_gids))
3245 if ((*num_gids) != 0) {
3246 if (UNMARSHALLING(ps)) {
3247 (*gid) = PRS_ALLOC_MEM(ps,DOM_GID,*num_gids);
3250 if ((*gid) == NULL) {
3254 for (i = 0; i < (*num_gids); i++) {
3255 if(!smb_io_gid("gids", &(*gid)[i], ps, depth))
3263 /*******************************************************************
3264 reads or writes a structure.
3265 ********************************************************************/
3267 BOOL samr_io_r_query_usergroups(const char *desc, SAMR_R_QUERY_USERGROUPS * r_u,
3268 prs_struct *ps, int depth)
3273 prs_debug(ps, depth, desc, "samr_io_r_query_usergroups");
3279 if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
3282 if (r_u->ptr_0 != 0) {
3283 if(!prs_uint32("num_entries ", ps, depth, &r_u->num_entries))
3285 if(!prs_uint32("ptr_1 ", ps, depth, &r_u->ptr_1))
3288 if (r_u->num_entries != 0 && r_u->ptr_1 != 0) {
3289 if(!samr_io_gids("gids", &r_u->num_entries2, &r_u->gid, ps, depth))
3296 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3302 /*******************************************************************
3303 inits a SAMR_Q_ENUM_DOMAINS structure.
3304 ********************************************************************/
3306 void init_samr_q_enum_domains(SAMR_Q_ENUM_DOMAINS * q_e,
3308 uint32 start_idx, uint32 size)
3310 DEBUG(5, ("init_samr_q_enum_domains\n"));
3314 q_e->start_idx = start_idx;
3315 q_e->max_size = size;
3318 /*******************************************************************
3319 reads or writes a structure.
3320 ********************************************************************/
3322 BOOL samr_io_q_enum_domains(const char *desc, SAMR_Q_ENUM_DOMAINS * q_e,
3323 prs_struct *ps, int depth)
3328 prs_debug(ps, depth, desc, "samr_io_q_enum_domains");
3334 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
3337 if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3339 if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3345 /*******************************************************************
3346 inits a SAMR_R_ENUM_DOMAINS structure.
3347 ********************************************************************/
3349 void init_samr_r_enum_domains(SAMR_R_ENUM_DOMAINS * r_u,
3350 uint32 next_idx, uint32 num_sam_entries)
3352 DEBUG(5, ("init_samr_r_enum_domains\n"));
3354 r_u->next_idx = next_idx;
3356 if (num_sam_entries != 0) {
3357 r_u->ptr_entries1 = 1;
3358 r_u->ptr_entries2 = 1;
3359 r_u->num_entries2 = num_sam_entries;
3360 r_u->num_entries3 = num_sam_entries;
3362 r_u->num_entries4 = num_sam_entries;
3364 r_u->ptr_entries1 = 0;
3365 r_u->num_entries2 = num_sam_entries;
3366 r_u->ptr_entries2 = 1;
3370 /*******************************************************************
3371 reads or writes a structure.
3372 ********************************************************************/
3374 BOOL samr_io_r_enum_domains(const char *desc, SAMR_R_ENUM_DOMAINS * r_u,
3375 prs_struct *ps, int depth)
3382 prs_debug(ps, depth, desc, "samr_io_r_enum_domains");
3388 if(!prs_uint32("next_idx ", ps, depth, &r_u->next_idx))
3390 if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3393 if (r_u->ptr_entries1 != 0) {
3394 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3396 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3398 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3401 if (UNMARSHALLING(ps)) {
3402 r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3403 r_u->uni_dom_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3406 if ((r_u->sam == NULL || r_u->uni_dom_name == NULL) && r_u->num_entries2 != 0) {
3407 DEBUG(0, ("NULL pointers in SAMR_R_ENUM_DOMAINS\n"));
3408 r_u->num_entries4 = 0;
3409 r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3413 for (i = 0; i < r_u->num_entries2; i++) {
3415 slprintf(tmp, sizeof(tmp) - 1, "dom[%d]", i);
3416 if(!sam_io_sam_entry(tmp, &r_u->sam[i], ps, depth))
3420 for (i = 0; i < r_u->num_entries2; i++) {
3422 slprintf(tmp, sizeof(tmp) - 1, "dom[%d]", i);
3423 if(!smb_io_unistr2(tmp, &r_u->uni_dom_name[i],
3424 r_u->sam[i].hdr_name.buffer, ps,
3433 if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3435 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3441 /*******************************************************************
3442 inits a SAMR_Q_ENUM_DOM_GROUPS structure.
3443 ********************************************************************/
3445 void init_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS * q_e,
3447 uint32 start_idx, uint32 size)
3449 DEBUG(5, ("init_samr_q_enum_dom_groups\n"));
3453 q_e->start_idx = start_idx;
3454 q_e->max_size = size;
3457 /*******************************************************************
3458 reads or writes a structure.
3459 ********************************************************************/
3461 BOOL samr_io_q_enum_dom_groups(const char *desc, SAMR_Q_ENUM_DOM_GROUPS * q_e,
3462 prs_struct *ps, int depth)
3467 prs_debug(ps, depth, desc, "samr_io_q_enum_dom_groups");
3473 if(!smb_io_pol_hnd("pol", &(q_e->pol), ps, depth))
3476 if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3478 if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3484 /*******************************************************************
3485 inits a SAMR_R_ENUM_DOM_GROUPS structure.
3486 ********************************************************************/
3488 void init_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS * r_u,
3489 uint32 next_idx, uint32 num_sam_entries)
3491 DEBUG(5, ("init_samr_r_enum_dom_groups\n"));
3493 r_u->next_idx = next_idx;
3495 if (num_sam_entries != 0) {
3496 r_u->ptr_entries1 = 1;
3497 r_u->ptr_entries2 = 1;
3498 r_u->num_entries2 = num_sam_entries;
3499 r_u->num_entries3 = num_sam_entries;
3501 r_u->num_entries4 = num_sam_entries;
3503 r_u->ptr_entries1 = 0;
3504 r_u->num_entries2 = num_sam_entries;
3505 r_u->ptr_entries2 = 1;
3509 /*******************************************************************
3510 reads or writes a structure.
3511 ********************************************************************/
3513 BOOL samr_io_r_enum_dom_groups(const char *desc, SAMR_R_ENUM_DOM_GROUPS * r_u,
3514 prs_struct *ps, int depth)
3521 prs_debug(ps, depth, desc, "samr_io_r_enum_dom_groups");
3527 if(!prs_uint32("next_idx ", ps, depth, &r_u->next_idx))
3529 if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3532 if (r_u->ptr_entries1 != 0) {
3533 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3535 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3537 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3540 if (UNMARSHALLING(ps)) {
3541 r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3542 r_u->uni_grp_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3545 if ((r_u->sam == NULL || r_u->uni_grp_name == NULL) && r_u->num_entries2 != 0) {
3547 ("NULL pointers in SAMR_R_ENUM_DOM_GROUPS\n"));
3548 r_u->num_entries4 = 0;
3549 r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3553 for (i = 0; i < r_u->num_entries2; i++) {
3554 if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
3558 for (i = 0; i < r_u->num_entries2; i++) {
3559 if(!smb_io_unistr2("", &r_u->uni_grp_name[i],
3560 r_u->sam[i].hdr_name.buffer, ps, depth))
3567 if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3569 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3575 /*******************************************************************
3576 inits a SAMR_Q_ENUM_DOM_ALIASES structure.
3577 ********************************************************************/
3579 void init_samr_q_enum_dom_aliases(SAMR_Q_ENUM_DOM_ALIASES * q_e,
3580 POLICY_HND *pol, uint32 start_idx,
3583 DEBUG(5, ("init_samr_q_enum_dom_aliases\n"));
3587 q_e->start_idx = start_idx;
3588 q_e->max_size = size;
3592 /*******************************************************************
3593 reads or writes a structure.
3594 ********************************************************************/
3596 BOOL samr_io_q_enum_dom_aliases(const char *desc, SAMR_Q_ENUM_DOM_ALIASES * q_e,
3597 prs_struct *ps, int depth)
3602 prs_debug(ps, depth, desc, "samr_io_q_enum_dom_aliases");
3608 if(!smb_io_pol_hnd("pol", &q_e->pol, ps, depth))
3611 if(!prs_uint32("start_idx", ps, depth, &q_e->start_idx))
3613 if(!prs_uint32("max_size ", ps, depth, &q_e->max_size))
3619 /*******************************************************************
3620 inits a SAMR_R_ENUM_DOM_ALIASES structure.
3621 ********************************************************************/
3623 void init_samr_r_enum_dom_aliases(SAMR_R_ENUM_DOM_ALIASES *r_u, uint32 next_idx, uint32 num_sam_entries)
3625 DEBUG(5, ("init_samr_r_enum_dom_aliases\n"));
3627 r_u->next_idx = next_idx;
3629 if (num_sam_entries != 0) {
3630 r_u->ptr_entries1 = 1;
3631 r_u->ptr_entries2 = 1;
3632 r_u->num_entries2 = num_sam_entries;
3633 r_u->num_entries3 = num_sam_entries;
3635 r_u->num_entries4 = num_sam_entries;
3637 r_u->ptr_entries1 = 0;
3638 r_u->num_entries2 = num_sam_entries;
3639 r_u->ptr_entries2 = 1;
3643 /*******************************************************************
3644 reads or writes a structure.
3645 ********************************************************************/
3647 BOOL samr_io_r_enum_dom_aliases(const char *desc, SAMR_R_ENUM_DOM_ALIASES * r_u,
3648 prs_struct *ps, int depth)
3655 prs_debug(ps, depth, desc, "samr_io_r_enum_dom_aliases");
3661 if(!prs_uint32("next_idx ", ps, depth, &r_u->next_idx))
3663 if(!prs_uint32("ptr_entries1", ps, depth, &r_u->ptr_entries1))
3666 if (r_u->ptr_entries1 != 0) {
3667 if(!prs_uint32("num_entries2", ps, depth, &r_u->num_entries2))
3669 if(!prs_uint32("ptr_entries2", ps, depth, &r_u->ptr_entries2))
3671 if(!prs_uint32("num_entries3", ps, depth, &r_u->num_entries3))
3674 if (UNMARSHALLING(ps) && (r_u->num_entries2 > 0)) {
3675 r_u->sam = PRS_ALLOC_MEM(ps,SAM_ENTRY,r_u->num_entries2);
3676 r_u->uni_grp_name = PRS_ALLOC_MEM(ps,UNISTR2,r_u->num_entries2);
3679 if (r_u->num_entries2 != 0 &&
3680 (r_u->sam == NULL || r_u->uni_grp_name == NULL)) {
3681 DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_ALIASES\n"));
3682 r_u->num_entries4 = 0;
3683 r_u->status = NT_STATUS_MEMORY_NOT_ALLOCATED;
3687 for (i = 0; i < r_u->num_entries2; i++) {
3688 if(!sam_io_sam_entry("", &r_u->sam[i], ps, depth))
3692 for (i = 0; i < r_u->num_entries2; i++) {
3693 if(!smb_io_unistr2("", &r_u->uni_grp_name[i],
3694 r_u->sam[i].hdr_name.buffer, ps,
3702 if(!prs_uint32("num_entries4", ps, depth, &r_u->num_entries4))
3704 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3710 /*******************************************************************
3711 inits a ALIAS_INFO1 structure.
3712 ********************************************************************/
3714 void init_samr_alias_info1(ALIAS_INFO1 * al1, char *acct_name, uint32 num_member, char *acct_desc)
3716 DEBUG(5, ("init_samr_alias_info1\n"));
3718 init_unistr4(&al1->name, acct_name, UNI_FLAGS_NONE);
3719 al1->num_member = num_member;
3720 init_unistr4(&al1->description, acct_desc, UNI_FLAGS_NONE);
3723 /*******************************************************************
3724 reads or writes a structure.
3725 ********************************************************************/
3727 BOOL samr_io_alias_info1(const char *desc, ALIAS_INFO1 * al1,
3728 prs_struct *ps, int depth)
3733 prs_debug(ps, depth, desc, "samr_io_alias_info1");
3739 if ( !prs_unistr4_hdr("name", ps, depth, &al1->name) )
3741 if ( !prs_uint32("num_member", ps, depth, &al1->num_member) )
3743 if ( !prs_unistr4_hdr("description", ps, depth, &al1->description) )
3746 if ( !prs_unistr4_str("name", ps, depth, &al1->name) )
3748 if ( !prs_align(ps) )
3750 if ( !prs_unistr4_str("description", ps, depth, &al1->description) )
3752 if ( !prs_align(ps) )
3758 /*******************************************************************
3759 inits a ALIAS_INFO3 structure.
3760 ********************************************************************/
3762 void init_samr_alias_info3(ALIAS_INFO3 * al3, const char *acct_desc)
3764 DEBUG(5, ("init_samr_alias_info3\n"));
3766 init_unistr4(&al3->description, acct_desc, UNI_FLAGS_NONE);
3769 /*******************************************************************
3770 reads or writes a structure.
3771 ********************************************************************/
3773 BOOL samr_io_alias_info3(const char *desc, ALIAS_INFO3 *al3,
3774 prs_struct *ps, int depth)
3779 prs_debug(ps, depth, desc, "samr_io_alias_info3");
3785 if (!prs_unistr4("description", ps, depth, &al3->description))
3791 /*******************************************************************
3792 reads or writes a structure.
3793 ********************************************************************/
3795 BOOL samr_io_alias_info2(const char *desc, ALIAS_INFO2 *al2,
3796 prs_struct *ps, int depth)
3801 prs_debug(ps, depth, desc, "samr_io_alias_info2");
3807 if (!prs_unistr4("name", ps, depth, &al2->name))
3813 /*******************************************************************
3814 reads or writes a structure.
3815 ********************************************************************/
3817 BOOL samr_alias_info_ctr(const char *desc, prs_struct *ps, int depth, ALIAS_INFO_CTR * ctr)
3822 prs_debug(ps, depth, desc, "samr_alias_info_ctr");
3825 if ( !prs_uint16("level", ps, depth, &ctr->level) )
3830 switch (ctr->level) {
3832 if(!samr_io_alias_info1("alias_info1", &ctr->alias.info1, ps, depth))
3836 if(!samr_io_alias_info2("alias_info2", &ctr->alias.info2, ps, depth))
3840 if(!samr_io_alias_info3("alias_info3", &ctr->alias.info3, ps, depth))
3844 DEBUG(0,("samr_alias_info_ctr: unsupported switch level\n"));
3851 /*******************************************************************
3852 inits a SAMR_Q_QUERY_ALIASINFO structure.
3853 ********************************************************************/
3855 void init_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO * q_e,
3856 POLICY_HND *pol, uint32 switch_level)
3858 DEBUG(5, ("init_samr_q_query_aliasinfo\n"));
3861 q_e->level = switch_level;
3864 /*******************************************************************
3865 reads or writes a structure.
3866 ********************************************************************/
3868 BOOL samr_io_q_query_aliasinfo(const char *desc, SAMR_Q_QUERY_ALIASINFO *in,
3869 prs_struct *ps, int depth)
3874 prs_debug(ps, depth, desc, "samr_io_q_query_aliasinfo");
3880 if ( !smb_io_pol_hnd("pol", &(in->pol), ps, depth) )
3883 if ( !prs_uint16("level", ps, depth, &in->level) )
3889 /*******************************************************************
3890 inits a SAMR_R_QUERY_ALIASINFO structure.
3891 ********************************************************************/
3893 void init_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO *out,
3894 ALIAS_INFO_CTR * ctr, NTSTATUS status)
3896 DEBUG(5, ("init_samr_r_query_aliasinfo\n"));
3899 out->status = status;
3902 /*******************************************************************
3903 reads or writes a structure.
3904 ********************************************************************/
3906 BOOL samr_io_r_query_aliasinfo(const char *desc, SAMR_R_QUERY_ALIASINFO *out,
3907 prs_struct *ps, int depth)
3912 prs_debug(ps, depth, desc, "samr_io_r_query_aliasinfo");
3918 if ( !prs_pointer("alias", ps, depth, (void*)&out->ctr, sizeof(ALIAS_INFO_CTR), (PRS_POINTER_CAST)samr_alias_info_ctr))
3923 if(!prs_ntstatus("status", ps, depth, &out->status))
3929 /*******************************************************************
3930 inits a SAMR_Q_SET_ALIASINFO structure.
3931 ********************************************************************/
3933 void init_samr_q_set_aliasinfo(SAMR_Q_SET_ALIASINFO * q_u,
3934 POLICY_HND *hnd, ALIAS_INFO_CTR * ctr)
3936 DEBUG(5, ("init_samr_q_set_aliasinfo\n"));
3938 q_u->alias_pol = *hnd;
3942 /*******************************************************************
3943 reads or writes a structure.
3944 ********************************************************************/
3946 BOOL samr_io_q_set_aliasinfo(const char *desc, SAMR_Q_SET_ALIASINFO * q_u,
3947 prs_struct *ps, int depth)
3952 prs_debug(ps, depth, desc, "samr_io_q_set_aliasinfo");
3958 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
3960 if(!samr_alias_info_ctr("ctr", ps, depth, &q_u->ctr))
3966 /*******************************************************************
3967 reads or writes a structure.
3968 ********************************************************************/
3970 BOOL samr_io_r_set_aliasinfo(const char *desc, SAMR_R_SET_ALIASINFO * r_u,
3971 prs_struct *ps, int depth)
3976 prs_debug(ps, depth, desc, "samr_io_r_set_aliasinfo");
3981 if(!prs_ntstatus("status", ps, depth, &r_u->status))
3987 /*******************************************************************
3988 inits a SAMR_Q_QUERY_USERALIASES structure.
3989 ********************************************************************/
3991 void init_samr_q_query_useraliases(SAMR_Q_QUERY_USERALIASES * q_u,
3994 uint32 *ptr_sid, DOM_SID2 * sid)
3996 DEBUG(5, ("init_samr_q_query_useraliases\n"));
4000 q_u->num_sids1 = num_sids;
4002 q_u->num_sids2 = num_sids;
4004 q_u->ptr_sid = ptr_sid;
4008 /*******************************************************************
4009 reads or writes a SAMR_Q_QUERY_USERALIASES structure.
4010 ********************************************************************/
4012 BOOL samr_io_q_query_useraliases(const char *desc, SAMR_Q_QUERY_USERALIASES * q_u,
4013 prs_struct *ps, int depth)
4021 prs_debug(ps, depth, desc, "samr_io_q_query_useraliases");
4027 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4030 if(!prs_uint32("num_sids1", ps, depth, &q_u->num_sids1))
4032 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
4038 if(!prs_uint32("num_sids2", ps, depth, &q_u->num_sids2))
4041 if (UNMARSHALLING(ps) && (q_u->num_sids2 != 0)) {
4042 q_u->ptr_sid = PRS_ALLOC_MEM(ps,uint32,q_u->num_sids2);
4043 if (q_u->ptr_sid == NULL)
4046 q_u->sid = PRS_ALLOC_MEM(ps, DOM_SID2, q_u->num_sids2);
4047 if (q_u->sid == NULL)
4051 for (i = 0; i < q_u->num_sids2; i++) {
4052 slprintf(tmp, sizeof(tmp) - 1, "ptr[%02d]", i);
4053 if(!prs_uint32(tmp, ps, depth, &q_u->ptr_sid[i]))
4057 for (i = 0; i < q_u->num_sids2; i++) {
4058 if (q_u->ptr_sid[i] != 0) {
4059 slprintf(tmp, sizeof(tmp) - 1, "sid[%02d]", i);
4060 if(!smb_io_dom_sid2(tmp, &q_u->sid[i], ps, depth))
4068 /*******************************************************************
4069 inits a SAMR_R_QUERY_USERALIASES structure.
4070 ********************************************************************/
4072 void init_samr_r_query_useraliases(SAMR_R_QUERY_USERALIASES * r_u,
4073 uint32 num_rids, uint32 *rid,
4076 DEBUG(5, ("init_samr_r_query_useraliases\n"));
4078 if (NT_STATUS_IS_OK(status)) {
4079 r_u->num_entries = num_rids;
4081 r_u->num_entries2 = num_rids;
4085 r_u->num_entries = 0;
4087 r_u->num_entries2 = 0;
4090 r_u->status = status;
4093 /*******************************************************************
4094 reads or writes a structure.
4095 ********************************************************************/
4097 BOOL samr_io_rids(const char *desc, uint32 *num_rids, uint32 **rid,
4098 prs_struct *ps, int depth)
4105 prs_debug(ps, depth, desc, "samr_io_rids");
4111 if(!prs_uint32("num_rids", ps, depth, num_rids))
4114 if ((*num_rids) != 0) {
4115 if (UNMARSHALLING(ps)) {
4117 (*rid) = PRS_ALLOC_MEM(ps,uint32, *num_rids);
4122 for (i = 0; i < (*num_rids); i++) {
4123 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d]", i);
4124 if(!prs_uint32(tmp, ps, depth, &((*rid)[i])))
4132 /*******************************************************************
4133 reads or writes a structure.
4134 ********************************************************************/
4136 BOOL samr_io_r_query_useraliases(const char *desc, SAMR_R_QUERY_USERALIASES * r_u,
4137 prs_struct *ps, int depth)
4142 prs_debug(ps, depth, desc, "samr_io_r_query_useraliases");
4148 if(!prs_uint32("num_entries", ps, depth, &r_u->num_entries))
4150 if(!prs_uint32("ptr ", ps, depth, &r_u->ptr))
4153 if (r_u->ptr != 0) {
4154 if(!samr_io_rids("rids", &r_u->num_entries2, &r_u->rid, ps, depth))
4160 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4166 /*******************************************************************
4167 inits a SAMR_Q_OPEN_ALIAS structure.
4168 ********************************************************************/
4170 void init_samr_q_open_alias(SAMR_Q_OPEN_ALIAS * q_u, POLICY_HND *pol,
4171 uint32 access_mask, uint32 rid)
4173 DEBUG(5, ("init_samr_q_open_alias\n"));
4175 q_u->dom_pol = *pol;
4176 q_u->access_mask = access_mask;
4177 q_u->rid_alias = rid;
4180 /*******************************************************************
4181 reads or writes a structure.
4182 ********************************************************************/
4184 BOOL samr_io_q_open_alias(const char *desc, SAMR_Q_OPEN_ALIAS * q_u,
4185 prs_struct *ps, int depth)
4190 prs_debug(ps, depth, desc, "samr_io_q_open_alias");
4196 if(!smb_io_pol_hnd("domain_pol", &q_u->dom_pol, ps, depth))
4199 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
4201 if(!prs_uint32("rid_alias", ps, depth, &q_u->rid_alias))
4207 /*******************************************************************
4208 reads or writes a structure.
4209 ********************************************************************/
4211 BOOL samr_io_r_open_alias(const char *desc, SAMR_R_OPEN_ALIAS * r_u,
4212 prs_struct *ps, int depth)
4217 prs_debug(ps, depth, desc, "samr_io_r_open_alias");
4223 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4226 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4232 /*******************************************************************
4233 inits a SAMR_Q_LOOKUP_RIDS structure.
4234 ********************************************************************/
4236 void init_samr_q_lookup_rids(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_RIDS * q_u,
4237 POLICY_HND *pol, uint32 flags,
4238 uint32 num_rids, uint32 *rid)
4240 DEBUG(5, ("init_samr_q_lookup_rids\n"));
4244 q_u->num_rids1 = num_rids;
4247 q_u->num_rids2 = num_rids;
4248 q_u->rid = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids );
4249 if (q_u->rid == NULL) {
4253 memcpy(q_u->rid, rid, num_rids * sizeof(q_u->rid[0]));
4257 /*******************************************************************
4258 reads or writes a structure.
4259 ********************************************************************/
4261 BOOL samr_io_q_lookup_rids(const char *desc, SAMR_Q_LOOKUP_RIDS * q_u,
4262 prs_struct *ps, int depth)
4270 prs_debug(ps, depth, desc, "samr_io_q_lookup_rids");
4273 if (UNMARSHALLING(ps))
4279 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4282 if(!prs_uint32("num_rids1", ps, depth, &q_u->num_rids1))
4284 if(!prs_uint32("flags ", ps, depth, &q_u->flags))
4286 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
4288 if(!prs_uint32("num_rids2", ps, depth, &q_u->num_rids2))
4291 if (UNMARSHALLING(ps) && (q_u->num_rids2 != 0)) {
4292 q_u->rid = PRS_ALLOC_MEM(ps, uint32, q_u->num_rids2);
4293 if (q_u->rid == NULL)
4297 for (i = 0; i < q_u->num_rids2; i++) {
4298 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d] ", i);
4299 if(!prs_uint32(tmp, ps, depth, &q_u->rid[i]))
4306 /*******************************************************************
4307 inits a SAMR_R_LOOKUP_RIDS structure.
4308 ********************************************************************/
4310 void init_samr_r_lookup_rids(SAMR_R_LOOKUP_RIDS * r_u,
4311 uint32 num_names, UNIHDR * hdr_name,
4312 UNISTR2 *uni_name, uint32 *type)
4314 DEBUG(5, ("init_samr_r_lookup_rids\n"));
4316 r_u->hdr_name = NULL;
4317 r_u->uni_name = NULL;
4320 if (num_names != 0) {
4321 r_u->num_names1 = num_names;
4323 r_u->num_names2 = num_names;
4325 r_u->num_types1 = num_names;
4327 r_u->num_types2 = num_names;
4329 r_u->hdr_name = hdr_name;
4330 r_u->uni_name = uni_name;
4333 r_u->num_names1 = num_names;
4335 r_u->num_names2 = num_names;
4337 r_u->num_types1 = num_names;
4339 r_u->num_types2 = num_names;
4343 /*******************************************************************
4344 reads or writes a structure.
4345 ********************************************************************/
4347 BOOL samr_io_r_lookup_rids(const char *desc, SAMR_R_LOOKUP_RIDS * r_u,
4348 prs_struct *ps, int depth)
4355 prs_debug(ps, depth, desc, "samr_io_r_lookup_rids");
4361 if(!prs_uint32("num_names1", ps, depth, &r_u->num_names1))
4363 if(!prs_uint32("ptr_names ", ps, depth, &r_u->ptr_names))
4366 if (r_u->ptr_names != 0) {
4368 if(!prs_uint32("num_names2", ps, depth, &r_u->num_names2))
4372 if (UNMARSHALLING(ps) && (r_u->num_names2 != 0)) {
4373 r_u->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, r_u->num_names2);
4374 if (r_u->hdr_name == NULL)
4377 r_u->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, r_u->num_names2);
4378 if (r_u->uni_name == NULL)
4382 for (i = 0; i < r_u->num_names2; i++) {
4383 slprintf(tmp, sizeof(tmp) - 1, "hdr[%02d] ", i);
4384 if(!smb_io_unihdr("", &r_u->hdr_name[i], ps, depth))
4387 for (i = 0; i < r_u->num_names2; i++) {
4388 slprintf(tmp, sizeof(tmp) - 1, "str[%02d] ", i);
4389 if(!smb_io_unistr2("", &r_u->uni_name[i], r_u->hdr_name[i].buffer, ps, depth))
4397 if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
4399 if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
4402 if (r_u->ptr_types != 0) {
4404 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
4407 if (UNMARSHALLING(ps) && (r_u->num_types2 != 0)) {
4408 r_u->type = PRS_ALLOC_MEM(ps, uint32, r_u->num_types2);
4409 if (r_u->type == NULL)
4413 for (i = 0; i < r_u->num_types2; i++) {
4414 slprintf(tmp, sizeof(tmp) - 1, "type[%02d] ", i);
4415 if(!prs_uint32(tmp, ps, depth, &r_u->type[i]))
4420 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4426 /*******************************************************************
4427 inits a SAMR_Q_OPEN_ALIAS structure.
4428 ********************************************************************/
4430 void init_samr_q_delete_alias(SAMR_Q_DELETE_DOM_ALIAS * q_u, POLICY_HND *hnd)
4432 DEBUG(5, ("init_samr_q_delete_alias\n"));
4434 q_u->alias_pol = *hnd;
4437 /*******************************************************************
4438 reads or writes a structure.
4439 ********************************************************************/
4441 BOOL samr_io_q_delete_alias(const char *desc, SAMR_Q_DELETE_DOM_ALIAS * q_u,
4442 prs_struct *ps, int depth)
4447 prs_debug(ps, depth, desc, "samr_io_q_delete_alias");
4453 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4459 /*******************************************************************
4460 reads or writes a structure.
4461 ********************************************************************/
4463 BOOL samr_io_r_delete_alias(const char *desc, SAMR_R_DELETE_DOM_ALIAS * r_u,
4464 prs_struct *ps, int depth)
4469 prs_debug(ps, depth, desc, "samr_io_r_delete_alias");
4475 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4477 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4483 /*******************************************************************
4484 inits a SAMR_Q_CREATE_DOM_ALIAS structure.
4485 ********************************************************************/
4487 void init_samr_q_create_dom_alias(SAMR_Q_CREATE_DOM_ALIAS * q_u,
4488 POLICY_HND *hnd, const char *acct_desc)
4490 DEBUG(5, ("init_samr_q_create_dom_alias\n"));
4492 q_u->dom_pol = *hnd;
4494 init_unistr2(&q_u->uni_acct_desc, acct_desc, UNI_FLAGS_NONE);
4495 init_uni_hdr(&q_u->hdr_acct_desc, &q_u->uni_acct_desc);
4497 q_u->access_mask = MAXIMUM_ALLOWED_ACCESS;
4500 /*******************************************************************
4501 reads or writes a structure.
4502 ********************************************************************/
4504 BOOL samr_io_q_create_dom_alias(const char *desc, SAMR_Q_CREATE_DOM_ALIAS * q_u,
4505 prs_struct *ps, int depth)
4510 prs_debug(ps, depth, desc, "samr_io_q_create_dom_alias");
4516 if(!smb_io_pol_hnd("dom_pol", &q_u->dom_pol, ps, depth))
4519 if(!smb_io_unihdr("hdr_acct_desc", &q_u->hdr_acct_desc, ps, depth))
4521 if(!smb_io_unistr2("uni_acct_desc", &q_u->uni_acct_desc,
4522 q_u->hdr_acct_desc.buffer, ps, depth))
4527 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
4533 /*******************************************************************
4534 reads or writes a structure.
4535 ********************************************************************/
4537 BOOL samr_io_r_create_dom_alias(const char *desc, SAMR_R_CREATE_DOM_ALIAS * r_u,
4538 prs_struct *ps, int depth)
4543 prs_debug(ps, depth, desc, "samr_io_r_create_dom_alias");
4549 if(!smb_io_pol_hnd("alias_pol", &r_u->alias_pol, ps, depth))
4552 if(!prs_uint32("rid", ps, depth, &r_u->rid))
4555 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4561 /*******************************************************************
4562 inits a SAMR_Q_ADD_ALIASMEM structure.
4563 ********************************************************************/
4565 void init_samr_q_add_aliasmem(SAMR_Q_ADD_ALIASMEM * q_u, POLICY_HND *hnd,
4568 DEBUG(5, ("init_samr_q_add_aliasmem\n"));
4570 q_u->alias_pol = *hnd;
4571 init_dom_sid2(&q_u->sid, sid);
4574 /*******************************************************************
4575 reads or writes a structure.
4576 ********************************************************************/
4578 BOOL samr_io_q_add_aliasmem(const char *desc, SAMR_Q_ADD_ALIASMEM * q_u,
4579 prs_struct *ps, int depth)
4584 prs_debug(ps, depth, desc, "samr_io_q_add_aliasmem");
4590 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4592 if(!smb_io_dom_sid2("sid ", &q_u->sid, ps, depth))
4598 /*******************************************************************
4599 reads or writes a structure.
4600 ********************************************************************/
4602 BOOL samr_io_r_add_aliasmem(const char *desc, SAMR_R_ADD_ALIASMEM * r_u,
4603 prs_struct *ps, int depth)
4608 prs_debug(ps, depth, desc, "samr_io_r_add_aliasmem");
4614 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4620 /*******************************************************************
4621 inits a SAMR_Q_DEL_ALIASMEM structure.
4622 ********************************************************************/
4624 void init_samr_q_del_aliasmem(SAMR_Q_DEL_ALIASMEM * q_u, POLICY_HND *hnd,
4627 DEBUG(5, ("init_samr_q_del_aliasmem\n"));
4629 q_u->alias_pol = *hnd;
4630 init_dom_sid2(&q_u->sid, sid);
4633 /*******************************************************************
4634 reads or writes a structure.
4635 ********************************************************************/
4637 BOOL samr_io_q_del_aliasmem(const char *desc, SAMR_Q_DEL_ALIASMEM * q_u,
4638 prs_struct *ps, int depth)
4643 prs_debug(ps, depth, desc, "samr_io_q_del_aliasmem");
4649 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4651 if(!smb_io_dom_sid2("sid ", &q_u->sid, ps, depth))
4657 /*******************************************************************
4658 reads or writes a structure.
4659 ********************************************************************/
4661 BOOL samr_io_r_del_aliasmem(const char *desc, SAMR_R_DEL_ALIASMEM * r_u,
4662 prs_struct *ps, int depth)
4667 prs_debug(ps, depth, desc, "samr_io_r_del_aliasmem");
4673 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4679 /*******************************************************************
4680 inits a SAMR_Q_DELETE_DOM_ALIAS structure.
4681 ********************************************************************/
4683 void init_samr_q_delete_dom_alias(SAMR_Q_DELETE_DOM_ALIAS * q_c,
4686 DEBUG(5, ("init_samr_q_delete_dom_alias\n"));
4688 q_c->alias_pol = *hnd;
4691 /*******************************************************************
4692 reads or writes a structure.
4693 ********************************************************************/
4695 BOOL samr_io_q_delete_dom_alias(const char *desc, SAMR_Q_DELETE_DOM_ALIAS * q_u,
4696 prs_struct *ps, int depth)
4701 prs_debug(ps, depth, desc, "samr_io_q_delete_dom_alias");
4707 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4713 /*******************************************************************
4714 inits a SAMR_R_DELETE_DOM_ALIAS structure.
4715 ********************************************************************/
4717 void init_samr_r_delete_dom_alias(SAMR_R_DELETE_DOM_ALIAS * r_u,
4720 DEBUG(5, ("init_samr_r_delete_dom_alias\n"));
4722 r_u->status = status;
4725 /*******************************************************************
4726 reads or writes a structure.
4727 ********************************************************************/
4729 BOOL samr_io_r_delete_dom_alias(const char *desc, SAMR_R_DELETE_DOM_ALIAS * r_u,
4730 prs_struct *ps, int depth)
4735 prs_debug(ps, depth, desc, "samr_io_r_delete_dom_alias");
4741 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
4744 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4750 /*******************************************************************
4751 inits a SAMR_Q_QUERY_ALIASMEM structure.
4752 ********************************************************************/
4754 void init_samr_q_query_aliasmem(SAMR_Q_QUERY_ALIASMEM * q_c,
4757 DEBUG(5, ("init_samr_q_query_aliasmem\n"));
4759 q_c->alias_pol = *hnd;
4762 /*******************************************************************
4763 reads or writes a structure.
4764 ********************************************************************/
4766 BOOL samr_io_q_query_aliasmem(const char *desc, SAMR_Q_QUERY_ALIASMEM * q_u,
4767 prs_struct *ps, int depth)
4772 prs_debug(ps, depth, desc, "samr_io_q_query_aliasmem");
4778 if(!smb_io_pol_hnd("alias_pol", &q_u->alias_pol, ps, depth))
4784 /*******************************************************************
4785 inits a SAMR_R_QUERY_ALIASMEM structure.
4786 ********************************************************************/
4788 void init_samr_r_query_aliasmem(SAMR_R_QUERY_ALIASMEM * r_u,
4789 uint32 num_sids, DOM_SID2 * sid,
4792 DEBUG(5, ("init_samr_r_query_aliasmem\n"));
4794 if (NT_STATUS_IS_OK(status)) {
4795 r_u->num_sids = num_sids;
4796 r_u->ptr = (num_sids != 0) ? 1 : 0;
4797 r_u->num_sids1 = num_sids;
4805 r_u->status = status;
4808 /*******************************************************************
4809 reads or writes a structure.
4810 ********************************************************************/
4812 BOOL samr_io_r_query_aliasmem(const char *desc, SAMR_R_QUERY_ALIASMEM * r_u,
4813 prs_struct *ps, int depth)
4820 prs_debug(ps, depth, desc, "samr_io_r_query_aliasmem");
4826 if(!prs_uint32("num_sids ", ps, depth, &r_u->num_sids))
4828 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
4831 if (r_u->ptr != 0 && r_u->num_sids != 0) {
4832 uint32 *ptr_sid = NULL;
4834 if(!prs_uint32("num_sids1", ps, depth, &r_u->num_sids1))
4837 ptr_sid = TALLOC_ARRAY(ps->mem_ctx, uint32, r_u->num_sids1);
4842 for (i = 0; i < r_u->num_sids1; i++) {
4844 if(!prs_uint32("ptr_sid", ps, depth, &ptr_sid[i]))
4848 if (UNMARSHALLING(ps)) {
4849 r_u->sid = TALLOC_ARRAY(ps->mem_ctx, DOM_SID2, r_u->num_sids1);
4852 for (i = 0; i < r_u->num_sids1; i++) {
4853 if (ptr_sid[i] != 0) {
4854 if(!smb_io_dom_sid2("sid", &r_u->sid[i], ps, depth))
4862 if(!prs_ntstatus("status", ps, depth, &r_u->status))
4868 /*******************************************************************
4869 inits a SAMR_Q_LOOKUP_NAMES structure.
4870 ********************************************************************/
4872 NTSTATUS init_samr_q_lookup_names(TALLOC_CTX *ctx, SAMR_Q_LOOKUP_NAMES * q_u,
4873 POLICY_HND *pol, uint32 flags,
4874 uint32 num_names, const char **name)
4878 DEBUG(5, ("init_samr_q_lookup_names\n"));
4882 q_u->num_names1 = num_names;
4885 q_u->num_names2 = num_names;
4887 if (!(q_u->hdr_name = TALLOC_ZERO_ARRAY(ctx, UNIHDR, num_names)))
4888 return NT_STATUS_NO_MEMORY;
4890 if (!(q_u->uni_name = TALLOC_ZERO_ARRAY(ctx, UNISTR2, num_names)))
4891 return NT_STATUS_NO_MEMORY;
4893 for (i = 0; i < num_names; i++) {
4894 init_unistr2(&q_u->uni_name[i], name[i], UNI_FLAGS_NONE); /* unicode string for machine account */
4895 init_uni_hdr(&q_u->hdr_name[i], &q_u->uni_name[i]); /* unicode header for user_name */
4898 return NT_STATUS_OK;
4901 /*******************************************************************
4902 reads or writes a structure.
4903 ********************************************************************/
4905 BOOL samr_io_q_lookup_names(const char *desc, SAMR_Q_LOOKUP_NAMES * q_u,
4906 prs_struct *ps, int depth)
4913 prs_debug(ps, depth, desc, "samr_io_q_lookup_names");
4916 if (UNMARSHALLING(ps))
4922 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
4925 if(!prs_uint32("num_names1", ps, depth, &q_u->num_names1))
4927 if(!prs_uint32("flags ", ps, depth, &q_u->flags))
4929 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
4931 if(!prs_uint32("num_names2", ps, depth, &q_u->num_names2))
4934 if (UNMARSHALLING(ps) && (q_u->num_names2 != 0)) {
4935 q_u->hdr_name = PRS_ALLOC_MEM(ps, UNIHDR, q_u->num_names2);
4936 q_u->uni_name = PRS_ALLOC_MEM(ps, UNISTR2, q_u->num_names2);
4937 if (!q_u->hdr_name || !q_u->uni_name)
4941 for (i = 0; i < q_u->num_names2; i++) {
4942 if(!smb_io_unihdr("", &q_u->hdr_name[i], ps, depth))
4946 for (i = 0; i < q_u->num_names2; i++) {
4947 if(!smb_io_unistr2("", &q_u->uni_name[i], q_u->hdr_name[i].buffer, ps, depth))
4954 /*******************************************************************
4955 inits a SAMR_R_LOOKUP_NAMES structure.
4956 ********************************************************************/
4958 NTSTATUS init_samr_r_lookup_names(TALLOC_CTX *ctx, SAMR_R_LOOKUP_NAMES * r_u,
4960 uint32 *rid, enum lsa_SidType *type,
4963 DEBUG(5, ("init_samr_r_lookup_names\n"));
4965 if (NT_STATUS_IS_OK(status) && (num_rids != 0)) {
4968 r_u->num_types1 = num_rids;
4970 r_u->num_types2 = num_rids;
4972 r_u->num_rids1 = num_rids;
4974 r_u->num_rids2 = num_rids;
4976 if (!(r_u->rids = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids)))
4977 return NT_STATUS_NO_MEMORY;
4978 if (!(r_u->types = TALLOC_ZERO_ARRAY(ctx, uint32, num_rids)))
4979 return NT_STATUS_NO_MEMORY;
4981 if (!r_u->rids || !r_u->types)
4984 for (i = 0; i < num_rids; i++) {
4985 r_u->rids[i] = rid[i];
4986 r_u->types[i] = type[i];
4991 r_u->num_types1 = 0;
4993 r_u->num_types2 = 0;
5003 r_u->status = status;
5005 return NT_STATUS_OK;
5008 /*******************************************************************
5009 reads or writes a structure.
5010 ********************************************************************/
5012 BOOL samr_io_r_lookup_names(const char *desc, SAMR_R_LOOKUP_NAMES * r_u,
5013 prs_struct *ps, int depth)
5021 prs_debug(ps, depth, desc, "samr_io_r_lookup_names");
5024 if (UNMARSHALLING(ps))
5030 if(!prs_uint32("num_rids1", ps, depth, &r_u->num_rids1))
5032 if(!prs_uint32("ptr_rids ", ps, depth, &r_u->ptr_rids))
5035 if (r_u->ptr_rids != 0) {
5036 if(!prs_uint32("num_rids2", ps, depth, &r_u->num_rids2))
5039 if (r_u->num_rids2 != r_u->num_rids1) {
5044 if (UNMARSHALLING(ps))
5045 r_u->rids = PRS_ALLOC_MEM(ps, uint32, r_u->num_rids2);
5048 DEBUG(0, ("NULL rids in samr_io_r_lookup_names\n"));
5052 for (i = 0; i < r_u->num_rids2; i++) {
5053 slprintf(tmp, sizeof(tmp) - 1, "rid[%02d] ", i);
5054 if(!prs_uint32(tmp, ps, depth, &r_u->rids[i]))
5059 if(!prs_uint32("num_types1", ps, depth, &r_u->num_types1))
5061 if(!prs_uint32("ptr_types ", ps, depth, &r_u->ptr_types))
5064 if (r_u->ptr_types != 0) {
5065 if(!prs_uint32("num_types2", ps, depth, &r_u->num_types2))
5068 if (r_u->num_types2 != r_u->num_types1) {
5073 if (UNMARSHALLING(ps))
5074 r_u->types = PRS_ALLOC_MEM(ps, uint32, r_u->num_types2);
5077 DEBUG(0, ("NULL types in samr_io_r_lookup_names\n"));
5081 for (i = 0; i < r_u->num_types2; i++) {
5082 slprintf(tmp, sizeof(tmp) - 1, "type[%02d] ", i);
5083 if(!prs_uint32(tmp, ps, depth, &r_u->types[i]))
5088 if(!prs_ntstatus("status", ps, depth, &r_u->status))
5094 /*******************************************************************
5095 inits a SAMR_Q_DELETE_DOM_USER structure.
5096 ********************************************************************/
5098 void init_samr_q_delete_dom_user(SAMR_Q_DELETE_DOM_USER * q_c,
5101 DEBUG(5, ("init_samr_q_delete_dom_user\n"));
5103 q_c->user_pol = *hnd;
5106 /*******************************************************************
5107 reads or writes a structure.
5108 ********************************************************************/
5110 BOOL samr_io_q_delete_dom_user(const char *desc, SAMR_Q_DELETE_DOM_USER * q_u,
5111 prs_struct *ps, int depth)
5116 prs_debug(ps, depth, desc, "samr_io_q_delete_dom_user");
5122 if(!smb_io_pol_hnd("user_pol", &q_u->user_pol, ps, depth))
5128 /*******************************************************************
5129 reads or writes a structure.
5130 ********************************************************************/
5132 BOOL samr_io_r_delete_dom_user(const char *desc, SAMR_R_DELETE_DOM_USER * r_u,
5133 prs_struct *ps, int depth)
5138 prs_debug(ps, depth, desc, "samr_io_r_delete_dom_user");
5144 if(!smb_io_pol_hnd("pol", &r_u->pol, ps, depth))
5146 if(!prs_ntstatus("status", ps, depth, &r_u->status))
5152 /*******************************************************************
5153 reads or writes a structure.
5154 ********************************************************************/
5156 void init_samr_q_open_user(SAMR_Q_OPEN_USER * q_u,
5158 uint32 access_mask, uint32 rid)
5160 DEBUG(5, ("samr_init_samr_q_open_user\n"));
5162 q_u->domain_pol = *pol;
5163 q_u->access_mask = access_mask;
5164 q_u->user_rid = rid;
5167 /*******************************************************************
5168 reads or writes a structure.
5169 ********************************************************************/
5171 BOOL samr_io_q_open_user(const char *desc, SAMR_Q_OPEN_USER * q_u,
5172 prs_struct *ps, int depth)
5177 prs_debug(ps, depth, desc, "samr_io_q_open_user");
5183 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
5186 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
5188 if(!prs_uint32("user_rid ", ps, depth, &q_u->user_rid))
5194 /*******************************************************************
5195 reads or writes a structure.
5196 ********************************************************************/
5198 BOOL samr_io_r_open_user(const char *desc, SAMR_R_OPEN_USER * r_u,
5199 prs_struct *ps, int depth)
5204 prs_debug(ps, depth, desc, "samr_io_r_open_user");
5210 if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
5213 if(!prs_ntstatus("status", ps, depth, &r_u->status))
5220 /*******************************************************************
5221 reads or writes a structure.
5222 ********************************************************************/
5224 void init_samr_q_create_user(SAMR_Q_CREATE_USER * q_u,
5227 uint32 acb_info, uint32 access_mask)
5229 DEBUG(5, ("samr_init_samr_q_create_user\n"));
5231 q_u->domain_pol = *pol;
5233 init_unistr2(&q_u->uni_name, name, UNI_FLAGS_NONE);
5234 init_uni_hdr(&q_u->hdr_name, &q_u->uni_name);
5236 q_u->acb_info = acb_info;
5237 q_u->access_mask = access_mask;
5240 /*******************************************************************
5241 reads or writes a structure.
5242 ********************************************************************/
5244 BOOL samr_io_q_create_user(const char *desc, SAMR_Q_CREATE_USER * q_u,
5245 prs_struct *ps, int depth)
5250 prs_debug(ps, depth, desc, "samr_io_q_create_user");
5256 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
5259 if(!smb_io_unihdr("hdr_name", &q_u->hdr_name, ps, depth))
5261 if(!smb_io_unistr2("uni_name", &q_u->uni_name, q_u->hdr_name.buffer, ps, depth))
5266 if(!prs_uint32("acb_info ", ps, depth, &q_u->acb_info))
5268 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
5274 /*******************************************************************
5275 reads or writes a structure.
5276 ********************************************************************/
5278 BOOL samr_io_r_create_user(const char *desc, SAMR_R_CREATE_USER * r_u,
5279 prs_struct *ps, int depth)
5284 prs_debug(ps, depth, desc, "samr_io_r_create_user");
5290 if(!smb_io_pol_hnd("user_pol", &r_u->user_pol, ps, depth))
5293 if(!prs_uint32("access_granted", ps, depth, &r_u->access_granted))
5295 if(!prs_uint32("user_rid ", ps, depth, &r_u->user_rid))
5297 if(!prs_ntstatus("status", ps, depth, &r_u->status))
5303 /*******************************************************************
5304 inits a SAMR_Q_QUERY_USERINFO structure.
5305 ********************************************************************/
5307 void init_samr_q_query_userinfo(SAMR_Q_QUERY_USERINFO * q_u,
5308 const POLICY_HND *hnd, uint16 switch_value)
5310 DEBUG(5, ("init_samr_q_query_userinfo\n"));
5313 q_u->switch_value = switch_value;
5316 /*******************************************************************
5317 reads or writes a structure.
5318 ********************************************************************/
5320 BOOL samr_io_q_query_userinfo(const char *desc, SAMR_Q_QUERY_USERINFO * q_u,
5321 prs_struct *ps, int depth)
5326 prs_debug(ps, depth, desc, "samr_io_q_query_userinfo");
5332 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
5335 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value)) /* 0x0015 or 0x0011 */
5341 /*******************************************************************
5342 reads or writes a LOGON_HRS structure.
5343 ********************************************************************/
5345 static BOOL sam_io_logon_hrs(const char *desc, LOGON_HRS * hrs,
5346 prs_struct *ps, int depth)
5351 prs_debug(ps, depth, desc, "sam_io_logon_hrs");
5357 if(!prs_uint32("maxlen", ps, depth, &hrs->max_len))
5360 if(!prs_uint32("offset", ps, depth, &hrs->offset))
5363 if(!prs_uint32("len ", ps, depth, &hrs->len))
5366 if (hrs->len > sizeof(hrs->hours)) {
5367 DEBUG(3, ("sam_io_logon_hrs: truncating length from %d\n", hrs->len));
5368 hrs->len = sizeof(hrs->hours);
5371 if(!prs_uint8s(False, "hours", ps, depth, hrs->hours, hrs->len))
5377 /*******************************************************************
5378 inits a SAM_USER_INFO_18 structure.
5379 ********************************************************************/
5381 void init_sam_user_info18(SAM_USER_INFO_18 * usr,
5382 const uint8 lm_pwd[16], const uint8 nt_pwd[16])
5384 DEBUG(5, ("init_sam_user_info18\n"));
5386 usr->lm_pwd_active =
5387 memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd)) ? 1 : 0;
5388 usr->nt_pwd_active =
5389 memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd)) ? 1 : 0;
5392 /*******************************************************************
5393 reads or writes a structure.
5394 ********************************************************************/
5396 static BOOL sam_io_user_info18(const char *desc, SAM_USER_INFO_18 * u,
5397 prs_struct *ps, int depth)
5402 prs_debug(ps, depth, desc, "samr_io_r_user_info18");
5408 if(!prs_uint8s(False, "lm_pwd", ps, depth, u->lm_pwd, sizeof(u->lm_pwd)))
5410 if(!prs_uint8s(False, "nt_pwd", ps, depth, u->nt_pwd, sizeof(u->nt_pwd)))
5413 if(!prs_uint8("lm_pwd_active", ps, depth, &u->lm_pwd_active))
5415 if(!prs_uint8("nt_pwd_active", ps, depth, &u->nt_pwd_active))
5421 /*******************************************************************
5422 inits a SAM_USER_INFO_7 structure.
5423 ********************************************************************/
5425 void init_sam_user_info7(SAM_USER_INFO_7 * usr, const char *name)
5427 DEBUG(5, ("init_sam_user_info7\n"));
5429 init_unistr2(&usr->uni_name, name, UNI_FLAGS_NONE); /* unicode string for name */
5430 init_uni_hdr(&usr->hdr_name, &usr->uni_name); /* unicode header for name */
5434 /*******************************************************************
5435 reads or writes a structure.
5436 ********************************************************************/
5438 static BOOL sam_io_user_info7(const char *desc, SAM_USER_INFO_7 * usr,
5439 prs_struct *ps, int depth)
5444 prs_debug(ps, depth, desc, "samr_io_r_user_info7");
5450 if(!smb_io_unihdr("unihdr", &usr->hdr_name, ps, depth))
5453 if(!smb_io_unistr2("unistr2", &usr->uni_name, True, ps, depth))
5459 /*******************************************************************
5460 inits a SAM_USER_INFO_9 structure.
5461 ********************************************************************/
5463 void init_sam_user_info9(SAM_USER_INFO_9 * usr, uint32 rid_group)
5465 DEBUG(5, ("init_sam_user_info9\n"));
5467 usr->rid_group = rid_group;
5470 /*******************************************************************
5471 reads or writes a structure.
5472 ********************************************************************/
5474 static BOOL sam_io_user_info9(const char *desc, SAM_USER_INFO_9 * usr,
5475 prs_struct *ps, int depth)
5480 prs_debug(ps, depth, desc, "samr_io_r_user_info9");
5486 if(!prs_uint32("rid_group", ps, depth, &usr->rid_group))
5492 /*******************************************************************
5493 inits a SAM_USER_INFO_16 structure.
5494 ********************************************************************/
5496 void init_sam_user_info16(SAM_USER_INFO_16 * usr, uint32 acb_info)
5498 DEBUG(5, ("init_sam_user_info16\n"));
5500 usr->acb_info = acb_info;
5503 /*******************************************************************
5504 reads or writes a structure.
5505 ********************************************************************/
5507 static BOOL sam_io_user_info16(const char *desc, SAM_USER_INFO_16 * usr,
5508 prs_struct *ps, int depth)
5513 prs_debug(ps, depth, desc, "samr_io_r_user_info16");
5519 if(!prs_uint32("acb_info", ps, depth, &usr->acb_info))
5525 /*******************************************************************
5526 inits a SAM_USER_INFO_17 structure.
5527 ********************************************************************/
5529 void init_sam_user_info17(SAM_USER_INFO_17 * usr,
5532 uint32 rid_user, uint32 rid_group, uint16 acct_ctrl)
5534 DEBUG(5, ("init_sam_user_info17\n"));
5536 memcpy(&usr->expiry, expiry, sizeof(usr->expiry)); /* expiry time or something? */
5537 ZERO_STRUCT(usr->padding_1); /* 0 - padding 24 bytes */
5539 usr->padding_2 = 0; /* 0 - padding 4 bytes */
5541 usr->ptr_1 = 1; /* pointer */
5542 ZERO_STRUCT(usr->padding_3); /* 0 - padding 32 bytes */
5543 usr->padding_4 = 0; /* 0 - padding 4 bytes */
5545 usr->ptr_2 = 1; /* pointer */
5546 usr->padding_5 = 0; /* 0 - padding 4 bytes */
5548 usr->ptr_3 = 1; /* pointer */
5549 ZERO_STRUCT(usr->padding_6); /* 0 - padding 32 bytes */
5551 usr->rid_user = rid_user;
5552 usr->rid_group = rid_group;
5554 usr->acct_ctrl = acct_ctrl;
5555 usr->unknown_3 = 0x0000;
5557 usr->unknown_4 = 0x003f; /* 0x003f - 16 bit unknown */
5558 usr->unknown_5 = 0x003c; /* 0x003c - 16 bit unknown */
5560 ZERO_STRUCT(usr->padding_7); /* 0 - padding 16 bytes */
5561 usr->padding_8 = 0; /* 0 - padding 4 bytes */
5563 init_unistr2(&usr->uni_mach_acct, mach_acct, UNI_FLAGS_NONE); /* unicode string for machine account */
5564 init_uni_hdr(&usr->hdr_mach_acct, &usr->uni_mach_acct); /* unicode header for machine account */
5567 /*******************************************************************
5568 reads or writes a structure.
5569 ********************************************************************/
5571 static BOOL sam_io_user_info17(const char *desc, SAM_USER_INFO_17 * usr,
5572 prs_struct *ps, int depth)
5577 prs_debug(ps, depth, desc, "samr_io_r_unknown_17");
5583 if(!prs_uint8s(False, "padding_0", ps, depth, usr->padding_0, sizeof(usr->padding_0)))
5586 if(!smb_io_time("time", &usr->expiry, ps, depth))
5589 if(!prs_uint8s(False, "padding_1", ps, depth, usr->padding_1, sizeof(usr->padding_1)))
5592 if(!smb_io_unihdr("unihdr", &usr->hdr_mach_acct, ps, depth))
5595 if(!prs_uint32("padding_2", ps, depth, &usr->padding_2))
5598 if(!prs_uint32("ptr_1 ", ps, depth, &usr->ptr_1))
5600 if(!prs_uint8s(False, "padding_3", ps, depth, usr->padding_3, sizeof(usr->padding_3)))
5603 if(!prs_uint32("padding_4", ps, depth, &usr->padding_4))
5606 if(!prs_uint32("ptr_2 ", ps, depth, &usr->ptr_2))
5608 if(!prs_uint32("padding_5", ps, depth, &usr->padding_5))
5611 if(!prs_uint32("ptr_3 ", ps, depth, &usr->ptr_3))
5613 if(!prs_uint8s(False, "padding_6", ps, depth, usr->padding_6,sizeof(usr->padding_6)))
5616 if(!prs_uint32("rid_user ", ps, depth, &usr->rid_user))
5618 if(!prs_uint32("rid_group", ps, depth, &usr->rid_group))
5620 if(!prs_uint16("acct_ctrl", ps, depth, &usr->acct_ctrl))
5622 if(!prs_uint16("unknown_3", ps, depth, &usr->unknown_3))
5624 if(!prs_uint16("unknown_4", ps, depth, &usr->unknown_4))
5626 if(!prs_uint16("unknown_5", ps, depth, &usr->unknown_5))
5629 if(!prs_uint8s(False, "padding_7", ps, depth, usr->padding_7, sizeof(usr->padding_7)))
5632 if(!prs_uint32("padding_8", ps, depth, &(usr->padding_8)))
5635 if(!smb_io_unistr2("unistr2", &usr->uni_mach_acct, True, ps, depth))
5641 if(!prs_uint8s(False, "padding_9", ps, depth, usr->padding_9, sizeof(usr->padding_9)))
5647 /*************************************************************************
5649 *************************************************************************/
5651 void init_sam_user_info24(SAM_USER_INFO_24 * usr, char newpass[516],
5654 DEBUG(10, ("init_sam_user_info24:\n"));
5655 memcpy(usr->pass, newpass, sizeof(usr->pass));
5656 usr->pw_len = pw_len;
5659 /*******************************************************************
5660 reads or writes a structure.
5661 ********************************************************************/
5663 static BOOL sam_io_user_info24(const char *desc, SAM_USER_INFO_24 * usr,
5664 prs_struct *ps, int depth)
5669 prs_debug(ps, depth, desc, "sam_io_user_info24");
5675 if(!prs_uint8s(False, "password", ps, depth, usr->pass,
5679 if (MARSHALLING(ps) && (usr->pw_len != 0)) {
5680 if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5682 } else if (UNMARSHALLING(ps)) {
5683 if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5690 /*******************************************************************
5691 reads or writes a structure.
5692 ********************************************************************/
5694 static BOOL sam_io_user_info26(const char *desc, SAM_USER_INFO_26 * usr,
5695 prs_struct *ps, int depth)
5700 prs_debug(ps, depth, desc, "sam_io_user_info26");
5706 if(!prs_uint8s(False, "password", ps, depth, usr->pass,
5710 if (!prs_uint8("pw_len", ps, depth, &usr->pw_len))
5717 /*************************************************************************
5718 init_sam_user_info23
5720 unknown_6 = 0x0000 04ec
5722 *************************************************************************/
5724 void init_sam_user_info23W(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5725 NTTIME * logoff_time, /* all zeros */
5726 NTTIME * kickoff_time, /* all zeros */
5727 NTTIME * pass_last_set_time, /* all zeros */
5728 NTTIME * pass_can_change_time, /* all zeros */
5729 NTTIME * pass_must_change_time, /* all zeros */
5740 uint32 user_rid, /* 0x0000 0000 */
5743 uint32 fields_present,
5746 uint16 bad_password_count,
5750 usr->logon_time = *logon_time; /* all zeros */
5751 usr->logoff_time = *logoff_time; /* all zeros */
5752 usr->kickoff_time = *kickoff_time; /* all zeros */
5753 usr->pass_last_set_time = *pass_last_set_time; /* all zeros */
5754 usr->pass_can_change_time = *pass_can_change_time; /* all zeros */
5755 usr->pass_must_change_time = *pass_must_change_time; /* all zeros */
5757 ZERO_STRUCT(usr->nt_pwd);
5758 ZERO_STRUCT(usr->lm_pwd);
5760 usr->user_rid = user_rid; /* 0x0000 0000 */
5761 usr->group_rid = group_rid;
5762 usr->acb_info = acb_info;
5763 usr->fields_present = fields_present; /* 09f8 27fa */
5765 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5766 usr->ptr_logon_hrs = hrs ? 1 : 0;
5768 if (nt_time_is_zero(pass_must_change_time)) {
5769 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5771 usr->passmustchange=0;
5774 ZERO_STRUCT(usr->padding1);
5775 ZERO_STRUCT(usr->padding2);
5777 usr->bad_password_count = bad_password_count;
5778 usr->logon_count = logon_count;
5780 memcpy(usr->pass, newpass, sizeof(usr->pass));
5782 copy_unistr2(&usr->uni_user_name, user_name);
5783 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5785 copy_unistr2(&usr->uni_full_name, full_name);
5786 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5788 copy_unistr2(&usr->uni_home_dir, home_dir);
5789 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5791 copy_unistr2(&usr->uni_dir_drive, dir_drive);
5792 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5794 copy_unistr2(&usr->uni_logon_script, log_scr);
5795 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5797 copy_unistr2(&usr->uni_profile_path, prof_path);
5798 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5800 copy_unistr2(&usr->uni_acct_desc, desc);
5801 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5803 copy_unistr2(&usr->uni_workstations, wkstas);
5804 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5806 copy_unistr2(&usr->uni_comment, unk_str);
5807 init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
5809 copy_unistr2(&usr->uni_munged_dial, mung_dial);
5810 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5813 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5815 ZERO_STRUCT(usr->logon_hrs);
5819 /*************************************************************************
5820 init_sam_user_info23
5822 unknown_6 = 0x0000 04ec
5824 *************************************************************************/
5826 void init_sam_user_info23A(SAM_USER_INFO_23 * usr, NTTIME * logon_time, /* all zeros */
5827 NTTIME * logoff_time, /* all zeros */
5828 NTTIME * kickoff_time, /* all zeros */
5829 NTTIME * pass_last_set_time, /* all zeros */
5830 NTTIME * pass_can_change_time, /* all zeros */
5831 NTTIME * pass_must_change_time, /* all zeros */
5832 char *user_name, /* NULL */
5834 char *home_dir, char *dir_drive, char *log_scr,
5835 char *prof_path, const char *desc, char *wkstas,
5836 char *unk_str, char *mung_dial, uint32 user_rid, /* 0x0000 0000 */
5837 uint32 group_rid, uint32 acb_info,
5838 uint32 fields_present, uint16 logon_divs,
5839 LOGON_HRS * hrs, uint16 bad_password_count, uint16 logon_count,
5842 DATA_BLOB blob = base64_decode_data_blob(mung_dial);
5844 usr->logon_time = *logon_time; /* all zeros */
5845 usr->logoff_time = *logoff_time; /* all zeros */
5846 usr->kickoff_time = *kickoff_time; /* all zeros */
5847 usr->pass_last_set_time = *pass_last_set_time; /* all zeros */
5848 usr->pass_can_change_time = *pass_can_change_time; /* all zeros */
5849 usr->pass_must_change_time = *pass_must_change_time; /* all zeros */
5851 ZERO_STRUCT(usr->nt_pwd);
5852 ZERO_STRUCT(usr->lm_pwd);
5854 usr->user_rid = user_rid; /* 0x0000 0000 */
5855 usr->group_rid = group_rid;
5856 usr->acb_info = acb_info;
5857 usr->fields_present = fields_present; /* 09f8 27fa */
5859 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
5860 usr->ptr_logon_hrs = hrs ? 1 : 0;
5862 if (nt_time_is_zero(pass_must_change_time)) {
5863 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
5865 usr->passmustchange=0;
5868 ZERO_STRUCT(usr->padding1);
5869 ZERO_STRUCT(usr->padding2);
5871 usr->bad_password_count = bad_password_count;
5872 usr->logon_count = logon_count;
5874 memcpy(usr->pass, newpass, sizeof(usr->pass));
5876 init_unistr2(&usr->uni_user_name, user_name, UNI_FLAGS_NONE);
5877 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
5879 init_unistr2(&usr->uni_full_name, full_name, UNI_FLAGS_NONE);
5880 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
5882 init_unistr2(&usr->uni_home_dir, home_dir, UNI_FLAGS_NONE);
5883 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
5885 init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_FLAGS_NONE);
5886 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
5888 init_unistr2(&usr->uni_logon_script, log_scr, UNI_FLAGS_NONE);
5889 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
5891 init_unistr2(&usr->uni_profile_path, prof_path, UNI_FLAGS_NONE);
5892 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
5894 init_unistr2(&usr->uni_acct_desc, desc, UNI_FLAGS_NONE);
5895 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
5897 init_unistr2(&usr->uni_workstations, wkstas, UNI_FLAGS_NONE);
5898 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
5900 init_unistr2(&usr->uni_comment, unk_str, UNI_FLAGS_NONE);
5901 init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
5903 init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
5904 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
5906 data_blob_free(&blob);
5909 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
5911 ZERO_STRUCT(usr->logon_hrs);
5915 /*******************************************************************
5916 reads or writes a structure.
5917 ********************************************************************/
5919 static BOOL sam_io_user_info23(const char *desc, SAM_USER_INFO_23 * usr,
5920 prs_struct *ps, int depth)
5925 prs_debug(ps, depth, desc, "sam_io_user_info23");
5931 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
5933 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
5935 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
5937 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps, depth))
5939 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
5941 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
5944 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
5946 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
5948 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
5950 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
5952 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
5954 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
5956 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
5958 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
5960 if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth)) /* unknown string */
5962 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
5965 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
5967 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
5970 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
5972 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
5974 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
5977 if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
5979 if(!prs_uint16("logon_divs ", ps, depth, &usr->logon_divs)) /* logon divisions per week */
5983 if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
5986 if(!prs_uint16("bad_password_count ", ps, depth, &usr->bad_password_count))
5988 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count))
5991 if(!prs_uint8s(False, "padding1 ", ps, depth, usr->padding1, sizeof(usr->padding1)))
5993 if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
5995 if(!prs_uint8("padding2 ", ps, depth, &usr->padding2))
5999 if(!prs_uint8s(False, "password ", ps, depth, usr->pass, sizeof(usr->pass)))
6002 /* here begins pointed-to data */
6004 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
6007 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
6010 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
6013 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
6016 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
6019 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
6022 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth)) /* user desc unicode string */
6025 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth)) /* worksations user can log on from */
6028 if(!smb_io_unistr2("uni_comment ", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth)) /* unknown string */
6031 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
6034 /* ok, this is only guess-work (as usual) */
6035 if (usr->ptr_logon_hrs) {
6036 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6043 /*******************************************************************
6044 reads or writes a structure.
6045 NB. This structure is *definately* incorrect. It's my best guess
6046 currently for W2K SP2. The password field is encrypted in a different
6047 way than normal... And there are definately other problems. JRA.
6048 ********************************************************************/
6050 static BOOL sam_io_user_info25(const char *desc, SAM_USER_INFO_25 * usr, prs_struct *ps, int depth)
6055 prs_debug(ps, depth, desc, "sam_io_user_info25");
6061 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
6063 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
6065 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
6067 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps, depth))
6069 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps, depth))
6071 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
6074 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
6076 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
6078 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
6080 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
6082 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
6084 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
6086 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
6088 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
6090 if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth)) /* unknown string */
6092 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6095 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6097 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6100 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
6102 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
6104 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
6106 if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6109 if(!prs_uint32s(False, "unknown_5 ", ps, depth, usr->unknown_5, 5))
6112 if(!prs_uint8s(False, "password ", ps, depth, usr->pass, sizeof(usr->pass)))
6115 /* here begins pointed-to data */
6117 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name, usr->hdr_user_name.buffer, ps, depth)) /* username unicode string */
6120 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth)) /* user's full name unicode string */
6123 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth)) /* home directory unicode string */
6126 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth)) /* home directory drive unicode string */
6129 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth)) /* logon script unicode string */
6132 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth)) /* profile path unicode string */
6135 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth)) /* user desc unicode string */
6138 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth)) /* worksations user can log on from */
6141 if(!smb_io_unistr2("uni_comment ", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth)) /* unknown string */
6144 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial, usr->hdr_munged_dial.buffer, ps, depth))
6147 #if 0 /* JRA - unknown... */
6148 /* ok, this is only guess-work (as usual) */
6149 if (usr->ptr_logon_hrs) {
6150 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6159 /*************************************************************************
6160 init_sam_user_info21W
6162 unknown_6 = 0x0000 04ec
6164 *************************************************************************/
6166 void init_sam_user_info21W(SAM_USER_INFO_21 * usr,
6167 NTTIME * logon_time,
6168 NTTIME * logoff_time,
6169 NTTIME * kickoff_time,
6170 NTTIME * pass_last_set_time,
6171 NTTIME * pass_can_change_time,
6172 NTTIME * pass_must_change_time,
6188 uint32 fields_present,
6191 uint16 bad_password_count,
6194 usr->logon_time = *logon_time;
6195 usr->logoff_time = *logoff_time;
6196 usr->kickoff_time = *kickoff_time;
6197 usr->pass_last_set_time = *pass_last_set_time;
6198 usr->pass_can_change_time = *pass_can_change_time;
6199 usr->pass_must_change_time = *pass_must_change_time;
6201 memcpy(usr->lm_pwd, lm_pwd, sizeof(usr->lm_pwd));
6202 memcpy(usr->nt_pwd, nt_pwd, sizeof(usr->nt_pwd));
6204 usr->user_rid = user_rid;
6205 usr->group_rid = group_rid;
6206 usr->acb_info = acb_info;
6207 usr->fields_present = fields_present; /* 0x00ff ffff */
6209 usr->logon_divs = logon_divs; /* should be 168 (hours/week) */
6210 usr->ptr_logon_hrs = hrs ? 1 : 0;
6211 usr->bad_password_count = bad_password_count;
6212 usr->logon_count = logon_count;
6214 if (nt_time_is_zero(pass_must_change_time)) {
6215 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6217 usr->passmustchange=0;
6220 ZERO_STRUCT(usr->padding1);
6221 ZERO_STRUCT(usr->padding2);
6223 copy_unistr2(&usr->uni_user_name, user_name);
6224 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6226 copy_unistr2(&usr->uni_full_name, full_name);
6227 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6229 copy_unistr2(&usr->uni_home_dir, home_dir);
6230 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6232 copy_unistr2(&usr->uni_dir_drive, dir_drive);
6233 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6235 copy_unistr2(&usr->uni_logon_script, log_scr);
6236 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6238 copy_unistr2(&usr->uni_profile_path, prof_path);
6239 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6241 copy_unistr2(&usr->uni_acct_desc, desc);
6242 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6244 copy_unistr2(&usr->uni_workstations, wkstas);
6245 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6247 copy_unistr2(&usr->uni_comment, unk_str);
6248 init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
6250 copy_unistr2(&usr->uni_munged_dial, mung_dial);
6251 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6254 memcpy(&usr->logon_hrs, hrs, sizeof(usr->logon_hrs));
6256 ZERO_STRUCT(usr->logon_hrs);
6260 /*************************************************************************
6261 init_sam_user_info21
6263 unknown_6 = 0x0000 04ec
6265 *************************************************************************/
6267 NTSTATUS init_sam_user_info21A(SAM_USER_INFO_21 *usr, struct samu *pw, DOM_SID *domain_sid)
6269 NTTIME logon_time, logoff_time, kickoff_time,
6270 pass_last_set_time, pass_can_change_time,
6271 pass_must_change_time;
6273 time_t must_change_time;
6274 const char* user_name = pdb_get_username(pw);
6275 const char* full_name = pdb_get_fullname(pw);
6276 const char* home_dir = pdb_get_homedir(pw);
6277 const char* dir_drive = pdb_get_dir_drive(pw);
6278 const char* logon_script = pdb_get_logon_script(pw);
6279 const char* profile_path = pdb_get_profile_path(pw);
6280 const char* description = pdb_get_acct_desc(pw);
6281 const char* workstations = pdb_get_workstations(pw);
6282 const char* munged_dial = pdb_get_munged_dial(pw);
6283 DATA_BLOB munged_dial_blob;
6286 const DOM_SID *user_sid;
6289 const DOM_SID *group_sid;
6292 munged_dial_blob = base64_decode_data_blob(munged_dial);
6294 munged_dial_blob = data_blob(NULL, 0);
6297 /* Create NTTIME structs */
6298 unix_to_nt_time (&logon_time, pdb_get_logon_time(pw));
6299 unix_to_nt_time (&logoff_time, pdb_get_logoff_time(pw));
6300 unix_to_nt_time (&kickoff_time, pdb_get_kickoff_time(pw));
6301 unix_to_nt_time (&pass_last_set_time, pdb_get_pass_last_set_time(pw));
6302 unix_to_nt_time (&pass_can_change_time,pdb_get_pass_can_change_time(pw));
6303 must_change_time = pdb_get_pass_must_change_time(pw);
6304 if (must_change_time == get_time_t_max())
6305 unix_to_nt_time_abs(&pass_must_change_time, must_change_time);
6307 unix_to_nt_time(&pass_must_change_time, must_change_time);
6309 /* structure assignment */
6310 usr->logon_time = logon_time;
6311 usr->logoff_time = logoff_time;
6312 usr->kickoff_time = kickoff_time;
6313 usr->pass_last_set_time = pass_last_set_time;
6314 usr->pass_can_change_time = pass_can_change_time;
6315 usr->pass_must_change_time = pass_must_change_time;
6317 ZERO_STRUCT(usr->nt_pwd);
6318 ZERO_STRUCT(usr->lm_pwd);
6320 user_sid = pdb_get_user_sid(pw);
6322 if (!sid_peek_check_rid(domain_sid, user_sid, &user_rid)) {
6323 fstring user_sid_string;
6324 fstring domain_sid_string;
6325 DEBUG(0, ("init_sam_user_info_21A: User %s has SID %s, \nwhich conflicts with "
6326 "the domain sid %s. Failing operation.\n",
6328 sid_to_string(user_sid_string, user_sid),
6329 sid_to_string(domain_sid_string, domain_sid)));
6330 data_blob_free(&munged_dial_blob);
6331 return NT_STATUS_UNSUCCESSFUL;
6335 group_sid = pdb_get_group_sid(pw);
6338 if (!sid_peek_check_rid(domain_sid, group_sid, &group_rid)) {
6339 fstring group_sid_string;
6340 fstring domain_sid_string;
6341 DEBUG(0, ("init_sam_user_info_21A: User %s has Primary Group SID %s, \n"
6342 "which conflicts with the domain sid %s. Failing operation.\n",
6344 sid_to_string(group_sid_string, group_sid),
6345 sid_to_string(domain_sid_string, domain_sid)));
6346 data_blob_free(&munged_dial_blob);
6347 return NT_STATUS_UNSUCCESSFUL;
6350 usr->user_rid = user_rid;
6351 usr->group_rid = group_rid;
6352 usr->acb_info = pdb_get_acct_ctrl(pw);
6355 Look at a user on a real NT4 PDC with usrmgr, press
6356 'ok'. Then you will see that fields_present is set to
6357 0x08f827fa. Look at the user immediately after that again,
6358 and you will see that 0x00fffff is returned. This solves
6359 the problem that you get access denied after having looked
6363 usr->fields_present = pdb_build_fields_present(pw);
6365 usr->logon_divs = pdb_get_logon_divs(pw);
6366 usr->ptr_logon_hrs = pdb_get_hours(pw) ? 1 : 0;
6367 usr->bad_password_count = pdb_get_bad_password_count(pw);
6368 usr->logon_count = pdb_get_logon_count(pw);
6370 if (pdb_get_pass_must_change_time(pw) == 0) {
6371 usr->passmustchange=PASS_MUST_CHANGE_AT_NEXT_LOGON;
6373 usr->passmustchange=0;
6376 ZERO_STRUCT(usr->padding1);
6377 ZERO_STRUCT(usr->padding2);
6379 init_unistr2(&usr->uni_user_name, user_name, UNI_STR_TERMINATE);
6380 init_uni_hdr(&usr->hdr_user_name, &usr->uni_user_name);
6382 init_unistr2(&usr->uni_full_name, full_name, UNI_STR_TERMINATE);
6383 init_uni_hdr(&usr->hdr_full_name, &usr->uni_full_name);
6385 init_unistr2(&usr->uni_home_dir, home_dir, UNI_STR_TERMINATE);
6386 init_uni_hdr(&usr->hdr_home_dir, &usr->uni_home_dir);
6388 init_unistr2(&usr->uni_dir_drive, dir_drive, UNI_STR_TERMINATE);
6389 init_uni_hdr(&usr->hdr_dir_drive, &usr->uni_dir_drive);
6391 init_unistr2(&usr->uni_logon_script, logon_script, UNI_STR_TERMINATE);
6392 init_uni_hdr(&usr->hdr_logon_script, &usr->uni_logon_script);
6394 init_unistr2(&usr->uni_profile_path, profile_path, UNI_STR_TERMINATE);
6395 init_uni_hdr(&usr->hdr_profile_path, &usr->uni_profile_path);
6397 init_unistr2(&usr->uni_acct_desc, description, UNI_STR_TERMINATE);
6398 init_uni_hdr(&usr->hdr_acct_desc, &usr->uni_acct_desc);
6400 init_unistr2(&usr->uni_workstations, workstations, UNI_STR_TERMINATE);
6401 init_uni_hdr(&usr->hdr_workstations, &usr->uni_workstations);
6403 init_unistr2(&usr->uni_comment, NULL, UNI_STR_TERMINATE);
6404 init_uni_hdr(&usr->hdr_comment, &usr->uni_comment);
6406 init_unistr2_from_datablob(&usr->uni_munged_dial, &munged_dial_blob);
6407 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6408 data_blob_free(&munged_dial_blob);
6410 if (pdb_get_hours(pw)) {
6411 usr->logon_hrs.max_len = 1260;
6412 usr->logon_hrs.offset = 0;
6413 usr->logon_hrs.len = pdb_get_hours_len(pw);
6414 memcpy(&usr->logon_hrs.hours, pdb_get_hours(pw), MAX_HOURS_LEN);
6416 usr->logon_hrs.max_len = 1260;
6417 usr->logon_hrs.offset = 0;
6418 usr->logon_hrs.len = 0;
6419 memset(&usr->logon_hrs, 0xff, sizeof(usr->logon_hrs));
6422 return NT_STATUS_OK;
6425 /*******************************************************************
6426 reads or writes a structure.
6427 ********************************************************************/
6429 static BOOL sam_io_user_info21(const char *desc, SAM_USER_INFO_21 * usr,
6430 prs_struct *ps, int depth)
6435 prs_debug(ps, depth, desc, "sam_io_user_info21");
6441 if(!smb_io_time("logon_time ", &usr->logon_time, ps, depth))
6443 if(!smb_io_time("logoff_time ", &usr->logoff_time, ps, depth))
6445 if(!smb_io_time("pass_last_set_time ", &usr->pass_last_set_time, ps,depth))
6447 if(!smb_io_time("kickoff_time ", &usr->kickoff_time, ps, depth))
6449 if(!smb_io_time("pass_can_change_time ", &usr->pass_can_change_time, ps,depth))
6451 if(!smb_io_time("pass_must_change_time", &usr->pass_must_change_time, ps, depth))
6454 if(!smb_io_unihdr("hdr_user_name ", &usr->hdr_user_name, ps, depth)) /* username unicode string header */
6456 if(!smb_io_unihdr("hdr_full_name ", &usr->hdr_full_name, ps, depth)) /* user's full name unicode string header */
6458 if(!smb_io_unihdr("hdr_home_dir ", &usr->hdr_home_dir, ps, depth)) /* home directory unicode string header */
6460 if(!smb_io_unihdr("hdr_dir_drive ", &usr->hdr_dir_drive, ps, depth)) /* home directory drive */
6462 if(!smb_io_unihdr("hdr_logon_script", &usr->hdr_logon_script, ps, depth)) /* logon script unicode string header */
6464 if(!smb_io_unihdr("hdr_profile_path", &usr->hdr_profile_path, ps, depth)) /* profile path unicode string header */
6466 if(!smb_io_unihdr("hdr_acct_desc ", &usr->hdr_acct_desc, ps, depth)) /* account desc */
6468 if(!smb_io_unihdr("hdr_workstations", &usr->hdr_workstations, ps, depth)) /* wkstas user can log on from */
6470 if(!smb_io_unihdr("hdr_comment ", &usr->hdr_comment, ps, depth)) /* unknown string */
6472 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6475 if(!prs_uint8s(False, "lm_pwd ", ps, depth, usr->lm_pwd, sizeof(usr->lm_pwd)))
6477 if(!prs_uint8s(False, "nt_pwd ", ps, depth, usr->nt_pwd, sizeof(usr->nt_pwd)))
6480 if(!prs_uint32("user_rid ", ps, depth, &usr->user_rid)) /* User ID */
6482 if(!prs_uint32("group_rid ", ps, depth, &usr->group_rid)) /* Group ID */
6484 if(!prs_uint32("acb_info ", ps, depth, &usr->acb_info))
6487 if(!prs_uint32("fields_present ", ps, depth, &usr->fields_present))
6489 if(!prs_uint16("logon_divs ", ps, depth, &usr->logon_divs)) /* logon divisions per week */
6493 if(!prs_uint32("ptr_logon_hrs ", ps, depth, &usr->ptr_logon_hrs))
6496 if(!prs_uint16("bad_password_count ", ps, depth, &usr->bad_password_count))
6498 if(!prs_uint16("logon_count ", ps, depth, &usr->logon_count))
6501 if(!prs_uint8s(False, "padding1 ", ps, depth, usr->padding1, sizeof(usr->padding1)))
6503 if(!prs_uint8("passmustchange ", ps, depth, &usr->passmustchange))
6505 if(!prs_uint8("padding2 ", ps, depth, &usr->padding2))
6508 /* here begins pointed-to data */
6510 if(!smb_io_unistr2("uni_user_name ", &usr->uni_user_name,usr->hdr_user_name.buffer, ps, depth))
6512 if(!smb_io_unistr2("uni_full_name ", &usr->uni_full_name, usr->hdr_full_name.buffer, ps, depth))
6514 if(!smb_io_unistr2("uni_home_dir ", &usr->uni_home_dir, usr->hdr_home_dir.buffer, ps, depth))
6516 if(!smb_io_unistr2("uni_dir_drive ", &usr->uni_dir_drive, usr->hdr_dir_drive.buffer, ps, depth))
6518 if(!smb_io_unistr2("uni_logon_script", &usr->uni_logon_script, usr->hdr_logon_script.buffer, ps, depth))
6520 if(!smb_io_unistr2("uni_profile_path", &usr->uni_profile_path, usr->hdr_profile_path.buffer, ps, depth))
6522 if(!smb_io_unistr2("uni_acct_desc ", &usr->uni_acct_desc, usr->hdr_acct_desc.buffer, ps, depth))
6524 if(!smb_io_unistr2("uni_workstations", &usr->uni_workstations, usr->hdr_workstations.buffer, ps, depth))
6526 if(!smb_io_unistr2("uni_comment", &usr->uni_comment, usr->hdr_comment.buffer, ps, depth))
6528 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth))
6531 /* ok, this is only guess-work (as usual) */
6532 if (usr->ptr_logon_hrs) {
6533 if(!sam_io_logon_hrs("logon_hrs", &usr->logon_hrs, ps, depth))
6540 void init_sam_user_info20A(SAM_USER_INFO_20 *usr, struct samu *pw)
6542 const char *munged_dial = pdb_get_munged_dial(pw);
6546 blob = base64_decode_data_blob(munged_dial);
6548 blob = data_blob(NULL, 0);
6551 init_unistr2_from_datablob(&usr->uni_munged_dial, &blob);
6552 init_uni_hdr(&usr->hdr_munged_dial, &usr->uni_munged_dial);
6553 data_blob_free(&blob);
6556 /*******************************************************************
6557 reads or writes a structure.
6558 ********************************************************************/
6560 static BOOL sam_io_user_info20(const char *desc, SAM_USER_INFO_20 *usr,
6561 prs_struct *ps, int depth)
6566 prs_debug(ps, depth, desc, "sam_io_user_info20");
6572 if(!smb_io_unihdr("hdr_munged_dial ", &usr->hdr_munged_dial, ps, depth)) /* wkstas user can log on from */
6575 if(!smb_io_unistr2("uni_munged_dial ", &usr->uni_munged_dial,usr->hdr_munged_dial.buffer, ps, depth)) /* worksations user can log on from */
6581 /*******************************************************************
6582 inits a SAM_USERINFO_CTR structure.
6583 ********************************************************************/
6585 NTSTATUS make_samr_userinfo_ctr_usr21(TALLOC_CTX *ctx, SAM_USERINFO_CTR * ctr,
6586 uint16 switch_value,
6587 SAM_USER_INFO_21 * usr)
6589 DEBUG(5, ("make_samr_userinfo_ctr_usr21\n"));
6591 ctr->switch_value = switch_value;
6592 ctr->info.id = NULL;
6594 switch (switch_value) {
6596 ctr->info.id16 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_16);
6597 if (ctr->info.id16 == NULL)
6598 return NT_STATUS_NO_MEMORY;
6600 init_sam_user_info16(ctr->info.id16, usr->acb_info);
6603 /* whoops - got this wrong. i think. or don't understand what's happening. */
6607 info = (void *)&id11;
6609 expire.low = 0xffffffff;
6610 expire.high = 0x7fffffff;
6612 ctr->info.id = TALLOC_ZERO_P(ctx,SAM_USER_INFO_17);
6613 init_sam_user_info11(ctr->info.id17, &expire,
6614 "BROOKFIELDS$", /* name */
6615 0x03ef, /* user rid */
6616 0x201, /* group rid */
6617 0x0080); /* acb info */
6623 ctr->info.id18 = TALLOC_ZERO_P(ctx,SAM_USER_INFO_18);
6624 if (ctr->info.id18 == NULL)
6625 return NT_STATUS_NO_MEMORY;
6627 init_sam_user_info18(ctr->info.id18, usr->lm_pwd, usr->nt_pwd);
6631 SAM_USER_INFO_21 *cusr;
6632 cusr = TALLOC_ZERO_P(ctx,SAM_USER_INFO_21);
6633 ctr->info.id21 = cusr;
6634 if (ctr->info.id21 == NULL)
6635 return NT_STATUS_NO_MEMORY;
6636 memcpy(cusr, usr, sizeof(*usr));
6637 memset(cusr->lm_pwd, 0, sizeof(cusr->lm_pwd));
6638 memset(cusr->nt_pwd, 0, sizeof(cusr->nt_pwd));
6642 DEBUG(4,("make_samr_userinfo_ctr: unsupported info\n"));
6643 return NT_STATUS_INVALID_INFO_CLASS;
6646 return NT_STATUS_OK;
6649 /*******************************************************************
6650 inits a SAM_USERINFO_CTR structure.
6651 ********************************************************************/
6653 static void init_samr_userinfo_ctr(SAM_USERINFO_CTR * ctr, DATA_BLOB *sess_key,
6654 uint16 switch_value, void *info)
6656 DEBUG(5, ("init_samr_userinfo_ctr\n"));
6658 ctr->switch_value = switch_value;
6659 ctr->info.id = info;
6661 switch (switch_value) {
6663 SamOEMhashBlob(ctr->info.id24->pass, 516, sess_key);
6664 dump_data(100, sess_key->data, sess_key->length);
6665 dump_data(100, ctr->info.id24->pass, 516);
6668 SamOEMhashBlob(ctr->info.id23->pass, 516, sess_key);
6669 dump_data(100, sess_key->data, sess_key->length);
6670 dump_data(100, ctr->info.id23->pass, 516);
6675 DEBUG(4,("init_samr_userinfo_ctr: unsupported switch level: %d\n", switch_value));
6679 /*******************************************************************
6680 reads or writes a structure.
6681 ********************************************************************/
6683 static BOOL samr_io_userinfo_ctr(const char *desc, SAM_USERINFO_CTR **ppctr,
6684 prs_struct *ps, int depth)
6687 SAM_USERINFO_CTR *ctr;
6689 prs_debug(ps, depth, desc, "samr_io_userinfo_ctr");
6692 if (UNMARSHALLING(ps)) {
6693 ctr = PRS_ALLOC_MEM(ps,SAM_USERINFO_CTR,1);
6701 /* lkclXXXX DO NOT ALIGN BEFORE READING SWITCH VALUE! */
6703 if(!prs_uint16("switch_value", ps, depth, &ctr->switch_value))
6710 switch (ctr->switch_value) {
6712 if (UNMARSHALLING(ps))
6713 ctr->info.id7 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_7,1);
6714 if (ctr->info.id7 == NULL) {
6715 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6718 ret = sam_io_user_info7("", ctr->info.id7, ps, depth);
6721 if (UNMARSHALLING(ps))
6722 ctr->info.id9 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_9,1);
6723 if (ctr->info.id9 == NULL) {
6724 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6727 ret = sam_io_user_info9("", ctr->info.id9, ps, depth);
6730 if (UNMARSHALLING(ps))
6731 ctr->info.id16 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_16,1);
6732 if (ctr->info.id16 == NULL) {
6733 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6736 ret = sam_io_user_info16("", ctr->info.id16, ps, depth);
6739 if (UNMARSHALLING(ps))
6740 ctr->info.id17 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_17,1);
6742 if (ctr->info.id17 == NULL) {
6743 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6746 ret = sam_io_user_info17("", ctr->info.id17, ps, depth);
6749 if (UNMARSHALLING(ps))
6750 ctr->info.id18 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_18,1);
6752 if (ctr->info.id18 == NULL) {
6753 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6756 ret = sam_io_user_info18("", ctr->info.id18, ps, depth);
6759 if (UNMARSHALLING(ps))
6760 ctr->info.id20 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_20,1);
6762 if (ctr->info.id20 == NULL) {
6763 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6766 ret = sam_io_user_info20("", ctr->info.id20, ps, depth);
6769 if (UNMARSHALLING(ps))
6770 ctr->info.id21 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_21,1);
6772 if (ctr->info.id21 == NULL) {
6773 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6776 ret = sam_io_user_info21("", ctr->info.id21, ps, depth);
6779 if (UNMARSHALLING(ps))
6780 ctr->info.id23 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_23,1);
6782 if (ctr->info.id23 == NULL) {
6783 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6786 ret = sam_io_user_info23("", ctr->info.id23, ps, depth);
6789 if (UNMARSHALLING(ps))
6790 ctr->info.id24 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_24,1);
6792 if (ctr->info.id24 == NULL) {
6793 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6796 ret = sam_io_user_info24("", ctr->info.id24, ps, depth);
6799 if (UNMARSHALLING(ps))
6800 ctr->info.id25 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_25,1);
6802 if (ctr->info.id25 == NULL) {
6803 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6806 ret = sam_io_user_info25("", ctr->info.id25, ps, depth);
6809 if (UNMARSHALLING(ps))
6810 ctr->info.id26 = PRS_ALLOC_MEM(ps,SAM_USER_INFO_26,1);
6812 if (ctr->info.id26 == NULL) {
6813 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6816 ret = sam_io_user_info26("", ctr->info.id26, ps, depth);
6819 DEBUG(2, ("samr_io_userinfo_ctr: unknown switch level 0x%x\n", ctr->switch_value));
6827 /*******************************************************************
6828 inits a SAMR_R_QUERY_USERINFO structure.
6829 ********************************************************************/
6831 void init_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO * r_u,
6832 SAM_USERINFO_CTR * ctr, NTSTATUS status)
6834 DEBUG(5, ("init_samr_r_query_userinfo\n"));
6839 if (NT_STATUS_IS_OK(status)) {
6844 r_u->status = status; /* return status */
6847 /*******************************************************************
6848 reads or writes a structure.
6849 ********************************************************************/
6851 BOOL samr_io_r_query_userinfo(const char *desc, SAMR_R_QUERY_USERINFO * r_u,
6852 prs_struct *ps, int depth)
6857 prs_debug(ps, depth, desc, "samr_io_r_query_userinfo");
6863 if(!prs_uint32("ptr", ps, depth, &r_u->ptr))
6866 if (r_u->ptr != 0) {
6867 if(!samr_io_userinfo_ctr("ctr", &r_u->ctr, ps, depth))
6873 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6879 /*******************************************************************
6880 inits a SAMR_Q_SET_USERINFO structure.
6881 ********************************************************************/
6883 void init_samr_q_set_userinfo(SAMR_Q_SET_USERINFO * q_u,
6884 const POLICY_HND *hnd, DATA_BLOB *sess_key,
6885 uint16 switch_value, void *info)
6887 DEBUG(5, ("init_samr_q_set_userinfo\n"));
6890 q_u->switch_value = switch_value;
6891 init_samr_userinfo_ctr(q_u->ctr, sess_key, switch_value, info);
6894 /*******************************************************************
6895 reads or writes a structure.
6896 ********************************************************************/
6898 BOOL samr_io_q_set_userinfo(const char *desc, SAMR_Q_SET_USERINFO * q_u,
6899 prs_struct *ps, int depth)
6904 prs_debug(ps, depth, desc, "samr_io_q_set_userinfo");
6910 smb_io_pol_hnd("pol", &(q_u->pol), ps, depth);
6912 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
6914 if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
6920 /*******************************************************************
6921 inits a SAMR_R_SET_USERINFO structure.
6922 ********************************************************************/
6924 void init_samr_r_set_userinfo(SAMR_R_SET_USERINFO * r_u, NTSTATUS status)
6926 DEBUG(5, ("init_samr_r_set_userinfo\n"));
6928 r_u->status = status; /* return status */
6931 /*******************************************************************
6932 reads or writes a structure.
6933 ********************************************************************/
6935 BOOL samr_io_r_set_userinfo(const char *desc, SAMR_R_SET_USERINFO * r_u,
6936 prs_struct *ps, int depth)
6941 prs_debug(ps, depth, desc, "samr_io_r_set_userinfo");
6947 if(!prs_ntstatus("status", ps, depth, &r_u->status))
6953 /*******************************************************************
6954 inits a SAMR_Q_SET_USERINFO2 structure.
6955 ********************************************************************/
6957 void init_samr_q_set_userinfo2(SAMR_Q_SET_USERINFO2 * q_u,
6958 const POLICY_HND *hnd, DATA_BLOB *sess_key,
6959 uint16 switch_value, SAM_USERINFO_CTR * ctr)
6961 DEBUG(5, ("init_samr_q_set_userinfo2\n"));
6964 q_u->switch_value = switch_value;
6967 q_u->ctr->switch_value = switch_value;
6969 switch (switch_value) {
6971 SamOEMhashBlob(ctr->info.id18->lm_pwd, 16, sess_key);
6972 SamOEMhashBlob(ctr->info.id18->nt_pwd, 16, sess_key);
6973 dump_data(100, sess_key->data, sess_key->length);
6974 dump_data(100, ctr->info.id18->lm_pwd, 16);
6975 dump_data(100, ctr->info.id18->nt_pwd, 16);
6980 /*******************************************************************
6981 reads or writes a structure.
6982 ********************************************************************/
6984 BOOL samr_io_q_set_userinfo2(const char *desc, SAMR_Q_SET_USERINFO2 * q_u,
6985 prs_struct *ps, int depth)
6990 prs_debug(ps, depth, desc, "samr_io_q_set_userinfo2");
6996 if(!smb_io_pol_hnd("pol", &q_u->pol, ps, depth))
6999 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7001 if(!samr_io_userinfo_ctr("ctr", &q_u->ctr, ps, depth))
7007 /*******************************************************************
7008 inits a SAMR_R_SET_USERINFO2 structure.
7009 ********************************************************************/
7011 void init_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2 * r_u, NTSTATUS status)
7013 DEBUG(5, ("init_samr_r_set_userinfo2\n"));
7015 r_u->status = status; /* return status */
7018 /*******************************************************************
7019 reads or writes a structure.
7020 ********************************************************************/
7022 BOOL samr_io_r_set_userinfo2(const char *desc, SAMR_R_SET_USERINFO2 * r_u,
7023 prs_struct *ps, int depth)
7028 prs_debug(ps, depth, desc, "samr_io_r_set_userinfo2");
7034 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7040 /*******************************************************************
7041 inits a SAMR_Q_CONNECT structure.
7042 ********************************************************************/
7044 void init_samr_q_connect(SAMR_Q_CONNECT * q_u,
7045 char *srv_name, uint32 access_mask)
7047 DEBUG(5, ("init_samr_q_connect\n"));
7049 /* make PDC server name \\server */
7050 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7051 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7053 /* example values: 0x0000 0002 */
7054 q_u->access_mask = access_mask;
7057 /*******************************************************************
7058 reads or writes a structure.
7059 ********************************************************************/
7061 BOOL samr_io_q_connect(const char *desc, SAMR_Q_CONNECT * q_u,
7062 prs_struct *ps, int depth)
7067 prs_debug(ps, depth, desc, "samr_io_q_connect");
7073 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7075 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7080 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7086 /*******************************************************************
7087 reads or writes a structure.
7088 ********************************************************************/
7090 BOOL samr_io_r_connect(const char *desc, SAMR_R_CONNECT * r_u,
7091 prs_struct *ps, int depth)
7096 prs_debug(ps, depth, desc, "samr_io_r_connect");
7102 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7105 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7111 /*******************************************************************
7112 inits a SAMR_Q_CONNECT4 structure.
7113 ********************************************************************/
7115 void init_samr_q_connect4(SAMR_Q_CONNECT4 * q_u,
7116 char *srv_name, uint32 access_mask)
7118 DEBUG(5, ("init_samr_q_connect4\n"));
7120 /* make PDC server name \\server */
7121 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7122 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7124 /* Only value we've seen, possibly an address type ? */
7127 /* example values: 0x0000 0002 */
7128 q_u->access_mask = access_mask;
7131 /*******************************************************************
7132 reads or writes a structure.
7133 ********************************************************************/
7135 BOOL samr_io_q_connect4(const char *desc, SAMR_Q_CONNECT4 * q_u,
7136 prs_struct *ps, int depth)
7141 prs_debug(ps, depth, desc, "samr_io_q_connect4");
7147 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7149 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7154 if(!prs_uint32("unk_0", ps, depth, &q_u->unk_0))
7156 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7162 /*******************************************************************
7163 reads or writes a structure.
7164 ********************************************************************/
7166 BOOL samr_io_r_connect4(const char *desc, SAMR_R_CONNECT4 * r_u,
7167 prs_struct *ps, int depth)
7172 prs_debug(ps, depth, desc, "samr_io_r_connect4");
7178 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7181 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7187 /*******************************************************************
7188 inits a SAMR_Q_CONNECT5 structure.
7189 ********************************************************************/
7191 void init_samr_q_connect5(SAMR_Q_CONNECT5 * q_u,
7192 char *srv_name, uint32 access_mask)
7194 DEBUG(5, ("init_samr_q_connect5\n"));
7196 /* make PDC server name \\server */
7197 q_u->ptr_srv_name = (srv_name != NULL && *srv_name) ? 1 : 0;
7198 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_STR_TERMINATE);
7200 /* example values: 0x0000 0002 */
7201 q_u->access_mask = access_mask;
7204 q_u->info1_unk1 = 3;
7205 q_u->info1_unk2 = 0;
7208 /*******************************************************************
7209 inits a SAMR_R_CONNECT5 structure.
7210 ********************************************************************/
7212 void init_samr_r_connect5(SAMR_R_CONNECT5 * r_u, POLICY_HND *pol, NTSTATUS status)
7214 DEBUG(5, ("init_samr_q_connect5\n"));
7217 r_u->info1_unk1 = 3;
7218 r_u->info1_unk2 = 0;
7220 r_u->connect_pol = *pol;
7221 r_u->status = status;
7224 /*******************************************************************
7225 reads or writes a structure.
7226 ********************************************************************/
7228 BOOL samr_io_q_connect5(const char *desc, SAMR_Q_CONNECT5 * q_u,
7229 prs_struct *ps, int depth)
7234 prs_debug(ps, depth, desc, "samr_io_q_connect5");
7240 if(!prs_uint32("ptr_srv_name", ps, depth, &q_u->ptr_srv_name))
7242 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->ptr_srv_name, ps, depth))
7247 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7250 if(!prs_uint32("level", ps, depth, &q_u->level))
7252 if(!prs_uint32("level", ps, depth, &q_u->level))
7255 if(!prs_uint32("info1_unk1", ps, depth, &q_u->info1_unk1))
7257 if(!prs_uint32("info1_unk2", ps, depth, &q_u->info1_unk2))
7263 /*******************************************************************
7264 reads or writes a structure.
7265 ********************************************************************/
7267 BOOL samr_io_r_connect5(const char *desc, SAMR_R_CONNECT5 * r_u,
7268 prs_struct *ps, int depth)
7273 prs_debug(ps, depth, desc, "samr_io_r_connect5");
7279 if(!prs_uint32("level", ps, depth, &r_u->level))
7281 if(!prs_uint32("level", ps, depth, &r_u->level))
7283 if(!prs_uint32("info1_unk1", ps, depth, &r_u->info1_unk1))
7285 if(!prs_uint32("info1_unk2", ps, depth, &r_u->info1_unk2))
7288 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7291 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7297 /*******************************************************************
7298 inits a SAMR_Q_CONNECT_ANON structure.
7299 ********************************************************************/
7301 void init_samr_q_connect_anon(SAMR_Q_CONNECT_ANON * q_u)
7303 DEBUG(5, ("init_samr_q_connect_anon\n"));
7306 q_u->unknown_0 = 0x5c; /* server name (?!!) */
7307 q_u->access_mask = MAXIMUM_ALLOWED_ACCESS;
7310 /*******************************************************************
7311 reads or writes a structure.
7312 ********************************************************************/
7314 BOOL samr_io_q_connect_anon(const char *desc, SAMR_Q_CONNECT_ANON * q_u,
7315 prs_struct *ps, int depth)
7320 prs_debug(ps, depth, desc, "samr_io_q_connect_anon");
7326 if(!prs_uint32("ptr ", ps, depth, &q_u->ptr))
7329 if(!prs_uint16("unknown_0", ps, depth, &q_u->unknown_0))
7334 if(!prs_uint32("access_mask", ps, depth, &q_u->access_mask))
7340 /*******************************************************************
7341 reads or writes a structure.
7342 ********************************************************************/
7344 BOOL samr_io_r_connect_anon(const char *desc, SAMR_R_CONNECT_ANON * r_u,
7345 prs_struct *ps, int depth)
7350 prs_debug(ps, depth, desc, "samr_io_r_connect_anon");
7356 if(!smb_io_pol_hnd("connect_pol", &r_u->connect_pol, ps, depth))
7359 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7365 /*******************************************************************
7366 inits a SAMR_Q_GET_DOM_PWINFO structure.
7367 ********************************************************************/
7369 void init_samr_q_get_dom_pwinfo(SAMR_Q_GET_DOM_PWINFO * q_u,
7372 DEBUG(5, ("init_samr_q_get_dom_pwinfo\n"));
7375 init_unistr2(&q_u->uni_srv_name, srv_name, UNI_FLAGS_NONE);
7376 init_uni_hdr(&q_u->hdr_srv_name, &q_u->uni_srv_name);
7379 /*******************************************************************
7380 reads or writes a structure.
7381 ********************************************************************/
7383 BOOL samr_io_q_get_dom_pwinfo(const char *desc, SAMR_Q_GET_DOM_PWINFO * q_u,
7384 prs_struct *ps, int depth)
7389 prs_debug(ps, depth, desc, "samr_io_q_get_dom_pwinfo");
7395 if(!prs_uint32("ptr", ps, depth, &q_u->ptr))
7397 if (q_u->ptr != 0) {
7398 if(!smb_io_unihdr("", &q_u->hdr_srv_name, ps, depth))
7400 if(!smb_io_unistr2("", &q_u->uni_srv_name, q_u->hdr_srv_name.buffer, ps, depth))
7407 /*******************************************************************
7408 reads or writes a structure.
7409 ********************************************************************/
7411 BOOL samr_io_r_get_dom_pwinfo(const char *desc, SAMR_R_GET_DOM_PWINFO * r_u,
7412 prs_struct *ps, int depth)
7417 prs_debug(ps, depth, desc, "samr_io_r_get_dom_pwinfo");
7423 if(!prs_uint16("min_pwd_length", ps, depth, &r_u->min_pwd_length))
7427 if(!prs_uint32("password_properties", ps, depth, &r_u->password_properties))
7430 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7436 /*******************************************************************
7437 make a SAMR_ENC_PASSWD structure.
7438 ********************************************************************/
7440 void init_enc_passwd(SAMR_ENC_PASSWD * pwd, const char pass[512])
7448 memcpy(pwd->pass, pass, sizeof(pwd->pass));
7452 /*******************************************************************
7453 reads or writes a SAMR_ENC_PASSWD structure.
7454 ********************************************************************/
7456 BOOL samr_io_enc_passwd(const char *desc, SAMR_ENC_PASSWD * pwd,
7457 prs_struct *ps, int depth)
7462 prs_debug(ps, depth, desc, "samr_io_enc_passwd");
7468 if(!prs_uint32("ptr", ps, depth, &pwd->ptr))
7471 if (pwd->ptr != 0) {
7472 if(!prs_uint8s(False, "pwd", ps, depth, pwd->pass, sizeof(pwd->pass)))
7479 /*******************************************************************
7480 inits a SAMR_ENC_HASH structure.
7481 ********************************************************************/
7483 void init_enc_hash(SAMR_ENC_HASH * hsh, const uchar hash[16])
7491 memcpy(hsh->hash, hash, sizeof(hsh->hash));
7495 /*******************************************************************
7496 reads or writes a SAMR_ENC_HASH structure.
7497 ********************************************************************/
7499 BOOL samr_io_enc_hash(const char *desc, SAMR_ENC_HASH * hsh,
7500 prs_struct *ps, int depth)
7505 prs_debug(ps, depth, desc, "samr_io_enc_hash");
7511 if(!prs_uint32("ptr ", ps, depth, &hsh->ptr))
7513 if (hsh->ptr != 0) {
7514 if(!prs_uint8s(False, "hash", ps, depth, hsh->hash,sizeof(hsh->hash)))
7521 /*******************************************************************
7522 inits a SAMR_Q_CHGPASSWD_USER structure.
7523 ********************************************************************/
7525 void init_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER * q_u,
7526 const char *dest_host, const char *user_name,
7527 const uchar nt_newpass[516],
7528 const uchar nt_oldhash[16],
7529 const uchar lm_newpass[516],
7530 const uchar lm_oldhash[16])
7532 DEBUG(5, ("init_samr_q_chgpasswd_user\n"));
7535 init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7536 init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7538 init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7539 init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7541 init_enc_passwd(&q_u->nt_newpass, (const char *)nt_newpass);
7542 init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7544 q_u->unknown = 0x01;
7546 init_enc_passwd(&q_u->lm_newpass, (const char *)lm_newpass);
7547 init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7550 /*******************************************************************
7551 reads or writes a structure.
7552 ********************************************************************/
7554 BOOL samr_io_q_chgpasswd_user(const char *desc, SAMR_Q_CHGPASSWD_USER * q_u,
7555 prs_struct *ps, int depth)
7560 prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user");
7566 if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7569 if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7571 if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7576 if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7578 if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7581 if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7583 if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7586 if(!prs_uint32("unknown", ps, depth, &q_u->unknown))
7589 if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7591 if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7597 /*******************************************************************
7598 inits a SAMR_R_CHGPASSWD_USER structure.
7599 ********************************************************************/
7601 void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER * r_u, NTSTATUS status)
7603 DEBUG(5, ("init_samr_r_chgpasswd_user\n"));
7605 r_u->status = status;
7608 /*******************************************************************
7609 reads or writes a structure.
7610 ********************************************************************/
7612 BOOL samr_io_r_chgpasswd_user(const char *desc, SAMR_R_CHGPASSWD_USER * r_u,
7613 prs_struct *ps, int depth)
7618 prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user");
7624 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7630 /*******************************************************************
7631 inits a SAMR_Q_CHGPASSWD3 structure.
7632 ********************************************************************/
7634 void init_samr_q_chgpasswd_user3(SAMR_Q_CHGPASSWD_USER3 * q_u,
7635 const char *dest_host, const char *user_name,
7636 const uchar nt_newpass[516],
7637 const uchar nt_oldhash[16],
7638 const uchar lm_newpass[516],
7639 const uchar lm_oldhash[16])
7641 DEBUG(5, ("init_samr_q_chgpasswd_user3\n"));
7644 init_unistr2(&q_u->uni_dest_host, dest_host, UNI_FLAGS_NONE);
7645 init_uni_hdr(&q_u->hdr_dest_host, &q_u->uni_dest_host);
7647 init_unistr2(&q_u->uni_user_name, user_name, UNI_FLAGS_NONE);
7648 init_uni_hdr(&q_u->hdr_user_name, &q_u->uni_user_name);
7650 init_enc_passwd(&q_u->nt_newpass, (const char *)nt_newpass);
7651 init_enc_hash(&q_u->nt_oldhash, nt_oldhash);
7653 q_u->lm_change = 0x01;
7655 init_enc_passwd(&q_u->lm_newpass, (const char *)lm_newpass);
7656 init_enc_hash(&q_u->lm_oldhash, lm_oldhash);
7658 init_enc_passwd(&q_u->password3, NULL);
7661 /*******************************************************************
7662 reads or writes a structure.
7663 ********************************************************************/
7665 BOOL samr_io_q_chgpasswd_user3(const char *desc, SAMR_Q_CHGPASSWD_USER3 * q_u,
7666 prs_struct *ps, int depth)
7671 prs_debug(ps, depth, desc, "samr_io_q_chgpasswd_user3");
7677 if(!prs_uint32("ptr_0", ps, depth, &q_u->ptr_0))
7680 if(!smb_io_unihdr("", &q_u->hdr_dest_host, ps, depth))
7682 if(!smb_io_unistr2("", &q_u->uni_dest_host, q_u->hdr_dest_host.buffer, ps, depth))
7687 if(!smb_io_unihdr("", &q_u->hdr_user_name, ps, depth))
7689 if(!smb_io_unistr2("", &q_u->uni_user_name, q_u->hdr_user_name.buffer,ps, depth))
7692 if(!samr_io_enc_passwd("nt_newpass", &q_u->nt_newpass, ps, depth))
7694 if(!samr_io_enc_hash("nt_oldhash", &q_u->nt_oldhash, ps, depth))
7697 if(!prs_uint32("lm_change", ps, depth, &q_u->lm_change))
7700 if(!samr_io_enc_passwd("lm_newpass", &q_u->lm_newpass, ps, depth))
7702 if(!samr_io_enc_hash("lm_oldhash", &q_u->lm_oldhash, ps, depth))
7705 if(!samr_io_enc_passwd("password3", &q_u->password3, ps, depth))
7711 /*******************************************************************
7712 inits a SAMR_R_CHGPASSWD_USER3 structure.
7713 ********************************************************************/
7715 void init_samr_r_chgpasswd_user3(SAMR_R_CHGPASSWD_USER3 *r_u, NTSTATUS status,
7716 SAMR_CHANGE_REJECT *reject, SAM_UNK_INFO_1 *info)
7718 DEBUG(5, ("init_samr_r_chgpasswd_user3\n"));
7720 r_u->status = status;
7724 r_u->ptr_reject = 0;
7730 if (reject && (reject->reject_reason != Undefined)) {
7731 r_u->reject = reject;
7732 r_u->ptr_reject = 1;
7736 /*******************************************************************
7737 Reads or writes an SAMR_CHANGE_REJECT structure.
7738 ********************************************************************/
7740 BOOL samr_io_change_reject(const char *desc, SAMR_CHANGE_REJECT *reject, prs_struct *ps, int depth)
7745 prs_debug(ps, depth, desc, "samr_io_change_reject");
7751 if(UNMARSHALLING(ps))
7752 ZERO_STRUCTP(reject);
7754 if (!prs_uint32("reject_reason", ps, depth, &reject->reject_reason))
7757 if (!prs_uint32("unknown1", ps, depth, &reject->unknown1))
7760 if (!prs_uint32("unknown2", ps, depth, &reject->unknown2))
7766 /*******************************************************************
7767 reads or writes a structure.
7768 ********************************************************************/
7770 BOOL samr_io_r_chgpasswd_user3(const char *desc, SAMR_R_CHGPASSWD_USER3 *r_u,
7771 prs_struct *ps, int depth)
7776 prs_debug(ps, depth, desc, "samr_io_r_chgpasswd_user3");
7782 if (!prs_uint32("ptr_info", ps, depth, &r_u->ptr_info))
7785 /* special case: Windows 2000 can return stub data here saying
7786 NT_STATUS_NOT_SUPPORTED */
7788 if ( NT_STATUS_EQUAL( NT_STATUS_NOT_SUPPORTED, NT_STATUS(r_u->ptr_info)) ) {
7789 r_u->status = NT_STATUS_NOT_SUPPORTED;
7793 if (r_u->ptr_info && r_u->info != NULL) {
7794 /* SAM_UNK_INFO_1 */
7795 if (!sam_io_unk_info1("info", r_u->info, ps, depth))
7799 if (!prs_uint32("ptr_reject", ps, depth, &r_u->ptr_reject))
7802 if (r_u->ptr_reject && r_u->reject != NULL) {
7803 /* SAMR_CHANGE_REJECT */
7804 if (!samr_io_change_reject("reject", r_u->reject, ps, depth))
7808 if (!prs_ntstatus("status", ps, depth, &r_u->status))
7814 /*******************************************************************
7815 reads or writes a structure.
7816 ********************************************************************/
7818 void init_samr_q_query_domain_info2(SAMR_Q_QUERY_DOMAIN_INFO2 *q_u,
7819 POLICY_HND *domain_pol, uint16 switch_value)
7821 DEBUG(5, ("init_samr_q_query_domain_info2\n"));
7823 q_u->domain_pol = *domain_pol;
7824 q_u->switch_value = switch_value;
7827 /*******************************************************************
7828 reads or writes a structure.
7829 ********************************************************************/
7831 BOOL samr_io_q_query_domain_info2(const char *desc, SAMR_Q_QUERY_DOMAIN_INFO2 *q_u,
7832 prs_struct *ps, int depth)
7837 prs_debug(ps, depth, desc, "samr_io_q_query_domain_info2");
7843 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7846 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
7852 /*******************************************************************
7853 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7854 ********************************************************************/
7856 void init_samr_r_query_domain_info2(SAMR_R_QUERY_DOMAIN_INFO2 * r_u,
7857 uint16 switch_value, SAM_UNK_CTR * ctr,
7860 DEBUG(5, ("init_samr_r_query_domain_info2\n"));
7863 r_u->switch_value = 0;
7864 r_u->status = status; /* return status */
7866 if (NT_STATUS_IS_OK(status)) {
7867 r_u->switch_value = switch_value;
7873 /*******************************************************************
7874 reads or writes a structure.
7875 ********************************************************************/
7877 BOOL samr_io_r_query_domain_info2(const char *desc, SAMR_R_QUERY_DOMAIN_INFO2 * r_u,
7878 prs_struct *ps, int depth)
7883 prs_debug(ps, depth, desc, "samr_io_r_query_domain_info2");
7889 if(!prs_uint32("ptr_0 ", ps, depth, &r_u->ptr_0))
7892 if (r_u->ptr_0 != 0 && r_u->ctr != NULL) {
7893 if(!prs_uint16("switch_value", ps, depth, &r_u->switch_value))
7898 switch (r_u->switch_value) {
7900 if(!sam_io_unk_info13("unk_inf13", &r_u->ctr->info.inf13, ps, depth))
7904 if(!sam_io_unk_info12("unk_inf12", &r_u->ctr->info.inf12, ps, depth))
7908 if(!sam_io_unk_info9("unk_inf9",&r_u->ctr->info.inf9, ps,depth))
7912 if(!sam_io_unk_info8("unk_inf8",&r_u->ctr->info.inf8, ps,depth))
7916 if(!sam_io_unk_info7("unk_inf7",&r_u->ctr->info.inf7, ps,depth))
7920 if(!sam_io_unk_info6("unk_inf6",&r_u->ctr->info.inf6, ps,depth))
7924 if(!sam_io_unk_info5("unk_inf5",&r_u->ctr->info.inf5, ps,depth))
7928 if(!sam_io_unk_info4("unk_inf4",&r_u->ctr->info.inf4, ps,depth))
7932 if(!sam_io_unk_info3("unk_inf3",&r_u->ctr->info.inf3, ps,depth))
7936 if(!sam_io_unk_info2("unk_inf2",&r_u->ctr->info.inf2, ps,depth))
7940 if(!sam_io_unk_info1("unk_inf1",&r_u->ctr->info.inf1, ps,depth))
7944 DEBUG(0, ("samr_io_r_query_domain_info2: unknown switch level 0x%x\n",
7945 r_u->switch_value));
7946 r_u->status = NT_STATUS_INVALID_INFO_CLASS;
7954 if(!prs_ntstatus("status", ps, depth, &r_u->status))
7961 /*******************************************************************
7962 reads or writes a structure.
7963 ********************************************************************/
7965 void init_samr_q_set_domain_info(SAMR_Q_SET_DOMAIN_INFO *q_u,
7966 POLICY_HND *domain_pol, uint16 switch_value, SAM_UNK_CTR *ctr)
7968 DEBUG(5, ("init_samr_q_set_domain_info\n"));
7970 q_u->domain_pol = *domain_pol;
7971 q_u->switch_value0 = switch_value;
7973 q_u->switch_value = switch_value;
7978 /*******************************************************************
7979 reads or writes a structure.
7980 ********************************************************************/
7982 BOOL samr_io_q_set_domain_info(const char *desc, SAMR_Q_SET_DOMAIN_INFO *q_u,
7983 prs_struct *ps, int depth)
7988 prs_debug(ps, depth, desc, "samr_io_q_set_domain_info");
7994 if(!smb_io_pol_hnd("domain_pol", &q_u->domain_pol, ps, depth))
7997 if(!prs_uint16("switch_value0", ps, depth, &q_u->switch_value0))
8000 if(!prs_uint16("switch_value", ps, depth, &q_u->switch_value))
8006 if (UNMARSHALLING(ps)) {
8007 if ((q_u->ctr = PRS_ALLOC_MEM(ps, SAM_UNK_CTR, 1)) == NULL)
8011 switch (q_u->switch_value) {
8014 if(!sam_io_unk_info12("unk_inf12", &q_u->ctr->info.inf12, ps, depth))
8018 if(!sam_io_unk_info7("unk_inf7",&q_u->ctr->info.inf7, ps,depth))
8022 if(!sam_io_unk_info6("unk_inf6",&q_u->ctr->info.inf6, ps,depth))
8026 if(!sam_io_unk_info5("unk_inf5",&q_u->ctr->info.inf5, ps,depth))
8030 if(!sam_io_unk_info3("unk_inf3",&q_u->ctr->info.inf3, ps,depth))
8034 if(!sam_io_unk_info2("unk_inf2",&q_u->ctr->info.inf2, ps,depth))
8038 if(!sam_io_unk_info1("unk_inf1",&q_u->ctr->info.inf1, ps,depth))
8042 DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
8043 q_u->switch_value));
8050 /*******************************************************************
8051 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
8052 ********************************************************************/
8054 void init_samr_r_set_domain_info(SAMR_R_SET_DOMAIN_INFO * r_u, NTSTATUS status)
8056 DEBUG(5, ("init_samr_r_set_domain_info\n"));
8058 r_u->status = status; /* return status */
8061 /*******************************************************************
8062 reads or writes a structure.
8063 ********************************************************************/
8065 BOOL samr_io_r_set_domain_info(const char *desc, SAMR_R_SET_DOMAIN_INFO * r_u,
8066 prs_struct *ps, int depth)
8071 prs_debug(ps, depth, desc, "samr_io_r_samr_unknown_2e");
8077 if(!prs_ntstatus("status", ps, depth, &r_u->status))