/*    Samba Unix/Linux SMB client library    Distributed SMB/CIFS Server Management Utility    Copyright (C) 2001 Andrew Bartlett (abartlet@samba.org)   Copyright (C) 2002 Jim McDonough (jmcd@us.ibm.com)   Copyright (C) 2004 Guenther Deschner (gd@samba.org)   Copyright (C) 2005 Jeremy Allison (jra@samba.org)   This program is free software; you can redistribute it and/or modify   it under the terms of the GNU General Public License as published by   the Free Software Foundation; either version 2 of the License, or   (at your option) any later version.      This program is distributed in the hope that it will be useful,   but WITHOUT ANY WARRANTY; without even the implied warranty of   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   GNU General Public License for more details.      You should have received a copy of the GNU General Public License   along with this program; if not, write to the Free Software   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */ #include "includes.h"#include "utils/net.h"static int net_mode_share;/** * @file net_rpc.c * * @brief RPC based subcommands for the 'net' utility. * * This file should contain much of the functionality that used to * be found in rpcclient, execpt that the commands should change  * less often, and the fucntionality should be sane (the user is not  * expected to know a rid/sid before they conduct an operation etc.) * * @todo Perhaps eventually these should be split out into a number * of files, as this could get quite big. **//** * Many of the RPC functions need the domain sid.  This function gets *  it at the start of every run  * * @param cli A cli_state already connected to the remote machine * * @return The Domain SID of the remote machine. **/static DOM_SID *net_get_remote_domain_sid(struct cli_state *cli, TALLOC_CTX *mem_ctx, char **domain_name){	struct rpc_pipe_client *lsa_pipe;	DOM_SID *domain_sid;	POLICY_HND pol;	NTSTATUS result = NT_STATUS_OK;	uint32 info_class = 5;		lsa_pipe = cli_rpc_pipe_open_noauth(cli, PI_LSARPC, &result);	if (!lsa_pipe) {		fprintf(stderr, "could not initialise lsa pipe\n");		goto error;	}		result = rpccli_lsa_open_policy(lsa_pipe, mem_ctx, False, 				     SEC_RIGHTS_MAXIMUM_ALLOWED,				     &pol);	if (!NT_STATUS_IS_OK(result)) {		goto error;	}	result = rpccli_lsa_query_info_policy(lsa_pipe, mem_ctx, &pol, info_class, 					   domain_name, &domain_sid);	if (!NT_STATUS_IS_OK(result)) { error:		fprintf(stderr, "could not obtain sid for domain %s\n", cli->domain);		if (!NT_STATUS_IS_OK(result)) {			fprintf(stderr, "error: %s\n", nt_errstr(result));		}		exit(1);	}	if (lsa_pipe) {		rpccli_lsa_close(lsa_pipe, mem_ctx, &pol);		cli_rpc_pipe_close(lsa_pipe);	}	return domain_sid;}/** * Run a single RPC command, from start to finish. * * @param pipe_name the pipe to connect to (usually a PIPE_ constant) * @param conn_flag a NET_FLAG_ combination.  Passed to  *                   net_make_ipc_connection. * @param argc  Standard main() style argc * @param argc  Standard main() style argv.  Initial components are already *              stripped * @return A shell status integer (0 for success) */int run_rpc_command(struct cli_state *cli_arg,			const int pipe_idx,			int conn_flags,			rpc_command_fn fn,			int argc,			const char **argv) {	struct cli_state *cli = NULL;	struct rpc_pipe_client *pipe_hnd = NULL;	TALLOC_CTX *mem_ctx;	NTSTATUS nt_status;	DOM_SID *domain_sid;	char *domain_name;	/* make use of cli_state handed over as an argument, if possible */	if (!cli_arg) {		cli = net_make_ipc_connection(conn_flags);	} else {		cli = cli_arg;	}	if (!cli) {		return -1;	}	/* Create mem_ctx */		if (!(mem_ctx = talloc_init("run_rpc_command"))) {		DEBUG(0, ("talloc_init() failed\n"));		cli_shutdown(cli);		return -1;	}		domain_sid = net_get_remote_domain_sid(cli, mem_ctx, &domain_name);	if (!(conn_flags & NET_FLAGS_NO_PIPE)) {		if (lp_client_schannel() && (pipe_idx == PI_NETLOGON)) {			/* Always try and create an schannel netlogon pipe. */			pipe_hnd = cli_rpc_pipe_open_schannel(cli, pipe_idx,							PIPE_AUTH_LEVEL_PRIVACY,							domain_name,							&nt_status);			if (!pipe_hnd) {				DEBUG(0, ("Could not initialise schannel netlogon pipe. Error was %s\n",					nt_errstr(nt_status) ));				cli_shutdown(cli);				return -1;			}		} else {			pipe_hnd = cli_rpc_pipe_open_noauth(cli, pipe_idx, &nt_status);			if (!pipe_hnd) {				DEBUG(0, ("Could not initialise pipe %s. Error was %s\n",					cli_get_pipe_name(pipe_idx),					nt_errstr(nt_status) ));				cli_shutdown(cli);				return -1;			}		}	}		nt_status = fn(domain_sid, domain_name, cli, pipe_hnd, mem_ctx, argc, argv);		if (!NT_STATUS_IS_OK(nt_status)) {		DEBUG(1, ("rpc command function failed! (%s)\n", nt_errstr(nt_status)));	} else {		DEBUG(5, ("rpc command function succedded\n"));	}			if (!(conn_flags & NET_FLAGS_NO_PIPE)) {		if (pipe_hnd) {			cli_rpc_pipe_close(pipe_hnd);		}	}	/* close the connection only if it was opened here */	if (!cli_arg) {		cli_shutdown(cli);	}		talloc_destroy(mem_ctx);	return (!NT_STATUS_IS_OK(nt_status));}/**  * Force a change of the trust acccount password. * * All parameters are provided by the run_rpc_command function, except for * argc, argv which are passes through.  * * @param domain_sid The domain sid aquired from the remote server * @param cli A cli_state connected to the server. * @param mem_ctx Talloc context, destoyed on compleation of the function. * @param argc  Standard main() style argc * @param argc  Standard main() style argv.  Initial components are already *              stripped * * @return Normal NTSTATUS return. **/static NTSTATUS rpc_changetrustpw_internals(const DOM_SID *domain_sid,					const char *domain_name, 					struct cli_state *cli,					struct rpc_pipe_client *pipe_hnd,					TALLOC_CTX *mem_ctx, 					int argc,					const char **argv){		return trust_pw_find_change_and_store_it(pipe_hnd, mem_ctx, opt_target_workgroup);}/**  * Force a change of the trust acccount password. * * @param argc  Standard main() style argc * @param argc  Standard main() style argv.  Initial components are already *              stripped * * @return A shell status integer (0 for success) **/int net_rpc_changetrustpw(int argc, const char **argv) {	return run_rpc_command(NULL, PI_NETLOGON, NET_FLAGS_ANONYMOUS | NET_FLAGS_PDC, 			       rpc_changetrustpw_internals,			       argc, argv);}/**  * Join a domain, the old way. * * This uses 'machinename' as the inital password, and changes it.  * * The password should be created with 'server manager' or equiv first. * * All parameters are provided by the run_rpc_command function, except for * argc, argv which are passes through.  * * @param domain_sid The domain sid aquired from the remote server * @param cli A cli_state connected to the server. * @param mem_ctx Talloc context, destoyed on compleation of the function. * @param argc  Standard main() style argc * @param argc  Standard main() style argv.  Initial components are already *              stripped * * @return Normal NTSTATUS return. **/static NTSTATUS rpc_oldjoin_internals(const DOM_SID *domain_sid,					const char *domain_name, 					struct cli_state *cli, 					struct rpc_pipe_client *pipe_hnd,					TALLOC_CTX *mem_ctx, 					int argc,					const char **argv){		fstring trust_passwd;	unsigned char orig_trust_passwd_hash[16];	NTSTATUS result;	uint32 sec_channel_type;	pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_NETLOGON, &result);	if (!pipe_hnd) {		DEBUG(0,("rpc_oldjoin_internals: netlogon pipe open to machine %s failed. "			"error was %s\n",			cli->desthost,			nt_errstr(result) ));		return result;	}	/* 	   check what type of join - if the user want's to join as	   a BDC, the server must agree that we are a BDC.	*/	if (argc >= 0) {		sec_channel_type = get_sec_channel_type(argv[0]);	} else {		sec_channel_type = get_sec_channel_type(NULL);	}		fstrcpy(trust_passwd, global_myname());	strlower_m(trust_passwd);	/*	 * Machine names can be 15 characters, but the max length on	 * a password is 14.  --jerry	 */	trust_passwd[14] = '\0';	E_md4hash(trust_passwd, orig_trust_passwd_hash);	result = trust_pw_change_and_store_it(pipe_hnd, mem_ctx, opt_target_workgroup,					      orig_trust_passwd_hash,					      sec_channel_type);	if (NT_STATUS_IS_OK(result))		printf("Joined domain %s.\n",opt_target_workgroup);	if (!secrets_store_domain_sid(opt_target_workgroup, domain_sid)) {		DEBUG(0, ("error storing domain sid for %s\n", opt_target_workgroup));		result = NT_STATUS_UNSUCCESSFUL;	}	return result;}/**  * Join a domain, the old way. * * @param argc  Standard main() style argc * @param argc  Standard main() style argv.  Initial components are already *              stripped * * @return A shell status integer (0 for success) **/static int net_rpc_perform_oldjoin(int argc, const char **argv){	return run_rpc_command(NULL, PI_NETLOGON, 			       NET_FLAGS_NO_PIPE | NET_FLAGS_ANONYMOUS | NET_FLAGS_PDC, 			       rpc_oldjoin_internals,			       argc, argv);}/**  * Join a domain, the old way.  This function exists to allow * the message to be displayed when oldjoin was explicitly  * requested, but not when it was implied by "net rpc join" * * @param argc  Standard main() style argc * @param argc  Standard main() style argv.  Initial components are already *              stripped * * @return A shell status integer (0 for success) **/static int net_rpc_oldjoin(int argc, const char **argv) {	int rc = net_rpc_perform_oldjoin(argc, argv);	if (rc) {		d_fprintf(stderr, "Failed to join domain\n");	}	return rc;}/**  * Basic usage function for 'net rpc join' * @param argc  Standard main() style argc * @param argc  Standard main() style argv.  Initial components are already *              stripped **/static int rpc_join_usage(int argc, const char **argv) {		d_printf("net rpc join -U <username>[%%password] <type>[options]\n"\		 "\t to join a domain with admin username & password\n"\		 "\t\t password will be prompted if needed and none is specified\n"\		 "\t <type> can be (default MEMBER)\n"\		 "\t\t BDC - Join as a BDC\n"\		 "\t\t PDC - Join as a PDC\n"\		 "\t\t MEMBER - Join as a MEMBER server\n");	net_common_flags_usage(argc, argv);	return -1;}/**  * 'net rpc join' entrypoint. * @param argc  Standard main() style argc * @param argc  Standard main() style argv.  Initial components are already *              stripped * * Main 'net_rpc_join()' (where the admain username/password is used) is  * in net_rpc_join.c * Try to just change the password, but if that doesn't work, use/prompt * for a username/password. **/int net_rpc_join(int argc, const char **argv) {	if ((net_rpc_perform_oldjoin(argc, argv) == 0))		return 0;		return net_rpc_join_newstyle(argc, argv);}/**  * display info about a rpc domain * * All parameters are provided by the run_rpc_command function, except for * argc, argv which are passed through.  * * @param domain_sid The domain sid acquired from the remote server * @param cli A cli_state connected to the server. * @param mem_ctx Talloc context, destoyed on completion of the function. * @param argc  Standard main() style argc * @param argv  Standard main() style argv.  Initial components are already *              stripped * * @return Normal NTSTATUS return. **/static NTSTATUS rpc_info_internals(const DOM_SID *domain_sid,			const char *domain_name, 			struct cli_state *cli,			struct rpc_pipe_client *pipe_hnd,			TALLOC_CTX *mem_ctx,			int argc,			const char **argv){	POLICY_HND connect_pol, domain_pol;	NTSTATUS result = NT_STATUS_UNSUCCESSFUL;	SAM_UNK_CTR ctr;	fstring sid_str;	sid_to_string(sid_str, domain_sid);	/* Get sam policy handle */		result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS, 				  &connect_pol);	if (!NT_STATUS_IS_OK(result)) {		goto done;	}		/* Get domain policy handle */	result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,				      MAXIMUM_ALLOWED_ACCESS,				      domain_sid, &domain_pol);	if (!NT_STATUS_IS_OK(result)) {		goto done;	}	ZERO_STRUCT(ctr);	result = rpccli_samr_query_dom_info(pipe_hnd, mem_ctx, &domain_pol,					 2, &ctr);	if (NT_STATUS_IS_OK(result)) {		TALLOC_CTX *ctx = talloc_init("rpc_info_internals");		d_printf("Domain Name: %s\n", unistr2_tdup(ctx, &ctr.info.inf2.uni_domain));		d_printf("Domain SID: %s\n", sid_str);		d_printf("Sequence number: %u\n", ctr.info.inf2.seq_num.low);		d_printf("Num users: %u\n", ctr.info.inf2.num_domain_usrs);		d_printf("Num domain groups: %u\n", ctr.info.inf2.num_domain_grps);		d_printf("Num local groups: %u\n", ctr.info.inf2.num_local_grps);		talloc_destroy(ctx);	} done:	return result;}/**  * 'net rpc info' entrypoint. * @param argc  Standard main() style argc * @param argc  Standard main() style argv.  Initial components are already *              stripped **/int net_rpc_info(int argc, const char **argv) {	return run_rpc_command(NULL, PI_SAMR, NET_FLAGS_ANONYMOUS | NET_FLAGS_PDC, 			       rpc_info_internals,			       argc, argv);}/**  * Fetch domain SID into the local secrets.tdb * * All parameters are provided by the run_rpc_command function, except for * argc, argv which are passes through.  * * @param domain_sid The domain sid acquired from the remote server * @param cli A cli_state connected to the server. * @param mem_ctx Talloc context, destoyed on completion of the function. * @param argc  Standard main() style argc * @param argv  Standard main() style argv.  Initial components are already *              stripped * * @return Normal NTSTATUS return. **/static NTSTATUS rpc_getsid_internals(const DOM_SID *domain_sid,			const char *domain_name, 			struct cli_state *cli,			struct rpc_pipe_client *pipe_hnd,			TALLOC_CTX *mem_ctx,			int argc,			const char **argv){	fstring sid_str;	sid_to_string(sid_str, domain_sid);	d_printf("Storing SID %s for Domain %s in secrets.tdb\n",		 sid_str, domain_name);