source: vendor/current/source3/rpcclient/cmd_fss.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 22.3 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 *
4 * File Server Remote VSS Protocol (FSRVP) client
5 *
6 * Copyright (C) David Disseldorp 2012
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22#include "includes.h"
23#include "rpcclient.h"
24#include "../librpc/gen_ndr/ndr_fsrvp.h"
25#include "../librpc/gen_ndr/ndr_fsrvp_c.h"
26#include "../libcli/util/hresult.h"
27
28static const struct {
29 uint32_t error_code;
30 const char *error_str;
31} fss_errors[] = {
32 {
33 FSRVP_E_BAD_STATE,
34 "A method call was invalid because of the state of the server."
35 },
36 {
37 FSRVP_E_SHADOW_COPY_SET_IN_PROGRESS,
38 "A call was made to either \'SetContext\' or \'StartShadowCopySet\' while the creation of another shadow copy set is in progress."
39 },
40 {
41 FSRVP_E_NOT_SUPPORTED,
42 "The file store which contains the share to be shadow copied is not supported by the server."
43 },
44 {
45 FSRVP_E_WAIT_TIMEOUT,
46 "The wait for a shadow copy commit or expose operation has timed out."
47 },
48 {
49 FSRVP_E_WAIT_FAILED,
50 "The wait for a shadow copy commit expose operation has failed."
51 },
52 {
53 FSRVP_E_OBJECT_NOT_FOUND,
54 "The specified object does not exist."
55 },
56 {
57 FSRVP_E_UNSUPPORTED_CONTEXT,
58 "The specified context value is invalid."
59 },
60 {
61 FSRVP_E_SHADOWCOPYSET_ID_MISMATCH,
62 "The provided ShadowCopySetId does not exist."
63 },
64};
65
66struct fss_context_map {
67 uint32_t ctx_val;
68 const char *ctx_str;
69 const char *ctx_desc;
70};
71struct fss_context_map ctx_map[] = {
72 {
73 .ctx_val = FSRVP_CTX_BACKUP,
74 .ctx_str = "backup",
75 .ctx_desc = "auto-release, non-persistent shadow-copy.",
76 },
77 {
78 .ctx_val = FSRVP_CTX_FILE_SHARE_BACKUP,
79 .ctx_str = "file_share_backup",
80 .ctx_desc = "auto-release, non-persistent shadow-copy created "
81 "without writer involvement.",
82 },
83 {
84 .ctx_val = FSRVP_CTX_NAS_ROLLBACK,
85 .ctx_str = "nas_rollback",
86 .ctx_desc = "non-auto-release, persistent shadow-copy created "
87 "without writer involvement.",
88 },
89 {
90 .ctx_val = FSRVP_CTX_APP_ROLLBACK,
91 .ctx_str = "app_rollback",
92 .ctx_desc = "non-auto-release, persistent shadow-copy.",
93 },
94 { 0, NULL, NULL },
95};
96
97static const char *get_error_str(uint32_t code)
98{
99 static const char *default_err = "Unknown Error";
100 const char *result = default_err;
101 int i;
102 for (i = 0; i < ARRAY_SIZE(fss_errors); ++i) {
103 if (code == fss_errors[i].error_code) {
104 result = fss_errors[i].error_str;
105 break;
106 }
107 }
108 /* error isn't specific fsrvp one, check hresult errors */
109 if (result == default_err) {
110 const char *hres_err = hresult_errstr_const(HRES_ERROR(code));
111 if (hres_err) {
112 result = hres_err;
113 }
114 }
115 return result;
116};
117
118static bool map_fss_ctx_str(const char *ctx_str,
119 uint32_t *ctx_val)
120{
121 int i;
122
123 for (i = 0; ctx_map[i].ctx_str != NULL; i++) {
124 if (!strcmp(ctx_map[i].ctx_str, ctx_str)) {
125 *ctx_val = ctx_map[i].ctx_val;
126 return true;
127 }
128 }
129 return false;
130}
131
132static void cmd_fss_is_path_sup_usage(const char *script_name)
133{
134 printf("usage: %s [share_name]\n", script_name);
135}
136
137static NTSTATUS cmd_fss_is_path_sup(struct rpc_pipe_client *cli,
138 TALLOC_CTX *mem_ctx, int argc,
139 const char **argv)
140{
141 NTSTATUS status;
142 struct fss_IsPathSupported r;
143 struct dcerpc_binding_handle *b = cli->binding_handle;
144
145 if (argc != 2) {
146 cmd_fss_is_path_sup_usage(argv[0]);
147 return NT_STATUS_UNSUCCESSFUL;
148 }
149
150 ZERO_STRUCT(r);
151 r.in.ShareName = talloc_asprintf(mem_ctx, "%s\\%s\\",
152 cli->srv_name_slash, argv[1]);
153 if (r.in.ShareName == NULL) {
154 return NT_STATUS_NO_MEMORY;
155 }
156
157 status = dcerpc_fss_IsPathSupported_r(b, mem_ctx, &r);
158 if (!NT_STATUS_IS_OK(status)) {
159 DEBUG(0, ("IsPathSupported failed with UNC %s\n",
160 r.in.ShareName));
161 return NT_STATUS_UNSUCCESSFUL;
162 } else if (r.out.result) {
163 DEBUG(0, ("failed IsPathSupported response: 0x%x - \"%s\"\n",
164 r.out.result, get_error_str(r.out.result)));
165 return NT_STATUS_UNSUCCESSFUL;
166 }
167 printf("UNC %s %s shadow copy requests\n", r.in.ShareName,
168 *r.out.SupportedByThisProvider ? "supports" : "does not support");
169
170 return NT_STATUS_OK;
171}
172
173static void cmd_fss_get_sup_version_usage(const char *script_name)
174{
175 printf("usage: %s\n", script_name);
176}
177
178static NTSTATUS cmd_fss_get_sup_version(struct rpc_pipe_client *cli,
179 TALLOC_CTX *mem_ctx, int argc,
180 const char **argv)
181{
182 NTSTATUS status;
183 struct fss_GetSupportedVersion r;
184 struct dcerpc_binding_handle *b = cli->binding_handle;
185
186 if (argc != 1) {
187 cmd_fss_get_sup_version_usage(argv[0]);
188 return NT_STATUS_UNSUCCESSFUL;
189 }
190
191 ZERO_STRUCT(r);
192 status = dcerpc_fss_GetSupportedVersion_r(b, mem_ctx, &r);
193 if (!NT_STATUS_IS_OK(status) || (r.out.result != 0)) {
194 DEBUG(0, ("GetSupportedVersion failed: %s result: 0x%x\n",
195 nt_errstr(status), r.out.result));
196 return NT_STATUS_UNSUCCESSFUL;
197 }
198 printf("server %s supports FSRVP versions from %u to %u\n",
199 cli->desthost, *r.out.MinVersion, *r.out.MaxVersion);
200
201 return NT_STATUS_OK;
202}
203
204static void cmd_fss_create_expose_usage(const char *script_name)
205{
206 int i;
207
208 printf("usage: %s [fss_context] [ro|rw] [share1] <share2> ...\n"
209 "[fss_context] values:\n", script_name);
210 for (i = 0; ctx_map[i].ctx_str != NULL; i++) {
211 printf("\t%s: %s\n", ctx_map[i].ctx_str, ctx_map[i].ctx_desc);
212 }
213}
214
215static NTSTATUS cmd_fss_create_expose_parse(TALLOC_CTX *mem_ctx, int argc,
216 const char **argv,
217 const char *desthost,
218 uint32_t *fss_ctx_val,
219 int *num_maps,
220 struct fssagent_share_mapping_1 **maps)
221{
222 int num_non_share_args = 3;
223 int num_share_args;
224 int i;
225 struct fssagent_share_mapping_1 *map_array;
226
227 if (argc < 4) {
228 return NT_STATUS_INVALID_PARAMETER;
229 }
230
231 if (!map_fss_ctx_str(argv[1], fss_ctx_val)) {
232 return NT_STATUS_INVALID_PARAMETER;
233 }
234
235 if (!strcmp(argv[2], "rw")) {
236 /* shadow-copy is created as read-write */
237 *fss_ctx_val |= ATTR_AUTO_RECOVERY;
238 } else if (strcmp(argv[2], "ro")) {
239 return NT_STATUS_INVALID_PARAMETER;
240 }
241
242 num_share_args = argc - num_non_share_args;
243 map_array = talloc_array(mem_ctx, struct fssagent_share_mapping_1,
244 num_share_args);
245 if (map_array == NULL) {
246 return NT_STATUS_NO_MEMORY;
247 }
248
249 for (i = 0; i < num_share_args; i++) {
250 /*
251 * A trailing slash should to be present in the request UNC,
252 * otherwise Windows Server 2012 FSRVP servers don't append
253 * a '$' to exposed hidden share shadow-copies. E.g.
254 * AddToShadowCopySet(UNC=\\server\hidden$)
255 * CommitShadowCopySet()
256 * ExposeShadowCopySet()
257 * -> new share = \\server\hidden$@{ShadowCopy.ShadowCopyId}
258 * But...
259 * AddToShadowCopySet(UNC=\\server\hidden$\)
260 * CommitShadowCopySet()
261 * ExposeShadowCopySet()
262 * -> new share = \\server\hidden$@{ShadowCopy.ShadowCopyId}$
263 */
264 map_array[i].ShareNameUNC = talloc_asprintf(mem_ctx,
265 "\\\\%s\\%s\\",
266 desthost,
267 argv[i + num_non_share_args]);
268 if (map_array[i].ShareNameUNC == NULL) {
269 return NT_STATUS_NO_MEMORY;
270 }
271 }
272 *num_maps = num_share_args;
273 *maps = map_array;
274
275 return NT_STATUS_OK;
276}
277
278static NTSTATUS cmd_fss_abort(TALLOC_CTX *mem_ctx,
279 struct dcerpc_binding_handle *b,
280 struct GUID *sc_set_id)
281{
282 NTSTATUS status;
283 struct fss_AbortShadowCopySet r_scset_abort;
284
285 ZERO_STRUCT(r_scset_abort);
286 r_scset_abort.in.ShadowCopySetId = *sc_set_id;
287 status = dcerpc_fss_AbortShadowCopySet_r(b, mem_ctx, &r_scset_abort);
288 if (!NT_STATUS_IS_OK(status) || (r_scset_abort.out.result != 0)) {
289 DEBUG(0, ("AbortShadowCopySet failed: %s result: 0x%x\n",
290 nt_errstr(status), r_scset_abort.out.result));
291 return NT_STATUS_UNSUCCESSFUL;
292 }
293 return NT_STATUS_OK;
294}
295
296static NTSTATUS cmd_fss_create_expose(struct rpc_pipe_client *cli,
297 TALLOC_CTX *mem_ctx, int argc,
298 const char **argv)
299{
300 NTSTATUS status;
301 struct fss_GetSupportedVersion r_version_get;
302 struct fss_SetContext r_context_set;
303 struct fss_StartShadowCopySet r_scset_start;
304 struct fss_PrepareShadowCopySet r_scset_prep;
305 struct fss_CommitShadowCopySet r_scset_commit;
306 struct fss_ExposeShadowCopySet r_scset_expose;
307 struct dcerpc_binding_handle *b = cli->binding_handle;
308 time_t start_time;
309 TALLOC_CTX *tmp_ctx;
310 uint32_t fss_ctx_val;
311 int num_maps;
312 struct fssagent_share_mapping_1 *req_maps;
313 int i;
314
315 tmp_ctx = talloc_new(mem_ctx);
316 if (tmp_ctx == NULL) {
317 return NT_STATUS_NO_MEMORY;
318 }
319
320 status = cmd_fss_create_expose_parse(tmp_ctx, argc, argv, cli->desthost,
321 &fss_ctx_val, &num_maps, &req_maps);
322 if (!NT_STATUS_IS_OK(status)) {
323 cmd_fss_create_expose_usage(argv[0]);
324 goto err_out;
325 }
326
327 /*
328 * PrepareShadowCopySet & CommitShadowCopySet often exceed the default
329 * 60 second dcerpc request timeout against Windows Server "8" Beta.
330 * ACHTUNG! dcerpc_binding_handle_set_timeout() value is interpreted as
331 * seconds on a source4 transport and as msecs here.
332 */
333 dcerpc_binding_handle_set_timeout(b, 240 * 1000);
334
335 for (i = 0; i < num_maps; i++) {
336 struct fss_IsPathSupported r_pathsupport_get;
337 r_pathsupport_get.in.ShareName = req_maps[i].ShareNameUNC;
338 status = dcerpc_fss_IsPathSupported_r(b, tmp_ctx, &r_pathsupport_get);
339 if (!NT_STATUS_IS_OK(status) || (r_pathsupport_get.out.result != 0)) {
340 DEBUG(0, ("IsPathSupported failed: %s result: 0x%x\n",
341 nt_errstr(status), r_pathsupport_get.out.result));
342 goto err_out;
343 }
344 if (!r_pathsupport_get.out.SupportedByThisProvider) {
345 printf("path %s does not supported shadow-copies\n",
346 req_maps[i].ShareNameUNC);
347 status = NT_STATUS_NOT_SUPPORTED;
348 goto err_out;
349 }
350 }
351
352 ZERO_STRUCT(r_version_get);
353 status = dcerpc_fss_GetSupportedVersion_r(b, tmp_ctx, &r_version_get);
354 if (!NT_STATUS_IS_OK(status) || (r_version_get.out.result != 0)) {
355 DEBUG(0, ("GetSupportedVersion failed: %s result: 0x%x\n",
356 nt_errstr(status), r_version_get.out.result));
357 goto err_out;
358 }
359
360 ZERO_STRUCT(r_context_set);
361 r_context_set.in.Context = fss_ctx_val;
362 status = dcerpc_fss_SetContext_r(b, tmp_ctx, &r_context_set);
363 if (!NT_STATUS_IS_OK(status) || (r_context_set.out.result != 0)) {
364 DEBUG(0, ("SetContext failed: %s result: 0x%x\n",
365 nt_errstr(status), r_context_set.out.result));
366 goto err_out;
367 }
368
369 ZERO_STRUCT(r_scset_start);
370 r_scset_start.in.ClientShadowCopySetId = GUID_random();
371 status = dcerpc_fss_StartShadowCopySet_r(b, tmp_ctx, &r_scset_start);
372 if (!NT_STATUS_IS_OK(status) || (r_scset_start.out.result != 0)) {
373 DEBUG(0, ("StartShadowCopySet failed: %s result: 0x%x\n",
374 nt_errstr(status), r_scset_start.out.result));
375 goto err_out;
376 }
377 printf("%s: shadow-copy set created\n",
378 GUID_string(tmp_ctx, r_scset_start.out.pShadowCopySetId));
379
380 for (i = 0; i < num_maps; i++) {
381 struct fss_AddToShadowCopySet r_scset_add;
382 r_scset_add.in.ClientShadowCopyId = GUID_random();
383 r_scset_add.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId;
384 r_scset_add.in.ShareName = req_maps[i].ShareNameUNC;
385 status = dcerpc_fss_AddToShadowCopySet_r(b, tmp_ctx, &r_scset_add);
386 if (!NT_STATUS_IS_OK(status) || (r_scset_add.out.result != 0)) {
387 DEBUG(0, ("AddToShadowCopySet failed: %s result: 0x%x\n",
388 nt_errstr(status), r_scset_add.out.result));
389 goto err_sc_set_abort;
390 }
391 printf("%s(%s): %s shadow-copy added to set\n",
392 GUID_string(tmp_ctx, r_scset_start.out.pShadowCopySetId),
393 GUID_string(tmp_ctx, r_scset_add.out.pShadowCopyId),
394 r_scset_add.in.ShareName);
395 req_maps[i].ShadowCopySetId = *r_scset_start.out.pShadowCopySetId;
396 req_maps[i].ShadowCopyId = *r_scset_add.out.pShadowCopyId;
397 }
398
399 start_time = time_mono(NULL);
400 ZERO_STRUCT(r_scset_prep);
401 r_scset_prep.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId;
402 r_scset_prep.in.TimeOutInMilliseconds = (240 * 1000);
403 status = dcerpc_fss_PrepareShadowCopySet_r(b, tmp_ctx, &r_scset_prep);
404 if (!NT_STATUS_IS_OK(status) || (r_scset_prep.out.result != 0)) {
405 DEBUG(0, ("PrepareShadowCopySet failed: %s result: 0x%x\n",
406 nt_errstr(status), r_scset_prep.out.result));
407 goto err_sc_set_abort;
408 }
409 printf("%s: prepare completed in %llu secs\n",
410 GUID_string(tmp_ctx, r_scset_start.out.pShadowCopySetId),
411 (long long unsigned int)(time_mono(NULL) - start_time));
412
413 start_time = time_mono(NULL);
414 ZERO_STRUCT(r_scset_commit);
415 r_scset_commit.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId;
416 r_scset_commit.in.TimeOutInMilliseconds = (180 * 1000); /* win8 */
417 status = dcerpc_fss_CommitShadowCopySet_r(b, tmp_ctx, &r_scset_commit);
418 if (!NT_STATUS_IS_OK(status) || (r_scset_commit.out.result != 0)) {
419 DEBUG(0, ("CommitShadowCopySet failed: %s result: 0x%x\n",
420 nt_errstr(status), r_scset_commit.out.result));
421 goto err_sc_set_abort;
422 }
423 printf("%s: commit completed in %llu secs\n",
424 GUID_string(tmp_ctx, r_scset_start.out.pShadowCopySetId),
425 (long long unsigned int)(time_mono(NULL) - start_time));
426
427 ZERO_STRUCT(r_scset_expose);
428 r_scset_expose.in.ShadowCopySetId = *r_scset_start.out.pShadowCopySetId;
429 r_scset_expose.in.TimeOutInMilliseconds = (120 * 1000); /* win8 */
430 status = dcerpc_fss_ExposeShadowCopySet_r(b, tmp_ctx, &r_scset_expose);
431 if (!NT_STATUS_IS_OK(status) || (r_scset_expose.out.result != 0)) {
432 DEBUG(0, ("ExposeShadowCopySet failed: %s result: 0x%x\n",
433 nt_errstr(status), r_scset_expose.out.result));
434 goto err_out;
435 }
436
437 for (i = 0; i < num_maps; i++) {
438 struct fss_GetShareMapping r_sharemap_get;
439 struct fssagent_share_mapping_1 *map;
440 r_sharemap_get.in.ShadowCopyId = req_maps[i].ShadowCopyId;
441 r_sharemap_get.in.ShadowCopySetId = req_maps[i].ShadowCopySetId;
442 r_sharemap_get.in.ShareName = req_maps[i].ShareNameUNC;
443 r_sharemap_get.in.Level = 1;
444 status = dcerpc_fss_GetShareMapping_r(b, tmp_ctx, &r_sharemap_get);
445 if (!NT_STATUS_IS_OK(status) || (r_sharemap_get.out.result != 0)) {
446 DEBUG(0, ("GetShareMapping failed: %s result: 0x%x\n",
447 nt_errstr(status), r_sharemap_get.out.result));
448 goto err_out;
449 }
450 map = r_sharemap_get.out.ShareMapping->ShareMapping1;
451 printf("%s(%s): share %s exposed as a snapshot of %s\n",
452 GUID_string(tmp_ctx, &map->ShadowCopySetId),
453 GUID_string(tmp_ctx, &map->ShadowCopyId),
454 map->ShadowCopyShareName, map->ShareNameUNC);
455 }
456
457 talloc_free(tmp_ctx);
458 return NT_STATUS_OK;
459
460err_sc_set_abort:
461 cmd_fss_abort(tmp_ctx, b, r_scset_start.out.pShadowCopySetId);
462err_out:
463 talloc_free(tmp_ctx);
464 return status;
465}
466
467static void cmd_fss_delete_usage(const char *script_name)
468{
469 printf("usage: %s [base_share] [shadow_copy_set_id] [shadow_copy_id]\n",
470 script_name);
471}
472
473static NTSTATUS cmd_fss_delete(struct rpc_pipe_client *cli,
474 TALLOC_CTX *mem_ctx, int argc,
475 const char **argv)
476{
477 struct dcerpc_binding_handle *b = cli->binding_handle;
478 struct fss_DeleteShareMapping r_sharemap_del;
479 const char *sc_set_id;
480 const char *sc_id;
481 NTSTATUS status;
482 TALLOC_CTX *tmp_ctx;
483
484 if (argc < 4) {
485 cmd_fss_delete_usage(argv[0]);
486 return NT_STATUS_UNSUCCESSFUL;
487 }
488 sc_set_id = argv[2];
489 sc_id = argv[3];
490
491 tmp_ctx = talloc_new(mem_ctx);
492 if (tmp_ctx == NULL) {
493 return NT_STATUS_NO_MEMORY;
494 }
495
496 ZERO_STRUCT(r_sharemap_del);
497 r_sharemap_del.in.ShareName = talloc_asprintf(tmp_ctx, "\\\\%s\\%s\\",
498 cli->desthost, argv[1]);
499 if (r_sharemap_del.in.ShareName == NULL) {
500 status = NT_STATUS_NO_MEMORY;
501 goto err_out;
502 }
503 status = GUID_from_string(sc_set_id, &r_sharemap_del.in.ShadowCopySetId);
504 if (!NT_STATUS_IS_OK(status)) {
505 DEBUG(0, ("Invalid shadow_copy_set_id parameter\n"));
506 goto err_out;
507 }
508 status = GUID_from_string(sc_id, &r_sharemap_del.in.ShadowCopyId);
509 if (!NT_STATUS_IS_OK(status)) {
510 DEBUG(0, ("Invalid shadow_copy_id parameter\n"));
511 goto err_out;
512 }
513 status = dcerpc_fss_DeleteShareMapping_r(b, tmp_ctx, &r_sharemap_del);
514 if (!NT_STATUS_IS_OK(status)) {
515 DEBUG(0, ("DeleteShareMapping failed\n"));
516 goto err_out;
517 } else if (r_sharemap_del.out.result != 0) {
518 DEBUG(0, ("failed DeleteShareMapping response: 0x%x\n",
519 r_sharemap_del.out.result));
520 status = NT_STATUS_UNSUCCESSFUL;
521 goto err_out;
522 }
523
524 printf("%s(%s): %s shadow-copy deleted\n",
525 sc_set_id, sc_id, r_sharemap_del.in.ShareName);
526
527err_out:
528 talloc_free(tmp_ctx);
529 return status;
530}
531
532static void cmd_fss_is_shadow_copied_usage(const char *script_name)
533{
534 printf("usage: %s [share_name]\n", script_name);
535}
536
537static NTSTATUS cmd_fss_is_shadow_copied(struct rpc_pipe_client *cli,
538 TALLOC_CTX *mem_ctx, int argc,
539 const char **argv)
540{
541 NTSTATUS status;
542 struct fss_IsPathShadowCopied r;
543 struct dcerpc_binding_handle *b = cli->binding_handle;
544
545 if (argc != 2) {
546 cmd_fss_is_shadow_copied_usage(argv[0]);
547 return NT_STATUS_UNSUCCESSFUL;
548 }
549
550 ZERO_STRUCT(r);
551 r.in.ShareName = talloc_asprintf(mem_ctx, "%s\\%s\\",
552 cli->srv_name_slash, argv[1]);
553 if (r.in.ShareName == NULL) {
554 return NT_STATUS_NO_MEMORY;
555 }
556
557 status = dcerpc_fss_IsPathShadowCopied_r(b, mem_ctx, &r);
558 if (!NT_STATUS_IS_OK(status)) {
559 DEBUG(0, ("IsPathShadowCopied failed with UNC %s\n",
560 r.in.ShareName));
561 return NT_STATUS_UNSUCCESSFUL;
562 } else if (r.out.result) {
563 DEBUG(0, ("failed IsPathShadowCopied response: 0x%x\n",
564 r.out.result));
565 return NT_STATUS_UNSUCCESSFUL;
566 }
567 printf("UNC %s %s an associated shadow-copy with compatibility 0x%x\n",
568 r.in.ShareName,
569 *r.out.ShadowCopyPresent ? "has" : "does not have",
570 *r.out.ShadowCopyCompatibility);
571
572 return NT_STATUS_OK;
573}
574
575static void cmd_fss_get_mapping_usage(const char *script_name)
576{
577 printf("usage: %s [base_share] [shadow_copy_set_id] [shadow_copy_id]\n",
578 script_name);
579}
580
581static NTSTATUS cmd_fss_get_mapping(struct rpc_pipe_client *cli,
582 TALLOC_CTX *mem_ctx, int argc,
583 const char **argv)
584{
585 struct dcerpc_binding_handle *b = cli->binding_handle;
586 struct fss_GetShareMapping r_sharemap_get;
587 const char *sc_set_id;
588 const char *sc_id;
589 struct fssagent_share_mapping_1 *map;
590 NTSTATUS status;
591 TALLOC_CTX *tmp_ctx;
592
593 if (argc < 4) {
594 cmd_fss_get_mapping_usage(argv[0]);
595 return NT_STATUS_UNSUCCESSFUL;
596 }
597 sc_set_id = argv[2];
598 sc_id = argv[3];
599
600 tmp_ctx = talloc_new(mem_ctx);
601 if (tmp_ctx == NULL) {
602 return NT_STATUS_NO_MEMORY;
603 }
604
605 ZERO_STRUCT(r_sharemap_get);
606 r_sharemap_get.in.ShareName = talloc_asprintf(tmp_ctx, "\\\\%s\\%s\\",
607 cli->desthost, argv[1]);
608 if (r_sharemap_get.in.ShareName == NULL) {
609 status = NT_STATUS_NO_MEMORY;
610 goto err_out;
611 }
612 status = GUID_from_string(sc_set_id, &r_sharemap_get.in.ShadowCopySetId);
613 if (!NT_STATUS_IS_OK(status)) {
614 DEBUG(0, ("Invalid shadow_copy_set_id parameter\n"));
615 goto err_out;
616 }
617 status = GUID_from_string(sc_id, &r_sharemap_get.in.ShadowCopyId);
618 if (!NT_STATUS_IS_OK(status)) {
619 DEBUG(0, ("Invalid shadow_copy_id parameter\n"));
620 goto err_out;
621 }
622 r_sharemap_get.in.Level = 1;
623 status = dcerpc_fss_GetShareMapping_r(b, tmp_ctx, &r_sharemap_get);
624 if (!NT_STATUS_IS_OK(status)) {
625 DEBUG(0, ("GetShareMapping failed\n"));
626 goto err_out;
627 } else if (r_sharemap_get.out.result != 0) {
628 DEBUG(0, ("failed GetShareMapping response: 0x%x\n",
629 r_sharemap_get.out.result));
630 status = NT_STATUS_UNSUCCESSFUL;
631 goto err_out;
632 }
633
634 map = r_sharemap_get.out.ShareMapping->ShareMapping1;
635 printf("%s(%s): share %s is a shadow-copy of %s at %s\n",
636 GUID_string(tmp_ctx, &map->ShadowCopySetId),
637 GUID_string(tmp_ctx, &map->ShadowCopyId),
638 map->ShadowCopyShareName, map->ShareNameUNC,
639 nt_time_string(tmp_ctx, map->tstamp));
640
641err_out:
642 talloc_free(tmp_ctx);
643 return status;
644}
645
646static void cmd_fss_recov_complete_usage(const char *script_name)
647{
648 printf("usage: %s [shadow_copy_set_id]\n", script_name);
649}
650
651static NTSTATUS cmd_fss_recov_complete(struct rpc_pipe_client *cli,
652 TALLOC_CTX *mem_ctx, int argc,
653 const char **argv)
654{
655 NTSTATUS status;
656 struct fss_RecoveryCompleteShadowCopySet r;
657 struct dcerpc_binding_handle *b = cli->binding_handle;
658 const char *sc_set_id;
659
660 if (argc != 2) {
661 cmd_fss_recov_complete_usage(argv[0]);
662 return NT_STATUS_UNSUCCESSFUL;
663 }
664 sc_set_id = argv[1];
665
666 ZERO_STRUCT(r);
667 status = GUID_from_string(sc_set_id, &r.in.ShadowCopySetId);
668 if (!NT_STATUS_IS_OK(status)) {
669 DEBUG(0, ("Invalid shadow_copy_set_id\n"));
670 return NT_STATUS_INVALID_PARAMETER;
671 }
672
673 status = dcerpc_fss_RecoveryCompleteShadowCopySet_r(b, mem_ctx, &r);
674 if (!NT_STATUS_IS_OK(status) || (r.out.result != 0)) {
675 DEBUG(0, ("RecoveryCompleteShadowCopySet failed: %s "
676 "result: 0x%x\n", nt_errstr(status), r.out.result));
677 return status;
678 }
679 printf("%s: shadow-copy set marked recovery complete\n", sc_set_id);
680
681 return NT_STATUS_OK;
682}
683
684/* List of commands exported by this module */
685struct cmd_set fss_commands[] = {
686
687 { "FSRVP" },
688
689 {
690 .name = "fss_is_path_sup",
691 .returntype = RPC_RTYPE_NTSTATUS,
692 .ntfn = cmd_fss_is_path_sup,
693 .table = &ndr_table_FileServerVssAgent,
694 .rpc_pipe = NULL,
695 .description = "Check whether a share supports shadow-copy "
696 "requests",
697 .usage = "",
698 },
699 {
700 .name = "fss_get_sup_version",
701 .returntype = RPC_RTYPE_NTSTATUS,
702 .ntfn = cmd_fss_get_sup_version,
703 .table = &ndr_table_FileServerVssAgent,
704 .rpc_pipe = NULL,
705 .description = "Get supported FSRVP version from server",
706 .usage = "",
707 },
708 {
709 .name = "fss_create_expose",
710 .returntype = RPC_RTYPE_NTSTATUS,
711 .ntfn = cmd_fss_create_expose,
712 .table = &ndr_table_FileServerVssAgent,
713 .rpc_pipe = NULL,
714 .description = "Request shadow-copy creation and exposure",
715 .usage = "",
716 },
717 {
718 .name = "fss_delete",
719 .returntype = RPC_RTYPE_NTSTATUS,
720 .ntfn = cmd_fss_delete,
721 .table = &ndr_table_FileServerVssAgent,
722 .rpc_pipe = NULL,
723 .description = "Request shadow-copy share deletion",
724 .usage = "",
725 },
726 {
727 .name = "fss_has_shadow_copy",
728 .returntype = RPC_RTYPE_NTSTATUS,
729 .ntfn = cmd_fss_is_shadow_copied,
730 .table = &ndr_table_FileServerVssAgent,
731 .rpc_pipe = NULL,
732 .description = "Check for an associated share shadow-copy",
733 .usage = "",
734 },
735 {
736 .name = "fss_get_mapping",
737 .returntype = RPC_RTYPE_NTSTATUS,
738 .ntfn = cmd_fss_get_mapping,
739 .table = &ndr_table_FileServerVssAgent,
740 .rpc_pipe = NULL,
741 .description = "Get shadow-copy share mapping information",
742 .usage = "",
743 },
744 {
745 .name = "fss_recovery_complete",
746 .returntype = RPC_RTYPE_NTSTATUS,
747 .ntfn = cmd_fss_recov_complete,
748 .table = &ndr_table_FileServerVssAgent,
749 .rpc_pipe = NULL,
750 .description = "Flag read-write snapshot as recovery complete, "
751 "allowing further shadow-copy requests",
752 .usage = "",
753 },
754 { NULL }
755};
Note: See TracBrowser for help on using the repository browser.