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);
}