diff options
Diffstat (limited to 'source3/rpcclient')
| -rw-r--r-- | source3/rpcclient/cmd_fss.c | 656 | ||||
| -rw-r--r-- | source3/rpcclient/rpcclient.c | 2 |
2 files changed, 658 insertions, 0 deletions
diff --git a/source3/rpcclient/cmd_fss.c b/source3/rpcclient/cmd_fss.c new file mode 100644 index 0000000000..56d9141da5 --- /dev/null +++ b/source3/rpcclient/cmd_fss.c @@ -0,0 +1,656 @@ +/* + * Unix SMB/CIFS implementation. + * + * File Server Remote VSS Protocol (FSRVP) client + * + * Copyright (C) David Disseldorp 2012 + * + * 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 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + */ + +#include "includes.h" +#include "rpcclient.h" +#include "../librpc/gen_ndr/ndr_fsrvp.h" +#include "../librpc/gen_ndr/ndr_fsrvp_c.h" + +struct fss_context_map { + uint32_t ctx_val; + const char *ctx_str; + const char *ctx_desc; +}; +struct fss_context_map ctx_map[] = { + { + .ctx_val = FSRVP_CTX_BACKUP, + .ctx_str = "backup", + .ctx_desc = "auto-release, non-persistent shadow-copy.", + }, + { + .ctx_val = FSRVP_CTX_FILE_SHARE_BACKUP, + .ctx_str = "file_share_backup", + .ctx_desc = "auto-release, non-persistent shadow-copy created " + "without writer involvement.", + }, + { + .ctx_val = FSRVP_CTX_NAS_ROLLBACK, + .ctx_str = "nas_rollback", + .ctx_desc = "non-auto-release, persistent shadow-copy created " + "without writer involvement.", + }, + { + .ctx_val = FSRVP_CTX_APP_ROLLBACK, + .ctx_str = "app_rollback", + .ctx_desc = "non-auto-release, persistent shadow-copy.", + }, + { 0, NULL, NULL }, +}; + +static bool map_fss_ctx_str(const char *ctx_str, + uint32_t *ctx_val) +{ + int i; + + for (i = 0; ctx_map[i].ctx_str != NULL; i++) { + if (!strcmp(ctx_map[i].ctx_str, ctx_str)) { + *ctx_val = ctx_map[i].ctx_val; + return true; + } + } + return false; +} + +static void cmd_fss_is_path_sup_usage(const char *script_name) +{ + printf("usage: %s [share_name]\n", script_name); +} + +static NTSTATUS cmd_fss_is_path_sup(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, int argc, + const char **argv) +{ + NTSTATUS status; + struct fss_IsPathSupported r; + struct dcerpc_binding_handle *b = cli->binding_handle; + + if (argc != 2) { + cmd_fss_is_path_sup_usage(argv[0]); + return NT_STATUS_UNSUCCESSFUL; + } + + ZERO_STRUCT(r); + r.in.ShareName = talloc_asprintf(mem_ctx, "%s\\%s", + cli->srv_name_slash, argv[1]); + if (r.in.ShareName == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = dcerpc_fss_IsPathSupported_r(b, mem_ctx, &r); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("IsPathSupported failed with UNC %s\n", + r.in.ShareName)); + return NT_STATUS_UNSUCCESSFUL; + } else if (r.out.result) { + DEBUG(0, ("failed IsPathSupported response: 0x%x\n", + r.out.result)); + return NT_STATUS_UNSUCCESSFUL; + } + printf("UNC %s %s shadow copy requests\n", r.in.ShareName, + *r.out.SupportedByThisProvider ? "supports" : "does not support"); + + return NT_STATUS_OK; +} + +static void cmd_fss_get_sup_version_usage(const char *script_name) +{ + printf("usage: %s\n", script_name); +} + +static NTSTATUS cmd_fss_get_sup_version(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, int argc, + const char **argv) +{ + NTSTATUS status; + struct fss_GetSupportedVersion r; + struct dcerpc_binding_handle *b = cli->binding_handle; + + if (argc != 1) { + cmd_fss_get_sup_version_usage(argv[0]); + return NT_STATUS_UNSUCCESSFUL; + } + + ZERO_STRUCT(r); + status = dcerpc_fss_GetSupportedVersion_r(b, mem_ctx, &r); + if (!NT_STATUS_IS_OK(status) || (r.out.result != 0)) { + DEBUG(0, ("GetSupportedVersion failed: %s result: 0x%x\n", + nt_errstr(status), r.out.result)); + return NT_STATUS_UNSUCCESSFUL; + } + printf("server %s supports FSRVP versions from %u to %u\n", + cli->desthost, *r.out.MinVersion, *r.out.MaxVersion); + + return NT_STATUS_OK; +} + +static void cmd_fss_create_expose_usage(const char *script_name) +{ + int i; + + printf("usage: %s [fss_context] [ro|rw] [share1] <share2> ...\n" + "[fss_context] values:\n", script_name); + for (i = 0; ctx_map[i].ctx_str != NULL; i++) { + printf("\t%s: %s\n", ctx_map[i].ctx_str, ctx_map[i].ctx_desc); + } +} + +static NTSTATUS cmd_fss_create_expose_parse(TALLOC_CTX *mem_ctx, int argc, + const char **argv, + const char *desthost, + uint32_t *fss_ctx_val, + int *num_maps, + struct fssagent_share_mapping_1 **maps) +{ + int num_non_share_args = 3; + int num_share_args; + int i; + struct fssagent_share_mapping_1 *map_array; + + if (argc < 4) { + return NT_STATUS_INVALID_PARAMETER; + } + + if (!map_fss_ctx_str(argv[1], fss_ctx_val)) { + return NT_STATUS_INVALID_PARAMETER; + } + + if (!strcmp(argv[2], "rw")) { + /* shadow-copy is created as read-write */ + *fss_ctx_val |= ATTR_AUTO_RECOVERY; + } else if (strcmp(argv[2], "ro")) { + return NT_STATUS_INVALID_PARAMETER; + } + + num_share_args = argc - num_non_share_args; + map_array = talloc_array(mem_ctx, struct fssagent_share_mapping_1, + num_share_args); + if (map_array == NULL) { + return NT_STATUS_NO_MEMORY; + } + + for (i = 0; i < num_share_args; i++) { + map_array[i].ShareNameUNC = talloc_asprintf(mem_ctx, "\\\\%s\\%s", + desthost, argv[i + num_non_share_args]); + if (map_array[i].ShareNameUNC == NULL) { + return NT_STATUS_NO_MEMORY; + } + } + *num_maps = num_share_args; + *maps = map_array; + + return NT_STATUS_OK; +} + +static NTSTATUS cmd_fss_create_expose(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, int argc, + const char **argv) +{ + NTSTATUS status; + struct fss_GetSupportedVersion r_version_get; + struct fss_SetContext r_context_set; + struct fss_StartShadowCopySet r_scset_start; + struct fss_PrepareShadowCopySet r_scset_prep; + struct fss_CommitShadowCopySet r_scset_commit; + struct fss_ExposeShadowCopySet r_scset_expose; + struct dcerpc_binding_handle *b = cli->binding_handle; + time_t start_time; + TALLOC_CTX *tmp_ctx; + uint32_t fss_ctx_val; + int num_maps; + struct fssagent_share_mapping_1 *req_maps; + int i; + + tmp_ctx = talloc_new(mem_ctx); + if (tmp_ctx == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = cmd_fss_create_expose_parse(tmp_ctx, argc, argv, cli->desthost, + &fss_ctx_val, &num_maps, &req_maps); + if (!NT_STATUS_IS_OK(status)) { + cmd_fss_create_expose_usage(argv[0]); + goto err_out; + } + + /* + * PrepareShadowCopySet & CommitShadowCopySet often exceed the default + * 60 second dcerpc request timeout against Windows Server "8" Beta. + * ACHTUNG! dcerpc_binding_handle_set_timeout() value is interpreted as + * seconds on a source4 transport and as msecs here. + */ + dcerpc_binding_handle_set_timeout(b, 240 * 1000); + + for (i = 0; i < num_maps; i++) { + struct fss_IsPathSupported r_pathsupport_get; + r_pathsupport_get.in.ShareName = req_maps[i].ShareNameUNC; + status = dcerpc_fss_IsPathSupported_r(b, tmp_ctx, &r_pathsupport_get); + if (!NT_STATUS_IS_OK(status) || (r_pathsupport_get.out.result != 0)) { + DEBUG(0, ("IsPathSupported failed: %s result: 0x%x\n", + nt_errstr(status), r_pathsupport_get.out.result)); + goto err_out; + } + if (!r_pathsupport_get.out.SupportedByThisProvider) { + printf("path %s does not supported shadow-copies\n", + req_maps[i].ShareNameUNC); + status = NT_STATUS_NOT_SUPPORTED; + goto err_out; + } + } + + ZERO_STRUCT(r_version_get); + status = dcerpc_fss_GetSupportedVersion_r(b, tmp_ctx, &r_version_get); + if (!NT_STATUS_IS_OK(status) || (r_version_get.out.result != 0)) { + DEBUG(0, ("GetSupportedVersion failed: %s result: 0x%x\n", + nt_errstr(status), r_version_get.out.result)); + goto err_out; + } + + ZERO_STRUCT(r_context_set); + r_context_set.in.Context = fss_ctx_val; + status = dcerpc_fss_SetContext_r(b, tmp_ctx, &r_context_set); + if (!NT_STATUS_IS_OK(status) || (r_context_set.out.result != 0)) { + DEBUG(0, ("SetContext failed: %s result: 0x%x\n", + nt_errstr(status), r_context_set.out.result)); + goto err_out; + } + + ZERO_STRUCT(r_scset_start); + r_scset_start.in.ClientShadowCopySetId = GUID_random(); + status = dcerpc_fss_StartShadowCopySet_r(b, tmp_ctx, &r_scset_start); + if (!NT_STATUS_IS_OK(status) || (r_scset_start.out.result != 0)) { + DEBUG(0, ("StartShadowCopySet failed: %s result: 0x%x\n", + nt_errstr(status), r_scset_start.out.result)); + goto err_out; + } + printf("%s: shadow-copy set created\n", + GUID_string(tmp_ctx, r_scset_start.out.pShadowCopySetId)); + + for (i = 0; i < num_maps; i++) { + struct fss_AddToShadowCopySet r_scset_add; + r_scset_add.in.ClientShadowCopyId = GUID_random(); + r_scset_add.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId; + r_scset_add.in.ShareName = req_maps[i].ShareNameUNC; + status = dcerpc_fss_AddToShadowCopySet_r(b, tmp_ctx, &r_scset_add); + if (!NT_STATUS_IS_OK(status) || (r_scset_add.out.result != 0)) { + DEBUG(0, ("AddToShadowCopySet failed: %s result: 0x%x\n", + nt_errstr(status), r_scset_add.out.result)); + goto err_out; + } + printf("%s(%s): %s shadow-copy added to set\n", + GUID_string(tmp_ctx, r_scset_start.out.pShadowCopySetId), + GUID_string(tmp_ctx, r_scset_add.out.pShadowCopyId), + r_scset_add.in.ShareName); + req_maps[i].ShadowCopySetId = *r_scset_start.out.pShadowCopySetId; + req_maps[i].ShadowCopyId = *r_scset_add.out.pShadowCopyId; + } + + start_time = time_mono(NULL); + ZERO_STRUCT(r_scset_prep); + r_scset_prep.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId; + r_scset_prep.in.TimeOutInMilliseconds = (240 * 1000); + status = dcerpc_fss_PrepareShadowCopySet_r(b, tmp_ctx, &r_scset_prep); + if (!NT_STATUS_IS_OK(status) || (r_scset_prep.out.result != 0)) { + DEBUG(0, ("PrepareShadowCopySet failed: %s result: 0x%x\n", + nt_errstr(status), r_scset_prep.out.result)); + goto err_out; + } + printf("%s: prepare completed in %lu secs\n", + GUID_string(tmp_ctx, r_scset_start.out.pShadowCopySetId), + (uint64_t)(time_mono(NULL) - start_time)); + + start_time = time_mono(NULL); + ZERO_STRUCT(r_scset_commit); + r_scset_commit.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId; + r_scset_commit.in.TimeOutInMilliseconds = (180 * 1000); /* win8 */ + status = dcerpc_fss_CommitShadowCopySet_r(b, tmp_ctx, &r_scset_commit); + if (!NT_STATUS_IS_OK(status) || (r_scset_commit.out.result != 0)) { + DEBUG(0, ("CommitShadowCopySet failed: %s result: 0x%x\n", + nt_errstr(status), r_scset_commit.out.result)); + goto err_out; + } + printf("%s: commit completed in %lu secs\n", + GUID_string(tmp_ctx, r_scset_start.out.pShadowCopySetId), + (uint64_t)(time_mono(NULL) - start_time)); + + ZERO_STRUCT(r_scset_expose); + r_scset_expose.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId; + r_scset_expose.in.TimeOutInMilliseconds = (120 * 1000); /* win8 */ + status = dcerpc_fss_ExposeShadowCopySet_r(b, tmp_ctx, &r_scset_expose); + if (!NT_STATUS_IS_OK(status) || (r_scset_expose.out.result != 0)) { + DEBUG(0, ("ExposeShadowCopySet failed: %s result: 0x%x\n", + nt_errstr(status), r_scset_expose.out.result)); + goto err_out; + } + + for (i = 0; i < num_maps; i++) { + struct fss_GetShareMapping r_sharemap_get; + struct fssagent_share_mapping_1 *map; + r_sharemap_get.in.ShadowCopyId = req_maps[i].ShadowCopyId; + r_sharemap_get.in.ShadowCopySetId = req_maps[i].ShadowCopySetId; + r_sharemap_get.in.ShareName = req_maps[i].ShareNameUNC; + r_sharemap_get.in.Level = 1; + status = dcerpc_fss_GetShareMapping_r(b, tmp_ctx, &r_sharemap_get); + if (!NT_STATUS_IS_OK(status) || (r_sharemap_get.out.result != 0)) { + DEBUG(0, ("GetShareMapping failed: %s result: 0x%x\n", + nt_errstr(status), r_sharemap_get.out.result)); + goto err_out; + } + map = r_sharemap_get.out.ShareMapping->ShareMapping1; + printf("%s(%s): share %s exposed as a snapshot of %s\n", + GUID_string(tmp_ctx, &map->ShadowCopySetId), + GUID_string(tmp_ctx, &map->ShadowCopyId), + map->ShadowCopyShareName, map->ShareNameUNC); + } + +err_out: + talloc_free(tmp_ctx); + return status; +} + +static void cmd_fss_delete_usage(const char *script_name) +{ + printf("usage: %s [base_share] [shadow_copy_set_id] [shadow_copy_id]\n", + script_name); +} + +static NTSTATUS cmd_fss_delete(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, int argc, + const char **argv) +{ + struct dcerpc_binding_handle *b = cli->binding_handle; + struct fss_DeleteShareMapping r_sharemap_del; + const char *sc_set_id; + const char *sc_id; + NTSTATUS status; + TALLOC_CTX *tmp_ctx; + + if (argc < 4) { + cmd_fss_delete_usage(argv[0]); + return NT_STATUS_UNSUCCESSFUL; + } + sc_set_id = argv[2]; + sc_id = argv[3]; + + tmp_ctx = talloc_new(mem_ctx); + if (tmp_ctx == NULL) { + return NT_STATUS_NO_MEMORY; + } + + ZERO_STRUCT(r_sharemap_del); + r_sharemap_del.in.ShareName = talloc_asprintf(tmp_ctx, "\\\\%s\\%s", + cli->desthost, argv[1]); + if (r_sharemap_del.in.ShareName == NULL) { + status = NT_STATUS_NO_MEMORY; + goto err_out; + } + status = GUID_from_string(sc_set_id, &r_sharemap_del.in.ShadowCopySetId); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Invalid shadow_copy_set_id parameter\n")); + goto err_out; + } + status = GUID_from_string(sc_id, &r_sharemap_del.in.ShadowCopyId); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Invalid shadow_copy_id parameter\n")); + goto err_out; + } + status = dcerpc_fss_DeleteShareMapping_r(b, tmp_ctx, &r_sharemap_del); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("DeleteShareMapping failed\n")); + goto err_out; + } else if (r_sharemap_del.out.result != 0) { + DEBUG(0, ("failed DeleteShareMapping response: 0x%x\n", + r_sharemap_del.out.result)); + status = NT_STATUS_UNSUCCESSFUL; + goto err_out; + } + + printf("%s(%s): %s shadow-copy deleted\n", + sc_set_id, sc_id, r_sharemap_del.in.ShareName); + +err_out: + talloc_free(tmp_ctx); + return status; +} + +static void cmd_fss_is_shadow_copied_usage(const char *script_name) +{ + printf("usage: %s [share_name]\n", script_name); +} + +static NTSTATUS cmd_fss_is_shadow_copied(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, int argc, + const char **argv) +{ + NTSTATUS status; + struct fss_IsPathShadowCopied r; + struct dcerpc_binding_handle *b = cli->binding_handle; + + if (argc != 2) { + cmd_fss_is_shadow_copied_usage(argv[0]); + return NT_STATUS_UNSUCCESSFUL; + } + + ZERO_STRUCT(r); + r.in.ShareName = talloc_asprintf(mem_ctx, "%s\\%s", + cli->srv_name_slash, argv[1]); + if (r.in.ShareName == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = dcerpc_fss_IsPathShadowCopied_r(b, mem_ctx, &r); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("IsPathShadowCopied failed with UNC %s\n", + r.in.ShareName)); + return NT_STATUS_UNSUCCESSFUL; + } else if (r.out.result) { + DEBUG(0, ("failed IsPathShadowCopied response: 0x%x\n", + r.out.result)); + return NT_STATUS_UNSUCCESSFUL; + } + printf("UNC %s %s an associated shadow-copy with compatibility 0x%x\n", + r.in.ShareName, + *r.out.ShadowCopyPresent ? "has" : "does not have", + *r.out.ShadowCopyCompatibility); + + return NT_STATUS_OK; +} + +static void cmd_fss_get_mapping_usage(const char *script_name) +{ + printf("usage: %s [base_share] [shadow_copy_set_id] [shadow_copy_id]\n", + script_name); +} + +static NTSTATUS cmd_fss_get_mapping(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, int argc, + const char **argv) +{ + struct dcerpc_binding_handle *b = cli->binding_handle; + struct fss_GetShareMapping r_sharemap_get; + const char *sc_set_id; + const char *sc_id; + struct fssagent_share_mapping_1 *map; + NTSTATUS status; + TALLOC_CTX *tmp_ctx; + + if (argc < 4) { + cmd_fss_get_mapping_usage(argv[0]); + return NT_STATUS_UNSUCCESSFUL; + } + sc_set_id = argv[2]; + sc_id = argv[3]; + + tmp_ctx = talloc_new(mem_ctx); + if (tmp_ctx == NULL) { + return NT_STATUS_NO_MEMORY; + } + + ZERO_STRUCT(r_sharemap_get); + r_sharemap_get.in.ShareName = talloc_asprintf(tmp_ctx, "\\\\%s\\%s", + cli->desthost, argv[1]); + if (r_sharemap_get.in.ShareName == NULL) { + status = NT_STATUS_NO_MEMORY; + goto err_out; + } + status = GUID_from_string(sc_set_id, &r_sharemap_get.in.ShadowCopySetId); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Invalid shadow_copy_set_id parameter\n")); + goto err_out; + } + status = GUID_from_string(sc_id, &r_sharemap_get.in.ShadowCopyId); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Invalid shadow_copy_id parameter\n")); + goto err_out; + } + r_sharemap_get.in.Level = 1; + status = dcerpc_fss_GetShareMapping_r(b, tmp_ctx, &r_sharemap_get); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("GetShareMapping failed\n")); + goto err_out; + } else if (r_sharemap_get.out.result != 0) { + DEBUG(0, ("failed GetShareMapping response: 0x%x\n", + r_sharemap_get.out.result)); + status = NT_STATUS_UNSUCCESSFUL; + goto err_out; + } + + map = r_sharemap_get.out.ShareMapping->ShareMapping1; + printf("%s(%s): share %s is a shadow-copy of %s at %s\n", + GUID_string(tmp_ctx, &map->ShadowCopySetId), + GUID_string(tmp_ctx, &map->ShadowCopyId), + map->ShadowCopyShareName, map->ShareNameUNC, + nt_time_string(tmp_ctx, map->tstamp)); + +err_out: + talloc_free(tmp_ctx); + return status; +} + +static void cmd_fss_recov_complete_usage(const char *script_name) +{ + printf("usage: %s [shadow_copy_set_id]\n", script_name); +} + +static NTSTATUS cmd_fss_recov_complete(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, int argc, + const char **argv) +{ + NTSTATUS status; + struct fss_RecoveryCompleteShadowCopySet r; + struct dcerpc_binding_handle *b = cli->binding_handle; + const char *sc_set_id; + + if (argc != 2) { + cmd_fss_recov_complete_usage(argv[0]); + return NT_STATUS_UNSUCCESSFUL; + } + sc_set_id = argv[1]; + + ZERO_STRUCT(r); + status = GUID_from_string(sc_set_id, &r.in.ShadowCopySetId); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("Invalid shadow_copy_set_id\n")); + return NT_STATUS_INVALID_PARAMETER; + } + + status = dcerpc_fss_RecoveryCompleteShadowCopySet_r(b, mem_ctx, &r); + if (!NT_STATUS_IS_OK(status) || (r.out.result != 0)) { + DEBUG(0, ("RecoveryCompleteShadowCopySet failed: %s " + "result: 0x%x\n", nt_errstr(status), r.out.result)); + return status; + } + printf("%s: shadow-copy set marked recovery complete\n", sc_set_id); + + return NT_STATUS_OK; +} + +/* List of commands exported by this module */ +struct cmd_set fss_commands[] = { + + { "FSRVP" }, + + { + .name = "fss_is_path_sup", + .returntype = RPC_RTYPE_NTSTATUS, + .ntfn = cmd_fss_is_path_sup, + .table = &ndr_table_FileServerVssAgent, + .rpc_pipe = NULL, + .description = "Check whether a share supports shadow-copy " + "requests", + .usage = "", + }, + { + .name = "fss_get_sup_version", + .returntype = RPC_RTYPE_NTSTATUS, + .ntfn = cmd_fss_get_sup_version, + .table = &ndr_table_FileServerVssAgent, + .rpc_pipe = NULL, + .description = "Get supported FSRVP version from server", + .usage = "", + }, + { + .name = "fss_create_expose", + .returntype = RPC_RTYPE_NTSTATUS, + .ntfn = cmd_fss_create_expose, + .table = &ndr_table_FileServerVssAgent, + .rpc_pipe = NULL, + .description = "Request shadow-copy creation and exposure", + .usage = "", + }, + { + .name = "fss_delete", + .returntype = RPC_RTYPE_NTSTATUS, + .ntfn = cmd_fss_delete, + .table = &ndr_table_FileServerVssAgent, + .rpc_pipe = NULL, + .description = "Request shadow-copy share deletion", + .usage = "", + }, + { + .name = "fss_has_shadow_copy", + .returntype = RPC_RTYPE_NTSTATUS, + .ntfn = cmd_fss_is_shadow_copied, + .table = &ndr_table_FileServerVssAgent, + .rpc_pipe = NULL, + .description = "Check for an associated share shadow-copy", + .usage = "", + }, + { + .name = "fss_get_mapping", + .returntype = RPC_RTYPE_NTSTATUS, + .ntfn = cmd_fss_get_mapping, + .table = &ndr_table_FileServerVssAgent, + .rpc_pipe = NULL, + .description = "Get shadow-copy share mapping information", + .usage = "", + }, + { + .name = "fss_recovery_complete", + .returntype = RPC_RTYPE_NTSTATUS, + .ntfn = cmd_fss_recov_complete, + .table = &ndr_table_FileServerVssAgent, + .rpc_pipe = NULL, + .description = "Flag read-write snapshot as recovery complete, " + "allowing further shadow-copy requests", + .usage = "", + }, + { NULL } +}; diff --git a/source3/rpcclient/rpcclient.c b/source3/rpcclient/rpcclient.c index 0c1a594dc3..7b31e1547e 100644 --- a/source3/rpcclient/rpcclient.c +++ b/source3/rpcclient/rpcclient.c @@ -620,6 +620,7 @@ extern struct cmd_set ntsvcs_commands[]; extern struct cmd_set drsuapi_commands[]; extern struct cmd_set eventlog_commands[]; extern struct cmd_set winreg_commands[]; +extern struct cmd_set fss_commands[]; static struct cmd_set *rpcclient_command_list[] = { rpcclient_commands, @@ -639,6 +640,7 @@ static struct cmd_set *rpcclient_command_list[] = { drsuapi_commands, eventlog_commands, winreg_commands, + fss_commands, NULL }; |