?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-shadow-copy2: Fix dir/@GMT-2012.10.15-13.48.43 form of paths
[Samba.git] / source3 / modules / vfs_shadow_copy2.c
blob82149f2cb7f39f085c9f93e9ecac5f6d09245a2a
1 /*
2 * shadow_copy2: a shadow copy module (second implementation)
3 *
4 * Copyright (C) Andrew Tridgell 2007 (portions taken from shadow_copy2)
5 * Copyright (C) Ed Plese 2009
6 * Copyright (C) Volker Lendecke 2011
7 * Copyright (C) Christian Ambach 2011
8 * Copyright (C) Michael Adam 2013
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25 /*
26 * This is a second implemetation of a shadow copy module for exposing
27 * file system snapshots to windows clients as shadow copies.
28 *
29 * See the manual page for documentation.
30 */
31
32 #include "includes.h"
33 #include "system/filesys.h"
34 #include "include/ntioctl.h"
35 #include <ccan/hash/hash.h>
36 #include "util_tdb.h"
37
38 struct shadow_copy2_config {
39 char *gmt_format;
40 bool use_sscanf;
41 bool use_localtime;
42 char *snapdir;
43 bool snapdirseverywhere;
44 bool crossmountpoints;
45 bool fixinodes;
46 char *sort_order;
47 bool snapdir_absolute;
48 char *basedir;
49 char *mount_point;
50 char *rel_connectpath; /* share root, relative to the basedir */
51 char *snapshot_basepath; /* the absolute version of snapdir */
52 };
53
54 static bool shadow_copy2_find_slashes(TALLOC_CTX *mem_ctx, const char *str,
55 size_t **poffsets,
56 unsigned *pnum_offsets)
57 {
58 unsigned num_offsets;
59 size_t *offsets;
60 const char *p;
61
62 num_offsets = 0;
63
64 p = str;
65 while ((p = strchr(p, '/')) != NULL) {
66 num_offsets += 1;
67 p += 1;
68 }
69
70 offsets = talloc_array(mem_ctx, size_t, num_offsets);
71 if (offsets == NULL) {
72 return false;
73 }
74
75 p = str;
76 num_offsets = 0;
77 while ((p = strchr(p, '/')) != NULL) {
78 offsets[num_offsets] = p-str;
79 num_offsets += 1;
80 p += 1;
81 }
82
83 *poffsets = offsets;
84 *pnum_offsets = num_offsets;
85 return true;
86 }
87
88 /**
89 * Given a timestamp, build the posix level GMT-tag string
90 * based on the configurable format.
91 */
92 static size_t shadow_copy2_posix_gmt_string(struct vfs_handle_struct *handle,
93 time_t snapshot,
94 char *snaptime_string,
95 size_t len)
96 {
97 struct tm snap_tm;
98 size_t snaptime_len;
99 struct shadow_copy2_config *config;
100
101 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
102 return 0);
103
104 if (config->use_sscanf) {
105 snaptime_len = snprintf(snaptime_string,
106 len,
107 config->gmt_format,
108 (unsigned long)snapshot);
109 if (snaptime_len <= 0) {
110 DEBUG(10, ("snprintf failed\n"));
111 return snaptime_len;
112 }
113 } else {
114 if (config->use_localtime) {
115 if (localtime_r(&snapshot, &snap_tm) == 0) {
116 DEBUG(10, ("gmtime_r failed\n"));
117 return -1;
118 }
119 } else {
120 if (gmtime_r(&snapshot, &snap_tm) == 0) {
121 DEBUG(10, ("gmtime_r failed\n"));
122 return -1;
123 }
124 }
125 snaptime_len = strftime(snaptime_string,
126 len,
127 config->gmt_format,
128 &snap_tm);
129 if (snaptime_len == 0) {
130 DEBUG(10, ("strftime failed\n"));
131 return 0;
132 }
133 }
134
135 return snaptime_len;
136 }
137
138 /**
139 * Given a timestamp, build the string to insert into a path
140 * as a path component for creating the local path to the
141 * snapshot at the given timestamp of the input path.
142 *
143 * In the case of a parallel snapdir (specified with an
144 * absolute path), this is the inital portion of the
145 * local path of any snapshot file. The complete path is
146 * obtained by appending the portion of the file's path
147 * below the share root's mountpoint.
148 */
149 static char *shadow_copy2_insert_string(TALLOC_CTX *mem_ctx,
150 struct vfs_handle_struct *handle,
151 time_t snapshot)
152 {
153 fstring snaptime_string;
154 size_t snaptime_len = 0;
155 char *result = NULL;
156 struct shadow_copy2_config *config;
157
158 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
159 return NULL);
160
161 snaptime_len = shadow_copy2_posix_gmt_string(handle,
162 snapshot,
163 snaptime_string,
164 sizeof(snaptime_string));
165 if (snaptime_len <= 0) {
166 return NULL;
167 }
168
169 if (config->snapdir_absolute) {
170 result = talloc_asprintf(mem_ctx, "%s/%s",
171 config->snapdir, snaptime_string);
172 } else {
173 result = talloc_asprintf(mem_ctx, "/%s/%s",
174 config->snapdir, snaptime_string);
175 }
176 if (result == NULL) {
177 DEBUG(1, (__location__ " talloc_asprintf failed\n"));
178 }
179
180 return result;
181 }
182
183 /**
184 * Build the posix snapshot path for the connection
185 * at the given timestamp, i.e. the absolute posix path
186 * that contains the snapshot for this file system.
187 *
188 * This only applies to classical case, i.e. not
189 * to the "snapdirseverywhere" mode.
190 */
191 static char *shadow_copy2_snapshot_path(TALLOC_CTX *mem_ctx,
192 struct vfs_handle_struct *handle,
193 time_t snapshot)
194 {
195 fstring snaptime_string;
196 size_t snaptime_len = 0;
197 char *result = NULL;
198 struct shadow_copy2_config *config;
199
200 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
201 return NULL);
202
203 snaptime_len = shadow_copy2_posix_gmt_string(handle,
204 snapshot,
205 snaptime_string,
206 sizeof(snaptime_string));
207 if (snaptime_len <= 0) {
208 return NULL;
209 }
210
211 result = talloc_asprintf(mem_ctx, "%s/%s",
212 config->snapshot_basepath, snaptime_string);
213 if (result == NULL) {
214 DEBUG(1, (__location__ " talloc_asprintf failed\n"));
215 }
216
217 return result;
218 }
219
220 /**
221 * Strip a snapshot component from a filename as
222 * handed in via the smb layer.
223 * Returns the parsed timestamp and the stripped filename.
224 */
225 static bool shadow_copy2_strip_snapshot(TALLOC_CTX *mem_ctx,
226 struct vfs_handle_struct *handle,
227 const char *name,
228 time_t *ptimestamp,
229 char **pstripped)
230 {
231 struct tm tm;
232 time_t timestamp;
233 const char *p;
234 char *q;
235 char *stripped;
236 size_t rest_len, dst_len;
237 struct shadow_copy2_config *config;
238
239 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
240 return false);
241
242 DEBUG(10, (__location__ ": enter path '%s'\n", name));
243
244 p = strstr_m(name, "@GMT-");
245 if (p == NULL) {
246 DEBUG(11, ("@GMT not found\n"));
247 goto no_snapshot;
248 }
249 if ((p > name) && (p[-1] != '/')) {
250 /* the GMT-token does not start a path-component */
251 DEBUG(10, ("not at start, p=%p, name=%p, p[-1]=%d\n",
252 p, name, (int)p[-1]));
253 goto no_snapshot;
254 }
255 q = strptime(p, GMT_FORMAT, &tm);
256 if (q == NULL) {
257 DEBUG(10, ("strptime failed\n"));
258 goto no_snapshot;
259 }
260 tm.tm_isdst = -1;
261 timestamp = timegm(&tm);
262 if (timestamp == (time_t)-1) {
263 DEBUG(10, ("timestamp==-1\n"));
264 goto no_snapshot;
265 }
266 if (q[0] == '\0') {
267 /* the name consists of only the GMT token */
268 if (pstripped != NULL) {
269 stripped = talloc_strndup(mem_ctx, name, p - name);
270 if (stripped == NULL) {
271 return false;
272 }
273 *pstripped = stripped;
274 }
275 *ptimestamp = timestamp;
276 return true;
277 }
278 if (q[0] != '/') {
279 /*
280 * The GMT token is either at the end of the path
281 * or it is not a complete path component, i.e. the
282 * path component continues after the gmt-token.
283 *
284 * TODO: Is this correct? Or would the GMT tag as the
285 * last component be a valid input?
286 */
287 DEBUG(10, ("q[0] = %d\n", (int)q[0]));
288 goto no_snapshot;
289 }
290 q += 1;
291
292 rest_len = strlen(q);
293 dst_len = (p-name) + rest_len;
294
295 if (config->snapdirseverywhere) {
296 char *insert;
297 bool have_insert;
298 insert = shadow_copy2_insert_string(talloc_tos(), handle,
299 timestamp);
300 if (insert == NULL) {
301 errno = ENOMEM;
302 return false;
303 }
304
305 DEBUG(10, (__location__ ": snapdirseverywhere mode.\n"
306 "path '%s'.\n"
307 "insert string '%s'\n", name, insert));
308
309 have_insert = (strstr(name, insert+1) != NULL);
310 DEBUG(10, ("have_insert=%d, name=%s, insert+1=%s\n",
311 (int)have_insert, name, insert+1));
312 if (have_insert) {
313 DEBUG(10, (__location__ ": insert string '%s' found in "
314 "path '%s' found in snapdirseverywhere mode "
315 "==> already converted\n", insert, name));
316 TALLOC_FREE(insert);
317 goto no_snapshot;
318 }
319 TALLOC_FREE(insert);
320 } else {
321 char *snapshot_path;
322 char *s;
323
324 snapshot_path = shadow_copy2_snapshot_path(talloc_tos(),
325 handle,
326 timestamp);
327 if (snapshot_path == NULL) {
328 errno = ENOMEM;
329 return false;
330 }
331
332 DEBUG(10, (__location__ " path: '%s'.\n"
333 "snapshot path: '%s'\n", name, snapshot_path));
334
335 s = strstr(name, snapshot_path);
336 if (s == name) {
337 /*
338 * this starts with "snapshot_basepath/GMT-Token"
339 * so it is already a converted absolute
340 * path. Don't process further.
341 */
342 DEBUG(10, (__location__ ": path '%s' starts with "
343 "snapshot path '%s' (not in "
344 "snapdirseverywhere mode) ==> "
345 "already converted\n", name, snapshot_path));
346 talloc_free(snapshot_path);
347 goto no_snapshot;
348 }
349 talloc_free(snapshot_path);
350 }
351
352 if (pstripped != NULL) {
353 stripped = talloc_array(mem_ctx, char, dst_len+1);
354 if (stripped == NULL) {
355 errno = ENOMEM;
356 return false;
357 }
358 if (p > name) {
359 memcpy(stripped, name, p-name);
360 }
361 if (rest_len > 0) {
362 memcpy(stripped + (p-name), q, rest_len);
363 }
364 stripped[dst_len] = '\0';
365 *pstripped = stripped;
366 }
367 *ptimestamp = timestamp;
368 return true;
369 no_snapshot:
370 *ptimestamp = 0;
371 return true;
372 }
373
374 static char *shadow_copy2_find_mount_point(TALLOC_CTX *mem_ctx,
375 vfs_handle_struct *handle)
376 {
377 char *path = talloc_strdup(mem_ctx, handle->conn->connectpath);
378 dev_t dev;
379 struct stat st;
380 char *p;
381
382 if (stat(path, &st) != 0) {
383 talloc_free(path);
384 return NULL;
385 }
386
387 dev = st.st_dev;
388
389 while ((p = strrchr(path, '/')) && p > path) {
390 *p = 0;
391 if (stat(path, &st) != 0) {
392 talloc_free(path);
393 return NULL;
394 }
395 if (st.st_dev != dev) {
396 *p = '/';
397 break;
398 }
399 }
400
401 return path;
402 }
403
404 /**
405 * Convert from a name as handed in via the SMB layer
406 * and a timestamp into the local path of the snapshot
407 * of the provided file at the provided time.
408 */
409 static char *shadow_copy2_convert(TALLOC_CTX *mem_ctx,
410 struct vfs_handle_struct *handle,
411 const char *name, time_t timestamp)
412 {
413 struct smb_filename converted_fname;
414 char *result = NULL;
415 size_t *slashes = NULL;
416 unsigned num_slashes;
417 char *path = NULL;
418 size_t pathlen;
419 char *insert = NULL;
420 char *converted = NULL;
421 size_t insertlen;
422 int i, saved_errno;
423 size_t min_offset;
424 struct shadow_copy2_config *config;
425
426 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
427 return NULL);
428
429 DEBUG(10, ("converting '%s'\n", name));
430
431 if (!config->snapdirseverywhere) {
432 int ret;
433 char *snapshot_path;
434
435 snapshot_path = shadow_copy2_snapshot_path(talloc_tos(),
436 handle,
437 timestamp);
438 if (snapshot_path == NULL) {
439 goto fail;
440 }
441
442 if (config->rel_connectpath == NULL) {
443 converted = talloc_asprintf(mem_ctx, "%s/%s",
444 snapshot_path, name);
445 } else {
446 converted = talloc_asprintf(mem_ctx, "%s/%s/%s",
447 snapshot_path,
448 config->rel_connectpath,
449 name);
450 }
451 if (converted == NULL) {
452 goto fail;
453 }
454
455 ZERO_STRUCT(converted_fname);
456 converted_fname.base_name = converted;
457
458 ret = SMB_VFS_NEXT_LSTAT(handle, &converted_fname);
459 DEBUG(10, ("Trying[not snapdirseverywhere] %s: %d (%s)\n",
460 converted,
461 ret, ret == 0 ? "ok" : strerror(errno)));
462 if (ret == 0) {
463 DEBUG(10, ("Found %s\n", converted));
464 result = converted;
465 converted = NULL;
466 goto fail;
467 } else {
468 errno = ENOENT;
469 goto fail;
470 }
471 /* never reached ... */
472 }
473
474 path = talloc_asprintf(mem_ctx, "%s/%s", handle->conn->connectpath,
475 name);
476 if (path == NULL) {
477 errno = ENOMEM;
478 goto fail;
479 }
480 pathlen = talloc_get_size(path)-1;
481
482 if (!shadow_copy2_find_slashes(talloc_tos(), path,
483 &slashes, &num_slashes)) {
484 goto fail;
485 }
486
487 insert = shadow_copy2_insert_string(talloc_tos(), handle, timestamp);
488 if (insert == NULL) {
489 goto fail;
490 }
491 insertlen = talloc_get_size(insert)-1;
492
493 /*
494 * Note: We deliberatly don't expensively initialize the
495 * array with talloc_zero here: Putting zero into
496 * converted[pathlen+insertlen] below is sufficient, because
497 * in the following for loop, the insert string is inserted
498 * at various slash places. So the memory up to position
499 * pathlen+insertlen will always be initialized when the
500 * converted string is used.
501 */
502 converted = talloc_array(mem_ctx, char, pathlen + insertlen + 1);
503 if (converted == NULL) {
504 goto fail;
505 }
506
507 if (path[pathlen-1] != '/') {
508 /*
509 * Append a fake slash to find the snapshot root
510 */
511 size_t *tmp;
512 tmp = talloc_realloc(talloc_tos(), slashes,
513 size_t, num_slashes+1);
514 if (tmp == NULL) {
515 goto fail;
516 }
517 slashes = tmp;
518 slashes[num_slashes] = pathlen;
519 num_slashes += 1;
520 }
521
522 min_offset = 0;
523
524 if (!config->crossmountpoints) {
525 min_offset = strlen(config->mount_point);
526 }
527
528 memcpy(converted, path, pathlen+1);
529 converted[pathlen+insertlen] = '\0';
530
531 ZERO_STRUCT(converted_fname);
532 converted_fname.base_name = converted;
533
534 for (i = num_slashes-1; i>=0; i--) {
535 int ret;
536 size_t offset;
537
538 offset = slashes[i];
539
540 if (offset < min_offset) {
541 errno = ENOENT;
542 goto fail;
543 }
544
545 memcpy(converted+offset, insert, insertlen);
546
547 offset += insertlen;
548 memcpy(converted+offset, path + slashes[i],
549 pathlen - slashes[i]);
550
551 ret = SMB_VFS_NEXT_LSTAT(handle, &converted_fname);
552
553 DEBUG(10, ("Trying[snapdirseverywhere] %s: %d (%s)\n",
554 converted,
555 ret, ret == 0 ? "ok" : strerror(errno)));
556 if (ret == 0) {
557 /* success */
558 break;
559 }
560 if (errno == ENOTDIR) {
561 /*
562 * This is a valid condition: We appended the
563 * .snaphots/@GMT.. to a file name. Just try
564 * with the upper levels.
565 */
566 continue;
567 }
568 if (errno != ENOENT) {
569 /* Other problem than "not found" */
570 goto fail;
571 }
572 }
573
574 if (i >= 0) {
575 /*
576 * Found something
577 */
578 DEBUG(10, ("Found %s\n", converted));
579 result = converted;
580 converted = NULL;
581 } else {
582 errno = ENOENT;
583 }
584 fail:
585 saved_errno = errno;
586 TALLOC_FREE(converted);
587 TALLOC_FREE(insert);
588 TALLOC_FREE(slashes);
589 TALLOC_FREE(path);
590 errno = saved_errno;
591 return result;
592 }
593
594 /*
595 modify a sbuf return to ensure that inodes in the shadow directory
596 are different from those in the main directory
597 */
598 static void convert_sbuf(vfs_handle_struct *handle, const char *fname,
599 SMB_STRUCT_STAT *sbuf)
600 {
601 struct shadow_copy2_config *config;
602
603 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
604 return);
605
606 if (config->fixinodes) {
607 /* some snapshot systems, like GPFS, return the name
608 device:inode for the snapshot files as the current
609 files. That breaks the 'restore' button in the shadow copy
610 GUI, as the client gets a sharing violation.
611
612 This is a crude way of allowing both files to be
613 open at once. It has a slight chance of inode
614 number collision, but I can't see a better approach
615 without significant VFS changes
616 */
617 uint32_t shash;
618
619 shash = hash(fname, strlen(fname), 0) & 0xFF000000;
620 if (shash == 0) {
621 shash = 1;
622 }
623 sbuf->st_ex_ino ^= shash;
624 }
625 }
626
627 static DIR *shadow_copy2_opendir(vfs_handle_struct *handle,
628 const char *fname,
629 const char *mask,
630 uint32 attr)
631 {
632 time_t timestamp;
633 char *stripped;
634 DIR *ret;
635 int saved_errno;
636 char *conv;
637
638 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
639 &timestamp, &stripped)) {
640 return NULL;
641 }
642 if (timestamp == 0) {
643 return SMB_VFS_NEXT_OPENDIR(handle, fname, mask, attr);
644 }
645 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
646 TALLOC_FREE(stripped);
647 if (conv == NULL) {
648 return NULL;
649 }
650 ret = SMB_VFS_NEXT_OPENDIR(handle, conv, mask, attr);
651 saved_errno = errno;
652 TALLOC_FREE(conv);
653 errno = saved_errno;
654 return ret;
655 }
656
657 static int shadow_copy2_rename(vfs_handle_struct *handle,
658 const struct smb_filename *smb_fname_src,
659 const struct smb_filename *smb_fname_dst)
660 {
661 time_t timestamp_src, timestamp_dst;
662
663 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
664 smb_fname_src->base_name,
665 &timestamp_src, NULL)) {
666 return -1;
667 }
668 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
669 smb_fname_dst->base_name,
670 &timestamp_dst, NULL)) {
671 return -1;
672 }
673 if (timestamp_src != 0) {
674 errno = EXDEV;
675 return -1;
676 }
677 if (timestamp_dst != 0) {
678 errno = EROFS;
679 return -1;
680 }
681 return SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
682 }
683
684 static int shadow_copy2_symlink(vfs_handle_struct *handle,
685 const char *oldname, const char *newname)
686 {
687 time_t timestamp_old, timestamp_new;
688
689 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, oldname,
690 &timestamp_old, NULL)) {
691 return -1;
692 }
693 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, newname,
694 &timestamp_new, NULL)) {
695 return -1;
696 }
697 if ((timestamp_old != 0) || (timestamp_new != 0)) {
698 errno = EROFS;
699 return -1;
700 }
701 return SMB_VFS_NEXT_SYMLINK(handle, oldname, newname);
702 }
703
704 static int shadow_copy2_link(vfs_handle_struct *handle,
705 const char *oldname, const char *newname)
706 {
707 time_t timestamp_old, timestamp_new;
708
709 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, oldname,
710 &timestamp_old, NULL)) {
711 return -1;
712 }
713 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, newname,
714 &timestamp_new, NULL)) {
715 return -1;
716 }
717 if ((timestamp_old != 0) || (timestamp_new != 0)) {
718 errno = EROFS;
719 return -1;
720 }
721 return SMB_VFS_NEXT_LINK(handle, oldname, newname);
722 }
723
724 static int shadow_copy2_stat(vfs_handle_struct *handle,
725 struct smb_filename *smb_fname)
726 {
727 time_t timestamp;
728 char *stripped, *tmp;
729 int ret, saved_errno;
730
731 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
732 smb_fname->base_name,
733 &timestamp, &stripped)) {
734 return -1;
735 }
736 if (timestamp == 0) {
737 return SMB_VFS_NEXT_STAT(handle, smb_fname);
738 }
739
740 tmp = smb_fname->base_name;
741 smb_fname->base_name = shadow_copy2_convert(
742 talloc_tos(), handle, stripped, timestamp);
743 TALLOC_FREE(stripped);
744
745 if (smb_fname->base_name == NULL) {
746 smb_fname->base_name = tmp;
747 return -1;
748 }
749
750 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
751 saved_errno = errno;
752
753 TALLOC_FREE(smb_fname->base_name);
754 smb_fname->base_name = tmp;
755
756 if (ret == 0) {
757 convert_sbuf(handle, smb_fname->base_name, &smb_fname->st);
758 }
759 errno = saved_errno;
760 return ret;
761 }
762
763 static int shadow_copy2_lstat(vfs_handle_struct *handle,
764 struct smb_filename *smb_fname)
765 {
766 time_t timestamp;
767 char *stripped, *tmp;
768 int ret, saved_errno;
769
770 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
771 smb_fname->base_name,
772 &timestamp, &stripped)) {
773 return -1;
774 }
775 if (timestamp == 0) {
776 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
777 }
778
779 tmp = smb_fname->base_name;
780 smb_fname->base_name = shadow_copy2_convert(
781 talloc_tos(), handle, stripped, timestamp);
782 TALLOC_FREE(stripped);
783
784 if (smb_fname->base_name == NULL) {
785 smb_fname->base_name = tmp;
786 return -1;
787 }
788
789 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
790 saved_errno = errno;
791
792 TALLOC_FREE(smb_fname->base_name);
793 smb_fname->base_name = tmp;
794
795 if (ret == 0) {
796 convert_sbuf(handle, smb_fname->base_name, &smb_fname->st);
797 }
798 errno = saved_errno;
799 return ret;
800 }
801
802 static int shadow_copy2_fstat(vfs_handle_struct *handle, files_struct *fsp,
803 SMB_STRUCT_STAT *sbuf)
804 {
805 time_t timestamp;
806 int ret;
807
808 ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
809 if (ret == -1) {
810 return ret;
811 }
812 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
813 fsp->fsp_name->base_name,
814 &timestamp, NULL)) {
815 return 0;
816 }
817 if (timestamp != 0) {
818 convert_sbuf(handle, fsp->fsp_name->base_name, sbuf);
819 }
820 return 0;
821 }
822
823 static int shadow_copy2_open(vfs_handle_struct *handle,
824 struct smb_filename *smb_fname, files_struct *fsp,
825 int flags, mode_t mode)
826 {
827 time_t timestamp;
828 char *stripped, *tmp;
829 int ret, saved_errno;
830
831 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
832 smb_fname->base_name,
833 &timestamp, &stripped)) {
834 return -1;
835 }
836 if (timestamp == 0) {
837 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
838 }
839
840 tmp = smb_fname->base_name;
841 smb_fname->base_name = shadow_copy2_convert(
842 talloc_tos(), handle, stripped, timestamp);
843 TALLOC_FREE(stripped);
844
845 if (smb_fname->base_name == NULL) {
846 smb_fname->base_name = tmp;
847 return -1;
848 }
849
850 ret = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
851 saved_errno = errno;
852
853 TALLOC_FREE(smb_fname->base_name);
854 smb_fname->base_name = tmp;
855
856 errno = saved_errno;
857 return ret;
858 }
859
860 static int shadow_copy2_unlink(vfs_handle_struct *handle,
861 const struct smb_filename *smb_fname)
862 {
863 time_t timestamp;
864 char *stripped;
865 int ret, saved_errno;
866 struct smb_filename *conv;
867
868 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
869 smb_fname->base_name,
870 &timestamp, &stripped)) {
871 return -1;
872 }
873 if (timestamp == 0) {
874 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
875 }
876 conv = cp_smb_filename(talloc_tos(), smb_fname);
877 if (conv == NULL) {
878 errno = ENOMEM;
879 return -1;
880 }
881 conv->base_name = shadow_copy2_convert(
882 conv, handle, stripped, timestamp);
883 TALLOC_FREE(stripped);
884 if (conv->base_name == NULL) {
885 return -1;
886 }
887 ret = SMB_VFS_NEXT_UNLINK(handle, conv);
888 saved_errno = errno;
889 TALLOC_FREE(conv);
890 errno = saved_errno;
891 return ret;
892 }
893
894 static int shadow_copy2_chmod(vfs_handle_struct *handle, const char *fname,
895 mode_t mode)
896 {
897 time_t timestamp;
898 char *stripped;
899 int ret, saved_errno;
900 char *conv;
901
902 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
903 &timestamp, &stripped)) {
904 return -1;
905 }
906 if (timestamp == 0) {
907 return SMB_VFS_NEXT_CHMOD(handle, fname, mode);
908 }
909 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
910 TALLOC_FREE(stripped);
911 if (conv == NULL) {
912 return -1;
913 }
914 ret = SMB_VFS_NEXT_CHMOD(handle, conv, mode);
915 saved_errno = errno;
916 TALLOC_FREE(conv);
917 errno = saved_errno;
918 return ret;
919 }
920
921 static int shadow_copy2_chown(vfs_handle_struct *handle, const char *fname,
922 uid_t uid, gid_t gid)
923 {
924 time_t timestamp;
925 char *stripped;
926 int ret, saved_errno;
927 char *conv;
928
929 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
930 &timestamp, &stripped)) {
931 return -1;
932 }
933 if (timestamp == 0) {
934 return SMB_VFS_NEXT_CHOWN(handle, fname, uid, gid);
935 }
936 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
937 TALLOC_FREE(stripped);
938 if (conv == NULL) {
939 return -1;
940 }
941 ret = SMB_VFS_NEXT_CHOWN(handle, conv, uid, gid);
942 saved_errno = errno;
943 TALLOC_FREE(conv);
944 errno = saved_errno;
945 return ret;
946 }
947
948 static int shadow_copy2_chdir(vfs_handle_struct *handle,
949 const char *fname)
950 {
951 time_t timestamp;
952 char *stripped;
953 int ret, saved_errno;
954 char *conv;
955
956 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
957 &timestamp, &stripped)) {
958 return -1;
959 }
960 if (timestamp == 0) {
961 return SMB_VFS_NEXT_CHDIR(handle, fname);
962 }
963 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
964 TALLOC_FREE(stripped);
965 if (conv == NULL) {
966 return -1;
967 }
968 ret = SMB_VFS_NEXT_CHDIR(handle, conv);
969 saved_errno = errno;
970 TALLOC_FREE(conv);
971 errno = saved_errno;
972 return ret;
973 }
974
975 static int shadow_copy2_ntimes(vfs_handle_struct *handle,
976 const struct smb_filename *smb_fname,
977 struct smb_file_time *ft)
978 {
979 time_t timestamp;
980 char *stripped;
981 int ret, saved_errno;
982 struct smb_filename *conv;
983
984 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
985 smb_fname->base_name,
986 &timestamp, &stripped)) {
987 return -1;
988 }
989 if (timestamp == 0) {
990 return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
991 }
992 conv = cp_smb_filename(talloc_tos(), smb_fname);
993 if (conv == NULL) {
994 errno = ENOMEM;
995 return -1;
996 }
997 conv->base_name = shadow_copy2_convert(
998 conv, handle, stripped, timestamp);
999 TALLOC_FREE(stripped);
1000 if (conv->base_name == NULL) {
1001 return -1;
1002 }
1003 ret = SMB_VFS_NEXT_NTIMES(handle, conv, ft);
1004 saved_errno = errno;
1005 TALLOC_FREE(conv);
1006 errno = saved_errno;
1007 return ret;
1008 }
1009
1010 static int shadow_copy2_readlink(vfs_handle_struct *handle,
1011 const char *fname, char *buf, size_t bufsiz)
1012 {
1013 time_t timestamp;
1014 char *stripped;
1015 int ret, saved_errno;
1016 char *conv;
1017
1018 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1019 &timestamp, &stripped)) {
1020 return -1;
1021 }
1022 if (timestamp == 0) {
1023 return SMB_VFS_NEXT_READLINK(handle, fname, buf, bufsiz);
1024 }
1025 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1026 TALLOC_FREE(stripped);
1027 if (conv == NULL) {
1028 return -1;
1029 }
1030 ret = SMB_VFS_NEXT_READLINK(handle, conv, buf, bufsiz);
1031 saved_errno = errno;
1032 TALLOC_FREE(conv);
1033 errno = saved_errno;
1034 return ret;
1035 }
1036
1037 static int shadow_copy2_mknod(vfs_handle_struct *handle,
1038 const char *fname, mode_t mode, SMB_DEV_T dev)
1039 {
1040 time_t timestamp;
1041 char *stripped;
1042 int ret, saved_errno;
1043 char *conv;
1044
1045 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1046 &timestamp, &stripped)) {
1047 return -1;
1048 }
1049 if (timestamp == 0) {
1050 return SMB_VFS_NEXT_MKNOD(handle, fname, mode, dev);
1051 }
1052 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1053 TALLOC_FREE(stripped);
1054 if (conv == NULL) {
1055 return -1;
1056 }
1057 ret = SMB_VFS_NEXT_MKNOD(handle, conv, mode, dev);
1058 saved_errno = errno;
1059 TALLOC_FREE(conv);
1060 errno = saved_errno;
1061 return ret;
1062 }
1063
1064 static char *shadow_copy2_realpath(vfs_handle_struct *handle,
1065 const char *fname)
1066 {
1067 time_t timestamp;
1068 char *stripped = NULL;
1069 char *tmp = NULL;
1070 char *result = NULL;
1071 char *inserted = NULL;
1072 char *inserted_to, *inserted_end;
1073 int saved_errno;
1074
1075 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1076 &timestamp, &stripped)) {
1077 goto done;
1078 }
1079 if (timestamp == 0) {
1080 return SMB_VFS_NEXT_REALPATH(handle, fname);
1081 }
1082
1083 tmp = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1084 if (tmp == NULL) {
1085 goto done;
1086 }
1087
1088 result = SMB_VFS_NEXT_REALPATH(handle, tmp);
1089 if (result == NULL) {
1090 goto done;
1091 }
1092
1093 /*
1094 * Take away what we've inserted. This removes the @GMT-thingy
1095 * completely, but will give a path under the share root.
1096 */
1097 inserted = shadow_copy2_insert_string(talloc_tos(), handle, timestamp);
1098 if (inserted == NULL) {
1099 goto done;
1100 }
1101 inserted_to = strstr_m(result, inserted);
1102 if (inserted_to == NULL) {
1103 DEBUG(2, ("SMB_VFS_NEXT_REALPATH removed %s\n", inserted));
1104 goto done;
1105 }
1106 inserted_end = inserted_to + talloc_get_size(inserted) - 1;
1107 memmove(inserted_to, inserted_end, strlen(inserted_end)+1);
1108
1109 done:
1110 saved_errno = errno;
1111 TALLOC_FREE(inserted);
1112 TALLOC_FREE(tmp);
1113 TALLOC_FREE(stripped);
1114 errno = saved_errno;
1115 return result;
1116 }
1117
1118 /**
1119 * Check whether a given directory contains a
1120 * snapshot directory as direct subdirectory.
1121 * If yes, return the path of the snapshot-subdir,
1122 * otherwise return NULL.
1123 */
1124 static char *have_snapdir(struct vfs_handle_struct *handle,
1125 const char *path)
1126 {
1127 struct smb_filename smb_fname;
1128 int ret;
1129 struct shadow_copy2_config *config;
1130
1131 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1132 return NULL);
1133
1134 ZERO_STRUCT(smb_fname);
1135 smb_fname.base_name = talloc_asprintf(talloc_tos(), "%s/%s",
1136 path, config->snapdir);
1137 if (smb_fname.base_name == NULL) {
1138 return NULL;
1139 }
1140
1141 ret = SMB_VFS_NEXT_STAT(handle, &smb_fname);
1142 if ((ret == 0) && (S_ISDIR(smb_fname.st.st_ex_mode))) {
1143 return smb_fname.base_name;
1144 }
1145 TALLOC_FREE(smb_fname.base_name);
1146 return NULL;
1147 }
1148
1149 /**
1150 * Find the snapshot directory (if any) for the given
1151 * filename (which is relative to the share).
1152 */
1153 static const char *shadow_copy2_find_snapdir(TALLOC_CTX *mem_ctx,
1154 struct vfs_handle_struct *handle,
1155 struct smb_filename *smb_fname)
1156 {
1157 char *path, *p;
1158 const char *snapdir;
1159 struct shadow_copy2_config *config;
1160
1161 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1162 return NULL);
1163
1164 /*
1165 * If the non-snapdisrseverywhere mode, we should not search!
1166 */
1167 if (!config->snapdirseverywhere) {
1168 return config->snapshot_basepath;
1169 }
1170
1171 path = talloc_asprintf(mem_ctx, "%s/%s",
1172 handle->conn->connectpath,
1173 smb_fname->base_name);
1174 if (path == NULL) {
1175 return NULL;
1176 }
1177
1178 snapdir = have_snapdir(handle, path);
1179 if (snapdir != NULL) {
1180 TALLOC_FREE(path);
1181 return snapdir;
1182 }
1183
1184 while ((p = strrchr(path, '/')) && (p > path)) {
1185
1186 p[0] = '\0';
1187
1188 snapdir = have_snapdir(handle, path);
1189 if (snapdir != NULL) {
1190 TALLOC_FREE(path);
1191 return snapdir;
1192 }
1193 }
1194 TALLOC_FREE(path);
1195 return NULL;
1196 }
1197
1198 static bool shadow_copy2_snapshot_to_gmt(vfs_handle_struct *handle,
1199 const char *name,
1200 char *gmt, size_t gmt_len)
1201 {
1202 struct tm timestamp;
1203 time_t timestamp_t;
1204 unsigned long int timestamp_long;
1205 const char *fmt;
1206 struct shadow_copy2_config *config;
1207
1208 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1209 return NULL);
1210
1211 fmt = config->gmt_format;
1212
1213 ZERO_STRUCT(timestamp);
1214 if (config->use_sscanf) {
1215 if (sscanf(name, fmt, &timestamp_long) != 1) {
1216 DEBUG(10, ("shadow_copy2_snapshot_to_gmt: "
1217 "no sscanf match %s: %s\n",
1218 fmt, name));
1219 return false;
1220 }
1221 timestamp_t = timestamp_long;
1222 gmtime_r(&timestamp_t, &timestamp);
1223 } else {
1224 if (strptime(name, fmt, &timestamp) == NULL) {
1225 DEBUG(10, ("shadow_copy2_snapshot_to_gmt: "
1226 "no match %s: %s\n",
1227 fmt, name));
1228 return false;
1229 }
1230 DEBUG(10, ("shadow_copy2_snapshot_to_gmt: match %s: %s\n",
1231 fmt, name));
1232
1233 if (config->use_localtime) {
1234 timestamp.tm_isdst = -1;
1235 timestamp_t = mktime(&timestamp);
1236 gmtime_r(&timestamp_t, &timestamp);
1237 }
1238 }
1239
1240 strftime(gmt, gmt_len, GMT_FORMAT, &timestamp);
1241 return true;
1242 }
1243
1244 static int shadow_copy2_label_cmp_asc(const void *x, const void *y)
1245 {
1246 return strncmp((const char *)x, (const char *)y, sizeof(SHADOW_COPY_LABEL));
1247 }
1248
1249 static int shadow_copy2_label_cmp_desc(const void *x, const void *y)
1250 {
1251 return -strncmp((const char *)x, (const char *)y, sizeof(SHADOW_COPY_LABEL));
1252 }
1253
1254 /*
1255 sort the shadow copy data in ascending or descending order
1256 */
1257 static void shadow_copy2_sort_data(vfs_handle_struct *handle,
1258 struct shadow_copy_data *shadow_copy2_data)
1259 {
1260 int (*cmpfunc)(const void *, const void *);
1261 const char *sort;
1262 struct shadow_copy2_config *config;
1263
1264 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1265 return);
1266
1267 sort = config->sort_order;
1268 if (sort == NULL) {
1269 return;
1270 }
1271
1272 if (strcmp(sort, "asc") == 0) {
1273 cmpfunc = shadow_copy2_label_cmp_asc;
1274 } else if (strcmp(sort, "desc") == 0) {
1275 cmpfunc = shadow_copy2_label_cmp_desc;
1276 } else {
1277 return;
1278 }
1279
1280 if (shadow_copy2_data && shadow_copy2_data->num_volumes > 0 &&
1281 shadow_copy2_data->labels)
1282 {
1283 TYPESAFE_QSORT(shadow_copy2_data->labels,
1284 shadow_copy2_data->num_volumes,
1285 cmpfunc);
1286 }
1287 }
1288
1289 static int shadow_copy2_get_shadow_copy_data(
1290 vfs_handle_struct *handle, files_struct *fsp,
1291 struct shadow_copy_data *shadow_copy2_data,
1292 bool labels)
1293 {
1294 DIR *p;
1295 const char *snapdir;
1296 struct dirent *d;
1297 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1298
1299 snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle, fsp->fsp_name);
1300 if (snapdir == NULL) {
1301 DEBUG(0,("shadow:snapdir not found for %s in get_shadow_copy_data\n",
1302 handle->conn->connectpath));
1303 errno = EINVAL;
1304 talloc_free(tmp_ctx);
1305 return -1;
1306 }
1307
1308 p = SMB_VFS_NEXT_OPENDIR(handle, snapdir, NULL, 0);
1309
1310 if (!p) {
1311 DEBUG(2,("shadow_copy2: SMB_VFS_NEXT_OPENDIR() failed for '%s'"
1312 " - %s\n", snapdir, strerror(errno)));
1313 talloc_free(tmp_ctx);
1314 errno = ENOSYS;
1315 return -1;
1316 }
1317
1318 shadow_copy2_data->num_volumes = 0;
1319 shadow_copy2_data->labels = NULL;
1320
1321 while ((d = SMB_VFS_NEXT_READDIR(handle, p, NULL))) {
1322 char snapshot[GMT_NAME_LEN+1];
1323 SHADOW_COPY_LABEL *tlabels;
1324
1325 /*
1326 * ignore names not of the right form in the snapshot
1327 * directory
1328 */
1329 if (!shadow_copy2_snapshot_to_gmt(
1330 handle, d->d_name,
1331 snapshot, sizeof(snapshot))) {
1332
1333 DEBUG(6, ("shadow_copy2_get_shadow_copy_data: "
1334 "ignoring %s\n", d->d_name));
1335 continue;
1336 }
1337 DEBUG(6,("shadow_copy2_get_shadow_copy_data: %s -> %s\n",
1338 d->d_name, snapshot));
1339
1340 if (!labels) {
1341 /* the caller doesn't want the labels */
1342 shadow_copy2_data->num_volumes++;
1343 continue;
1344 }
1345
1346 tlabels = talloc_realloc(shadow_copy2_data,
1347 shadow_copy2_data->labels,
1348 SHADOW_COPY_LABEL,
1349 shadow_copy2_data->num_volumes+1);
1350 if (tlabels == NULL) {
1351 DEBUG(0,("shadow_copy2: out of memory\n"));
1352 SMB_VFS_NEXT_CLOSEDIR(handle, p);
1353 talloc_free(tmp_ctx);
1354 return -1;
1355 }
1356
1357 strlcpy(tlabels[shadow_copy2_data->num_volumes], snapshot,
1358 sizeof(*tlabels));
1359
1360 shadow_copy2_data->num_volumes++;
1361 shadow_copy2_data->labels = tlabels;
1362 }
1363
1364 SMB_VFS_NEXT_CLOSEDIR(handle,p);
1365
1366 shadow_copy2_sort_data(handle, shadow_copy2_data);
1367
1368 talloc_free(tmp_ctx);
1369 return 0;
1370 }
1371
1372 static NTSTATUS shadow_copy2_fget_nt_acl(vfs_handle_struct *handle,
1373 struct files_struct *fsp,
1374 uint32 security_info,
1375 TALLOC_CTX *mem_ctx,
1376 struct security_descriptor **ppdesc)
1377 {
1378 time_t timestamp;
1379 char *stripped;
1380 NTSTATUS status;
1381 char *conv;
1382
1383 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
1384 fsp->fsp_name->base_name,
1385 &timestamp, &stripped)) {
1386 return map_nt_error_from_unix(errno);
1387 }
1388 if (timestamp == 0) {
1389 return SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
1390 mem_ctx,
1391 ppdesc);
1392 }
1393 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1394 TALLOC_FREE(stripped);
1395 if (conv == NULL) {
1396 return map_nt_error_from_unix(errno);
1397 }
1398 status = SMB_VFS_NEXT_GET_NT_ACL(handle, conv, security_info,
1399 mem_ctx, ppdesc);
1400 TALLOC_FREE(conv);
1401 return status;
1402 }
1403
1404 static NTSTATUS shadow_copy2_get_nt_acl(vfs_handle_struct *handle,
1405 const char *fname,
1406 uint32 security_info,
1407 TALLOC_CTX *mem_ctx,
1408 struct security_descriptor **ppdesc)
1409 {
1410 time_t timestamp;
1411 char *stripped;
1412 NTSTATUS status;
1413 char *conv;
1414
1415 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1416 &timestamp, &stripped)) {
1417 return map_nt_error_from_unix(errno);
1418 }
1419 if (timestamp == 0) {
1420 return SMB_VFS_NEXT_GET_NT_ACL(handle, fname, security_info,
1421 mem_ctx, ppdesc);
1422 }
1423 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1424 TALLOC_FREE(stripped);
1425 if (conv == NULL) {
1426 return map_nt_error_from_unix(errno);
1427 }
1428 status = SMB_VFS_NEXT_GET_NT_ACL(handle, conv, security_info,
1429 mem_ctx, ppdesc);
1430 TALLOC_FREE(conv);
1431 return status;
1432 }
1433
1434 static int shadow_copy2_mkdir(vfs_handle_struct *handle,
1435 const char *fname, mode_t mode)
1436 {
1437 time_t timestamp;
1438 char *stripped;
1439 int ret, saved_errno;
1440 char *conv;
1441
1442 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1443 &timestamp, &stripped)) {
1444 return -1;
1445 }
1446 if (timestamp == 0) {
1447 return SMB_VFS_NEXT_MKDIR(handle, fname, mode);
1448 }
1449 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1450 TALLOC_FREE(stripped);
1451 if (conv == NULL) {
1452 return -1;
1453 }
1454 ret = SMB_VFS_NEXT_MKDIR(handle, conv, mode);
1455 saved_errno = errno;
1456 TALLOC_FREE(conv);
1457 errno = saved_errno;
1458 return ret;
1459 }
1460
1461 static int shadow_copy2_rmdir(vfs_handle_struct *handle, const char *fname)
1462 {
1463 time_t timestamp;
1464 char *stripped;
1465 int ret, saved_errno;
1466 char *conv;
1467
1468 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1469 &timestamp, &stripped)) {
1470 return -1;
1471 }
1472 if (timestamp == 0) {
1473 return SMB_VFS_NEXT_RMDIR(handle, fname);
1474 }
1475 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1476 TALLOC_FREE(stripped);
1477 if (conv == NULL) {
1478 return -1;
1479 }
1480 ret = SMB_VFS_NEXT_RMDIR(handle, conv);
1481 saved_errno = errno;
1482 TALLOC_FREE(conv);
1483 errno = saved_errno;
1484 return ret;
1485 }
1486
1487 static int shadow_copy2_chflags(vfs_handle_struct *handle, const char *fname,
1488 unsigned int flags)
1489 {
1490 time_t timestamp;
1491 char *stripped;
1492 int ret, saved_errno;
1493 char *conv;
1494
1495 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1496 &timestamp, &stripped)) {
1497 return -1;
1498 }
1499 if (timestamp == 0) {
1500 return SMB_VFS_NEXT_CHFLAGS(handle, fname, flags);
1501 }
1502 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1503 TALLOC_FREE(stripped);
1504 if (conv == NULL) {
1505 return -1;
1506 }
1507 ret = SMB_VFS_NEXT_CHFLAGS(handle, conv, flags);
1508 saved_errno = errno;
1509 TALLOC_FREE(conv);
1510 errno = saved_errno;
1511 return ret;
1512 }
1513
1514 static ssize_t shadow_copy2_getxattr(vfs_handle_struct *handle,
1515 const char *fname, const char *aname,
1516 void *value, size_t size)
1517 {
1518 time_t timestamp;
1519 char *stripped;
1520 ssize_t ret;
1521 int saved_errno;
1522 char *conv;
1523
1524 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1525 &timestamp, &stripped)) {
1526 return -1;
1527 }
1528 if (timestamp == 0) {
1529 return SMB_VFS_NEXT_GETXATTR(handle, fname, aname, value,
1530 size);
1531 }
1532 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1533 TALLOC_FREE(stripped);
1534 if (conv == NULL) {
1535 return -1;
1536 }
1537 ret = SMB_VFS_NEXT_GETXATTR(handle, conv, aname, value, size);
1538 saved_errno = errno;
1539 TALLOC_FREE(conv);
1540 errno = saved_errno;
1541 return ret;
1542 }
1543
1544 static ssize_t shadow_copy2_listxattr(struct vfs_handle_struct *handle,
1545 const char *fname,
1546 char *list, size_t size)
1547 {
1548 time_t timestamp;
1549 char *stripped;
1550 ssize_t ret;
1551 int saved_errno;
1552 char *conv;
1553
1554 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1555 &timestamp, &stripped)) {
1556 return -1;
1557 }
1558 if (timestamp == 0) {
1559 return SMB_VFS_NEXT_LISTXATTR(handle, fname, list, size);
1560 }
1561 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1562 TALLOC_FREE(stripped);
1563 if (conv == NULL) {
1564 return -1;
1565 }
1566 ret = SMB_VFS_NEXT_LISTXATTR(handle, conv, list, size);
1567 saved_errno = errno;
1568 TALLOC_FREE(conv);
1569 errno = saved_errno;
1570 return ret;
1571 }
1572
1573 static int shadow_copy2_removexattr(vfs_handle_struct *handle,
1574 const char *fname, const char *aname)
1575 {
1576 time_t timestamp;
1577 char *stripped;
1578 int ret, saved_errno;
1579 char *conv;
1580
1581 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1582 &timestamp, &stripped)) {
1583 return -1;
1584 }
1585 if (timestamp == 0) {
1586 return SMB_VFS_NEXT_REMOVEXATTR(handle, fname, aname);
1587 }
1588 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1589 TALLOC_FREE(stripped);
1590 if (conv == NULL) {
1591 return -1;
1592 }
1593 ret = SMB_VFS_NEXT_REMOVEXATTR(handle, conv, aname);
1594 saved_errno = errno;
1595 TALLOC_FREE(conv);
1596 errno = saved_errno;
1597 return ret;
1598 }
1599
1600 static int shadow_copy2_setxattr(struct vfs_handle_struct *handle,
1601 const char *fname,
1602 const char *aname, const void *value,
1603 size_t size, int flags)
1604 {
1605 time_t timestamp;
1606 char *stripped;
1607 ssize_t ret;
1608 int saved_errno;
1609 char *conv;
1610
1611 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1612 &timestamp, &stripped)) {
1613 return -1;
1614 }
1615 if (timestamp == 0) {
1616 return SMB_VFS_NEXT_SETXATTR(handle, fname, aname, value, size,
1617 flags);
1618 }
1619 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1620 TALLOC_FREE(stripped);
1621 if (conv == NULL) {
1622 return -1;
1623 }
1624 ret = SMB_VFS_NEXT_SETXATTR(handle, conv, aname, value, size, flags);
1625 saved_errno = errno;
1626 TALLOC_FREE(conv);
1627 errno = saved_errno;
1628 return ret;
1629 }
1630
1631 static int shadow_copy2_chmod_acl(vfs_handle_struct *handle,
1632 const char *fname, mode_t mode)
1633 {
1634 time_t timestamp;
1635 char *stripped;
1636 ssize_t ret;
1637 int saved_errno;
1638 char *conv;
1639
1640 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1641 &timestamp, &stripped)) {
1642 return -1;
1643 }
1644 if (timestamp == 0) {
1645 return SMB_VFS_NEXT_CHMOD_ACL(handle, fname, mode);
1646 }
1647 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1648 TALLOC_FREE(stripped);
1649 if (conv == NULL) {
1650 return -1;
1651 }
1652 ret = SMB_VFS_NEXT_CHMOD_ACL(handle, conv, mode);
1653 saved_errno = errno;
1654 TALLOC_FREE(conv);
1655 errno = saved_errno;
1656 return ret;
1657 }
1658
1659 static int shadow_copy2_get_real_filename(struct vfs_handle_struct *handle,
1660 const char *path,
1661 const char *name,
1662 TALLOC_CTX *mem_ctx,
1663 char **found_name)
1664 {
1665 time_t timestamp;
1666 char *stripped;
1667 ssize_t ret;
1668 int saved_errno;
1669 char *conv;
1670
1671 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, path,
1672 &timestamp, &stripped)) {
1673 return -1;
1674 }
1675 if (timestamp == 0) {
1676 return SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name,
1677 mem_ctx, found_name);
1678 }
1679 if (stripped[0] == '\0') {
1680 *found_name = talloc_strdup(mem_ctx, name);
1681 if (*found_name == NULL) {
1682 errno = ENOMEM;
1683 return -1;
1684 }
1685 return 0;
1686 }
1687 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1688 TALLOC_FREE(stripped);
1689 if (conv == NULL) {
1690 return -1;
1691 }
1692 ret = SMB_VFS_NEXT_GET_REAL_FILENAME(handle, conv, name,
1693 mem_ctx, found_name);
1694 saved_errno = errno;
1695 TALLOC_FREE(conv);
1696 errno = saved_errno;
1697 return ret;
1698 }
1699
1700 static uint64_t shadow_copy2_disk_free(vfs_handle_struct *handle,
1701 const char *path, bool small_query,
1702 uint64_t *bsize, uint64_t *dfree,
1703 uint64_t *dsize)
1704 {
1705 time_t timestamp;
1706 char *stripped;
1707 ssize_t ret;
1708 int saved_errno;
1709 char *conv;
1710
1711 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, path,
1712 &timestamp, &stripped)) {
1713 return -1;
1714 }
1715 if (timestamp == 0) {
1716 return SMB_VFS_NEXT_DISK_FREE(handle, path, small_query,
1717 bsize, dfree, dsize);
1718 }
1719
1720 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1721 TALLOC_FREE(stripped);
1722 if (conv == NULL) {
1723 return -1;
1724 }
1725
1726 ret = SMB_VFS_NEXT_DISK_FREE(handle, conv, small_query, bsize, dfree,
1727 dsize);
1728
1729 saved_errno = errno;
1730 TALLOC_FREE(conv);
1731 errno = saved_errno;
1732
1733 return ret;
1734 }
1735
1736 static int shadow_copy2_connect(struct vfs_handle_struct *handle,
1737 const char *service, const char *user)
1738 {
1739 struct shadow_copy2_config *config;
1740 int ret;
1741 const char *snapdir;
1742 const char *gmt_format;
1743 const char *sort_order;
1744 const char *basedir;
1745 const char *mount_point;
1746
1747 DEBUG(10, (__location__ ": cnum[%u], connectpath[%s]\n",
1748 (unsigned)handle->conn->cnum,
1749 handle->conn->connectpath));
1750
1751 ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
1752 if (ret < 0) {
1753 return ret;
1754 }
1755
1756 config = talloc_zero(handle->conn, struct shadow_copy2_config);
1757 if (config == NULL) {
1758 DEBUG(0, ("talloc_zero() failed\n"));
1759 errno = ENOMEM;
1760 return -1;
1761 }
1762
1763 gmt_format = lp_parm_const_string(SNUM(handle->conn),
1764 "shadow", "format",
1765 GMT_FORMAT);
1766 config->gmt_format = talloc_strdup(config, gmt_format);
1767 if (config->gmt_format == NULL) {
1768 DEBUG(0, ("talloc_strdup() failed\n"));
1769 errno = ENOMEM;
1770 return -1;
1771 }
1772
1773 config->use_sscanf = lp_parm_bool(SNUM(handle->conn),
1774 "shadow", "sscanf", false);
1775
1776 config->use_localtime = lp_parm_bool(SNUM(handle->conn),
1777 "shadow", "localtime",
1778 false);
1779
1780 snapdir = lp_parm_const_string(SNUM(handle->conn),
1781 "shadow", "snapdir",
1782 ".snapshots");
1783 config->snapdir = talloc_strdup(config, snapdir);
1784 if (config->snapdir == NULL) {
1785 DEBUG(0, ("talloc_strdup() failed\n"));
1786 errno = ENOMEM;
1787 return -1;
1788 }
1789
1790 config->snapdirseverywhere = lp_parm_bool(SNUM(handle->conn),
1791 "shadow",
1792 "snapdirseverywhere",
1793 false);
1794
1795 config->crossmountpoints = lp_parm_bool(SNUM(handle->conn),
1796 "shadow", "crossmountpoints",
1797 false);
1798
1799 config->fixinodes = lp_parm_bool(SNUM(handle->conn),
1800 "shadow", "fixinodes",
1801 false);
1802
1803 sort_order = lp_parm_const_string(SNUM(handle->conn),
1804 "shadow", "sort", "desc");
1805 config->sort_order = talloc_strdup(config, sort_order);
1806 if (config->sort_order == NULL) {
1807 DEBUG(0, ("talloc_strdup() failed\n"));
1808 errno = ENOMEM;
1809 return -1;
1810 }
1811
1812 mount_point = lp_parm_const_string(SNUM(handle->conn),
1813 "shadow", "mountpoint", NULL);
1814 if (mount_point != NULL) {
1815 if (mount_point[0] != '/') {
1816 DEBUG(1, (__location__ " Warning: 'mountpoint' is "
1817 "relative ('%s'), but it has to be an "
1818 "absolute path. Ignoring provided value.\n",
1819 mount_point));
1820 mount_point = NULL;
1821 } else {
1822 char *p;
1823 p = strstr(handle->conn->connectpath, mount_point);
1824 if (p != handle->conn->connectpath) {
1825 DEBUG(1, ("Warning: mount_point (%s) is not a "
1826 "subdirectory of the share root "
1827 "(%s). Ignoring provided value.\n",
1828 mount_point,
1829 handle->conn->connectpath));
1830 mount_point = NULL;
1831 }
1832 }
1833 }
1834
1835 if (mount_point != NULL) {
1836 config->mount_point = talloc_strdup(config, mount_point);
1837 if (config->mount_point == NULL) {
1838 DEBUG(0, (__location__ " talloc_strdup() failed\n"));
1839 return -1;
1840 }
1841 } else {
1842 config->mount_point = shadow_copy2_find_mount_point(config,
1843 handle);
1844 if (config->mount_point == NULL) {
1845 DEBUG(0, (__location__ ": shadow_copy2_find_mount_point"
1846 " failed: %s\n", strerror(errno)));
1847 return -1;
1848 }
1849 }
1850
1851 basedir = lp_parm_const_string(SNUM(handle->conn),
1852 "shadow", "basedir", NULL);
1853
1854 if (basedir != NULL) {
1855 if (basedir[0] != '/') {
1856 DEBUG(1, (__location__ " Warning: 'basedir' is "
1857 "relative ('%s'), but it has to be an "
1858 "absolute path. Disabling basedir.\n",
1859 basedir));
1860 } else {
1861 char *p;
1862 p = strstr(basedir, config->mount_point);
1863 if (p != basedir) {
1864 DEBUG(1, ("Warning: basedir (%s) is not a "
1865 "subdirectory of the share root's "
1866 "mount point (%s). "
1867 "Disabling basedir\n",
1868 basedir, config->mount_point));
1869 } else {
1870 config->basedir = talloc_strdup(config,
1871 basedir);
1872 if (config->basedir == NULL) {
1873 DEBUG(0, ("talloc_strdup() failed\n"));
1874 errno = ENOMEM;
1875 return -1;
1876 }
1877 }
1878 }
1879 }
1880
1881 if (config->snapdirseverywhere && config->basedir != NULL) {
1882 DEBUG(1, (__location__ " Warning: 'basedir' is incompatible "
1883 "with 'snapdirseverywhere'. Disabling basedir.\n"));
1884 TALLOC_FREE(config->basedir);
1885 }
1886
1887 if (config->crossmountpoints && config->basedir != NULL) {
1888 DEBUG(1, (__location__ " Warning: 'basedir' is incompatible "
1889 "with 'crossmountpoints'. Disabling basedir.\n"));
1890 TALLOC_FREE(config->basedir);
1891 }
1892
1893 if (config->basedir == NULL) {
1894 config->basedir = config->mount_point;
1895 }
1896
1897 if (strlen(config->basedir) != strlen(handle->conn->connectpath)) {
1898 config->rel_connectpath = talloc_strdup(config,
1899 handle->conn->connectpath + strlen(config->basedir));
1900 if (config->rel_connectpath == NULL) {
1901 DEBUG(0, ("talloc_strdup() failed\n"));
1902 errno = ENOMEM;
1903 return -1;
1904 }
1905 }
1906
1907 if (config->snapdir[0] == '/') {
1908 config->snapdir_absolute = true;
1909
1910 if (config->snapdirseverywhere == true) {
1911 DEBUG(1, (__location__ " Warning: An absolute snapdir "
1912 "is incompatible with 'snapdirseverywhere', "
1913 "setting 'snapdirseverywhere' to false.\n"));
1914 config->snapdirseverywhere = false;
1915 }
1916
1917 if (config->crossmountpoints == true) {
1918 DEBUG(1, (__location__ " Warning: 'crossmountpoints' "
1919 "is not supported with an absolute snapdir. "
1920 "Disabling it.\n"));
1921 config->crossmountpoints = false;
1922 }
1923
1924 config->snapshot_basepath = config->snapdir;
1925 } else {
1926 config->snapshot_basepath = talloc_asprintf(config, "%s/%s",
1927 config->mount_point, config->snapdir);
1928 if (config->snapshot_basepath == NULL) {
1929 DEBUG(0, ("talloc_asprintf() failed\n"));
1930 errno = ENOMEM;
1931 return -1;
1932 }
1933 }
1934
1935 DEBUG(10, ("shadow_copy2_connect: configuration:\n"
1936 " share root: '%s'\n"
1937 " basedir: '%s'\n"
1938 " mountpoint: '%s'\n"
1939 " rel share root: '%s'\n"
1940 " snapdir: '%s'\n"
1941 " snapshot base path: '%s'\n"
1942 " format: '%s'\n"
1943 " use sscanf: %s\n"
1944 " snapdirs everywhere: %s\n"
1945 " cross mountpoints: %s\n"
1946 " fix inodes: %s\n"
1947 " sort order: %s\n"
1948 "",
1949 handle->conn->connectpath,
1950 config->basedir,
1951 config->mount_point,
1952 config->rel_connectpath,
1953 config->snapdir,
1954 config->snapshot_basepath,
1955 config->gmt_format,
1956 config->use_sscanf ? "yes" : "no",
1957 config->snapdirseverywhere ? "yes" : "no",
1958 config->crossmountpoints ? "yes" : "no",
1959 config->fixinodes ? "yes" : "no",
1960 config->sort_order
1961 ));
1962
1963
1964 SMB_VFS_HANDLE_SET_DATA(handle, config,
1965 NULL, struct shadow_copy2_config,
1966 return -1);
1967
1968 return 0;
1969 }
1970
1971 static struct vfs_fn_pointers vfs_shadow_copy2_fns = {
1972 .connect_fn = shadow_copy2_connect,
1973 .opendir_fn = shadow_copy2_opendir,
1974 .disk_free_fn = shadow_copy2_disk_free,
1975 .rename_fn = shadow_copy2_rename,
1976 .link_fn = shadow_copy2_link,
1977 .symlink_fn = shadow_copy2_symlink,
1978 .stat_fn = shadow_copy2_stat,
1979 .lstat_fn = shadow_copy2_lstat,
1980 .fstat_fn = shadow_copy2_fstat,
1981 .open_fn = shadow_copy2_open,
1982 .unlink_fn = shadow_copy2_unlink,
1983 .chmod_fn = shadow_copy2_chmod,
1984 .chown_fn = shadow_copy2_chown,
1985 .chdir_fn = shadow_copy2_chdir,
1986 .ntimes_fn = shadow_copy2_ntimes,
1987 .readlink_fn = shadow_copy2_readlink,
1988 .mknod_fn = shadow_copy2_mknod,
1989 .realpath_fn = shadow_copy2_realpath,
1990 .get_nt_acl_fn = shadow_copy2_get_nt_acl,
1991 .fget_nt_acl_fn = shadow_copy2_fget_nt_acl,
1992 .get_shadow_copy_data_fn = shadow_copy2_get_shadow_copy_data,
1993 .mkdir_fn = shadow_copy2_mkdir,
1994 .rmdir_fn = shadow_copy2_rmdir,
1995 .getxattr_fn = shadow_copy2_getxattr,
1996 .listxattr_fn = shadow_copy2_listxattr,
1997 .removexattr_fn = shadow_copy2_removexattr,
1998 .setxattr_fn = shadow_copy2_setxattr,
1999 .chmod_acl_fn = shadow_copy2_chmod_acl,
2000 .chflags_fn = shadow_copy2_chflags,
2001 .get_real_filename_fn = shadow_copy2_get_real_filename,
2002 };
2003
2004 NTSTATUS vfs_shadow_copy2_init(void);
2005 NTSTATUS vfs_shadow_copy2_init(void)
2006 {
2007 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
2008 "shadow_copy2", &vfs_shadow_copy2_fns);
2009 }
Samba GIT mirror