?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libsmb: Use clistr_smb2_extract_snapshot_token() in cli_smb2_create_fnum_send()
[Samba.git] / source3 / rpc_server / fss / srv_fss_agent.c
blob4de600fd06c5e39e9dbf62eec6fc079344b4aebb
1 /*
2 * File Server Remote VSS Protocol (FSRVP) server
3 *
4 * Copyright (C) David Disseldorp 2012-2015
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "ntdomain.h"
22 #include "include/messages.h"
23 #include "serverid.h"
24 #include "include/auth.h"
25 #include "../libcli/security/security.h"
26 #include "../libcli/util/hresult.h"
27 #include "../lib/smbconf/smbconf.h"
28 #include "smbd/proto.h"
29 #include "lib/smbconf/smbconf_init.h"
30 #include "librpc/rpc/dcesrv_core.h"
31 #include "librpc/gen_ndr/ndr_fsrvp_scompat.h"
32 #include "librpc/gen_ndr/ndr_fsrvp.h"
33 #include "rpc_server/rpc_server.h"
34 #include "srv_fss_private.h"
35 #include "lib/global_contexts.h"
36
37 #undef DBGC_CLASS
38 #define DBGC_CLASS DBGC_RPC_SRV
39
40 static struct fss_global fss_global;
41
42 /* errmap NTSTATUS->fsrvp */
43 static const struct {
44 NTSTATUS status;
45 uint32_t fsrvp_err;
46 } ntstatus_to_fsrvp_map[] = {
47 {NT_STATUS_INVALID_SERVER_STATE, FSRVP_E_BAD_STATE},
48 {NT_STATUS_INVALID_DISPOSITION, FSRVP_E_SHADOW_COPY_SET_IN_PROGRESS},
49 {NT_STATUS_NOT_SUPPORTED, FSRVP_E_NOT_SUPPORTED},
50 {NT_STATUS_IO_TIMEOUT, FSRVP_E_WAIT_TIMEOUT},
51 {NT_STATUS_CANT_WAIT, FSRVP_E_WAIT_FAILED},
52 {NT_STATUS_OBJECTID_EXISTS, FSRVP_E_OBJECT_ALREADY_EXISTS},
53 {NT_STATUS_OBJECTID_NOT_FOUND, FSRVP_E_OBJECT_NOT_FOUND},
54 {NT_STATUS_OBJECT_NAME_INVALID, FSRVP_E_BAD_ID},
55 };
56
57 /* errmap NTSTATUS->hresult */
58 static const struct {
59 NTSTATUS status;
60 HRESULT hres;
61 } ntstatus_to_hres_map[] = {
62 {NT_STATUS_ACCESS_DENIED, HRES_E_ACCESSDENIED},
63 {NT_STATUS_INVALID_PARAMETER, HRES_E_INVALIDARG},
64 {NT_STATUS_NO_MEMORY, HRES_E_OUTOFMEMORY},
65 };
66
67 static uint32_t fss_ntstatus_map(NTSTATUS status)
68 {
69 size_t i;
70
71 if (NT_STATUS_IS_OK(status))
72 return 0;
73
74 /* check fsrvp specific errors first */
75 for (i = 0; i < ARRAY_SIZE(ntstatus_to_fsrvp_map); i++) {
76 if (NT_STATUS_EQUAL(status, ntstatus_to_fsrvp_map[i].status)) {
77 return ntstatus_to_fsrvp_map[i].fsrvp_err;
78 }
79 }
80 /* fall-back to generic hresult values */
81 for (i = 0; i < ARRAY_SIZE(ntstatus_to_hres_map); i++) {
82 if (NT_STATUS_EQUAL(status, ntstatus_to_hres_map[i].status)) {
83 return HRES_ERROR_V(ntstatus_to_hres_map[i].hres);
84 }
85 }
86
87 return HRES_ERROR_V(HRES_E_FAIL);
88 }
89
90 static NTSTATUS fss_unc_parse(TALLOC_CTX *mem_ctx,
91 const char *unc,
92 char **_server,
93 char **_share)
94 {
95 char *s;
96 char *server;
97 char *share;
98
99 if (unc == NULL) {
100 return NT_STATUS_INVALID_PARAMETER;
101 }
102
103 s = strstr_m(unc, "\\\\");
104 if (s == NULL) {
105 return NT_STATUS_INVALID_PARAMETER;
106 }
107
108 server = talloc_strdup(mem_ctx, s + 2);
109 if (server == NULL) {
110 return NT_STATUS_NO_MEMORY;
111 }
112 s = strchr_m(server, '\\');
113 if ((s == NULL) || (s == server)) {
114 return NT_STATUS_INVALID_PARAMETER;
115 }
116 *s = '\0';
117 share = s + 1;
118
119 s = strchr_m(share, '\\');
120 if (s != NULL) {
121 /* diskshadow.exe adds a trailing '\' to the share-name */
122 *s = '\0';
123 }
124 if (strlen(share) == 0) {
125 return NT_STATUS_INVALID_PARAMETER;
126 }
127
128 if (_server != NULL) {
129 *_server = server;
130 }
131 if (_share != NULL) {
132 *_share = share;
133 }
134
135 return NT_STATUS_OK;
136 }
137
138 static NTSTATUS fss_conn_create_tos(struct messaging_context *msg_ctx,
139 struct auth_session_info *session_info,
140 int snum,
141 struct connection_struct **conn_out);
142
143 /* test if system path exists */
144 static bool snap_path_exists(TALLOC_CTX *ctx, struct messaging_context *msg_ctx,
145 struct fss_sc *sc)
146 {
147 TALLOC_CTX *frame = talloc_stackframe();
148 SMB_STRUCT_STAT st;
149 struct connection_struct *conn = NULL;
150 struct smb_filename *smb_fname = NULL;
151 char *service = NULL;
152 char *share;
153 int snum;
154 int ret;
155 NTSTATUS status;
156 bool result = false;
157
158 ZERO_STRUCT(st);
159
160 if ((sc->smaps_count == 0) || (sc->sc_path == NULL)) {
161 goto out;
162 }
163
164 share = sc->smaps->share_name;
165 snum = find_service(frame, share, &service);
166
167 if ((snum == -1) || (service == NULL)) {
168 goto out;
169 }
170
171 status = fss_conn_create_tos(msg_ctx, NULL, snum, &conn);
172 if(!NT_STATUS_IS_OK(status)) {
173 goto out;
174 }
175
176 smb_fname = synthetic_smb_fname(service,
177 sc->sc_path,
178 NULL,
179 NULL,
180 0,
181 0);
182 if (smb_fname == NULL) {
183 goto out;
184 }
185
186 ret = SMB_VFS_STAT(conn, smb_fname);
187 if ((ret == -1) && (errno == ENOENT)) {
188 goto out;
189 }
190 result = true;
191 out:
192 TALLOC_FREE(frame);
193 return result;
194 }
195
196 static NTSTATUS sc_smap_unexpose(struct messaging_context *msg_ctx,
197 struct fss_sc_smap *sc_smap, bool delete_all);
198
199 static NTSTATUS fss_prune_stale(struct messaging_context *msg_ctx,
200 const char *db_path)
201 {
202 struct fss_sc_set *sc_sets;
203 uint32_t sc_sets_count = 0;
204 struct fss_sc_set *sc_set;
205 struct fss_sc_smap *prunable_sc_smaps = NULL;
206 bool is_modified = false;
207 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
208 TALLOC_CTX *ctx = talloc_new(NULL);
209
210 if (!ctx) {
211 return NT_STATUS_NO_MEMORY;
212 }
213
214 /* work with temporary state for simple cleanup on failure */
215 become_root();
216 status = fss_state_retrieve(ctx, &sc_sets, &sc_sets_count, db_path);
217 unbecome_root();
218 if (!NT_STATUS_IS_OK(status)) {
219 DEBUG(1, ("failed to retrieve fss server state: %s\n",
220 nt_errstr(status)));
221 goto out;
222 }
223
224 /* walk the cache and pick up any entries to be deleted */
225 sc_set = sc_sets;
226 DEBUG(10, ("pruning shared shadow copies\n"));
227 while (sc_set) {
228 struct fss_sc *sc;
229 struct fss_sc_set *sc_set_next = sc_set->next;
230 char *set_id = GUID_string(ctx, &sc_set->id);
231 if (set_id == NULL) {
232 status = NT_STATUS_NO_MEMORY;
233 goto out;
234 }
235 DEBUGADD(10, ("\tprocessing shadow set id %s\n", set_id));
236 sc = sc_set->scs;
237 while (sc) {
238 struct fss_sc_smap *sc_smap;
239 struct fss_sc *sc_next = sc->next;
240 DEBUGADD(10, ("\tprocessing shadow copy path %s\n",
241 sc->sc_path));
242 if (snap_path_exists(ctx, msg_ctx, sc)) {
243 sc = sc_next;
244 continue;
245 }
246
247 /* move missing snapshot state to purge list */
248 sc_smap = sc->smaps;
249 while (sc_smap != NULL) {
250 struct fss_sc_smap *smap_next = sc_smap->next;
251 DLIST_REMOVE(sc->smaps, sc_smap);
252 DLIST_ADD_END(prunable_sc_smaps, sc_smap);
253 sc->smaps_count--;
254 sc_smap = smap_next;
255 }
256
257 DLIST_REMOVE(sc_set->scs, sc);
258 sc_set->scs_count--;
259 is_modified = true;
260 sc = sc_next;
261 }
262 if (sc_set->scs_count == 0) {
263 DLIST_REMOVE(sc_sets, sc_set);
264 sc_sets_count--;
265 }
266 sc_set = sc_set_next;
267 }
268
269 if (is_modified) {
270 /* unexpose all shares in a single transaction */
271 status = sc_smap_unexpose(msg_ctx, prunable_sc_smaps, true);
272 if (!NT_STATUS_IS_OK(status)) {
273 /* exit without storing updated state */
274 goto out;
275 }
276
277 become_root();
278 status = fss_state_store(ctx, sc_sets, sc_sets_count, db_path);
279 unbecome_root();
280 if (!NT_STATUS_IS_OK(status)) {
281 DEBUG(1, ("pruning failed to store fss server state: %s\n",
282 nt_errstr(status)));
283 goto out;
284 }
285 }
286 status = NT_STATUS_OK;
287 out:
288 TALLOC_FREE(ctx);
289 return status;
290 }
291
292 static NTSTATUS fss_conn_create_tos(struct messaging_context *msg_ctx,
293 struct auth_session_info *session_info,
294 int snum,
295 struct connection_struct **conn_out)
296 {
297 const struct loadparm_substitution *lp_sub =
298 loadparm_s3_global_substitution();
299 struct conn_struct_tos *c = NULL;
300 NTSTATUS status;
301
302 status = create_conn_struct_tos(msg_ctx,
303 snum,
304 lp_path(talloc_tos(), lp_sub, snum),
305 session_info,
306 &c);
307 if (!NT_STATUS_IS_OK(status)) {
308 DEBUG(0,("failed to create conn for vfs: %s\n",
309 nt_errstr(status)));
310 return status;
311 }
312
313 status = set_conn_force_user_group(c->conn, snum);
314 if (!NT_STATUS_IS_OK(status)) {
315 DEBUG(0, ("failed set force user / group\n"));
316 TALLOC_FREE(c);
317 return status;
318 }
319
320 *conn_out = c->conn;
321 return NT_STATUS_OK;
322 }
323
324 static struct fss_sc_set *sc_set_lookup(struct fss_sc_set *sc_set_head,
325 struct GUID *sc_set_id)
326 {
327
328 struct fss_sc_set *sc_set;
329 char *guid_str;
330
331 for (sc_set = sc_set_head; sc_set; sc_set = sc_set->next) {
332 if (GUID_equal(&sc_set->id, sc_set_id)) {
333 return sc_set;
334 }
335 }
336 guid_str = GUID_string(sc_set_head, sc_set_id);
337 DEBUG(4, ("shadow copy set with GUID %s not found\n",
338 guid_str ? guid_str : "NO MEM"));
339 talloc_free(guid_str);
340
341 return NULL;
342 }
343
344 static struct fss_sc *sc_lookup(struct fss_sc *sc_head, struct GUID *sc_id)
345 {
346
347 struct fss_sc *sc;
348 char *guid_str;
349
350 for (sc = sc_head; sc; sc = sc->next) {
351 if (GUID_equal(&sc->id, sc_id)) {
352 return sc;
353 }
354 }
355 guid_str = GUID_string(sc_head, sc_id);
356 DEBUG(4, ("shadow copy with GUID %s not found\n",
357 guid_str ? guid_str : "NO MEM"));
358 talloc_free(guid_str);
359
360 return NULL;
361 }
362
363 static struct fss_sc *sc_lookup_volname(struct fss_sc *sc_head,
364 const char *volname)
365 {
366 struct fss_sc *sc;
367
368 for (sc = sc_head; sc; sc = sc->next) {
369 if (!strcmp(sc->volume_name, volname)) {
370 return sc;
371 }
372 }
373 DEBUG(4, ("shadow copy with base volume %s not found\n", volname));
374 return NULL;
375 }
376
377 /* lookup is case-insensitive */
378 static struct fss_sc_smap *sc_smap_lookup(struct fss_sc_smap *smaps_head,
379 const char *share)
380 {
381 struct fss_sc_smap *sc_smap;
382 for (sc_smap = smaps_head; sc_smap; sc_smap = sc_smap->next) {
383 if (!strcasecmp_m(sc_smap->share_name, share)) {
384 return sc_smap;
385 }
386 }
387 DEBUG(4, ("shadow copy share mapping for %s not found\n", share));
388 return NULL;
389 }
390
391 static void srv_fssa_cleanup(void)
392 {
393 talloc_free(fss_global.db_path);
394 talloc_free(fss_global.mem_ctx);
395 ZERO_STRUCT(fss_global);
396 }
397
398 static NTSTATUS srv_fssa_start(struct messaging_context *msg_ctx)
399 {
400 NTSTATUS status;
401 fss_global.mem_ctx = talloc_named_const(NULL, 0,
402 "parent fss rpc server ctx");
403 if (fss_global.mem_ctx == NULL) {
404 return NT_STATUS_NO_MEMORY;
405 }
406
407 fss_global.db_path = lock_path(talloc_tos(), FSS_DB_NAME);
408 if (fss_global.db_path == NULL) {
409 talloc_free(fss_global.mem_ctx);
410 return NT_STATUS_NO_MEMORY;
411 }
412
413 fss_global.min_vers = FSRVP_RPC_VERSION_1;
414 fss_global.max_vers = FSRVP_RPC_VERSION_1;
415 /*
416 * The server MUST populate the GlobalShadowCopySetTable with the
417 * ShadowCopySet entries read from the configuration store.
418 */
419 if (lp_parm_bool(GLOBAL_SECTION_SNUM, "fss", "prune stale", false)) {
420 fss_prune_stale(msg_ctx, fss_global.db_path);
421 }
422 become_root();
423 status = fss_state_retrieve(fss_global.mem_ctx, &fss_global.sc_sets,
424 &fss_global.sc_sets_count,
425 fss_global.db_path);
426 unbecome_root();
427 if (!NT_STATUS_IS_OK(status)) {
428 DEBUG(1, ("failed to retrieve fss server state: %s\n",
429 nt_errstr(status)));
430 }
431 return NT_STATUS_OK;
432 }
433
434 /*
435 * Determine whether to process an FSRVP operation from connected user @p.
436 * Windows checks for Administrators or Backup Operators group membership. We
437 * also allow for the SEC_PRIV_BACKUP privilege.
438 */
439 static bool fss_permitted(struct pipes_struct *p)
440 {
441 struct dcesrv_call_state *dce_call = p->dce_call;
442 struct auth_session_info *session_info =
443 dcesrv_call_session_info(dce_call);
444
445 if (session_info->unix_token->uid == sec_initial_uid()) {
446 DEBUG(6, ("Granting FSRVP op, user started smbd\n"));
447 return true;
448 }
449
450 if (nt_token_check_sid(&global_sid_Builtin_Administrators,
451 session_info->security_token)) {
452 DEBUG(6, ("Granting FSRVP op, administrators group member\n"));
453 return true;
454 }
455 if (nt_token_check_sid(&global_sid_Builtin_Backup_Operators,
456 session_info->security_token)) {
457 DEBUG(6, ("Granting FSRVP op, backup operators group member\n"));
458 return true;
459 }
460 if (security_token_has_privilege(session_info->security_token,
461 SEC_PRIV_BACKUP)) {
462 DEBUG(6, ("Granting FSRVP op, backup privilege present\n"));
463 return true;
464 }
465
466 DEBUG(2, ("FSRVP operation blocked due to lack of backup privilege "
467 "or Administrators/Backup Operators group membership\n"));
468
469 return false;
470 }
471
472 static void fss_seq_tout_handler(struct tevent_context *ev,
473 struct tevent_timer *te,
474 struct timeval t,
475 void *private_data)
476 {
477 struct GUID *sc_set_id = NULL;
478 struct fss_sc_set *sc_set;
479
480 /*
481 * MS-FSRVP: 3.1.5 Timer Events
482 * Message Sequence Timer elapses: When the Message Sequence Timer
483 * elapses, the server MUST delete the ShadowCopySet in the
484 * GlobalShadowCopySetTable where ShadowCopySet.Status is not equal to
485 * "Recovered", ContextSet MUST be set to FALSE, and the ShadowCopySet
486 * object MUST be freed.
487 */
488 DEBUG(2, ("FSRVP msg seq timeout fired\n"));
489
490 if (private_data == NULL) {
491 DEBUG(4, ("timeout without sc_set\n"));
492 goto out_init_ctx;
493 }
494
495 sc_set_id = talloc_get_type_abort(private_data, struct GUID);
496 sc_set = sc_set_lookup(fss_global.sc_sets, sc_set_id);
497 if (sc_set == NULL) {
498 DEBUG(0, ("timeout for unknown sc_set\n"));
499 goto out_init_ctx;
500 } else if ((sc_set->state == FSS_SC_EXPOSED)
501 || (sc_set->state == FSS_SC_RECOVERED)) {
502 DEBUG(2, ("timeout for finished sc_set %s\n", sc_set->id_str));
503 goto out_init_ctx;
504 }
505 DEBUG(2, ("cleaning up sc_set %s\n", sc_set->id_str));
506 SMB_ASSERT(fss_global.sc_sets_count > 0);
507 DLIST_REMOVE(fss_global.sc_sets, sc_set);
508 fss_global.sc_sets_count--;
509 talloc_free(sc_set);
510
511 out_init_ctx:
512 fss_global.ctx_set = false;
513 fss_global.seq_tmr = NULL;
514 talloc_free(sc_set_id);
515 }
516
517 static void fss_seq_tout_set(TALLOC_CTX *mem_ctx,
518 uint32_t timeout_s,
519 struct fss_sc_set *sc_set,
520 struct tevent_timer **tmr_out)
521 {
522 struct tevent_timer *tmr;
523 struct GUID *sc_set_id = NULL;
524 uint32_t tout;
525
526 /* allow changes to timeout for testing/debugging purposes */
527 tout = lp_parm_int(GLOBAL_SECTION_SNUM, "fss",
528 "sequence timeout", timeout_s);
529 if (tout == 0) {
530 DEBUG(2, ("FSRVP message sequence timeout disabled\n"));
531 *tmr_out = NULL;
532 return;
533 }
534
535 if (sc_set) {
536 /* don't use talloc_memdup(), need explicit type for callback */
537 sc_set_id = talloc(mem_ctx, struct GUID);
538 if (sc_set_id == NULL) {
539 smb_panic("no memory");
540 }
541 memcpy(sc_set_id, &sc_set->id, sizeof(*sc_set_id));
542 }
543
544 tmr = tevent_add_timer(global_event_context(),
545 mem_ctx,
546 timeval_current_ofs(tout, 0),
547 fss_seq_tout_handler, sc_set_id);
548 if (tmr == NULL) {
549 talloc_free(sc_set_id);
550 smb_panic("no memory");
551 }
552
553 *tmr_out = tmr;
554 }
555
556 uint32_t _fss_GetSupportedVersion(struct pipes_struct *p,
557 struct fss_GetSupportedVersion *r)
558 {
559 if (!fss_permitted(p)) {
560 return HRES_ERROR_V(HRES_E_ACCESSDENIED);
561 }
562
563 *r->out.MinVersion = fss_global.min_vers;
564 *r->out.MaxVersion = fss_global.max_vers;
565
566 return 0;
567 }
568
569 uint32_t _fss_SetContext(struct pipes_struct *p,
570 struct fss_SetContext *r)
571 {
572 if (!fss_permitted(p)) {
573 return HRES_ERROR_V(HRES_E_ACCESSDENIED);
574 }
575
576 /* ATTR_AUTO_RECOVERY flag can be applied to any */
577 switch (r->in.Context & (~ATTR_AUTO_RECOVERY)) {
578 case FSRVP_CTX_BACKUP:
579 DEBUG(6, ("fss ctx set backup\n"));
580 break;
581 case FSRVP_CTX_FILE_SHARE_BACKUP:
582 DEBUG(6, ("fss ctx set file share backup\n"));
583 break;
584 case FSRVP_CTX_NAS_ROLLBACK:
585 DEBUG(6, ("fss ctx set nas rollback\n"));
586 break;
587 case FSRVP_CTX_APP_ROLLBACK:
588 DEBUG(6, ("fss ctx set app rollback\n"));
589 break;
590 default:
591 DEBUG(0, ("invalid fss ctx set value: 0x%x\n", r->in.Context));
592 return HRES_ERROR_V(HRES_E_INVALIDARG);
593 break; /* not reached */
594 }
595
596 fss_global.ctx_set = true;
597 fss_global.cur_ctx = r->in.Context;
598
599 TALLOC_FREE(fss_global.seq_tmr); /* kill timer if running */
600 fss_seq_tout_set(fss_global.mem_ctx, 180, NULL, &fss_global.seq_tmr);
601
602 fss_global.cur_ctx = r->in.Context;
603
604 return 0;
605 }
606
607 static bool sc_set_active(struct fss_sc_set *sc_set_head)
608 {
609
610 struct fss_sc_set *sc_set;
611
612 for (sc_set = sc_set_head; sc_set; sc_set = sc_set->next) {
613 if ((sc_set->state != FSS_SC_EXPOSED)
614 && (sc_set->state != FSS_SC_RECOVERED)) {
615 return true;
616 }
617 }
618
619 return false;
620 }
621
622 uint32_t _fss_StartShadowCopySet(struct pipes_struct *p,
623 struct fss_StartShadowCopySet *r)
624 {
625 struct fss_sc_set *sc_set;
626 uint32_t ret;
627
628 if (!fss_permitted(p)) {
629 ret = HRES_ERROR_V(HRES_E_ACCESSDENIED);
630 goto err_out;
631 }
632
633 if (!fss_global.ctx_set) {
634 DEBUG(3, ("invalid sequence: start sc set requested without "
635 "prior context set\n"));
636 ret = FSRVP_E_BAD_STATE;
637 goto err_out;
638 }
639
640 /*
641 * At any given time, Windows servers allow only one shadow copy set to
642 * be going through the creation process.
643 */
644 if (sc_set_active(fss_global.sc_sets)) {
645 DEBUG(3, ("StartShadowCopySet called while in progress\n"));
646 ret = FSRVP_E_SHADOW_COPY_SET_IN_PROGRESS;
647 goto err_out;
648 }
649
650 /* stop msg seq timer */
651 TALLOC_FREE(fss_global.seq_tmr);
652
653 sc_set = talloc_zero(fss_global.mem_ctx, struct fss_sc_set);
654 if (sc_set == NULL) {
655 ret = HRES_ERROR_V(HRES_E_OUTOFMEMORY);
656 goto err_tmr_restart;
657 }
658
659 sc_set->id = GUID_random(); /* Windows servers ignore client ids */
660 sc_set->id_str = GUID_string(sc_set, &sc_set->id);
661 if (sc_set->id_str == NULL) {
662 ret = HRES_ERROR_V(HRES_E_OUTOFMEMORY);
663 goto err_sc_set_free;
664 }
665 sc_set->state = FSS_SC_STARTED;
666 sc_set->context = fss_global.cur_ctx;
667 DLIST_ADD_END(fss_global.sc_sets, sc_set);
668 fss_global.sc_sets_count++;
669 DEBUG(6, ("%s: shadow-copy set %u added\n",
670 sc_set->id_str, fss_global.sc_sets_count));
671
672 /* start msg seq timer */
673 fss_seq_tout_set(fss_global.mem_ctx, 180, sc_set, &fss_global.seq_tmr);
674
675 r->out.pShadowCopySetId = &sc_set->id;
676
677 return 0;
678
679 err_sc_set_free:
680 talloc_free(sc_set);
681 err_tmr_restart:
682 fss_seq_tout_set(fss_global.mem_ctx, 180, NULL, &fss_global.seq_tmr);
683 err_out:
684 return ret;
685 }
686
687 static uint32_t map_share_name(struct fss_sc_smap *sc_smap,
688 const struct fss_sc *sc)
689 {
690 bool hidden_base = false;
691
692 if (*(sc_smap->share_name + strlen(sc_smap->share_name) - 1) == '$') {
693 /*
694 * If MappedShare.ShareName ends with a $ character (meaning
695 * that the share is hidden), then the exposed share name will
696 * have the $ suffix appended.
697 * FIXME: turns out Windows doesn't do this, contrary to docs
698 */
699 hidden_base = true;
700 }
701
702 sc_smap->sc_share_name = talloc_asprintf(sc_smap, "%s@{%s}%s",
703 sc_smap->share_name,
704 sc->id_str,
705 hidden_base ? "$" : "");
706 if (sc_smap->sc_share_name == NULL) {
707 return HRES_ERROR_V(HRES_E_OUTOFMEMORY);
708 }
709
710 return 0;
711 }
712
713 static uint32_t map_share_comment(struct fss_sc_smap *sc_smap,
714 const struct fss_sc *sc)
715 {
716 char *time_str;
717
718 time_str = http_timestring(sc_smap, sc->create_ts);
719 if (time_str == NULL) {
720 return HRES_ERROR_V(HRES_E_OUTOFMEMORY);
721 }
722
723 sc_smap->sc_share_comment = talloc_asprintf(sc_smap, "Shadow copy of %s taken %s",
724 sc_smap->share_name, time_str);
725 if (sc_smap->sc_share_comment == NULL) {
726 return HRES_ERROR_V(HRES_E_OUTOFMEMORY);
727 }
728
729 return 0;
730 }
731
732 uint32_t _fss_AddToShadowCopySet(struct pipes_struct *p,
733 struct fss_AddToShadowCopySet *r)
734 {
735 struct dcesrv_call_state *dce_call = p->dce_call;
736 struct auth_session_info *session_info =
737 dcesrv_call_session_info(dce_call);
738 uint32_t ret;
739 struct fss_sc_set *sc_set;
740 struct fss_sc *sc;
741 struct fss_sc_smap *sc_smap;
742 int snum;
743 char *service;
744 char *base_vol;
745 char *share;
746 char *path_name;
747 struct connection_struct *conn;
748 NTSTATUS status;
749 TALLOC_CTX *frame = talloc_stackframe();
750 const struct loadparm_substitution *lp_sub =
751 loadparm_s3_global_substitution();
752
753 if (!fss_permitted(p)) {
754 ret = HRES_ERROR_V(HRES_E_ACCESSDENIED);
755 goto err_tmp_free;
756 }
757
758 sc_set = sc_set_lookup(fss_global.sc_sets, &r->in.ShadowCopySetId);
759 if (sc_set == NULL) {
760 ret = HRES_ERROR_V(HRES_E_INVALIDARG);
761 goto err_tmp_free;
762 }
763
764 status = fss_unc_parse(frame, r->in.ShareName, NULL, &share);
765 if (!NT_STATUS_IS_OK(status)) {
766 ret = fss_ntstatus_map(status);
767 goto err_tmp_free;
768 }
769
770 snum = find_service(frame, share, &service);
771 if ((snum == -1) || (service == NULL)) {
772 DEBUG(0, ("share at %s not found\n", r->in.ShareName));
773 ret = HRES_ERROR_V(HRES_E_INVALIDARG);
774 goto err_tmp_free;
775 }
776
777 path_name = lp_path(frame, lp_sub, snum);
778 if (path_name == NULL) {
779 ret = HRES_ERROR_V(HRES_E_OUTOFMEMORY);
780 goto err_tmp_free;
781 }
782
783 status = fss_conn_create_tos(p->msg_ctx, session_info, snum, &conn);
784 if (!NT_STATUS_IS_OK(status)) {
785 ret = HRES_ERROR_V(HRES_E_ACCESSDENIED);
786 goto err_tmp_free;
787 }
788 if (!become_user_without_service_by_session(conn, session_info)) {
789 DEBUG(0, ("failed to become user\n"));
790 ret = HRES_ERROR_V(HRES_E_ACCESSDENIED);
791 goto err_tmp_free;
792 }
793
794 status = SMB_VFS_SNAP_CHECK_PATH(conn, frame, path_name, &base_vol);
795 unbecome_user_without_service();
796 if (!NT_STATUS_IS_OK(status)) {
797 ret = FSRVP_E_NOT_SUPPORTED;
798 goto err_tmp_free;
799 }
800
801 if ((sc_set->state != FSS_SC_STARTED)
802 && (sc_set->state != FSS_SC_ADDED)) {
803 ret = FSRVP_E_BAD_STATE;
804 goto err_tmp_free;
805 }
806
807 /* stop msg seq timer */
808 TALLOC_FREE(fss_global.seq_tmr);
809
810 /*
811 * server MUST look up the ShadowCopy in ShadowCopySet.ShadowCopyList
812 * where ShadowCopy.VolumeName matches the file store on which the
813 * share identified by ShareName is hosted. If an entry is found, the
814 * server MUST fail the call with FSRVP_E_OBJECT_ALREADY_EXISTS.
815 * If no entry is found, the server MUST create a new ShadowCopy
816 * object
817 * XXX Windows appears to allow multiple mappings for the same vol!
818 */
819 sc = sc_lookup_volname(sc_set->scs, base_vol);
820 if (sc != NULL) {
821 ret = FSRVP_E_OBJECT_ALREADY_EXISTS;
822 goto err_tmr_restart;
823 }
824
825 sc = talloc_zero(sc_set, struct fss_sc);
826 if (sc == NULL) {
827 ret = HRES_ERROR_V(HRES_E_OUTOFMEMORY);
828 goto err_tmr_restart;
829 }
830 talloc_steal(sc, base_vol);
831 sc->volume_name = base_vol;
832 sc->sc_set = sc_set;
833 sc->create_ts = time(NULL);
834
835 sc->id = GUID_random(); /* Windows servers ignore client ids */
836 sc->id_str = GUID_string(sc, &sc->id);
837 if (sc->id_str == NULL) {
838 ret = HRES_ERROR_V(HRES_E_OUTOFMEMORY);
839 goto err_sc_free;
840 }
841
842 sc_smap = talloc_zero(sc, struct fss_sc_smap);
843 if (sc_smap == NULL) {
844 ret = HRES_ERROR_V(HRES_E_OUTOFMEMORY);
845 goto err_sc_free;
846 }
847
848 talloc_steal(sc_smap, service);
849 sc_smap->share_name = service;
850 sc_smap->is_exposed = false;
851 /*
852 * generate the sc_smap share name now. It is a unique identifier for
853 * the smap used as a tdb key for state storage.
854 */
855 ret = map_share_name(sc_smap, sc);
856 if (ret) {
857 goto err_sc_free;
858 }
859
860 /* add share map to shadow-copy */
861 DLIST_ADD_END(sc->smaps, sc_smap);
862 sc->smaps_count++;
863 /* add shadow-copy to shadow-copy set */
864 DLIST_ADD_END(sc_set->scs, sc);
865 sc_set->scs_count++;
866 DEBUG(4, ("added volume %s to shadow copy set with GUID %s\n",
867 sc->volume_name, sc_set->id_str));
868
869 /* start the Message Sequence Timer with timeout of 1800 seconds */
870 fss_seq_tout_set(fss_global.mem_ctx, 1800, sc_set, &fss_global.seq_tmr);
871
872 sc_set->state = FSS_SC_ADDED;
873 r->out.pShadowCopyId = &sc->id;
874
875 TALLOC_FREE(frame);
876 return 0;
877
878 err_sc_free:
879 talloc_free(sc);
880 err_tmr_restart:
881 fss_seq_tout_set(fss_global.mem_ctx, 180, sc_set, &fss_global.seq_tmr);
882 err_tmp_free:
883 TALLOC_FREE(frame);
884 return ret;
885 }
886
887 static NTSTATUS commit_sc_with_conn(TALLOC_CTX *mem_ctx,
888 struct tevent_context *ev,
889 struct messaging_context *msg_ctx,
890 struct auth_session_info *session_info,
891 struct fss_sc *sc,
892 char **base_path,
893 char **snap_path)
894 {
895 TALLOC_CTX *frame = talloc_stackframe();
896 NTSTATUS status;
897 bool rw;
898 struct connection_struct *conn;
899 int snum;
900 char *service;
901
902 snum = find_service(frame, sc->smaps->share_name, &service);
903 if ((snum == -1) || (service == NULL)) {
904 DEBUG(0, ("share at %s not found\n", sc->smaps->share_name));
905 TALLOC_FREE(frame);
906 return NT_STATUS_UNSUCCESSFUL;
907 }
908
909 status = fss_conn_create_tos(msg_ctx, session_info, snum, &conn);
910 if (!NT_STATUS_IS_OK(status)) {
911 TALLOC_FREE(frame);
912 return status;
913 }
914
915 if (!become_user_without_service_by_session(conn, session_info)) {
916 DEBUG(0, ("failed to become user\n"));
917 TALLOC_FREE(frame);
918 return NT_STATUS_ACCESS_DENIED;
919 }
920 rw = ((sc->sc_set->context & ATTR_AUTO_RECOVERY) == ATTR_AUTO_RECOVERY);
921 status = SMB_VFS_SNAP_CREATE(conn, mem_ctx,
922 sc->volume_name,
923 &sc->create_ts, rw,
924 base_path, snap_path);
925 unbecome_user_without_service();
926 if (!NT_STATUS_IS_OK(status)) {
927 DEBUG(0, ("snap create failed: %s\n", nt_errstr(status)));
928 TALLOC_FREE(frame);
929 return status;
930 }
931
932 TALLOC_FREE(frame);
933 return status;
934 }
935
936 uint32_t _fss_CommitShadowCopySet(struct pipes_struct *p,
937 struct fss_CommitShadowCopySet *r)
938 {
939 struct dcesrv_call_state *dce_call = p->dce_call;
940 struct auth_session_info *session_info =
941 dcesrv_call_session_info(dce_call);
942 struct fss_sc_set *sc_set;
943 struct fss_sc *sc;
944 uint32_t commit_count;
945 NTSTATUS status;
946 NTSTATUS saved_status;
947 TALLOC_CTX *frame = talloc_stackframe();
948
949 if (!fss_permitted(p)) {
950 status = NT_STATUS_ACCESS_DENIED;
951 goto err_tmp_free;
952 }
953
954 sc_set = sc_set_lookup(fss_global.sc_sets, &r->in.ShadowCopySetId);
955 if (sc_set == NULL) {
956 status = NT_STATUS_INVALID_PARAMETER;
957 goto err_tmp_free;
958 }
959
960 if (sc_set->state != FSS_SC_ADDED) {
961 status = NT_STATUS_INVALID_SERVER_STATE;
962 goto err_tmp_free;
963 }
964
965 /* stop Message Sequence Timer */
966 TALLOC_FREE(fss_global.seq_tmr);
967 sc_set->state = FSS_SC_CREATING;
968 commit_count = 0;
969 saved_status = NT_STATUS_OK;
970 for (sc = sc_set->scs; sc; sc = sc->next) {
971 char *base_path;
972 char *snap_path;
973 status = commit_sc_with_conn(frame, global_event_context(),
974 p->msg_ctx, session_info, sc,
975 &base_path, &snap_path);
976 if (!NT_STATUS_IS_OK(status)) {
977 DEBUG(0, ("snap create failed for shadow copy of "
978 "%s\n", sc->volume_name));
979 /* dispatch all scs in set, but retain last error */
980 saved_status = status;
981 continue;
982 }
983 /* XXX set timeout r->in.TimeOutInMilliseconds */
984 commit_count++;
985 DEBUG(10, ("good snap create %d\n",
986 commit_count));
987 sc->sc_path = talloc_steal(sc, snap_path);
988 }
989 if (!NT_STATUS_IS_OK(saved_status)) {
990 status = saved_status;
991 goto err_state_revert;
992 }
993
994 sc_set->state = FSS_SC_COMMITED;
995 become_root();
996 status = fss_state_store(fss_global.mem_ctx, fss_global.sc_sets,
997 fss_global.sc_sets_count,
998 fss_global.db_path);
999 unbecome_root();
1000 if (!NT_STATUS_IS_OK(status)) {
1001 DEBUG(1, ("failed to store fss server state: %s\n",
1002 nt_errstr(status)));
1003 }
1004
1005 fss_seq_tout_set(fss_global.mem_ctx, 180, sc_set,
1006 &fss_global.seq_tmr);
1007 TALLOC_FREE(frame);
1008 return 0;
1009
1010 err_state_revert:
1011 sc_set->state = FSS_SC_ADDED;
1012 fss_seq_tout_set(fss_global.mem_ctx, 180, sc_set,
1013 &fss_global.seq_tmr);
1014 err_tmp_free:
1015 TALLOC_FREE(frame);
1016 return fss_ntstatus_map(status);
1017 }
1018
1019 static sbcErr fss_conf_get_share_def(struct smbconf_ctx *fconf_ctx,
1020 struct smbconf_ctx *rconf_ctx,
1021 TALLOC_CTX *mem_ctx,
1022 char *share,
1023 struct smbconf_service **service_def)
1024 {
1025 sbcErr cerr;
1026 struct smbconf_service *def;
1027
1028 *service_def = NULL;
1029 cerr = smbconf_get_share(fconf_ctx, mem_ctx, share, &def);
1030 if (SBC_ERROR_IS_OK(cerr)) {
1031 *service_def = def;
1032 return SBC_ERR_OK;
1033 }
1034
1035 cerr = smbconf_get_share(rconf_ctx, mem_ctx, share, &def);
1036 if (SBC_ERROR_IS_OK(cerr)) {
1037 *service_def = def;
1038 return SBC_ERR_OK;
1039 }
1040 return cerr;
1041 }
1042
1043 /*
1044 * Expose a new share using libsmbconf, cloning the existing configuration
1045 * from the base share. The base share may be defined in either the registry
1046 * or smb.conf.
1047 * XXX this is called as root
1048 */
1049 static uint32_t fss_sc_expose(struct smbconf_ctx *fconf_ctx,
1050 struct smbconf_ctx *rconf_ctx,
1051 TALLOC_CTX *mem_ctx,
1052 struct fss_sc *sc)
1053 {
1054 struct fss_sc_smap *sc_smap;
1055 uint32_t err = 0;
1056
1057 for (sc_smap = sc->smaps; sc_smap; sc_smap = sc_smap->next) {
1058 sbcErr cerr;
1059 struct smbconf_service *base_service = NULL;
1060 struct security_descriptor *sd;
1061 size_t sd_size;
1062
1063 cerr = fss_conf_get_share_def(fconf_ctx, rconf_ctx, mem_ctx,
1064 sc_smap->share_name, &base_service);
1065 if (!SBC_ERROR_IS_OK(cerr)) {
1066 DEBUG(0, ("failed to get base share %s definition: "
1067 "%s\n", sc_smap->share_name,
1068 sbcErrorString(cerr)));
1069 err = HRES_ERROR_V(HRES_E_FAIL);
1070 break;
1071 }
1072
1073 /* smap share name already defined when added */
1074 err = map_share_comment(sc_smap, sc);
1075 if (err) {
1076 DEBUG(0, ("failed to map share comment\n"));
1077 break;
1078 }
1079
1080 base_service->name = sc_smap->sc_share_name;
1081
1082 cerr = smbconf_create_set_share(rconf_ctx, base_service);
1083 if (!SBC_ERROR_IS_OK(cerr)) {
1084 DEBUG(0, ("failed to create share %s: %s\n",
1085 base_service->name, sbcErrorString(cerr)));
1086 err = HRES_ERROR_V(HRES_E_FAIL);
1087 break;
1088 }
1089 cerr = smbconf_set_parameter(rconf_ctx, sc_smap->sc_share_name,
1090 "path", sc->sc_path);
1091 if (!SBC_ERROR_IS_OK(cerr)) {
1092 DEBUG(0, ("failed to set path param: %s\n",
1093 sbcErrorString(cerr)));
1094 err = HRES_ERROR_V(HRES_E_FAIL);
1095 break;
1096 }
1097 if (sc_smap->sc_share_comment != NULL) {
1098 cerr = smbconf_set_parameter(rconf_ctx,
1099 sc_smap->sc_share_name,
1100 "comment",
1101 sc_smap->sc_share_comment);
1102 if (!SBC_ERROR_IS_OK(cerr)) {
1103 DEBUG(0, ("failed to set comment param: %s\n",
1104 sbcErrorString(cerr)));
1105 err = HRES_ERROR_V(HRES_E_FAIL);
1106 break;
1107 }
1108 }
1109 talloc_free(base_service);
1110
1111 /*
1112 * Obtain the base share SD, which also needs to be cloned.
1113 * Share SDs are stored in share_info.tdb, so are not covered by
1114 * the registry transaction.
1115 * The base share SD should be cloned at the time of exposure,
1116 * rather than when the snapshot is taken. This matches Windows
1117 * Server 2012 behaviour.
1118 */
1119 sd = get_share_security(mem_ctx, sc_smap->share_name, &sd_size);
1120 if (sd == NULL) {
1121 DEBUG(2, ("no share SD to clone for %s snapshot\n",
1122 sc_smap->share_name));
1123 } else {
1124 NTSTATUS status;
1125 status = set_share_security(sc_smap->sc_share_name, sd);
1126 TALLOC_FREE(sd);
1127 if (!NT_STATUS_IS_OK(status)) {
1128 DEBUG(0, ("failed to set %s share SD\n",
1129 sc_smap->sc_share_name));
1130 err = HRES_ERROR_V(HRES_E_FAIL);
1131 break;
1132 }
1133 }
1134 }
1135
1136 return err;
1137 }
1138
1139 uint32_t _fss_ExposeShadowCopySet(struct pipes_struct *p,
1140 struct fss_ExposeShadowCopySet *r)
1141 {
1142 NTSTATUS status;
1143 struct fss_sc_set *sc_set;
1144 struct fss_sc *sc;
1145 uint32_t ret;
1146 struct smbconf_ctx *fconf_ctx;
1147 struct smbconf_ctx *rconf_ctx;
1148 sbcErr cerr;
1149 char *fconf_path;
1150 TALLOC_CTX *frame = talloc_stackframe();
1151
1152 if (!fss_permitted(p)) {
1153 ret = HRES_ERROR_V(HRES_E_ACCESSDENIED);
1154 goto err_out;
1155 }
1156
1157 sc_set = sc_set_lookup(fss_global.sc_sets, &r->in.ShadowCopySetId);
1158 if (sc_set == NULL) {
1159 ret = HRES_ERROR_V(HRES_E_INVALIDARG);
1160 goto err_out;
1161 }
1162
1163 if (sc_set->state != FSS_SC_COMMITED) {
1164 ret = FSRVP_E_BAD_STATE;
1165 goto err_out;
1166 }
1167
1168 /* stop message sequence timer */
1169 TALLOC_FREE(fss_global.seq_tmr);
1170
1171 /*
1172 * Prepare to clone the base share definition for the snapshot share.
1173 * Create both registry and file conf contexts, as the base share
1174 * definition may be located in either. The snapshot share definition
1175 * is always written to the registry.
1176 */
1177 cerr = smbconf_init(frame, &rconf_ctx, "registry");
1178 if (!SBC_ERROR_IS_OK(cerr)) {
1179 DEBUG(0, ("failed registry smbconf init: %s\n",
1180 sbcErrorString(cerr)));
1181 ret = HRES_ERROR_V(HRES_E_FAIL);
1182 goto err_tmr_restart;
1183 }
1184 fconf_path = talloc_asprintf(frame, "file:%s", get_dyn_CONFIGFILE());
1185 if (fconf_path == NULL) {
1186 ret = HRES_ERROR_V(HRES_E_OUTOFMEMORY);
1187 goto err_tmr_restart;
1188 }
1189 cerr = smbconf_init(frame, &fconf_ctx, fconf_path);
1190 if (!SBC_ERROR_IS_OK(cerr)) {
1191 DEBUG(0, ("failed %s smbconf init: %s\n",
1192 fconf_path, sbcErrorString(cerr)));
1193 ret = HRES_ERROR_V(HRES_E_FAIL);
1194 goto err_tmr_restart;
1195 }
1196
1197 /* registry IO must be done as root */
1198 become_root();
1199 cerr = smbconf_transaction_start(rconf_ctx);
1200 if (!SBC_ERROR_IS_OK(cerr)) {
1201 DEBUG(0, ("error starting transaction: %s\n",
1202 sbcErrorString(cerr)));
1203 ret = HRES_ERROR_V(HRES_E_FAIL);
1204 unbecome_root();
1205 goto err_tmr_restart;
1206 }
1207
1208 for (sc = sc_set->scs; sc; sc = sc->next) {
1209 ret = fss_sc_expose(fconf_ctx, rconf_ctx, frame, sc);
1210 if (ret) {
1211 DEBUG(0,("failed to expose shadow copy of %s\n",
1212 sc->volume_name));
1213 goto err_cancel;
1214 }
1215 }
1216
1217 cerr = smbconf_transaction_commit(rconf_ctx);
1218 if (!SBC_ERROR_IS_OK(cerr)) {
1219 DEBUG(0, ("error committing transaction: %s\n",
1220 sbcErrorString(cerr)));
1221 ret = HRES_ERROR_V(HRES_E_FAIL);
1222 goto err_cancel;
1223 }
1224 unbecome_root();
1225
1226 messaging_send_all(p->msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0);
1227 for (sc = sc_set->scs; sc; sc = sc->next) {
1228 struct fss_sc_smap *sm;
1229 for (sm = sc->smaps; sm; sm = sm->next)
1230 sm->is_exposed = true;
1231 }
1232 sc_set->state = FSS_SC_EXPOSED;
1233 become_root();
1234 status = fss_state_store(fss_global.mem_ctx, fss_global.sc_sets,
1235 fss_global.sc_sets_count, fss_global.db_path);
1236 unbecome_root();
1237 if (!NT_STATUS_IS_OK(status)) {
1238 DEBUG(1, ("failed to store fss server state: %s\n",
1239 nt_errstr(status)));
1240 }
1241 /* start message sequence timer */
1242 fss_seq_tout_set(fss_global.mem_ctx, 180, sc_set, &fss_global.seq_tmr);
1243 TALLOC_FREE(frame);
1244 return 0;
1245
1246 err_cancel:
1247 smbconf_transaction_cancel(rconf_ctx);
1248 unbecome_root();
1249 err_tmr_restart:
1250 fss_seq_tout_set(fss_global.mem_ctx, 180, sc_set, &fss_global.seq_tmr);
1251 err_out:
1252 TALLOC_FREE(frame);
1253 return ret;
1254 }
1255
1256 uint32_t _fss_RecoveryCompleteShadowCopySet(struct pipes_struct *p,
1257 struct fss_RecoveryCompleteShadowCopySet *r)
1258 {
1259 NTSTATUS status;
1260 struct fss_sc_set *sc_set;
1261
1262 if (!fss_permitted(p)) {
1263 return HRES_ERROR_V(HRES_E_ACCESSDENIED);
1264 }
1265
1266 sc_set = sc_set_lookup(fss_global.sc_sets, &r->in.ShadowCopySetId);
1267 if (sc_set == NULL) {
1268 return HRES_ERROR_V(HRES_E_INVALIDARG);
1269 }
1270
1271 if (sc_set->state != FSS_SC_EXPOSED) {
1272 return FSRVP_E_BAD_STATE;
1273 }
1274
1275 /* stop msg sequence timer */
1276 TALLOC_FREE(fss_global.seq_tmr);
1277
1278 if (sc_set->context & ATTR_NO_AUTO_RECOVERY) {
1279 /* TODO set read-only */
1280 }
1281
1282 sc_set->state = FSS_SC_RECOVERED;
1283 fss_global.cur_ctx = 0;
1284 fss_global.ctx_set = false;
1285
1286 become_root();
1287 status = fss_state_store(fss_global.mem_ctx, fss_global.sc_sets,
1288 fss_global.sc_sets_count, fss_global.db_path);
1289 unbecome_root();
1290 if (!NT_STATUS_IS_OK(status)) {
1291 DEBUG(1, ("failed to store fss server state: %s\n",
1292 nt_errstr(status)));
1293 }
1294
1295 return 0;
1296 }
1297
1298 uint32_t _fss_AbortShadowCopySet(struct pipes_struct *p,
1299 struct fss_AbortShadowCopySet *r)
1300 {
1301 NTSTATUS status;
1302 struct fss_sc_set *sc_set;
1303
1304 if (!fss_permitted(p)) {
1305 return HRES_ERROR_V(HRES_E_ACCESSDENIED);
1306 }
1307
1308 sc_set = sc_set_lookup(fss_global.sc_sets, &r->in.ShadowCopySetId);
1309 if (sc_set == NULL) {
1310 return HRES_ERROR_V(HRES_E_INVALIDARG);
1311 }
1312
1313 DEBUG(6, ("%s: aborting shadow-copy set\n", sc_set->id_str));
1314
1315 if ((sc_set->state == FSS_SC_COMMITED)
1316 || (sc_set->state == FSS_SC_EXPOSED)
1317 || (sc_set->state == FSS_SC_RECOVERED)) {
1318 return 0;
1319 }
1320
1321 if (sc_set->state == FSS_SC_CREATING) {
1322 return FSRVP_E_BAD_STATE;
1323 }
1324
1325 DLIST_REMOVE(fss_global.sc_sets, sc_set);
1326 talloc_free(sc_set);
1327 fss_global.sc_sets_count--;
1328 become_root();
1329 status = fss_state_store(fss_global.mem_ctx, fss_global.sc_sets,
1330 fss_global.sc_sets_count, fss_global.db_path);
1331 unbecome_root();
1332 if (!NT_STATUS_IS_OK(status)) {
1333 DEBUG(1, ("failed to store fss server state: %s\n",
1334 nt_errstr(status)));
1335 }
1336
1337 return 0;
1338 }
1339
1340 uint32_t _fss_IsPathSupported(struct pipes_struct *p,
1341 struct fss_IsPathSupported *r)
1342 {
1343 struct dcesrv_call_state *dce_call = p->dce_call;
1344 struct auth_session_info *session_info =
1345 dcesrv_call_session_info(dce_call);
1346 int snum;
1347 char *service;
1348 char *base_vol;
1349 NTSTATUS status;
1350 struct connection_struct *conn;
1351 char *share;
1352 TALLOC_CTX *frame = talloc_stackframe();
1353 const struct loadparm_substitution *lp_sub =
1354 loadparm_s3_global_substitution();
1355
1356 if (!fss_permitted(p)) {
1357 TALLOC_FREE(frame);
1358 return HRES_ERROR_V(HRES_E_ACCESSDENIED);
1359 }
1360
1361 status = fss_unc_parse(frame, r->in.ShareName, NULL, &share);
1362 if (!NT_STATUS_IS_OK(status)) {
1363 TALLOC_FREE(frame);
1364 return fss_ntstatus_map(status);
1365 }
1366
1367 snum = find_service(frame, share, &service);
1368 if ((snum == -1) || (service == NULL)) {
1369 DEBUG(0, ("share at %s not found\n", r->in.ShareName));
1370 TALLOC_FREE(frame);
1371 return HRES_ERROR_V(HRES_E_INVALIDARG);
1372 }
1373
1374 status = fss_conn_create_tos(p->msg_ctx, session_info, snum, &conn);
1375 if (!NT_STATUS_IS_OK(status)) {
1376 TALLOC_FREE(frame);
1377 return HRES_ERROR_V(HRES_E_ACCESSDENIED);
1378 }
1379 if (!become_user_without_service_by_session(conn, session_info)) {
1380 DEBUG(0, ("failed to become user\n"));
1381 TALLOC_FREE(frame);
1382 return HRES_ERROR_V(HRES_E_ACCESSDENIED);
1383 }
1384 status = SMB_VFS_SNAP_CHECK_PATH(conn, frame,
1385 lp_path(frame, lp_sub, snum),
1386 &base_vol);
1387 unbecome_user_without_service();
1388 if (!NT_STATUS_IS_OK(status)) {
1389 TALLOC_FREE(frame);
1390 return FSRVP_E_NOT_SUPPORTED;
1391 }
1392
1393 *r->out.OwnerMachineName = lp_netbios_name();
1394 *r->out.SupportedByThisProvider = 1;
1395 TALLOC_FREE(frame);
1396 return 0;
1397 }
1398
1399 uint32_t _fss_IsPathShadowCopied(struct pipes_struct *p,
1400 struct fss_IsPathShadowCopied *r)
1401 {
1402 if (!fss_permitted(p)) {
1403 return HRES_ERROR_V(HRES_E_ACCESSDENIED);
1404 }
1405
1406 /* not yet supported */
1407 return FSRVP_E_NOT_SUPPORTED;
1408 }
1409
1410 uint32_t _fss_GetShareMapping(struct pipes_struct *p,
1411 struct fss_GetShareMapping *r)
1412 {
1413 NTSTATUS status;
1414 struct fss_sc_set *sc_set;
1415 struct fss_sc *sc;
1416 struct fss_sc_smap *sc_smap;
1417 char *share;
1418 struct fssagent_share_mapping_1 *sm_out;
1419 TALLOC_CTX *frame = talloc_stackframe();
1420
1421 if (!fss_permitted(p)) {
1422 TALLOC_FREE(frame);
1423 return HRES_ERROR_V(HRES_E_ACCESSDENIED);
1424 }
1425
1426 sc_set = sc_set_lookup(fss_global.sc_sets, &r->in.ShadowCopySetId);
1427 if (sc_set == NULL) {
1428 TALLOC_FREE(frame);
1429 return HRES_ERROR_V(HRES_E_INVALIDARG);
1430 }
1431
1432 /*
1433 * If ShadowCopySet.Status is not "Exposed", the server SHOULD<9> fail
1434 * the call with FSRVP_E_BAD_STATE.
1435 * <9> If ShadowCopySet.Status is "Started", "Added",
1436 * "CreationInProgress", or "Committed", Windows Server 2012 FSRVP
1437 * servers return an error value of 0x80042311.
1438 */
1439 if ((sc_set->state == FSS_SC_STARTED)
1440 || (sc_set->state == FSS_SC_ADDED)
1441 || (sc_set->state == FSS_SC_CREATING)
1442 || (sc_set->state == FSS_SC_COMMITED)) {
1443 TALLOC_FREE(frame);
1444 return 0x80042311; /* documented magic value */
1445 }
1446
1447 sc = sc_lookup(sc_set->scs, &r->in.ShadowCopyId);
1448 if (sc == NULL) {
1449 TALLOC_FREE(frame);
1450 return HRES_ERROR_V(HRES_E_INVALIDARG);
1451 }
1452
1453 status = fss_unc_parse(frame, r->in.ShareName, NULL, &share);
1454 if (!NT_STATUS_IS_OK(status)) {
1455 TALLOC_FREE(frame);
1456 return fss_ntstatus_map(status);
1457 }
1458
1459 sc_smap = sc_smap_lookup(sc->smaps, share);
1460 if (sc_smap == NULL) {
1461 TALLOC_FREE(frame);
1462 return HRES_ERROR_V(HRES_E_INVALIDARG);
1463 }
1464
1465 if (r->in.Level != 1) {
1466 TALLOC_FREE(frame);
1467 return HRES_ERROR_V(HRES_E_INVALIDARG);
1468 }
1469
1470 sm_out = talloc_zero(p->mem_ctx, struct fssagent_share_mapping_1);
1471 if (sm_out == NULL) {
1472 TALLOC_FREE(frame);
1473 return HRES_ERROR_V(HRES_E_OUTOFMEMORY);
1474 }
1475 sm_out->ShadowCopySetId = sc_set->id;
1476 sm_out->ShadowCopyId = sc->id;
1477 sm_out->ShareNameUNC = talloc_asprintf(sm_out, "\\\\%s\\%s",
1478 lp_netbios_name(),
1479 sc_smap->share_name);
1480 if (sm_out->ShareNameUNC == NULL) {
1481 talloc_free(sm_out);
1482 TALLOC_FREE(frame);
1483 return HRES_ERROR_V(HRES_E_OUTOFMEMORY);
1484 }
1485 sm_out->ShadowCopyShareName = sc_smap->sc_share_name;
1486 unix_to_nt_time(&sm_out->tstamp, sc->create_ts);
1487 r->out.ShareMapping->ShareMapping1 = sm_out;
1488 TALLOC_FREE(frame);
1489
1490 /* reset msg sequence timer */
1491 TALLOC_FREE(fss_global.seq_tmr);
1492 fss_seq_tout_set(fss_global.mem_ctx, 1800, sc_set, &fss_global.seq_tmr);
1493
1494 return 0;
1495 }
1496
1497 static NTSTATUS sc_smap_unexpose(struct messaging_context *msg_ctx,
1498 struct fss_sc_smap *sc_smap, bool delete_all)
1499 {
1500 NTSTATUS ret;
1501 struct smbconf_ctx *conf_ctx;
1502 sbcErr cerr;
1503 bool is_modified = false;
1504 TALLOC_CTX *frame = talloc_stackframe();
1505
1506 cerr = smbconf_init(frame, &conf_ctx, "registry");
1507 if (!SBC_ERROR_IS_OK(cerr)) {
1508 DEBUG(0, ("failed registry smbconf init: %s\n",
1509 sbcErrorString(cerr)));
1510 ret = NT_STATUS_UNSUCCESSFUL;
1511 goto err_tmp;
1512 }
1513
1514 /* registry IO must be done as root */
1515 become_root();
1516
1517 cerr = smbconf_transaction_start(conf_ctx);
1518 if (!SBC_ERROR_IS_OK(cerr)) {
1519 DEBUG(0, ("error starting transaction: %s\n",
1520 sbcErrorString(cerr)));
1521 ret = NT_STATUS_UNSUCCESSFUL;
1522 goto err_conf;
1523 }
1524
1525 while (sc_smap) {
1526 struct fss_sc_smap *sc_map_next = sc_smap->next;
1527 if (!smbconf_share_exists(conf_ctx, sc_smap->sc_share_name)) {
1528 DEBUG(2, ("no such share: %s\n", sc_smap->sc_share_name));
1529 if (!delete_all) {
1530 ret = NT_STATUS_OK;
1531 goto err_cancel;
1532 }
1533 sc_smap = sc_map_next;
1534 continue;
1535 }
1536
1537 cerr = smbconf_delete_share(conf_ctx, sc_smap->sc_share_name);
1538 if (!SBC_ERROR_IS_OK(cerr)) {
1539 DEBUG(0, ("error deleting share: %s\n",
1540 sbcErrorString(cerr)));
1541 ret = NT_STATUS_UNSUCCESSFUL;
1542 goto err_cancel;
1543 }
1544 is_modified = true;
1545 sc_smap->is_exposed = false;
1546 if (delete_all) {
1547 sc_smap = sc_map_next;
1548 } else {
1549 sc_smap = NULL; /* only process single sc_map entry */
1550 }
1551 }
1552 if (is_modified) {
1553 cerr = smbconf_transaction_commit(conf_ctx);
1554 if (!SBC_ERROR_IS_OK(cerr)) {
1555 DEBUG(0, ("error committing transaction: %s\n",
1556 sbcErrorString(cerr)));
1557 ret = NT_STATUS_UNSUCCESSFUL;
1558 goto err_cancel;
1559 }
1560 messaging_send_all(msg_ctx, MSG_SMB_CONF_UPDATED, NULL, 0);
1561 } else {
1562 ret = NT_STATUS_OK;
1563 goto err_cancel;
1564 }
1565 ret = NT_STATUS_OK;
1566
1567 err_conf:
1568 talloc_free(conf_ctx);
1569 unbecome_root();
1570 err_tmp:
1571 TALLOC_FREE(frame);
1572 return ret;
1573
1574 err_cancel:
1575 smbconf_transaction_cancel(conf_ctx);
1576 talloc_free(conf_ctx);
1577 unbecome_root();
1578 TALLOC_FREE(frame);
1579 return ret;
1580 }
1581
1582 uint32_t _fss_DeleteShareMapping(struct pipes_struct *p,
1583 struct fss_DeleteShareMapping *r)
1584 {
1585 struct dcesrv_call_state *dce_call = p->dce_call;
1586 struct auth_session_info *session_info =
1587 dcesrv_call_session_info(dce_call);
1588 struct fss_sc_set *sc_set;
1589 struct fss_sc *sc;
1590 struct fss_sc_smap *sc_smap;
1591 char *share;
1592 NTSTATUS status;
1593 TALLOC_CTX *frame = talloc_stackframe();
1594 struct connection_struct *conn;
1595 int snum;
1596 char *service;
1597
1598 if (!fss_permitted(p)) {
1599 status = NT_STATUS_ACCESS_DENIED;
1600 goto err_tmp_free;
1601 }
1602
1603 sc_set = sc_set_lookup(fss_global.sc_sets, &r->in.ShadowCopySetId);
1604 if (sc_set == NULL) {
1605 /* docs say HRES_E_INVALIDARG */
1606 status = NT_STATUS_OBJECTID_NOT_FOUND;
1607 goto err_tmp_free;
1608 }
1609
1610 if ((sc_set->state != FSS_SC_EXPOSED)
1611 && (sc_set->state != FSS_SC_RECOVERED)) {
1612 status = NT_STATUS_INVALID_SERVER_STATE;
1613 goto err_tmp_free;
1614 }
1615
1616 sc = sc_lookup(sc_set->scs, &r->in.ShadowCopyId);
1617 if (sc == NULL) {
1618 status = NT_STATUS_INVALID_PARAMETER;
1619 goto err_tmp_free;
1620 }
1621
1622 status = fss_unc_parse(frame, r->in.ShareName, NULL, &share);
1623 if (!NT_STATUS_IS_OK(status)) {
1624 goto err_tmp_free;
1625 }
1626
1627 sc_smap = sc_smap_lookup(sc->smaps, share);
1628 if (sc_smap == NULL) {
1629 status = NT_STATUS_INVALID_PARAMETER;
1630 goto err_tmp_free;
1631 }
1632
1633 status = sc_smap_unexpose(p->msg_ctx, sc_smap, false);
1634 if (!NT_STATUS_IS_OK(status)) {
1635 DEBUG(0, ("failed to remove share %s: %s\n",
1636 sc_smap->sc_share_name, nt_errstr(status)));
1637 goto err_tmp_free;
1638 }
1639
1640 messaging_send_all(p->msg_ctx, MSG_SMB_FORCE_TDIS,
1641 sc_smap->sc_share_name,
1642 strlen(sc_smap->sc_share_name) + 1);
1643
1644 if (sc->smaps_count > 1) {
1645 /* do not delete the underlying snapshot - still in use */
1646 status = NT_STATUS_OK;
1647 goto err_tmp_free;
1648 }
1649
1650 snum = find_service(frame, sc_smap->share_name, &service);
1651 if ((snum == -1) || (service == NULL)) {
1652 DEBUG(0, ("share at %s not found\n", sc_smap->share_name));
1653 status = NT_STATUS_UNSUCCESSFUL;
1654 goto err_tmp_free;
1655 }
1656
1657 status = fss_conn_create_tos(p->msg_ctx, session_info, snum, &conn);
1658 if (!NT_STATUS_IS_OK(status)) {
1659 goto err_tmp_free;
1660 }
1661 if (!become_user_without_service_by_session(conn, session_info)) {
1662 DEBUG(0, ("failed to become user\n"));
1663 status = NT_STATUS_ACCESS_DENIED;
1664 goto err_tmp_free;
1665 }
1666
1667 status = SMB_VFS_SNAP_DELETE(conn, frame, sc->volume_name,
1668 sc->sc_path);
1669 unbecome_user_without_service();
1670 if (!NT_STATUS_IS_OK(status)) {
1671 goto err_tmp_free;
1672 }
1673
1674 /* XXX set timeout r->in.TimeOutInMilliseconds */
1675 DEBUG(6, ("good snap delete\n"));
1676 DLIST_REMOVE(sc->smaps, sc_smap);
1677 sc->smaps_count--;
1678 talloc_free(sc_smap);
1679 if (sc->smaps_count == 0) {
1680 DLIST_REMOVE(sc_set->scs, sc);
1681 sc_set->scs_count--;
1682 talloc_free(sc);
1683
1684 if (sc_set->scs_count == 0) {
1685 DLIST_REMOVE(fss_global.sc_sets, sc_set);
1686 fss_global.sc_sets_count--;
1687 talloc_free(sc_set);
1688 }
1689 }
1690
1691 become_root();
1692 status = fss_state_store(fss_global.mem_ctx, fss_global.sc_sets,
1693 fss_global.sc_sets_count, fss_global.db_path);
1694 unbecome_root();
1695 if (!NT_STATUS_IS_OK(status)) {
1696 DEBUG(1, ("failed to store fss server state: %s\n",
1697 nt_errstr(status)));
1698 }
1699
1700 status = NT_STATUS_OK;
1701 err_tmp_free:
1702 TALLOC_FREE(frame);
1703 return fss_ntstatus_map(status);
1704 }
1705
1706 uint32_t _fss_PrepareShadowCopySet(struct pipes_struct *p,
1707 struct fss_PrepareShadowCopySet *r)
1708 {
1709 struct fss_sc_set *sc_set;
1710
1711 if (!fss_permitted(p)) {
1712 return HRES_ERROR_V(HRES_E_ACCESSDENIED);
1713 }
1714
1715 sc_set = sc_set_lookup(fss_global.sc_sets, &r->in.ShadowCopySetId);
1716 if (sc_set == NULL) {
1717 return HRES_ERROR_V(HRES_E_INVALIDARG);
1718 }
1719
1720 if (sc_set->state != FSS_SC_ADDED) {
1721 return FSRVP_E_BAD_STATE;
1722 }
1723
1724 /* stop msg sequence timer */
1725 TALLOC_FREE(fss_global.seq_tmr);
1726
1727 /*
1728 * Windows Server "8" Beta takes ~60s here, presumably flushing
1729 * everything to disk. We may want to do something similar.
1730 */
1731
1732 /* start msg sequence timer, 1800 on success */
1733 fss_seq_tout_set(fss_global.mem_ctx, 1800, sc_set, &fss_global.seq_tmr);
1734
1735 return 0;
1736 }
1737
1738 static NTSTATUS FileServerVssAgent__op_init_server(
1739 struct dcesrv_context *dce_ctx,
1740 const struct dcesrv_endpoint_server *ep_server);
1741
1742 static NTSTATUS FileServerVssAgent__op_shutdown_server(
1743 struct dcesrv_context *dce_ctx,
1744 const struct dcesrv_endpoint_server *ep_server);
1745
1746 #define DCESRV_INTERFACE_FILESERVERVSSAGENT_INIT_SERVER \
1747 fileservervssagent_init_server
1748
1749 #define DCESRV_INTERFACE_FILESERVERVSSAGENT_SHUTDOWN_SERVER \
1750 fileservervssagent_shutdown_server
1751
1752 static NTSTATUS fileservervssagent_shutdown_server(
1753 struct dcesrv_context *dce_ctx,
1754 const struct dcesrv_endpoint_server *ep_server)
1755 {
1756 srv_fssa_cleanup();
1757 return FileServerVssAgent__op_shutdown_server(dce_ctx, ep_server);
1758 }
1759
1760 static NTSTATUS fileservervssagent_init_server(
1761 struct dcesrv_context *dce_ctx,
1762 const struct dcesrv_endpoint_server *ep_server)
1763 {
1764 NTSTATUS status;
1765 struct messaging_context *msg_ctx = global_messaging_context();
1766
1767 status = srv_fssa_start(msg_ctx);
1768 if (!NT_STATUS_IS_OK(status)) {
1769 return status;
1770 }
1771
1772 return FileServerVssAgent__op_init_server(dce_ctx, ep_server);
1773 }
1774
1775 /* include the generated boilerplate */
1776 #include "librpc/gen_ndr/ndr_fsrvp_scompat.c"
Samba GIT mirror