2 Unix SMB/Netbios implementation.
4 NT Domain Authentication SMB / MSRPC client
5 Copyright (C) Andrew Tridgell 1994-1997
6 Copyright (C) Luke Kenneth Casson Leighton 1996-1997
7 Copyright (C) Jeremy Allison 1999.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33 extern int DEBUGLEVEL;
35 /****************************************************************************
36 do a SAMR query user groups
37 ****************************************************************************/
38 BOOL get_samr_query_usergroups(struct cli_state *cli,
39 POLICY_HND *pol_open_domain, uint32 user_rid,
40 uint32 *num_groups, DOM_GID *gid)
42 POLICY_HND pol_open_user;
43 if (pol_open_domain == NULL || num_groups == NULL || gid == NULL)
46 /* send open domain (on user sid) */
47 if (!do_samr_open_user(cli,
55 /* send user groups query */
56 if (!do_samr_query_usergroups(cli,
60 DEBUG(5,("do_samr_query_usergroups: error in query user groups\n"));
63 return do_samr_close(cli, &pol_open_user);
66 /****************************************************************************
67 do a SAMR query user info
68 ****************************************************************************/
69 BOOL get_samr_query_userinfo(struct cli_state *cli,
70 POLICY_HND *pol_open_domain,
72 uint32 user_rid, SAM_USER_INFO_21 *usr)
74 POLICY_HND pol_open_user;
75 if (pol_open_domain == NULL || usr == NULL)
78 memset((char *)usr, '\0', sizeof(*usr));
80 /* send open domain (on user sid) */
81 if (!do_samr_open_user(cli,
89 /* send user info query */
90 if (!do_samr_query_userinfo(cli,
92 info_level, (void*)usr))
94 DEBUG(5,("do_samr_query_userinfo: error in query user info, level 0x%x\n",
98 return do_samr_close(cli, &pol_open_user);
101 /****************************************************************************
102 do a SAMR change user password command
103 ****************************************************************************/
104 BOOL do_samr_chgpasswd_user(struct cli_state *cli,
105 char *srv_name, char *user_name,
106 char nt_newpass[516], uchar nt_oldhash[16],
107 char lm_newpass[516], uchar lm_oldhash[16])
111 SAMR_Q_CHGPASSWD_USER q_e;
112 SAMR_R_CHGPASSWD_USER r_e;
114 /* create and send a MSRPC command with api SAMR_CHGPASSWD_USER */
116 prs_init(&data , MAX_PDU_FRAG_LEN, 4, MARSHALL);
117 prs_init(&rdata, 0, 4, UNMARSHALL);
119 DEBUG(4,("SAMR Change User Password. server:%s username:%s\n",
120 srv_name, user_name));
122 init_samr_q_chgpasswd_user(&q_e, srv_name, user_name,
123 nt_newpass, nt_oldhash,
124 lm_newpass, lm_oldhash);
126 /* turn parameters into data stream */
127 if(!samr_io_q_chgpasswd_user("", &q_e, &data, 0)) {
129 prs_mem_free(&rdata);
133 /* send the data on \PIPE\ */
134 if (!rpc_api_pipe_req(cli, SAMR_CHGPASSWD_USER, &data, &rdata)) {
136 prs_mem_free(&rdata);
142 if(!samr_io_r_chgpasswd_user("", &r_e, &rdata, 0)) {
143 prs_mem_free(&rdata);
147 if (r_e.status != 0) {
148 /* report error code */
149 DEBUG(0,("SAMR_R_CHGPASSWD_USER: %s\n", get_nt_error_msg(r_e.status)));
150 prs_mem_free(&rdata);
154 prs_mem_free(&rdata);
159 /****************************************************************************
160 do a SAMR unknown 0x38 command
161 ****************************************************************************/
162 BOOL do_samr_unknown_38(struct cli_state *cli, char *srv_name)
167 SAMR_Q_UNKNOWN_38 q_e;
168 SAMR_R_UNKNOWN_38 r_e;
170 /* create and send a MSRPC command with api SAMR_ENUM_DOM_USERS */
172 prs_init(&data , MAX_PDU_FRAG_LEN, 4, MARSHALL);
173 prs_init(&rdata, 0, 4, UNMARSHALL);
175 DEBUG(4,("SAMR Unknown 38 server:%s\n", srv_name));
177 init_samr_q_unknown_38(&q_e, srv_name);
179 /* turn parameters into data stream */
180 if(!samr_io_q_unknown_38("", &q_e, &data, 0)) {
182 prs_mem_free(&rdata);
186 /* send the data on \PIPE\ */
187 if (!rpc_api_pipe_req(cli, SAMR_UNKNOWN_38, &data, &rdata)) {
189 prs_mem_free(&rdata);
195 if(!samr_io_r_unknown_38("", &r_e, &rdata, 0)) {
196 prs_mem_free(&rdata);
200 if (r_e.status != 0) {
201 /* report error code */
202 DEBUG(0,("SAMR_R_UNKNOWN_38: %s\n", get_nt_error_msg(r_e.status)));
203 prs_mem_free(&rdata);
207 prs_mem_free(&rdata);
212 /****************************************************************************
213 do a SAMR unknown 0x8 command
214 ****************************************************************************/
215 BOOL do_samr_query_dom_info(struct cli_state *cli,
216 POLICY_HND *domain_pol, uint16 switch_value)
220 SAMR_Q_QUERY_DOMAIN_INFO q_e;
221 SAMR_R_QUERY_DOMAIN_INFO r_e;
223 if (domain_pol == NULL)
226 /* create and send a MSRPC command with api SAMR_ENUM_DOM_USERS */
228 prs_init(&data , MAX_PDU_FRAG_LEN, 4, MARSHALL);
229 prs_init(&rdata, 0, 4, UNMARSHALL);
231 DEBUG(4,("SAMR Unknown 8 switch:%d\n", switch_value));
233 /* store the parameters */
234 init_samr_q_query_dom_info(&q_e, domain_pol, switch_value);
236 /* turn parameters into data stream */
237 if(!samr_io_q_query_dom_info("", &q_e, &data, 0)) {
239 prs_mem_free(&rdata);
243 /* send the data on \PIPE\ */
244 if (!rpc_api_pipe_req(cli, SAMR_QUERY_DOMAIN_INFO, &data, &rdata)) {
246 prs_mem_free(&rdata);
252 if(!samr_io_r_query_dom_info("", &r_e, &rdata, 0)) {
253 prs_mem_free(&rdata);
257 if (r_e.status != 0) {
258 /* report error code */
259 DEBUG(0,("SAMR_R_QUERY_DOMAIN_INFO: %s\n", get_nt_error_msg(r_e.status)));
260 prs_mem_free(&rdata);
264 prs_mem_free(&rdata);
269 /****************************************************************************
270 do a SAMR enumerate users
271 ****************************************************************************/
272 BOOL do_samr_enum_dom_users(struct cli_state *cli,
273 POLICY_HND *pol, uint16 num_entries, uint16 unk_0,
274 uint16 acb_mask, uint16 unk_1, uint32 size,
275 struct acct_info **sam,
280 SAMR_Q_ENUM_DOM_USERS q_e;
281 SAMR_R_ENUM_DOM_USERS r_e;
285 if (pol == NULL || num_sam_users == NULL)
288 /* create and send a MSRPC command with api SAMR_ENUM_DOM_USERS */
290 prs_init(&data , MAX_PDU_FRAG_LEN, 4, MARSHALL);
291 prs_init(&rdata, 0, 4, UNMARSHALL);
293 DEBUG(4,("SAMR Enum SAM DB max size:%x\n", size));
295 /* store the parameters */
296 init_samr_q_enum_dom_users(&q_e, pol,
298 acb_mask, unk_1, size);
300 /* turn parameters into data stream */
301 if(!samr_io_q_enum_dom_users("", &q_e, &data, 0)) {
303 prs_mem_free(&rdata);
307 /* send the data on \PIPE\ */
308 if (!rpc_api_pipe_req(cli, SAMR_ENUM_DOM_USERS, &data, &rdata)) {
310 prs_mem_free(&rdata);
316 if(!samr_io_r_enum_dom_users("", &r_e, &rdata, 0)) {
317 prs_mem_free(&rdata);
321 if (r_e.status != 0) {
322 /* report error code */
323 DEBUG(0,("SAMR_R_ENUM_DOM_USERS: %s\n", get_nt_error_msg(r_e.status)));
324 prs_mem_free(&rdata);
328 *num_sam_users = r_e.num_entries2;
329 if (*num_sam_users > MAX_SAM_ENTRIES) {
330 *num_sam_users = MAX_SAM_ENTRIES;
331 DEBUG(2,("do_samr_enum_dom_users: sam user entries limited to %d\n",
335 *sam = (struct acct_info*) malloc(sizeof(struct acct_info) * (*num_sam_users));
340 for (i = 0; i < *num_sam_users; i++) {
341 (*sam)[i].smb_userid = r_e.sam[i].rid;
342 if (r_e.sam[i].hdr_name.buffer) {
343 char *acct_name = dos_unistrn2(r_e.uni_acct_name[name_idx].buffer,
344 r_e.uni_acct_name[name_idx].uni_str_len);
345 fstrcpy((*sam)[i].acct_name, acct_name);
348 memset((char *)(*sam)[i].acct_name, '\0', sizeof((*sam)[i].acct_name));
351 DEBUG(5,("do_samr_enum_dom_users: idx: %4d rid: %8x acct: %s\n",
352 i, (*sam)[i].smb_userid, (*sam)[i].acct_name));
355 prs_mem_free(&rdata );
360 /****************************************************************************
362 ****************************************************************************/
363 BOOL do_samr_connect(struct cli_state *cli,
364 char *srv_name, uint32 unknown_0,
365 POLICY_HND *connect_pol)
372 if (srv_name == NULL || connect_pol == NULL)
375 /* create and send a MSRPC command with api SAMR_CONNECT */
377 prs_init(&data , MAX_PDU_FRAG_LEN, 4, MARSHALL);
378 prs_init(&rdata, 0, 4, UNMARSHALL);
380 DEBUG(4,("SAMR Open Policy server:%s undoc value:%x\n",
381 srv_name, unknown_0));
383 /* store the parameters */
384 init_samr_q_connect(&q_o, srv_name, unknown_0);
386 /* turn parameters into data stream */
387 if(!samr_io_q_connect("", &q_o, &data, 0)) {
389 prs_mem_free(&rdata);
393 /* send the data on \PIPE\ */
394 if (!rpc_api_pipe_req(cli, SAMR_CONNECT, &data, &rdata)) {
396 prs_mem_free(&rdata);
402 if(!samr_io_r_connect("", &r_o, &rdata, 0)) {
403 prs_mem_free(&rdata);
407 if (r_o.status != 0) {
408 /* report error code */
409 DEBUG(0,("SAMR_R_CONNECT: %s\n", get_nt_error_msg(r_o.status)));
410 prs_mem_free(&rdata);
414 memcpy(connect_pol, &r_o.connect_pol, sizeof(r_o.connect_pol));
416 prs_mem_free(&rdata);
421 /****************************************************************************
423 ****************************************************************************/
424 BOOL do_samr_open_user(struct cli_state *cli,
425 POLICY_HND *pol, uint32 unk_0, uint32 rid,
426 POLICY_HND *user_pol)
430 SAMR_Q_OPEN_USER q_o;
431 SAMR_R_OPEN_USER r_o;
433 if (pol == NULL || user_pol == NULL)
436 /* create and send a MSRPC command with api SAMR_OPEN_USER */
438 prs_init(&data , MAX_PDU_FRAG_LEN, 4, MARSHALL);
439 prs_init(&rdata, 0, 4, UNMARSHALL);
441 DEBUG(4,("SAMR Open User. unk_0: %08x RID:%x\n",
444 /* store the parameters */
445 init_samr_q_open_user(&q_o, pol, unk_0, rid);
447 /* turn parameters into data stream */
448 if(!samr_io_q_open_user("", &q_o, &data, 0)) {
450 prs_mem_free(&rdata);
454 /* send the data on \PIPE\ */
455 if (!rpc_api_pipe_req(cli, SAMR_OPEN_USER, &data, &rdata)) {
457 prs_mem_free(&rdata);
463 if(!samr_io_r_open_user("", &r_o, &rdata, 0)) {
464 prs_mem_free(&rdata);
468 if (r_o.status != 0) {
469 /* report error code */
470 DEBUG(0,("SAMR_R_OPEN_USER: %s\n", get_nt_error_msg(r_o.status)));
471 prs_mem_free(&rdata);
475 memcpy(user_pol, &r_o.user_pol, sizeof(r_o.user_pol));
477 prs_mem_free(&rdata);
482 /****************************************************************************
483 do a SAMR Open Domain
484 ****************************************************************************/
485 BOOL do_samr_open_domain(struct cli_state *cli,
486 POLICY_HND *connect_pol, uint32 rid, DOM_SID *sid,
487 POLICY_HND *domain_pol)
492 SAMR_Q_OPEN_DOMAIN q_o;
493 SAMR_R_OPEN_DOMAIN r_o;
495 if (connect_pol == NULL || sid == NULL || domain_pol == NULL)
498 /* create and send a MSRPC command with api SAMR_OPEN_DOMAIN */
500 prs_init(&data , MAX_PDU_FRAG_LEN, 4, MARSHALL);
501 prs_init(&rdata, 0, 4, UNMARSHALL);
503 sid_to_string(sid_str, sid);
504 DEBUG(4,("SAMR Open Domain. SID:%s RID:%x\n", sid_str, rid));
506 /* store the parameters */
507 init_samr_q_open_domain(&q_o, connect_pol, rid, sid);
509 /* turn parameters into data stream */
510 if(!samr_io_q_open_domain("", &q_o, &data, 0)) {
512 prs_mem_free(&rdata);
516 /* send the data on \PIPE\ */
517 if (!rpc_api_pipe_req(cli, SAMR_OPEN_DOMAIN, &data, &rdata)) {
519 prs_mem_free(&rdata);
525 if(!samr_io_r_open_domain("", &r_o, &rdata, 0)) {
526 prs_mem_free(&rdata);
530 if (r_o.status != 0) {
531 /* report error code */
532 DEBUG(0,("SAMR_R_OPEN_DOMAIN: %s\n", get_nt_error_msg(r_o.status)));
533 prs_mem_free(&rdata);
537 memcpy(domain_pol, &r_o.domain_pol, sizeof(r_o.domain_pol));
539 prs_mem_free(&rdata);
544 /****************************************************************************
545 do a SAMR Query Unknown 12
546 ****************************************************************************/
547 BOOL do_samr_query_unknown_12(struct cli_state *cli,
548 POLICY_HND *pol, uint32 rid, uint32 num_gids, uint32 *gids,
550 fstring als_names [MAX_LOOKUP_SIDS],
551 uint32 num_als_users[MAX_LOOKUP_SIDS])
555 SAMR_Q_UNKNOWN_12 q_o;
556 SAMR_R_UNKNOWN_12 r_o;
558 if (pol == NULL || rid == 0 || num_gids == 0 || gids == NULL ||
559 num_aliases == NULL || als_names == NULL || num_als_users == NULL )
562 /* create and send a MSRPC command with api SAMR_UNKNOWN_12 */
564 prs_init(&data , MAX_PDU_FRAG_LEN, 4, MARSHALL);
565 prs_init(&rdata, 0, 4, UNMARSHALL);
567 DEBUG(4,("SAMR Query Unknown 12.\n"));
569 /* store the parameters */
570 init_samr_q_unknown_12(&q_o, pol, rid, num_gids, gids);
572 /* turn parameters into data stream */
573 if(!samr_io_q_unknown_12("", &q_o, &data, 0)) {
575 prs_mem_free(&rdata);
579 /* send the data on \PIPE\ */
580 if (!rpc_api_pipe_req(cli, SAMR_UNKNOWN_12, &data, &rdata)) {
582 prs_mem_free(&rdata);
588 if(!samr_io_r_unknown_12("", &r_o, &rdata, 0)) {
589 prs_mem_free(&rdata);
593 if (r_o.status != 0) {
594 /* report error code */
595 DEBUG(0,("SAMR_R_UNKNOWN_12: %s\n", get_nt_error_msg(r_o.status)));
596 prs_mem_free(&rdata);
600 if (r_o.ptr_aliases != 0 && r_o.ptr_als_usrs != 0 &&
601 r_o.num_als_usrs1 == r_o.num_aliases1) {
604 *num_aliases = r_o.num_aliases1;
606 for (i = 0; i < r_o.num_aliases1; i++) {
607 fstrcpy(als_names[i], dos_unistrn2(r_o.uni_als_name[i].buffer,
608 r_o.uni_als_name[i].uni_str_len));
610 for (i = 0; i < r_o.num_als_usrs1; i++) {
611 num_als_users[i] = r_o.num_als_usrs[i];
613 } else if (r_o.ptr_aliases == 0 && r_o.ptr_als_usrs == 0) {
616 prs_mem_free(&rdata);
620 prs_mem_free(&rdata);
625 /****************************************************************************
626 do a SAMR Query User Groups
627 ****************************************************************************/
628 BOOL do_samr_query_usergroups(struct cli_state *cli,
629 POLICY_HND *pol, uint32 *num_groups, DOM_GID *gid)
633 SAMR_Q_QUERY_USERGROUPS q_o;
634 SAMR_R_QUERY_USERGROUPS r_o;
636 if (pol == NULL || gid == NULL || num_groups == 0)
639 /* create and send a MSRPC command with api SAMR_QUERY_USERGROUPS */
641 prs_init(&data , MAX_PDU_FRAG_LEN, 4, MARSHALL);
642 prs_init(&rdata, 0, 4, UNMARSHALL);
644 DEBUG(4,("SAMR Query User Groups.\n"));
646 /* store the parameters */
647 init_samr_q_query_usergroups(&q_o, pol);
649 /* turn parameters into data stream */
650 if(!samr_io_q_query_usergroups("", &q_o, &data, 0)) {
652 prs_mem_free(&rdata);
656 /* send the data on \PIPE\ */
657 if (!rpc_api_pipe_req(cli, SAMR_QUERY_USERGROUPS, &data, &rdata)) {
659 prs_mem_free(&rdata);
668 if(!samr_io_r_query_usergroups("", &r_o, &rdata, 0)) {
669 prs_mem_free(&rdata);
673 if (r_o.status != 0) {
674 /* report error code */
675 DEBUG(0,("SAMR_R_QUERY_USERGROUPS: %s\n", get_nt_error_msg(r_o.status)));
676 prs_mem_free(&rdata);
680 *num_groups = r_o.num_entries;
682 prs_mem_free(&rdata);
687 /****************************************************************************
688 do a SAMR Query User Info
689 ****************************************************************************/
690 BOOL do_samr_query_userinfo(struct cli_state *cli,
691 POLICY_HND *pol, uint16 switch_value, void* usr)
695 SAMR_Q_QUERY_USERINFO q_o;
696 SAMR_R_QUERY_USERINFO r_o;
698 if (pol == NULL || usr == NULL || switch_value == 0)
701 /* create and send a MSRPC command with api SAMR_QUERY_USERINFO */
703 prs_init(&data , MAX_PDU_FRAG_LEN, 4, MARSHALL);
704 prs_init(&rdata, 0, 4, UNMARSHALL);
706 DEBUG(4,("SAMR Query User Info. level: %d\n", switch_value));
708 /* store the parameters */
709 init_samr_q_query_userinfo(&q_o, pol, switch_value);
711 /* turn parameters into data stream */
712 if(!samr_io_q_query_userinfo("", &q_o, &data, 0)) {
714 prs_mem_free(&rdata);
718 /* send the data on \PIPE\ */
719 if (!rpc_api_pipe_req(cli, SAMR_QUERY_USERINFO, &data, &rdata)) {
721 prs_mem_free(&rdata);
730 if(!samr_io_r_query_userinfo("", &r_o, &rdata, 0)) {
731 prs_mem_free(&rdata);
735 if (r_o.status != 0) {
736 /* report error code */
737 DEBUG(0,("SAMR_R_QUERY_USERINFO: %s\n", get_nt_error_msg(r_o.status)));
738 prs_mem_free(&rdata);
742 if (r_o.switch_value != switch_value) {
743 DEBUG(0,("SAMR_R_QUERY_USERINFO: received incorrect level %d\n",
745 prs_mem_free(&rdata);
750 prs_mem_free(&rdata);
754 prs_mem_free(&rdata);
759 /****************************************************************************
761 ****************************************************************************/
762 BOOL do_samr_close(struct cli_state *cli, POLICY_HND *hnd)
766 SAMR_Q_CLOSE_HND q_c;
767 SAMR_R_CLOSE_HND r_c;
773 prs_init(&data , MAX_PDU_FRAG_LEN, 4, MARSHALL);
774 prs_init(&rdata, 0, 4, UNMARSHALL);
776 /* create and send a MSRPC command with api SAMR_CLOSE_HND */
778 DEBUG(4,("SAMR Close\n"));
780 /* store the parameters */
781 init_samr_q_close_hnd(&q_c, hnd);
783 /* turn parameters into data stream */
784 if(!samr_io_q_close_hnd("", &q_c, &data, 0)) {
786 prs_mem_free(&rdata);
790 /* send the data on \PIPE\ */
791 if (!rpc_api_pipe_req(cli, SAMR_CLOSE_HND, &data, &rdata)) {
793 prs_mem_free(&rdata);
799 if(!samr_io_r_close_hnd("", &r_c, &rdata, 0)) {
800 prs_mem_free(&rdata);
804 if (r_c.status != 0) {
805 /* report error code */
806 DEBUG(0,("SAMR_CLOSE_HND: %s\n", get_nt_error_msg(r_c.status)));
807 prs_mem_free(&rdata);
811 /* check that the returned policy handle is all zeros */
813 for (i = 0; i < sizeof(r_c.pol.data); i++) {
814 if (r_c.pol.data[i] != 0) {
815 DEBUG(0,("SAMR_CLOSE_HND: non-zero handle returned\n"));
816 prs_mem_free(&rdata);
821 prs_mem_free(&rdata);