2 * shadow_copy2: a shadow copy module (second implementation)
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
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.
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.
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.
26 * This is a second implemetation of a shadow copy module for exposing
27 * file system snapshots to windows clients as shadow copies.
29 * See the manual page for documentation.
33 #include "smbd/smbd.h"
34 #include "system/filesys.h"
35 #include "include/ntioctl.h"
38 struct shadow_copy2_config {
43 bool snapdirseverywhere;
44 bool crossmountpoints;
47 bool snapdir_absolute;
49 char *rel_connectpath; /* share root, relative to a snapshot root */
50 char *snapshot_basepath; /* the absolute version of snapdir */
53 static bool shadow_copy2_find_slashes(TALLOC_CTX *mem_ctx, const char *str,
55 unsigned *pnum_offsets)
64 while ((p = strchr(p, '/')) != NULL) {
69 offsets = talloc_array(mem_ctx, size_t, num_offsets);
70 if (offsets == NULL) {
76 while ((p = strchr(p, '/')) != NULL) {
77 offsets[num_offsets] = p-str;
83 *pnum_offsets = num_offsets;
88 * Given a timestamp, build the posix level GMT-tag string
89 * based on the configurable format.
91 static size_t shadow_copy2_posix_gmt_string(struct vfs_handle_struct *handle,
93 char *snaptime_string,
98 struct shadow_copy2_config *config;
100 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
103 if (config->use_sscanf) {
104 snaptime_len = snprintf(snaptime_string,
107 (unsigned long)snapshot);
108 if (snaptime_len <= 0) {
109 DEBUG(10, ("snprintf failed\n"));
113 if (config->use_localtime) {
114 if (localtime_r(&snapshot, &snap_tm) == 0) {
115 DEBUG(10, ("gmtime_r failed\n"));
119 if (gmtime_r(&snapshot, &snap_tm) == 0) {
120 DEBUG(10, ("gmtime_r failed\n"));
124 snaptime_len = strftime(snaptime_string,
128 if (snaptime_len == 0) {
129 DEBUG(10, ("strftime failed\n"));
138 * Given a timestamp, build the string to insert into a path
139 * as a path component for creating the local path to the
140 * snapshot at the given timestamp of the input path.
142 * In the case of a parallel snapdir (specified with an
143 * absolute path), this is the inital portion of the
144 * local path of any snapshot file. The complete path is
145 * obtained by appending the portion of the file's path
146 * below the share root's mountpoint.
148 static char *shadow_copy2_insert_string(TALLOC_CTX *mem_ctx,
149 struct vfs_handle_struct *handle,
152 fstring snaptime_string;
153 size_t snaptime_len = 0;
155 struct shadow_copy2_config *config;
157 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
160 snaptime_len = shadow_copy2_posix_gmt_string(handle,
163 sizeof(snaptime_string));
164 if (snaptime_len <= 0) {
168 if (config->snapdir_absolute) {
169 result = talloc_asprintf(mem_ctx, "%s/%s",
170 config->snapdir, snaptime_string);
172 result = talloc_asprintf(mem_ctx, "/%s/%s",
173 config->snapdir, snaptime_string);
175 if (result == NULL) {
176 DEBUG(1, (__location__ " talloc_asprintf failed\n"));
183 * Build the posix snapshot path for the connection
184 * at the given timestamp, i.e. the absolute posix path
185 * that contains the snapshot for this file system.
187 * This only applies to classical case, i.e. not
188 * to the "snapdirseverywhere" mode.
190 static char *shadow_copy2_snapshot_path(TALLOC_CTX *mem_ctx,
191 struct vfs_handle_struct *handle,
194 fstring snaptime_string;
195 size_t snaptime_len = 0;
197 struct shadow_copy2_config *config;
199 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
202 snaptime_len = shadow_copy2_posix_gmt_string(handle,
205 sizeof(snaptime_string));
206 if (snaptime_len <= 0) {
210 result = talloc_asprintf(mem_ctx, "%s/%s",
211 config->snapshot_basepath, snaptime_string);
212 if (result == NULL) {
213 DEBUG(1, (__location__ " talloc_asprintf failed\n"));
220 * Strip a snapshot component from a filename as
221 * handed in via the smb layer.
222 * Returns the parsed timestamp and the stripped filename.
224 static bool shadow_copy2_strip_snapshot(TALLOC_CTX *mem_ctx,
225 struct vfs_handle_struct *handle,
235 size_t rest_len, dst_len;
236 struct shadow_copy2_config *config;
239 ptrdiff_t len_before_gmt;
241 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
244 DEBUG(10, (__location__ ": enter path '%s'\n", name));
246 p = strstr_m(name, "@GMT-");
248 DEBUG(11, ("@GMT not found\n"));
251 if ((p > name) && (p[-1] != '/')) {
252 /* the GMT-token does not start a path-component */
253 DEBUG(10, ("not at start, p=%p, name=%p, p[-1]=%d\n",
254 p, name, (int)p[-1]));
259 * Figure out whether we got an already converted string. One
260 * case where this happens is in a smb2 create call with the
261 * mxac create blob set. We do the get_acl call on
262 * fsp->fsp_name, which is already converted. We are converted
263 * if we got a file name of the form ".snapshots/@GMT-",
264 * i.e. ".snapshots/" precedes "p".
267 snapdir = lp_parm_const_string(SNUM(handle->conn), "shadow", "snapdir",
269 snapdirlen = strlen(snapdir);
270 len_before_gmt = p - name;
272 if ((len_before_gmt >= (snapdirlen + 1)) && (p[-1] == '/')) {
273 const char *parent_snapdir = p - (snapdirlen+1);
275 DEBUG(10, ("parent_snapdir = %s\n", parent_snapdir));
277 if (strncmp(parent_snapdir, snapdir, snapdirlen) == 0) {
278 DEBUG(10, ("name=%s is already converted\n", name));
282 q = strptime(p, GMT_FORMAT, &tm);
284 DEBUG(10, ("strptime failed\n"));
288 timestamp = timegm(&tm);
289 if (timestamp == (time_t)-1) {
290 DEBUG(10, ("timestamp==-1\n"));
295 * The name consists of only the GMT token or the GMT
296 * token is at the end of the path. XP seems to send
297 * @GMT- at the end under certain circumstances even
298 * with a path prefix.
300 if (pstripped != NULL) {
301 stripped = talloc_strndup(mem_ctx, name, p - name);
302 if (stripped == NULL) {
305 *pstripped = stripped;
307 *ptimestamp = timestamp;
312 * It is not a complete path component, i.e. the path
313 * component continues after the gmt-token.
315 DEBUG(10, ("q[0] = %d\n", (int)q[0]));
320 rest_len = strlen(q);
321 dst_len = (p-name) + rest_len;
323 if (config->snapdirseverywhere) {
326 insert = shadow_copy2_insert_string(talloc_tos(), handle,
328 if (insert == NULL) {
333 DEBUG(10, (__location__ ": snapdirseverywhere mode.\n"
335 "insert string '%s'\n", name, insert));
337 have_insert = (strstr(name, insert+1) != NULL);
338 DEBUG(10, ("have_insert=%d, name=%s, insert+1=%s\n",
339 (int)have_insert, name, insert+1));
341 DEBUG(10, (__location__ ": insert string '%s' found in "
342 "path '%s' found in snapdirseverywhere mode "
343 "==> already converted\n", insert, name));
352 snapshot_path = shadow_copy2_snapshot_path(talloc_tos(),
355 if (snapshot_path == NULL) {
360 DEBUG(10, (__location__ " path: '%s'.\n"
361 "snapshot path: '%s'\n", name, snapshot_path));
363 s = strstr(name, snapshot_path);
366 * this starts with "snapshot_basepath/GMT-Token"
367 * so it is already a converted absolute
368 * path. Don't process further.
370 DEBUG(10, (__location__ ": path '%s' starts with "
371 "snapshot path '%s' (not in "
372 "snapdirseverywhere mode) ==> "
373 "already converted\n", name, snapshot_path));
374 talloc_free(snapshot_path);
377 talloc_free(snapshot_path);
380 if (pstripped != NULL) {
381 stripped = talloc_array(mem_ctx, char, dst_len+1);
382 if (stripped == NULL) {
387 memcpy(stripped, name, p-name);
390 memcpy(stripped + (p-name), q, rest_len);
392 stripped[dst_len] = '\0';
393 *pstripped = stripped;
395 *ptimestamp = timestamp;
402 static char *shadow_copy2_find_mount_point(TALLOC_CTX *mem_ctx,
403 vfs_handle_struct *handle)
405 char *path = talloc_strdup(mem_ctx, handle->conn->connectpath);
410 if (stat(path, &st) != 0) {
417 while ((p = strrchr(path, '/')) && p > path) {
419 if (stat(path, &st) != 0) {
423 if (st.st_dev != dev) {
433 * Convert from a name as handed in via the SMB layer
434 * and a timestamp into the local path of the snapshot
435 * of the provided file at the provided time.
436 * Also return the path in the snapshot corresponding
437 * to the file's share root.
439 static char *shadow_copy2_do_convert(TALLOC_CTX *mem_ctx,
440 struct vfs_handle_struct *handle,
441 const char *name, time_t timestamp,
442 size_t *snaproot_len)
444 struct smb_filename converted_fname;
446 size_t *slashes = NULL;
447 unsigned num_slashes;
451 char *converted = NULL;
452 size_t insertlen, connectlen = 0;
455 struct shadow_copy2_config *config;
456 size_t in_share_offset = 0;
458 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
461 DEBUG(10, ("converting '%s'\n", name));
463 if (!config->snapdirseverywhere) {
467 snapshot_path = shadow_copy2_snapshot_path(talloc_tos(),
470 if (snapshot_path == NULL) {
474 if (config->rel_connectpath == NULL) {
475 converted = talloc_asprintf(mem_ctx, "%s/%s",
476 snapshot_path, name);
478 converted = talloc_asprintf(mem_ctx, "%s/%s/%s",
480 config->rel_connectpath,
483 if (converted == NULL) {
487 ZERO_STRUCT(converted_fname);
488 converted_fname.base_name = converted;
490 ret = SMB_VFS_NEXT_LSTAT(handle, &converted_fname);
491 DEBUG(10, ("Trying[not snapdirseverywhere] %s: %d (%s)\n",
493 ret, ret == 0 ? "ok" : strerror(errno)));
495 DEBUG(10, ("Found %s\n", converted));
498 if (snaproot_len != NULL) {
499 *snaproot_len = strlen(snapshot_path);
500 if (config->rel_connectpath != NULL) {
502 strlen(config->rel_connectpath) + 1;
510 /* never reached ... */
513 connectlen = strlen(handle->conn->connectpath);
515 path = talloc_strdup(mem_ctx, handle->conn->connectpath);
517 path = talloc_asprintf(
518 mem_ctx, "%s/%s", handle->conn->connectpath, name);
524 pathlen = talloc_get_size(path)-1;
526 if (!shadow_copy2_find_slashes(talloc_tos(), path,
527 &slashes, &num_slashes)) {
531 insert = shadow_copy2_insert_string(talloc_tos(), handle, timestamp);
532 if (insert == NULL) {
535 insertlen = talloc_get_size(insert)-1;
538 * Note: We deliberatly don't expensively initialize the
539 * array with talloc_zero here: Putting zero into
540 * converted[pathlen+insertlen] below is sufficient, because
541 * in the following for loop, the insert string is inserted
542 * at various slash places. So the memory up to position
543 * pathlen+insertlen will always be initialized when the
544 * converted string is used.
546 converted = talloc_array(mem_ctx, char, pathlen + insertlen + 1);
547 if (converted == NULL) {
551 if (path[pathlen-1] != '/') {
553 * Append a fake slash to find the snapshot root
556 tmp = talloc_realloc(talloc_tos(), slashes,
557 size_t, num_slashes+1);
562 slashes[num_slashes] = pathlen;
568 if (!config->crossmountpoints) {
569 min_offset = strlen(config->mount_point);
572 memcpy(converted, path, pathlen+1);
573 converted[pathlen+insertlen] = '\0';
575 ZERO_STRUCT(converted_fname);
576 converted_fname.base_name = converted;
578 for (i = num_slashes-1; i>=0; i--) {
584 if (offset < min_offset) {
589 if (offset >= connectlen) {
590 in_share_offset = offset;
593 memcpy(converted+offset, insert, insertlen);
596 memcpy(converted+offset, path + slashes[i],
597 pathlen - slashes[i]);
599 ret = SMB_VFS_NEXT_LSTAT(handle, &converted_fname);
601 DEBUG(10, ("Trying[snapdirseverywhere] %s: %d (%s)\n",
603 ret, ret == 0 ? "ok" : strerror(errno)));
606 if (snaproot_len != NULL) {
607 *snaproot_len = in_share_offset + insertlen;
611 if (errno == ENOTDIR) {
613 * This is a valid condition: We appended the
614 * .snaphots/@GMT.. to a file name. Just try
615 * with the upper levels.
619 if (errno != ENOENT) {
620 /* Other problem than "not found" */
629 DEBUG(10, ("Found %s\n", converted));
637 TALLOC_FREE(converted);
639 TALLOC_FREE(slashes);
646 * Convert from a name as handed in via the SMB layer
647 * and a timestamp into the local path of the snapshot
648 * of the provided file at the provided time.
650 static char *shadow_copy2_convert(TALLOC_CTX *mem_ctx,
651 struct vfs_handle_struct *handle,
652 const char *name, time_t timestamp)
654 return shadow_copy2_do_convert(mem_ctx, handle, name, timestamp, NULL);
658 modify a sbuf return to ensure that inodes in the shadow directory
659 are different from those in the main directory
661 static void convert_sbuf(vfs_handle_struct *handle, const char *fname,
662 SMB_STRUCT_STAT *sbuf)
664 struct shadow_copy2_config *config;
666 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
669 if (config->fixinodes) {
670 /* some snapshot systems, like GPFS, return the name
671 device:inode for the snapshot files as the current
672 files. That breaks the 'restore' button in the shadow copy
673 GUI, as the client gets a sharing violation.
675 This is a crude way of allowing both files to be
676 open at once. It has a slight chance of inode
677 number collision, but I can't see a better approach
678 without significant VFS changes
680 TDB_DATA key = { .dptr = discard_const_p(uint8_t, fname),
681 .dsize = strlen(fname) };
684 shash = tdb_jenkins_hash(&key) & 0xFF000000;
688 sbuf->st_ex_ino ^= shash;
692 static DIR *shadow_copy2_opendir(vfs_handle_struct *handle,
693 const struct smb_filename *smb_fname,
702 struct smb_filename *conv_smb_fname = NULL;
704 if (!shadow_copy2_strip_snapshot(talloc_tos(),
706 smb_fname->base_name,
711 if (timestamp == 0) {
712 return SMB_VFS_NEXT_OPENDIR(handle, smb_fname, mask, attr);
714 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
715 TALLOC_FREE(stripped);
719 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
724 if (conv_smb_fname == NULL) {
728 ret = SMB_VFS_NEXT_OPENDIR(handle, conv_smb_fname, mask, attr);
731 TALLOC_FREE(conv_smb_fname);
736 static int shadow_copy2_rename(vfs_handle_struct *handle,
737 const struct smb_filename *smb_fname_src,
738 const struct smb_filename *smb_fname_dst)
740 time_t timestamp_src, timestamp_dst;
742 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
743 smb_fname_src->base_name,
744 ×tamp_src, NULL)) {
747 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
748 smb_fname_dst->base_name,
749 ×tamp_dst, NULL)) {
752 if (timestamp_src != 0) {
756 if (timestamp_dst != 0) {
760 return SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
763 static int shadow_copy2_symlink(vfs_handle_struct *handle,
764 const char *oldname, const char *newname)
766 time_t timestamp_old, timestamp_new;
768 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, oldname,
769 ×tamp_old, NULL)) {
772 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, newname,
773 ×tamp_new, NULL)) {
776 if ((timestamp_old != 0) || (timestamp_new != 0)) {
780 return SMB_VFS_NEXT_SYMLINK(handle, oldname, newname);
783 static int shadow_copy2_link(vfs_handle_struct *handle,
784 const char *oldname, const char *newname)
786 time_t timestamp_old, timestamp_new;
788 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, oldname,
789 ×tamp_old, NULL)) {
792 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, newname,
793 ×tamp_new, NULL)) {
796 if ((timestamp_old != 0) || (timestamp_new != 0)) {
800 return SMB_VFS_NEXT_LINK(handle, oldname, newname);
803 static int shadow_copy2_stat(vfs_handle_struct *handle,
804 struct smb_filename *smb_fname)
807 char *stripped, *tmp;
808 int ret, saved_errno;
810 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
811 smb_fname->base_name,
812 ×tamp, &stripped)) {
815 if (timestamp == 0) {
816 return SMB_VFS_NEXT_STAT(handle, smb_fname);
819 tmp = smb_fname->base_name;
820 smb_fname->base_name = shadow_copy2_convert(
821 talloc_tos(), handle, stripped, timestamp);
822 TALLOC_FREE(stripped);
824 if (smb_fname->base_name == NULL) {
825 smb_fname->base_name = tmp;
829 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
832 TALLOC_FREE(smb_fname->base_name);
833 smb_fname->base_name = tmp;
836 convert_sbuf(handle, smb_fname->base_name, &smb_fname->st);
842 static int shadow_copy2_lstat(vfs_handle_struct *handle,
843 struct smb_filename *smb_fname)
846 char *stripped, *tmp;
847 int ret, saved_errno;
849 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
850 smb_fname->base_name,
851 ×tamp, &stripped)) {
854 if (timestamp == 0) {
855 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
858 tmp = smb_fname->base_name;
859 smb_fname->base_name = shadow_copy2_convert(
860 talloc_tos(), handle, stripped, timestamp);
861 TALLOC_FREE(stripped);
863 if (smb_fname->base_name == NULL) {
864 smb_fname->base_name = tmp;
868 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
871 TALLOC_FREE(smb_fname->base_name);
872 smb_fname->base_name = tmp;
875 convert_sbuf(handle, smb_fname->base_name, &smb_fname->st);
881 static int shadow_copy2_fstat(vfs_handle_struct *handle, files_struct *fsp,
882 SMB_STRUCT_STAT *sbuf)
887 ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
891 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
892 fsp->fsp_name->base_name,
896 if (timestamp != 0) {
897 convert_sbuf(handle, fsp->fsp_name->base_name, sbuf);
902 static int shadow_copy2_open(vfs_handle_struct *handle,
903 struct smb_filename *smb_fname, files_struct *fsp,
904 int flags, mode_t mode)
907 char *stripped, *tmp;
908 int ret, saved_errno;
910 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
911 smb_fname->base_name,
912 ×tamp, &stripped)) {
915 if (timestamp == 0) {
916 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
919 tmp = smb_fname->base_name;
920 smb_fname->base_name = shadow_copy2_convert(
921 talloc_tos(), handle, stripped, timestamp);
922 TALLOC_FREE(stripped);
924 if (smb_fname->base_name == NULL) {
925 smb_fname->base_name = tmp;
929 ret = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
932 TALLOC_FREE(smb_fname->base_name);
933 smb_fname->base_name = tmp;
939 static int shadow_copy2_unlink(vfs_handle_struct *handle,
940 const struct smb_filename *smb_fname)
944 int ret, saved_errno;
945 struct smb_filename *conv;
947 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
948 smb_fname->base_name,
949 ×tamp, &stripped)) {
952 if (timestamp == 0) {
953 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
955 conv = cp_smb_filename(talloc_tos(), smb_fname);
960 conv->base_name = shadow_copy2_convert(
961 conv, handle, stripped, timestamp);
962 TALLOC_FREE(stripped);
963 if (conv->base_name == NULL) {
966 ret = SMB_VFS_NEXT_UNLINK(handle, conv);
973 static int shadow_copy2_chmod(vfs_handle_struct *handle,
974 const struct smb_filename *smb_fname,
978 char *stripped = NULL;
979 int ret, saved_errno;
981 struct smb_filename *conv_smb_fname;
983 if (!shadow_copy2_strip_snapshot(talloc_tos(),
985 smb_fname->base_name,
990 if (timestamp == 0) {
991 TALLOC_FREE(stripped);
992 return SMB_VFS_NEXT_CHMOD(handle, smb_fname, mode);
994 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
995 TALLOC_FREE(stripped);
999 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
1004 if (conv_smb_fname == NULL) {
1010 ret = SMB_VFS_NEXT_CHMOD(handle, conv_smb_fname, mode);
1011 saved_errno = errno;
1013 TALLOC_FREE(conv_smb_fname);
1014 errno = saved_errno;
1018 static int shadow_copy2_chown(vfs_handle_struct *handle,
1019 const struct smb_filename *smb_fname,
1025 int ret, saved_errno;
1027 struct smb_filename *conv_smb_fname = NULL;
1029 if (!shadow_copy2_strip_snapshot(talloc_tos(),
1031 smb_fname->base_name,
1036 if (timestamp == 0) {
1037 return SMB_VFS_NEXT_CHOWN(handle, smb_fname, uid, gid);
1039 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1040 TALLOC_FREE(stripped);
1044 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
1049 if (conv_smb_fname == NULL) {
1054 ret = SMB_VFS_NEXT_CHOWN(handle, conv_smb_fname, uid, gid);
1055 saved_errno = errno;
1057 TALLOC_FREE(conv_smb_fname);
1058 errno = saved_errno;
1062 static int shadow_copy2_chdir(vfs_handle_struct *handle,
1067 int ret, saved_errno;
1070 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1071 ×tamp, &stripped)) {
1074 if (timestamp == 0) {
1075 return SMB_VFS_NEXT_CHDIR(handle, fname);
1077 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1078 TALLOC_FREE(stripped);
1082 ret = SMB_VFS_NEXT_CHDIR(handle, conv);
1083 saved_errno = errno;
1085 errno = saved_errno;
1089 static int shadow_copy2_ntimes(vfs_handle_struct *handle,
1090 const struct smb_filename *smb_fname,
1091 struct smb_file_time *ft)
1095 int ret, saved_errno;
1096 struct smb_filename *conv;
1098 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
1099 smb_fname->base_name,
1100 ×tamp, &stripped)) {
1103 if (timestamp == 0) {
1104 return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
1106 conv = cp_smb_filename(talloc_tos(), smb_fname);
1111 conv->base_name = shadow_copy2_convert(
1112 conv, handle, stripped, timestamp);
1113 TALLOC_FREE(stripped);
1114 if (conv->base_name == NULL) {
1117 ret = SMB_VFS_NEXT_NTIMES(handle, conv, ft);
1118 saved_errno = errno;
1120 errno = saved_errno;
1124 static int shadow_copy2_readlink(vfs_handle_struct *handle,
1125 const char *fname, char *buf, size_t bufsiz)
1129 int ret, saved_errno;
1132 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1133 ×tamp, &stripped)) {
1136 if (timestamp == 0) {
1137 return SMB_VFS_NEXT_READLINK(handle, fname, buf, bufsiz);
1139 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1140 TALLOC_FREE(stripped);
1144 ret = SMB_VFS_NEXT_READLINK(handle, conv, buf, bufsiz);
1145 saved_errno = errno;
1147 errno = saved_errno;
1151 static int shadow_copy2_mknod(vfs_handle_struct *handle,
1152 const char *fname, mode_t mode, SMB_DEV_T dev)
1156 int ret, saved_errno;
1159 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1160 ×tamp, &stripped)) {
1163 if (timestamp == 0) {
1164 return SMB_VFS_NEXT_MKNOD(handle, fname, mode, dev);
1166 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1167 TALLOC_FREE(stripped);
1171 ret = SMB_VFS_NEXT_MKNOD(handle, conv, mode, dev);
1172 saved_errno = errno;
1174 errno = saved_errno;
1178 static char *shadow_copy2_realpath(vfs_handle_struct *handle,
1182 char *stripped = NULL;
1184 char *result = NULL;
1187 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1188 ×tamp, &stripped)) {
1191 if (timestamp == 0) {
1192 return SMB_VFS_NEXT_REALPATH(handle, fname);
1195 tmp = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1200 result = SMB_VFS_NEXT_REALPATH(handle, tmp);
1203 saved_errno = errno;
1205 TALLOC_FREE(stripped);
1206 errno = saved_errno;
1211 * Check whether a given directory contains a
1212 * snapshot directory as direct subdirectory.
1213 * If yes, return the path of the snapshot-subdir,
1214 * otherwise return NULL.
1216 static char *have_snapdir(struct vfs_handle_struct *handle,
1219 struct smb_filename smb_fname;
1221 struct shadow_copy2_config *config;
1223 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1226 ZERO_STRUCT(smb_fname);
1227 smb_fname.base_name = talloc_asprintf(talloc_tos(), "%s/%s",
1228 path, config->snapdir);
1229 if (smb_fname.base_name == NULL) {
1233 ret = SMB_VFS_NEXT_STAT(handle, &smb_fname);
1234 if ((ret == 0) && (S_ISDIR(smb_fname.st.st_ex_mode))) {
1235 return smb_fname.base_name;
1237 TALLOC_FREE(smb_fname.base_name);
1241 static bool check_access_snapdir(struct vfs_handle_struct *handle,
1244 struct smb_filename smb_fname;
1248 ZERO_STRUCT(smb_fname);
1249 smb_fname.base_name = talloc_asprintf(talloc_tos(),
1252 if (smb_fname.base_name == NULL) {
1256 ret = SMB_VFS_NEXT_STAT(handle, &smb_fname);
1257 if (ret != 0 || !S_ISDIR(smb_fname.st.st_ex_mode)) {
1258 TALLOC_FREE(smb_fname.base_name);
1262 status = smbd_check_access_rights(handle->conn,
1266 if (!NT_STATUS_IS_OK(status)) {
1267 DEBUG(0,("user does not have list permission "
1269 smb_fname.base_name));
1270 TALLOC_FREE(smb_fname.base_name);
1273 TALLOC_FREE(smb_fname.base_name);
1278 * Find the snapshot directory (if any) for the given
1279 * filename (which is relative to the share).
1281 static const char *shadow_copy2_find_snapdir(TALLOC_CTX *mem_ctx,
1282 struct vfs_handle_struct *handle,
1283 struct smb_filename *smb_fname)
1286 const char *snapdir;
1287 struct shadow_copy2_config *config;
1289 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1293 * If the non-snapdisrseverywhere mode, we should not search!
1295 if (!config->snapdirseverywhere) {
1296 return config->snapshot_basepath;
1299 path = talloc_asprintf(mem_ctx, "%s/%s",
1300 handle->conn->connectpath,
1301 smb_fname->base_name);
1306 snapdir = have_snapdir(handle, path);
1307 if (snapdir != NULL) {
1312 while ((p = strrchr(path, '/')) && (p > path)) {
1316 snapdir = have_snapdir(handle, path);
1317 if (snapdir != NULL) {
1326 static bool shadow_copy2_snapshot_to_gmt(vfs_handle_struct *handle,
1328 char *gmt, size_t gmt_len)
1330 struct tm timestamp;
1332 unsigned long int timestamp_long;
1334 struct shadow_copy2_config *config;
1336 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1339 fmt = config->gmt_format;
1341 ZERO_STRUCT(timestamp);
1342 if (config->use_sscanf) {
1343 if (sscanf(name, fmt, ×tamp_long) != 1) {
1344 DEBUG(10, ("shadow_copy2_snapshot_to_gmt: "
1345 "no sscanf match %s: %s\n",
1349 timestamp_t = timestamp_long;
1350 gmtime_r(×tamp_t, ×tamp);
1352 if (strptime(name, fmt, ×tamp) == NULL) {
1353 DEBUG(10, ("shadow_copy2_snapshot_to_gmt: "
1354 "no match %s: %s\n",
1358 DEBUG(10, ("shadow_copy2_snapshot_to_gmt: match %s: %s\n",
1361 if (config->use_localtime) {
1362 timestamp.tm_isdst = -1;
1363 timestamp_t = mktime(×tamp);
1364 gmtime_r(×tamp_t, ×tamp);
1368 strftime(gmt, gmt_len, GMT_FORMAT, ×tamp);
1372 static int shadow_copy2_label_cmp_asc(const void *x, const void *y)
1374 return strncmp((const char *)x, (const char *)y, sizeof(SHADOW_COPY_LABEL));
1377 static int shadow_copy2_label_cmp_desc(const void *x, const void *y)
1379 return -strncmp((const char *)x, (const char *)y, sizeof(SHADOW_COPY_LABEL));
1383 sort the shadow copy data in ascending or descending order
1385 static void shadow_copy2_sort_data(vfs_handle_struct *handle,
1386 struct shadow_copy_data *shadow_copy2_data)
1388 int (*cmpfunc)(const void *, const void *);
1390 struct shadow_copy2_config *config;
1392 SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1395 sort = config->sort_order;
1400 if (strcmp(sort, "asc") == 0) {
1401 cmpfunc = shadow_copy2_label_cmp_asc;
1402 } else if (strcmp(sort, "desc") == 0) {
1403 cmpfunc = shadow_copy2_label_cmp_desc;
1408 if (shadow_copy2_data && shadow_copy2_data->num_volumes > 0 &&
1409 shadow_copy2_data->labels)
1411 TYPESAFE_QSORT(shadow_copy2_data->labels,
1412 shadow_copy2_data->num_volumes,
1417 static int shadow_copy2_get_shadow_copy_data(
1418 vfs_handle_struct *handle, files_struct *fsp,
1419 struct shadow_copy_data *shadow_copy2_data,
1423 const char *snapdir;
1424 struct smb_filename *snapdir_smb_fname = NULL;
1426 TALLOC_CTX *tmp_ctx = talloc_stackframe();
1429 snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle, fsp->fsp_name);
1430 if (snapdir == NULL) {
1431 DEBUG(0,("shadow:snapdir not found for %s in get_shadow_copy_data\n",
1432 handle->conn->connectpath));
1434 talloc_free(tmp_ctx);
1437 ret = check_access_snapdir(handle, snapdir);
1439 DEBUG(0,("access denied on listing snapdir %s\n", snapdir));
1441 talloc_free(tmp_ctx);
1445 snapdir_smb_fname = synthetic_smb_fname(talloc_tos(),
1449 fsp->fsp_name->flags);
1450 if (snapdir_smb_fname == NULL) {
1452 talloc_free(tmp_ctx);
1456 p = SMB_VFS_NEXT_OPENDIR(handle, snapdir_smb_fname, NULL, 0);
1459 DEBUG(2,("shadow_copy2: SMB_VFS_NEXT_OPENDIR() failed for '%s'"
1460 " - %s\n", snapdir, strerror(errno)));
1461 talloc_free(tmp_ctx);
1466 shadow_copy2_data->num_volumes = 0;
1467 shadow_copy2_data->labels = NULL;
1469 while ((d = SMB_VFS_NEXT_READDIR(handle, p, NULL))) {
1470 char snapshot[GMT_NAME_LEN+1];
1471 SHADOW_COPY_LABEL *tlabels;
1474 * ignore names not of the right form in the snapshot
1477 if (!shadow_copy2_snapshot_to_gmt(
1479 snapshot, sizeof(snapshot))) {
1481 DEBUG(6, ("shadow_copy2_get_shadow_copy_data: "
1482 "ignoring %s\n", d->d_name));
1485 DEBUG(6,("shadow_copy2_get_shadow_copy_data: %s -> %s\n",
1486 d->d_name, snapshot));
1489 /* the caller doesn't want the labels */
1490 shadow_copy2_data->num_volumes++;
1494 tlabels = talloc_realloc(shadow_copy2_data,
1495 shadow_copy2_data->labels,
1497 shadow_copy2_data->num_volumes+1);
1498 if (tlabels == NULL) {
1499 DEBUG(0,("shadow_copy2: out of memory\n"));
1500 SMB_VFS_NEXT_CLOSEDIR(handle, p);
1501 talloc_free(tmp_ctx);
1505 strlcpy(tlabels[shadow_copy2_data->num_volumes], snapshot,
1508 shadow_copy2_data->num_volumes++;
1509 shadow_copy2_data->labels = tlabels;
1512 SMB_VFS_NEXT_CLOSEDIR(handle,p);
1514 shadow_copy2_sort_data(handle, shadow_copy2_data);
1516 talloc_free(tmp_ctx);
1520 static NTSTATUS shadow_copy2_fget_nt_acl(vfs_handle_struct *handle,
1521 struct files_struct *fsp,
1522 uint32_t security_info,
1523 TALLOC_CTX *mem_ctx,
1524 struct security_descriptor **ppdesc)
1530 struct smb_filename *smb_fname = NULL;
1532 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
1533 fsp->fsp_name->base_name,
1534 ×tamp, &stripped)) {
1535 return map_nt_error_from_unix(errno);
1537 if (timestamp == 0) {
1538 return SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
1542 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1543 TALLOC_FREE(stripped);
1545 return map_nt_error_from_unix(errno);
1547 smb_fname = synthetic_smb_fname(talloc_tos(),
1551 fsp->fsp_name->flags);
1552 if (smb_fname == NULL) {
1554 return NT_STATUS_NO_MEMORY;
1557 status = SMB_VFS_NEXT_GET_NT_ACL(handle, smb_fname, security_info,
1560 TALLOC_FREE(smb_fname);
1564 static NTSTATUS shadow_copy2_get_nt_acl(vfs_handle_struct *handle,
1565 const struct smb_filename *smb_fname,
1566 uint32_t security_info,
1567 TALLOC_CTX *mem_ctx,
1568 struct security_descriptor **ppdesc)
1574 struct smb_filename *conv_smb_fname = NULL;
1576 if (!shadow_copy2_strip_snapshot(talloc_tos(),
1578 smb_fname->base_name,
1581 return map_nt_error_from_unix(errno);
1583 if (timestamp == 0) {
1584 return SMB_VFS_NEXT_GET_NT_ACL(handle, smb_fname, security_info,
1587 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1588 TALLOC_FREE(stripped);
1590 return map_nt_error_from_unix(errno);
1592 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
1597 if (conv_smb_fname == NULL) {
1599 return NT_STATUS_NO_MEMORY;
1601 status = SMB_VFS_NEXT_GET_NT_ACL(handle, conv_smb_fname, security_info,
1604 TALLOC_FREE(conv_smb_fname);
1608 static int shadow_copy2_mkdir(vfs_handle_struct *handle,
1609 const struct smb_filename *smb_fname,
1614 int ret, saved_errno;
1616 struct smb_filename *conv_smb_fname = NULL;
1618 if (!shadow_copy2_strip_snapshot(talloc_tos(),
1620 smb_fname->base_name,
1625 if (timestamp == 0) {
1626 return SMB_VFS_NEXT_MKDIR(handle, smb_fname, mode);
1628 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1629 TALLOC_FREE(stripped);
1633 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
1638 if (conv_smb_fname == NULL) {
1642 ret = SMB_VFS_NEXT_MKDIR(handle, conv_smb_fname, mode);
1643 saved_errno = errno;
1645 TALLOC_FREE(conv_smb_fname);
1646 errno = saved_errno;
1650 static int shadow_copy2_rmdir(vfs_handle_struct *handle,
1651 const struct smb_filename *smb_fname)
1655 int ret, saved_errno;
1657 struct smb_filename *conv_smb_fname = NULL;
1659 if (!shadow_copy2_strip_snapshot(talloc_tos(),
1661 smb_fname->base_name,
1666 if (timestamp == 0) {
1667 return SMB_VFS_NEXT_RMDIR(handle, smb_fname);
1669 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1670 TALLOC_FREE(stripped);
1674 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
1679 if (conv_smb_fname == NULL) {
1683 ret = SMB_VFS_NEXT_RMDIR(handle, conv_smb_fname);
1684 saved_errno = errno;
1685 TALLOC_FREE(conv_smb_fname);
1687 errno = saved_errno;
1691 static int shadow_copy2_chflags(vfs_handle_struct *handle, const char *fname,
1696 int ret, saved_errno;
1699 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1700 ×tamp, &stripped)) {
1703 if (timestamp == 0) {
1704 return SMB_VFS_NEXT_CHFLAGS(handle, fname, flags);
1706 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1707 TALLOC_FREE(stripped);
1711 ret = SMB_VFS_NEXT_CHFLAGS(handle, conv, flags);
1712 saved_errno = errno;
1714 errno = saved_errno;
1718 static ssize_t shadow_copy2_getxattr(vfs_handle_struct *handle,
1719 const char *fname, const char *aname,
1720 void *value, size_t size)
1728 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1729 ×tamp, &stripped)) {
1732 if (timestamp == 0) {
1733 return SMB_VFS_NEXT_GETXATTR(handle, fname, aname, value,
1736 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1737 TALLOC_FREE(stripped);
1741 ret = SMB_VFS_NEXT_GETXATTR(handle, conv, aname, value, size);
1742 saved_errno = errno;
1744 errno = saved_errno;
1748 static ssize_t shadow_copy2_listxattr(struct vfs_handle_struct *handle,
1750 char *list, size_t size)
1758 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1759 ×tamp, &stripped)) {
1762 if (timestamp == 0) {
1763 return SMB_VFS_NEXT_LISTXATTR(handle, fname, list, size);
1765 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1766 TALLOC_FREE(stripped);
1770 ret = SMB_VFS_NEXT_LISTXATTR(handle, conv, list, size);
1771 saved_errno = errno;
1773 errno = saved_errno;
1777 static int shadow_copy2_removexattr(vfs_handle_struct *handle,
1778 const char *fname, const char *aname)
1782 int ret, saved_errno;
1785 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1786 ×tamp, &stripped)) {
1789 if (timestamp == 0) {
1790 return SMB_VFS_NEXT_REMOVEXATTR(handle, fname, aname);
1792 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1793 TALLOC_FREE(stripped);
1797 ret = SMB_VFS_NEXT_REMOVEXATTR(handle, conv, aname);
1798 saved_errno = errno;
1800 errno = saved_errno;
1804 static int shadow_copy2_setxattr(struct vfs_handle_struct *handle,
1806 const char *aname, const void *value,
1807 size_t size, int flags)
1815 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1816 ×tamp, &stripped)) {
1819 if (timestamp == 0) {
1820 return SMB_VFS_NEXT_SETXATTR(handle, fname, aname, value, size,
1823 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1824 TALLOC_FREE(stripped);
1828 ret = SMB_VFS_NEXT_SETXATTR(handle, conv, aname, value, size, flags);
1829 saved_errno = errno;
1831 errno = saved_errno;
1835 static int shadow_copy2_chmod_acl(vfs_handle_struct *handle,
1836 const struct smb_filename *smb_fname,
1844 struct smb_filename *conv_smb_fname = NULL;
1846 if (!shadow_copy2_strip_snapshot(talloc_tos(),
1848 smb_fname->base_name,
1853 if (timestamp == 0) {
1854 return SMB_VFS_NEXT_CHMOD_ACL(handle, smb_fname, mode);
1856 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1857 TALLOC_FREE(stripped);
1861 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
1866 if (conv_smb_fname == NULL) {
1871 ret = SMB_VFS_NEXT_CHMOD_ACL(handle, conv_smb_fname, mode);
1872 saved_errno = errno;
1874 TALLOC_FREE(conv_smb_fname);
1875 errno = saved_errno;
1879 static int shadow_copy2_get_real_filename(struct vfs_handle_struct *handle,
1882 TALLOC_CTX *mem_ctx,
1891 DEBUG(10, ("shadow_copy2_get_real_filename called for path=[%s], "
1892 "name=[%s]\n", path, name));
1894 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, path,
1895 ×tamp, &stripped)) {
1896 DEBUG(10, ("shadow_copy2_strip_snapshot failed\n"));
1899 if (timestamp == 0) {
1900 DEBUG(10, ("timestamp == 0\n"));
1901 return SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name,
1902 mem_ctx, found_name);
1904 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1905 TALLOC_FREE(stripped);
1907 DEBUG(10, ("shadow_copy2_convert failed\n"));
1910 DEBUG(10, ("Calling NEXT_GET_REAL_FILE_NAME for conv=[%s], "
1911 "name=[%s]\n", conv, name));
1912 ret = SMB_VFS_NEXT_GET_REAL_FILENAME(handle, conv, name,
1913 mem_ctx, found_name);
1914 DEBUG(10, ("NEXT_REAL_FILE_NAME returned %d\n", (int)ret));
1915 saved_errno = errno;
1917 errno = saved_errno;
1921 static const char *shadow_copy2_connectpath(struct vfs_handle_struct *handle,
1925 char *stripped = NULL;
1927 char *result = NULL;
1929 size_t rootpath_len = 0;
1931 DBG_DEBUG("Calc connect path for [%s]\n", fname);
1933 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1934 ×tamp, &stripped)) {
1937 if (timestamp == 0) {
1938 return SMB_VFS_NEXT_CONNECTPATH(handle, fname);
1941 tmp = shadow_copy2_do_convert(talloc_tos(), handle, stripped, timestamp,
1947 DBG_DEBUG("converted path is [%s] root path is [%.*s]\n", tmp,
1948 (int)rootpath_len, tmp);
1950 tmp[rootpath_len] = '\0';
1951 result = SMB_VFS_NEXT_REALPATH(handle, tmp);
1952 if (result == NULL) {
1956 DBG_DEBUG("connect path is [%s]\n", result);
1959 saved_errno = errno;
1961 TALLOC_FREE(stripped);
1962 errno = saved_errno;
1966 static uint64_t shadow_copy2_disk_free(vfs_handle_struct *handle,
1967 const char *path, uint64_t *bsize,
1968 uint64_t *dfree, uint64_t *dsize)
1976 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, path,
1977 ×tamp, &stripped)) {
1980 if (timestamp == 0) {
1981 return SMB_VFS_NEXT_DISK_FREE(handle, path,
1982 bsize, dfree, dsize);
1985 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1986 TALLOC_FREE(stripped);
1991 ret = SMB_VFS_NEXT_DISK_FREE(handle, conv, bsize, dfree, dsize);
1993 saved_errno = errno;
1995 errno = saved_errno;
2000 static int shadow_copy2_get_quota(vfs_handle_struct *handle, const char *path,
2001 enum SMB_QUOTA_TYPE qtype, unid_t id,
2010 if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, path, ×tamp,
2014 if (timestamp == 0) {
2015 return SMB_VFS_NEXT_GET_QUOTA(handle, path, qtype, id, dq);
2018 conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
2019 TALLOC_FREE(stripped);
2024 ret = SMB_VFS_NEXT_GET_QUOTA(handle, conv, qtype, id, dq);
2026 saved_errno = errno;
2028 errno = saved_errno;
2033 static int shadow_copy2_connect(struct vfs_handle_struct *handle,
2034 const char *service, const char *user)
2036 struct shadow_copy2_config *config;
2038 const char *snapdir;
2039 const char *gmt_format;
2040 const char *sort_order;
2041 const char *basedir = NULL;
2042 const char *snapsharepath = NULL;
2043 const char *mount_point;
2045 DEBUG(10, (__location__ ": cnum[%u], connectpath[%s]\n",
2046 (unsigned)handle->conn->cnum,
2047 handle->conn->connectpath));
2049 ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
2054 config = talloc_zero(handle->conn, struct shadow_copy2_config);
2055 if (config == NULL) {
2056 DEBUG(0, ("talloc_zero() failed\n"));
2061 gmt_format = lp_parm_const_string(SNUM(handle->conn),
2064 config->gmt_format = talloc_strdup(config, gmt_format);
2065 if (config->gmt_format == NULL) {
2066 DEBUG(0, ("talloc_strdup() failed\n"));
2071 config->use_sscanf = lp_parm_bool(SNUM(handle->conn),
2072 "shadow", "sscanf", false);
2074 config->use_localtime = lp_parm_bool(SNUM(handle->conn),
2075 "shadow", "localtime",
2078 snapdir = lp_parm_const_string(SNUM(handle->conn),
2079 "shadow", "snapdir",
2081 config->snapdir = talloc_strdup(config, snapdir);
2082 if (config->snapdir == NULL) {
2083 DEBUG(0, ("talloc_strdup() failed\n"));
2088 config->snapdirseverywhere = lp_parm_bool(SNUM(handle->conn),
2090 "snapdirseverywhere",
2093 config->crossmountpoints = lp_parm_bool(SNUM(handle->conn),
2094 "shadow", "crossmountpoints",
2097 if (config->crossmountpoints && !config->snapdirseverywhere) {
2098 DBG_WARNING("Warning: 'crossmountpoints' depends on "
2099 "'snapdirseverywhere'. Disabling crossmountpoints.\n");
2102 config->fixinodes = lp_parm_bool(SNUM(handle->conn),
2103 "shadow", "fixinodes",
2106 sort_order = lp_parm_const_string(SNUM(handle->conn),
2107 "shadow", "sort", "desc");
2108 config->sort_order = talloc_strdup(config, sort_order);
2109 if (config->sort_order == NULL) {
2110 DEBUG(0, ("talloc_strdup() failed\n"));
2115 mount_point = lp_parm_const_string(SNUM(handle->conn),
2116 "shadow", "mountpoint", NULL);
2117 if (mount_point != NULL) {
2118 if (mount_point[0] != '/') {
2119 DEBUG(1, (__location__ " Warning: 'mountpoint' is "
2120 "relative ('%s'), but it has to be an "
2121 "absolute path. Ignoring provided value.\n",
2126 p = strstr(handle->conn->connectpath, mount_point);
2127 if (p != handle->conn->connectpath) {
2128 DBG_WARNING("Warning: the share root (%s) is "
2129 "not a subdirectory of the "
2130 "specified mountpoint (%s). "
2131 "Ignoring provided value.\n",
2132 handle->conn->connectpath,
2139 if (mount_point != NULL) {
2140 config->mount_point = talloc_strdup(config, mount_point);
2141 if (config->mount_point == NULL) {
2142 DEBUG(0, (__location__ " talloc_strdup() failed\n"));
2146 config->mount_point = shadow_copy2_find_mount_point(config,
2148 if (config->mount_point == NULL) {
2149 DBG_WARNING("shadow_copy2_find_mount_point "
2150 "of the share root '%s' failed: %s\n",
2151 handle->conn->connectpath, strerror(errno));
2156 basedir = lp_parm_const_string(SNUM(handle->conn),
2157 "shadow", "basedir", NULL);
2159 if (basedir != NULL) {
2160 if (basedir[0] != '/') {
2161 DEBUG(1, (__location__ " Warning: 'basedir' is "
2162 "relative ('%s'), but it has to be an "
2163 "absolute path. Disabling basedir.\n",
2168 p = strstr(basedir, config->mount_point);
2170 DEBUG(1, ("Warning: basedir (%s) is not a "
2171 "subdirectory of the share root's "
2172 "mount point (%s). "
2173 "Disabling basedir\n",
2174 basedir, config->mount_point));
2180 if (config->snapdirseverywhere && basedir != NULL) {
2181 DEBUG(1, (__location__ " Warning: 'basedir' is incompatible "
2182 "with 'snapdirseverywhere'. Disabling basedir.\n"));
2186 snapsharepath = lp_parm_const_string(SNUM(handle->conn), "shadow",
2187 "snapsharepath", NULL);
2188 if (snapsharepath != NULL) {
2189 if (snapsharepath[0] == '/') {
2190 DBG_WARNING("Warning: 'snapsharepath' is "
2191 "absolute ('%s'), but it has to be a "
2192 "relative path. Disabling snapsharepath.\n",
2194 snapsharepath = NULL;
2196 if (config->snapdirseverywhere && snapsharepath != NULL) {
2197 DBG_WARNING("Warning: 'snapsharepath' is incompatible "
2198 "with 'snapdirseverywhere'. Disabling "
2199 "snapsharepath.\n");
2200 snapsharepath = NULL;
2204 if (basedir != NULL && snapsharepath != NULL) {
2205 DBG_WARNING("Warning: 'snapsharepath' is incompatible with "
2206 "'basedir'. Disabling snapsharepath\n");
2207 snapsharepath = NULL;
2210 if (snapsharepath != NULL) {
2211 config->rel_connectpath = talloc_strdup(config, snapsharepath);
2212 if (config->rel_connectpath == NULL) {
2213 DBG_ERR("talloc_strdup() failed\n");
2219 if (basedir == NULL) {
2220 basedir = config->mount_point;
2223 if (config->rel_connectpath == NULL &&
2224 strlen(basedir) != strlen(handle->conn->connectpath)) {
2225 config->rel_connectpath = talloc_strdup(config,
2226 handle->conn->connectpath + strlen(basedir));
2227 if (config->rel_connectpath == NULL) {
2228 DEBUG(0, ("talloc_strdup() failed\n"));
2234 if (config->snapdir[0] == '/') {
2235 config->snapdir_absolute = true;
2237 if (config->snapdirseverywhere == true) {
2238 DEBUG(1, (__location__ " Warning: An absolute snapdir "
2239 "is incompatible with 'snapdirseverywhere', "
2240 "setting 'snapdirseverywhere' to false.\n"));
2241 config->snapdirseverywhere = false;
2244 if (config->crossmountpoints == true) {
2245 DEBUG(1, (__location__ " Warning: 'crossmountpoints' "
2246 "is not supported with an absolute snapdir. "
2247 "Disabling it.\n"));
2248 config->crossmountpoints = false;
2251 config->snapshot_basepath = config->snapdir;
2253 config->snapshot_basepath = talloc_asprintf(config, "%s/%s",
2254 config->mount_point, config->snapdir);
2255 if (config->snapshot_basepath == NULL) {
2256 DEBUG(0, ("talloc_asprintf() failed\n"));
2262 DEBUG(10, ("shadow_copy2_connect: configuration:\n"
2263 " share root: '%s'\n"
2264 " mountpoint: '%s'\n"
2265 " rel share root: '%s'\n"
2267 " snapshot base path: '%s'\n"
2270 " snapdirs everywhere: %s\n"
2271 " cross mountpoints: %s\n"
2275 handle->conn->connectpath,
2276 config->mount_point,
2277 config->rel_connectpath,
2279 config->snapshot_basepath,
2281 config->use_sscanf ? "yes" : "no",
2282 config->snapdirseverywhere ? "yes" : "no",
2283 config->crossmountpoints ? "yes" : "no",
2284 config->fixinodes ? "yes" : "no",
2289 SMB_VFS_HANDLE_SET_DATA(handle, config,
2290 NULL, struct shadow_copy2_config,
2296 static struct vfs_fn_pointers vfs_shadow_copy2_fns = {
2297 .connect_fn = shadow_copy2_connect,
2298 .opendir_fn = shadow_copy2_opendir,
2299 .disk_free_fn = shadow_copy2_disk_free,
2300 .get_quota_fn = shadow_copy2_get_quota,
2301 .rename_fn = shadow_copy2_rename,
2302 .link_fn = shadow_copy2_link,
2303 .symlink_fn = shadow_copy2_symlink,
2304 .stat_fn = shadow_copy2_stat,
2305 .lstat_fn = shadow_copy2_lstat,
2306 .fstat_fn = shadow_copy2_fstat,
2307 .open_fn = shadow_copy2_open,
2308 .unlink_fn = shadow_copy2_unlink,
2309 .chmod_fn = shadow_copy2_chmod,
2310 .chown_fn = shadow_copy2_chown,
2311 .chdir_fn = shadow_copy2_chdir,
2312 .ntimes_fn = shadow_copy2_ntimes,
2313 .readlink_fn = shadow_copy2_readlink,
2314 .mknod_fn = shadow_copy2_mknod,
2315 .realpath_fn = shadow_copy2_realpath,
2316 .get_nt_acl_fn = shadow_copy2_get_nt_acl,
2317 .fget_nt_acl_fn = shadow_copy2_fget_nt_acl,
2318 .get_shadow_copy_data_fn = shadow_copy2_get_shadow_copy_data,
2319 .mkdir_fn = shadow_copy2_mkdir,
2320 .rmdir_fn = shadow_copy2_rmdir,
2321 .getxattr_fn = shadow_copy2_getxattr,
2322 .listxattr_fn = shadow_copy2_listxattr,
2323 .removexattr_fn = shadow_copy2_removexattr,
2324 .setxattr_fn = shadow_copy2_setxattr,
2325 .chmod_acl_fn = shadow_copy2_chmod_acl,
2326 .chflags_fn = shadow_copy2_chflags,
2327 .get_real_filename_fn = shadow_copy2_get_real_filename,
2328 .connectpath_fn = shadow_copy2_connectpath,
2331 NTSTATUS vfs_shadow_copy2_init(void);
2332 NTSTATUS vfs_shadow_copy2_init(void)
2334 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
2335 "shadow_copy2", &vfs_shadow_copy2_fns);