自学教程：C++ werror_to_ntstatus函数代码示例

NTSTATUS rpccli_WKSSVC_NETRGETJOINABLEOUS(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx){	struct WKSSVC_NETRGETJOINABLEOUS r;	NTSTATUS status;		/* In parameters */		if (DEBUGLEVEL >= 10)		NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOINABLEOUS, &r);		status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRGETJOINABLEOUS, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRGETJOINABLEOUS, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRGETJOINABLEOUS);		if ( !NT_STATUS_IS_OK(status) ) {		return status;	}		if (DEBUGLEVEL >= 10)		NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOINABLEOUS, &r);		if (NT_STATUS_IS_ERR(status)) {		return status;	}		/* Return variables */		/* Return result */	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_wkssvc_NetrJoinDomain2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name, const char *domain_name, const char *account_name, const char *admin_account, struct wkssvc_PasswordBuffer *encrypted_password, uint32_t join_flags){	struct wkssvc_NetrJoinDomain2 r;	NTSTATUS status;		/* In parameters */	r.in.server_name = server_name;	r.in.domain_name = domain_name;	r.in.account_name = account_name;	r.in.admin_account = admin_account;	r.in.encrypted_password = encrypted_password;	r.in.join_flags = join_flags;		if (DEBUGLEVEL >= 10)		NDR_PRINT_IN_DEBUG(wkssvc_NetrJoinDomain2, &r);		status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRJOINDOMAIN2, &r, (ndr_pull_flags_fn_t)ndr_pull_wkssvc_NetrJoinDomain2, (ndr_push_flags_fn_t)ndr_push_wkssvc_NetrJoinDomain2);		if ( !NT_STATUS_IS_OK(status) ) {		return status;	}		if (DEBUGLEVEL >= 10)		NDR_PRINT_OUT_DEBUG(wkssvc_NetrJoinDomain2, &r);		if (NT_STATUS_IS_ERR(status)) {		return status;	}		/* Return variables */		/* Return result */	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_wkssvc_NetWkstaSetInfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name, uint32_t level, union wkssvc_NetWkstaInfo *info, uint32_t *parm_error){	struct wkssvc_NetWkstaSetInfo r;	NTSTATUS status;		/* In parameters */	r.in.server_name = server_name;	r.in.level = level;	r.in.info = info;	r.in.parm_error = parm_error;		if (DEBUGLEVEL >= 10)		NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaSetInfo, &r);		status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETWKSTASETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_wkssvc_NetWkstaSetInfo, (ndr_push_flags_fn_t)ndr_push_wkssvc_NetWkstaSetInfo);		if ( !NT_STATUS_IS_OK(status) ) {		return status;	}		if (DEBUGLEVEL >= 10)		NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaSetInfo, &r);		if (NT_STATUS_IS_ERR(status)) {		return status;	}		/* Return variables */	*parm_error = *r.out.parm_error;		/* Return result */	return werror_to_ntstatus(r.out.result);}

void print_spool_end(files_struct *fsp, enum file_close_type close_type){	NTSTATUS status;	WERROR werr;	struct dcerpc_binding_handle *b = NULL;	b = fsp->conn->spoolss_pipe->binding_handle;	switch (close_type) {	case NORMAL_CLOSE:	case SHUTDOWN_CLOSE:		/* this also automatically calls spoolss_EndDocPrinter */		status = dcerpc_spoolss_ClosePrinter(b, fsp->print_file,						&fsp->print_file->handle,						&werr);		if (!NT_STATUS_IS_OK(status) ||		    !NT_STATUS_IS_OK(status = werror_to_ntstatus(werr))) {			DEBUG(3, ("Failed to close printer %s [%s]/n",			      fsp->print_file->svcname, nt_errstr(status)));		}		break;	case ERROR_CLOSE:		print_spool_terminate(fsp->conn, fsp->print_file);		break;	}}

