s3-rpcclient: add fsrvp commands

fss_create_expose connects to an FSRVP server and negotiates the
creation and exposure of a share shadow-copy.
shadow-copies of multiple shares can be requested with a single
fss_create_expose request.

ddiss@plati:~> bin/rpcclient -k -U 'LURCH\administrator%password' \
                             ncacn_np:lutze[sign]
rpcclient $> fss_create_expose backup ro hyper
381884f2-b578-45ea-b8d2-cf82491f4011: shadow-copy set created
...
share hyper@{B6137E21-9CBB-4547-A21D-E7AD40D0874B} exposed as a snapshot
of \\lutze\hyper

fss_delete removes the shadow-copy share:
rpcclient $> fss_delete hyper 381884f2-b578-45ea-b8d2-cf82491f4011 \
                        b6137e21-9cbb-4547-a21d-e7ad40d0874

Shadow-copies can be created read-write or read-only.
Experimenting with Windows Server "8" beta, a recovery complete call is
required after creating a read-write (ATTR_AUTO_RECOVERY) shadow copy.
Otherwise subsequent creation requests fail with
FSRVP_E_SHADOW_COPY_SET_IN_PROGRESS.

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