2 * Third attempt at a shadow copy module
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
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 This is a 3rd implemetation of a shadow copy module for exposing
27 snapshots to windows clients as shadow copies. This version has the
30 1) you don't need to populate your shares with symlinks to the
31 snapshots. This can be very important when you have thousands of
32 shares, or use [homes]
34 2) the inode number of the files is altered so it is different
35 from the original. This allows the 'restore' button to work
36 without a sharing violation
38 3) shadow copy results can be sorted before being sent to the
39 client. This is beneficial for filesystems that don't read
40 directories alphabetically (the default unix).
42 4) vanity naming for snapshots. Snapshots can be named in any
43 format compatible with str[fp]time conversions.
45 5) time stamps in snapshot names can be represented in localtime
50 shadow:snapdir = <directory where snapshots are kept>
52 This is the directory containing the @GMT-* snapshot directories. If it is an absolute
53 path it is used as-is. If it is a relative path, then it is taken relative to the mount
54 point of the filesystem that the root of this share is on
56 shadow:basedir = <base directory that snapshots are from>
58 This is an optional parameter that specifies the directory that
59 the snapshots are relative to. It defaults to the filesystem
62 shadow:fixinodes = yes/no
64 If you enable shadow:fixinodes then this module will modify the
65 apparent inode number of files in the snapshot directories using
66 a hash of the files path. This is needed for snapshot systems
67 where the snapshots have the same device:inode number as the
68 original files (such as happens with GPFS snapshots). If you
69 don't set this option then the 'restore' button in the shadow
70 copy UI will fail with a sharing violation.
72 shadow:sort = asc/desc, or not specified for unsorted (default)
74 This is an optional parameter that specifies that the shadow
75 copy directories should be sorted before sending them to the
76 client. This can be beneficial as unix filesystems are usually
77 not listed alphabetically sorted. If enabled, you typically
78 want to specify descending order.
80 shadow:format = <format specification for snapshot names>
82 This is an optional parameter that specifies the format
83 specification for the naming of snapshots. The format must
84 be compatible with the conversion specifications recognized
85 by str[fp]time. The default value is "@GMT-%Y.%m.%d-%H.%M.%S".
87 shadow:sscanf = yes/no (default is no)
89 The time is the unsigned long integer (%lu) in the format string
90 rather than a time strptime() can parse. The result must be a unix time_t
93 shadow:localtime = yes/no (default is no)
95 This is an optional parameter that indicates whether the
96 snapshot names are in UTC/GMT or the local time.
99 The following command would generate a correctly formatted directory name
100 for use with the default parameters:
101 date -u +@GMT-%Y.%m.%d-%H.%M.%S
104 #include "includes.h"
105 #include "system/filesys.h"
106 #include "include/ntioctl.h"
107 #include <ccan/hash/hash.h>
108 #include "util_tdb.h"
110 struct shadow_copy2_config {
115 bool snapdirseverywhere;
116 bool crossmountpoints;
119 bool snapdir_absolute;
124 static bool shadow_copy2_find_slashes(TALLOC_CTX *mem_ctx, const char *str,
126 unsigned *pnum_offsets)
128 unsigned num_offsets;
135 while ((p = strchr(p, '/')) != NULL) {
140 offsets = talloc_array(mem_ctx, size_t, num_offsets);
141 if (offsets == NULL) {
147 while ((p = strchr(p, '/')) != NULL) {
148 offsets[num_offsets] = p-str;
154 *pnum_offsets = num_offsets;
159 * Given a timstamp, build the string to insert into a path
160 * as a path component for creating the local path to the
161 * snapshot at the given timestamp of the input path.
163 static char *shadow_copy2_insert_string(TALLOC_CTX *mem_ctx,
164 struct vfs_handle_struct *handle,
168 fstring snaptime_string;
170 struct shadow_copy2_config *config;
172 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
175 if (config->use_sscanf) {
176 snaptime_len = snprintf(snaptime_string,
177 sizeof(snaptime_string),
179 (unsigned long)snapshot);
180 if (snaptime_len <= 0) {
181 DEBUG(10, ("snprintf failed\n"));
185 if (config->use_localtime) {
186 if (localtime_r(&snapshot, &snap_tm) == 0) {
187 DEBUG(10, ("gmtime_r failed\n"));
191 if (gmtime_r(&snapshot, &snap_tm) == 0) {
192 DEBUG(10, ("gmtime_r failed\n"));
196 snaptime_len = strftime(snaptime_string,
197 sizeof(snaptime_string),
200 if (snaptime_len == 0) {
201 DEBUG(10, ("strftime failed\n"));
205 return talloc_asprintf(mem_ctx, "/%s/%s",
206 config->snapdir, snaptime_string);
210 * Strip a snapshot component from an filename as
211 * handed in via the smb layer.
212 * Returns the parsed timestamp and the stripped filename.
214 static bool shadow_copy2_strip_snapshot(TALLOC_CTX *mem_ctx,
215 struct vfs_handle_struct *handle,
225 size_t rest_len, dst_len;
226 struct shadow_copy2_config *config;
228 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
231 p = strstr_m(name, "@GMT-");
235 if ((p > name) && (p[-1] != '/')) {
238 q = strptime(p, GMT_FORMAT, &tm);
243 timestamp = timegm(&tm);
244 if (timestamp == (time_t)-1) {
247 if ((p == name) && (q[0] == '\0')) {
248 if (pstripped != NULL) {
249 stripped = talloc_strdup(mem_ctx, "");
250 if (stripped == NULL) {
253 *pstripped = stripped;
255 *ptimestamp = timestamp;
263 rest_len = strlen(q);
264 dst_len = (p-name) + rest_len;
266 if (config->snapdirseverywhere) {
269 insert = shadow_copy2_insert_string(talloc_tos(), handle,
271 if (insert == NULL) {
276 have_insert = (strstr(name, insert+1) != NULL);
283 if (pstripped != NULL) {
284 stripped = talloc_array(mem_ctx, char, dst_len+1);
285 if (stripped == NULL) {
290 memcpy(stripped, name, p-name);
293 memcpy(stripped + (p-name), q, rest_len);
295 stripped[dst_len] = '\0';
296 *pstripped = stripped;
298 *ptimestamp = timestamp;
305 static char *shadow_copy2_find_mount_point(TALLOC_CTX *mem_ctx,
306 vfs_handle_struct *handle)
308 char *path = talloc_strdup(mem_ctx, handle->conn->connectpath);
313 if (stat(path, &st) != 0) {
320 while ((p = strrchr(path, '/')) && p > path) {
322 if (stat(path, &st) != 0) {
326 if (st.st_dev != dev) {
336 * Convert from a name as handed in via the SMB layer
337 * and a timestamp into the local path of the snapshot
338 * of the provided file at the provided time.
340 static char *shadow_copy2_convert(TALLOC_CTX *mem_ctx,
341 struct vfs_handle_struct *handle,
342 const char *name, time_t timestamp)
344 struct smb_filename converted_fname;
346 size_t *slashes = NULL;
347 unsigned num_slashes;
351 char *converted = NULL;
355 struct shadow_copy2_config *config;
357 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
360 path = talloc_asprintf(mem_ctx, "%s/%s", handle->conn->connectpath,
366 pathlen = talloc_get_size(path)-1;
368 DEBUG(10, ("converting %s\n", path));
370 if (!shadow_copy2_find_slashes(talloc_tos(), path,
371 &slashes, &num_slashes)) {
374 insert = shadow_copy2_insert_string(talloc_tos(), handle, timestamp);
375 if (insert == NULL) {
378 insertlen = talloc_get_size(insert)-1;
379 converted = talloc_array(mem_ctx, char, pathlen + insertlen + 1);
380 if (converted == NULL) {
384 if (path[pathlen-1] != '/') {
386 * Append a fake slash to find the snapshot root
389 tmp = talloc_realloc(talloc_tos(), slashes,
390 size_t, num_slashes+1);
395 slashes[num_slashes] = pathlen;
401 if (!config->crossmountpoints) {
404 mount_point = shadow_copy2_find_mount_point(talloc_tos(),
406 if (mount_point == NULL) {
409 min_offset = strlen(mount_point);
410 TALLOC_FREE(mount_point);
413 memcpy(converted, path, pathlen+1);
414 converted[pathlen+insertlen] = '\0';
416 ZERO_STRUCT(converted_fname);
417 converted_fname.base_name = converted;
419 for (i = num_slashes-1; i>=0; i--) {
425 if (offset < min_offset) {
430 memcpy(converted+offset, insert, insertlen);
433 memcpy(converted+offset, path + slashes[i],
434 pathlen - slashes[i]);
436 ret = SMB_VFS_NEXT_LSTAT(handle, &converted_fname);
438 DEBUG(10, ("Trying %s: %d (%s)\n", converted,
439 ret, ret == 0 ? "ok" : strerror(errno)));
444 if (errno == ENOTDIR) {
446 * This is a valid condition: We appended the
447 * .snaphots/@GMT.. to a file name. Just try
448 * with the upper levels.
452 if (errno != ENOENT) {
453 /* Other problem than "not found" */
462 DEBUG(10, ("Found %s\n", converted));
470 TALLOC_FREE(converted);
472 TALLOC_FREE(slashes);
479 modify a sbuf return to ensure that inodes in the shadow directory
480 are different from those in the main directory
482 static void convert_sbuf(vfs_handle_struct *handle, const char *fname,
483 SMB_STRUCT_STAT *sbuf)
485 struct shadow_copy2_config *config;
487 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
490 if (config->fixinodes) {
491 /* some snapshot systems, like GPFS, return the name
492 device:inode for the snapshot files as the current
493 files. That breaks the 'restore' button in the shadow copy
494 GUI, as the client gets a sharing violation.
496 This is a crude way of allowing both files to be
497 open at once. It has a slight chance of inode
498 number collision, but I can't see a better approach
499 without significant VFS changes
503 shash = hash(fname, strlen(fname), 0) & 0xFF000000;
507 sbuf->st_ex_ino ^= shash;
511 static DIR *shadow_copy2_opendir(vfs_handle_struct *handle,
522 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
523 ×tamp, &stripped)) {
526 if (timestamp == 0) {
527 return SMB_VFS_NEXT_OPENDIR(handle, fname, mask, attr);
529 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
530 TALLOC_FREE(stripped);
534 ret = SMB_VFS_NEXT_OPENDIR(handle, conv, mask, attr);
541 static int shadow_copy2_rename(vfs_handle_struct *handle,
542 const struct smb_filename *smb_fname_src,
543 const struct smb_filename *smb_fname_dst)
545 time_t timestamp_src, timestamp_dst;
547 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
548 smb_fname_src->base_name,
549 ×tamp_src, NULL)) {
552 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
553 smb_fname_dst->base_name,
554 ×tamp_dst, NULL)) {
557 if (timestamp_src != 0) {
561 if (timestamp_dst != 0) {
565 return SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
568 static int shadow_copy2_symlink(vfs_handle_struct *handle,
569 const char *oldname, const char *newname)
571 time_t timestamp_old, timestamp_new;
573 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, oldname,
574 ×tamp_old, NULL)) {
577 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, newname,
578 ×tamp_new, NULL)) {
581 if ((timestamp_old != 0) || (timestamp_new != 0)) {
585 return SMB_VFS_NEXT_SYMLINK(handle, oldname, newname);
588 static int shadow_copy2_link(vfs_handle_struct *handle,
589 const char *oldname, const char *newname)
591 time_t timestamp_old, timestamp_new;
593 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, oldname,
594 ×tamp_old, NULL)) {
597 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, newname,
598 ×tamp_new, NULL)) {
601 if ((timestamp_old != 0) || (timestamp_new != 0)) {
605 return SMB_VFS_NEXT_LINK(handle, oldname, newname);
608 static int shadow_copy2_stat(vfs_handle_struct *handle,
609 struct smb_filename *smb_fname)
612 char *stripped, *tmp;
613 int ret, saved_errno;
615 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
616 smb_fname->base_name,
617 ×tamp, &stripped)) {
620 if (timestamp == 0) {
621 return SMB_VFS_NEXT_STAT(handle, smb_fname);
624 tmp = smb_fname->base_name;
625 smb_fname->base_name = shadow_copy2_convert(
626 talloc_tos(), handle, stripped, timestamp);
627 TALLOC_FREE(stripped);
629 if (smb_fname->base_name == NULL) {
630 smb_fname->base_name = tmp;
634 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
637 TALLOC_FREE(smb_fname->base_name);
638 smb_fname->base_name = tmp;
641 convert_sbuf(handle, smb_fname->base_name, &smb_fname->st);
647 static int shadow_copy2_lstat(vfs_handle_struct *handle,
648 struct smb_filename *smb_fname)
651 char *stripped, *tmp;
652 int ret, saved_errno;
654 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
655 smb_fname->base_name,
656 ×tamp, &stripped)) {
659 if (timestamp == 0) {
660 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
663 tmp = smb_fname->base_name;
664 smb_fname->base_name = shadow_copy2_convert(
665 talloc_tos(), handle, stripped, timestamp);
666 TALLOC_FREE(stripped);
668 if (smb_fname->base_name == NULL) {
669 smb_fname->base_name = tmp;
673 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
676 TALLOC_FREE(smb_fname->base_name);
677 smb_fname->base_name = tmp;
680 convert_sbuf(handle, smb_fname->base_name, &smb_fname->st);
686 static int shadow_copy2_fstat(vfs_handle_struct *handle, files_struct *fsp,
687 SMB_STRUCT_STAT *sbuf)
692 ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
696 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
697 fsp->fsp_name->base_name,
701 if (timestamp != 0) {
702 convert_sbuf(handle, fsp->fsp_name->base_name, sbuf);
707 static int shadow_copy2_open(vfs_handle_struct *handle,
708 struct smb_filename *smb_fname, files_struct *fsp,
709 int flags, mode_t mode)
712 char *stripped, *tmp;
713 int ret, saved_errno;
715 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
716 smb_fname->base_name,
717 ×tamp, &stripped)) {
720 if (timestamp == 0) {
721 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
724 tmp = smb_fname->base_name;
725 smb_fname->base_name = shadow_copy2_convert(
726 talloc_tos(), handle, stripped, timestamp);
727 TALLOC_FREE(stripped);
729 if (smb_fname->base_name == NULL) {
730 smb_fname->base_name = tmp;
734 ret = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
737 TALLOC_FREE(smb_fname->base_name);
738 smb_fname->base_name = tmp;
744 static int shadow_copy2_unlink(vfs_handle_struct *handle,
745 const struct smb_filename *smb_fname)
749 int ret, saved_errno;
750 struct smb_filename *conv;
752 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
753 smb_fname->base_name,
754 ×tamp, &stripped)) {
757 if (timestamp == 0) {
758 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
760 conv = cp_smb_filename(talloc_tos(), smb_fname);
765 conv->base_name = shadow_copy2_convert(
766 conv, handle, stripped, timestamp);
767 TALLOC_FREE(stripped);
768 if (conv->base_name == NULL) {
771 ret = SMB_VFS_NEXT_UNLINK(handle, conv);
778 static int shadow_copy2_chmod(vfs_handle_struct *handle, const char *fname,
783 int ret, saved_errno;
786 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
787 ×tamp, &stripped)) {
790 if (timestamp == 0) {
791 return SMB_VFS_NEXT_CHMOD(handle, fname, mode);
793 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
794 TALLOC_FREE(stripped);
798 ret = SMB_VFS_NEXT_CHMOD(handle, conv, mode);
805 static int shadow_copy2_chown(vfs_handle_struct *handle, const char *fname,
806 uid_t uid, gid_t gid)
810 int ret, saved_errno;
813 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
814 ×tamp, &stripped)) {
817 if (timestamp == 0) {
818 return SMB_VFS_NEXT_CHOWN(handle, fname, uid, gid);
820 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
821 TALLOC_FREE(stripped);
825 ret = SMB_VFS_NEXT_CHOWN(handle, conv, uid, gid);
832 static int shadow_copy2_chdir(vfs_handle_struct *handle,
837 int ret, saved_errno;
840 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
841 ×tamp, &stripped)) {
844 if (timestamp == 0) {
845 return SMB_VFS_NEXT_CHDIR(handle, fname);
847 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
848 TALLOC_FREE(stripped);
852 ret = SMB_VFS_NEXT_CHDIR(handle, conv);
859 static int shadow_copy2_ntimes(vfs_handle_struct *handle,
860 const struct smb_filename *smb_fname,
861 struct smb_file_time *ft)
865 int ret, saved_errno;
866 struct smb_filename *conv;
868 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
869 smb_fname->base_name,
870 ×tamp, &stripped)) {
873 if (timestamp == 0) {
874 return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
876 conv = cp_smb_filename(talloc_tos(), smb_fname);
881 conv->base_name = shadow_copy2_convert(
882 conv, handle, stripped, timestamp);
883 TALLOC_FREE(stripped);
884 if (conv->base_name == NULL) {
887 ret = SMB_VFS_NEXT_NTIMES(handle, conv, ft);
894 static int shadow_copy2_readlink(vfs_handle_struct *handle,
895 const char *fname, char *buf, size_t bufsiz)
899 int ret, saved_errno;
902 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
903 ×tamp, &stripped)) {
906 if (timestamp == 0) {
907 return SMB_VFS_NEXT_READLINK(handle, fname, buf, bufsiz);
909 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
910 TALLOC_FREE(stripped);
914 ret = SMB_VFS_NEXT_READLINK(handle, conv, buf, bufsiz);
921 static int shadow_copy2_mknod(vfs_handle_struct *handle,
922 const char *fname, mode_t mode, SMB_DEV_T dev)
926 int ret, saved_errno;
929 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
930 ×tamp, &stripped)) {
933 if (timestamp == 0) {
934 return SMB_VFS_NEXT_MKNOD(handle, fname, mode, dev);
936 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
937 TALLOC_FREE(stripped);
941 ret = SMB_VFS_NEXT_MKNOD(handle, conv, mode, dev);
948 static char *shadow_copy2_realpath(vfs_handle_struct *handle,
952 char *stripped = NULL;
955 char *inserted = NULL;
956 char *inserted_to, *inserted_end;
959 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
960 ×tamp, &stripped)) {
963 if (timestamp == 0) {
964 return SMB_VFS_NEXT_REALPATH(handle, fname);
967 tmp = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
972 result = SMB_VFS_NEXT_REALPATH(handle, tmp);
973 if (result == NULL) {
978 * Take away what we've inserted. This removes the @GMT-thingy
979 * completely, but will give a path under the share root.
981 inserted = shadow_copy2_insert_string(talloc_tos(), handle, timestamp);
982 if (inserted == NULL) {
985 inserted_to = strstr_m(result, inserted);
986 if (inserted_to == NULL) {
987 DEBUG(2, ("SMB_VFS_NEXT_REALPATH removed %s\n", inserted));
990 inserted_end = inserted_to + talloc_get_size(inserted) - 1;
991 memmove(inserted_to, inserted_end, strlen(inserted_end)+1);
995 TALLOC_FREE(inserted);
997 TALLOC_FREE(stripped);
1003 * Check whether a given directory contains a
1004 * snapshot directory as direct subdirectory.
1005 * If yes, return the path of the snapshot-subdir,
1006 * otherwise return NULL.
1008 static char *have_snapdir(struct vfs_handle_struct *handle,
1011 struct smb_filename smb_fname;
1013 struct shadow_copy2_config *config;
1015 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1018 ZERO_STRUCT(smb_fname);
1019 smb_fname.base_name = talloc_asprintf(talloc_tos(), "%s/%s",
1020 path, config->snapdir);
1021 if (smb_fname.base_name == NULL) {
1025 ret = SMB_VFS_NEXT_STAT(handle, &smb_fname);
1026 if ((ret == 0) && (S_ISDIR(smb_fname.st.st_ex_mode))) {
1027 return smb_fname.base_name;
1029 TALLOC_FREE(smb_fname.base_name);
1034 * Find the snapshot directory (if any) for the given
1035 * filename (which is relative to the share).
1037 static char *shadow_copy2_find_snapdir(TALLOC_CTX *mem_ctx,
1038 struct vfs_handle_struct *handle,
1039 struct smb_filename *smb_fname)
1043 struct shadow_copy2_config *config;
1045 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1048 path = talloc_asprintf(mem_ctx, "%s/%s",
1049 handle->conn->connectpath,
1050 smb_fname->base_name);
1055 snapdir = have_snapdir(handle, path);
1056 if (snapdir != NULL) {
1061 while ((p = strrchr(path, '/')) && (p > path)) {
1065 snapdir = have_snapdir(handle, path);
1066 if (snapdir != NULL) {
1075 static bool shadow_copy2_snapshot_to_gmt(vfs_handle_struct *handle,
1077 char *gmt, size_t gmt_len)
1079 struct tm timestamp;
1081 unsigned long int timestamp_long;
1083 struct shadow_copy2_config *config;
1085 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1088 fmt = config->gmt_format;
1090 ZERO_STRUCT(timestamp);
1091 if (config->use_sscanf) {
1092 if (sscanf(name, fmt, ×tamp_long) != 1) {
1093 DEBUG(10, ("shadow_copy2_snapshot_to_gmt: "
1094 "no sscanf match %s: %s\n",
1098 timestamp_t = timestamp_long;
1099 gmtime_r(×tamp_t, ×tamp);
1101 if (strptime(name, fmt, ×tamp) == NULL) {
1102 DEBUG(10, ("shadow_copy2_snapshot_to_gmt: "
1103 "no match %s: %s\n",
1107 DEBUG(10, ("shadow_copy2_snapshot_to_gmt: match %s: %s\n",
1110 if (config->use_localtime) {
1111 timestamp.tm_isdst = -1;
1112 timestamp_t = mktime(×tamp);
1113 gmtime_r(×tamp_t, ×tamp);
1117 strftime(gmt, gmt_len, GMT_FORMAT, ×tamp);
1121 static int shadow_copy2_label_cmp_asc(const void *x, const void *y)
1123 return strncmp((const char *)x, (const char *)y, sizeof(SHADOW_COPY_LABEL));
1126 static int shadow_copy2_label_cmp_desc(const void *x, const void *y)
1128 return -strncmp((const char *)x, (const char *)y, sizeof(SHADOW_COPY_LABEL));
1132 sort the shadow copy data in ascending or descending order
1134 static void shadow_copy2_sort_data(vfs_handle_struct *handle,
1135 struct shadow_copy_data *shadow_copy2_data)
1137 int (*cmpfunc)(const void *, const void *);
1139 struct shadow_copy2_config *config;
1141 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1144 sort = config->sort_order;
1149 if (strcmp(sort, "asc") == 0) {
1150 cmpfunc = shadow_copy2_label_cmp_asc;
1151 } else if (strcmp(sort, "desc") == 0) {
1152 cmpfunc = shadow_copy2_label_cmp_desc;
1157 if (shadow_copy2_data && shadow_copy2_data->num_volumes > 0 &&
1158 shadow_copy2_data->labels)
1160 TYPESAFE_QSORT(shadow_copy2_data->labels,
1161 shadow_copy2_data->num_volumes,
1166 static int shadow_copy2_get_shadow_copy_data(
1167 vfs_handle_struct *handle, files_struct *fsp,
1168 struct shadow_copy_data *shadow_copy2_data,
1172 const char *snapdir;
1174 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1176 snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle, fsp->fsp_name);
1177 if (snapdir == NULL) {
1178 DEBUG(0,("shadow:snapdir not found for %s in get_shadow_copy_data\n",
1179 handle->conn->connectpath));
1181 talloc_free(tmp_ctx);
1185 p = SMB_VFS_NEXT_OPENDIR(handle, snapdir, NULL, 0);
1188 DEBUG(2,("shadow_copy2: SMB_VFS_NEXT_OPENDIR() failed for '%s'"
1189 " - %s\n", snapdir, strerror(errno)));
1190 talloc_free(tmp_ctx);
1195 shadow_copy2_data->num_volumes = 0;
1196 shadow_copy2_data->labels = NULL;
1198 while ((d = SMB_VFS_NEXT_READDIR(handle, p, NULL))) {
1199 char snapshot[GMT_NAME_LEN+1];
1200 SHADOW_COPY_LABEL *tlabels;
1203 * ignore names not of the right form in the snapshot
1206 if (!shadow_copy2_snapshot_to_gmt(
1208 snapshot, sizeof(snapshot))) {
1210 DEBUG(6, ("shadow_copy2_get_shadow_copy_data: "
1211 "ignoring %s\n", d->d_name));
1214 DEBUG(6,("shadow_copy2_get_shadow_copy_data: %s -> %s\n",
1215 d->d_name, snapshot));
1218 /* the caller doesn't want the labels */
1219 shadow_copy2_data->num_volumes++;
1223 tlabels = talloc_realloc(shadow_copy2_data,
1224 shadow_copy2_data->labels,
1226 shadow_copy2_data->num_volumes+1);
1227 if (tlabels == NULL) {
1228 DEBUG(0,("shadow_copy2: out of memory\n"));
1229 SMB_VFS_NEXT_CLOSEDIR(handle, p);
1230 talloc_free(tmp_ctx);
1234 strlcpy(tlabels[shadow_copy2_data->num_volumes], snapshot,
1237 shadow_copy2_data->num_volumes++;
1238 shadow_copy2_data->labels = tlabels;
1241 SMB_VFS_NEXT_CLOSEDIR(handle,p);
1243 shadow_copy2_sort_data(handle, shadow_copy2_data);
1245 talloc_free(tmp_ctx);
1249 static NTSTATUS shadow_copy2_fget_nt_acl(vfs_handle_struct *handle,
1250 struct files_struct *fsp,
1251 uint32 security_info,
1252 TALLOC_CTX *mem_ctx,
1253 struct security_descriptor **ppdesc)
1260 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
1261 fsp->fsp_name->base_name,
1262 ×tamp, &stripped)) {
1263 return map_nt_error_from_unix(errno);
1265 if (timestamp == 0) {
1266 return SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
1270 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1271 TALLOC_FREE(stripped);
1273 return map_nt_error_from_unix(errno);
1275 status = SMB_VFS_NEXT_GET_NT_ACL(handle, conv, security_info,
1281 static NTSTATUS shadow_copy2_get_nt_acl(vfs_handle_struct *handle,
1283 uint32 security_info,
1284 TALLOC_CTX *mem_ctx,
1285 struct security_descriptor **ppdesc)
1292 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1293 ×tamp, &stripped)) {
1294 return map_nt_error_from_unix(errno);
1296 if (timestamp == 0) {
1297 return SMB_VFS_NEXT_GET_NT_ACL(handle, fname, security_info,
1300 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1301 TALLOC_FREE(stripped);
1303 return map_nt_error_from_unix(errno);
1305 status = SMB_VFS_NEXT_GET_NT_ACL(handle, conv, security_info,
1311 static int shadow_copy2_mkdir(vfs_handle_struct *handle,
1312 const char *fname, mode_t mode)
1316 int ret, saved_errno;
1319 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1320 ×tamp, &stripped)) {
1323 if (timestamp == 0) {
1324 return SMB_VFS_NEXT_MKDIR(handle, fname, mode);
1326 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1327 TALLOC_FREE(stripped);
1331 ret = SMB_VFS_NEXT_MKDIR(handle, conv, mode);
1332 saved_errno = errno;
1334 errno = saved_errno;
1338 static int shadow_copy2_rmdir(vfs_handle_struct *handle, const char *fname)
1342 int ret, saved_errno;
1345 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1346 ×tamp, &stripped)) {
1349 if (timestamp == 0) {
1350 return SMB_VFS_NEXT_RMDIR(handle, fname);
1352 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1353 TALLOC_FREE(stripped);
1357 ret = SMB_VFS_NEXT_RMDIR(handle, conv);
1358 saved_errno = errno;
1360 errno = saved_errno;
1364 static int shadow_copy2_chflags(vfs_handle_struct *handle, const char *fname,
1369 int ret, saved_errno;
1372 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1373 ×tamp, &stripped)) {
1376 if (timestamp == 0) {
1377 return SMB_VFS_NEXT_CHFLAGS(handle, fname, flags);
1379 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1380 TALLOC_FREE(stripped);
1384 ret = SMB_VFS_NEXT_CHFLAGS(handle, conv, flags);
1385 saved_errno = errno;
1387 errno = saved_errno;
1391 static ssize_t shadow_copy2_getxattr(vfs_handle_struct *handle,
1392 const char *fname, const char *aname,
1393 void *value, size_t size)
1401 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1402 ×tamp, &stripped)) {
1405 if (timestamp == 0) {
1406 return SMB_VFS_NEXT_GETXATTR(handle, fname, aname, value,
1409 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1410 TALLOC_FREE(stripped);
1414 ret = SMB_VFS_NEXT_GETXATTR(handle, conv, aname, value, size);
1415 saved_errno = errno;
1417 errno = saved_errno;
1421 static ssize_t shadow_copy2_listxattr(struct vfs_handle_struct *handle,
1423 char *list, size_t size)
1431 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1432 ×tamp, &stripped)) {
1435 if (timestamp == 0) {
1436 return SMB_VFS_NEXT_LISTXATTR(handle, fname, list, size);
1438 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1439 TALLOC_FREE(stripped);
1443 ret = SMB_VFS_NEXT_LISTXATTR(handle, conv, list, size);
1444 saved_errno = errno;
1446 errno = saved_errno;
1450 static int shadow_copy2_removexattr(vfs_handle_struct *handle,
1451 const char *fname, const char *aname)
1455 int ret, saved_errno;
1458 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1459 ×tamp, &stripped)) {
1462 if (timestamp == 0) {
1463 return SMB_VFS_NEXT_REMOVEXATTR(handle, fname, aname);
1465 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1466 TALLOC_FREE(stripped);
1470 ret = SMB_VFS_NEXT_REMOVEXATTR(handle, conv, aname);
1471 saved_errno = errno;
1473 errno = saved_errno;
1477 static int shadow_copy2_setxattr(struct vfs_handle_struct *handle,
1479 const char *aname, const void *value,
1480 size_t size, int flags)
1488 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1489 ×tamp, &stripped)) {
1492 if (timestamp == 0) {
1493 return SMB_VFS_NEXT_SETXATTR(handle, fname, aname, value, size,
1496 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1497 TALLOC_FREE(stripped);
1501 ret = SMB_VFS_NEXT_SETXATTR(handle, conv, aname, value, size, flags);
1502 saved_errno = errno;
1504 errno = saved_errno;
1508 static int shadow_copy2_chmod_acl(vfs_handle_struct *handle,
1509 const char *fname, mode_t mode)
1517 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1518 ×tamp, &stripped)) {
1521 if (timestamp == 0) {
1522 return SMB_VFS_NEXT_CHMOD_ACL(handle, fname, mode);
1524 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1525 TALLOC_FREE(stripped);
1529 ret = SMB_VFS_NEXT_CHMOD_ACL(handle, conv, mode);
1530 saved_errno = errno;
1532 errno = saved_errno;
1536 static int shadow_copy2_get_real_filename(struct vfs_handle_struct *handle,
1539 TALLOC_CTX *mem_ctx,
1548 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, path,
1549 ×tamp, &stripped)) {
1552 if (timestamp == 0) {
1553 return SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name,
1554 mem_ctx, found_name);
1556 if (stripped[0] == '\0') {
1557 *found_name = talloc_strdup(mem_ctx, name);
1558 if (*found_name == NULL) {
1564 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1565 TALLOC_FREE(stripped);
1569 ret = SMB_VFS_NEXT_GET_REAL_FILENAME(handle, conv, name,
1570 mem_ctx, found_name);
1571 saved_errno = errno;
1573 errno = saved_errno;
1577 static int shadow_copy2_connect(struct vfs_handle_struct *handle,
1578 const char *service, const char *user)
1580 struct shadow_copy2_config *config;
1582 const char *snapdir;
1583 const char *gmt_format;
1584 const char *sort_order;
1585 const char *basedir;
1586 const char *mount_point;
1588 DEBUG(10, (__location__ ": cnum[%u], connectpath[%s]\n",
1589 (unsigned)handle->conn->cnum,
1590 handle->conn->connectpath));
1592 ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
1597 config = talloc_zero(handle->conn, struct shadow_copy2_config);
1598 if (config == NULL) {
1599 DEBUG(0, ("talloc_zero() failed\n"));
1604 gmt_format = lp_parm_const_string(SNUM(handle->conn),
1607 config->gmt_format = talloc_strdup(config, gmt_format);
1608 if (config->gmt_format == NULL) {
1609 DEBUG(0, ("talloc_strdup() failed\n"));
1614 config->use_sscanf = lp_parm_bool(SNUM(handle->conn),
1615 "shadow", "sscanf", false);
1617 config->use_localtime = lp_parm_bool(SNUM(handle->conn),
1618 "shadow", "localtime",
1621 snapdir = lp_parm_const_string(SNUM(handle->conn),
1622 "shadow", "snapdir",
1624 config->snapdir = talloc_strdup(config, snapdir);
1625 if (config->snapdir == NULL) {
1626 DEBUG(0, ("talloc_strdup() failed\n"));
1631 config->snapdirseverywhere = lp_parm_bool(SNUM(handle->conn),
1633 "snapdirseverywhere",
1636 config->crossmountpoints = lp_parm_bool(SNUM(handle->conn),
1637 "shadow", "crossmountpoints",
1640 config->fixinodes = lp_parm_bool(SNUM(handle->conn),
1641 "shadow", "fixinodes",
1644 sort_order = lp_parm_const_string(SNUM(handle->conn),
1645 "shadow", "sort", "desc");
1646 config->sort_order = talloc_strdup(config, sort_order);
1647 if (config->sort_order == NULL) {
1648 DEBUG(0, ("talloc_strdup() failed\n"));
1653 mount_point = lp_parm_const_string(SNUM(handle->conn),
1654 "shadow", "mountpoint", NULL);
1655 if (mount_point != NULL) {
1656 if (mount_point[0] != '/') {
1657 DEBUG(1, (__location__ " Warning: 'mountpoint' is "
1658 "relative ('%s'), but it has to be an "
1659 "absolute path. Ignoring provided value.\n",
1664 p = strstr(handle->conn->connectpath, mount_point);
1665 if (p != handle->conn->connectpath) {
1666 DEBUG(1, ("Warning: mount_point (%s) is not a "
1667 "subdirectory of the share root "
1668 "(%s). Ignoring provided value.\n",
1670 handle->conn->connectpath));
1676 if (mount_point != NULL) {
1677 config->mount_point = talloc_strdup(config, mount_point);
1678 if (config->mount_point == NULL) {
1679 DEBUG(0, (__location__ " talloc_strdup() failed\n"));
1683 config->mount_point = shadow_copy2_find_mount_point(config,
1685 if (config->mount_point == NULL) {
1686 DEBUG(0, (__location__ ": shadow_copy2_find_mount_point"
1687 " failed: %s\n", strerror(errno)));
1692 basedir = lp_parm_const_string(SNUM(handle->conn),
1693 "shadow", "basedir", NULL);
1695 if (basedir != NULL) {
1696 if (basedir[0] != '/') {
1697 DEBUG(1, (__location__ " Warning: 'basedir' is "
1698 "relative ('%s'), but it has to be an "
1699 "absolute path. Disabling basedir.\n",
1703 p = strstr(basedir, config->mount_point);
1705 DEBUG(1, ("Warning: basedir (%s) is not a "
1706 "subdirectory of the share root's "
1707 "mount point (%s). "
1708 "Disabling basedir\n",
1709 basedir, config->mount_point));
1711 config->basedir = talloc_strdup(config,
1713 if (config->basedir == NULL) {
1714 DEBUG(0, ("talloc_strdup() failed\n"));
1722 if (config->snapdirseverywhere && config->basedir != NULL) {
1723 DEBUG(1, (__location__ " Warning: 'basedir' is incompatible "
1724 "with 'snapdirseverywhere'. Disabling basedir.\n"));
1725 TALLOC_FREE(config->basedir);
1728 if (config->crossmountpoints && config->basedir != NULL) {
1729 DEBUG(1, (__location__ " Warning: 'basedir' is incompatible "
1730 "with 'crossmountpoints'. Disabling basedir.\n"));
1731 TALLOC_FREE(config->basedir);
1734 if (config->basedir == NULL) {
1735 config->basedir = config->mount_point;
1738 if (config->snapdir[0] == '/') {
1739 config->snapdir_absolute = true;
1740 if (config->snapdirseverywhere == true) {
1741 DEBUG(1, (__location__ " Warning: An absolute snapdir "
1742 "is incompatible with 'snapdirseverywhere', "
1743 "setting 'snapdirseverywhere' to false.\n"));
1744 config->snapdirseverywhere = false;
1747 if (config->crossmountpoints == true) {
1748 DEBUG(1, (__location__ " Warning: 'crossmountpoints' "
1749 "is not supported with an absolute snapdir. "
1750 "Disabling it.\n"));
1751 config->crossmountpoints = false;
1755 SMB_VFS_HANDLE_SET_DATA(handle, config,
1756 NULL, struct shadow_copy2_config,
1762 static struct vfs_fn_pointers vfs_shadow_copy2_fns = {
1763 .connect_fn = shadow_copy2_connect,
1764 .opendir_fn = shadow_copy2_opendir,
1765 .rename_fn = shadow_copy2_rename,
1766 .link_fn = shadow_copy2_link,
1767 .symlink_fn = shadow_copy2_symlink,
1768 .stat_fn = shadow_copy2_stat,
1769 .lstat_fn = shadow_copy2_lstat,
1770 .fstat_fn = shadow_copy2_fstat,
1771 .open_fn = shadow_copy2_open,
1772 .unlink_fn = shadow_copy2_unlink,
1773 .chmod_fn = shadow_copy2_chmod,
1774 .chown_fn = shadow_copy2_chown,
1775 .chdir_fn = shadow_copy2_chdir,
1776 .ntimes_fn = shadow_copy2_ntimes,
1777 .readlink_fn = shadow_copy2_readlink,
1778 .mknod_fn = shadow_copy2_mknod,
1779 .realpath_fn = shadow_copy2_realpath,
1780 .get_nt_acl_fn = shadow_copy2_get_nt_acl,
1781 .fget_nt_acl_fn = shadow_copy2_fget_nt_acl,
1782 .get_shadow_copy_data_fn = shadow_copy2_get_shadow_copy_data,
1783 .mkdir_fn = shadow_copy2_mkdir,
1784 .rmdir_fn = shadow_copy2_rmdir,
1785 .getxattr_fn = shadow_copy2_getxattr,
1786 .listxattr_fn = shadow_copy2_listxattr,
1787 .removexattr_fn = shadow_copy2_removexattr,
1788 .setxattr_fn = shadow_copy2_setxattr,
1789 .chmod_acl_fn = shadow_copy2_chmod_acl,
1790 .chflags_fn = shadow_copy2_chflags,
1791 .get_real_filename_fn = shadow_copy2_get_real_filename,
1794 NTSTATUS vfs_shadow_copy2_init(void);
1795 NTSTATUS vfs_shadow_copy2_init(void)
1797 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1798 "shadow_copy2", &vfs_shadow_copy2_fns);