2 Unix SMB/CIFS implementation.
3 NT Domain Authentication SMB / MSRPC client
4 Copyright (C) Andrew Tridgell 1994-1997
5 Copyright (C) Luke Kenneth Casson Leighton 1996-1997
6 Copyright (C) Jeremy Allison 1999.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 /****************************************************************************
26 do a SAMR query user groups
27 ****************************************************************************/
28 BOOL get_samr_query_usergroups(struct cli_state *cli,
29 POLICY_HND *pol_open_domain, uint32 user_rid,
30 uint32 *num_groups, DOM_GID *gid)
32 POLICY_HND pol_open_user;
33 if (pol_open_domain == NULL || num_groups == NULL || gid == NULL)
36 /* send open domain (on user sid) */
37 if (!do_samr_open_user(cli,
45 /* send user groups query */
46 if (!do_samr_query_usergroups(cli,
50 DEBUG(5,("do_samr_query_usergroups: error in query user groups\n"));
53 return do_samr_close(cli, &pol_open_user);
57 /* DOES NOT COMPILE WITH THE NEW SAMR PARSE CODE. JRA. */
59 /****************************************************************************
60 do a SAMR query user info
61 ****************************************************************************/
62 BOOL get_samr_query_userinfo(struct cli_state *cli,
63 POLICY_HND *pol_open_domain,
65 uint32 user_rid, SAM_USER_INFO_21 *usr)
67 POLICY_HND pol_open_user;
68 if (pol_open_domain == NULL || usr == NULL)
71 memset((char *)usr, '\0', sizeof(*usr));
73 /* send open domain (on user sid) */
74 if (!do_samr_open_user(cli,
82 /* send user info query */
83 if (!do_samr_query_userinfo(cli,
85 info_level, (void*)usr))
87 DEBUG(5,("do_samr_query_userinfo: error in query user info, level 0x%x\n",
91 return do_samr_close(cli, &pol_open_user);
95 /****************************************************************************
96 do a SAMR change user password command
97 ****************************************************************************/
98 BOOL do_samr_chgpasswd_user(struct cli_state *cli,
99 char *srv_name, char *user_name,
100 char nt_newpass[516], uchar nt_oldhash[16],
101 char lm_newpass[516], uchar lm_oldhash[16])
105 SAMR_Q_CHGPASSWD_USER q_e;
106 SAMR_R_CHGPASSWD_USER r_e;
108 /* create and send a MSRPC command with api SAMR_CHGPASSWD_USER */
110 prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
111 prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
113 DEBUG(4,("SAMR Change User Password. server:%s username:%s\n",
114 srv_name, user_name));
116 init_samr_q_chgpasswd_user(&q_e, srv_name, user_name,
117 nt_newpass, nt_oldhash,
118 lm_newpass, lm_oldhash);
120 /* turn parameters into data stream */
121 if(!samr_io_q_chgpasswd_user("", &q_e, &data, 0)) {
123 prs_mem_free(&rdata);
127 /* send the data on \PIPE\ */
128 if (!rpc_api_pipe_req(cli, SAMR_CHGPASSWD_USER, &data, &rdata)) {
130 prs_mem_free(&rdata);
136 if(!samr_io_r_chgpasswd_user("", &r_e, &rdata, 0)) {
137 prs_mem_free(&rdata);
141 if (r_e.status != 0) {
142 /* report error code */
143 DEBUG(0,("SAMR_R_CHGPASSWD_USER: %s\n", get_nt_error_msg(r_e.status)));
144 prs_mem_free(&rdata);
148 prs_mem_free(&rdata);
155 /* CURRENTLY THIS DOESN'T COMPILE AND IS NOT USED ANYWHERE. JRA. */
157 /****************************************************************************
158 do a SAMR unknown 0x38 command
159 ****************************************************************************/
160 BOOL do_samr_unknown_38(struct cli_state *cli, char *srv_name)
165 SAMR_Q_UNKNOWN_38 q_e;
166 SAMR_R_UNKNOWN_38 r_e;
168 /* create and send a MSRPC command with api SAMR_ENUM_DOM_USERS */
170 prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
171 prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
173 DEBUG(4,("SAMR Unknown 38 server:%s\n", srv_name));
175 init_samr_q_unknown_38(&q_e, srv_name);
177 /* turn parameters into data stream */
178 if(!samr_io_q_unknown_38("", &q_e, &data, 0)) {
180 prs_mem_free(&rdata);
184 /* send the data on \PIPE\ */
185 if (!rpc_api_pipe_req(cli, SAMR_UNKNOWN_38, &data, &rdata)) {
187 prs_mem_free(&rdata);
193 if(!samr_io_r_unknown_38("", &r_e, &rdata, 0)) {
194 prs_mem_free(&rdata);
198 if (r_e.status != 0) {
199 /* report error code */
200 DEBUG(0,("SAMR_R_UNKNOWN_38: %s\n", get_nt_error_msg(r_e.status)));
201 prs_mem_free(&rdata);
205 prs_mem_free(&rdata);
211 /****************************************************************************
212 do a SAMR unknown 0x8 command
213 ****************************************************************************/
214 BOOL do_samr_query_dom_info(struct cli_state *cli,
215 POLICY_HND *domain_pol, uint16 switch_value)
219 SAMR_Q_QUERY_DOMAIN_INFO q_e;
220 SAMR_R_QUERY_DOMAIN_INFO r_e;
222 if (domain_pol == NULL)
225 /* create and send a MSRPC command with api SAMR_ENUM_DOM_USERS */
227 prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
228 prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
230 DEBUG(4,("SAMR Unknown 8 switch:%d\n", switch_value));
232 /* store the parameters */
233 init_samr_q_query_dom_info(&q_e, domain_pol, switch_value);
235 /* turn parameters into data stream */
236 if(!samr_io_q_query_dom_info("", &q_e, &data, 0)) {
238 prs_mem_free(&rdata);
242 /* send the data on \PIPE\ */
243 if (!rpc_api_pipe_req(cli, SAMR_QUERY_DOMAIN_INFO, &data, &rdata)) {
245 prs_mem_free(&rdata);
251 if(!samr_io_r_query_dom_info("", &r_e, &rdata, 0)) {
252 prs_mem_free(&rdata);
256 if (r_e.status != 0) {
257 /* report error code */
258 DEBUG(0,("SAMR_R_QUERY_DOMAIN_INFO: %s\n", get_nt_error_msg(r_e.status)));
259 prs_mem_free(&rdata);
263 prs_mem_free(&rdata);
270 /* CURRENTLY DOESN'T COMPILE WITH THE NEW SAMR PARSE CODE. JRA */
272 /****************************************************************************
273 do a SAMR enumerate users
274 ****************************************************************************/
275 BOOL do_samr_enum_dom_users(struct cli_state *cli,
276 POLICY_HND *pol, uint16 num_entries, uint16 unk_0,
277 uint16 acb_mask, uint16 unk_1, uint32 size,
278 struct acct_info **sam,
283 SAMR_Q_ENUM_DOM_USERS q_e;
284 SAMR_R_ENUM_DOM_USERS r_e;
288 if (pol == NULL || num_sam_users == NULL)
291 /* create and send a MSRPC command with api SAMR_ENUM_DOM_USERS */
293 prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
294 prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
296 DEBUG(4,("SAMR Enum SAM DB max size:%x\n", size));
298 /* store the parameters */
299 init_samr_q_enum_dom_users(&q_e, pol,
301 acb_mask, unk_1, size);
303 /* turn parameters into data stream */
304 if(!samr_io_q_enum_dom_users("", &q_e, &data, 0)) {
306 prs_mem_free(&rdata);
310 /* send the data on \PIPE\ */
311 if (!rpc_api_pipe_req(cli, SAMR_ENUM_DOM_USERS, &data, &rdata)) {
313 prs_mem_free(&rdata);
319 if(!samr_io_r_enum_dom_users("", &r_e, &rdata, 0)) {
320 prs_mem_free(&rdata);
324 if (r_e.status != 0) {
325 /* report error code */
326 DEBUG(0,("SAMR_R_ENUM_DOM_USERS: %s\n", get_nt_error_msg(r_e.status)));
327 prs_mem_free(&rdata);
331 *num_sam_users = r_e.num_entries2;
332 if (*num_sam_users > MAX_SAM_ENTRIES) {
333 *num_sam_users = MAX_SAM_ENTRIES;
334 DEBUG(2,("do_samr_enum_dom_users: sam user entries limited to %d\n",
338 *sam = (struct acct_info*) malloc(sizeof(struct acct_info) * (*num_sam_users));
343 for (i = 0; i < *num_sam_users; i++) {
344 (*sam)[i].smb_userid = r_e.sam[i].rid;
345 if (r_e.sam[i].hdr_name.buffer) {
346 char *acct_name = dos_unistrn2(r_e.uni_acct_name[name_idx].buffer,
347 r_e.uni_acct_name[name_idx].uni_str_len);
348 fstrcpy((*sam)[i].acct_name, acct_name);
351 memset((char *)(*sam)[i].acct_name, '\0', sizeof((*sam)[i].acct_name));
354 DEBUG(5,("do_samr_enum_dom_users: idx: %4d rid: %8x acct: %s\n",
355 i, (*sam)[i].smb_userid, (*sam)[i].acct_name));
358 prs_mem_free(&rdata );
364 /****************************************************************************
366 ****************************************************************************/
367 BOOL do_samr_connect(struct cli_state *cli,
368 char *srv_name, uint32 unknown_0,
369 POLICY_HND *connect_pol)
376 if (srv_name == NULL || connect_pol == NULL)
379 /* create and send a MSRPC command with api SAMR_CONNECT */
381 prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
382 prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
384 DEBUG(4,("SAMR Open Policy server:%s undoc value:%x\n",
385 srv_name, unknown_0));
387 /* store the parameters */
388 init_samr_q_connect(&q_o, srv_name, unknown_0);
390 /* turn parameters into data stream */
391 if(!samr_io_q_connect("", &q_o, &data, 0)) {
393 prs_mem_free(&rdata);
397 /* send the data on \PIPE\ */
398 if (!rpc_api_pipe_req(cli, SAMR_CONNECT, &data, &rdata)) {
400 prs_mem_free(&rdata);
406 if(!samr_io_r_connect("", &r_o, &rdata, 0)) {
407 prs_mem_free(&rdata);
411 if (r_o.status != 0) {
412 /* report error code */
413 DEBUG(0,("SAMR_R_CONNECT: %s\n", get_nt_error_msg(r_o.status)));
414 prs_mem_free(&rdata);
418 memcpy(connect_pol, &r_o.connect_pol, sizeof(r_o.connect_pol));
420 prs_mem_free(&rdata);
425 /****************************************************************************
427 ****************************************************************************/
428 BOOL do_samr_open_user(struct cli_state *cli,
429 POLICY_HND *pol, uint32 unk_0, uint32 rid,
430 POLICY_HND *user_pol)
434 SAMR_Q_OPEN_USER q_o;
435 SAMR_R_OPEN_USER r_o;
437 if (pol == NULL || user_pol == NULL)
440 /* create and send a MSRPC command with api SAMR_OPEN_USER */
442 prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
443 prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
445 DEBUG(4,("SAMR Open User. unk_0: %08x RID:%x\n",
448 /* store the parameters */
449 init_samr_q_open_user(&q_o, pol, unk_0, rid);
451 /* turn parameters into data stream */
452 if(!samr_io_q_open_user("", &q_o, &data, 0)) {
454 prs_mem_free(&rdata);
458 /* send the data on \PIPE\ */
459 if (!rpc_api_pipe_req(cli, SAMR_OPEN_USER, &data, &rdata)) {
461 prs_mem_free(&rdata);
467 if(!samr_io_r_open_user("", &r_o, &rdata, 0)) {
468 prs_mem_free(&rdata);
472 if (r_o.status != 0) {
473 /* report error code */
474 DEBUG(0,("SAMR_R_OPEN_USER: %s\n", get_nt_error_msg(r_o.status)));
475 prs_mem_free(&rdata);
479 memcpy(user_pol, &r_o.user_pol, sizeof(r_o.user_pol));
481 prs_mem_free(&rdata);
486 /****************************************************************************
487 do a SAMR Open Domain
488 ****************************************************************************/
489 BOOL do_samr_open_domain(struct cli_state *cli,
490 POLICY_HND *connect_pol, uint32 rid, DOM_SID *sid,
491 POLICY_HND *domain_pol)
496 SAMR_Q_OPEN_DOMAIN q_o;
497 SAMR_R_OPEN_DOMAIN r_o;
499 if (connect_pol == NULL || sid == NULL || domain_pol == NULL)
502 /* create and send a MSRPC command with api SAMR_OPEN_DOMAIN */
504 prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
505 prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
507 sid_to_string(sid_str, sid);
508 DEBUG(4,("SAMR Open Domain. SID:%s RID:%x\n", sid_str, rid));
510 /* store the parameters */
511 init_samr_q_open_domain(&q_o, connect_pol, rid, sid);
513 /* turn parameters into data stream */
514 if(!samr_io_q_open_domain("", &q_o, &data, 0)) {
516 prs_mem_free(&rdata);
520 /* send the data on \PIPE\ */
521 if (!rpc_api_pipe_req(cli, SAMR_OPEN_DOMAIN, &data, &rdata)) {
523 prs_mem_free(&rdata);
529 if(!samr_io_r_open_domain("", &r_o, &rdata, 0)) {
530 prs_mem_free(&rdata);
534 if (r_o.status != 0) {
535 /* report error code */
536 DEBUG(0,("SAMR_R_OPEN_DOMAIN: %s\n", get_nt_error_msg(r_o.status)));
537 prs_mem_free(&rdata);
541 memcpy(domain_pol, &r_o.domain_pol, sizeof(r_o.domain_pol));
543 prs_mem_free(&rdata);
550 /* CURRENTLY DOES NOT COMPILE AND IS NOT USED ANYWHERE. JRA. */
552 /****************************************************************************
553 do a SAMR Query Unknown 12
554 ****************************************************************************/
555 BOOL do_samr_query_unknown_12(struct cli_state *cli,
556 POLICY_HND *pol, uint32 rid, uint32 num_gids, uint32 *gids,
558 fstring als_names [MAX_LOOKUP_SIDS],
559 uint32 num_als_users[MAX_LOOKUP_SIDS])
563 SAMR_Q_LOOKUP_RIDS q_o;
564 SAMR_R_LOOKUP_RIDS r_o;
566 if (pol == NULL || rid == 0 || num_gids == 0 || gids == NULL ||
567 num_aliases == NULL || als_names == NULL || num_als_users == NULL )
570 /* create and send a MSRPC command with api SAMR_UNKNOWN_12 */
572 prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
573 prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
575 DEBUG(4,("SAMR Query Unknown 12.\n"));
577 /* store the parameters */
578 init_samr_q_lookup_rids(&q_o, pol, rid, num_gids, gids);
580 /* turn parameters into data stream */
581 if(!samr_io_q_lookup_rids("", &q_o, &data, 0)) {
583 prs_mem_free(&rdata);
587 /* send the data on \PIPE\ */
588 if (!rpc_api_pipe_req(cli, SAMR_LOOKUP_RIDS, &data, &rdata)) {
590 prs_mem_free(&rdata);
596 if(!samr_io_r_lookup_rids("", &r_o, &rdata, 0)) {
597 prs_mem_free(&rdata);
601 if (r_o.status != 0) {
602 /* report error code */
603 DEBUG(0,("SAMR_R_UNKNOWN_12: %s\n", get_nt_error_msg(r_o.status)));
604 prs_mem_free(&rdata);
608 if (r_o.ptr_aliases != 0 && r_o.ptr_als_usrs != 0 &&
609 r_o.num_als_usrs1 == r_o.num_aliases1) {
612 *num_aliases = r_o.num_aliases1;
614 for (i = 0; i < r_o.num_aliases1; i++) {
615 fstrcpy(als_names[i], dos_unistrn2(r_o.uni_als_name[i].buffer,
616 r_o.uni_als_name[i].uni_str_len));
618 for (i = 0; i < r_o.num_als_usrs1; i++) {
619 num_als_users[i] = r_o.num_als_usrs[i];
621 } else if (r_o.ptr_aliases == 0 && r_o.ptr_als_usrs == 0) {
624 prs_mem_free(&rdata);
628 prs_mem_free(&rdata);
634 /****************************************************************************
635 do a SAMR Query User Groups
636 ****************************************************************************/
637 BOOL do_samr_query_usergroups(struct cli_state *cli,
638 POLICY_HND *pol, uint32 *num_groups, DOM_GID *gid)
642 SAMR_Q_QUERY_USERGROUPS q_o;
643 SAMR_R_QUERY_USERGROUPS r_o;
645 if (pol == NULL || gid == NULL || num_groups == 0)
648 /* create and send a MSRPC command with api SAMR_QUERY_USERGROUPS */
650 prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
651 prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
653 DEBUG(4,("SAMR Query User Groups.\n"));
655 /* store the parameters */
656 init_samr_q_query_usergroups(&q_o, pol);
658 /* turn parameters into data stream */
659 if(!samr_io_q_query_usergroups("", &q_o, &data, 0)) {
661 prs_mem_free(&rdata);
665 /* send the data on \PIPE\ */
666 if (!rpc_api_pipe_req(cli, SAMR_QUERY_USERGROUPS, &data, &rdata)) {
668 prs_mem_free(&rdata);
677 if(!samr_io_r_query_usergroups("", &r_o, &rdata, 0)) {
678 prs_mem_free(&rdata);
682 if (r_o.status != 0) {
683 /* report error code */
684 DEBUG(0,("SAMR_R_QUERY_USERGROUPS: %s\n", get_nt_error_msg(r_o.status)));
685 prs_mem_free(&rdata);
689 *num_groups = r_o.num_entries;
691 prs_mem_free(&rdata);
698 /* CURRENTLY DOES NOT COMPILE WITH THE NEW SAMR PARSE CODE. JRA */
700 /****************************************************************************
701 do a SAMR Query User Info
702 ****************************************************************************/
703 BOOL do_samr_query_userinfo(struct cli_state *cli,
704 POLICY_HND *pol, uint16 switch_value, void* usr)
708 SAMR_Q_QUERY_USERINFO q_o;
709 SAMR_R_QUERY_USERINFO r_o;
711 if (pol == NULL || usr == NULL || switch_value == 0)
714 /* create and send a MSRPC command with api SAMR_QUERY_USERINFO */
716 prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
717 prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
719 DEBUG(4,("SAMR Query User Info. level: %d\n", switch_value));
721 /* store the parameters */
722 init_samr_q_query_userinfo(&q_o, pol, switch_value);
724 /* turn parameters into data stream */
725 if(!samr_io_q_query_userinfo("", &q_o, &data, 0)) {
727 prs_mem_free(&rdata);
731 /* send the data on \PIPE\ */
732 if (!rpc_api_pipe_req(cli, SAMR_QUERY_USERINFO, &data, &rdata)) {
734 prs_mem_free(&rdata);
743 if(!samr_io_r_query_userinfo("", &r_o, &rdata, 0)) {
744 prs_mem_free(&rdata);
748 if (r_o.status != 0) {
749 /* report error code */
750 DEBUG(0,("SAMR_R_QUERY_USERINFO: %s\n", get_nt_error_msg(r_o.status)));
751 prs_mem_free(&rdata);
755 if (r_o.switch_value != switch_value) {
756 DEBUG(0,("SAMR_R_QUERY_USERINFO: received incorrect level %d\n",
758 prs_mem_free(&rdata);
763 prs_mem_free(&rdata);
767 prs_mem_free(&rdata);
774 /****************************************************************************
776 ****************************************************************************/
777 BOOL do_samr_close(struct cli_state *cli, POLICY_HND *hnd)
781 SAMR_Q_CLOSE_HND q_c;
782 SAMR_R_CLOSE_HND r_c;
787 prs_init(&data, MAX_PDU_FRAG_LEN, cli->mem_ctx, MARSHALL);
788 prs_init(&rdata, 0, cli->mem_ctx, UNMARSHALL);
790 /* create and send a MSRPC command with api SAMR_CLOSE_HND */
792 DEBUG(4,("SAMR Close\n"));
794 /* store the parameters */
795 init_samr_q_close_hnd(&q_c, hnd);
797 /* turn parameters into data stream */
798 if(!samr_io_q_close_hnd("", &q_c, &data, 0)) {
800 prs_mem_free(&rdata);
804 /* send the data on \PIPE\ */
805 if (!rpc_api_pipe_req(cli, SAMR_CLOSE_HND, &data, &rdata)) {
807 prs_mem_free(&rdata);
813 if(!samr_io_r_close_hnd("", &r_c, &rdata, 0)) {
814 prs_mem_free(&rdata);
818 if (r_c.status != 0) {
819 /* report error code */
820 DEBUG(0,("SAMR_CLOSE_HND: %s\n", get_nt_error_msg(r_c.status)));
821 prs_mem_free(&rdata);
825 /* check that the returned policy handle is all zeros */
827 if (IVAL(&r_c.pol.data1,0) || IVAL(&r_c.pol.data2,0) || SVAL(&r_c.pol.data3,0) ||
828 SVAL(&r_c.pol.data4,0) || IVAL(r_c.pol.data5,0) || IVAL(r_c.pol.data5,4) ) {
829 DEBUG(0,("SAMR_CLOSE_HND: non-zero handle returned\n"));
830 prs_mem_free(&rdata);
834 prs_mem_free(&rdata);