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_OPEN_GROUP structure.
2177 ********************************************************************/
2179 void init_samr_q_open_group(SAMR_Q_OPEN_GROUP
* q_c
,
2181 uint32 access_mask
, uint32 rid
)
2183 DEBUG(5, ("init_samr_q_open_group\n"));
2185 q_c
->domain_pol
= *hnd
;
2186 q_c
->access_mask
= access_mask
;
2187 q_c
->rid_group
= rid
;
2190 /*******************************************************************
2191 reads or writes a structure.
2192 ********************************************************************/
2194 BOOL
samr_io_q_open_group(const char *desc
, SAMR_Q_OPEN_GROUP
* q_u
,
2195 prs_struct
*ps
, int depth
)
2200 prs_debug(ps
, depth
, desc
, "samr_io_q_open_group");
2206 if(!smb_io_pol_hnd("domain_pol", &q_u
->domain_pol
, ps
, depth
))
2209 if(!prs_uint32("access_mask", ps
, depth
, &q_u
->access_mask
))
2211 if(!prs_uint32("rid_group", ps
, depth
, &q_u
->rid_group
))
2217 /*******************************************************************
2218 reads or writes a structure.
2219 ********************************************************************/
2221 BOOL
samr_io_r_open_group(const char *desc
, SAMR_R_OPEN_GROUP
* r_u
,
2222 prs_struct
*ps
, int depth
)
2227 prs_debug(ps
, depth
, desc
, "samr_io_r_open_group");
2233 if(!smb_io_pol_hnd("pol", &r_u
->pol
, ps
, depth
))
2236 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
2242 /*******************************************************************
2243 inits a GROUP_INFO1 structure.
2244 ********************************************************************/
2246 void init_samr_group_info1(GROUP_INFO1
* gr1
,
2247 char *acct_name
, char *acct_desc
,
2250 DEBUG(5, ("init_samr_group_info1\n"));
2252 gr1
->group_attr
= (SE_GROUP_MANDATORY
|SE_GROUP_ENABLED_BY_DEFAULT
); /* why not | SE_GROUP_ENABLED ? */
2253 gr1
->num_members
= num_members
;
2255 init_unistr2(&gr1
->uni_acct_name
, acct_name
, UNI_FLAGS_NONE
);
2256 init_uni_hdr(&gr1
->hdr_acct_name
, &gr1
->uni_acct_name
);
2257 init_unistr2(&gr1
->uni_acct_desc
, acct_desc
, UNI_FLAGS_NONE
);
2258 init_uni_hdr(&gr1
->hdr_acct_desc
, &gr1
->uni_acct_desc
);
2261 /*******************************************************************
2262 reads or writes a structure.
2263 ********************************************************************/
2265 BOOL
samr_io_group_info1(const char *desc
, GROUP_INFO1
* gr1
,
2266 prs_struct
*ps
, int depth
)
2273 prs_debug(ps
, depth
, desc
, "samr_io_group_info1");
2276 if(!prs_uint16("level", ps
, depth
, &dummy
))
2282 if(!smb_io_unihdr("hdr_acct_name", &gr1
->hdr_acct_name
, ps
, depth
))
2285 if(!prs_uint32("group_attr", ps
, depth
, &gr1
->group_attr
))
2287 if(!prs_uint32("num_members", ps
, depth
, &gr1
->num_members
))
2290 if(!smb_io_unihdr("hdr_acct_desc", &gr1
->hdr_acct_desc
, ps
, depth
))
2293 if(!smb_io_unistr2("uni_acct_name", &gr1
->uni_acct_name
,
2294 gr1
->hdr_acct_name
.buffer
, ps
, depth
))
2297 if(!smb_io_unistr2("uni_acct_desc", &gr1
->uni_acct_desc
,
2298 gr1
->hdr_acct_desc
.buffer
, ps
, depth
))
2304 /*******************************************************************
2305 inits a GROUP_INFO2 structure.
2306 ********************************************************************/
2308 void init_samr_group_info2(GROUP_INFO2
* gr2
, const char *acct_name
)
2310 DEBUG(5, ("init_samr_group_info2\n"));
2313 init_unistr2(&gr2
->uni_acct_name
, acct_name
, UNI_FLAGS_NONE
);
2314 init_uni_hdr(&gr2
->hdr_acct_name
, &gr2
->uni_acct_name
);
2317 /*******************************************************************
2318 reads or writes a structure.
2319 ********************************************************************/
2321 BOOL
samr_io_group_info2(const char *desc
, GROUP_INFO2
*gr2
, prs_struct
*ps
, int depth
)
2326 prs_debug(ps
, depth
, desc
, "samr_io_group_info2");
2329 if(!prs_uint16("hdr_level", ps
, depth
, &gr2
->level
))
2332 if(!smb_io_unihdr("hdr_acct_name", &gr2
->hdr_acct_name
, ps
, depth
))
2334 if(!smb_io_unistr2("uni_acct_name", &gr2
->uni_acct_name
,
2335 gr2
->hdr_acct_name
.buffer
, ps
, depth
))
2341 /*******************************************************************
2342 inits a GROUP_INFO3 structure.
2343 ********************************************************************/
2345 void init_samr_group_info3(GROUP_INFO3
*gr3
)
2347 DEBUG(5, ("init_samr_group_info3\n"));
2349 gr3
->group_attr
= (SE_GROUP_MANDATORY
|SE_GROUP_ENABLED_BY_DEFAULT
); /* why not | SE_GROUP_ENABLED ? */
2352 /*******************************************************************
2353 reads or writes a structure.
2354 ********************************************************************/
2356 BOOL
samr_io_group_info3(const char *desc
, GROUP_INFO3
*gr3
, prs_struct
*ps
, int depth
)
2361 prs_debug(ps
, depth
, desc
, "samr_io_group_info3");
2367 if(!prs_uint32("group_attr", ps
, depth
, &gr3
->group_attr
))
2373 /*******************************************************************
2374 inits a GROUP_INFO4 structure.
2375 ********************************************************************/
2377 void init_samr_group_info4(GROUP_INFO4
* gr4
, const char *acct_desc
)
2379 DEBUG(5, ("init_samr_group_info4\n"));
2382 init_unistr2(&gr4
->uni_acct_desc
, acct_desc
, UNI_FLAGS_NONE
);
2383 init_uni_hdr(&gr4
->hdr_acct_desc
, &gr4
->uni_acct_desc
);
2386 /*******************************************************************
2387 reads or writes a structure.
2388 ********************************************************************/
2390 BOOL
samr_io_group_info4(const char *desc
, GROUP_INFO4
* gr4
,
2391 prs_struct
*ps
, int depth
)
2396 prs_debug(ps
, depth
, desc
, "samr_io_group_info4");
2399 if(!prs_uint16("hdr_level", ps
, depth
, &gr4
->level
))
2401 if(!smb_io_unihdr("hdr_acct_desc", &gr4
->hdr_acct_desc
, ps
, depth
))
2403 if(!smb_io_unistr2("uni_acct_desc", &gr4
->uni_acct_desc
,
2404 gr4
->hdr_acct_desc
.buffer
, ps
, depth
))
2410 /*******************************************************************
2411 inits a GROUP_INFO5 structure.
2412 ********************************************************************/
2414 void init_samr_group_info5(GROUP_INFO5
* gr5
,
2415 char *acct_name
, char *acct_desc
,
2418 DEBUG(5, ("init_samr_group_info5\n"));
2420 gr5
->group_attr
= (SE_GROUP_MANDATORY
|SE_GROUP_ENABLED_BY_DEFAULT
); /* why not | SE_GROUP_ENABLED ? */
2421 gr5
->num_members
= num_members
;
2423 init_unistr2(&gr5
->uni_acct_name
, acct_name
, UNI_FLAGS_NONE
);
2424 init_uni_hdr(&gr5
->hdr_acct_name
, &gr5
->uni_acct_name
);
2425 init_unistr2(&gr5
->uni_acct_desc
, acct_desc
, UNI_FLAGS_NONE
);
2426 init_uni_hdr(&gr5
->hdr_acct_desc
, &gr5
->uni_acct_desc
);
2429 /*******************************************************************
2430 reads or writes a structure.
2431 ********************************************************************/
2433 BOOL
samr_io_group_info5(const char *desc
, GROUP_INFO5
* gr5
,
2434 prs_struct
*ps
, int depth
)
2441 prs_debug(ps
, depth
, desc
, "samr_io_group_info5");
2444 if(!prs_uint16("level", ps
, depth
, &dummy
))
2450 if(!smb_io_unihdr("hdr_acct_name", &gr5
->hdr_acct_name
, ps
, depth
))
2453 if(!prs_uint32("group_attr", ps
, depth
, &gr5
->group_attr
))
2455 if(!prs_uint32("num_members", ps
, depth
, &gr5
->num_members
))
2458 if(!smb_io_unihdr("hdr_acct_desc", &gr5
->hdr_acct_desc
, ps
, depth
))
2461 if(!smb_io_unistr2("uni_acct_name", &gr5
->uni_acct_name
,
2462 gr5
->hdr_acct_name
.buffer
, ps
, depth
))
2465 if(!smb_io_unistr2("uni_acct_desc", &gr5
->uni_acct_desc
,
2466 gr5
->hdr_acct_desc
.buffer
, ps
, depth
))
2473 /*******************************************************************
2474 reads or writes a structure.
2475 ********************************************************************/
2477 static BOOL
samr_group_info_ctr(const char *desc
, GROUP_INFO_CTR
**ctr
,
2478 prs_struct
*ps
, int depth
)
2480 if (UNMARSHALLING(ps
))
2481 *ctr
= PRS_ALLOC_MEM(ps
,GROUP_INFO_CTR
,1);
2486 prs_debug(ps
, depth
, desc
, "samr_group_info_ctr");
2489 if(!prs_uint16("switch_value1", ps
, depth
, &(*ctr
)->switch_value1
))
2492 switch ((*ctr
)->switch_value1
) {
2494 if(!samr_io_group_info1("group_info1", &(*ctr
)->group
.info1
, ps
, depth
))
2498 if(!samr_io_group_info2("group_info2", &(*ctr
)->group
.info2
, ps
, depth
))
2502 if(!samr_io_group_info3("group_info3", &(*ctr
)->group
.info3
, ps
, depth
))
2506 if(!samr_io_group_info4("group_info4", &(*ctr
)->group
.info4
, ps
, depth
))
2510 if(!samr_io_group_info5("group_info5", &(*ctr
)->group
.info5
, ps
, depth
))
2514 DEBUG(0,("samr_group_info_ctr: unsupported switch level\n"));
2521 /*******************************************************************
2522 inits a SAMR_Q_CREATE_DOM_GROUP structure.
2523 ********************************************************************/
2525 void init_samr_q_create_dom_group(SAMR_Q_CREATE_DOM_GROUP
* q_e
,
2526 POLICY_HND
*pol
, const char *acct_desc
,
2529 DEBUG(5, ("init_samr_q_create_dom_group\n"));
2533 init_unistr2(&q_e
->uni_acct_desc
, acct_desc
, UNI_FLAGS_NONE
);
2534 init_uni_hdr(&q_e
->hdr_acct_desc
, &q_e
->uni_acct_desc
);
2536 q_e
->access_mask
= access_mask
;
2539 /*******************************************************************
2540 reads or writes a structure.
2541 ********************************************************************/
2543 BOOL
samr_io_q_create_dom_group(const char *desc
, SAMR_Q_CREATE_DOM_GROUP
* q_e
,
2544 prs_struct
*ps
, int depth
)
2549 prs_debug(ps
, depth
, desc
, "samr_io_q_create_dom_group");
2555 if(!smb_io_pol_hnd("pol", &q_e
->pol
, ps
, depth
))
2558 if(!smb_io_unihdr("hdr_acct_desc", &q_e
->hdr_acct_desc
, ps
, depth
))
2560 if(!smb_io_unistr2("uni_acct_desc", &q_e
->uni_acct_desc
,
2561 q_e
->hdr_acct_desc
.buffer
, ps
, depth
))
2566 if(!prs_uint32("access", ps
, depth
, &q_e
->access_mask
))
2572 /*******************************************************************
2573 reads or writes a structure.
2574 ********************************************************************/
2576 BOOL
samr_io_r_create_dom_group(const char *desc
, SAMR_R_CREATE_DOM_GROUP
* r_u
,
2577 prs_struct
*ps
, int depth
)
2582 prs_debug(ps
, depth
, desc
, "samr_io_r_create_dom_group");
2588 if(!smb_io_pol_hnd("pol", &r_u
->pol
, ps
, depth
))
2591 if(!prs_uint32("rid ", ps
, depth
, &r_u
->rid
))
2593 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
2599 /*******************************************************************
2600 inits a SAMR_Q_DELETE_DOM_GROUP structure.
2601 ********************************************************************/
2603 void init_samr_q_delete_dom_group(SAMR_Q_DELETE_DOM_GROUP
* q_c
,
2606 DEBUG(5, ("init_samr_q_delete_dom_group\n"));
2608 q_c
->group_pol
= *hnd
;
2611 /*******************************************************************
2612 reads or writes a structure.
2613 ********************************************************************/
2615 BOOL
samr_io_q_delete_dom_group(const char *desc
, SAMR_Q_DELETE_DOM_GROUP
* q_u
,
2616 prs_struct
*ps
, int depth
)
2621 prs_debug(ps
, depth
, desc
, "samr_io_q_delete_dom_group");
2627 if(!smb_io_pol_hnd("group_pol", &q_u
->group_pol
, ps
, depth
))
2633 /*******************************************************************
2634 reads or writes a structure.
2635 ********************************************************************/
2637 BOOL
samr_io_r_delete_dom_group(const char *desc
, SAMR_R_DELETE_DOM_GROUP
* r_u
,
2638 prs_struct
*ps
, int depth
)
2643 prs_debug(ps
, depth
, desc
, "samr_io_r_delete_dom_group");
2649 if(!smb_io_pol_hnd("pol", &r_u
->pol
, ps
, depth
))
2652 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
2658 /*******************************************************************
2659 inits a SAMR_Q_DEL_GROUPMEM structure.
2660 ********************************************************************/
2662 void init_samr_q_del_groupmem(SAMR_Q_DEL_GROUPMEM
* q_e
,
2663 POLICY_HND
*pol
, uint32 rid
)
2665 DEBUG(5, ("init_samr_q_del_groupmem\n"));
2671 /*******************************************************************
2672 reads or writes a structure.
2673 ********************************************************************/
2675 BOOL
samr_io_q_del_groupmem(const char *desc
, SAMR_Q_DEL_GROUPMEM
* q_e
,
2676 prs_struct
*ps
, int depth
)
2681 prs_debug(ps
, depth
, desc
, "samr_io_q_del_groupmem");
2687 if(!smb_io_pol_hnd("pol", &q_e
->pol
, ps
, depth
))
2690 if(!prs_uint32("rid", ps
, depth
, &q_e
->rid
))
2696 /*******************************************************************
2697 inits a SAMR_R_DEL_GROUPMEM structure.
2698 ********************************************************************/
2700 void init_samr_r_del_groupmem(SAMR_R_DEL_GROUPMEM
* r_u
, POLICY_HND
*pol
,
2703 DEBUG(5, ("init_samr_r_del_groupmem\n"));
2705 r_u
->status
= status
;
2708 /*******************************************************************
2709 reads or writes a structure.
2710 ********************************************************************/
2712 BOOL
samr_io_r_del_groupmem(const char *desc
, SAMR_R_DEL_GROUPMEM
* r_u
,
2713 prs_struct
*ps
, int depth
)
2718 prs_debug(ps
, depth
, desc
, "samr_io_r_del_groupmem");
2724 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
2730 /*******************************************************************
2731 inits a SAMR_Q_ADD_GROUPMEM structure.
2732 ********************************************************************/
2734 void init_samr_q_add_groupmem(SAMR_Q_ADD_GROUPMEM
* q_e
,
2735 POLICY_HND
*pol
, uint32 rid
)
2737 DEBUG(5, ("init_samr_q_add_groupmem\n"));
2741 q_e
->unknown
= 0x0005;
2744 /*******************************************************************
2745 reads or writes a structure.
2746 ********************************************************************/
2748 BOOL
samr_io_q_add_groupmem(const char *desc
, SAMR_Q_ADD_GROUPMEM
* q_e
,
2749 prs_struct
*ps
, int depth
)
2754 prs_debug(ps
, depth
, desc
, "samr_io_q_add_groupmem");
2760 if(!smb_io_pol_hnd("pol", &q_e
->pol
, ps
, depth
))
2763 if(!prs_uint32("rid ", ps
, depth
, &q_e
->rid
))
2765 if(!prs_uint32("unknown", ps
, depth
, &q_e
->unknown
))
2771 /*******************************************************************
2772 inits a SAMR_R_ADD_GROUPMEM structure.
2773 ********************************************************************/
2775 void init_samr_r_add_groupmem(SAMR_R_ADD_GROUPMEM
* r_u
, POLICY_HND
*pol
,
2778 DEBUG(5, ("init_samr_r_add_groupmem\n"));
2780 r_u
->status
= status
;
2783 /*******************************************************************
2784 reads or writes a structure.
2785 ********************************************************************/
2787 BOOL
samr_io_r_add_groupmem(const char *desc
, SAMR_R_ADD_GROUPMEM
* r_u
,
2788 prs_struct
*ps
, int depth
)
2793 prs_debug(ps
, depth
, desc
, "samr_io_r_add_groupmem");
2799 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
2805 /*******************************************************************
2806 inits a SAMR_Q_SET_GROUPINFO structure.
2807 ********************************************************************/
2809 void init_samr_q_set_groupinfo(SAMR_Q_SET_GROUPINFO
* q_e
,
2810 POLICY_HND
*pol
, GROUP_INFO_CTR
* ctr
)
2812 DEBUG(5, ("init_samr_q_set_groupinfo\n"));
2818 /*******************************************************************
2819 reads or writes a structure.
2820 ********************************************************************/
2822 BOOL
samr_io_q_set_groupinfo(const char *desc
, SAMR_Q_SET_GROUPINFO
* q_e
,
2823 prs_struct
*ps
, int depth
)
2828 prs_debug(ps
, depth
, desc
, "samr_io_q_set_groupinfo");
2834 if(!smb_io_pol_hnd("pol", &q_e
->pol
, ps
, depth
))
2837 if(!samr_group_info_ctr("ctr", &q_e
->ctr
, ps
, depth
))
2843 /*******************************************************************
2844 inits a SAMR_R_SET_GROUPINFO structure.
2845 ********************************************************************/
2847 void init_samr_r_set_groupinfo(SAMR_R_SET_GROUPINFO
* r_u
, NTSTATUS status
)
2849 DEBUG(5, ("init_samr_r_set_groupinfo\n"));
2851 r_u
->status
= status
;
2854 /*******************************************************************
2855 reads or writes a structure.
2856 ********************************************************************/
2858 BOOL
samr_io_r_set_groupinfo(const char *desc
, SAMR_R_SET_GROUPINFO
* r_u
,
2859 prs_struct
*ps
, int depth
)
2864 prs_debug(ps
, depth
, desc
, "samr_io_r_set_groupinfo");
2870 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
2876 /*******************************************************************
2877 inits a SAMR_Q_QUERY_GROUPINFO structure.
2878 ********************************************************************/
2880 void init_samr_q_query_groupinfo(SAMR_Q_QUERY_GROUPINFO
* q_e
,
2881 POLICY_HND
*pol
, uint16 switch_level
)
2883 DEBUG(5, ("init_samr_q_query_groupinfo\n"));
2887 q_e
->switch_level
= switch_level
;
2890 /*******************************************************************
2891 reads or writes a structure.
2892 ********************************************************************/
2894 BOOL
samr_io_q_query_groupinfo(const char *desc
, SAMR_Q_QUERY_GROUPINFO
* q_e
,
2895 prs_struct
*ps
, int depth
)
2900 prs_debug(ps
, depth
, desc
, "samr_io_q_query_groupinfo");
2906 if(!smb_io_pol_hnd("pol", &q_e
->pol
, ps
, depth
))
2909 if(!prs_uint16("switch_level", ps
, depth
, &q_e
->switch_level
))
2915 /*******************************************************************
2916 inits a SAMR_R_QUERY_GROUPINFO structure.
2917 ********************************************************************/
2919 void init_samr_r_query_groupinfo(SAMR_R_QUERY_GROUPINFO
* r_u
,
2920 GROUP_INFO_CTR
* ctr
, NTSTATUS status
)
2922 DEBUG(5, ("init_samr_r_query_groupinfo\n"));
2924 r_u
->ptr
= (NT_STATUS_IS_OK(status
) && ctr
!= NULL
) ? 1 : 0;
2926 r_u
->status
= status
;
2929 /*******************************************************************
2930 reads or writes a structure.
2931 ********************************************************************/
2933 BOOL
samr_io_r_query_groupinfo(const char *desc
, SAMR_R_QUERY_GROUPINFO
* r_u
,
2934 prs_struct
*ps
, int depth
)
2939 prs_debug(ps
, depth
, desc
, "samr_io_r_query_groupinfo");
2945 if(!prs_uint32("ptr", ps
, depth
, &r_u
->ptr
))
2948 if (r_u
->ptr
!= 0) {
2949 if(!samr_group_info_ctr("ctr", &r_u
->ctr
, ps
, depth
))
2955 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
2961 /*******************************************************************
2962 inits a SAMR_Q_QUERY_GROUPMEM structure.
2963 ********************************************************************/
2965 void init_samr_q_query_groupmem(SAMR_Q_QUERY_GROUPMEM
* q_c
, POLICY_HND
*hnd
)
2967 DEBUG(5, ("init_samr_q_query_groupmem\n"));
2969 q_c
->group_pol
= *hnd
;
2972 /*******************************************************************
2973 reads or writes a structure.
2974 ********************************************************************/
2976 BOOL
samr_io_q_query_groupmem(const char *desc
, SAMR_Q_QUERY_GROUPMEM
* q_u
,
2977 prs_struct
*ps
, int depth
)
2982 prs_debug(ps
, depth
, desc
, "samr_io_q_query_groupmem");
2988 if(!smb_io_pol_hnd("group_pol", &q_u
->group_pol
, ps
, depth
))
2994 /*******************************************************************
2995 inits a SAMR_R_QUERY_GROUPMEM structure.
2996 ********************************************************************/
2998 void init_samr_r_query_groupmem(SAMR_R_QUERY_GROUPMEM
* r_u
,
2999 uint32 num_entries
, uint32
*rid
,
3000 uint32
*attr
, NTSTATUS status
)
3002 DEBUG(5, ("init_samr_r_query_groupmem\n"));
3004 if (NT_STATUS_IS_OK(status
)) {
3006 r_u
->num_entries
= num_entries
;
3008 r_u
->ptr_attrs
= attr
!= NULL
? 1 : 0;
3009 r_u
->ptr_rids
= rid
!= NULL
? 1 : 0;
3011 r_u
->num_rids
= num_entries
;
3014 r_u
->num_attrs
= num_entries
;
3018 r_u
->num_entries
= 0;
3021 r_u
->status
= status
;
3024 /*******************************************************************
3025 reads or writes a structure.
3026 ********************************************************************/
3028 BOOL
samr_io_r_query_groupmem(const char *desc
, SAMR_R_QUERY_GROUPMEM
* r_u
,
3029 prs_struct
*ps
, int depth
)
3036 if (UNMARSHALLING(ps
))
3039 prs_debug(ps
, depth
, desc
, "samr_io_r_query_groupmem");
3045 if(!prs_uint32("ptr", ps
, depth
, &r_u
->ptr
))
3047 if(!prs_uint32("num_entries ", ps
, depth
, &r_u
->num_entries
))
3050 if (r_u
->ptr
!= 0) {
3051 if(!prs_uint32("ptr_rids ", ps
, depth
, &r_u
->ptr_rids
))
3053 if(!prs_uint32("ptr_attrs", ps
, depth
, &r_u
->ptr_attrs
))
3056 if (r_u
->ptr_rids
!= 0) {
3057 if(!prs_uint32("num_rids", ps
, depth
, &r_u
->num_rids
))
3059 if (UNMARSHALLING(ps
) && r_u
->num_rids
!= 0) {
3060 r_u
->rid
= PRS_ALLOC_MEM(ps
,uint32
,r_u
->num_rids
);
3061 if (r_u
->rid
== NULL
)
3065 for (i
= 0; i
< r_u
->num_rids
; i
++) {
3066 if(!prs_uint32("", ps
, depth
, &r_u
->rid
[i
]))
3071 if (r_u
->ptr_attrs
!= 0) {
3072 if(!prs_uint32("num_attrs", ps
, depth
, &r_u
->num_attrs
))
3075 if (UNMARSHALLING(ps
) && r_u
->num_attrs
!= 0) {
3076 r_u
->attr
= PRS_ALLOC_MEM(ps
,uint32
,r_u
->num_attrs
);
3077 if (r_u
->attr
== NULL
)
3081 for (i
= 0; i
< r_u
->num_attrs
; i
++) {
3082 if(!prs_uint32("", ps
, depth
, &r_u
->attr
[i
]))
3088 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
3094 /*******************************************************************
3095 inits a SAMR_Q_QUERY_USERGROUPS structure.
3096 ********************************************************************/
3098 void init_samr_q_query_usergroups(SAMR_Q_QUERY_USERGROUPS
* q_u
,
3101 DEBUG(5, ("init_samr_q_query_usergroups\n"));
3106 /*******************************************************************
3107 reads or writes a structure.
3108 ********************************************************************/
3110 BOOL
samr_io_q_query_usergroups(const char *desc
, SAMR_Q_QUERY_USERGROUPS
* q_u
,
3111 prs_struct
*ps
, int depth
)
3116 prs_debug(ps
, depth
, desc
, "samr_io_q_query_usergroups");
3122 if(!smb_io_pol_hnd("pol", &q_u
->pol
, ps
, depth
))
3128 /*******************************************************************
3129 inits a SAMR_R_QUERY_USERGROUPS structure.
3130 ********************************************************************/
3132 void init_samr_r_query_usergroups(SAMR_R_QUERY_USERGROUPS
* r_u
,
3133 uint32 num_gids
, DOM_GID
* gid
,
3136 DEBUG(5, ("init_samr_r_query_usergroups\n"));
3138 if (NT_STATUS_IS_OK(status
)) {
3140 r_u
->num_entries
= num_gids
;
3141 r_u
->ptr_1
= (num_gids
!= 0) ? 1 : 0;
3142 r_u
->num_entries2
= num_gids
;
3147 r_u
->num_entries
= 0;
3152 r_u
->status
= status
;
3155 /*******************************************************************
3156 reads or writes a structure.
3157 ********************************************************************/
3159 BOOL
samr_io_gids(const char *desc
, uint32
*num_gids
, DOM_GID
** gid
,
3160 prs_struct
*ps
, int depth
)
3166 prs_debug(ps
, depth
, desc
, "samr_io_gids");
3172 if(!prs_uint32("num_gids", ps
, depth
, num_gids
))
3175 if ((*num_gids
) != 0) {
3176 if (UNMARSHALLING(ps
)) {
3177 (*gid
) = PRS_ALLOC_MEM(ps
,DOM_GID
,*num_gids
);
3180 if ((*gid
) == NULL
) {
3184 for (i
= 0; i
< (*num_gids
); i
++) {
3185 if(!smb_io_gid("gids", &(*gid
)[i
], ps
, depth
))
3193 /*******************************************************************
3194 reads or writes a structure.
3195 ********************************************************************/
3197 BOOL
samr_io_r_query_usergroups(const char *desc
, SAMR_R_QUERY_USERGROUPS
* r_u
,
3198 prs_struct
*ps
, int depth
)
3203 prs_debug(ps
, depth
, desc
, "samr_io_r_query_usergroups");
3209 if(!prs_uint32("ptr_0 ", ps
, depth
, &r_u
->ptr_0
))
3212 if (r_u
->ptr_0
!= 0) {
3213 if(!prs_uint32("num_entries ", ps
, depth
, &r_u
->num_entries
))
3215 if(!prs_uint32("ptr_1 ", ps
, depth
, &r_u
->ptr_1
))
3218 if (r_u
->num_entries
!= 0 && r_u
->ptr_1
!= 0) {
3219 if(!samr_io_gids("gids", &r_u
->num_entries2
, &r_u
->gid
, ps
, depth
))
3226 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
3232 /*******************************************************************
3233 inits a SAMR_Q_ENUM_DOMAINS structure.
3234 ********************************************************************/
3236 void init_samr_q_enum_domains(SAMR_Q_ENUM_DOMAINS
* q_e
,
3238 uint32 start_idx
, uint32 size
)
3240 DEBUG(5, ("init_samr_q_enum_domains\n"));
3244 q_e
->start_idx
= start_idx
;
3245 q_e
->max_size
= size
;
3248 /*******************************************************************
3249 reads or writes a structure.
3250 ********************************************************************/
3252 BOOL
samr_io_q_enum_domains(const char *desc
, SAMR_Q_ENUM_DOMAINS
* q_e
,
3253 prs_struct
*ps
, int depth
)
3258 prs_debug(ps
, depth
, desc
, "samr_io_q_enum_domains");
3264 if(!smb_io_pol_hnd("pol", &q_e
->pol
, ps
, depth
))
3267 if(!prs_uint32("start_idx", ps
, depth
, &q_e
->start_idx
))
3269 if(!prs_uint32("max_size ", ps
, depth
, &q_e
->max_size
))
3275 /*******************************************************************
3276 inits a SAMR_R_ENUM_DOMAINS structure.
3277 ********************************************************************/
3279 void init_samr_r_enum_domains(SAMR_R_ENUM_DOMAINS
* r_u
,
3280 uint32 next_idx
, uint32 num_sam_entries
)
3282 DEBUG(5, ("init_samr_r_enum_domains\n"));
3284 r_u
->next_idx
= next_idx
;
3286 if (num_sam_entries
!= 0) {
3287 r_u
->ptr_entries1
= 1;
3288 r_u
->ptr_entries2
= 1;
3289 r_u
->num_entries2
= num_sam_entries
;
3290 r_u
->num_entries3
= num_sam_entries
;
3292 r_u
->num_entries4
= num_sam_entries
;
3294 r_u
->ptr_entries1
= 0;
3295 r_u
->num_entries2
= num_sam_entries
;
3296 r_u
->ptr_entries2
= 1;
3300 /*******************************************************************
3301 reads or writes a structure.
3302 ********************************************************************/
3304 BOOL
samr_io_r_enum_domains(const char *desc
, SAMR_R_ENUM_DOMAINS
* r_u
,
3305 prs_struct
*ps
, int depth
)
3312 prs_debug(ps
, depth
, desc
, "samr_io_r_enum_domains");
3318 if(!prs_uint32("next_idx ", ps
, depth
, &r_u
->next_idx
))
3320 if(!prs_uint32("ptr_entries1", ps
, depth
, &r_u
->ptr_entries1
))
3323 if (r_u
->ptr_entries1
!= 0) {
3324 if(!prs_uint32("num_entries2", ps
, depth
, &r_u
->num_entries2
))
3326 if(!prs_uint32("ptr_entries2", ps
, depth
, &r_u
->ptr_entries2
))
3328 if(!prs_uint32("num_entries3", ps
, depth
, &r_u
->num_entries3
))
3331 if (UNMARSHALLING(ps
)) {
3332 r_u
->sam
= PRS_ALLOC_MEM(ps
,SAM_ENTRY
,r_u
->num_entries2
);
3333 r_u
->uni_dom_name
= PRS_ALLOC_MEM(ps
,UNISTR2
,r_u
->num_entries2
);
3336 if ((r_u
->sam
== NULL
|| r_u
->uni_dom_name
== NULL
) && r_u
->num_entries2
!= 0) {
3337 DEBUG(0, ("NULL pointers in SAMR_R_ENUM_DOMAINS\n"));
3338 r_u
->num_entries4
= 0;
3339 r_u
->status
= NT_STATUS_MEMORY_NOT_ALLOCATED
;
3343 for (i
= 0; i
< r_u
->num_entries2
; i
++) {
3345 slprintf(tmp
, sizeof(tmp
) - 1, "dom[%d]", i
);
3346 if(!sam_io_sam_entry(tmp
, &r_u
->sam
[i
], ps
, depth
))
3350 for (i
= 0; i
< r_u
->num_entries2
; i
++) {
3352 slprintf(tmp
, sizeof(tmp
) - 1, "dom[%d]", i
);
3353 if(!smb_io_unistr2(tmp
, &r_u
->uni_dom_name
[i
],
3354 r_u
->sam
[i
].hdr_name
.buffer
, ps
,
3363 if(!prs_uint32("num_entries4", ps
, depth
, &r_u
->num_entries4
))
3365 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
3371 /*******************************************************************
3372 inits a SAMR_Q_ENUM_DOM_GROUPS structure.
3373 ********************************************************************/
3375 void init_samr_q_enum_dom_groups(SAMR_Q_ENUM_DOM_GROUPS
* q_e
,
3377 uint32 start_idx
, uint32 size
)
3379 DEBUG(5, ("init_samr_q_enum_dom_groups\n"));
3383 q_e
->start_idx
= start_idx
;
3384 q_e
->max_size
= size
;
3387 /*******************************************************************
3388 reads or writes a structure.
3389 ********************************************************************/
3391 BOOL
samr_io_q_enum_dom_groups(const char *desc
, SAMR_Q_ENUM_DOM_GROUPS
* q_e
,
3392 prs_struct
*ps
, int depth
)
3397 prs_debug(ps
, depth
, desc
, "samr_io_q_enum_dom_groups");
3403 if(!smb_io_pol_hnd("pol", &(q_e
->pol
), ps
, depth
))
3406 if(!prs_uint32("start_idx", ps
, depth
, &q_e
->start_idx
))
3408 if(!prs_uint32("max_size ", ps
, depth
, &q_e
->max_size
))
3414 /*******************************************************************
3415 inits a SAMR_R_ENUM_DOM_GROUPS structure.
3416 ********************************************************************/
3418 void init_samr_r_enum_dom_groups(SAMR_R_ENUM_DOM_GROUPS
* r_u
,
3419 uint32 next_idx
, uint32 num_sam_entries
)
3421 DEBUG(5, ("init_samr_r_enum_dom_groups\n"));
3423 r_u
->next_idx
= next_idx
;
3425 if (num_sam_entries
!= 0) {
3426 r_u
->ptr_entries1
= 1;
3427 r_u
->ptr_entries2
= 1;
3428 r_u
->num_entries2
= num_sam_entries
;
3429 r_u
->num_entries3
= num_sam_entries
;
3431 r_u
->num_entries4
= num_sam_entries
;
3433 r_u
->ptr_entries1
= 0;
3434 r_u
->num_entries2
= num_sam_entries
;
3435 r_u
->ptr_entries2
= 1;
3439 /*******************************************************************
3440 reads or writes a structure.
3441 ********************************************************************/
3443 BOOL
samr_io_r_enum_dom_groups(const char *desc
, SAMR_R_ENUM_DOM_GROUPS
* r_u
,
3444 prs_struct
*ps
, int depth
)
3451 prs_debug(ps
, depth
, desc
, "samr_io_r_enum_dom_groups");
3457 if(!prs_uint32("next_idx ", ps
, depth
, &r_u
->next_idx
))
3459 if(!prs_uint32("ptr_entries1", ps
, depth
, &r_u
->ptr_entries1
))
3462 if (r_u
->ptr_entries1
!= 0) {
3463 if(!prs_uint32("num_entries2", ps
, depth
, &r_u
->num_entries2
))
3465 if(!prs_uint32("ptr_entries2", ps
, depth
, &r_u
->ptr_entries2
))
3467 if(!prs_uint32("num_entries3", ps
, depth
, &r_u
->num_entries3
))
3470 if (UNMARSHALLING(ps
)) {
3471 r_u
->sam
= PRS_ALLOC_MEM(ps
,SAM_ENTRY
,r_u
->num_entries2
);
3472 r_u
->uni_grp_name
= PRS_ALLOC_MEM(ps
,UNISTR2
,r_u
->num_entries2
);
3475 if ((r_u
->sam
== NULL
|| r_u
->uni_grp_name
== NULL
) && r_u
->num_entries2
!= 0) {
3477 ("NULL pointers in SAMR_R_ENUM_DOM_GROUPS\n"));
3478 r_u
->num_entries4
= 0;
3479 r_u
->status
= NT_STATUS_MEMORY_NOT_ALLOCATED
;
3483 for (i
= 0; i
< r_u
->num_entries2
; i
++) {
3484 if(!sam_io_sam_entry("", &r_u
->sam
[i
], ps
, depth
))
3488 for (i
= 0; i
< r_u
->num_entries2
; i
++) {
3489 if(!smb_io_unistr2("", &r_u
->uni_grp_name
[i
],
3490 r_u
->sam
[i
].hdr_name
.buffer
, ps
, depth
))
3497 if(!prs_uint32("num_entries4", ps
, depth
, &r_u
->num_entries4
))
3499 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
3505 /*******************************************************************
3506 inits a SAMR_Q_ENUM_DOM_ALIASES structure.
3507 ********************************************************************/
3509 void init_samr_q_enum_dom_aliases(SAMR_Q_ENUM_DOM_ALIASES
* q_e
,
3510 POLICY_HND
*pol
, uint32 start_idx
,
3513 DEBUG(5, ("init_samr_q_enum_dom_aliases\n"));
3517 q_e
->start_idx
= start_idx
;
3518 q_e
->max_size
= size
;
3522 /*******************************************************************
3523 reads or writes a structure.
3524 ********************************************************************/
3526 BOOL
samr_io_q_enum_dom_aliases(const char *desc
, SAMR_Q_ENUM_DOM_ALIASES
* q_e
,
3527 prs_struct
*ps
, int depth
)
3532 prs_debug(ps
, depth
, desc
, "samr_io_q_enum_dom_aliases");
3538 if(!smb_io_pol_hnd("pol", &q_e
->pol
, ps
, depth
))
3541 if(!prs_uint32("start_idx", ps
, depth
, &q_e
->start_idx
))
3543 if(!prs_uint32("max_size ", ps
, depth
, &q_e
->max_size
))
3549 /*******************************************************************
3550 inits a SAMR_R_ENUM_DOM_ALIASES structure.
3551 ********************************************************************/
3553 void init_samr_r_enum_dom_aliases(SAMR_R_ENUM_DOM_ALIASES
*r_u
, uint32 next_idx
, uint32 num_sam_entries
)
3555 DEBUG(5, ("init_samr_r_enum_dom_aliases\n"));
3557 r_u
->next_idx
= next_idx
;
3559 if (num_sam_entries
!= 0) {
3560 r_u
->ptr_entries1
= 1;
3561 r_u
->ptr_entries2
= 1;
3562 r_u
->num_entries2
= num_sam_entries
;
3563 r_u
->num_entries3
= num_sam_entries
;
3565 r_u
->num_entries4
= num_sam_entries
;
3567 r_u
->ptr_entries1
= 0;
3568 r_u
->num_entries2
= num_sam_entries
;
3569 r_u
->ptr_entries2
= 1;
3573 /*******************************************************************
3574 reads or writes a structure.
3575 ********************************************************************/
3577 BOOL
samr_io_r_enum_dom_aliases(const char *desc
, SAMR_R_ENUM_DOM_ALIASES
* r_u
,
3578 prs_struct
*ps
, int depth
)
3585 prs_debug(ps
, depth
, desc
, "samr_io_r_enum_dom_aliases");
3591 if(!prs_uint32("next_idx ", ps
, depth
, &r_u
->next_idx
))
3593 if(!prs_uint32("ptr_entries1", ps
, depth
, &r_u
->ptr_entries1
))
3596 if (r_u
->ptr_entries1
!= 0) {
3597 if(!prs_uint32("num_entries2", ps
, depth
, &r_u
->num_entries2
))
3599 if(!prs_uint32("ptr_entries2", ps
, depth
, &r_u
->ptr_entries2
))
3601 if(!prs_uint32("num_entries3", ps
, depth
, &r_u
->num_entries3
))
3604 if (UNMARSHALLING(ps
) && (r_u
->num_entries2
> 0)) {
3605 r_u
->sam
= PRS_ALLOC_MEM(ps
,SAM_ENTRY
,r_u
->num_entries2
);
3606 r_u
->uni_grp_name
= PRS_ALLOC_MEM(ps
,UNISTR2
,r_u
->num_entries2
);
3609 if (r_u
->num_entries2
!= 0 &&
3610 (r_u
->sam
== NULL
|| r_u
->uni_grp_name
== NULL
)) {
3611 DEBUG(0,("NULL pointers in SAMR_R_ENUM_DOM_ALIASES\n"));
3612 r_u
->num_entries4
= 0;
3613 r_u
->status
= NT_STATUS_MEMORY_NOT_ALLOCATED
;
3617 for (i
= 0; i
< r_u
->num_entries2
; i
++) {
3618 if(!sam_io_sam_entry("", &r_u
->sam
[i
], ps
, depth
))
3622 for (i
= 0; i
< r_u
->num_entries2
; i
++) {
3623 if(!smb_io_unistr2("", &r_u
->uni_grp_name
[i
],
3624 r_u
->sam
[i
].hdr_name
.buffer
, ps
,
3632 if(!prs_uint32("num_entries4", ps
, depth
, &r_u
->num_entries4
))
3634 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
3640 /*******************************************************************
3641 inits a ALIAS_INFO1 structure.
3642 ********************************************************************/
3644 void init_samr_alias_info1(ALIAS_INFO1
* al1
, char *acct_name
, uint32 num_member
, char *acct_desc
)
3646 DEBUG(5, ("init_samr_alias_info1\n"));
3648 init_unistr4(&al1
->name
, acct_name
, UNI_FLAGS_NONE
);
3649 al1
->num_member
= num_member
;
3650 init_unistr4(&al1
->description
, acct_desc
, UNI_FLAGS_NONE
);
3653 /*******************************************************************
3654 reads or writes a structure.
3655 ********************************************************************/
3657 BOOL
samr_io_alias_info1(const char *desc
, ALIAS_INFO1
* al1
,
3658 prs_struct
*ps
, int depth
)
3663 prs_debug(ps
, depth
, desc
, "samr_io_alias_info1");
3669 if ( !prs_unistr4_hdr("name", ps
, depth
, &al1
->name
) )
3671 if ( !prs_uint32("num_member", ps
, depth
, &al1
->num_member
) )
3673 if ( !prs_unistr4_hdr("description", ps
, depth
, &al1
->description
) )
3676 if ( !prs_unistr4_str("name", ps
, depth
, &al1
->name
) )
3678 if ( !prs_align(ps
) )
3680 if ( !prs_unistr4_str("description", ps
, depth
, &al1
->description
) )
3682 if ( !prs_align(ps
) )
3688 /*******************************************************************
3689 inits a ALIAS_INFO3 structure.
3690 ********************************************************************/
3692 void init_samr_alias_info3(ALIAS_INFO3
* al3
, const char *acct_desc
)
3694 DEBUG(5, ("init_samr_alias_info3\n"));
3696 init_unistr4(&al3
->description
, acct_desc
, UNI_FLAGS_NONE
);
3699 /*******************************************************************
3700 reads or writes a structure.
3701 ********************************************************************/
3703 BOOL
samr_io_alias_info3(const char *desc
, ALIAS_INFO3
*al3
,
3704 prs_struct
*ps
, int depth
)
3709 prs_debug(ps
, depth
, desc
, "samr_io_alias_info3");
3715 if (!prs_unistr4("description", ps
, depth
, &al3
->description
))
3721 /*******************************************************************
3722 reads or writes a structure.
3723 ********************************************************************/
3725 BOOL
samr_io_alias_info2(const char *desc
, ALIAS_INFO2
*al2
,
3726 prs_struct
*ps
, int depth
)
3731 prs_debug(ps
, depth
, desc
, "samr_io_alias_info2");
3737 if (!prs_unistr4("name", ps
, depth
, &al2
->name
))
3743 /*******************************************************************
3744 reads or writes a structure.
3745 ********************************************************************/
3747 BOOL
samr_alias_info_ctr(const char *desc
, prs_struct
*ps
, int depth
, ALIAS_INFO_CTR
* ctr
)
3752 prs_debug(ps
, depth
, desc
, "samr_alias_info_ctr");
3755 if ( !prs_uint16("level", ps
, depth
, &ctr
->level
) )
3760 switch (ctr
->level
) {
3762 if(!samr_io_alias_info1("alias_info1", &ctr
->alias
.info1
, ps
, depth
))
3766 if(!samr_io_alias_info2("alias_info2", &ctr
->alias
.info2
, ps
, depth
))
3770 if(!samr_io_alias_info3("alias_info3", &ctr
->alias
.info3
, ps
, depth
))
3774 DEBUG(0,("samr_alias_info_ctr: unsupported switch level\n"));
3781 /*******************************************************************
3782 inits a SAMR_Q_QUERY_ALIASINFO structure.
3783 ********************************************************************/
3785 void init_samr_q_query_aliasinfo(SAMR_Q_QUERY_ALIASINFO
* q_e
,
3786 POLICY_HND
*pol
, uint32 switch_level
)
3788 DEBUG(5, ("init_samr_q_query_aliasinfo\n"));
3791 q_e
->level
= switch_level
;
3794 /*******************************************************************
3795 reads or writes a structure.
3796 ********************************************************************/
3798 BOOL
samr_io_q_query_aliasinfo(const char *desc
, SAMR_Q_QUERY_ALIASINFO
*in
,
3799 prs_struct
*ps
, int depth
)
3804 prs_debug(ps
, depth
, desc
, "samr_io_q_query_aliasinfo");
3810 if ( !smb_io_pol_hnd("pol", &(in
->pol
), ps
, depth
) )
3813 if ( !prs_uint16("level", ps
, depth
, &in
->level
) )
3819 /*******************************************************************
3820 inits a SAMR_R_QUERY_ALIASINFO structure.
3821 ********************************************************************/
3823 void init_samr_r_query_aliasinfo(SAMR_R_QUERY_ALIASINFO
*out
,
3824 ALIAS_INFO_CTR
* ctr
, NTSTATUS status
)
3826 DEBUG(5, ("init_samr_r_query_aliasinfo\n"));
3829 out
->status
= status
;
3832 /*******************************************************************
3833 reads or writes a structure.
3834 ********************************************************************/
3836 BOOL
samr_io_r_query_aliasinfo(const char *desc
, SAMR_R_QUERY_ALIASINFO
*out
,
3837 prs_struct
*ps
, int depth
)
3842 prs_debug(ps
, depth
, desc
, "samr_io_r_query_aliasinfo");
3848 if ( !prs_pointer("alias", ps
, depth
, (void*)&out
->ctr
, sizeof(ALIAS_INFO_CTR
), (PRS_POINTER_CAST
)samr_alias_info_ctr
))
3853 if(!prs_ntstatus("status", ps
, depth
, &out
->status
))
3859 /*******************************************************************
3860 inits a SAMR_Q_SET_ALIASINFO structure.
3861 ********************************************************************/
3863 void init_samr_q_set_aliasinfo(SAMR_Q_SET_ALIASINFO
* q_u
,
3864 POLICY_HND
*hnd
, ALIAS_INFO_CTR
* ctr
)
3866 DEBUG(5, ("init_samr_q_set_aliasinfo\n"));
3868 q_u
->alias_pol
= *hnd
;
3872 /*******************************************************************
3873 reads or writes a structure.
3874 ********************************************************************/
3876 BOOL
samr_io_q_set_aliasinfo(const char *desc
, SAMR_Q_SET_ALIASINFO
* q_u
,
3877 prs_struct
*ps
, int depth
)
3882 prs_debug(ps
, depth
, desc
, "samr_io_q_set_aliasinfo");
3888 if(!smb_io_pol_hnd("alias_pol", &q_u
->alias_pol
, ps
, depth
))
3890 if(!samr_alias_info_ctr("ctr", ps
, depth
, &q_u
->ctr
))
3896 /*******************************************************************
3897 reads or writes a structure.
3898 ********************************************************************/
3900 BOOL
samr_io_r_set_aliasinfo(const char *desc
, SAMR_R_SET_ALIASINFO
* r_u
,
3901 prs_struct
*ps
, int depth
)
3906 prs_debug(ps
, depth
, desc
, "samr_io_r_set_aliasinfo");
3911 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
3917 /*******************************************************************
3918 inits a SAMR_Q_QUERY_USERALIASES structure.
3919 ********************************************************************/
3921 void init_samr_q_query_useraliases(SAMR_Q_QUERY_USERALIASES
* q_u
,
3924 uint32
*ptr_sid
, DOM_SID2
* sid
)
3926 DEBUG(5, ("init_samr_q_query_useraliases\n"));
3930 q_u
->num_sids1
= num_sids
;
3932 q_u
->num_sids2
= num_sids
;
3934 q_u
->ptr_sid
= ptr_sid
;
3938 /*******************************************************************
3939 reads or writes a SAMR_Q_QUERY_USERALIASES structure.
3940 ********************************************************************/
3942 BOOL
samr_io_q_query_useraliases(const char *desc
, SAMR_Q_QUERY_USERALIASES
* q_u
,
3943 prs_struct
*ps
, int depth
)
3951 prs_debug(ps
, depth
, desc
, "samr_io_q_query_useraliases");
3957 if(!smb_io_pol_hnd("pol", &q_u
->pol
, ps
, depth
))
3960 if(!prs_uint32("num_sids1", ps
, depth
, &q_u
->num_sids1
))
3962 if(!prs_uint32("ptr ", ps
, depth
, &q_u
->ptr
))
3968 if(!prs_uint32("num_sids2", ps
, depth
, &q_u
->num_sids2
))
3971 if (UNMARSHALLING(ps
) && (q_u
->num_sids2
!= 0)) {
3972 q_u
->ptr_sid
= PRS_ALLOC_MEM(ps
,uint32
,q_u
->num_sids2
);
3973 if (q_u
->ptr_sid
== NULL
)
3976 q_u
->sid
= PRS_ALLOC_MEM(ps
, DOM_SID2
, q_u
->num_sids2
);
3977 if (q_u
->sid
== NULL
)
3981 for (i
= 0; i
< q_u
->num_sids2
; i
++) {
3982 slprintf(tmp
, sizeof(tmp
) - 1, "ptr[%02d]", i
);
3983 if(!prs_uint32(tmp
, ps
, depth
, &q_u
->ptr_sid
[i
]))
3987 for (i
= 0; i
< q_u
->num_sids2
; i
++) {
3988 if (q_u
->ptr_sid
[i
] != 0) {
3989 slprintf(tmp
, sizeof(tmp
) - 1, "sid[%02d]", i
);
3990 if(!smb_io_dom_sid2(tmp
, &q_u
->sid
[i
], ps
, depth
))
3998 /*******************************************************************
3999 inits a SAMR_R_QUERY_USERALIASES structure.
4000 ********************************************************************/
4002 void init_samr_r_query_useraliases(SAMR_R_QUERY_USERALIASES
* r_u
,
4003 uint32 num_rids
, uint32
*rid
,
4006 DEBUG(5, ("init_samr_r_query_useraliases\n"));
4008 if (NT_STATUS_IS_OK(status
)) {
4009 r_u
->num_entries
= num_rids
;
4011 r_u
->num_entries2
= num_rids
;
4015 r_u
->num_entries
= 0;
4017 r_u
->num_entries2
= 0;
4020 r_u
->status
= status
;
4023 /*******************************************************************
4024 reads or writes a structure.
4025 ********************************************************************/
4027 BOOL
samr_io_rids(const char *desc
, uint32
*num_rids
, uint32
**rid
,
4028 prs_struct
*ps
, int depth
)
4035 prs_debug(ps
, depth
, desc
, "samr_io_rids");
4041 if(!prs_uint32("num_rids", ps
, depth
, num_rids
))
4044 if ((*num_rids
) != 0) {
4045 if (UNMARSHALLING(ps
)) {
4047 (*rid
) = PRS_ALLOC_MEM(ps
,uint32
, *num_rids
);
4052 for (i
= 0; i
< (*num_rids
); i
++) {
4053 slprintf(tmp
, sizeof(tmp
) - 1, "rid[%02d]", i
);
4054 if(!prs_uint32(tmp
, ps
, depth
, &((*rid
)[i
])))
4062 /*******************************************************************
4063 reads or writes a structure.
4064 ********************************************************************/
4066 BOOL
samr_io_r_query_useraliases(const char *desc
, SAMR_R_QUERY_USERALIASES
* r_u
,
4067 prs_struct
*ps
, int depth
)
4072 prs_debug(ps
, depth
, desc
, "samr_io_r_query_useraliases");
4078 if(!prs_uint32("num_entries", ps
, depth
, &r_u
->num_entries
))
4080 if(!prs_uint32("ptr ", ps
, depth
, &r_u
->ptr
))
4083 if (r_u
->ptr
!= 0) {
4084 if(!samr_io_rids("rids", &r_u
->num_entries2
, &r_u
->rid
, ps
, depth
))
4090 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
4096 /*******************************************************************
4097 inits a SAMR_Q_OPEN_ALIAS structure.
4098 ********************************************************************/
4100 void init_samr_q_open_alias(SAMR_Q_OPEN_ALIAS
* q_u
, POLICY_HND
*pol
,
4101 uint32 access_mask
, uint32 rid
)
4103 DEBUG(5, ("init_samr_q_open_alias\n"));
4105 q_u
->dom_pol
= *pol
;
4106 q_u
->access_mask
= access_mask
;
4107 q_u
->rid_alias
= rid
;
4110 /*******************************************************************
4111 reads or writes a structure.
4112 ********************************************************************/
4114 BOOL
samr_io_q_open_alias(const char *desc
, SAMR_Q_OPEN_ALIAS
* q_u
,
4115 prs_struct
*ps
, int depth
)
4120 prs_debug(ps
, depth
, desc
, "samr_io_q_open_alias");
4126 if(!smb_io_pol_hnd("domain_pol", &q_u
->dom_pol
, ps
, depth
))
4129 if(!prs_uint32("access_mask", ps
, depth
, &q_u
->access_mask
))
4131 if(!prs_uint32("rid_alias", ps
, depth
, &q_u
->rid_alias
))
4137 /*******************************************************************
4138 reads or writes a structure.
4139 ********************************************************************/
4141 BOOL
samr_io_r_open_alias(const char *desc
, SAMR_R_OPEN_ALIAS
* r_u
,
4142 prs_struct
*ps
, int depth
)
4147 prs_debug(ps
, depth
, desc
, "samr_io_r_open_alias");
4153 if(!smb_io_pol_hnd("pol", &r_u
->pol
, ps
, depth
))
4156 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
4162 /*******************************************************************
4163 inits a SAMR_Q_LOOKUP_RIDS structure.
4164 ********************************************************************/
4166 void init_samr_q_lookup_rids(TALLOC_CTX
*ctx
, SAMR_Q_LOOKUP_RIDS
* q_u
,
4167 POLICY_HND
*pol
, uint32 flags
,
4168 uint32 num_rids
, uint32
*rid
)
4170 DEBUG(5, ("init_samr_q_lookup_rids\n"));
4174 q_u
->num_rids1
= num_rids
;
4177 q_u
->num_rids2
= num_rids
;
4178 q_u
->rid
= TALLOC_ZERO_ARRAY(ctx
, uint32
, num_rids
);
4179 if (q_u
->rid
== NULL
) {
4183 memcpy(q_u
->rid
, rid
, num_rids
* sizeof(q_u
->rid
[0]));
4187 /*******************************************************************
4188 reads or writes a structure.
4189 ********************************************************************/
4191 BOOL
samr_io_q_lookup_rids(const char *desc
, SAMR_Q_LOOKUP_RIDS
* q_u
,
4192 prs_struct
*ps
, int depth
)
4200 prs_debug(ps
, depth
, desc
, "samr_io_q_lookup_rids");
4203 if (UNMARSHALLING(ps
))
4209 if(!smb_io_pol_hnd("pol", &q_u
->pol
, ps
, depth
))
4212 if(!prs_uint32("num_rids1", ps
, depth
, &q_u
->num_rids1
))
4214 if(!prs_uint32("flags ", ps
, depth
, &q_u
->flags
))
4216 if(!prs_uint32("ptr ", ps
, depth
, &q_u
->ptr
))
4218 if(!prs_uint32("num_rids2", ps
, depth
, &q_u
->num_rids2
))
4221 if (UNMARSHALLING(ps
) && (q_u
->num_rids2
!= 0)) {
4222 q_u
->rid
= PRS_ALLOC_MEM(ps
, uint32
, q_u
->num_rids2
);
4223 if (q_u
->rid
== NULL
)
4227 for (i
= 0; i
< q_u
->num_rids2
; i
++) {
4228 slprintf(tmp
, sizeof(tmp
) - 1, "rid[%02d] ", i
);
4229 if(!prs_uint32(tmp
, ps
, depth
, &q_u
->rid
[i
]))
4236 /*******************************************************************
4237 inits a SAMR_R_LOOKUP_RIDS structure.
4238 ********************************************************************/
4240 void init_samr_r_lookup_rids(SAMR_R_LOOKUP_RIDS
* r_u
,
4241 uint32 num_names
, UNIHDR
* hdr_name
,
4242 UNISTR2
*uni_name
, uint32
*type
)
4244 DEBUG(5, ("init_samr_r_lookup_rids\n"));
4246 r_u
->hdr_name
= NULL
;
4247 r_u
->uni_name
= NULL
;
4250 if (num_names
!= 0) {
4251 r_u
->num_names1
= num_names
;
4253 r_u
->num_names2
= num_names
;
4255 r_u
->num_types1
= num_names
;
4257 r_u
->num_types2
= num_names
;
4259 r_u
->hdr_name
= hdr_name
;
4260 r_u
->uni_name
= uni_name
;
4263 r_u
->num_names1
= num_names
;
4265 r_u
->num_names2
= num_names
;
4267 r_u
->num_types1
= num_names
;
4269 r_u
->num_types2
= num_names
;
4273 /*******************************************************************
4274 reads or writes a structure.
4275 ********************************************************************/
4277 BOOL
samr_io_r_lookup_rids(const char *desc
, SAMR_R_LOOKUP_RIDS
* r_u
,
4278 prs_struct
*ps
, int depth
)
4285 prs_debug(ps
, depth
, desc
, "samr_io_r_lookup_rids");
4291 if(!prs_uint32("num_names1", ps
, depth
, &r_u
->num_names1
))
4293 if(!prs_uint32("ptr_names ", ps
, depth
, &r_u
->ptr_names
))
4296 if (r_u
->ptr_names
!= 0) {
4298 if(!prs_uint32("num_names2", ps
, depth
, &r_u
->num_names2
))
4302 if (UNMARSHALLING(ps
) && (r_u
->num_names2
!= 0)) {
4303 r_u
->hdr_name
= PRS_ALLOC_MEM(ps
, UNIHDR
, r_u
->num_names2
);
4304 if (r_u
->hdr_name
== NULL
)
4307 r_u
->uni_name
= PRS_ALLOC_MEM(ps
, UNISTR2
, r_u
->num_names2
);
4308 if (r_u
->uni_name
== NULL
)
4312 for (i
= 0; i
< r_u
->num_names2
; i
++) {
4313 slprintf(tmp
, sizeof(tmp
) - 1, "hdr[%02d] ", i
);
4314 if(!smb_io_unihdr("", &r_u
->hdr_name
[i
], ps
, depth
))
4317 for (i
= 0; i
< r_u
->num_names2
; i
++) {
4318 slprintf(tmp
, sizeof(tmp
) - 1, "str[%02d] ", i
);
4319 if(!smb_io_unistr2("", &r_u
->uni_name
[i
], r_u
->hdr_name
[i
].buffer
, ps
, depth
))
4327 if(!prs_uint32("num_types1", ps
, depth
, &r_u
->num_types1
))
4329 if(!prs_uint32("ptr_types ", ps
, depth
, &r_u
->ptr_types
))
4332 if (r_u
->ptr_types
!= 0) {
4334 if(!prs_uint32("num_types2", ps
, depth
, &r_u
->num_types2
))
4337 if (UNMARSHALLING(ps
) && (r_u
->num_types2
!= 0)) {
4338 r_u
->type
= PRS_ALLOC_MEM(ps
, uint32
, r_u
->num_types2
);
4339 if (r_u
->type
== NULL
)
4343 for (i
= 0; i
< r_u
->num_types2
; i
++) {
4344 slprintf(tmp
, sizeof(tmp
) - 1, "type[%02d] ", i
);
4345 if(!prs_uint32(tmp
, ps
, depth
, &r_u
->type
[i
]))
4350 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
4356 /*******************************************************************
4357 inits a SAMR_Q_OPEN_ALIAS structure.
4358 ********************************************************************/
4360 void init_samr_q_delete_alias(SAMR_Q_DELETE_DOM_ALIAS
* q_u
, POLICY_HND
*hnd
)
4362 DEBUG(5, ("init_samr_q_delete_alias\n"));
4364 q_u
->alias_pol
= *hnd
;
4367 /*******************************************************************
4368 reads or writes a structure.
4369 ********************************************************************/
4371 BOOL
samr_io_q_delete_alias(const char *desc
, SAMR_Q_DELETE_DOM_ALIAS
* q_u
,
4372 prs_struct
*ps
, int depth
)
4377 prs_debug(ps
, depth
, desc
, "samr_io_q_delete_alias");
4383 if(!smb_io_pol_hnd("alias_pol", &q_u
->alias_pol
, ps
, depth
))
4389 /*******************************************************************
4390 reads or writes a structure.
4391 ********************************************************************/
4393 BOOL
samr_io_r_delete_alias(const char *desc
, SAMR_R_DELETE_DOM_ALIAS
* r_u
,
4394 prs_struct
*ps
, int depth
)
4399 prs_debug(ps
, depth
, desc
, "samr_io_r_delete_alias");
4405 if(!smb_io_pol_hnd("pol", &r_u
->pol
, ps
, depth
))
4407 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
4413 /*******************************************************************
4414 inits a SAMR_Q_CREATE_DOM_ALIAS structure.
4415 ********************************************************************/
4417 void init_samr_q_create_dom_alias(SAMR_Q_CREATE_DOM_ALIAS
* q_u
,
4418 POLICY_HND
*hnd
, const char *acct_desc
)
4420 DEBUG(5, ("init_samr_q_create_dom_alias\n"));
4422 q_u
->dom_pol
= *hnd
;
4424 init_unistr2(&q_u
->uni_acct_desc
, acct_desc
, UNI_FLAGS_NONE
);
4425 init_uni_hdr(&q_u
->hdr_acct_desc
, &q_u
->uni_acct_desc
);
4427 q_u
->access_mask
= MAXIMUM_ALLOWED_ACCESS
;
4430 /*******************************************************************
4431 reads or writes a structure.
4432 ********************************************************************/
4434 BOOL
samr_io_q_create_dom_alias(const char *desc
, SAMR_Q_CREATE_DOM_ALIAS
* q_u
,
4435 prs_struct
*ps
, int depth
)
4440 prs_debug(ps
, depth
, desc
, "samr_io_q_create_dom_alias");
4446 if(!smb_io_pol_hnd("dom_pol", &q_u
->dom_pol
, ps
, depth
))
4449 if(!smb_io_unihdr("hdr_acct_desc", &q_u
->hdr_acct_desc
, ps
, depth
))
4451 if(!smb_io_unistr2("uni_acct_desc", &q_u
->uni_acct_desc
,
4452 q_u
->hdr_acct_desc
.buffer
, ps
, depth
))
4457 if(!prs_uint32("access_mask", ps
, depth
, &q_u
->access_mask
))
4463 /*******************************************************************
4464 reads or writes a structure.
4465 ********************************************************************/
4467 BOOL
samr_io_r_create_dom_alias(const char *desc
, SAMR_R_CREATE_DOM_ALIAS
* r_u
,
4468 prs_struct
*ps
, int depth
)
4473 prs_debug(ps
, depth
, desc
, "samr_io_r_create_dom_alias");
4479 if(!smb_io_pol_hnd("alias_pol", &r_u
->alias_pol
, ps
, depth
))
4482 if(!prs_uint32("rid", ps
, depth
, &r_u
->rid
))
4485 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
4491 /*******************************************************************
4492 inits a SAMR_Q_ADD_ALIASMEM structure.
4493 ********************************************************************/
4495 void init_samr_q_add_aliasmem(SAMR_Q_ADD_ALIASMEM
* q_u
, POLICY_HND
*hnd
,
4498 DEBUG(5, ("init_samr_q_add_aliasmem\n"));
4500 q_u
->alias_pol
= *hnd
;
4501 init_dom_sid2(&q_u
->sid
, sid
);
4504 /*******************************************************************
4505 reads or writes a structure.
4506 ********************************************************************/
4508 BOOL
samr_io_q_add_aliasmem(const char *desc
, SAMR_Q_ADD_ALIASMEM
* q_u
,
4509 prs_struct
*ps
, int depth
)
4514 prs_debug(ps
, depth
, desc
, "samr_io_q_add_aliasmem");
4520 if(!smb_io_pol_hnd("alias_pol", &q_u
->alias_pol
, ps
, depth
))
4522 if(!smb_io_dom_sid2("sid ", &q_u
->sid
, ps
, depth
))
4528 /*******************************************************************
4529 reads or writes a structure.
4530 ********************************************************************/
4532 BOOL
samr_io_r_add_aliasmem(const char *desc
, SAMR_R_ADD_ALIASMEM
* r_u
,
4533 prs_struct
*ps
, int depth
)
4538 prs_debug(ps
, depth
, desc
, "samr_io_r_add_aliasmem");
4544 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
4550 /*******************************************************************
4551 inits a SAMR_Q_DEL_ALIASMEM structure.
4552 ********************************************************************/
4554 void init_samr_q_del_aliasmem(SAMR_Q_DEL_ALIASMEM
* q_u
, POLICY_HND
*hnd
,
4557 DEBUG(5, ("init_samr_q_del_aliasmem\n"));
4559 q_u
->alias_pol
= *hnd
;
4560 init_dom_sid2(&q_u
->sid
, sid
);
4563 /*******************************************************************
4564 reads or writes a structure.
4565 ********************************************************************/
4567 BOOL
samr_io_q_del_aliasmem(const char *desc
, SAMR_Q_DEL_ALIASMEM
* q_u
,
4568 prs_struct
*ps
, int depth
)
4573 prs_debug(ps
, depth
, desc
, "samr_io_q_del_aliasmem");
4579 if(!smb_io_pol_hnd("alias_pol", &q_u
->alias_pol
, ps
, depth
))
4581 if(!smb_io_dom_sid2("sid ", &q_u
->sid
, ps
, depth
))
4587 /*******************************************************************
4588 reads or writes a structure.
4589 ********************************************************************/
4591 BOOL
samr_io_r_del_aliasmem(const char *desc
, SAMR_R_DEL_ALIASMEM
* r_u
,
4592 prs_struct
*ps
, int depth
)
4597 prs_debug(ps
, depth
, desc
, "samr_io_r_del_aliasmem");
4603 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
4609 /*******************************************************************
4610 inits a SAMR_Q_DELETE_DOM_ALIAS structure.
4611 ********************************************************************/
4613 void init_samr_q_delete_dom_alias(SAMR_Q_DELETE_DOM_ALIAS
* q_c
,
4616 DEBUG(5, ("init_samr_q_delete_dom_alias\n"));
4618 q_c
->alias_pol
= *hnd
;
4621 /*******************************************************************
4622 reads or writes a structure.
4623 ********************************************************************/
4625 BOOL
samr_io_q_delete_dom_alias(const char *desc
, SAMR_Q_DELETE_DOM_ALIAS
* q_u
,
4626 prs_struct
*ps
, int depth
)
4631 prs_debug(ps
, depth
, desc
, "samr_io_q_delete_dom_alias");
4637 if(!smb_io_pol_hnd("alias_pol", &q_u
->alias_pol
, ps
, depth
))
4643 /*******************************************************************
4644 inits a SAMR_R_DELETE_DOM_ALIAS structure.
4645 ********************************************************************/
4647 void init_samr_r_delete_dom_alias(SAMR_R_DELETE_DOM_ALIAS
* r_u
,
4650 DEBUG(5, ("init_samr_r_delete_dom_alias\n"));
4652 r_u
->status
= status
;
4655 /*******************************************************************
4656 reads or writes a structure.
4657 ********************************************************************/
4659 BOOL
samr_io_r_delete_dom_alias(const char *desc
, SAMR_R_DELETE_DOM_ALIAS
* r_u
,
4660 prs_struct
*ps
, int depth
)
4665 prs_debug(ps
, depth
, desc
, "samr_io_r_delete_dom_alias");
4671 if(!smb_io_pol_hnd("pol", &r_u
->pol
, ps
, depth
))
4674 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
4680 /*******************************************************************
4681 inits a SAMR_Q_QUERY_ALIASMEM structure.
4682 ********************************************************************/
4684 void init_samr_q_query_aliasmem(SAMR_Q_QUERY_ALIASMEM
* q_c
,
4687 DEBUG(5, ("init_samr_q_query_aliasmem\n"));
4689 q_c
->alias_pol
= *hnd
;
4692 /*******************************************************************
4693 reads or writes a structure.
4694 ********************************************************************/
4696 BOOL
samr_io_q_query_aliasmem(const char *desc
, SAMR_Q_QUERY_ALIASMEM
* q_u
,
4697 prs_struct
*ps
, int depth
)
4702 prs_debug(ps
, depth
, desc
, "samr_io_q_query_aliasmem");
4708 if(!smb_io_pol_hnd("alias_pol", &q_u
->alias_pol
, ps
, depth
))
4714 /*******************************************************************
4715 inits a SAMR_R_QUERY_ALIASMEM structure.
4716 ********************************************************************/
4718 void init_samr_r_query_aliasmem(SAMR_R_QUERY_ALIASMEM
* r_u
,
4719 uint32 num_sids
, DOM_SID2
* sid
,
4722 DEBUG(5, ("init_samr_r_query_aliasmem\n"));
4724 if (NT_STATUS_IS_OK(status
)) {
4725 r_u
->num_sids
= num_sids
;
4726 r_u
->ptr
= (num_sids
!= 0) ? 1 : 0;
4727 r_u
->num_sids1
= num_sids
;
4735 r_u
->status
= status
;
4738 /*******************************************************************
4739 reads or writes a structure.
4740 ********************************************************************/
4742 BOOL
samr_io_r_query_aliasmem(const char *desc
, SAMR_R_QUERY_ALIASMEM
* r_u
,
4743 prs_struct
*ps
, int depth
)
4750 prs_debug(ps
, depth
, desc
, "samr_io_r_query_aliasmem");
4756 if(!prs_uint32("num_sids ", ps
, depth
, &r_u
->num_sids
))
4758 if(!prs_uint32("ptr", ps
, depth
, &r_u
->ptr
))
4761 if (r_u
->ptr
!= 0 && r_u
->num_sids
!= 0) {
4762 uint32
*ptr_sid
= NULL
;
4764 if(!prs_uint32("num_sids1", ps
, depth
, &r_u
->num_sids1
))
4767 ptr_sid
= TALLOC_ARRAY(ps
->mem_ctx
, uint32
, r_u
->num_sids1
);
4772 for (i
= 0; i
< r_u
->num_sids1
; i
++) {
4774 if(!prs_uint32("ptr_sid", ps
, depth
, &ptr_sid
[i
]))
4778 if (UNMARSHALLING(ps
)) {
4779 r_u
->sid
= TALLOC_ARRAY(ps
->mem_ctx
, DOM_SID2
, r_u
->num_sids1
);
4782 for (i
= 0; i
< r_u
->num_sids1
; i
++) {
4783 if (ptr_sid
[i
] != 0) {
4784 if(!smb_io_dom_sid2("sid", &r_u
->sid
[i
], ps
, depth
))
4792 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
4798 /*******************************************************************
4799 inits a SAMR_Q_LOOKUP_NAMES structure.
4800 ********************************************************************/
4802 NTSTATUS
init_samr_q_lookup_names(TALLOC_CTX
*ctx
, SAMR_Q_LOOKUP_NAMES
* q_u
,
4803 POLICY_HND
*pol
, uint32 flags
,
4804 uint32 num_names
, const char **name
)
4808 DEBUG(5, ("init_samr_q_lookup_names\n"));
4812 q_u
->num_names1
= num_names
;
4815 q_u
->num_names2
= num_names
;
4817 if (!(q_u
->hdr_name
= TALLOC_ZERO_ARRAY(ctx
, UNIHDR
, num_names
)))
4818 return NT_STATUS_NO_MEMORY
;
4820 if (!(q_u
->uni_name
= TALLOC_ZERO_ARRAY(ctx
, UNISTR2
, num_names
)))
4821 return NT_STATUS_NO_MEMORY
;
4823 for (i
= 0; i
< num_names
; i
++) {
4824 init_unistr2(&q_u
->uni_name
[i
], name
[i
], UNI_FLAGS_NONE
); /* unicode string for machine account */
4825 init_uni_hdr(&q_u
->hdr_name
[i
], &q_u
->uni_name
[i
]); /* unicode header for user_name */
4828 return NT_STATUS_OK
;
4831 /*******************************************************************
4832 reads or writes a structure.
4833 ********************************************************************/
4835 BOOL
samr_io_q_lookup_names(const char *desc
, SAMR_Q_LOOKUP_NAMES
* q_u
,
4836 prs_struct
*ps
, int depth
)
4843 prs_debug(ps
, depth
, desc
, "samr_io_q_lookup_names");
4846 if (UNMARSHALLING(ps
))
4852 if(!smb_io_pol_hnd("pol", &q_u
->pol
, ps
, depth
))
4855 if(!prs_uint32("num_names1", ps
, depth
, &q_u
->num_names1
))
4857 if(!prs_uint32("flags ", ps
, depth
, &q_u
->flags
))
4859 if(!prs_uint32("ptr ", ps
, depth
, &q_u
->ptr
))
4861 if(!prs_uint32("num_names2", ps
, depth
, &q_u
->num_names2
))
4864 if (UNMARSHALLING(ps
) && (q_u
->num_names2
!= 0)) {
4865 q_u
->hdr_name
= PRS_ALLOC_MEM(ps
, UNIHDR
, q_u
->num_names2
);
4866 q_u
->uni_name
= PRS_ALLOC_MEM(ps
, UNISTR2
, q_u
->num_names2
);
4867 if (!q_u
->hdr_name
|| !q_u
->uni_name
)
4871 for (i
= 0; i
< q_u
->num_names2
; i
++) {
4872 if(!smb_io_unihdr("", &q_u
->hdr_name
[i
], ps
, depth
))
4876 for (i
= 0; i
< q_u
->num_names2
; i
++) {
4877 if(!smb_io_unistr2("", &q_u
->uni_name
[i
], q_u
->hdr_name
[i
].buffer
, ps
, depth
))
4884 /*******************************************************************
4885 inits a SAMR_R_LOOKUP_NAMES structure.
4886 ********************************************************************/
4888 NTSTATUS
init_samr_r_lookup_names(TALLOC_CTX
*ctx
, SAMR_R_LOOKUP_NAMES
* r_u
,
4890 uint32
*rid
, enum lsa_SidType
*type
,
4893 DEBUG(5, ("init_samr_r_lookup_names\n"));
4895 if (NT_STATUS_IS_OK(status
) && (num_rids
!= 0)) {
4898 r_u
->num_types1
= num_rids
;
4900 r_u
->num_types2
= num_rids
;
4902 r_u
->num_rids1
= num_rids
;
4904 r_u
->num_rids2
= num_rids
;
4906 if (!(r_u
->rids
= TALLOC_ZERO_ARRAY(ctx
, uint32
, num_rids
)))
4907 return NT_STATUS_NO_MEMORY
;
4908 if (!(r_u
->types
= TALLOC_ZERO_ARRAY(ctx
, uint32
, num_rids
)))
4909 return NT_STATUS_NO_MEMORY
;
4911 if (!r_u
->rids
|| !r_u
->types
)
4914 for (i
= 0; i
< num_rids
; i
++) {
4915 r_u
->rids
[i
] = rid
[i
];
4916 r_u
->types
[i
] = type
[i
];
4921 r_u
->num_types1
= 0;
4923 r_u
->num_types2
= 0;
4933 r_u
->status
= status
;
4935 return NT_STATUS_OK
;
4938 /*******************************************************************
4939 reads or writes a structure.
4940 ********************************************************************/
4942 BOOL
samr_io_r_lookup_names(const char *desc
, SAMR_R_LOOKUP_NAMES
* r_u
,
4943 prs_struct
*ps
, int depth
)
4951 prs_debug(ps
, depth
, desc
, "samr_io_r_lookup_names");
4954 if (UNMARSHALLING(ps
))
4960 if(!prs_uint32("num_rids1", ps
, depth
, &r_u
->num_rids1
))
4962 if(!prs_uint32("ptr_rids ", ps
, depth
, &r_u
->ptr_rids
))
4965 if (r_u
->ptr_rids
!= 0) {
4966 if(!prs_uint32("num_rids2", ps
, depth
, &r_u
->num_rids2
))
4969 if (r_u
->num_rids2
!= r_u
->num_rids1
) {
4974 if (UNMARSHALLING(ps
))
4975 r_u
->rids
= PRS_ALLOC_MEM(ps
, uint32
, r_u
->num_rids2
);
4978 DEBUG(0, ("NULL rids in samr_io_r_lookup_names\n"));
4982 for (i
= 0; i
< r_u
->num_rids2
; i
++) {
4983 slprintf(tmp
, sizeof(tmp
) - 1, "rid[%02d] ", i
);
4984 if(!prs_uint32(tmp
, ps
, depth
, &r_u
->rids
[i
]))
4989 if(!prs_uint32("num_types1", ps
, depth
, &r_u
->num_types1
))
4991 if(!prs_uint32("ptr_types ", ps
, depth
, &r_u
->ptr_types
))
4994 if (r_u
->ptr_types
!= 0) {
4995 if(!prs_uint32("num_types2", ps
, depth
, &r_u
->num_types2
))
4998 if (r_u
->num_types2
!= r_u
->num_types1
) {
5003 if (UNMARSHALLING(ps
))
5004 r_u
->types
= PRS_ALLOC_MEM(ps
, uint32
, r_u
->num_types2
);
5007 DEBUG(0, ("NULL types in samr_io_r_lookup_names\n"));
5011 for (i
= 0; i
< r_u
->num_types2
; i
++) {
5012 slprintf(tmp
, sizeof(tmp
) - 1, "type[%02d] ", i
);
5013 if(!prs_uint32(tmp
, ps
, depth
, &r_u
->types
[i
]))
5018 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
5024 /*******************************************************************
5025 inits a SAMR_Q_DELETE_DOM_USER structure.
5026 ********************************************************************/
5028 void init_samr_q_delete_dom_user(SAMR_Q_DELETE_DOM_USER
* q_c
,
5031 DEBUG(5, ("init_samr_q_delete_dom_user\n"));
5033 q_c
->user_pol
= *hnd
;
5036 /*******************************************************************
5037 reads or writes a structure.
5038 ********************************************************************/
5040 BOOL
samr_io_q_delete_dom_user(const char *desc
, SAMR_Q_DELETE_DOM_USER
* q_u
,
5041 prs_struct
*ps
, int depth
)
5046 prs_debug(ps
, depth
, desc
, "samr_io_q_delete_dom_user");
5052 if(!smb_io_pol_hnd("user_pol", &q_u
->user_pol
, ps
, depth
))
5058 /*******************************************************************
5059 reads or writes a structure.
5060 ********************************************************************/
5062 BOOL
samr_io_r_delete_dom_user(const char *desc
, SAMR_R_DELETE_DOM_USER
* r_u
,
5063 prs_struct
*ps
, int depth
)
5068 prs_debug(ps
, depth
, desc
, "samr_io_r_delete_dom_user");
5074 if(!smb_io_pol_hnd("pol", &r_u
->pol
, ps
, depth
))
5076 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
5082 /*******************************************************************
5083 reads or writes a structure.
5084 ********************************************************************/
5086 void init_samr_q_open_user(SAMR_Q_OPEN_USER
* q_u
,
5088 uint32 access_mask
, uint32 rid
)
5090 DEBUG(5, ("samr_init_samr_q_open_user\n"));
5092 q_u
->domain_pol
= *pol
;
5093 q_u
->access_mask
= access_mask
;
5094 q_u
->user_rid
= rid
;
5097 /*******************************************************************
5098 reads or writes a structure.
5099 ********************************************************************/
5101 BOOL
samr_io_q_open_user(const char *desc
, SAMR_Q_OPEN_USER
* q_u
,
5102 prs_struct
*ps
, int depth
)
5107 prs_debug(ps
, depth
, desc
, "samr_io_q_open_user");
5113 if(!smb_io_pol_hnd("domain_pol", &q_u
->domain_pol
, ps
, depth
))
5116 if(!prs_uint32("access_mask", ps
, depth
, &q_u
->access_mask
))
5118 if(!prs_uint32("user_rid ", ps
, depth
, &q_u
->user_rid
))
5124 /*******************************************************************
5125 reads or writes a structure.
5126 ********************************************************************/
5128 BOOL
samr_io_r_open_user(const char *desc
, SAMR_R_OPEN_USER
* r_u
,
5129 prs_struct
*ps
, int depth
)
5134 prs_debug(ps
, depth
, desc
, "samr_io_r_open_user");
5140 if(!smb_io_pol_hnd("user_pol", &r_u
->user_pol
, ps
, depth
))
5143 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
5150 /*******************************************************************
5151 reads or writes a structure.
5152 ********************************************************************/
5154 void init_samr_q_create_user(SAMR_Q_CREATE_USER
* q_u
,
5157 uint32 acb_info
, uint32 access_mask
)
5159 DEBUG(5, ("samr_init_samr_q_create_user\n"));
5161 q_u
->domain_pol
= *pol
;
5163 init_unistr2(&q_u
->uni_name
, name
, UNI_FLAGS_NONE
);
5164 init_uni_hdr(&q_u
->hdr_name
, &q_u
->uni_name
);
5166 q_u
->acb_info
= acb_info
;
5167 q_u
->access_mask
= access_mask
;
5170 /*******************************************************************
5171 reads or writes a structure.
5172 ********************************************************************/
5174 BOOL
samr_io_q_create_user(const char *desc
, SAMR_Q_CREATE_USER
* q_u
,
5175 prs_struct
*ps
, int depth
)
5180 prs_debug(ps
, depth
, desc
, "samr_io_q_create_user");
5186 if(!smb_io_pol_hnd("domain_pol", &q_u
->domain_pol
, ps
, depth
))
5189 if(!smb_io_unihdr("hdr_name", &q_u
->hdr_name
, ps
, depth
))
5191 if(!smb_io_unistr2("uni_name", &q_u
->uni_name
, q_u
->hdr_name
.buffer
, ps
, depth
))
5196 if(!prs_uint32("acb_info ", ps
, depth
, &q_u
->acb_info
))
5198 if(!prs_uint32("access_mask", ps
, depth
, &q_u
->access_mask
))
5204 /*******************************************************************
5205 reads or writes a structure.
5206 ********************************************************************/
5208 BOOL
samr_io_r_create_user(const char *desc
, SAMR_R_CREATE_USER
* r_u
,
5209 prs_struct
*ps
, int depth
)
5214 prs_debug(ps
, depth
, desc
, "samr_io_r_create_user");
5220 if(!smb_io_pol_hnd("user_pol", &r_u
->user_pol
, ps
, depth
))
5223 if(!prs_uint32("access_granted", ps
, depth
, &r_u
->access_granted
))
5225 if(!prs_uint32("user_rid ", ps
, depth
, &r_u
->user_rid
))
5227 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
5233 /*******************************************************************
5234 inits a SAMR_Q_QUERY_USERINFO structure.
5235 ********************************************************************/
5237 void init_samr_q_query_userinfo(SAMR_Q_QUERY_USERINFO
* q_u
,
5238 const POLICY_HND
*hnd
, uint16 switch_value
)
5240 DEBUG(5, ("init_samr_q_query_userinfo\n"));
5243 q_u
->switch_value
= switch_value
;
5246 /*******************************************************************
5247 reads or writes a structure.
5248 ********************************************************************/
5250 BOOL
samr_io_q_query_userinfo(const char *desc
, SAMR_Q_QUERY_USERINFO
* q_u
,
5251 prs_struct
*ps
, int depth
)
5256 prs_debug(ps
, depth
, desc
, "samr_io_q_query_userinfo");
5262 if(!smb_io_pol_hnd("pol", &q_u
->pol
, ps
, depth
))
5265 if(!prs_uint16("switch_value", ps
, depth
, &q_u
->switch_value
)) /* 0x0015 or 0x0011 */
5271 /*******************************************************************
5272 reads or writes a LOGON_HRS structure.
5273 ********************************************************************/
5275 static BOOL
sam_io_logon_hrs(const char *desc
, LOGON_HRS
* hrs
,
5276 prs_struct
*ps
, int depth
)
5281 prs_debug(ps
, depth
, desc
, "sam_io_logon_hrs");
5287 if(!prs_uint32("maxlen", ps
, depth
, &hrs
->max_len
))
5290 if(!prs_uint32("offset", ps
, depth
, &hrs
->offset
))
5293 if(!prs_uint32("len ", ps
, depth
, &hrs
->len
))
5296 if (hrs
->len
> sizeof(hrs
->hours
)) {
5297 DEBUG(3, ("sam_io_logon_hrs: truncating length from %d\n", hrs
->len
));
5298 hrs
->len
= sizeof(hrs
->hours
);
5301 if(!prs_uint8s(False
, "hours", ps
, depth
, hrs
->hours
, hrs
->len
))
5307 /*******************************************************************
5308 inits a SAM_USER_INFO_18 structure.
5309 ********************************************************************/
5311 void init_sam_user_info18(SAM_USER_INFO_18
* usr
,
5312 const uint8 lm_pwd
[16], const uint8 nt_pwd
[16])
5314 DEBUG(5, ("init_sam_user_info18\n"));
5316 usr
->lm_pwd_active
=
5317 memcpy(usr
->lm_pwd
, lm_pwd
, sizeof(usr
->lm_pwd
)) ? 1 : 0;
5318 usr
->nt_pwd_active
=
5319 memcpy(usr
->nt_pwd
, nt_pwd
, sizeof(usr
->nt_pwd
)) ? 1 : 0;
5322 /*******************************************************************
5323 reads or writes a structure.
5324 ********************************************************************/
5326 static BOOL
sam_io_user_info18(const char *desc
, SAM_USER_INFO_18
* u
,
5327 prs_struct
*ps
, int depth
)
5332 prs_debug(ps
, depth
, desc
, "samr_io_r_user_info18");
5338 if(!prs_uint8s(False
, "lm_pwd", ps
, depth
, u
->lm_pwd
, sizeof(u
->lm_pwd
)))
5340 if(!prs_uint8s(False
, "nt_pwd", ps
, depth
, u
->nt_pwd
, sizeof(u
->nt_pwd
)))
5343 if(!prs_uint8("lm_pwd_active", ps
, depth
, &u
->lm_pwd_active
))
5345 if(!prs_uint8("nt_pwd_active", ps
, depth
, &u
->nt_pwd_active
))
5351 /*******************************************************************
5352 inits a SAM_USER_INFO_7 structure.
5353 ********************************************************************/
5355 void init_sam_user_info7(SAM_USER_INFO_7
* usr
, const char *name
)
5357 DEBUG(5, ("init_sam_user_info7\n"));
5359 init_unistr2(&usr
->uni_name
, name
, UNI_FLAGS_NONE
); /* unicode string for name */
5360 init_uni_hdr(&usr
->hdr_name
, &usr
->uni_name
); /* unicode header for name */
5364 /*******************************************************************
5365 reads or writes a structure.
5366 ********************************************************************/
5368 static BOOL
sam_io_user_info7(const char *desc
, SAM_USER_INFO_7
* usr
,
5369 prs_struct
*ps
, int depth
)
5374 prs_debug(ps
, depth
, desc
, "samr_io_r_user_info7");
5380 if(!smb_io_unihdr("unihdr", &usr
->hdr_name
, ps
, depth
))
5383 if(!smb_io_unistr2("unistr2", &usr
->uni_name
, True
, ps
, depth
))
5389 /*******************************************************************
5390 inits a SAM_USER_INFO_9 structure.
5391 ********************************************************************/
5393 void init_sam_user_info9(SAM_USER_INFO_9
* usr
, uint32 rid_group
)
5395 DEBUG(5, ("init_sam_user_info9\n"));
5397 usr
->rid_group
= rid_group
;
5400 /*******************************************************************
5401 reads or writes a structure.
5402 ********************************************************************/
5404 static BOOL
sam_io_user_info9(const char *desc
, SAM_USER_INFO_9
* usr
,
5405 prs_struct
*ps
, int depth
)
5410 prs_debug(ps
, depth
, desc
, "samr_io_r_user_info9");
5416 if(!prs_uint32("rid_group", ps
, depth
, &usr
->rid_group
))
5422 /*******************************************************************
5423 inits a SAM_USER_INFO_16 structure.
5424 ********************************************************************/
5426 void init_sam_user_info16(SAM_USER_INFO_16
* usr
, uint32 acb_info
)
5428 DEBUG(5, ("init_sam_user_info16\n"));
5430 usr
->acb_info
= acb_info
;
5433 /*******************************************************************
5434 reads or writes a structure.
5435 ********************************************************************/
5437 static BOOL
sam_io_user_info16(const char *desc
, SAM_USER_INFO_16
* usr
,
5438 prs_struct
*ps
, int depth
)
5443 prs_debug(ps
, depth
, desc
, "samr_io_r_user_info16");
5449 if(!prs_uint32("acb_info", ps
, depth
, &usr
->acb_info
))
5455 /*******************************************************************
5456 inits a SAM_USER_INFO_17 structure.
5457 ********************************************************************/
5459 void init_sam_user_info17(SAM_USER_INFO_17
* usr
,
5462 uint32 rid_user
, uint32 rid_group
, uint16 acct_ctrl
)
5464 DEBUG(5, ("init_sam_user_info17\n"));
5466 memcpy(&usr
->expiry
, expiry
, sizeof(usr
->expiry
)); /* expiry time or something? */
5467 ZERO_STRUCT(usr
->padding_1
); /* 0 - padding 24 bytes */
5469 usr
->padding_2
= 0; /* 0 - padding 4 bytes */
5471 usr
->ptr_1
= 1; /* pointer */
5472 ZERO_STRUCT(usr
->padding_3
); /* 0 - padding 32 bytes */
5473 usr
->padding_4
= 0; /* 0 - padding 4 bytes */
5475 usr
->ptr_2
= 1; /* pointer */
5476 usr
->padding_5
= 0; /* 0 - padding 4 bytes */
5478 usr
->ptr_3
= 1; /* pointer */
5479 ZERO_STRUCT(usr
->padding_6
); /* 0 - padding 32 bytes */
5481 usr
->rid_user
= rid_user
;
5482 usr
->rid_group
= rid_group
;
5484 usr
->acct_ctrl
= acct_ctrl
;
5485 usr
->unknown_3
= 0x0000;
5487 usr
->unknown_4
= 0x003f; /* 0x003f - 16 bit unknown */
5488 usr
->unknown_5
= 0x003c; /* 0x003c - 16 bit unknown */
5490 ZERO_STRUCT(usr
->padding_7
); /* 0 - padding 16 bytes */
5491 usr
->padding_8
= 0; /* 0 - padding 4 bytes */
5493 init_unistr2(&usr
->uni_mach_acct
, mach_acct
, UNI_FLAGS_NONE
); /* unicode string for machine account */
5494 init_uni_hdr(&usr
->hdr_mach_acct
, &usr
->uni_mach_acct
); /* unicode header for machine account */
5497 /*******************************************************************
5498 reads or writes a structure.
5499 ********************************************************************/
5501 static BOOL
sam_io_user_info17(const char *desc
, SAM_USER_INFO_17
* usr
,
5502 prs_struct
*ps
, int depth
)
5507 prs_debug(ps
, depth
, desc
, "samr_io_r_unknown_17");
5513 if(!prs_uint8s(False
, "padding_0", ps
, depth
, usr
->padding_0
, sizeof(usr
->padding_0
)))
5516 if(!smb_io_time("time", &usr
->expiry
, ps
, depth
))
5519 if(!prs_uint8s(False
, "padding_1", ps
, depth
, usr
->padding_1
, sizeof(usr
->padding_1
)))
5522 if(!smb_io_unihdr("unihdr", &usr
->hdr_mach_acct
, ps
, depth
))
5525 if(!prs_uint32("padding_2", ps
, depth
, &usr
->padding_2
))
5528 if(!prs_uint32("ptr_1 ", ps
, depth
, &usr
->ptr_1
))
5530 if(!prs_uint8s(False
, "padding_3", ps
, depth
, usr
->padding_3
, sizeof(usr
->padding_3
)))
5533 if(!prs_uint32("padding_4", ps
, depth
, &usr
->padding_4
))
5536 if(!prs_uint32("ptr_2 ", ps
, depth
, &usr
->ptr_2
))
5538 if(!prs_uint32("padding_5", ps
, depth
, &usr
->padding_5
))
5541 if(!prs_uint32("ptr_3 ", ps
, depth
, &usr
->ptr_3
))
5543 if(!prs_uint8s(False
, "padding_6", ps
, depth
, usr
->padding_6
,sizeof(usr
->padding_6
)))
5546 if(!prs_uint32("rid_user ", ps
, depth
, &usr
->rid_user
))
5548 if(!prs_uint32("rid_group", ps
, depth
, &usr
->rid_group
))
5550 if(!prs_uint16("acct_ctrl", ps
, depth
, &usr
->acct_ctrl
))
5552 if(!prs_uint16("unknown_3", ps
, depth
, &usr
->unknown_3
))
5554 if(!prs_uint16("unknown_4", ps
, depth
, &usr
->unknown_4
))
5556 if(!prs_uint16("unknown_5", ps
, depth
, &usr
->unknown_5
))
5559 if(!prs_uint8s(False
, "padding_7", ps
, depth
, usr
->padding_7
, sizeof(usr
->padding_7
)))
5562 if(!prs_uint32("padding_8", ps
, depth
, &(usr
->padding_8
)))
5565 if(!smb_io_unistr2("unistr2", &usr
->uni_mach_acct
, True
, ps
, depth
))
5571 if(!prs_uint8s(False
, "padding_9", ps
, depth
, usr
->padding_9
, sizeof(usr
->padding_9
)))
5577 /*************************************************************************
5579 *************************************************************************/
5581 void init_sam_user_info24(SAM_USER_INFO_24
* usr
, char newpass
[516],
5584 DEBUG(10, ("init_sam_user_info24:\n"));
5585 memcpy(usr
->pass
, newpass
, sizeof(usr
->pass
));
5586 usr
->pw_len
= pw_len
;
5589 /*******************************************************************
5590 reads or writes a structure.
5591 ********************************************************************/
5593 static BOOL
sam_io_user_info24(const char *desc
, SAM_USER_INFO_24
* usr
,
5594 prs_struct
*ps
, int depth
)
5599 prs_debug(ps
, depth
, desc
, "sam_io_user_info24");
5605 if(!prs_uint8s(False
, "password", ps
, depth
, usr
->pass
,
5609 if (MARSHALLING(ps
) && (usr
->pw_len
!= 0)) {
5610 if (!prs_uint8("pw_len", ps
, depth
, &usr
->pw_len
))
5612 } else if (UNMARSHALLING(ps
)) {
5613 if (!prs_uint8("pw_len", ps
, depth
, &usr
->pw_len
))
5620 /*******************************************************************
5621 reads or writes a structure.
5622 ********************************************************************/
5624 static BOOL
sam_io_user_info26(const char *desc
, SAM_USER_INFO_26
* usr
,
5625 prs_struct
*ps
, int depth
)
5630 prs_debug(ps
, depth
, desc
, "sam_io_user_info26");
5636 if(!prs_uint8s(False
, "password", ps
, depth
, usr
->pass
,
5640 if (!prs_uint8("pw_len", ps
, depth
, &usr
->pw_len
))
5647 /*************************************************************************
5648 init_sam_user_info23
5650 unknown_6 = 0x0000 04ec
5652 *************************************************************************/
5654 void init_sam_user_info23W(SAM_USER_INFO_23
* usr
, NTTIME
* logon_time
, /* all zeros */
5655 NTTIME
* logoff_time
, /* all zeros */
5656 NTTIME
* kickoff_time
, /* all zeros */
5657 NTTIME
* pass_last_set_time
, /* all zeros */
5658 NTTIME
* pass_can_change_time
, /* all zeros */
5659 NTTIME
* pass_must_change_time
, /* all zeros */
5670 uint32 user_rid
, /* 0x0000 0000 */
5673 uint32 fields_present
,
5676 uint16 bad_password_count
,
5680 usr
->logon_time
= *logon_time
; /* all zeros */
5681 usr
->logoff_time
= *logoff_time
; /* all zeros */
5682 usr
->kickoff_time
= *kickoff_time
; /* all zeros */
5683 usr
->pass_last_set_time
= *pass_last_set_time
; /* all zeros */
5684 usr
->pass_can_change_time
= *pass_can_change_time
; /* all zeros */
5685 usr
->pass_must_change_time
= *pass_must_change_time
; /* all zeros */
5687 ZERO_STRUCT(usr
->nt_pwd
);
5688 ZERO_STRUCT(usr
->lm_pwd
);
5690 usr
->user_rid
= user_rid
; /* 0x0000 0000 */
5691 usr
->group_rid
= group_rid
;
5692 usr
->acb_info
= acb_info
;
5693 usr
->fields_present
= fields_present
; /* 09f8 27fa */
5695 usr
->logon_divs
= logon_divs
; /* should be 168 (hours/week) */
5696 usr
->ptr_logon_hrs
= hrs
? 1 : 0;
5698 if (nt_time_is_zero(pass_must_change_time
)) {
5699 usr
->passmustchange
=PASS_MUST_CHANGE_AT_NEXT_LOGON
;
5701 usr
->passmustchange
=0;
5704 ZERO_STRUCT(usr
->padding1
);
5705 ZERO_STRUCT(usr
->padding2
);
5707 usr
->bad_password_count
= bad_password_count
;
5708 usr
->logon_count
= logon_count
;
5710 memcpy(usr
->pass
, newpass
, sizeof(usr
->pass
));
5712 copy_unistr2(&usr
->uni_user_name
, user_name
);
5713 init_uni_hdr(&usr
->hdr_user_name
, &usr
->uni_user_name
);
5715 copy_unistr2(&usr
->uni_full_name
, full_name
);
5716 init_uni_hdr(&usr
->hdr_full_name
, &usr
->uni_full_name
);
5718 copy_unistr2(&usr
->uni_home_dir
, home_dir
);
5719 init_uni_hdr(&usr
->hdr_home_dir
, &usr
->uni_home_dir
);
5721 copy_unistr2(&usr
->uni_dir_drive
, dir_drive
);
5722 init_uni_hdr(&usr
->hdr_dir_drive
, &usr
->uni_dir_drive
);
5724 copy_unistr2(&usr
->uni_logon_script
, log_scr
);
5725 init_uni_hdr(&usr
->hdr_logon_script
, &usr
->uni_logon_script
);
5727 copy_unistr2(&usr
->uni_profile_path
, prof_path
);
5728 init_uni_hdr(&usr
->hdr_profile_path
, &usr
->uni_profile_path
);
5730 copy_unistr2(&usr
->uni_acct_desc
, desc
);
5731 init_uni_hdr(&usr
->hdr_acct_desc
, &usr
->uni_acct_desc
);
5733 copy_unistr2(&usr
->uni_workstations
, wkstas
);
5734 init_uni_hdr(&usr
->hdr_workstations
, &usr
->uni_workstations
);
5736 copy_unistr2(&usr
->uni_comment
, unk_str
);
5737 init_uni_hdr(&usr
->hdr_comment
, &usr
->uni_comment
);
5739 copy_unistr2(&usr
->uni_munged_dial
, mung_dial
);
5740 init_uni_hdr(&usr
->hdr_munged_dial
, &usr
->uni_munged_dial
);
5743 memcpy(&usr
->logon_hrs
, hrs
, sizeof(usr
->logon_hrs
));
5745 ZERO_STRUCT(usr
->logon_hrs
);
5749 /*************************************************************************
5750 init_sam_user_info23
5752 unknown_6 = 0x0000 04ec
5754 *************************************************************************/
5756 void init_sam_user_info23A(SAM_USER_INFO_23
* usr
, NTTIME
* logon_time
, /* all zeros */
5757 NTTIME
* logoff_time
, /* all zeros */
5758 NTTIME
* kickoff_time
, /* all zeros */
5759 NTTIME
* pass_last_set_time
, /* all zeros */
5760 NTTIME
* pass_can_change_time
, /* all zeros */
5761 NTTIME
* pass_must_change_time
, /* all zeros */
5762 char *user_name
, /* NULL */
5764 char *home_dir
, char *dir_drive
, char *log_scr
,
5765 char *prof_path
, const char *desc
, char *wkstas
,
5766 char *unk_str
, char *mung_dial
, uint32 user_rid
, /* 0x0000 0000 */
5767 uint32 group_rid
, uint32 acb_info
,
5768 uint32 fields_present
, uint16 logon_divs
,
5769 LOGON_HRS
* hrs
, uint16 bad_password_count
, uint16 logon_count
,
5772 DATA_BLOB blob
= base64_decode_data_blob(mung_dial
);
5774 usr
->logon_time
= *logon_time
; /* all zeros */
5775 usr
->logoff_time
= *logoff_time
; /* all zeros */
5776 usr
->kickoff_time
= *kickoff_time
; /* all zeros */
5777 usr
->pass_last_set_time
= *pass_last_set_time
; /* all zeros */
5778 usr
->pass_can_change_time
= *pass_can_change_time
; /* all zeros */
5779 usr
->pass_must_change_time
= *pass_must_change_time
; /* all zeros */
5781 ZERO_STRUCT(usr
->nt_pwd
);
5782 ZERO_STRUCT(usr
->lm_pwd
);
5784 usr
->user_rid
= user_rid
; /* 0x0000 0000 */
5785 usr
->group_rid
= group_rid
;
5786 usr
->acb_info
= acb_info
;
5787 usr
->fields_present
= fields_present
; /* 09f8 27fa */
5789 usr
->logon_divs
= logon_divs
; /* should be 168 (hours/week) */
5790 usr
->ptr_logon_hrs
= hrs
? 1 : 0;
5792 if (nt_time_is_zero(pass_must_change_time
)) {
5793 usr
->passmustchange
=PASS_MUST_CHANGE_AT_NEXT_LOGON
;
5795 usr
->passmustchange
=0;
5798 ZERO_STRUCT(usr
->padding1
);
5799 ZERO_STRUCT(usr
->padding2
);
5801 usr
->bad_password_count
= bad_password_count
;
5802 usr
->logon_count
= logon_count
;
5804 memcpy(usr
->pass
, newpass
, sizeof(usr
->pass
));
5806 init_unistr2(&usr
->uni_user_name
, user_name
, UNI_FLAGS_NONE
);
5807 init_uni_hdr(&usr
->hdr_user_name
, &usr
->uni_user_name
);
5809 init_unistr2(&usr
->uni_full_name
, full_name
, UNI_FLAGS_NONE
);
5810 init_uni_hdr(&usr
->hdr_full_name
, &usr
->uni_full_name
);
5812 init_unistr2(&usr
->uni_home_dir
, home_dir
, UNI_FLAGS_NONE
);
5813 init_uni_hdr(&usr
->hdr_home_dir
, &usr
->uni_home_dir
);
5815 init_unistr2(&usr
->uni_dir_drive
, dir_drive
, UNI_FLAGS_NONE
);
5816 init_uni_hdr(&usr
->hdr_dir_drive
, &usr
->uni_dir_drive
);
5818 init_unistr2(&usr
->uni_logon_script
, log_scr
, UNI_FLAGS_NONE
);
5819 init_uni_hdr(&usr
->hdr_logon_script
, &usr
->uni_logon_script
);
5821 init_unistr2(&usr
->uni_profile_path
, prof_path
, UNI_FLAGS_NONE
);
5822 init_uni_hdr(&usr
->hdr_profile_path
, &usr
->uni_profile_path
);
5824 init_unistr2(&usr
->uni_acct_desc
, desc
, UNI_FLAGS_NONE
);
5825 init_uni_hdr(&usr
->hdr_acct_desc
, &usr
->uni_acct_desc
);
5827 init_unistr2(&usr
->uni_workstations
, wkstas
, UNI_FLAGS_NONE
);
5828 init_uni_hdr(&usr
->hdr_workstations
, &usr
->uni_workstations
);
5830 init_unistr2(&usr
->uni_comment
, unk_str
, UNI_FLAGS_NONE
);
5831 init_uni_hdr(&usr
->hdr_comment
, &usr
->uni_comment
);
5833 init_unistr2_from_datablob(&usr
->uni_munged_dial
, &blob
);
5834 init_uni_hdr(&usr
->hdr_munged_dial
, &usr
->uni_munged_dial
);
5836 data_blob_free(&blob
);
5839 memcpy(&usr
->logon_hrs
, hrs
, sizeof(usr
->logon_hrs
));
5841 ZERO_STRUCT(usr
->logon_hrs
);
5845 /*******************************************************************
5846 reads or writes a structure.
5847 ********************************************************************/
5849 static BOOL
sam_io_user_info23(const char *desc
, SAM_USER_INFO_23
* usr
,
5850 prs_struct
*ps
, int depth
)
5855 prs_debug(ps
, depth
, desc
, "sam_io_user_info23");
5861 if(!smb_io_time("logon_time ", &usr
->logon_time
, ps
, depth
))
5863 if(!smb_io_time("logoff_time ", &usr
->logoff_time
, ps
, depth
))
5865 if(!smb_io_time("kickoff_time ", &usr
->kickoff_time
, ps
, depth
))
5867 if(!smb_io_time("pass_last_set_time ", &usr
->pass_last_set_time
, ps
, depth
))
5869 if(!smb_io_time("pass_can_change_time ", &usr
->pass_can_change_time
, ps
, depth
))
5871 if(!smb_io_time("pass_must_change_time", &usr
->pass_must_change_time
, ps
, depth
))
5874 if(!smb_io_unihdr("hdr_user_name ", &usr
->hdr_user_name
, ps
, depth
)) /* username unicode string header */
5876 if(!smb_io_unihdr("hdr_full_name ", &usr
->hdr_full_name
, ps
, depth
)) /* user's full name unicode string header */
5878 if(!smb_io_unihdr("hdr_home_dir ", &usr
->hdr_home_dir
, ps
, depth
)) /* home directory unicode string header */
5880 if(!smb_io_unihdr("hdr_dir_drive ", &usr
->hdr_dir_drive
, ps
, depth
)) /* home directory drive */
5882 if(!smb_io_unihdr("hdr_logon_script", &usr
->hdr_logon_script
, ps
, depth
)) /* logon script unicode string header */
5884 if(!smb_io_unihdr("hdr_profile_path", &usr
->hdr_profile_path
, ps
, depth
)) /* profile path unicode string header */
5886 if(!smb_io_unihdr("hdr_acct_desc ", &usr
->hdr_acct_desc
, ps
, depth
)) /* account desc */
5888 if(!smb_io_unihdr("hdr_workstations", &usr
->hdr_workstations
, ps
, depth
)) /* wkstas user can log on from */
5890 if(!smb_io_unihdr("hdr_comment ", &usr
->hdr_comment
, ps
, depth
)) /* unknown string */
5892 if(!smb_io_unihdr("hdr_munged_dial ", &usr
->hdr_munged_dial
, ps
, depth
)) /* wkstas user can log on from */
5895 if(!prs_uint8s(False
, "lm_pwd ", ps
, depth
, usr
->lm_pwd
, sizeof(usr
->lm_pwd
)))
5897 if(!prs_uint8s(False
, "nt_pwd ", ps
, depth
, usr
->nt_pwd
, sizeof(usr
->nt_pwd
)))
5900 if(!prs_uint32("user_rid ", ps
, depth
, &usr
->user_rid
)) /* User ID */
5902 if(!prs_uint32("group_rid ", ps
, depth
, &usr
->group_rid
)) /* Group ID */
5904 if(!prs_uint32("acb_info ", ps
, depth
, &usr
->acb_info
))
5907 if(!prs_uint32("fields_present ", ps
, depth
, &usr
->fields_present
))
5909 if(!prs_uint16("logon_divs ", ps
, depth
, &usr
->logon_divs
)) /* logon divisions per week */
5913 if(!prs_uint32("ptr_logon_hrs ", ps
, depth
, &usr
->ptr_logon_hrs
))
5916 if(!prs_uint16("bad_password_count ", ps
, depth
, &usr
->bad_password_count
))
5918 if(!prs_uint16("logon_count ", ps
, depth
, &usr
->logon_count
))
5921 if(!prs_uint8s(False
, "padding1 ", ps
, depth
, usr
->padding1
, sizeof(usr
->padding1
)))
5923 if(!prs_uint8("passmustchange ", ps
, depth
, &usr
->passmustchange
))
5925 if(!prs_uint8("padding2 ", ps
, depth
, &usr
->padding2
))
5929 if(!prs_uint8s(False
, "password ", ps
, depth
, usr
->pass
, sizeof(usr
->pass
)))
5932 /* here begins pointed-to data */
5934 if(!smb_io_unistr2("uni_user_name ", &usr
->uni_user_name
, usr
->hdr_user_name
.buffer
, ps
, depth
)) /* username unicode string */
5937 if(!smb_io_unistr2("uni_full_name ", &usr
->uni_full_name
, usr
->hdr_full_name
.buffer
, ps
, depth
)) /* user's full name unicode string */
5940 if(!smb_io_unistr2("uni_home_dir ", &usr
->uni_home_dir
, usr
->hdr_home_dir
.buffer
, ps
, depth
)) /* home directory unicode string */
5943 if(!smb_io_unistr2("uni_dir_drive ", &usr
->uni_dir_drive
, usr
->hdr_dir_drive
.buffer
, ps
, depth
)) /* home directory drive unicode string */
5946 if(!smb_io_unistr2("uni_logon_script", &usr
->uni_logon_script
, usr
->hdr_logon_script
.buffer
, ps
, depth
)) /* logon script unicode string */
5949 if(!smb_io_unistr2("uni_profile_path", &usr
->uni_profile_path
, usr
->hdr_profile_path
.buffer
, ps
, depth
)) /* profile path unicode string */
5952 if(!smb_io_unistr2("uni_acct_desc ", &usr
->uni_acct_desc
, usr
->hdr_acct_desc
.buffer
, ps
, depth
)) /* user desc unicode string */
5955 if(!smb_io_unistr2("uni_workstations", &usr
->uni_workstations
, usr
->hdr_workstations
.buffer
, ps
, depth
)) /* worksations user can log on from */
5958 if(!smb_io_unistr2("uni_comment ", &usr
->uni_comment
, usr
->hdr_comment
.buffer
, ps
, depth
)) /* unknown string */
5961 if(!smb_io_unistr2("uni_munged_dial ", &usr
->uni_munged_dial
, usr
->hdr_munged_dial
.buffer
, ps
, depth
))
5964 /* ok, this is only guess-work (as usual) */
5965 if (usr
->ptr_logon_hrs
) {
5966 if(!sam_io_logon_hrs("logon_hrs", &usr
->logon_hrs
, ps
, depth
))
5973 /*******************************************************************
5974 reads or writes a structure.
5975 NB. This structure is *definately* incorrect. It's my best guess
5976 currently for W2K SP2. The password field is encrypted in a different
5977 way than normal... And there are definately other problems. JRA.
5978 ********************************************************************/
5980 static BOOL
sam_io_user_info25(const char *desc
, SAM_USER_INFO_25
* usr
, prs_struct
*ps
, int depth
)
5985 prs_debug(ps
, depth
, desc
, "sam_io_user_info25");
5991 if(!smb_io_time("logon_time ", &usr
->logon_time
, ps
, depth
))
5993 if(!smb_io_time("logoff_time ", &usr
->logoff_time
, ps
, depth
))
5995 if(!smb_io_time("kickoff_time ", &usr
->kickoff_time
, ps
, depth
))
5997 if(!smb_io_time("pass_last_set_time ", &usr
->pass_last_set_time
, ps
, depth
))
5999 if(!smb_io_time("pass_can_change_time ", &usr
->pass_can_change_time
, ps
, depth
))
6001 if(!smb_io_time("pass_must_change_time", &usr
->pass_must_change_time
, ps
, depth
))
6004 if(!smb_io_unihdr("hdr_user_name ", &usr
->hdr_user_name
, ps
, depth
)) /* username unicode string header */
6006 if(!smb_io_unihdr("hdr_full_name ", &usr
->hdr_full_name
, ps
, depth
)) /* user's full name unicode string header */
6008 if(!smb_io_unihdr("hdr_home_dir ", &usr
->hdr_home_dir
, ps
, depth
)) /* home directory unicode string header */
6010 if(!smb_io_unihdr("hdr_dir_drive ", &usr
->hdr_dir_drive
, ps
, depth
)) /* home directory drive */
6012 if(!smb_io_unihdr("hdr_logon_script", &usr
->hdr_logon_script
, ps
, depth
)) /* logon script unicode string header */
6014 if(!smb_io_unihdr("hdr_profile_path", &usr
->hdr_profile_path
, ps
, depth
)) /* profile path unicode string header */
6016 if(!smb_io_unihdr("hdr_acct_desc ", &usr
->hdr_acct_desc
, ps
, depth
)) /* account desc */
6018 if(!smb_io_unihdr("hdr_workstations", &usr
->hdr_workstations
, ps
, depth
)) /* wkstas user can log on from */
6020 if(!smb_io_unihdr("hdr_comment ", &usr
->hdr_comment
, ps
, depth
)) /* unknown string */
6022 if(!smb_io_unihdr("hdr_munged_dial ", &usr
->hdr_munged_dial
, ps
, depth
)) /* wkstas user can log on from */
6025 if(!prs_uint8s(False
, "lm_pwd ", ps
, depth
, usr
->lm_pwd
, sizeof(usr
->lm_pwd
)))
6027 if(!prs_uint8s(False
, "nt_pwd ", ps
, depth
, usr
->nt_pwd
, sizeof(usr
->nt_pwd
)))
6030 if(!prs_uint32("user_rid ", ps
, depth
, &usr
->user_rid
)) /* User ID */
6032 if(!prs_uint32("group_rid ", ps
, depth
, &usr
->group_rid
)) /* Group ID */
6034 if(!prs_uint32("acb_info ", ps
, depth
, &usr
->acb_info
))
6036 if(!prs_uint32("fields_present ", ps
, depth
, &usr
->fields_present
))
6039 if(!prs_uint32s(False
, "unknown_5 ", ps
, depth
, usr
->unknown_5
, 5))
6042 if(!prs_uint8s(False
, "password ", ps
, depth
, usr
->pass
, sizeof(usr
->pass
)))
6045 /* here begins pointed-to data */
6047 if(!smb_io_unistr2("uni_user_name ", &usr
->uni_user_name
, usr
->hdr_user_name
.buffer
, ps
, depth
)) /* username unicode string */
6050 if(!smb_io_unistr2("uni_full_name ", &usr
->uni_full_name
, usr
->hdr_full_name
.buffer
, ps
, depth
)) /* user's full name unicode string */
6053 if(!smb_io_unistr2("uni_home_dir ", &usr
->uni_home_dir
, usr
->hdr_home_dir
.buffer
, ps
, depth
)) /* home directory unicode string */
6056 if(!smb_io_unistr2("uni_dir_drive ", &usr
->uni_dir_drive
, usr
->hdr_dir_drive
.buffer
, ps
, depth
)) /* home directory drive unicode string */
6059 if(!smb_io_unistr2("uni_logon_script", &usr
->uni_logon_script
, usr
->hdr_logon_script
.buffer
, ps
, depth
)) /* logon script unicode string */
6062 if(!smb_io_unistr2("uni_profile_path", &usr
->uni_profile_path
, usr
->hdr_profile_path
.buffer
, ps
, depth
)) /* profile path unicode string */
6065 if(!smb_io_unistr2("uni_acct_desc ", &usr
->uni_acct_desc
, usr
->hdr_acct_desc
.buffer
, ps
, depth
)) /* user desc unicode string */
6068 if(!smb_io_unistr2("uni_workstations", &usr
->uni_workstations
, usr
->hdr_workstations
.buffer
, ps
, depth
)) /* worksations user can log on from */
6071 if(!smb_io_unistr2("uni_comment ", &usr
->uni_comment
, usr
->hdr_comment
.buffer
, ps
, depth
)) /* unknown string */
6074 if(!smb_io_unistr2("uni_munged_dial ", &usr
->uni_munged_dial
, usr
->hdr_munged_dial
.buffer
, ps
, depth
))
6077 #if 0 /* JRA - unknown... */
6078 /* ok, this is only guess-work (as usual) */
6079 if (usr
->ptr_logon_hrs
) {
6080 if(!sam_io_logon_hrs("logon_hrs", &usr
->logon_hrs
, ps
, depth
))
6089 /*************************************************************************
6090 init_sam_user_info21W
6092 unknown_6 = 0x0000 04ec
6094 *************************************************************************/
6096 void init_sam_user_info21W(SAM_USER_INFO_21
* usr
,
6097 NTTIME
* logon_time
,
6098 NTTIME
* logoff_time
,
6099 NTTIME
* kickoff_time
,
6100 NTTIME
* pass_last_set_time
,
6101 NTTIME
* pass_can_change_time
,
6102 NTTIME
* pass_must_change_time
,
6118 uint32 fields_present
,
6121 uint16 bad_password_count
,
6124 usr
->logon_time
= *logon_time
;
6125 usr
->logoff_time
= *logoff_time
;
6126 usr
->kickoff_time
= *kickoff_time
;
6127 usr
->pass_last_set_time
= *pass_last_set_time
;
6128 usr
->pass_can_change_time
= *pass_can_change_time
;
6129 usr
->pass_must_change_time
= *pass_must_change_time
;
6131 memcpy(usr
->lm_pwd
, lm_pwd
, sizeof(usr
->lm_pwd
));
6132 memcpy(usr
->nt_pwd
, nt_pwd
, sizeof(usr
->nt_pwd
));
6134 usr
->user_rid
= user_rid
;
6135 usr
->group_rid
= group_rid
;
6136 usr
->acb_info
= acb_info
;
6137 usr
->fields_present
= fields_present
; /* 0x00ff ffff */
6139 usr
->logon_divs
= logon_divs
; /* should be 168 (hours/week) */
6140 usr
->ptr_logon_hrs
= hrs
? 1 : 0;
6141 usr
->bad_password_count
= bad_password_count
;
6142 usr
->logon_count
= logon_count
;
6144 if (nt_time_is_zero(pass_must_change_time
)) {
6145 usr
->passmustchange
=PASS_MUST_CHANGE_AT_NEXT_LOGON
;
6147 usr
->passmustchange
=0;
6150 ZERO_STRUCT(usr
->padding1
);
6151 ZERO_STRUCT(usr
->padding2
);
6153 copy_unistr2(&usr
->uni_user_name
, user_name
);
6154 init_uni_hdr(&usr
->hdr_user_name
, &usr
->uni_user_name
);
6156 copy_unistr2(&usr
->uni_full_name
, full_name
);
6157 init_uni_hdr(&usr
->hdr_full_name
, &usr
->uni_full_name
);
6159 copy_unistr2(&usr
->uni_home_dir
, home_dir
);
6160 init_uni_hdr(&usr
->hdr_home_dir
, &usr
->uni_home_dir
);
6162 copy_unistr2(&usr
->uni_dir_drive
, dir_drive
);
6163 init_uni_hdr(&usr
->hdr_dir_drive
, &usr
->uni_dir_drive
);
6165 copy_unistr2(&usr
->uni_logon_script
, log_scr
);
6166 init_uni_hdr(&usr
->hdr_logon_script
, &usr
->uni_logon_script
);
6168 copy_unistr2(&usr
->uni_profile_path
, prof_path
);
6169 init_uni_hdr(&usr
->hdr_profile_path
, &usr
->uni_profile_path
);
6171 copy_unistr2(&usr
->uni_acct_desc
, desc
);
6172 init_uni_hdr(&usr
->hdr_acct_desc
, &usr
->uni_acct_desc
);
6174 copy_unistr2(&usr
->uni_workstations
, wkstas
);
6175 init_uni_hdr(&usr
->hdr_workstations
, &usr
->uni_workstations
);
6177 copy_unistr2(&usr
->uni_comment
, unk_str
);
6178 init_uni_hdr(&usr
->hdr_comment
, &usr
->uni_comment
);
6180 copy_unistr2(&usr
->uni_munged_dial
, mung_dial
);
6181 init_uni_hdr(&usr
->hdr_munged_dial
, &usr
->uni_munged_dial
);
6184 memcpy(&usr
->logon_hrs
, hrs
, sizeof(usr
->logon_hrs
));
6186 ZERO_STRUCT(usr
->logon_hrs
);
6190 /*************************************************************************
6191 init_sam_user_info21
6193 unknown_6 = 0x0000 04ec
6195 *************************************************************************/
6197 NTSTATUS
init_sam_user_info21A(SAM_USER_INFO_21
*usr
, struct samu
*pw
, DOM_SID
*domain_sid
)
6199 NTTIME logon_time
, logoff_time
, kickoff_time
,
6200 pass_last_set_time
, pass_can_change_time
,
6201 pass_must_change_time
;
6203 const char* user_name
= pdb_get_username(pw
);
6204 const char* full_name
= pdb_get_fullname(pw
);
6205 const char* home_dir
= pdb_get_homedir(pw
);
6206 const char* dir_drive
= pdb_get_dir_drive(pw
);
6207 const char* logon_script
= pdb_get_logon_script(pw
);
6208 const char* profile_path
= pdb_get_profile_path(pw
);
6209 const char* description
= pdb_get_acct_desc(pw
);
6210 const char* workstations
= pdb_get_workstations(pw
);
6211 const char* munged_dial
= pdb_get_munged_dial(pw
);
6212 DATA_BLOB munged_dial_blob
;
6215 const DOM_SID
*user_sid
;
6218 const DOM_SID
*group_sid
;
6221 munged_dial_blob
= base64_decode_data_blob(munged_dial
);
6223 munged_dial_blob
= data_blob(NULL
, 0);
6226 /* Create NTTIME structs */
6227 unix_to_nt_time (&logon_time
, pdb_get_logon_time(pw
));
6228 unix_to_nt_time (&logoff_time
, pdb_get_logoff_time(pw
));
6229 unix_to_nt_time (&kickoff_time
, pdb_get_kickoff_time(pw
));
6230 unix_to_nt_time (&pass_last_set_time
, pdb_get_pass_last_set_time(pw
));
6231 unix_to_nt_time (&pass_can_change_time
, pdb_get_pass_can_change_time(pw
));
6232 unix_to_nt_time (&pass_must_change_time
,pdb_get_pass_must_change_time(pw
));
6234 /* structure assignment */
6235 usr
->logon_time
= logon_time
;
6236 usr
->logoff_time
= logoff_time
;
6237 usr
->kickoff_time
= kickoff_time
;
6238 usr
->pass_last_set_time
= pass_last_set_time
;
6239 usr
->pass_can_change_time
= pass_can_change_time
;
6240 usr
->pass_must_change_time
= pass_must_change_time
;
6242 ZERO_STRUCT(usr
->nt_pwd
);
6243 ZERO_STRUCT(usr
->lm_pwd
);
6245 user_sid
= pdb_get_user_sid(pw
);
6247 if (!sid_peek_check_rid(domain_sid
, user_sid
, &user_rid
)) {
6248 fstring user_sid_string
;
6249 fstring domain_sid_string
;
6250 DEBUG(0, ("init_sam_user_info_21A: User %s has SID %s, \nwhich conflicts with "
6251 "the domain sid %s. Failing operation.\n",
6253 sid_to_string(user_sid_string
, user_sid
),
6254 sid_to_string(domain_sid_string
, domain_sid
)));
6255 data_blob_free(&munged_dial_blob
);
6256 return NT_STATUS_UNSUCCESSFUL
;
6259 group_sid
= pdb_get_group_sid(pw
);
6261 if (!sid_peek_check_rid(domain_sid
, group_sid
, &group_rid
)) {
6262 fstring group_sid_string
;
6263 fstring domain_sid_string
;
6264 DEBUG(0, ("init_sam_user_info_21A: User %s has Primary Group SID %s, \n"
6265 "which conflicts with the domain sid %s. Failing operation.\n",
6267 sid_to_string(group_sid_string
, group_sid
),
6268 sid_to_string(domain_sid_string
, domain_sid
)));
6269 data_blob_free(&munged_dial_blob
);
6270 return NT_STATUS_UNSUCCESSFUL
;
6273 usr
->user_rid
= user_rid
;
6274 usr
->group_rid
= group_rid
;
6275 usr
->acb_info
= pdb_get_acct_ctrl(pw
);
6278 Look at a user on a real NT4 PDC with usrmgr, press
6279 'ok'. Then you will see that fields_present is set to
6280 0x08f827fa. Look at the user immediately after that again,
6281 and you will see that 0x00fffff is returned. This solves
6282 the problem that you get access denied after having looked
6286 usr
->fields_present
= pdb_build_fields_present(pw
);
6288 usr
->logon_divs
= pdb_get_logon_divs(pw
);
6289 usr
->ptr_logon_hrs
= pdb_get_hours(pw
) ? 1 : 0;
6290 usr
->bad_password_count
= pdb_get_bad_password_count(pw
);
6291 usr
->logon_count
= pdb_get_logon_count(pw
);
6293 if (pdb_get_pass_must_change_time(pw
) == 0) {
6294 usr
->passmustchange
=PASS_MUST_CHANGE_AT_NEXT_LOGON
;
6296 usr
->passmustchange
=0;
6299 ZERO_STRUCT(usr
->padding1
);
6300 ZERO_STRUCT(usr
->padding2
);
6302 init_unistr2(&usr
->uni_user_name
, user_name
, UNI_STR_TERMINATE
);
6303 init_uni_hdr(&usr
->hdr_user_name
, &usr
->uni_user_name
);
6305 init_unistr2(&usr
->uni_full_name
, full_name
, UNI_STR_TERMINATE
);
6306 init_uni_hdr(&usr
->hdr_full_name
, &usr
->uni_full_name
);
6308 init_unistr2(&usr
->uni_home_dir
, home_dir
, UNI_STR_TERMINATE
);
6309 init_uni_hdr(&usr
->hdr_home_dir
, &usr
->uni_home_dir
);
6311 init_unistr2(&usr
->uni_dir_drive
, dir_drive
, UNI_STR_TERMINATE
);
6312 init_uni_hdr(&usr
->hdr_dir_drive
, &usr
->uni_dir_drive
);
6314 init_unistr2(&usr
->uni_logon_script
, logon_script
, UNI_STR_TERMINATE
);
6315 init_uni_hdr(&usr
->hdr_logon_script
, &usr
->uni_logon_script
);
6317 init_unistr2(&usr
->uni_profile_path
, profile_path
, UNI_STR_TERMINATE
);
6318 init_uni_hdr(&usr
->hdr_profile_path
, &usr
->uni_profile_path
);
6320 init_unistr2(&usr
->uni_acct_desc
, description
, UNI_STR_TERMINATE
);
6321 init_uni_hdr(&usr
->hdr_acct_desc
, &usr
->uni_acct_desc
);
6323 init_unistr2(&usr
->uni_workstations
, workstations
, UNI_STR_TERMINATE
);
6324 init_uni_hdr(&usr
->hdr_workstations
, &usr
->uni_workstations
);
6326 init_unistr2(&usr
->uni_comment
, NULL
, UNI_STR_TERMINATE
);
6327 init_uni_hdr(&usr
->hdr_comment
, &usr
->uni_comment
);
6329 init_unistr2_from_datablob(&usr
->uni_munged_dial
, &munged_dial_blob
);
6330 init_uni_hdr(&usr
->hdr_munged_dial
, &usr
->uni_munged_dial
);
6331 data_blob_free(&munged_dial_blob
);
6333 if (pdb_get_hours(pw
)) {
6334 usr
->logon_hrs
.max_len
= 1260;
6335 usr
->logon_hrs
.offset
= 0;
6336 usr
->logon_hrs
.len
= pdb_get_hours_len(pw
);
6337 memcpy(&usr
->logon_hrs
.hours
, pdb_get_hours(pw
), MAX_HOURS_LEN
);
6339 usr
->logon_hrs
.max_len
= 1260;
6340 usr
->logon_hrs
.offset
= 0;
6341 usr
->logon_hrs
.len
= 0;
6342 memset(&usr
->logon_hrs
, 0xff, sizeof(usr
->logon_hrs
));
6345 return NT_STATUS_OK
;
6348 /*******************************************************************
6349 reads or writes a structure.
6350 ********************************************************************/
6352 static BOOL
sam_io_user_info21(const char *desc
, SAM_USER_INFO_21
* usr
,
6353 prs_struct
*ps
, int depth
)
6358 prs_debug(ps
, depth
, desc
, "sam_io_user_info21");
6364 if(!smb_io_time("logon_time ", &usr
->logon_time
, ps
, depth
))
6366 if(!smb_io_time("logoff_time ", &usr
->logoff_time
, ps
, depth
))
6368 if(!smb_io_time("pass_last_set_time ", &usr
->pass_last_set_time
, ps
,depth
))
6370 if(!smb_io_time("kickoff_time ", &usr
->kickoff_time
, ps
, depth
))
6372 if(!smb_io_time("pass_can_change_time ", &usr
->pass_can_change_time
, ps
,depth
))
6374 if(!smb_io_time("pass_must_change_time", &usr
->pass_must_change_time
, ps
, depth
))
6377 if(!smb_io_unihdr("hdr_user_name ", &usr
->hdr_user_name
, ps
, depth
)) /* username unicode string header */
6379 if(!smb_io_unihdr("hdr_full_name ", &usr
->hdr_full_name
, ps
, depth
)) /* user's full name unicode string header */
6381 if(!smb_io_unihdr("hdr_home_dir ", &usr
->hdr_home_dir
, ps
, depth
)) /* home directory unicode string header */
6383 if(!smb_io_unihdr("hdr_dir_drive ", &usr
->hdr_dir_drive
, ps
, depth
)) /* home directory drive */
6385 if(!smb_io_unihdr("hdr_logon_script", &usr
->hdr_logon_script
, ps
, depth
)) /* logon script unicode string header */
6387 if(!smb_io_unihdr("hdr_profile_path", &usr
->hdr_profile_path
, ps
, depth
)) /* profile path unicode string header */
6389 if(!smb_io_unihdr("hdr_acct_desc ", &usr
->hdr_acct_desc
, ps
, depth
)) /* account desc */
6391 if(!smb_io_unihdr("hdr_workstations", &usr
->hdr_workstations
, ps
, depth
)) /* wkstas user can log on from */
6393 if(!smb_io_unihdr("hdr_comment ", &usr
->hdr_comment
, ps
, depth
)) /* unknown string */
6395 if(!smb_io_unihdr("hdr_munged_dial ", &usr
->hdr_munged_dial
, ps
, depth
)) /* wkstas user can log on from */
6398 if(!prs_uint8s(False
, "lm_pwd ", ps
, depth
, usr
->lm_pwd
, sizeof(usr
->lm_pwd
)))
6400 if(!prs_uint8s(False
, "nt_pwd ", ps
, depth
, usr
->nt_pwd
, sizeof(usr
->nt_pwd
)))
6403 if(!prs_uint32("user_rid ", ps
, depth
, &usr
->user_rid
)) /* User ID */
6405 if(!prs_uint32("group_rid ", ps
, depth
, &usr
->group_rid
)) /* Group ID */
6407 if(!prs_uint32("acb_info ", ps
, depth
, &usr
->acb_info
))
6410 if(!prs_uint32("fields_present ", ps
, depth
, &usr
->fields_present
))
6412 if(!prs_uint16("logon_divs ", ps
, depth
, &usr
->logon_divs
)) /* logon divisions per week */
6416 if(!prs_uint32("ptr_logon_hrs ", ps
, depth
, &usr
->ptr_logon_hrs
))
6419 if(!prs_uint16("bad_password_count ", ps
, depth
, &usr
->bad_password_count
))
6421 if(!prs_uint16("logon_count ", ps
, depth
, &usr
->logon_count
))
6424 if(!prs_uint8s(False
, "padding1 ", ps
, depth
, usr
->padding1
, sizeof(usr
->padding1
)))
6426 if(!prs_uint8("passmustchange ", ps
, depth
, &usr
->passmustchange
))
6428 if(!prs_uint8("padding2 ", ps
, depth
, &usr
->padding2
))
6431 /* here begins pointed-to data */
6433 if(!smb_io_unistr2("uni_user_name ", &usr
->uni_user_name
,usr
->hdr_user_name
.buffer
, ps
, depth
))
6435 if(!smb_io_unistr2("uni_full_name ", &usr
->uni_full_name
, usr
->hdr_full_name
.buffer
, ps
, depth
))
6437 if(!smb_io_unistr2("uni_home_dir ", &usr
->uni_home_dir
, usr
->hdr_home_dir
.buffer
, ps
, depth
))
6439 if(!smb_io_unistr2("uni_dir_drive ", &usr
->uni_dir_drive
, usr
->hdr_dir_drive
.buffer
, ps
, depth
))
6441 if(!smb_io_unistr2("uni_logon_script", &usr
->uni_logon_script
, usr
->hdr_logon_script
.buffer
, ps
, depth
))
6443 if(!smb_io_unistr2("uni_profile_path", &usr
->uni_profile_path
, usr
->hdr_profile_path
.buffer
, ps
, depth
))
6445 if(!smb_io_unistr2("uni_acct_desc ", &usr
->uni_acct_desc
, usr
->hdr_acct_desc
.buffer
, ps
, depth
))
6447 if(!smb_io_unistr2("uni_workstations", &usr
->uni_workstations
, usr
->hdr_workstations
.buffer
, ps
, depth
))
6449 if(!smb_io_unistr2("uni_comment", &usr
->uni_comment
, usr
->hdr_comment
.buffer
, ps
, depth
))
6451 if(!smb_io_unistr2("uni_munged_dial ", &usr
->uni_munged_dial
,usr
->hdr_munged_dial
.buffer
, ps
, depth
))
6454 /* ok, this is only guess-work (as usual) */
6455 if (usr
->ptr_logon_hrs
) {
6456 if(!sam_io_logon_hrs("logon_hrs", &usr
->logon_hrs
, ps
, depth
))
6463 void init_sam_user_info20A(SAM_USER_INFO_20
*usr
, struct samu
*pw
)
6465 const char *munged_dial
= pdb_get_munged_dial(pw
);
6469 blob
= base64_decode_data_blob(munged_dial
);
6471 blob
= data_blob(NULL
, 0);
6474 init_unistr2_from_datablob(&usr
->uni_munged_dial
, &blob
);
6475 init_uni_hdr(&usr
->hdr_munged_dial
, &usr
->uni_munged_dial
);
6476 data_blob_free(&blob
);
6479 /*******************************************************************
6480 reads or writes a structure.
6481 ********************************************************************/
6483 static BOOL
sam_io_user_info20(const char *desc
, SAM_USER_INFO_20
*usr
,
6484 prs_struct
*ps
, int depth
)
6489 prs_debug(ps
, depth
, desc
, "sam_io_user_info20");
6495 if(!smb_io_unihdr("hdr_munged_dial ", &usr
->hdr_munged_dial
, ps
, depth
)) /* wkstas user can log on from */
6498 if(!smb_io_unistr2("uni_munged_dial ", &usr
->uni_munged_dial
,usr
->hdr_munged_dial
.buffer
, ps
, depth
)) /* worksations user can log on from */
6504 /*******************************************************************
6505 inits a SAM_USERINFO_CTR structure.
6506 ********************************************************************/
6508 NTSTATUS
make_samr_userinfo_ctr_usr21(TALLOC_CTX
*ctx
, SAM_USERINFO_CTR
* ctr
,
6509 uint16 switch_value
,
6510 SAM_USER_INFO_21
* usr
)
6512 DEBUG(5, ("make_samr_userinfo_ctr_usr21\n"));
6514 ctr
->switch_value
= switch_value
;
6515 ctr
->info
.id
= NULL
;
6517 switch (switch_value
) {
6519 ctr
->info
.id16
= TALLOC_ZERO_P(ctx
,SAM_USER_INFO_16
);
6520 if (ctr
->info
.id16
== NULL
)
6521 return NT_STATUS_NO_MEMORY
;
6523 init_sam_user_info16(ctr
->info
.id16
, usr
->acb_info
);
6526 /* whoops - got this wrong. i think. or don't understand what's happening. */
6530 info
= (void *)&id11
;
6532 expire
.low
= 0xffffffff;
6533 expire
.high
= 0x7fffffff;
6535 ctr
->info
.id
= TALLOC_ZERO_P(ctx
,SAM_USER_INFO_17
);
6536 init_sam_user_info11(ctr
->info
.id17
, &expire
,
6537 "BROOKFIELDS$", /* name */
6538 0x03ef, /* user rid */
6539 0x201, /* group rid */
6540 0x0080); /* acb info */
6546 ctr
->info
.id18
= TALLOC_ZERO_P(ctx
,SAM_USER_INFO_18
);
6547 if (ctr
->info
.id18
== NULL
)
6548 return NT_STATUS_NO_MEMORY
;
6550 init_sam_user_info18(ctr
->info
.id18
, usr
->lm_pwd
, usr
->nt_pwd
);
6554 SAM_USER_INFO_21
*cusr
;
6555 cusr
= TALLOC_ZERO_P(ctx
,SAM_USER_INFO_21
);
6556 ctr
->info
.id21
= cusr
;
6557 if (ctr
->info
.id21
== NULL
)
6558 return NT_STATUS_NO_MEMORY
;
6559 memcpy(cusr
, usr
, sizeof(*usr
));
6560 memset(cusr
->lm_pwd
, 0, sizeof(cusr
->lm_pwd
));
6561 memset(cusr
->nt_pwd
, 0, sizeof(cusr
->nt_pwd
));
6565 DEBUG(4,("make_samr_userinfo_ctr: unsupported info\n"));
6566 return NT_STATUS_INVALID_INFO_CLASS
;
6569 return NT_STATUS_OK
;
6572 /*******************************************************************
6573 inits a SAM_USERINFO_CTR structure.
6574 ********************************************************************/
6576 static void init_samr_userinfo_ctr(SAM_USERINFO_CTR
* ctr
, DATA_BLOB
*sess_key
,
6577 uint16 switch_value
, void *info
)
6579 DEBUG(5, ("init_samr_userinfo_ctr\n"));
6581 ctr
->switch_value
= switch_value
;
6582 ctr
->info
.id
= info
;
6584 switch (switch_value
) {
6586 SamOEMhashBlob(ctr
->info
.id24
->pass
, 516, sess_key
);
6587 dump_data(100, (char *)sess_key
->data
, sess_key
->length
);
6588 dump_data(100, (char *)ctr
->info
.id24
->pass
, 516);
6591 SamOEMhashBlob(ctr
->info
.id23
->pass
, 516, sess_key
);
6592 dump_data(100, (char *)sess_key
->data
, sess_key
->length
);
6593 dump_data(100, (char *)ctr
->info
.id23
->pass
, 516);
6598 DEBUG(4,("init_samr_userinfo_ctr: unsupported switch level: %d\n", switch_value
));
6602 /*******************************************************************
6603 reads or writes a structure.
6604 ********************************************************************/
6606 static BOOL
samr_io_userinfo_ctr(const char *desc
, SAM_USERINFO_CTR
**ppctr
,
6607 prs_struct
*ps
, int depth
)
6610 SAM_USERINFO_CTR
*ctr
;
6612 prs_debug(ps
, depth
, desc
, "samr_io_userinfo_ctr");
6615 if (UNMARSHALLING(ps
)) {
6616 ctr
= PRS_ALLOC_MEM(ps
,SAM_USERINFO_CTR
,1);
6624 /* lkclXXXX DO NOT ALIGN BEFORE READING SWITCH VALUE! */
6626 if(!prs_uint16("switch_value", ps
, depth
, &ctr
->switch_value
))
6633 switch (ctr
->switch_value
) {
6635 if (UNMARSHALLING(ps
))
6636 ctr
->info
.id7
= PRS_ALLOC_MEM(ps
,SAM_USER_INFO_7
,1);
6637 if (ctr
->info
.id7
== NULL
) {
6638 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6641 ret
= sam_io_user_info7("", ctr
->info
.id7
, ps
, depth
);
6644 if (UNMARSHALLING(ps
))
6645 ctr
->info
.id9
= PRS_ALLOC_MEM(ps
,SAM_USER_INFO_9
,1);
6646 if (ctr
->info
.id9
== NULL
) {
6647 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6650 ret
= sam_io_user_info9("", ctr
->info
.id9
, ps
, depth
);
6653 if (UNMARSHALLING(ps
))
6654 ctr
->info
.id16
= PRS_ALLOC_MEM(ps
,SAM_USER_INFO_16
,1);
6655 if (ctr
->info
.id16
== NULL
) {
6656 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6659 ret
= sam_io_user_info16("", ctr
->info
.id16
, ps
, depth
);
6662 if (UNMARSHALLING(ps
))
6663 ctr
->info
.id17
= PRS_ALLOC_MEM(ps
,SAM_USER_INFO_17
,1);
6665 if (ctr
->info
.id17
== NULL
) {
6666 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6669 ret
= sam_io_user_info17("", ctr
->info
.id17
, ps
, depth
);
6672 if (UNMARSHALLING(ps
))
6673 ctr
->info
.id18
= PRS_ALLOC_MEM(ps
,SAM_USER_INFO_18
,1);
6675 if (ctr
->info
.id18
== NULL
) {
6676 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6679 ret
= sam_io_user_info18("", ctr
->info
.id18
, ps
, depth
);
6682 if (UNMARSHALLING(ps
))
6683 ctr
->info
.id20
= PRS_ALLOC_MEM(ps
,SAM_USER_INFO_20
,1);
6685 if (ctr
->info
.id20
== NULL
) {
6686 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6689 ret
= sam_io_user_info20("", ctr
->info
.id20
, ps
, depth
);
6692 if (UNMARSHALLING(ps
))
6693 ctr
->info
.id21
= PRS_ALLOC_MEM(ps
,SAM_USER_INFO_21
,1);
6695 if (ctr
->info
.id21
== NULL
) {
6696 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6699 ret
= sam_io_user_info21("", ctr
->info
.id21
, ps
, depth
);
6702 if (UNMARSHALLING(ps
))
6703 ctr
->info
.id23
= PRS_ALLOC_MEM(ps
,SAM_USER_INFO_23
,1);
6705 if (ctr
->info
.id23
== NULL
) {
6706 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6709 ret
= sam_io_user_info23("", ctr
->info
.id23
, ps
, depth
);
6712 if (UNMARSHALLING(ps
))
6713 ctr
->info
.id24
= PRS_ALLOC_MEM(ps
,SAM_USER_INFO_24
,1);
6715 if (ctr
->info
.id24
== NULL
) {
6716 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6719 ret
= sam_io_user_info24("", ctr
->info
.id24
, ps
, depth
);
6722 if (UNMARSHALLING(ps
))
6723 ctr
->info
.id25
= PRS_ALLOC_MEM(ps
,SAM_USER_INFO_25
,1);
6725 if (ctr
->info
.id25
== NULL
) {
6726 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6729 ret
= sam_io_user_info25("", ctr
->info
.id25
, ps
, depth
);
6732 if (UNMARSHALLING(ps
))
6733 ctr
->info
.id26
= PRS_ALLOC_MEM(ps
,SAM_USER_INFO_26
,1);
6735 if (ctr
->info
.id26
== NULL
) {
6736 DEBUG(2,("samr_io_userinfo_ctr: info pointer not initialised\n"));
6739 ret
= sam_io_user_info26("", ctr
->info
.id26
, ps
, depth
);
6742 DEBUG(2, ("samr_io_userinfo_ctr: unknown switch level 0x%x\n", ctr
->switch_value
));
6750 /*******************************************************************
6751 inits a SAMR_R_QUERY_USERINFO structure.
6752 ********************************************************************/
6754 void init_samr_r_query_userinfo(SAMR_R_QUERY_USERINFO
* r_u
,
6755 SAM_USERINFO_CTR
* ctr
, NTSTATUS status
)
6757 DEBUG(5, ("init_samr_r_query_userinfo\n"));
6762 if (NT_STATUS_IS_OK(status
)) {
6767 r_u
->status
= status
; /* return status */
6770 /*******************************************************************
6771 reads or writes a structure.
6772 ********************************************************************/
6774 BOOL
samr_io_r_query_userinfo(const char *desc
, SAMR_R_QUERY_USERINFO
* r_u
,
6775 prs_struct
*ps
, int depth
)
6780 prs_debug(ps
, depth
, desc
, "samr_io_r_query_userinfo");
6786 if(!prs_uint32("ptr", ps
, depth
, &r_u
->ptr
))
6789 if (r_u
->ptr
!= 0) {
6790 if(!samr_io_userinfo_ctr("ctr", &r_u
->ctr
, ps
, depth
))
6796 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
6802 /*******************************************************************
6803 inits a SAMR_Q_SET_USERINFO structure.
6804 ********************************************************************/
6806 void init_samr_q_set_userinfo(SAMR_Q_SET_USERINFO
* q_u
,
6807 const POLICY_HND
*hnd
, DATA_BLOB
*sess_key
,
6808 uint16 switch_value
, void *info
)
6810 DEBUG(5, ("init_samr_q_set_userinfo\n"));
6813 q_u
->switch_value
= switch_value
;
6814 init_samr_userinfo_ctr(q_u
->ctr
, sess_key
, switch_value
, info
);
6817 /*******************************************************************
6818 reads or writes a structure.
6819 ********************************************************************/
6821 BOOL
samr_io_q_set_userinfo(const char *desc
, SAMR_Q_SET_USERINFO
* q_u
,
6822 prs_struct
*ps
, int depth
)
6827 prs_debug(ps
, depth
, desc
, "samr_io_q_set_userinfo");
6833 smb_io_pol_hnd("pol", &(q_u
->pol
), ps
, depth
);
6835 if(!prs_uint16("switch_value", ps
, depth
, &q_u
->switch_value
))
6837 if(!samr_io_userinfo_ctr("ctr", &q_u
->ctr
, ps
, depth
))
6843 /*******************************************************************
6844 inits a SAMR_R_SET_USERINFO structure.
6845 ********************************************************************/
6847 void init_samr_r_set_userinfo(SAMR_R_SET_USERINFO
* r_u
, NTSTATUS status
)
6849 DEBUG(5, ("init_samr_r_set_userinfo\n"));
6851 r_u
->status
= status
; /* return status */
6854 /*******************************************************************
6855 reads or writes a structure.
6856 ********************************************************************/
6858 BOOL
samr_io_r_set_userinfo(const char *desc
, SAMR_R_SET_USERINFO
* r_u
,
6859 prs_struct
*ps
, int depth
)
6864 prs_debug(ps
, depth
, desc
, "samr_io_r_set_userinfo");
6870 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
6876 /*******************************************************************
6877 inits a SAMR_Q_SET_USERINFO2 structure.
6878 ********************************************************************/
6880 void init_samr_q_set_userinfo2(SAMR_Q_SET_USERINFO2
* q_u
,
6881 const POLICY_HND
*hnd
, DATA_BLOB
*sess_key
,
6882 uint16 switch_value
, SAM_USERINFO_CTR
* ctr
)
6884 DEBUG(5, ("init_samr_q_set_userinfo2\n"));
6887 q_u
->switch_value
= switch_value
;
6890 q_u
->ctr
->switch_value
= switch_value
;
6892 switch (switch_value
) {
6894 SamOEMhashBlob(ctr
->info
.id18
->lm_pwd
, 16, sess_key
);
6895 SamOEMhashBlob(ctr
->info
.id18
->nt_pwd
, 16, sess_key
);
6896 dump_data(100, (char *)sess_key
->data
, sess_key
->length
);
6897 dump_data(100, (char *)ctr
->info
.id18
->lm_pwd
, 16);
6898 dump_data(100, (char *)ctr
->info
.id18
->nt_pwd
, 16);
6903 /*******************************************************************
6904 reads or writes a structure.
6905 ********************************************************************/
6907 BOOL
samr_io_q_set_userinfo2(const char *desc
, SAMR_Q_SET_USERINFO2
* q_u
,
6908 prs_struct
*ps
, int depth
)
6913 prs_debug(ps
, depth
, desc
, "samr_io_q_set_userinfo2");
6919 if(!smb_io_pol_hnd("pol", &q_u
->pol
, ps
, depth
))
6922 if(!prs_uint16("switch_value", ps
, depth
, &q_u
->switch_value
))
6924 if(!samr_io_userinfo_ctr("ctr", &q_u
->ctr
, ps
, depth
))
6930 /*******************************************************************
6931 inits a SAMR_R_SET_USERINFO2 structure.
6932 ********************************************************************/
6934 void init_samr_r_set_userinfo2(SAMR_R_SET_USERINFO2
* r_u
, NTSTATUS status
)
6936 DEBUG(5, ("init_samr_r_set_userinfo2\n"));
6938 r_u
->status
= status
; /* return status */
6941 /*******************************************************************
6942 reads or writes a structure.
6943 ********************************************************************/
6945 BOOL
samr_io_r_set_userinfo2(const char *desc
, SAMR_R_SET_USERINFO2
* r_u
,
6946 prs_struct
*ps
, int depth
)
6951 prs_debug(ps
, depth
, desc
, "samr_io_r_set_userinfo2");
6957 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
6963 /*******************************************************************
6964 inits a SAMR_Q_CONNECT structure.
6965 ********************************************************************/
6967 void init_samr_q_connect(SAMR_Q_CONNECT
* q_u
,
6968 char *srv_name
, uint32 access_mask
)
6970 DEBUG(5, ("init_samr_q_connect\n"));
6972 /* make PDC server name \\server */
6973 q_u
->ptr_srv_name
= (srv_name
!= NULL
&& *srv_name
) ? 1 : 0;
6974 init_unistr2(&q_u
->uni_srv_name
, srv_name
, UNI_STR_TERMINATE
);
6976 /* example values: 0x0000 0002 */
6977 q_u
->access_mask
= access_mask
;
6980 /*******************************************************************
6981 reads or writes a structure.
6982 ********************************************************************/
6984 BOOL
samr_io_q_connect(const char *desc
, SAMR_Q_CONNECT
* q_u
,
6985 prs_struct
*ps
, int depth
)
6990 prs_debug(ps
, depth
, desc
, "samr_io_q_connect");
6996 if(!prs_uint32("ptr_srv_name", ps
, depth
, &q_u
->ptr_srv_name
))
6998 if(!smb_io_unistr2("", &q_u
->uni_srv_name
, q_u
->ptr_srv_name
, ps
, depth
))
7003 if(!prs_uint32("access_mask", ps
, depth
, &q_u
->access_mask
))
7009 /*******************************************************************
7010 reads or writes a structure.
7011 ********************************************************************/
7013 BOOL
samr_io_r_connect(const char *desc
, SAMR_R_CONNECT
* r_u
,
7014 prs_struct
*ps
, int depth
)
7019 prs_debug(ps
, depth
, desc
, "samr_io_r_connect");
7025 if(!smb_io_pol_hnd("connect_pol", &r_u
->connect_pol
, ps
, depth
))
7028 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
7034 /*******************************************************************
7035 inits a SAMR_Q_CONNECT4 structure.
7036 ********************************************************************/
7038 void init_samr_q_connect4(SAMR_Q_CONNECT4
* q_u
,
7039 char *srv_name
, uint32 access_mask
)
7041 DEBUG(5, ("init_samr_q_connect4\n"));
7043 /* make PDC server name \\server */
7044 q_u
->ptr_srv_name
= (srv_name
!= NULL
&& *srv_name
) ? 1 : 0;
7045 init_unistr2(&q_u
->uni_srv_name
, srv_name
, UNI_STR_TERMINATE
);
7047 /* Only value we've seen, possibly an address type ? */
7050 /* example values: 0x0000 0002 */
7051 q_u
->access_mask
= access_mask
;
7054 /*******************************************************************
7055 reads or writes a structure.
7056 ********************************************************************/
7058 BOOL
samr_io_q_connect4(const char *desc
, SAMR_Q_CONNECT4
* q_u
,
7059 prs_struct
*ps
, int depth
)
7064 prs_debug(ps
, depth
, desc
, "samr_io_q_connect4");
7070 if(!prs_uint32("ptr_srv_name", ps
, depth
, &q_u
->ptr_srv_name
))
7072 if(!smb_io_unistr2("", &q_u
->uni_srv_name
, q_u
->ptr_srv_name
, ps
, depth
))
7077 if(!prs_uint32("unk_0", ps
, depth
, &q_u
->unk_0
))
7079 if(!prs_uint32("access_mask", ps
, depth
, &q_u
->access_mask
))
7085 /*******************************************************************
7086 reads or writes a structure.
7087 ********************************************************************/
7089 BOOL
samr_io_r_connect4(const char *desc
, SAMR_R_CONNECT4
* r_u
,
7090 prs_struct
*ps
, int depth
)
7095 prs_debug(ps
, depth
, desc
, "samr_io_r_connect4");
7101 if(!smb_io_pol_hnd("connect_pol", &r_u
->connect_pol
, ps
, depth
))
7104 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
7110 /*******************************************************************
7111 inits a SAMR_Q_CONNECT5 structure.
7112 ********************************************************************/
7114 void init_samr_q_connect5(SAMR_Q_CONNECT5
* q_u
,
7115 char *srv_name
, uint32 access_mask
)
7117 DEBUG(5, ("init_samr_q_connect5\n"));
7119 /* make PDC server name \\server */
7120 q_u
->ptr_srv_name
= (srv_name
!= NULL
&& *srv_name
) ? 1 : 0;
7121 init_unistr2(&q_u
->uni_srv_name
, srv_name
, UNI_STR_TERMINATE
);
7123 /* example values: 0x0000 0002 */
7124 q_u
->access_mask
= access_mask
;
7127 q_u
->info1_unk1
= 3;
7128 q_u
->info1_unk2
= 0;
7131 /*******************************************************************
7132 inits a SAMR_R_CONNECT5 structure.
7133 ********************************************************************/
7135 void init_samr_r_connect5(SAMR_R_CONNECT5
* r_u
, POLICY_HND
*pol
, NTSTATUS status
)
7137 DEBUG(5, ("init_samr_q_connect5\n"));
7140 r_u
->info1_unk1
= 3;
7141 r_u
->info1_unk2
= 0;
7143 r_u
->connect_pol
= *pol
;
7144 r_u
->status
= status
;
7147 /*******************************************************************
7148 reads or writes a structure.
7149 ********************************************************************/
7151 BOOL
samr_io_q_connect5(const char *desc
, SAMR_Q_CONNECT5
* q_u
,
7152 prs_struct
*ps
, int depth
)
7157 prs_debug(ps
, depth
, desc
, "samr_io_q_connect5");
7163 if(!prs_uint32("ptr_srv_name", ps
, depth
, &q_u
->ptr_srv_name
))
7165 if(!smb_io_unistr2("", &q_u
->uni_srv_name
, q_u
->ptr_srv_name
, ps
, depth
))
7170 if(!prs_uint32("access_mask", ps
, depth
, &q_u
->access_mask
))
7173 if(!prs_uint32("level", ps
, depth
, &q_u
->level
))
7175 if(!prs_uint32("level", ps
, depth
, &q_u
->level
))
7178 if(!prs_uint32("info1_unk1", ps
, depth
, &q_u
->info1_unk1
))
7180 if(!prs_uint32("info1_unk2", ps
, depth
, &q_u
->info1_unk2
))
7186 /*******************************************************************
7187 reads or writes a structure.
7188 ********************************************************************/
7190 BOOL
samr_io_r_connect5(const char *desc
, SAMR_R_CONNECT5
* r_u
,
7191 prs_struct
*ps
, int depth
)
7196 prs_debug(ps
, depth
, desc
, "samr_io_r_connect5");
7202 if(!prs_uint32("level", ps
, depth
, &r_u
->level
))
7204 if(!prs_uint32("level", ps
, depth
, &r_u
->level
))
7206 if(!prs_uint32("info1_unk1", ps
, depth
, &r_u
->info1_unk1
))
7208 if(!prs_uint32("info1_unk2", ps
, depth
, &r_u
->info1_unk2
))
7211 if(!smb_io_pol_hnd("connect_pol", &r_u
->connect_pol
, ps
, depth
))
7214 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
7220 /*******************************************************************
7221 inits a SAMR_Q_CONNECT_ANON structure.
7222 ********************************************************************/
7224 void init_samr_q_connect_anon(SAMR_Q_CONNECT_ANON
* q_u
)
7226 DEBUG(5, ("init_samr_q_connect_anon\n"));
7229 q_u
->unknown_0
= 0x5c; /* server name (?!!) */
7230 q_u
->access_mask
= MAXIMUM_ALLOWED_ACCESS
;
7233 /*******************************************************************
7234 reads or writes a structure.
7235 ********************************************************************/
7237 BOOL
samr_io_q_connect_anon(const char *desc
, SAMR_Q_CONNECT_ANON
* q_u
,
7238 prs_struct
*ps
, int depth
)
7243 prs_debug(ps
, depth
, desc
, "samr_io_q_connect_anon");
7249 if(!prs_uint32("ptr ", ps
, depth
, &q_u
->ptr
))
7252 if(!prs_uint16("unknown_0", ps
, depth
, &q_u
->unknown_0
))
7257 if(!prs_uint32("access_mask", ps
, depth
, &q_u
->access_mask
))
7263 /*******************************************************************
7264 reads or writes a structure.
7265 ********************************************************************/
7267 BOOL
samr_io_r_connect_anon(const char *desc
, SAMR_R_CONNECT_ANON
* r_u
,
7268 prs_struct
*ps
, int depth
)
7273 prs_debug(ps
, depth
, desc
, "samr_io_r_connect_anon");
7279 if(!smb_io_pol_hnd("connect_pol", &r_u
->connect_pol
, ps
, depth
))
7282 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
7288 /*******************************************************************
7289 inits a SAMR_Q_GET_DOM_PWINFO structure.
7290 ********************************************************************/
7292 void init_samr_q_get_dom_pwinfo(SAMR_Q_GET_DOM_PWINFO
* q_u
,
7295 DEBUG(5, ("init_samr_q_get_dom_pwinfo\n"));
7298 init_unistr2(&q_u
->uni_srv_name
, srv_name
, UNI_FLAGS_NONE
);
7299 init_uni_hdr(&q_u
->hdr_srv_name
, &q_u
->uni_srv_name
);
7302 /*******************************************************************
7303 reads or writes a structure.
7304 ********************************************************************/
7306 BOOL
samr_io_q_get_dom_pwinfo(const char *desc
, SAMR_Q_GET_DOM_PWINFO
* q_u
,
7307 prs_struct
*ps
, int depth
)
7312 prs_debug(ps
, depth
, desc
, "samr_io_q_get_dom_pwinfo");
7318 if(!prs_uint32("ptr", ps
, depth
, &q_u
->ptr
))
7320 if (q_u
->ptr
!= 0) {
7321 if(!smb_io_unihdr("", &q_u
->hdr_srv_name
, ps
, depth
))
7323 if(!smb_io_unistr2("", &q_u
->uni_srv_name
, q_u
->hdr_srv_name
.buffer
, ps
, depth
))
7330 /*******************************************************************
7331 reads or writes a structure.
7332 ********************************************************************/
7334 BOOL
samr_io_r_get_dom_pwinfo(const char *desc
, SAMR_R_GET_DOM_PWINFO
* r_u
,
7335 prs_struct
*ps
, int depth
)
7340 prs_debug(ps
, depth
, desc
, "samr_io_r_get_dom_pwinfo");
7346 if(!prs_uint16("min_pwd_length", ps
, depth
, &r_u
->min_pwd_length
))
7350 if(!prs_uint32("password_properties", ps
, depth
, &r_u
->password_properties
))
7353 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
7359 /*******************************************************************
7360 make a SAMR_ENC_PASSWD structure.
7361 ********************************************************************/
7363 void init_enc_passwd(SAMR_ENC_PASSWD
* pwd
, const char pass
[512])
7371 memcpy(pwd
->pass
, pass
, sizeof(pwd
->pass
));
7375 /*******************************************************************
7376 reads or writes a SAMR_ENC_PASSWD structure.
7377 ********************************************************************/
7379 BOOL
samr_io_enc_passwd(const char *desc
, SAMR_ENC_PASSWD
* pwd
,
7380 prs_struct
*ps
, int depth
)
7385 prs_debug(ps
, depth
, desc
, "samr_io_enc_passwd");
7391 if(!prs_uint32("ptr", ps
, depth
, &pwd
->ptr
))
7394 if (pwd
->ptr
!= 0) {
7395 if(!prs_uint8s(False
, "pwd", ps
, depth
, pwd
->pass
, sizeof(pwd
->pass
)))
7402 /*******************************************************************
7403 inits a SAMR_ENC_HASH structure.
7404 ********************************************************************/
7406 void init_enc_hash(SAMR_ENC_HASH
* hsh
, const uchar hash
[16])
7414 memcpy(hsh
->hash
, hash
, sizeof(hsh
->hash
));
7418 /*******************************************************************
7419 reads or writes a SAMR_ENC_HASH structure.
7420 ********************************************************************/
7422 BOOL
samr_io_enc_hash(const char *desc
, SAMR_ENC_HASH
* hsh
,
7423 prs_struct
*ps
, int depth
)
7428 prs_debug(ps
, depth
, desc
, "samr_io_enc_hash");
7434 if(!prs_uint32("ptr ", ps
, depth
, &hsh
->ptr
))
7436 if (hsh
->ptr
!= 0) {
7437 if(!prs_uint8s(False
, "hash", ps
, depth
, hsh
->hash
,sizeof(hsh
->hash
)))
7444 /*******************************************************************
7445 inits a SAMR_Q_CHGPASSWD_USER structure.
7446 ********************************************************************/
7448 void init_samr_q_chgpasswd_user(SAMR_Q_CHGPASSWD_USER
* q_u
,
7449 const char *dest_host
, const char *user_name
,
7450 const uchar nt_newpass
[516],
7451 const uchar nt_oldhash
[16],
7452 const uchar lm_newpass
[516],
7453 const uchar lm_oldhash
[16])
7455 DEBUG(5, ("init_samr_q_chgpasswd_user\n"));
7458 init_unistr2(&q_u
->uni_dest_host
, dest_host
, UNI_FLAGS_NONE
);
7459 init_uni_hdr(&q_u
->hdr_dest_host
, &q_u
->uni_dest_host
);
7461 init_unistr2(&q_u
->uni_user_name
, user_name
, UNI_FLAGS_NONE
);
7462 init_uni_hdr(&q_u
->hdr_user_name
, &q_u
->uni_user_name
);
7464 init_enc_passwd(&q_u
->nt_newpass
, (const char *)nt_newpass
);
7465 init_enc_hash(&q_u
->nt_oldhash
, nt_oldhash
);
7467 q_u
->unknown
= 0x01;
7469 init_enc_passwd(&q_u
->lm_newpass
, (const char *)lm_newpass
);
7470 init_enc_hash(&q_u
->lm_oldhash
, lm_oldhash
);
7473 /*******************************************************************
7474 reads or writes a structure.
7475 ********************************************************************/
7477 BOOL
samr_io_q_chgpasswd_user(const char *desc
, SAMR_Q_CHGPASSWD_USER
* q_u
,
7478 prs_struct
*ps
, int depth
)
7483 prs_debug(ps
, depth
, desc
, "samr_io_q_chgpasswd_user");
7489 if(!prs_uint32("ptr_0", ps
, depth
, &q_u
->ptr_0
))
7492 if(!smb_io_unihdr("", &q_u
->hdr_dest_host
, ps
, depth
))
7494 if(!smb_io_unistr2("", &q_u
->uni_dest_host
, q_u
->hdr_dest_host
.buffer
, ps
, depth
))
7499 if(!smb_io_unihdr("", &q_u
->hdr_user_name
, ps
, depth
))
7501 if(!smb_io_unistr2("", &q_u
->uni_user_name
, q_u
->hdr_user_name
.buffer
,ps
, depth
))
7504 if(!samr_io_enc_passwd("nt_newpass", &q_u
->nt_newpass
, ps
, depth
))
7506 if(!samr_io_enc_hash("nt_oldhash", &q_u
->nt_oldhash
, ps
, depth
))
7509 if(!prs_uint32("unknown", ps
, depth
, &q_u
->unknown
))
7512 if(!samr_io_enc_passwd("lm_newpass", &q_u
->lm_newpass
, ps
, depth
))
7514 if(!samr_io_enc_hash("lm_oldhash", &q_u
->lm_oldhash
, ps
, depth
))
7520 /*******************************************************************
7521 inits a SAMR_R_CHGPASSWD_USER structure.
7522 ********************************************************************/
7524 void init_samr_r_chgpasswd_user(SAMR_R_CHGPASSWD_USER
* r_u
, NTSTATUS status
)
7526 DEBUG(5, ("init_samr_r_chgpasswd_user\n"));
7528 r_u
->status
= status
;
7531 /*******************************************************************
7532 reads or writes a structure.
7533 ********************************************************************/
7535 BOOL
samr_io_r_chgpasswd_user(const char *desc
, SAMR_R_CHGPASSWD_USER
* r_u
,
7536 prs_struct
*ps
, int depth
)
7541 prs_debug(ps
, depth
, desc
, "samr_io_r_chgpasswd_user");
7547 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
7553 /*******************************************************************
7554 inits a SAMR_Q_CHGPASSWD3 structure.
7555 ********************************************************************/
7557 void init_samr_q_chgpasswd_user3(SAMR_Q_CHGPASSWD_USER3
* q_u
,
7558 const char *dest_host
, const char *user_name
,
7559 const uchar nt_newpass
[516],
7560 const uchar nt_oldhash
[16],
7561 const uchar lm_newpass
[516],
7562 const uchar lm_oldhash
[16])
7564 DEBUG(5, ("init_samr_q_chgpasswd_user3\n"));
7567 init_unistr2(&q_u
->uni_dest_host
, dest_host
, UNI_FLAGS_NONE
);
7568 init_uni_hdr(&q_u
->hdr_dest_host
, &q_u
->uni_dest_host
);
7570 init_unistr2(&q_u
->uni_user_name
, user_name
, UNI_FLAGS_NONE
);
7571 init_uni_hdr(&q_u
->hdr_user_name
, &q_u
->uni_user_name
);
7573 init_enc_passwd(&q_u
->nt_newpass
, (const char *)nt_newpass
);
7574 init_enc_hash(&q_u
->nt_oldhash
, nt_oldhash
);
7576 q_u
->lm_change
= 0x01;
7578 init_enc_passwd(&q_u
->lm_newpass
, (const char *)lm_newpass
);
7579 init_enc_hash(&q_u
->lm_oldhash
, lm_oldhash
);
7581 init_enc_passwd(&q_u
->password3
, NULL
);
7584 /*******************************************************************
7585 reads or writes a structure.
7586 ********************************************************************/
7588 BOOL
samr_io_q_chgpasswd_user3(const char *desc
, SAMR_Q_CHGPASSWD_USER3
* q_u
,
7589 prs_struct
*ps
, int depth
)
7594 prs_debug(ps
, depth
, desc
, "samr_io_q_chgpasswd_user3");
7600 if(!prs_uint32("ptr_0", ps
, depth
, &q_u
->ptr_0
))
7603 if(!smb_io_unihdr("", &q_u
->hdr_dest_host
, ps
, depth
))
7605 if(!smb_io_unistr2("", &q_u
->uni_dest_host
, q_u
->hdr_dest_host
.buffer
, ps
, depth
))
7610 if(!smb_io_unihdr("", &q_u
->hdr_user_name
, ps
, depth
))
7612 if(!smb_io_unistr2("", &q_u
->uni_user_name
, q_u
->hdr_user_name
.buffer
,ps
, depth
))
7615 if(!samr_io_enc_passwd("nt_newpass", &q_u
->nt_newpass
, ps
, depth
))
7617 if(!samr_io_enc_hash("nt_oldhash", &q_u
->nt_oldhash
, ps
, depth
))
7620 if(!prs_uint32("lm_change", ps
, depth
, &q_u
->lm_change
))
7623 if(!samr_io_enc_passwd("lm_newpass", &q_u
->lm_newpass
, ps
, depth
))
7625 if(!samr_io_enc_hash("lm_oldhash", &q_u
->lm_oldhash
, ps
, depth
))
7628 if(!samr_io_enc_passwd("password3", &q_u
->password3
, ps
, depth
))
7634 /*******************************************************************
7635 inits a SAMR_R_CHGPASSWD_USER3 structure.
7636 ********************************************************************/
7638 void init_samr_r_chgpasswd_user3(SAMR_R_CHGPASSWD_USER3
*r_u
, NTSTATUS status
,
7639 SAMR_CHANGE_REJECT
*reject
, SAM_UNK_INFO_1
*info
)
7641 DEBUG(5, ("init_samr_r_chgpasswd_user3\n"));
7643 r_u
->status
= status
;
7647 r_u
->ptr_reject
= 0;
7653 if (reject
&& (reject
->reject_reason
!= Undefined
)) {
7654 r_u
->reject
= reject
;
7655 r_u
->ptr_reject
= 1;
7659 /*******************************************************************
7660 Reads or writes an SAMR_CHANGE_REJECT structure.
7661 ********************************************************************/
7663 BOOL
samr_io_change_reject(const char *desc
, SAMR_CHANGE_REJECT
*reject
, prs_struct
*ps
, int depth
)
7668 prs_debug(ps
, depth
, desc
, "samr_io_change_reject");
7674 if(UNMARSHALLING(ps
))
7675 ZERO_STRUCTP(reject
);
7677 if (!prs_uint32("reject_reason", ps
, depth
, &reject
->reject_reason
))
7680 if (!prs_uint32("unknown1", ps
, depth
, &reject
->unknown1
))
7683 if (!prs_uint32("unknown2", ps
, depth
, &reject
->unknown2
))
7689 /*******************************************************************
7690 reads or writes a structure.
7691 ********************************************************************/
7693 BOOL
samr_io_r_chgpasswd_user3(const char *desc
, SAMR_R_CHGPASSWD_USER3
*r_u
,
7694 prs_struct
*ps
, int depth
)
7699 prs_debug(ps
, depth
, desc
, "samr_io_r_chgpasswd_user3");
7705 if (!prs_uint32("ptr_info", ps
, depth
, &r_u
->ptr_info
))
7708 if (r_u
->ptr_info
&& r_u
->info
!= NULL
) {
7709 /* SAM_UNK_INFO_1 */
7710 if (!sam_io_unk_info1("info", r_u
->info
, ps
, depth
))
7714 if (!prs_uint32("ptr_reject", ps
, depth
, &r_u
->ptr_reject
))
7717 if (r_u
->ptr_reject
&& r_u
->reject
!= NULL
) {
7718 /* SAMR_CHANGE_REJECT */
7719 if (!samr_io_change_reject("reject", r_u
->reject
, ps
, depth
))
7723 if (!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
7729 /*******************************************************************
7730 reads or writes a structure.
7731 ********************************************************************/
7733 void init_samr_q_query_domain_info2(SAMR_Q_QUERY_DOMAIN_INFO2
*q_u
,
7734 POLICY_HND
*domain_pol
, uint16 switch_value
)
7736 DEBUG(5, ("init_samr_q_query_domain_info2\n"));
7738 q_u
->domain_pol
= *domain_pol
;
7739 q_u
->switch_value
= switch_value
;
7742 /*******************************************************************
7743 reads or writes a structure.
7744 ********************************************************************/
7746 BOOL
samr_io_q_query_domain_info2(const char *desc
, SAMR_Q_QUERY_DOMAIN_INFO2
*q_u
,
7747 prs_struct
*ps
, int depth
)
7752 prs_debug(ps
, depth
, desc
, "samr_io_q_query_domain_info2");
7758 if(!smb_io_pol_hnd("domain_pol", &q_u
->domain_pol
, ps
, depth
))
7761 if(!prs_uint16("switch_value", ps
, depth
, &q_u
->switch_value
))
7767 /*******************************************************************
7768 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7769 ********************************************************************/
7771 void init_samr_r_query_domain_info2(SAMR_R_QUERY_DOMAIN_INFO2
* r_u
,
7772 uint16 switch_value
, SAM_UNK_CTR
* ctr
,
7775 DEBUG(5, ("init_samr_r_query_domain_info2\n"));
7778 r_u
->switch_value
= 0;
7779 r_u
->status
= status
; /* return status */
7781 if (NT_STATUS_IS_OK(status
)) {
7782 r_u
->switch_value
= switch_value
;
7788 /*******************************************************************
7789 reads or writes a structure.
7790 ********************************************************************/
7792 BOOL
samr_io_r_query_domain_info2(const char *desc
, SAMR_R_QUERY_DOMAIN_INFO2
* r_u
,
7793 prs_struct
*ps
, int depth
)
7798 prs_debug(ps
, depth
, desc
, "samr_io_r_query_domain_info2");
7804 if(!prs_uint32("ptr_0 ", ps
, depth
, &r_u
->ptr_0
))
7807 if (r_u
->ptr_0
!= 0 && r_u
->ctr
!= NULL
) {
7808 if(!prs_uint16("switch_value", ps
, depth
, &r_u
->switch_value
))
7813 switch (r_u
->switch_value
) {
7815 if(!sam_io_unk_info13("unk_inf13", &r_u
->ctr
->info
.inf13
, ps
, depth
))
7819 if(!sam_io_unk_info12("unk_inf12", &r_u
->ctr
->info
.inf12
, ps
, depth
))
7823 if(!sam_io_unk_info9("unk_inf9",&r_u
->ctr
->info
.inf9
, ps
,depth
))
7827 if(!sam_io_unk_info8("unk_inf8",&r_u
->ctr
->info
.inf8
, ps
,depth
))
7831 if(!sam_io_unk_info7("unk_inf7",&r_u
->ctr
->info
.inf7
, ps
,depth
))
7835 if(!sam_io_unk_info6("unk_inf6",&r_u
->ctr
->info
.inf6
, ps
,depth
))
7839 if(!sam_io_unk_info5("unk_inf5",&r_u
->ctr
->info
.inf5
, ps
,depth
))
7843 if(!sam_io_unk_info4("unk_inf4",&r_u
->ctr
->info
.inf4
, ps
,depth
))
7847 if(!sam_io_unk_info3("unk_inf3",&r_u
->ctr
->info
.inf3
, ps
,depth
))
7851 if(!sam_io_unk_info2("unk_inf2",&r_u
->ctr
->info
.inf2
, ps
,depth
))
7855 if(!sam_io_unk_info1("unk_inf1",&r_u
->ctr
->info
.inf1
, ps
,depth
))
7859 DEBUG(0, ("samr_io_r_query_domain_info2: unknown switch level 0x%x\n",
7860 r_u
->switch_value
));
7861 r_u
->status
= NT_STATUS_INVALID_INFO_CLASS
;
7869 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))
7876 /*******************************************************************
7877 reads or writes a structure.
7878 ********************************************************************/
7880 void init_samr_q_set_domain_info(SAMR_Q_SET_DOMAIN_INFO
*q_u
,
7881 POLICY_HND
*domain_pol
, uint16 switch_value
, SAM_UNK_CTR
*ctr
)
7883 DEBUG(5, ("init_samr_q_set_domain_info\n"));
7885 q_u
->domain_pol
= *domain_pol
;
7886 q_u
->switch_value0
= switch_value
;
7888 q_u
->switch_value
= switch_value
;
7893 /*******************************************************************
7894 reads or writes a structure.
7895 ********************************************************************/
7897 BOOL
samr_io_q_set_domain_info(const char *desc
, SAMR_Q_SET_DOMAIN_INFO
*q_u
,
7898 prs_struct
*ps
, int depth
)
7903 prs_debug(ps
, depth
, desc
, "samr_io_q_set_domain_info");
7909 if(!smb_io_pol_hnd("domain_pol", &q_u
->domain_pol
, ps
, depth
))
7912 if(!prs_uint16("switch_value0", ps
, depth
, &q_u
->switch_value0
))
7915 if(!prs_uint16("switch_value", ps
, depth
, &q_u
->switch_value
))
7921 if (UNMARSHALLING(ps
)) {
7922 if ((q_u
->ctr
= PRS_ALLOC_MEM(ps
, SAM_UNK_CTR
, 1)) == NULL
)
7926 switch (q_u
->switch_value
) {
7929 if(!sam_io_unk_info12("unk_inf12", &q_u
->ctr
->info
.inf12
, ps
, depth
))
7933 if(!sam_io_unk_info7("unk_inf7",&q_u
->ctr
->info
.inf7
, ps
,depth
))
7937 if(!sam_io_unk_info6("unk_inf6",&q_u
->ctr
->info
.inf6
, ps
,depth
))
7941 if(!sam_io_unk_info5("unk_inf5",&q_u
->ctr
->info
.inf5
, ps
,depth
))
7945 if(!sam_io_unk_info3("unk_inf3",&q_u
->ctr
->info
.inf3
, ps
,depth
))
7949 if(!sam_io_unk_info2("unk_inf2",&q_u
->ctr
->info
.inf2
, ps
,depth
))
7953 if(!sam_io_unk_info1("unk_inf1",&q_u
->ctr
->info
.inf1
, ps
,depth
))
7957 DEBUG(0, ("samr_io_r_samr_unknown_2e: unknown switch level 0x%x\n",
7958 q_u
->switch_value
));
7965 /*******************************************************************
7966 inits a SAMR_R_QUERY_DOMAIN_INFO structure.
7967 ********************************************************************/
7969 void init_samr_r_set_domain_info(SAMR_R_SET_DOMAIN_INFO
* r_u
, NTSTATUS status
)
7971 DEBUG(5, ("init_samr_r_set_domain_info\n"));
7973 r_u
->status
= status
; /* return status */
7976 /*******************************************************************
7977 reads or writes a structure.
7978 ********************************************************************/
7980 BOOL
samr_io_r_set_domain_info(const char *desc
, SAMR_R_SET_DOMAIN_INFO
* r_u
,
7981 prs_struct
*ps
, int depth
)
7986 prs_debug(ps
, depth
, desc
, "samr_io_r_samr_unknown_2e");
7992 if(!prs_ntstatus("status", ps
, depth
, &r_u
->status
))