static WERROR cmd_netlogon_dsr_getsitename(struct rpc_pipe_client *cli,					   TALLOC_CTX *mem_ctx, int argc,					   const char **argv){	WERROR werr;	NTSTATUS status;	const char *sitename = NULL;	struct dcerpc_binding_handle *b = cli->binding_handle;	if (argc != 2) {		fprintf(stderr, "Usage: %s computername/n", argv[0]);		return WERR_OK;	}	status = dcerpc_netr_DsRGetSiteName(b, mem_ctx,					    argv[1],					    &sitename,					    &werr);	if (!NT_STATUS_IS_OK(status)) {		return ntstatus_to_werror(status);	}	if (!W_ERROR_IS_OK(werr)) {		printf("rpccli_netlogon_dsr_gesitename returned %s/n",		       nt_errstr(werror_to_ntstatus(werr)));		return werr;	}	printf("Computer %s is on Site: %s/n", argv[1], sitename);	return WERR_OK;}

static NTSTATUS libnet_dssync_lookup_nc(TALLOC_CTX *mem_ctx,					struct dssync_context *ctx){	NTSTATUS status;	WERROR werr;	int32_t level = 1;	union drsuapi_DsNameRequest req;	int32_t level_out;	struct drsuapi_DsNameString names[1];	union drsuapi_DsNameCtr ctr;	names[0].str = talloc_asprintf(mem_ctx, "%s//", ctx->domain_name);	NT_STATUS_HAVE_NO_MEMORY(names[0].str);	req.req1.codepage	= 1252; /* german */	req.req1.language	= 0x00000407; /* german */	req.req1.count		= 1;	req.req1.names		= names;	req.req1.format_flags	= DRSUAPI_DS_NAME_FLAG_NO_FLAGS;	req.req1.format_offered	= DRSUAPI_DS_NAME_FORMAT_UNKNOWN;	req.req1.format_desired	= DRSUAPI_DS_NAME_FORMAT_FQDN_1779;	status = rpccli_drsuapi_DsCrackNames(ctx->cli, mem_ctx,					     &ctx->bind_handle,					     level,					     &req,					     &level_out,					     &ctr,					     &werr);	if (!NT_STATUS_IS_OK(status)) {		ctx->error_message = talloc_asprintf(ctx,			"Failed to lookup DN for domain name: %s",			get_friendly_werror_msg(werr));		return status;	}	if (!W_ERROR_IS_OK(werr)) {		return werror_to_ntstatus(werr);	}	if (ctr.ctr1->count != 1) {		return NT_STATUS_UNSUCCESSFUL;	}	if (ctr.ctr1->array[0].status != DRSUAPI_DS_NAME_STATUS_OK) {		return NT_STATUS_UNSUCCESSFUL;	}	ctx->nc_dn = talloc_strdup(mem_ctx, ctr.ctr1->array[0].result_name);	NT_STATUS_HAVE_NO_MEMORY(ctx->nc_dn);	if (!ctx->dns_domain_name) {		ctx->dns_domain_name = talloc_strdup_upper(mem_ctx,			ctr.ctr1->array[0].dns_domain_name);		NT_STATUS_HAVE_NO_MEMORY(ctx->dns_domain_name);	}	return NT_STATUS_OK;}

