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)
+ Copyright (C) 2006 Jelmer Vernooij (jelmer@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
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
return result;
}
- rpccli_lsa_close(lsa_pipe, mem_ctx, &pol);
+ rpccli_lsa_Close(lsa_pipe, mem_ctx, &pol);
cli_rpc_pipe_close(lsa_pipe);
return NT_STATUS_OK;
int net_rpc_join(int argc, const char **argv)
{
+ if (lp_server_role() == ROLE_STANDALONE) {
+ d_printf("cannot join as standalone machine\n");
+ return -1;
+ }
+
+ if (strlen(global_myname()) > 15) {
+ d_printf("Our netbios name can be at most 15 chars long, "
+ "\"%s\" is %u chars long\n",
+ global_myname(), (unsigned int)strlen(global_myname()));
+ return -1;
+ }
+
if ((net_rpc_perform_oldjoin(argc, argv) == 0))
return 0;
result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
&connect_pol);
if (!NT_STATUS_IS_OK(result)) {
+ d_fprintf(stderr, "Could not connect to SAM: %s\n", nt_errstr(result));
goto done;
}
MAXIMUM_ALLOWED_ACCESS,
domain_sid, &domain_pol);
if (!NT_STATUS_IS_OK(result)) {
+ d_fprintf(stderr, "Could not open domain: %s\n", nt_errstr(result));
goto done;
}
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("Sequence number: %llu\n", (unsigned long long)ctr.info.inf2.seq_num);
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);
int net_rpc_info(int argc, const char **argv)
{
- return run_rpc_command(NULL, PI_SAMR, NET_FLAGS_ANONYMOUS | NET_FLAGS_PDC,
+ return run_rpc_command(NULL, PI_SAMR, NET_FLAGS_PDC,
rpc_info_internals,
argc, argv);
}
uint32 acb_info;
uint32 unknown, user_rid;
- if (argc != 1) {
+ if (argc < 1) {
d_printf("User must be specified\n");
rpc_user_usage(argc, argv);
return NT_STATUS_OK;
goto done;
}
+ if (argc == 2) {
+
+ uint32 *user_rids, num_rids, *name_types;
+ uint32 flags = 0x000003e8; /* Unknown */
+ SAM_USERINFO_CTR ctr;
+ SAM_USER_INFO_24 p24;
+ uchar pwbuf[516];
+
+ result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol,
+ flags, 1, &acct_name,
+ &num_rids, &user_rids,
+ &name_types);
+
+ if (!NT_STATUS_IS_OK(result)) {
+ goto done;
+ }
+
+ result = rpccli_samr_open_user(pipe_hnd, mem_ctx, &domain_pol,
+ MAXIMUM_ALLOWED_ACCESS,
+ user_rids[0], &user_pol);
+
+ if (!NT_STATUS_IS_OK(result)) {
+ goto done;
+ }
+
+ /* Set password on account */
+
+ ZERO_STRUCT(ctr);
+ ZERO_STRUCT(p24);
+
+ encode_pw_buffer(pwbuf, argv[1], STR_UNICODE);
+
+ init_sam_user_info24(&p24, (char *)pwbuf,24);
+
+ ctr.switch_value = 24;
+ ctr.info.id24 = &p24;
+
+ result = rpccli_samr_set_userinfo(pipe_hnd, mem_ctx, &user_pol, 24,
+ &cli->user_session_key, &ctr);
+
+ if (!NT_STATUS_IS_OK(result)) {
+ d_fprintf(stderr, "Failed to set password for user %s - %s\n",
+ acct_name, nt_errstr(result));
+
+ result = rpccli_samr_delete_dom_user(pipe_hnd, mem_ctx, &user_pol);
+
+ if (!NT_STATUS_IS_OK(result)) {
+ d_fprintf(stderr, "Failed to delete user %s - %s\n",
+ acct_name, nt_errstr(result));
+ return result;
+ }
+ }
+
+ }
done:
if (!NT_STATUS_IS_OK(result)) {
d_fprintf(stderr, "Failed to add user %s - %s\n", acct_name,
goto done;
}
- names = TALLOC_ARRAY(mem_ctx, const char *, num_names);
+ if ((names = TALLOC_ARRAY(mem_ctx, const char *, num_names)) == NULL) {
+ result = NT_STATUS_NO_MEMORY;
+ goto done;
+ }
names[0] = old_name;
result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol,
flags, num_names, names,
/* Look up rids */
if (num_rids) {
- rids = TALLOC_ARRAY(mem_ctx, uint32, num_rids);
+ if ((rids = TALLOC_ARRAY(mem_ctx, uint32, num_rids)) == NULL) {
+ result = NT_STATUS_NO_MEMORY;
+ goto done;
+ }
for (i = 0; i < num_rids; i++)
rids[i] = user_gids[i].g_rid;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
DOM_SID sid;
uint32 rid;
- enum SID_NAME_USE type;
+ enum lsa_SidType type;
if (argc == 0) {
d_fprintf(stderr, "usage: %s <username>\n", ctx->whoami);
#define SETSTR(name, rec, flag) \
do { if (strequal(ctx->thiscmd, name)) { \
- init_unistr2(&usr->uni_##rec, argv[0], STR_TERMINATE); \
+ init_unistr2(&usr->uni_##rec, argv[0], UNI_STR_TERMINATE); \
init_uni_hdr(&usr->hdr_##rec, &usr->uni_##rec); \
usr->fields_present |= ACCT_##flag; } \
} while (0);
};
return cmds;
-};
+}
/****************************************************************************/
TALLOC_CTX *mem_ctx,
const char *name,
DOM_SID *sid,
- enum SID_NAME_USE *type)
+ enum lsa_SidType *type)
{
DOM_SID *sids = NULL;
- uint32 *types = NULL;
+ enum lsa_SidType *types = NULL;
struct rpc_pipe_client *pipe_hnd;
POLICY_HND lsa_pol;
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
}
result = rpccli_lsa_lookup_names(pipe_hnd, mem_ctx, &lsa_pol, 1,
- &name, NULL, &sids, &types);
+ &name, NULL, 1, &sids, &types);
if (NT_STATUS_IS_OK(result)) {
sid_copy(sid, &sids[0]);
*type = types[0];
}
- rpccli_lsa_close(pipe_hnd, mem_ctx, &lsa_pol);
+ rpccli_lsa_Close(pipe_hnd, mem_ctx, &lsa_pol);
done:
if (pipe_hnd) {
POLICY_HND alias_pol;
DOM_SID member_sid;
- enum SID_NAME_USE member_type;
+ enum lsa_SidType member_type;
DOM_SID sid;
const char **argv)
{
DOM_SID group_sid;
- enum SID_NAME_USE group_type;
+ enum lsa_SidType group_type;
if (argc != 2) {
d_printf("Usage: 'net rpc group addmem <group> <member>\n");
POLICY_HND alias_pol;
DOM_SID member_sid;
- enum SID_NAME_USE member_type;
+ enum lsa_SidType member_type;
DOM_SID sid;
const char **argv)
{
DOM_SID group_sid;
- enum SID_NAME_USE group_type;
+ enum lsa_SidType group_type;
if (argc != 2) {
d_printf("Usage: 'net rpc group delmem <group> <member>\n");
DOM_SID *alias_sids;
char **domains;
char **names;
- uint32 *types;
+ enum lsa_SidType *types;
int i;
result = rpccli_samr_open_alias(pipe_hnd, mem_ctx, domain_pol,
TALLOC_CTX *mem_ctx,int argc,
const char **argv)
{
- WERROR result;
- char *sharename=talloc_strdup(mem_ctx, argv[0]);
+ NTSTATUS result;
+ char *sharename;
char *path;
uint32 type = STYPE_DISKTREE; /* only allow disk shares to be added */
uint32 num_users=0, perms=0;
char *password=NULL; /* don't allow a share password */
uint32 level = 2;
+ uint32 parm_error;
+ union srvsvc_NetShareInfo info;
+ struct srvsvc_NetShareInfo2 info2;
+
+ if ((sharename = talloc_strdup(mem_ctx, argv[0])) == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
path = strchr(sharename, '=');
if (!path)
return NT_STATUS_UNSUCCESSFUL;
*path++ = '\0';
- result = rpccli_srvsvc_net_share_add(pipe_hnd, mem_ctx, sharename, type,
- opt_comment, perms, opt_maxusers,
- num_users, path, password,
- level, NULL);
- return werror_to_ntstatus(result);
+ info.info2 = &info2;
+
+ info2.type = type;
+ info2.comment = opt_comment;
+ info2.permissions = perms;
+ info2.max_users = opt_maxusers;
+ info2.current_users = num_users;
+ info2.path = path;
+ info2.password = password;
+ info2.name = sharename;
+
+ result = rpccli_srvsvc_NetShareAdd(pipe_hnd, mem_ctx, NULL, level,
+ info, &parm_error);
+ return result;
}
static int rpc_share_add(int argc, const char **argv)
int argc,
const char **argv)
{
- WERROR result;
-
- result = rpccli_srvsvc_net_share_del(pipe_hnd, mem_ctx, argv[0]);
- return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
+ return rpccli_srvsvc_NetShareDel(pipe_hnd, mem_ctx, NULL, argv[0], 0);
}
/**
/**
* Formatted print of share info
*
- * @param info1 pointer to SRV_SHARE_INFO_1 to format
+ * @param info1 pointer to struct srvsvc_NetShareInfo1 to format
**/
-static void display_share_info_1(SRV_SHARE_INFO_1 *info1)
+static void display_share_info_1(struct srvsvc_NetShareInfo1 *info1)
{
- fstring netname = "", remark = "";
-
- rpcstr_pull_unistr2_fstring(netname, &info1->info_1_str.uni_netname);
- rpcstr_pull_unistr2_fstring(remark, &info1->info_1_str.uni_remark);
-
if (opt_long_list_entries) {
d_printf("%-12s %-8.8s %-50s\n",
- netname, share_type[info1->info_1.type], remark);
+ info1->name, share_type[info1->type & ~(STYPE_TEMPORARY|STYPE_HIDDEN)],
+ info1->comment ? info1->comment : "");
} else {
- d_printf("%s\n", netname);
+ d_printf("%s\n", info1->name);
}
}
-static WERROR get_share_info(struct rpc_pipe_client *pipe_hnd,
+static NTSTATUS get_share_info(struct rpc_pipe_client *pipe_hnd,
TALLOC_CTX *mem_ctx,
uint32 level,
int argc,
const char **argv,
- SRV_SHARE_INFO_CTR *ctr)
+ union srvsvc_NetShareCtr *ctr,
+ uint32 *numentries)
{
- WERROR result;
- SRV_SHARE_INFO info;
+ union srvsvc_NetShareInfo info;
+ NTSTATUS status;
+
+ switch(level) {
+ case 1:
+ if (!(ctr->ctr1 = TALLOC_ZERO_P(
+ mem_ctx, struct srvsvc_NetShareCtr1))) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ break;
+ case 502:
+ if (!(ctr->ctr502 = TALLOC_ZERO_P(
+ mem_ctx, struct srvsvc_NetShareCtr502))) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ break;
+ default:
+ return NT_STATUS_INVALID_LEVEL;
+ break;
+ }
/* no specific share requested, enumerate all */
if (argc == 0) {
+ uint32 hnd = 0;
- ENUM_HND hnd;
- uint32 preferred_len = 0xffffffff;
-
- init_enum_hnd(&hnd, 0);
-
- return rpccli_srvsvc_net_share_enum(pipe_hnd, mem_ctx, level, ctr,
- preferred_len, &hnd);
+ return rpccli_srvsvc_NetShareEnum(pipe_hnd, mem_ctx, NULL,
+ &level, ctr, 0xffffffff,
+ numentries, &hnd);
}
/* request just one share */
- result = rpccli_srvsvc_net_share_get_info(pipe_hnd, mem_ctx, argv[0], level, &info);
-
- if (!W_ERROR_IS_OK(result))
- goto done;
-
- /* construct ctr */
- ZERO_STRUCTP(ctr);
-
- ctr->info_level = ctr->switch_value = level;
- ctr->ptr_share_info = ctr->ptr_entries = 1;
- ctr->num_entries = ctr->num_entries2 = 1;
-
- switch (level) {
- case 1:
- {
- char *s;
- SRV_SHARE_INFO_1 *info1;
-
- ctr->share.info1 = TALLOC_ARRAY(mem_ctx, SRV_SHARE_INFO_1, 1);
- info1 = ctr->share.info1;
-
- memset(ctr->share.info1, 0, sizeof(SRV_SHARE_INFO_1));
-
- /* Copy pointer crap */
-
- memcpy(&info1->info_1, &info.share.info1.info_1, sizeof(SH_INFO_1));
-
- /* Duplicate strings */
-
- s = unistr2_tdup(mem_ctx, &info.share.info1.info_1_str.uni_netname);
- if (s)
- init_unistr2(&info1->info_1_str.uni_netname, s, UNI_STR_TERMINATE);
-
- s = unistr2_tdup(mem_ctx, &info.share.info1.info_1_str.uni_remark);
- if (s)
- init_unistr2(&info1->info_1_str.uni_remark, s, UNI_STR_TERMINATE);
+ status = rpccli_srvsvc_NetShareGetInfo(pipe_hnd, mem_ctx, NULL,
+ argv[0], level, &info);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
}
- case 2:
- {
- char *s;
- SRV_SHARE_INFO_2 *info2;
-
- ctr->share.info2 = TALLOC_ARRAY(mem_ctx, SRV_SHARE_INFO_2, 1);
- info2 = ctr->share.info2;
-
- memset(ctr->share.info2, 0, sizeof(SRV_SHARE_INFO_2));
-
- /* Copy pointer crap */
-
- memcpy(&info2->info_2, &info.share.info2.info_2, sizeof(SH_INFO_2));
-
- /* Duplicate strings */
- s = unistr2_tdup(mem_ctx, &info.share.info2.info_2_str.uni_netname);
- if (s)
- init_unistr2(&info2->info_2_str.uni_netname, s, UNI_STR_TERMINATE);
+ *numentries = 1;
- s = unistr2_tdup(mem_ctx, &info.share.info2.info_2_str.uni_remark);
- if (s)
- init_unistr2(&info2->info_2_str.uni_remark, s, UNI_STR_TERMINATE);
-
- s = unistr2_tdup(mem_ctx, &info.share.info2.info_2_str.uni_path);
- if (s)
- init_unistr2(&info2->info_2_str.uni_path, s, UNI_STR_TERMINATE);
-
- s = unistr2_tdup(mem_ctx, &info.share.info2.info_2_str.uni_passwd);
- if (s)
- init_unistr2(&info2->info_2_str.uni_passwd, s, UNI_STR_TERMINATE);
- }
+ switch(level) {
+ case 1:
+ ctr->ctr1->count = 1;
+ ctr->ctr1->array = info.info1;
+ break;
case 502:
- {
- char *s;
- SRV_SHARE_INFO_502 *info502;
-
- ctr->share.info502 = TALLOC_ARRAY(mem_ctx, SRV_SHARE_INFO_502, 1);
- info502 = ctr->share.info502;
-
- memset(ctr->share.info502, 0, sizeof(SRV_SHARE_INFO_502));
-
- /* Copy pointer crap */
-
- memcpy(&info502->info_502, &info.share.info502.info_502, sizeof(SH_INFO_502));
-
- /* Duplicate strings */
-
- s = unistr2_tdup(mem_ctx, &info.share.info502.info_502_str.uni_netname);
- if (s)
- init_unistr2(&info502->info_502_str.uni_netname, s, UNI_STR_TERMINATE);
-
- s = unistr2_tdup(mem_ctx, &info.share.info502.info_502_str.uni_remark);
- if (s)
- init_unistr2(&info502->info_502_str.uni_remark, s, UNI_STR_TERMINATE);
-
- s = unistr2_tdup(mem_ctx, &info.share.info502.info_502_str.uni_path);
- if (s)
- init_unistr2(&info502->info_502_str.uni_path, s, UNI_STR_TERMINATE);
-
- s = unistr2_tdup(mem_ctx, &info.share.info502.info_502_str.uni_passwd);
- if (s)
- init_unistr2(&info502->info_502_str.uni_passwd, s, UNI_STR_TERMINATE);
-
- info502->info_502_str.sd = dup_sec_desc(mem_ctx, info.share.info502.info_502_str.sd);
-
+ ctr->ctr501->count = 1;
+ ctr->ctr502->array = info.info502;
+ break;
+ default:
+ return NT_STATUS_INTERNAL_ERROR;
+ break;
}
- } /* switch */
-
-done:
- return result;
+ return NT_STATUS_OK;
}
/**
int argc,
const char **argv)
{
- SRV_SHARE_INFO_CTR ctr;
- WERROR result;
+ union srvsvc_NetShareCtr ctr;
+ NTSTATUS result;
uint32 i, level = 1;
+ uint32 numentries;
- result = get_share_info(pipe_hnd, mem_ctx, level, argc, argv, &ctr);
- if (!W_ERROR_IS_OK(result))
+ result = get_share_info(pipe_hnd, mem_ctx, level, argc, argv, &ctr,
+ &numentries);
+ if (!NT_STATUS_IS_OK(result))
goto done;
/* Display results */
"\nShare name Type Description\n"\
"---------- ---- -----------\n");
}
- for (i = 0; i < ctr.num_entries; i++)
- display_share_info_1(&ctr.share.info1[i]);
+ for (i = 0; i < numentries; i++)
+ display_share_info_1(&ctr.ctr1->array[i]);
done:
- return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
+ return NT_STATUS_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
}
/***
return True;
}
-static BOOL check_share_sanity(struct cli_state *cli, fstring netname, uint32 type)
+static BOOL check_share_sanity(struct cli_state *cli, const char *netname, uint32 type)
{
/* only support disk shares */
if (! ( type == STYPE_DISKTREE || type == (STYPE_DISKTREE | STYPE_HIDDEN)) ) {
int argc,
const char **argv)
{
- WERROR result;
+ NTSTATUS result;
NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
- SRV_SHARE_INFO_CTR ctr_src;
- uint32 type = STYPE_DISKTREE; /* only allow disk shares to be added */
- char *password = NULL; /* don't allow a share password */
+ union srvsvc_NetShareCtr ctr_src;
uint32 i;
struct rpc_pipe_client *srvsvc_pipe = NULL;
struct cli_state *cli_dst = NULL;
uint32 level = 502; /* includes secdesc */
+ uint32 numentries;
- result = get_share_info(pipe_hnd, mem_ctx, level, argc, argv, &ctr_src);
- if (!W_ERROR_IS_OK(result))
+ result = get_share_info(pipe_hnd, mem_ctx, level, argc, argv, &ctr_src,
+ &numentries);
+ if (!NT_STATUS_IS_OK(result))
goto done;
/* connect destination PI_SRVSVC */
return nt_status;
- for (i = 0; i < ctr_src.num_entries; i++) {
+ for (i = 0; i < numentries; i++) {
+ uint32 parm_error = 0;
+ union srvsvc_NetShareInfo info;
- fstring netname = "", remark = "", path = "";
/* reset error-code */
nt_status = NT_STATUS_UNSUCCESSFUL;
- rpcstr_pull_unistr2_fstring(
- netname, &ctr_src.share.info502[i].info_502_str.uni_netname);
- rpcstr_pull_unistr2_fstring(
- remark, &ctr_src.share.info502[i].info_502_str.uni_remark);
- rpcstr_pull_unistr2_fstring(
- path, &ctr_src.share.info502[i].info_502_str.uni_path);
-
- if (!check_share_sanity(cli, netname, ctr_src.share.info502[i].info_502.type))
+ if (!check_share_sanity(cli, ctr_src.ctr502->array[i].name,
+ ctr_src.ctr502->array[i].type))
+
continue;
/* finally add the share on the dst server */
printf("migrating: [%s], path: %s, comment: %s, without share-ACLs\n",
- netname, path, remark);
-
- result = rpccli_srvsvc_net_share_add(srvsvc_pipe, mem_ctx, netname, type, remark,
- ctr_src.share.info502[i].info_502.perms,
- ctr_src.share.info502[i].info_502.max_uses,
- ctr_src.share.info502[i].info_502.num_uses,
- path, password, level,
- NULL);
+ ctr_src.ctr502->array[i].name,
+ ctr_src.ctr502->array[i].path,
+ ctr_src.ctr502->array[i].comment);
+
+ info.info502 = &ctr_src.ctr502->array[i];
+
+ result = rpccli_srvsvc_NetShareAdd(srvsvc_pipe, mem_ctx, NULL,
+ 502, info, &parm_error);
- if (W_ERROR_V(result) == W_ERROR_V(WERR_ALREADY_EXISTS)) {
- printf(" [%s] does already exist\n", netname);
+ if (NT_STATUS_EQUAL(result, NT_STATUS_OBJECT_NAME_COLLISION)) {
+ printf(" [%s] does already exist\n", ctr_src.ctr502->array[i].name);
continue;
}
- if (!W_ERROR_IS_OK(result)) {
- printf("cannot add share: %s\n", dos_errstr(result));
+ if (!NT_STATUS_IS_OK(result)) {
+ printf("cannot add share: %s\n", nt_errstr(result));
goto done;
}
**/
BOOL sync_files(struct copy_clistate *cp_clistate, pstring mask)
{
+ struct cli_state *targetcli;
+ pstring targetpath;
DEBUG(3,("calling cli_list with mask: %s\n", mask));
- if (cli_list(cp_clistate->cli_share_src, mask, cp_clistate->attribute, copy_fn, cp_clistate) == -1) {
- d_fprintf(stderr, "listing %s failed with error: %s\n",
+ if ( !cli_resolve_path( "", cp_clistate->cli_share_src, mask, &targetcli, targetpath ) ) {
+ d_fprintf(stderr, "cli_resolve_path %s failed with error: %s\n",
mask, cli_errstr(cp_clistate->cli_share_src));
return False;
}
+ if (cli_list(targetcli, targetpath, cp_clistate->attribute, copy_fn, cp_clistate) == -1) {
+ d_fprintf(stderr, "listing %s failed with error: %s\n",
+ mask, cli_errstr(targetcli));
+ return False;
+ }
+
return True;
}
int argc,
const char **argv)
{
- WERROR result;
+ NTSTATUS result;
NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
- SRV_SHARE_INFO_CTR ctr_src;
+ union srvsvc_NetShareCtr ctr_src;
uint32 i;
uint32 level = 502;
struct copy_clistate cp_clistate;
BOOL got_dst_share = False;
pstring mask = "\\*";
char *dst = NULL;
+ uint32 numentries;
dst = SMB_STRDUP(opt_destination?opt_destination:"127.0.0.1");
- result = get_share_info(pipe_hnd, mem_ctx, level, argc, argv, &ctr_src);
+ result = get_share_info(pipe_hnd, mem_ctx, level, argc, argv, &ctr_src,
+ &numentries);
- if (!W_ERROR_IS_OK(result))
+ if (!NT_STATUS_IS_OK(result))
goto done;
- for (i = 0; i < ctr_src.num_entries; i++) {
-
- fstring netname = "";
-
- rpcstr_pull_unistr2_fstring(
- netname, &ctr_src.share.info502[i].info_502_str.uni_netname);
-
- if (!check_share_sanity(cli, netname, ctr_src.share.info502[i].info_502.type))
+ for (i = 0; i < numentries; i++) {
+ if (!check_share_sanity(cli, ctr_src.ctr502->array[i].name,
+ ctr_src.ctr502->array[i].type))
continue;
/* one might not want to mirror whole discs :) */
- if (strequal(netname, "print$") || netname[1] == '$') {
- d_printf("skipping [%s]: builtin/hidden share\n", netname);
+ if (strequal(ctr_src.ctr502->array[i].name, "print$") || ctr_src.ctr502->array[i].name[1] == '$') {
+ d_printf("skipping [%s]: builtin/hidden share\n", ctr_src.ctr502->array[i].name);
continue;
}
break;
}
printf(" [%s] files and directories %s ACLs, %s DOS Attributes %s\n",
- netname,
+ ctr_src.ctr502->array[i].name,
opt_acls ? "including" : "without",
opt_attrs ? "including" : "without",
opt_timestamps ? "(preserving timestamps)" : "");
/* open share source */
nt_status = connect_to_service(&cp_clistate.cli_share_src,
&cli->dest_ip, cli->desthost,
- netname, "A:");
+ ctr_src.ctr502->array[i].name, "A:");
if (!NT_STATUS_IS_OK(nt_status))
goto done;
if (net_mode_share == NET_MODE_SHARE_MIGRATE) {
/* open share destination */
nt_status = connect_to_service(&cp_clistate.cli_share_dst,
- NULL, dst, netname, "A:");
+ NULL, dst, ctr_src.ctr502->array[i].name, "A:");
if (!NT_STATUS_IS_OK(nt_status))
goto done;
got_dst_share = True;
}
- if (!copy_top_level_perms(&cp_clistate, netname)) {
- d_fprintf(stderr, "Could not handle the top level directory permissions for the share: %s\n", netname);
+ if (!copy_top_level_perms(&cp_clistate, ctr_src.ctr502->array[i].name)) {
+ d_fprintf(stderr, "Could not handle the top level directory permissions for the share: %s\n", ctr_src.ctr502->array[i].name);
nt_status = NT_STATUS_UNSUCCESSFUL;
goto done;
}
if (!sync_files(&cp_clistate, mask)) {
- d_fprintf(stderr, "could not handle files for share: %s\n", netname);
+ d_fprintf(stderr, "could not handle files for share: %s\n",
+ ctr_src.ctr502->array[i].name);
nt_status = NT_STATUS_UNSUCCESSFUL;
goto done;
}
int argc,
const char **argv)
{
- WERROR result;
+ NTSTATUS result;
NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
- SRV_SHARE_INFO_CTR ctr_src;
- SRV_SHARE_INFO info;
+ union srvsvc_NetShareCtr ctr_src;
+ union srvsvc_NetShareInfo info;
uint32 i;
struct rpc_pipe_client *srvsvc_pipe = NULL;
struct cli_state *cli_dst = NULL;
uint32 level = 502; /* includes secdesc */
+ uint32 numentries;
+ uint32 parm_error = 0;
- result = get_share_info(pipe_hnd, mem_ctx, level, argc, argv, &ctr_src);
+ result = get_share_info(pipe_hnd, mem_ctx, level, argc, argv, &ctr_src,
+ &numentries);
- if (!W_ERROR_IS_OK(result))
+ if (!NT_STATUS_IS_OK(result))
goto done;
/* connect destination PI_SRVSVC */
return nt_status;
- for (i = 0; i < ctr_src.num_entries; i++) {
-
- fstring netname = "", remark = "", path = "";
+ for (i = 0; i < numentries; i++) {
/* reset error-code */
nt_status = NT_STATUS_UNSUCCESSFUL;
- rpcstr_pull_unistr2_fstring(
- netname, &ctr_src.share.info502[i].info_502_str.uni_netname);
- rpcstr_pull_unistr2_fstring(
- remark, &ctr_src.share.info502[i].info_502_str.uni_remark);
- rpcstr_pull_unistr2_fstring(
- path, &ctr_src.share.info502[i].info_502_str.uni_path);
-
- if (!check_share_sanity(cli, netname, ctr_src.share.info502[i].info_502.type))
+ if (!check_share_sanity(cli, ctr_src.ctr502->array[i].name, ctr_src.ctr502->array[i].type))
continue;
printf("migrating: [%s], path: %s, comment: %s, including share-ACLs\n",
- netname, path, remark);
+ ctr_src.ctr502->array[i].name,
+ ctr_src.ctr502->array[i].path,
+ ctr_src.ctr502->array[i].comment);
if (opt_verbose)
- display_sec_desc(ctr_src.share.info502[i].info_502_str.sd);
+ display_sec_desc(ctr_src.ctr502->array[i].sd);
/* init info */
ZERO_STRUCT(info);
- info.switch_value = level;
- info.ptr_share_ctr = 1;
-
- /* FIXME: shouldn't we be able to just set the security descriptor ? */
- info.share.info502 = ctr_src.share.info502[i];
-
/* finally modify the share on the dst server */
- result = rpccli_srvsvc_net_share_set_info(srvsvc_pipe, mem_ctx, netname, level, &info);
+ result = rpccli_srvsvc_NetShareSetInfo(
+ srvsvc_pipe, mem_ctx, NULL, argv[0], level, info,
+ &parm_error);
- if (!W_ERROR_IS_OK(result)) {
- printf("cannot set share-acl: %s\n", dos_errstr(result));
+ if (!NT_STATUS_IS_OK(result)) {
+ printf("cannot set share-acl: %s\n", nt_errstr(result));
goto done;
}
for (i=0; i<num_server_aliases; i++) {
char **names;
char **domains;
- uint32 *types;
+ enum lsa_SidType *types;
int j;
struct full_alias *alias = &server_aliases[i];
DEBUG(1, ("\n"));
}
- rpccli_lsa_close(pipe_hnd, mem_ctx, &lsa_pol);
+ rpccli_lsa_Close(pipe_hnd, mem_ctx, &lsa_pol);
return NT_STATUS_OK;
}
{
token->num_sids = 4;
- token->user_sids = SMB_MALLOC_ARRAY(DOM_SID, 4);
+ if (!(token->user_sids = SMB_MALLOC_ARRAY(DOM_SID, 4))) {
+ d_fprintf(stderr, "malloc failed\n");
+ token->num_sids = 0;
+ return;
+ }
token->user_sids[0] = *user_sid;
sid_copy(&token->user_sids[1], &global_sid_World);
}
for (i = 0; i < response.data.num_entries; i++) {
- gid_t gid = ((gid_t *)response.extra_data)[i];
+ gid_t gid = ((gid_t *)response.extra_data.data)[i];
DOM_SID sid;
struct winbindd_request sidrequest;
add_sid_to_token(token, &sid);
}
- SAFE_FREE(response.extra_data);
+ SAFE_FREE(response.extra_data.data);
return True;
}
/* Look through extra data */
- if (!response.extra_data)
+ if (!response.extra_data.data)
return False;
- extra_data = (const char *)response.extra_data;
+ extra_data = (const char *)response.extra_data.data;
*num_tokens = 0;
while(next_token(&extra_data, name, ",", sizeof(fstring))) {
return False;
}
- extra_data = (const char *)response.extra_data;
+ extra_data = (const char *)response.extra_data.data;
i=0;
while(next_token(&extra_data, name, ",", sizeof(fstring))) {
i+=1;
}
- SAFE_FREE(response.extra_data);
+ SAFE_FREE(response.extra_data.data);
*user_tokens = result;
SEC_DESC *root_sd = NULL;
struct cli_state *cli = pipe_hnd->cli;
int i;
- SRV_SHARE_INFO info;
- WERROR result;
+ union srvsvc_NetShareInfo info;
+ NTSTATUS result;
uint16 cnum;
- result = rpccli_srvsvc_net_share_get_info(pipe_hnd, mem_ctx, netname,
+ result = rpccli_srvsvc_NetShareGetInfo(pipe_hnd, mem_ctx, NULL, netname,
502, &info);
- if (!W_ERROR_IS_OK(result)) {
+ if (!NT_STATUS_IS_OK(result)) {
DEBUG(1, ("Coult not query secdesc for share %s\n",
netname));
return;
}
- share_sd = info.share.info502.info_502_str.sd;
+ share_sd = info.info502->sd;
if (share_sd == NULL) {
DEBUG(1, ("Got no secdesc for share %s\n",
netname));
{
int ret;
BOOL r;
- ENUM_HND hnd;
+ uint32 hnd;
uint32 i;
FILE *f;
for (i=0; i<num_tokens; i++)
collect_alias_memberships(&tokens[i].token);
- init_enum_hnd(&hnd, 0);
-
+ hnd = 0;
share_list.num_shares = 0;
share_list.shares = NULL;
struct rpc_pipe_client *pipe_hnd,
int argc, const char **argv)
{
- WERROR result;
+ union srvsvc_NetShareInfo info;
+ struct srvsvc_NetShareInfo2 info2;
+ NTSTATUS result;
+ uint32 parm_error = 0;
if ((argc < 2) || (argc > 3)) {
d_fprintf(stderr, "usage: %s <share> <path> [comment]\n",
return NT_STATUS_INVALID_PARAMETER;
}
- result = rpccli_srvsvc_net_share_add(
- pipe_hnd, mem_ctx, argv[0], STYPE_DISKTREE,
- (argc == 3) ? argv[2] : "",
- 0, 0, 0, argv[1], NULL, 2, NULL);
+ info.info2 = &info2;
+ info2.name = argv[0];
+ info2.type = STYPE_DISKTREE;
+ info2.comment = (argc == 3) ? argv[2] : "";
+
+ result = rpccli_srvsvc_NetShareAdd(
+ pipe_hnd, mem_ctx, NULL, 2, info, &parm_error);
- return werror_to_ntstatus(result);
+ return result;
}
static NTSTATUS rpc_sh_share_delete(TALLOC_CTX *mem_ctx,
struct rpc_pipe_client *pipe_hnd,
int argc, const char **argv)
{
- WERROR result;
+ NTSTATUS result;
if (argc != 1) {
d_fprintf(stderr, "usage: %s <share>\n", ctx->whoami);
return NT_STATUS_INVALID_PARAMETER;
}
- result = rpccli_srvsvc_net_share_del(pipe_hnd, mem_ctx, argv[0]);
- return werror_to_ntstatus(result);
+ result = rpccli_srvsvc_NetShareDel(pipe_hnd, mem_ctx, NULL, argv[0], 0);
+ return result;
}
static NTSTATUS rpc_sh_share_info(TALLOC_CTX *mem_ctx,
struct rpc_pipe_client *pipe_hnd,
int argc, const char **argv)
{
- SRV_SHARE_INFO info;
- SRV_SHARE_INFO_2 *info2 = &info.share.info2;
- WERROR result;
+ union srvsvc_NetShareInfo info;
+ NTSTATUS result;
if (argc != 1) {
d_fprintf(stderr, "usage: %s <share>\n", ctx->whoami);
return NT_STATUS_INVALID_PARAMETER;
}
- result = rpccli_srvsvc_net_share_get_info(
- pipe_hnd, mem_ctx, argv[0], 2, &info);
- if (!W_ERROR_IS_OK(result)) {
+ result = rpccli_srvsvc_NetShareGetInfo(
+ pipe_hnd, mem_ctx, NULL, argv[0], 2, &info);
+ if (!NT_STATUS_IS_OK(result)) {
goto done;
}
- d_printf("Name: %s\n",
- rpcstr_pull_unistr2_talloc(mem_ctx,
- &info2->info_2_str.uni_netname));
- d_printf("Comment: %s\n",
- rpcstr_pull_unistr2_talloc(mem_ctx,
- &info2->info_2_str.uni_remark));
-
- d_printf("Path: %s\n",
- rpcstr_pull_unistr2_talloc(mem_ctx,
- &info2->info_2_str.uni_path));
- d_printf("Password: %s\n",
- rpcstr_pull_unistr2_talloc(mem_ctx,
- &info2->info_2_str.uni_passwd));
+ d_printf("Name: %s\n", info.info2->name);
+ d_printf("Comment: %s\n", info.info2->comment);
+ d_printf("Path: %s\n", info.info2->path);
+ d_printf("Password: %s\n", info.info2->password);
done:
- return werror_to_ntstatus(result);
+ return result;
}
struct rpc_sh_cmd *net_rpc_share_cmds(TALLOC_CTX *mem_ctx,
};
return cmds;
-};
+}
/****************************************************************************/
int argc,
const char **argv)
{
- WERROR result;
- result = rpccli_srvsvc_net_file_close(pipe_hnd, mem_ctx, atoi(argv[0]));
- return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
+ NTSTATUS result;
+ result = rpccli_srvsvc_NetFileClose(pipe_hnd, mem_ctx, NULL, atoi(argv[0]));
+ return NT_STATUS_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
}
/**
* @param str3 strings for FILE_INFO_3
**/
-static void display_file_info_3(FILE_INFO_3 *info3, FILE_INFO_3_STR *str3)
+static void display_file_info_3( struct srvsvc_NetFileInfo3 *info3 )
{
- fstring user = "", path = "";
-
- rpcstr_pull_unistr2_fstring(user, &str3->uni_user_name);
- rpcstr_pull_unistr2_fstring(path, &str3->uni_path_name);
-
d_printf("%-7.1d %-20.20s 0x%-4.2x %-6.1d %s\n",
- info3->id, user, info3->perms, info3->num_locks, path);
+ info3->fid, info3->user, info3->permissions, info3->num_locks, info3->path);
}
/**
int argc,
const char **argv)
{
- SRV_FILE_INFO_CTR ctr;
- WERROR result;
- ENUM_HND hnd;
+ union srvsvc_NetFileCtr ctr;
+ NTSTATUS result;
+ uint32 hnd;
uint32 preferred_len = 0xffffffff, i;
const char *username=NULL;
+ uint32 level = 3;
+ uint32 numentries;
- init_enum_hnd(&hnd, 0);
+ hnd = 0;
/* if argc > 0, must be user command */
if (argc > 0)
username = smb_xstrdup(argv[0]);
- result = rpccli_srvsvc_net_file_enum(pipe_hnd,
- mem_ctx, 3, username, &ctr, preferred_len, &hnd);
+ result = rpccli_srvsvc_NetFileEnum(pipe_hnd, mem_ctx, NULL, NULL,
+ username, &level, &ctr,
+ preferred_len, &numentries, &hnd);
- if (!W_ERROR_IS_OK(result))
+ if (!NT_STATUS_IS_OK(result))
goto done;
/* Display results */
"\nEnumerating open files on remote server:\n\n"\
"\nFileId Opened by Perms Locks Path"\
"\n------ --------- ----- ----- ---- \n");
- for (i = 0; i < ctr.num_entries; i++)
- display_file_info_3(&ctr.file.info3[i].info_3,
- &ctr.file.info3[i].info_3_str);
+ for (i = 0; i < numentries; i++)
+ display_file_info_3(&ctr.ctr3->array[i]);
done:
- return W_ERROR_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
+ return NT_STATUS_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
}
/**
{
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
- result = rpccli_shutdown_abort(pipe_hnd, mem_ctx);
+ result = rpccli_initshutdown_Abort(pipe_hnd, mem_ctx, NULL);
if (NT_STATUS_IS_OK(result)) {
d_printf("\nShutdown successfully aborted\n");
{
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
- result = werror_to_ntstatus(rpccli_reg_abort_shutdown(pipe_hnd, mem_ctx));
+ result = rpccli_winreg_AbortSystemShutdown(pipe_hnd, mem_ctx, NULL);
if (NT_STATUS_IS_OK(result)) {
d_printf("\nShutdown successfully aborted\n");
static int rpc_shutdown_abort(int argc, const char **argv)
{
- int rc = run_rpc_command(NULL, PI_SHUTDOWN, 0,
+ int rc = run_rpc_command(NULL, PI_INITSHUTDOWN, 0,
rpc_shutdown_abort_internals,
argc, argv);
NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
const char *msg = "This machine will be shutdown shortly";
uint32 timeout = 20;
+ struct initshutdown_String msg_string;
+ struct initshutdown_String_sub s;
if (opt_comment) {
msg = opt_comment;
timeout = opt_timeout;
}
+ s.name = msg;
+ msg_string.name = &s;
+
/* create an entry */
- result = rpccli_shutdown_init(pipe_hnd, mem_ctx, msg, timeout, opt_reboot,
- opt_force);
+ result = rpccli_initshutdown_Init(pipe_hnd, mem_ctx, NULL,
+ &msg_string, timeout, opt_force, opt_reboot);
if (NT_STATUS_IS_OK(result)) {
d_printf("\nShutdown of remote machine succeeded\n");
int argc,
const char **argv)
{
- WERROR result;
const char *msg = "This machine will be shutdown shortly";
uint32 timeout = 20;
-#if 0
- poptContext pc;
- int rc;
-
- struct poptOption long_options[] = {
- {"message", 'm', POPT_ARG_STRING, &msg},
- {"timeout", 't', POPT_ARG_INT, &timeout},
- {"reboot", 'r', POPT_ARG_NONE, &reboot},
- {"force", 'f', POPT_ARG_NONE, &force},
- { 0, 0, 0, 0}
- };
-
- pc = poptGetContext(NULL, argc, (const char **) argv, long_options,
- POPT_CONTEXT_KEEP_FIRST);
+ struct initshutdown_String msg_string;
+ struct initshutdown_String_sub s;
+ NTSTATUS result;
- rc = poptGetNextOpt(pc);
-
- if (rc < -1) {
- /* an error occurred during option processing */
- DEBUG(0, ("%s: %s\n",
- poptBadOption(pc, POPT_BADOPTION_NOALIAS),
- poptStrerror(rc)));
- return NT_STATUS_INVALID_PARAMETER;
- }
-#endif
if (opt_comment) {
msg = opt_comment;
}
+ s.name = msg;
+ msg_string.name = &s;
+
if (opt_timeout) {
timeout = opt_timeout;
}
/* create an entry */
- result = rpccli_reg_shutdown(pipe_hnd, mem_ctx, msg, timeout, opt_reboot, opt_force);
+ result = rpccli_winreg_InitiateSystemShutdown(pipe_hnd, mem_ctx, NULL,
+ &msg_string, timeout, opt_force, opt_reboot);
- if (W_ERROR_IS_OK(result)) {
+ if (NT_STATUS_IS_OK(result)) {
d_printf("\nShutdown of remote machine succeeded\n");
} else {
d_fprintf(stderr, "\nShutdown of remote machine failed\n");
- if (W_ERROR_EQUAL(result,WERR_MACHINE_LOCKED))
+ if ( W_ERROR_EQUAL(ntstatus_to_werror(result),WERR_MACHINE_LOCKED) )
d_fprintf(stderr, "\nMachine locked, use -f switch to force\n");
else
- d_fprintf(stderr, "\nresult was: %s\n", dos_errstr(result));
+ d_fprintf(stderr, "\nresult was: %s\n", nt_errstr(result));
}
- return werror_to_ntstatus(result);
+ return result;
}
/**
static int rpc_shutdown(int argc, const char **argv)
{
- int rc = run_rpc_command(NULL, PI_SHUTDOWN, 0,
+ int rc = run_rpc_command(NULL, PI_INITSHUTDOWN, 0,
rpc_init_shutdown_internals,
argc, argv);
strupper_m(acct_name);
- names = TALLOC_ARRAY(mem_ctx, const char *, 1);
+ if ((names = TALLOC_ARRAY(mem_ctx, const char *, 1)) == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
names[0] = acct_name;
if (NT_STATUS_IS_ERR(nt_status)) {
DEBUG(0, ("Couldn't connect to domain %s controller. Error was %s.\n",
domain_name, nt_errstr(nt_status)));
+ return -1;
}
/*
if (!cli_get_pdc_name(cli, domain_name, (char*)pdc_name)) {
DEBUG(0, ("NetServerEnum2 error: Couldn't find primary domain controller\
for domain %s\n", domain_name));
+ cli_shutdown(cli);
+ return -1;
}
if (!(mem_ctx = talloc_init("establishing trust relationship to "
if (!pipe_hnd) {
DEBUG(0, ("Could not initialise lsa pipe. Error was %s\n", nt_errstr(nt_status) ));
cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
}
DEBUG(0, ("Couldn't open policy handle. Error was %s\n",
nt_errstr(nt_status)));
cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
}
DEBUG(0, ("LSA Query Info failed. Returned error was %s\n",
nt_errstr(nt_status)));
cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
}
* Store the password in secrets db
*/
- if (!secrets_store_trusted_domain_password(domain_name,
- opt_password,
- domain_sid)) {
+ if (!pdb_set_trusteddom_pw(domain_name, opt_password, domain_sid)) {
DEBUG(0, ("Storing password for trusted domain failed.\n"));
cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
}
* Close the pipes and clean up
*/
- nt_status = rpccli_lsa_close(pipe_hnd, mem_ctx, &connect_hnd);
+ nt_status = rpccli_lsa_Close(pipe_hnd, mem_ctx, &connect_hnd);
if (NT_STATUS_IS_ERR(nt_status)) {
DEBUG(0, ("Couldn't close LSA pipe. Error was %s\n",
nt_errstr(nt_status)));
cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
}
static int rpc_trustdom_revoke(int argc, const char **argv)
{
char* domain_name;
+ int rc = -1;
if (argc < 1) return -1;
strupper_m(domain_name);
/* delete password of the trust */
- if (!trusted_domain_password_delete(domain_name)) {
+ if (!pdb_del_trusteddom_pw(domain_name)) {
DEBUG(0, ("Failed to revoke relationship to the trusted domain %s\n",
domain_name));
- return -1;
+ goto done;
};
- return 0;
+ rc = 0;
+done:
+ SAFE_FREE(domain_name);
+ return rc;
}
/**
goto done;
}
- if (!secrets_store_trusted_domain_password(trusted_dom_name,
- cleartextpwd,
- &dom_sid)) {
+ if (!pdb_set_trusteddom_pw(trusted_dom_name, cleartextpwd, &dom_sid)) {
DEBUG(0, ("Storing password for trusted domain failed.\n"));
nt_status = NT_STATUS_UNSUCCESSFUL;
goto done;
/* open \PIPE\lsarpc and open policy handle */
if (!(cli = net_make_ipc_connection(NET_FLAGS_PDC))) {
DEBUG(0, ("Couldn't connect to domain controller\n"));
+ talloc_destroy(mem_ctx);
return -1;
};
DEBUG(0, ("Could not initialise lsa pipe. Error was %s\n",
nt_errstr(nt_status) ));
cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
};
DEBUG(0, ("Couldn't open policy handle. Error was %s\n",
nt_errstr(nt_status)));
cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
};
DEBUG(0, ("LSA Query Info failed. Returned error was %s\n",
nt_errstr(nt_status)));
cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
}
DEBUG(0, ("Couldn't enumerate trusted domains. Error was %s\n",
nt_errstr(nt_status)));
cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
};
domain_sids[i], trusted_dom_names[i]);
if (!NT_STATUS_IS_OK(nt_status)) {
cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
}
};
} while (NT_STATUS_EQUAL(nt_status, STATUS_MORE_ENTRIES));
/* close this connection before doing next one */
- nt_status = rpccli_lsa_close(pipe_hnd, mem_ctx, &connect_hnd);
+ nt_status = rpccli_lsa_Close(pipe_hnd, mem_ctx, &connect_hnd);
if (NT_STATUS_IS_ERR(nt_status)) {
DEBUG(0, ("Couldn't properly close lsa policy handle. Error was %s\n",
nt_errstr(nt_status)));
cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
};
/* open \PIPE\lsarpc and open policy handle */
if (!(cli = net_make_ipc_connection(NET_FLAGS_PDC))) {
DEBUG(0, ("Couldn't connect to domain controller\n"));
+ talloc_destroy(mem_ctx);
return -1;
};
if (!pipe_hnd) {
DEBUG(0, ("Could not initialise lsa pipe. Error was %s\n",
nt_errstr(nt_status) ));
+ cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
};
if (NT_STATUS_IS_ERR(nt_status)) {
DEBUG(0, ("Couldn't open policy handle. Error was %s\n",
nt_errstr(nt_status)));
+ cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
};
if (NT_STATUS_IS_ERR(nt_status)) {
DEBUG(0, ("LSA Query Info failed. Returned error was %s\n",
nt_errstr(nt_status)));
+ cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
}
if (NT_STATUS_IS_ERR(nt_status)) {
DEBUG(0, ("Couldn't enumerate trusted domains. Error was %s\n",
nt_errstr(nt_status)));
+ cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
};
} while (NT_STATUS_EQUAL(nt_status, STATUS_MORE_ENTRIES));
/* close this connection before doing next one */
- nt_status = rpccli_lsa_close(pipe_hnd, mem_ctx, &connect_hnd);
+ nt_status = rpccli_lsa_Close(pipe_hnd, mem_ctx, &connect_hnd);
if (NT_STATUS_IS_ERR(nt_status)) {
DEBUG(0, ("Couldn't properly close lsa policy handle. Error was %s\n",
nt_errstr(nt_status)));
+ cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
};
pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_SAMR, &nt_status);
if (!pipe_hnd) {
DEBUG(0, ("Could not initialise samr pipe. Error was %s\n", nt_errstr(nt_status)));
+ cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
};
if (!NT_STATUS_IS_OK(nt_status)) {
DEBUG(0, ("Couldn't open SAMR policy handle. Error was %s\n",
nt_errstr(nt_status)));
+ cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
};
if (!NT_STATUS_IS_OK(nt_status)) {
DEBUG(0, ("Couldn't open domain object. Error was %s\n",
nt_errstr(nt_status)));
+ cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
};
if (NT_STATUS_IS_ERR(nt_status)) {
DEBUG(0, ("Couldn't enumerate accounts. Error was: %s\n",
nt_errstr(nt_status)));
+ cli_shutdown(cli);
+ talloc_destroy(mem_ctx);
return -1;
};
*/
BOOL net_rpc_check(unsigned flags)
{
- struct cli_state cli;
+ struct cli_state *cli;
BOOL ret = False;
struct in_addr server_ip;
char *server_name = NULL;
+ NTSTATUS status;
/* flags (i.e. server type) may depend on command */
- if (!net_find_server(flags, &server_ip, &server_name))
+ if (!net_find_server(NULL, flags, &server_ip, &server_name))
return False;
- ZERO_STRUCT(cli);
- if (cli_initialise(&cli) == False)
+ if ((cli = cli_initialise()) == NULL) {
return False;
+ }
- if (!cli_connect(&cli, server_name, &server_ip))
+ status = cli_connect(cli, server_name, &server_ip);
+ if (!NT_STATUS_IS_OK(status))
goto done;
if (!attempt_netbios_session_request(&cli, global_myname(),
server_name, &server_ip))
goto done;
- if (!cli_negprot(&cli))
+ if (!cli_negprot(cli))
goto done;
- if (cli.protocol < PROTOCOL_NT1)
+ if (cli->protocol < PROTOCOL_NT1)
goto done;
ret = True;
done:
- cli_shutdown(&cli);
+ cli_shutdown(cli);
return ret;
}
d_printf(" net rpc rights\t\tto manage privileges assigned to SIDs\n");
d_printf(" net rpc registry\t\tto manage registry hives\n");
d_printf(" net rpc service\t\tto start, stop and query services\n");
+ d_printf(" net rpc audit\t\t\tto modify global auditing settings\n");
+ d_printf(" net rpc shell\t\t\tto open an interactive shell for remote server/account management\n");
d_printf("\n");
d_printf("'net rpc shutdown' also accepts the following miscellaneous options:\n"); /* misc options */
d_printf("\t-r or --reboot\trequest remote server reboot on shutdown\n");
int net_rpc(int argc, const char **argv)
{
struct functable func[] = {
+ {"audit", net_rpc_audit},
{"info", net_rpc_info},
{"join", net_rpc_join},
{"oldjoin", net_rpc_oldjoin},
git.samba.org / bbaumbach / samba-autobuild / .git / blobdiff