NTSTATUS rpccli_winreg_CreateKey(struct rpc_pipe_client *cli,				 TALLOC_CTX *mem_ctx,				 struct policy_handle *handle /* [in] [ref] */,				 struct winreg_String name /* [in]  */,				 struct winreg_String keyclass /* [in]  */,				 uint32_t options /* [in]  */,				 uint32_t access_mask /* [in]  */,				 struct winreg_SecBuf *secdesc /* [in] [unique] */,				 struct policy_handle *new_handle /* [out] [ref] */,				 enum winreg_CreateAction *action_taken /* [in,out] [unique] */,				 WERROR *werror){	struct winreg_CreateKey r;	NTSTATUS status;	/* In parameters */	r.in.handle = handle;	r.in.name = name;	r.in.keyclass = keyclass;	r.in.options = options;	r.in.access_mask = access_mask;	r.in.secdesc = secdesc;	r.in.action_taken = action_taken;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(winreg_CreateKey, &r);	}	status = cli_do_rpc_ndr(cli,				mem_ctx,				&ndr_table_winreg,				NDR_WINREG_CREATEKEY,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(winreg_CreateKey, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	*new_handle = *r.out.new_handle;	if (action_taken && r.out.action_taken) {		*action_taken = *r.out.action_taken;	}	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_svcctl_EnumServicesStatusW(struct rpc_pipe_client *cli,					   TALLOC_CTX *mem_ctx,					   struct policy_handle *handle /* [in] [ref] */,					   uint32_t type /* [in]  */,					   enum svcctl_ServiceState state /* [in]  */,					   uint8_t *service /* [out] [ref,size_is(offered)] */,					   uint32_t offered /* [in] [range(0,0x40000)] */,					   uint32_t *needed /* [out] [ref,range(0,0x40000)] */,					   uint32_t *services_returned /* [out] [ref,range(0,0x40000)] */,					   uint32_t *resume_handle /* [in,out] [unique] */,					   WERROR *werror){	struct svcctl_EnumServicesStatusW r;	NTSTATUS status;	/* In parameters */	r.in.handle = handle;	r.in.type = type;	r.in.state = state;	r.in.offered = offered;	r.in.resume_handle = resume_handle;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(svcctl_EnumServicesStatusW, &r);	}	status = cli->dispatch(cli,				mem_ctx,				&ndr_table_svcctl,				NDR_SVCCTL_ENUMSERVICESSTATUSW,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusW, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	memcpy(service, r.out.service, r.in.offered * sizeof(*service));	*needed = *r.out.needed;	*services_returned = *r.out.services_returned;	if (resume_handle && r.out.resume_handle) {		*resume_handle = *r.out.resume_handle;	}	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_PNP_GetDeviceRegProp(struct rpc_pipe_client *cli,				     TALLOC_CTX *mem_ctx,				     const char *devicepath /* [in] [ref,charset(UTF16)] */,				     uint32_t property /* [in]  */,				     uint32_t *unknown1 /* [in,out] [ref] */,				     uint8_t *buffer /* [out] [ref,length_is(*buffer_size),size_is(*buffer_size)] */,				     uint32_t *buffer_size /* [in,out] [ref] */,				     uint32_t *needed /* [in,out] [ref] */,				     uint32_t unknown3 /* [in]  */,				     WERROR *werror){	struct PNP_GetDeviceRegProp r;	NTSTATUS status;	/* In parameters */	r.in.devicepath = devicepath;	r.in.property = property;	r.in.unknown1 = unknown1;	r.in.buffer_size = buffer_size;	r.in.needed = needed;	r.in.unknown3 = unknown3;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(PNP_GetDeviceRegProp, &r);	}	status = cli_do_rpc_ndr(cli,				mem_ctx,				&ndr_table_ntsvcs,				NDR_PNP_GETDEVICEREGPROP,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(PNP_GetDeviceRegProp, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	*unknown1 = *r.out.unknown1;	memcpy(buffer, r.out.buffer, *r.in.buffer_size * sizeof(*buffer));	*buffer_size = *r.out.buffer_size;	*needed = *r.out.needed;	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

static NTSTATUS init_registry_key_action(struct db_context *db,					 void *private_data){	struct init_registry_key_context *init_ctx =		(struct init_registry_key_context *)private_data;	return werror_to_ntstatus(init_registry_key_internal(					db, init_ctx->add_path));}

NTSTATUS rpccli_winreg_EnumKey(struct rpc_pipe_client *cli,			       TALLOC_CTX *mem_ctx,			       struct policy_handle *handle /* [in] [ref] */,			       uint32_t enum_index /* [in]  */,			       struct winreg_StringBuf *name /* [in,out] [ref] */,			       struct winreg_StringBuf *keyclass /* [in,out] [unique] */,			       NTTIME *last_changed_time /* [in,out] [unique] */,			       WERROR *werror){	struct winreg_EnumKey r;	NTSTATUS status;	/* In parameters */	r.in.handle = handle;	r.in.enum_index = enum_index;	r.in.name = name;	r.in.keyclass = keyclass;	r.in.last_changed_time = last_changed_time;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(winreg_EnumKey, &r);	}	status = cli_do_rpc_ndr(cli,				mem_ctx,				&ndr_table_winreg,				NDR_WINREG_ENUMKEY,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(winreg_EnumKey, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	*name = *r.out.name;	if (keyclass && r.out.keyclass) {		*keyclass = *r.out.keyclass;	}	if (last_changed_time && r.out.last_changed_time) {		*last_changed_time = *r.out.last_changed_time;	}	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

void print_spool_terminate(struct connection_struct *conn,			   struct print_file_data *print_file){	NTSTATUS status;	WERROR werr;	struct dcerpc_binding_handle *b = NULL;	rap_jobid_delete(print_file->svcname, print_file->jobid);	status = rpc_pipe_open_interface(conn,					 &ndr_table_spoolss.syntax_id,					 conn->session_info,					 &conn->sconn->client_id,					 conn->sconn->msg_ctx,					 &conn->spoolss_pipe);	if (!NT_STATUS_IS_OK(status)) {		DEBUG(0, ("print_spool_terminate: "			  "Failed to get spoolss pipe [%s]/n",			  nt_errstr(status)));		return;	}	b = conn->spoolss_pipe->binding_handle;	status = dcerpc_spoolss_SetJob(b, print_file,					&print_file->handle,					print_file->jobid,					NULL, SPOOLSS_JOB_CONTROL_DELETE,					&werr);	if (!NT_STATUS_IS_OK(status) ||	    !NT_STATUS_IS_OK(status = werror_to_ntstatus(werr))) {		DEBUG(3, ("Failed to delete job %d [%s]/n",			  print_file->jobid, nt_errstr(status)));		return;	}	status = dcerpc_spoolss_ClosePrinter(b, print_file,					     &print_file->handle,					     &werr);	if (!NT_STATUS_IS_OK(status) ||	    !NT_STATUS_IS_OK(status = werror_to_ntstatus(werr))) {		DEBUG(3, ("Failed to close printer %s [%s]/n",			  print_file->svcname, nt_errstr(status)));		return;	}}

NTSTATUS printing_tdb_migrate_form(TALLOC_CTX *mem_ctx,				   struct rpc_pipe_client *winreg_pipe,				   const char *key_name,				   unsigned char *data,				   size_t length){	struct dcerpc_binding_handle *b = winreg_pipe->binding_handle;	enum ndr_err_code ndr_err;	struct ntprinting_form r;	struct spoolss_AddFormInfo1 f1;	DATA_BLOB blob;	WERROR result;	blob = data_blob_const(data, length);	ZERO_STRUCT(r);	ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,		   (ndr_pull_flags_fn_t)ndr_pull_ntprinting_form);	if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {		DEBUG(2, ("Form pull failed: %s/n",			  ndr_errstr(ndr_err)));		return NT_STATUS_NO_MEMORY;	}	/* Don't migrate builtin forms */	if (r.flag == SPOOLSS_FORM_BUILTIN) {		return NT_STATUS_OK;	}	DEBUG(2, ("Migrating Form: %s/n", key_name));	f1.form_name = key_name;	f1.flags = r.flag;	f1.size.width = r.width;	f1.size.height = r.length;	f1.area.top = r.top;	f1.area.right = r.right;	f1.area.bottom = r.bottom;	f1.area.left = r.left;	result = winreg_printer_addform1(mem_ctx,					 b,					 &f1);	if (W_ERROR_EQUAL(result, WERR_FILE_EXISTS)) {		/* Don't migrate form if it already exists. */		result = WERR_OK;	}	if (!W_ERROR_IS_OK(result)) {		return werror_to_ntstatus(result);	}	return NT_STATUS_OK;}

NTSTATUS rpccli_winreg_QueryMultipleValues(struct rpc_pipe_client *cli,					   TALLOC_CTX *mem_ctx,					   struct policy_handle *key_handle /* [in] [ref] */,					   struct QueryMultipleValue *values /* [in,out] [ref,length_is(num_values),size_is(num_values)] */,					   uint32_t num_values /* [in]  */,					   uint8_t *buffer /* [in,out] [unique,length_is(*buffer_size),size_is(*buffer_size)] */,					   uint32_t *buffer_size /* [in,out] [ref] */,					   WERROR *werror){	struct winreg_QueryMultipleValues r;	NTSTATUS status;	/* In parameters */	r.in.key_handle = key_handle;	r.in.values = values;	r.in.num_values = num_values;	r.in.buffer = buffer;	r.in.buffer_size = buffer_size;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues, &r);	}	status = cli_do_rpc_ndr(cli,				mem_ctx,				&ndr_table_winreg,				NDR_WINREG_QUERYMULTIPLEVALUES,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	memcpy(values, r.out.values, r.in.num_values * sizeof(*values));	if (buffer && r.out.buffer) {		memcpy(buffer, r.out.buffer, *r.in.buffer_size * sizeof(*buffer));	}	*buffer_size = *r.out.buffer_size;	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

static NTSTATUS rpc_service_resume_internal(struct net_context *c,					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 ){	struct policy_handle hSCM;	WERROR result = WERR_GENERAL_FAILURE;	NTSTATUS status;	fstring servicename;	if (argc != 1 ) {		d_printf(_("Usage: net rpc service status <service>/n"));		return NT_STATUS_OK;	}	fstrcpy( servicename, argv[0] );	/* Open the Service Control Manager */	status = rpccli_svcctl_OpenSCManagerW(pipe_hnd, mem_ctx,					      pipe_hnd->srv_name_slash,					      NULL,					      SC_RIGHT_MGR_ENUMERATE_SERVICE,					      &hSCM,					      &result);	if (!NT_STATUS_IS_OK(status) || !W_ERROR_IS_OK(result)) {		d_fprintf(stderr,			  _("Failed to open Service Control Manager.  [%s]/n"),			  win_errstr(result));		return werror_to_ntstatus(result);	}	result = control_service(pipe_hnd, mem_ctx, &hSCM, servicename,		SVCCTL_CONTROL_CONTINUE, SVCCTL_RUNNING );	rpccli_svcctl_CloseServiceHandle(pipe_hnd, mem_ctx, &hSCM, NULL);	return werror_to_ntstatus(result);}

NTSTATUS rpccli_svcctl_EnumDependentServicesA(struct rpc_pipe_client *cli,					      TALLOC_CTX *mem_ctx,					      struct policy_handle *service /* [in] [ref] */,					      enum svcctl_ServiceState state /* [in]  */,					      struct ENUM_SERVICE_STATUSA *service_status /* [out] [unique] */,					      uint32_t offered /* [in]  */,					      uint32_t *needed /* [out] [ref] */,					      uint32_t *services_returned /* [out] [ref] */,					      WERROR *werror){	struct svcctl_EnumDependentServicesA r;	NTSTATUS status;	/* In parameters */	r.in.service = service;	r.in.state = state;	r.in.offered = offered;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(svcctl_EnumDependentServicesA, &r);	}	status = cli->dispatch(cli,				mem_ctx,				&ndr_table_svcctl,				NDR_SVCCTL_ENUMDEPENDENTSERVICESA,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesA, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	if (service_status && r.out.service_status) {		*service_status = *r.out.service_status;	}	*needed = *r.out.needed;	*services_returned = *r.out.services_returned;	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_winreg_NotifyChangeKeyValue(struct rpc_pipe_client *cli,					    TALLOC_CTX *mem_ctx,					    struct policy_handle *handle /* [in] [ref] */,					    uint8_t watch_subtree /* [in]  */,					    uint32_t notify_filter /* [in]  */,					    uint32_t unknown /* [in]  */,					    struct winreg_String string1 /* [in]  */,					    struct winreg_String string2 /* [in]  */,					    uint32_t unknown2 /* [in]  */,					    WERROR *werror){	struct winreg_NotifyChangeKeyValue r;	NTSTATUS status;	/* In parameters */	r.in.handle = handle;	r.in.watch_subtree = watch_subtree;	r.in.notify_filter = notify_filter;	r.in.unknown = unknown;	r.in.string1 = string1;	r.in.string2 = string2;	r.in.unknown2 = unknown2;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(winreg_NotifyChangeKeyValue, &r);	}	status = cli_do_rpc_ndr(cli,				mem_ctx,				&ndr_table_winreg,				NDR_WINREG_NOTIFYCHANGEKEYVALUE,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(winreg_NotifyChangeKeyValue, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_initshutdown_InitEx(struct rpc_pipe_client *cli,				    TALLOC_CTX *mem_ctx,				    uint16_t *hostname /* [in] [unique] */,				    struct initshutdown_String *message /* [in] [unique] */,				    uint32_t timeout /* [in]  */,				    uint8_t force_apps /* [in]  */,				    uint8_t reboot /* [in]  */,				    uint32_t reason /* [in]  */,				    WERROR *werror){	struct initshutdown_InitEx r;	NTSTATUS status;	/* In parameters */	r.in.hostname = hostname;	r.in.message = message;	r.in.timeout = timeout;	r.in.force_apps = force_apps;	r.in.reboot = reboot;	r.in.reason = reason;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(initshutdown_InitEx, &r);	}	status = cli_do_rpc_ndr(cli,				mem_ctx,				PI_INITSHUTDOWN,				&ndr_table_initshutdown,				NDR_INITSHUTDOWN_INITEX,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(initshutdown_InitEx, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_svcctl_GetServiceKeyNameA(struct rpc_pipe_client *cli,					  TALLOC_CTX *mem_ctx,					  struct policy_handle *handle /* [in] [ref] */,					  const char *service_name /* [in] [unique,charset(UTF16)] */,					  const char **key_name /* [out] [ref,charset(UTF16)] */,					  uint32_t *display_name_length /* [in,out] [unique] */,					  WERROR *werror){	struct svcctl_GetServiceKeyNameA r;	NTSTATUS status;	/* In parameters */	r.in.handle = handle;	r.in.service_name = service_name;	r.in.display_name_length = display_name_length;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(svcctl_GetServiceKeyNameA, &r);	}	status = cli->dispatch(cli,				mem_ctx,				&ndr_table_svcctl,				NDR_SVCCTL_GETSERVICEKEYNAMEA,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameA, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	*key_name = *r.out.key_name;	if (display_name_length && r.out.display_name_length) {		*display_name_length = *r.out.display_name_length;	}	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_svcctl_QueryServiceObjectSecurity(struct rpc_pipe_client *cli,						  TALLOC_CTX *mem_ctx,						  struct policy_handle *handle /* [in] [ref] */,						  uint32_t security_flags /* [in]  */,						  uint8_t *buffer /* [out] [ref,size_is(offered)] */,						  uint32_t offered /* [in] [range(0,0x40000)] */,						  uint32_t *needed /* [out] [ref,range(0,0x40000)] */,						  WERROR *werror){	struct svcctl_QueryServiceObjectSecurity r;	NTSTATUS status;	/* In parameters */	r.in.handle = handle;	r.in.security_flags = security_flags;	r.in.offered = offered;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(svcctl_QueryServiceObjectSecurity, &r);	}	status = cli->dispatch(cli,				mem_ctx,				&ndr_table_svcctl,				NDR_SVCCTL_QUERYSERVICEOBJECTSECURITY,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceObjectSecurity, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	memcpy(buffer, r.out.buffer, r.in.offered * sizeof(*buffer));	*needed = *r.out.needed;	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_winreg_OpenKey(struct rpc_pipe_client *cli,			       TALLOC_CTX *mem_ctx,			       struct policy_handle *parent_handle /* [in] [ref] */,			       struct winreg_String keyname /* [in]  */,			       uint32_t unknown /* [in]  */,			       uint32_t access_mask /* [in]  */,			       struct policy_handle *handle /* [out] [ref] */,			       WERROR *werror){	struct winreg_OpenKey r;	NTSTATUS status;	/* In parameters */	r.in.parent_handle = parent_handle;	r.in.keyname = keyname;	r.in.unknown = unknown;	r.in.access_mask = access_mask;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(winreg_OpenKey, &r);	}	status = cli_do_rpc_ndr(cli,				mem_ctx,				&ndr_table_winreg,				NDR_WINREG_OPENKEY,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(winreg_OpenKey, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	*handle = *r.out.handle;	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_svcctl_QueryServiceStatusEx(struct rpc_pipe_client *cli,					    TALLOC_CTX *mem_ctx,					    struct policy_handle *handle /* [in] [ref] */,					    enum svcctl_StatusLevel info_level /* [in]  */,					    uint8_t *buffer /* [out] [ref,size_is(offered)] */,					    uint32_t offered /* [in] [range(0,8192)] */,					    uint32_t *needed /* [out] [ref,range(0,8192)] */,					    WERROR *werror){	struct svcctl_QueryServiceStatusEx r;	NTSTATUS status;	/* In parameters */	r.in.handle = handle;	r.in.info_level = info_level;	r.in.offered = offered;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(svcctl_QueryServiceStatusEx, &r);	}	status = cli->dispatch(cli,				mem_ctx,				&ndr_table_svcctl,				NDR_SVCCTL_QUERYSERVICESTATUSEX,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatusEx, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	memcpy(buffer, r.out.buffer, r.in.offered * sizeof(*buffer));	*needed = *r.out.needed;	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_winreg_InitiateSystemShutdown(struct rpc_pipe_client *cli,					      TALLOC_CTX *mem_ctx,					      uint16_t *hostname /* [in] [unique] */,					      struct initshutdown_String *message /* [in] [unique] */,					      uint32_t timeout /* [in]  */,					      uint8_t force_apps /* [in]  */,					      uint8_t do_reboot /* [in]  */,					      WERROR *werror){	struct winreg_InitiateSystemShutdown r;	NTSTATUS status;	/* In parameters */	r.in.hostname = hostname;	r.in.message = message;	r.in.timeout = timeout;	r.in.force_apps = force_apps;	r.in.do_reboot = do_reboot;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdown, &r);	}	status = cli_do_rpc_ndr(cli,				mem_ctx,				&ndr_table_winreg,				NDR_WINREG_INITIATESYSTEMSHUTDOWN,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdown, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_winreg_SetValue(struct rpc_pipe_client *cli,				TALLOC_CTX *mem_ctx,				struct policy_handle *handle /* [in] [ref] */,				struct winreg_String name /* [in]  */,				enum winreg_Type type /* [in]  */,				uint8_t *data /* [in] [ref,size_is(size)] */,				uint32_t size /* [in]  */,				WERROR *werror){	struct winreg_SetValue r;	NTSTATUS status;	/* In parameters */	r.in.handle = handle;	r.in.name = name;	r.in.type = type;	r.in.data = data;	r.in.size = size;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(winreg_SetValue, &r);	}	status = cli_do_rpc_ndr(cli,				mem_ctx,				&ndr_table_winreg,				NDR_WINREG_SETVALUE,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(winreg_SetValue, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_PNP_GetHwProfInfo(struct rpc_pipe_client *cli,				  TALLOC_CTX *mem_ctx,				  uint32_t idx /* [in]  */,				  struct PNP_HwProfInfo *info /* [in,out] [ref] */,				  uint32_t size /* [in]  */,				  uint32_t flags /* [in]  */,				  WERROR *werror){	struct PNP_GetHwProfInfo r;	NTSTATUS status;	/* In parameters */	r.in.idx = idx;	r.in.info = info;	r.in.size = size;	r.in.flags = flags;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(PNP_GetHwProfInfo, &r);	}	status = cli_do_rpc_ndr(cli,				mem_ctx,				&ndr_table_ntsvcs,				NDR_PNP_GETHWPROFINFO,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(PNP_GetHwProfInfo, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	*info = *r.out.info;	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_svcctl_OpenServiceW(struct rpc_pipe_client *cli,				    TALLOC_CTX *mem_ctx,				    struct policy_handle *scmanager_handle /* [in] [ref] */,				    const char *ServiceName /* [in] [charset(UTF16)] */,				    uint32_t access_mask /* [in]  */,				    struct policy_handle *handle /* [out] [ref] */,				    WERROR *werror){	struct svcctl_OpenServiceW r;	NTSTATUS status;	/* In parameters */	r.in.scmanager_handle = scmanager_handle;	r.in.ServiceName = ServiceName;	r.in.access_mask = access_mask;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(svcctl_OpenServiceW, &r);	}	status = cli->dispatch(cli,				mem_ctx,				&ndr_table_svcctl,				NDR_SVCCTL_OPENSERVICEW,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceW, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	*handle = *r.out.handle;	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS libnet_AddShare(struct libnet_context *ctx,			 TALLOC_CTX *mem_ctx, struct libnet_AddShare *r){	NTSTATUS status;	struct libnet_RpcConnect c;	struct srvsvc_NetShareAdd s;	union srvsvc_NetShareInfo info;	c.level              = LIBNET_RPC_CONNECT_SERVER;	c.in.name            = r->in.server_name;	c.in.dcerpc_iface    = &ndr_table_srvsvc;	status = libnet_RpcConnect(ctx, mem_ctx, &c);	if (!NT_STATUS_IS_OK(status)) {		r->out.error_string = talloc_asprintf(mem_ctx,						      "Connection to SRVSVC pipe of server %s "						      "failed: %s",						      r->in.server_name, nt_errstr(status));		return status;	}	info.info2		= &r->in.share;	s.in.level 		= 2;	s.in.info		= &info;	s.in.server_unc		= talloc_asprintf(mem_ctx, "////%s", r->in.server_name); 	status = dcerpc_srvsvc_NetShareAdd(c.out.dcerpc_pipe, mem_ctx, &s);		if (!NT_STATUS_IS_OK(status)) {		r->out.error_string = talloc_asprintf(mem_ctx,						      "srvsvc_NetShareAdd '%s' on server '%s' failed"						      ": %s",						      r->in.share.name, r->in.server_name, 						      nt_errstr(status));	} else if (!W_ERROR_IS_OK(s.out.result)) {		r->out.error_string = talloc_asprintf(mem_ctx,						      "srvsvc_NetShareAdd '%s' on server '%s' failed"						      ": %s",						      r->in.share.name, r->in.server_name, 						      win_errstr(s.out.result));		status = werror_to_ntstatus(s.out.result);	}	talloc_free(c.out.dcerpc_pipe);		return status;}

NTSTATUS rpccli_svcctl_QueryServiceConfigA(struct rpc_pipe_client *cli,					   TALLOC_CTX *mem_ctx,					   struct policy_handle *handle /* [in] [ref] */,					   uint8_t *query /* [out]  */,					   uint32_t offered /* [in]  */,					   uint32_t *needed /* [out] [ref] */,					   WERROR *werror){	struct svcctl_QueryServiceConfigA r;	NTSTATUS status;	/* In parameters */	r.in.handle = handle;	r.in.offered = offered;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(svcctl_QueryServiceConfigA, &r);	}	status = cli->dispatch(cli,				mem_ctx,				&ndr_table_svcctl,				NDR_SVCCTL_QUERYSERVICECONFIGA,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigA, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	memcpy(query, r.out.query, r.in.offered * sizeof(*query));	*needed = *r.out.needed;	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_svcctl_SCSetServiceBitsW(struct rpc_pipe_client *cli,					 TALLOC_CTX *mem_ctx,					 struct policy_handle *handle /* [in] [ref] */,					 uint32_t bits /* [in]  */,					 uint32_t bitson /* [in]  */,					 uint32_t immediate /* [in]  */,					 WERROR *werror){	struct svcctl_SCSetServiceBitsW r;	NTSTATUS status;	/* In parameters */	r.in.handle = handle;	r.in.bits = bits;	r.in.bitson = bitson;	r.in.immediate = immediate;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsW, &r);	}	status = cli->dispatch(cli,				mem_ctx,				&ndr_table_svcctl,				NDR_SVCCTL_SCSETSERVICEBITSW,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsW, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}

NTSTATUS rpccli_svcctl_QueryServiceLockStatusW(struct rpc_pipe_client *cli,					       TALLOC_CTX *mem_ctx,					       struct policy_handle *handle /* [in] [ref] */,					       uint32_t offered /* [in]  */,					       struct SERVICE_LOCK_STATUS *lock_status /* [out] [ref] */,					       uint32_t *needed /* [out] [ref] */,					       WERROR *werror){	struct svcctl_QueryServiceLockStatusW r;	NTSTATUS status;	/* In parameters */	r.in.handle = handle;	r.in.offered = offered;	if (DEBUGLEVEL >= 10) {		NDR_PRINT_IN_DEBUG(svcctl_QueryServiceLockStatusW, &r);	}	status = cli->dispatch(cli,				mem_ctx,				&ndr_table_svcctl,				NDR_SVCCTL_QUERYSERVICELOCKSTATUSW,				&r);	if (!NT_STATUS_IS_OK(status)) {		return status;	}	if (DEBUGLEVEL >= 10) {		NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusW, &r);	}	if (NT_STATUS_IS_ERR(status)) {		return status;	}	/* Return variables */	*lock_status = *r.out.lock_status;	*needed = *r.out.needed;	/* Return result */	if (werror) {		*werror = r.out.result;	}	return werror_to_ntstatus(r.out.result);}