/* * shadow_copy2: a shadow copy module (second implementation) * * Copyright (C) Andrew Tridgell 2007 (portions taken from shadow_copy2) * Copyright (C) Ed Plese 2009 * Copyright (C) Volker Lendecke 2011 * Copyright (C) Christian Ambach 2011 * Copyright (C) Michael Adam 2013 * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* * This is a second implemetation of a shadow copy module for exposing * file system snapshots to windows clients as shadow copies. * * See the manual page for documentation. */ #include "includes.h" #include "smbd/smbd.h" #include "system/filesys.h" #include "include/ntioctl.h" #include "util_tdb.h" struct shadow_copy2_config { char *gmt_format; bool use_sscanf; bool use_localtime; char *snapdir; bool snapdirseverywhere; bool crossmountpoints; bool fixinodes; char *sort_order; bool snapdir_absolute; char *mount_point; char *rel_connectpath; /* share root, relative to a snapshot root */ char *snapshot_basepath; /* the absolute version of snapdir */ }; static bool shadow_copy2_find_slashes(TALLOC_CTX *mem_ctx, const char *str, size_t **poffsets, unsigned *pnum_offsets) { unsigned num_offsets; size_t *offsets; const char *p; num_offsets = 0; p = str; while ((p = strchr(p, '/')) != NULL) { num_offsets += 1; p += 1; } offsets = talloc_array(mem_ctx, size_t, num_offsets); if (offsets == NULL) { return false; } p = str; num_offsets = 0; while ((p = strchr(p, '/')) != NULL) { offsets[num_offsets] = p-str; num_offsets += 1; p += 1; } *poffsets = offsets; *pnum_offsets = num_offsets; return true; } /** * Given a timestamp, build the posix level GMT-tag string * based on the configurable format. */ static size_t shadow_copy2_posix_gmt_string(struct vfs_handle_struct *handle, time_t snapshot, char *snaptime_string, size_t len) { struct tm snap_tm; size_t snaptime_len; struct shadow_copy2_config *config; SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config, return 0); if (config->use_sscanf) { snaptime_len = snprintf(snaptime_string, len, config->gmt_format, (unsigned long)snapshot); if (snaptime_len <= 0) { DEBUG(10, ("snprintf failed\n")); return snaptime_len; } } else { if (config->use_localtime) { if (localtime_r(&snapshot, &snap_tm) == 0) { DEBUG(10, ("gmtime_r failed\n")); return -1; } } else { if (gmtime_r(&snapshot, &snap_tm) == 0) { DEBUG(10, ("gmtime_r failed\n")); return -1; } } snaptime_len = strftime(snaptime_string, len, config->gmt_format, &snap_tm); if (snaptime_len == 0) { DEBUG(10, ("strftime failed\n")); return 0; } } return snaptime_len; } /** * Given a timestamp, build the string to insert into a path * as a path component for creating the local path to the * snapshot at the given timestamp of the input path. * * In the case of a parallel snapdir (specified with an * absolute path), this is the inital portion of the * local path of any snapshot file. The complete path is * obtained by appending the portion of the file's path * below the share root's mountpoint. */ static char *shadow_copy2_insert_string(TALLOC_CTX *mem_ctx, struct vfs_handle_struct *handle, time_t snapshot) { fstring snaptime_string; size_t snaptime_len = 0; char *result = NULL; struct shadow_copy2_config *config; SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config, return NULL); snaptime_len = shadow_copy2_posix_gmt_string(handle, snapshot, snaptime_string, sizeof(snaptime_string)); if (snaptime_len <= 0) { return NULL; } if (config->snapdir_absolute) { result = talloc_asprintf(mem_ctx, "%s/%s", config->snapdir, snaptime_string); } else { result = talloc_asprintf(mem_ctx, "/%s/%s", config->snapdir, snaptime_string); } if (result == NULL) { DEBUG(1, (__location__ " talloc_asprintf failed\n")); } return result; } /** * Build the posix snapshot path for the connection * at the given timestamp, i.e. the absolute posix path * that contains the snapshot for this file system. * * This only applies to classical case, i.e. not * to the "snapdirseverywhere" mode. */ static char *shadow_copy2_snapshot_path(TALLOC_CTX *mem_ctx, struct vfs_handle_struct *handle, time_t snapshot) { fstring snaptime_string; size_t snaptime_len = 0; char *result = NULL; struct shadow_copy2_config *config; SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config, return NULL); snaptime_len = shadow_copy2_posix_gmt_string(handle, snapshot, snaptime_string, sizeof(snaptime_string)); if (snaptime_len <= 0) { return NULL; } result = talloc_asprintf(mem_ctx, "%s/%s", config->snapshot_basepath, snaptime_string); if (result == NULL) { DEBUG(1, (__location__ " talloc_asprintf failed\n")); } return result; } /** * Strip a snapshot component from a filename as * handed in via the smb layer. * Returns the parsed timestamp and the stripped filename. */ static bool shadow_copy2_strip_snapshot(TALLOC_CTX *mem_ctx, struct vfs_handle_struct *handle, const char *name, time_t *ptimestamp, char **pstripped) { struct tm tm; time_t timestamp; const char *p; char *q; char *stripped; size_t rest_len, dst_len; struct shadow_copy2_config *config; const char *snapdir; ssize_t snapdirlen; ptrdiff_t len_before_gmt; SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config, return false); DEBUG(10, (__location__ ": enter path '%s'\n", name)); p = strstr_m(name, "@GMT-"); if (p == NULL) { DEBUG(11, ("@GMT not found\n")); goto no_snapshot; } if ((p > name) && (p[-1] != '/')) { /* the GMT-token does not start a path-component */ DEBUG(10, ("not at start, p=%p, name=%p, p[-1]=%d\n", p, name, (int)p[-1])); goto no_snapshot; } /* * Figure out whether we got an already converted string. One * case where this happens is in a smb2 create call with the * mxac create blob set. We do the get_acl call on * fsp->fsp_name, which is already converted. We are converted * if we got a file name of the form ".snapshots/@GMT-", * i.e. ".snapshots/" precedes "p". */ snapdir = lp_parm_const_string(SNUM(handle->conn), "shadow", "snapdir", ".snapshots"); snapdirlen = strlen(snapdir); len_before_gmt = p - name; if ((len_before_gmt >= (snapdirlen + 1)) && (p[-1] == '/')) { const char *parent_snapdir = p - (snapdirlen+1); DEBUG(10, ("parent_snapdir = %s\n", parent_snapdir)); if (strncmp(parent_snapdir, snapdir, snapdirlen) == 0) { DEBUG(10, ("name=%s is already converted\n", name)); goto no_snapshot; } } q = strptime(p, GMT_FORMAT, &tm); if (q == NULL) { DEBUG(10, ("strptime failed\n")); goto no_snapshot; } tm.tm_isdst = -1; timestamp = timegm(&tm); if (timestamp == (time_t)-1) { DEBUG(10, ("timestamp==-1\n")); goto no_snapshot; } if (q[0] == '\0') { /* * The name consists of only the GMT token or the GMT * token is at the end of the path. XP seems to send * @GMT- at the end under certain circumstances even * with a path prefix. */ if (pstripped != NULL) { stripped = talloc_strndup(mem_ctx, name, p - name); if (stripped == NULL) { return false; } *pstripped = stripped; } *ptimestamp = timestamp; return true; } if (q[0] != '/') { /* * It is not a complete path component, i.e. the path * component continues after the gmt-token. */ DEBUG(10, ("q[0] = %d\n", (int)q[0])); goto no_snapshot; } q += 1; rest_len = strlen(q); dst_len = (p-name) + rest_len; if (config->snapdirseverywhere) { char *insert; bool have_insert; insert = shadow_copy2_insert_string(talloc_tos(), handle, timestamp); if (insert == NULL) { errno = ENOMEM; return false; } DEBUG(10, (__location__ ": snapdirseverywhere mode.\n" "path '%s'.\n" "insert string '%s'\n", name, insert)); have_insert = (strstr(name, insert+1) != NULL); DEBUG(10, ("have_insert=%d, name=%s, insert+1=%s\n", (int)have_insert, name, insert+1)); if (have_insert) { DEBUG(10, (__location__ ": insert string '%s' found in " "path '%s' found in snapdirseverywhere mode " "==> already converted\n", insert, name)); TALLOC_FREE(insert); goto no_snapshot; } TALLOC_FREE(insert); } else { char *snapshot_path; char *s; snapshot_path = shadow_copy2_snapshot_path(talloc_tos(), handle, timestamp); if (snapshot_path == NULL) { errno = ENOMEM; return false; } DEBUG(10, (__location__ " path: '%s'.\n" "snapshot path: '%s'\n", name, snapshot_path)); s = strstr(name, snapshot_path); if (s == name) { /* * this starts with "snapshot_basepath/GMT-Token" * so it is already a converted absolute * path. Don't process further. */ DEBUG(10, (__location__ ": path '%s' starts with " "snapshot path '%s' (not in " "snapdirseverywhere mode) ==> " "already converted\n", name, snapshot_path)); talloc_free(snapshot_path); goto no_snapshot; } talloc_free(snapshot_path); } if (pstripped != NULL) { stripped = talloc_array(mem_ctx, char, dst_len+1); if (stripped == NULL) { errno = ENOMEM; return false; } if (p > name) { memcpy(stripped, name, p-name); } if (rest_len > 0) { memcpy(stripped + (p-name), q, rest_len); } stripped[dst_len] = '\0'; *pstripped = stripped; } *ptimestamp = timestamp; return true; no_snapshot: *ptimestamp = 0; return true; } static char *shadow_copy2_find_mount_point(TALLOC_CTX *mem_ctx, vfs_handle_struct *handle) { char *path = talloc_strdup(mem_ctx, handle->conn->connectpath); dev_t dev; struct stat st; char *p; if (stat(path, &st) != 0) { talloc_free(path); return NULL; } dev = st.st_dev; while ((p = strrchr(path, '/')) && p > path) { *p = 0; if (stat(path, &st) != 0) { talloc_free(path); return NULL; } if (st.st_dev != dev) { *p = '/'; break; } } return path; } /** * Convert from a name as handed in via the SMB layer * and a timestamp into the local path of the snapshot * of the provided file at the provided time. * Also return the path in the snapshot corresponding * to the file's share root. */ static char *shadow_copy2_do_convert(TALLOC_CTX *mem_ctx, struct vfs_handle_struct *handle, const char *name, time_t timestamp, size_t *snaproot_len) { struct smb_filename converted_fname; char *result = NULL; size_t *slashes = NULL; unsigned num_slashes; char *path = NULL; size_t pathlen; char *insert = NULL; char *converted = NULL; size_t insertlen, connectlen = 0; int i, saved_errno; size_t min_offset; struct shadow_copy2_config *config; size_t in_share_offset = 0; SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config, return NULL); DEBUG(10, ("converting '%s'\n", name)); if (!config->snapdirseverywhere) { int ret; char *snapshot_path; snapshot_path = shadow_copy2_snapshot_path(talloc_tos(), handle, timestamp); if (snapshot_path == NULL) { goto fail; } if (config->rel_connectpath == NULL) { converted = talloc_asprintf(mem_ctx, "%s/%s", snapshot_path, name); } else { converted = talloc_asprintf(mem_ctx, "%s/%s/%s", snapshot_path, config->rel_connectpath, name); } if (converted == NULL) { goto fail; } ZERO_STRUCT(converted_fname); converted_fname.base_name = converted; ret = SMB_VFS_NEXT_LSTAT(handle, &converted_fname); DEBUG(10, ("Trying[not snapdirseverywhere] %s: %d (%s)\n", converted, ret, ret == 0 ? "ok" : strerror(errno))); if (ret == 0) { DEBUG(10, ("Found %s\n", converted)); result = converted; converted = NULL; if (snaproot_len != NULL) { *snaproot_len = strlen(snapshot_path); if (config->rel_connectpath != NULL) { *snaproot_len += strlen(config->rel_connectpath) + 1; } } goto fail; } else { errno = ENOENT; goto fail; } /* never reached ... */ } connectlen = strlen(handle->conn->connectpath); if (name[0] == 0) { path = talloc_strdup(mem_ctx, handle->conn->connectpath); } else { path = talloc_asprintf( mem_ctx, "%s/%s", handle->conn->connectpath, name); } if (path == NULL) { errno = ENOMEM; goto fail; } pathlen = talloc_get_size(path)-1; if (!shadow_copy2_find_slashes(talloc_tos(), path, &slashes, &num_slashes)) { goto fail; } insert = shadow_copy2_insert_string(talloc_tos(), handle, timestamp); if (insert == NULL) { goto fail; } insertlen = talloc_get_size(insert)-1; /* * Note: We deliberatly don't expensively initialize the * array with talloc_zero here: Putting zero into * converted[pathlen+insertlen] below is sufficient, because * in the following for loop, the insert string is inserted * at various slash places. So the memory up to position * pathlen+insertlen will always be initialized when the * converted string is used. */ converted = talloc_array(mem_ctx, char, pathlen + insertlen + 1); if (converted == NULL) { goto fail; } if (path[pathlen-1] != '/') { /* * Append a fake slash to find the snapshot root */ size_t *tmp; tmp = talloc_realloc(talloc_tos(), slashes, size_t, num_slashes+1); if (tmp == NULL) { goto fail; } slashes = tmp; slashes[num_slashes] = pathlen; num_slashes += 1; } min_offset = 0; if (!config->crossmountpoints) { min_offset = strlen(config->mount_point); } memcpy(converted, path, pathlen+1); converted[pathlen+insertlen] = '\0'; ZERO_STRUCT(converted_fname); converted_fname.base_name = converted; for (i = num_slashes-1; i>=0; i--) { int ret; size_t offset; offset = slashes[i]; if (offset < min_offset) { errno = ENOENT; goto fail; } if (offset >= connectlen) { in_share_offset = offset; } memcpy(converted+offset, insert, insertlen); offset += insertlen; memcpy(converted+offset, path + slashes[i], pathlen - slashes[i]); ret = SMB_VFS_NEXT_LSTAT(handle, &converted_fname); DEBUG(10, ("Trying[snapdirseverywhere] %s: %d (%s)\n", converted, ret, ret == 0 ? "ok" : strerror(errno))); if (ret == 0) { /* success */ if (snaproot_len != NULL) { *snaproot_len = in_share_offset + insertlen; } break; } if (errno == ENOTDIR) { /* * This is a valid condition: We appended the * .snaphots/@GMT.. to a file name. Just try * with the upper levels. */ continue; } if (errno != ENOENT) { /* Other problem than "not found" */ goto fail; } } if (i >= 0) { /* * Found something */ DEBUG(10, ("Found %s\n", converted)); result = converted; converted = NULL; } else { errno = ENOENT; } fail: saved_errno = errno; TALLOC_FREE(converted); TALLOC_FREE(insert); TALLOC_FREE(slashes); TALLOC_FREE(path); errno = saved_errno; return result; } /** * Convert from a name as handed in via the SMB layer * and a timestamp into the local path of the snapshot * of the provided file at the provided time. */ static char *shadow_copy2_convert(TALLOC_CTX *mem_ctx, struct vfs_handle_struct *handle, const char *name, time_t timestamp) { return shadow_copy2_do_convert(mem_ctx, handle, name, timestamp, NULL); } /* modify a sbuf return to ensure that inodes in the shadow directory are different from those in the main directory */ static void convert_sbuf(vfs_handle_struct *handle, const char *fname, SMB_STRUCT_STAT *sbuf) { struct shadow_copy2_config *config; SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config, return); if (config->fixinodes) { /* some snapshot systems, like GPFS, return the name device:inode for the snapshot files as the current files. That breaks the 'restore' button in the shadow copy GUI, as the client gets a sharing violation. This is a crude way of allowing both files to be open at once. It has a slight chance of inode number collision, but I can't see a better approach without significant VFS changes */ TDB_DATA key = { .dptr = discard_const_p(uint8_t, fname), .dsize = strlen(fname) }; uint32_t shash; shash = tdb_jenkins_hash(&key) & 0xFF000000; if (shash == 0) { shash = 1; } sbuf->st_ex_ino ^= shash; } } static DIR *shadow_copy2_opendir(vfs_handle_struct *handle, const struct smb_filename *smb_fname, const char *mask, uint32_t attr) { time_t timestamp; char *stripped; DIR *ret; int saved_errno; char *conv; struct smb_filename *conv_smb_fname = NULL; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, smb_fname->base_name, ×tamp, &stripped)) { return NULL; } if (timestamp == 0) { return SMB_VFS_NEXT_OPENDIR(handle, smb_fname, mask, attr); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return NULL; } conv_smb_fname = synthetic_smb_fname(talloc_tos(), conv, NULL, NULL); if (conv_smb_fname == NULL) { TALLOC_FREE(conv); return NULL; } ret = SMB_VFS_NEXT_OPENDIR(handle, conv_smb_fname, mask, attr); saved_errno = errno; TALLOC_FREE(conv); TALLOC_FREE(conv_smb_fname); errno = saved_errno; return ret; } static int shadow_copy2_rename(vfs_handle_struct *handle, const struct smb_filename *smb_fname_src, const struct smb_filename *smb_fname_dst) { time_t timestamp_src, timestamp_dst; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, smb_fname_src->base_name, ×tamp_src, NULL)) { return -1; } if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, smb_fname_dst->base_name, ×tamp_dst, NULL)) { return -1; } if (timestamp_src != 0) { errno = EXDEV; return -1; } if (timestamp_dst != 0) { errno = EROFS; return -1; } return SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst); } static int shadow_copy2_symlink(vfs_handle_struct *handle, const char *oldname, const char *newname) { time_t timestamp_old, timestamp_new; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, oldname, ×tamp_old, NULL)) { return -1; } if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, newname, ×tamp_new, NULL)) { return -1; } if ((timestamp_old != 0) || (timestamp_new != 0)) { errno = EROFS; return -1; } return SMB_VFS_NEXT_SYMLINK(handle, oldname, newname); } static int shadow_copy2_link(vfs_handle_struct *handle, const char *oldname, const char *newname) { time_t timestamp_old, timestamp_new; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, oldname, ×tamp_old, NULL)) { return -1; } if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, newname, ×tamp_new, NULL)) { return -1; } if ((timestamp_old != 0) || (timestamp_new != 0)) { errno = EROFS; return -1; } return SMB_VFS_NEXT_LINK(handle, oldname, newname); } static int shadow_copy2_stat(vfs_handle_struct *handle, struct smb_filename *smb_fname) { time_t timestamp; char *stripped, *tmp; int ret, saved_errno; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, smb_fname->base_name, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_STAT(handle, smb_fname); } tmp = smb_fname->base_name; smb_fname->base_name = shadow_copy2_convert( talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (smb_fname->base_name == NULL) { smb_fname->base_name = tmp; return -1; } ret = SMB_VFS_NEXT_STAT(handle, smb_fname); saved_errno = errno; TALLOC_FREE(smb_fname->base_name); smb_fname->base_name = tmp; if (ret == 0) { convert_sbuf(handle, smb_fname->base_name, &smb_fname->st); } errno = saved_errno; return ret; } static int shadow_copy2_lstat(vfs_handle_struct *handle, struct smb_filename *smb_fname) { time_t timestamp; char *stripped, *tmp; int ret, saved_errno; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, smb_fname->base_name, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_LSTAT(handle, smb_fname); } tmp = smb_fname->base_name; smb_fname->base_name = shadow_copy2_convert( talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (smb_fname->base_name == NULL) { smb_fname->base_name = tmp; return -1; } ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname); saved_errno = errno; TALLOC_FREE(smb_fname->base_name); smb_fname->base_name = tmp; if (ret == 0) { convert_sbuf(handle, smb_fname->base_name, &smb_fname->st); } errno = saved_errno; return ret; } static int shadow_copy2_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf) { time_t timestamp; int ret; ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf); if (ret == -1) { return ret; } if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fsp->fsp_name->base_name, ×tamp, NULL)) { return 0; } if (timestamp != 0) { convert_sbuf(handle, fsp->fsp_name->base_name, sbuf); } return 0; } static int shadow_copy2_open(vfs_handle_struct *handle, struct smb_filename *smb_fname, files_struct *fsp, int flags, mode_t mode) { time_t timestamp; char *stripped, *tmp; int ret, saved_errno; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, smb_fname->base_name, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode); } tmp = smb_fname->base_name; smb_fname->base_name = shadow_copy2_convert( talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (smb_fname->base_name == NULL) { smb_fname->base_name = tmp; return -1; } ret = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode); saved_errno = errno; TALLOC_FREE(smb_fname->base_name); smb_fname->base_name = tmp; errno = saved_errno; return ret; } static int shadow_copy2_unlink(vfs_handle_struct *handle, const struct smb_filename *smb_fname) { time_t timestamp; char *stripped; int ret, saved_errno; struct smb_filename *conv; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, smb_fname->base_name, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_UNLINK(handle, smb_fname); } conv = cp_smb_filename(talloc_tos(), smb_fname); if (conv == NULL) { errno = ENOMEM; return -1; } conv->base_name = shadow_copy2_convert( conv, handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv->base_name == NULL) { return -1; } ret = SMB_VFS_NEXT_UNLINK(handle, conv); saved_errno = errno; TALLOC_FREE(conv); errno = saved_errno; return ret; } static int shadow_copy2_chmod(vfs_handle_struct *handle, const struct smb_filename *smb_fname, mode_t mode) { time_t timestamp; char *stripped = NULL; int ret, saved_errno; char *conv = NULL; struct smb_filename *conv_smb_fname; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, smb_fname->base_name, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { TALLOC_FREE(stripped); return SMB_VFS_NEXT_CHMOD(handle, smb_fname, mode); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } conv_smb_fname = synthetic_smb_fname(talloc_tos(), conv, NULL, NULL); if (conv_smb_fname == NULL) { TALLOC_FREE(conv); errno = ENOMEM; return -1; } ret = SMB_VFS_NEXT_CHMOD(handle, conv_smb_fname, mode); saved_errno = errno; TALLOC_FREE(conv); TALLOC_FREE(conv_smb_fname); errno = saved_errno; return ret; } static int shadow_copy2_chown(vfs_handle_struct *handle, const char *fname, uid_t uid, gid_t gid) { time_t timestamp; char *stripped; int ret, saved_errno; char *conv; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_CHOWN(handle, fname, uid, gid); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } ret = SMB_VFS_NEXT_CHOWN(handle, conv, uid, gid); saved_errno = errno; TALLOC_FREE(conv); errno = saved_errno; return ret; } static int shadow_copy2_chdir(vfs_handle_struct *handle, const char *fname) { time_t timestamp; char *stripped; int ret, saved_errno; char *conv; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_CHDIR(handle, fname); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } ret = SMB_VFS_NEXT_CHDIR(handle, conv); saved_errno = errno; TALLOC_FREE(conv); errno = saved_errno; return ret; } static int shadow_copy2_ntimes(vfs_handle_struct *handle, const struct smb_filename *smb_fname, struct smb_file_time *ft) { time_t timestamp; char *stripped; int ret, saved_errno; struct smb_filename *conv; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, smb_fname->base_name, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft); } conv = cp_smb_filename(talloc_tos(), smb_fname); if (conv == NULL) { errno = ENOMEM; return -1; } conv->base_name = shadow_copy2_convert( conv, handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv->base_name == NULL) { return -1; } ret = SMB_VFS_NEXT_NTIMES(handle, conv, ft); saved_errno = errno; TALLOC_FREE(conv); errno = saved_errno; return ret; } static int shadow_copy2_readlink(vfs_handle_struct *handle, const char *fname, char *buf, size_t bufsiz) { time_t timestamp; char *stripped; int ret, saved_errno; char *conv; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_READLINK(handle, fname, buf, bufsiz); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } ret = SMB_VFS_NEXT_READLINK(handle, conv, buf, bufsiz); saved_errno = errno; TALLOC_FREE(conv); errno = saved_errno; return ret; } static int shadow_copy2_mknod(vfs_handle_struct *handle, const char *fname, mode_t mode, SMB_DEV_T dev) { time_t timestamp; char *stripped; int ret, saved_errno; char *conv; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_MKNOD(handle, fname, mode, dev); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } ret = SMB_VFS_NEXT_MKNOD(handle, conv, mode, dev); saved_errno = errno; TALLOC_FREE(conv); errno = saved_errno; return ret; } static char *shadow_copy2_realpath(vfs_handle_struct *handle, const char *fname) { time_t timestamp; char *stripped = NULL; char *tmp = NULL; char *result = NULL; int saved_errno; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname, ×tamp, &stripped)) { goto done; } if (timestamp == 0) { return SMB_VFS_NEXT_REALPATH(handle, fname); } tmp = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); if (tmp == NULL) { goto done; } result = SMB_VFS_NEXT_REALPATH(handle, tmp); done: saved_errno = errno; TALLOC_FREE(tmp); TALLOC_FREE(stripped); errno = saved_errno; return result; } /** * Check whether a given directory contains a * snapshot directory as direct subdirectory. * If yes, return the path of the snapshot-subdir, * otherwise return NULL. */ static char *have_snapdir(struct vfs_handle_struct *handle, const char *path) { struct smb_filename smb_fname; int ret; struct shadow_copy2_config *config; SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config, return NULL); ZERO_STRUCT(smb_fname); smb_fname.base_name = talloc_asprintf(talloc_tos(), "%s/%s", path, config->snapdir); if (smb_fname.base_name == NULL) { return NULL; } ret = SMB_VFS_NEXT_STAT(handle, &smb_fname); if ((ret == 0) && (S_ISDIR(smb_fname.st.st_ex_mode))) { return smb_fname.base_name; } TALLOC_FREE(smb_fname.base_name); return NULL; } static bool check_access_snapdir(struct vfs_handle_struct *handle, const char *path) { struct smb_filename smb_fname; int ret; NTSTATUS status; ZERO_STRUCT(smb_fname); smb_fname.base_name = talloc_asprintf(talloc_tos(), "%s", path); if (smb_fname.base_name == NULL) { return false; } ret = SMB_VFS_NEXT_STAT(handle, &smb_fname); if (ret != 0 || !S_ISDIR(smb_fname.st.st_ex_mode)) { TALLOC_FREE(smb_fname.base_name); return false; } status = smbd_check_access_rights(handle->conn, &smb_fname, false, SEC_DIR_LIST); if (!NT_STATUS_IS_OK(status)) { DEBUG(0,("user does not have list permission " "on snapdir %s\n", smb_fname.base_name)); TALLOC_FREE(smb_fname.base_name); return false; } TALLOC_FREE(smb_fname.base_name); return true; } /** * Find the snapshot directory (if any) for the given * filename (which is relative to the share). */ static const char *shadow_copy2_find_snapdir(TALLOC_CTX *mem_ctx, struct vfs_handle_struct *handle, struct smb_filename *smb_fname) { char *path, *p; const char *snapdir; struct shadow_copy2_config *config; SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config, return NULL); /* * If the non-snapdisrseverywhere mode, we should not search! */ if (!config->snapdirseverywhere) { return config->snapshot_basepath; } path = talloc_asprintf(mem_ctx, "%s/%s", handle->conn->connectpath, smb_fname->base_name); if (path == NULL) { return NULL; } snapdir = have_snapdir(handle, path); if (snapdir != NULL) { TALLOC_FREE(path); return snapdir; } while ((p = strrchr(path, '/')) && (p > path)) { p[0] = '\0'; snapdir = have_snapdir(handle, path); if (snapdir != NULL) { TALLOC_FREE(path); return snapdir; } } TALLOC_FREE(path); return NULL; } static bool shadow_copy2_snapshot_to_gmt(vfs_handle_struct *handle, const char *name, char *gmt, size_t gmt_len) { struct tm timestamp; time_t timestamp_t; unsigned long int timestamp_long; const char *fmt; struct shadow_copy2_config *config; SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config, return NULL); fmt = config->gmt_format; ZERO_STRUCT(timestamp); if (config->use_sscanf) { if (sscanf(name, fmt, ×tamp_long) != 1) { DEBUG(10, ("shadow_copy2_snapshot_to_gmt: " "no sscanf match %s: %s\n", fmt, name)); return false; } timestamp_t = timestamp_long; gmtime_r(×tamp_t, ×tamp); } else { if (strptime(name, fmt, ×tamp) == NULL) { DEBUG(10, ("shadow_copy2_snapshot_to_gmt: " "no match %s: %s\n", fmt, name)); return false; } DEBUG(10, ("shadow_copy2_snapshot_to_gmt: match %s: %s\n", fmt, name)); if (config->use_localtime) { timestamp.tm_isdst = -1; timestamp_t = mktime(×tamp); gmtime_r(×tamp_t, ×tamp); } } strftime(gmt, gmt_len, GMT_FORMAT, ×tamp); return true; } static int shadow_copy2_label_cmp_asc(const void *x, const void *y) { return strncmp((const char *)x, (const char *)y, sizeof(SHADOW_COPY_LABEL)); } static int shadow_copy2_label_cmp_desc(const void *x, const void *y) { return -strncmp((const char *)x, (const char *)y, sizeof(SHADOW_COPY_LABEL)); } /* sort the shadow copy data in ascending or descending order */ static void shadow_copy2_sort_data(vfs_handle_struct *handle, struct shadow_copy_data *shadow_copy2_data) { int (*cmpfunc)(const void *, const void *); const char *sort; struct shadow_copy2_config *config; SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config, return); sort = config->sort_order; if (sort == NULL) { return; } if (strcmp(sort, "asc") == 0) { cmpfunc = shadow_copy2_label_cmp_asc; } else if (strcmp(sort, "desc") == 0) { cmpfunc = shadow_copy2_label_cmp_desc; } else { return; } if (shadow_copy2_data && shadow_copy2_data->num_volumes > 0 && shadow_copy2_data->labels) { TYPESAFE_QSORT(shadow_copy2_data->labels, shadow_copy2_data->num_volumes, cmpfunc); } } static int shadow_copy2_get_shadow_copy_data( vfs_handle_struct *handle, files_struct *fsp, struct shadow_copy_data *shadow_copy2_data, bool labels) { DIR *p; const char *snapdir; struct smb_filename *snapdir_smb_fname = NULL; struct dirent *d; TALLOC_CTX *tmp_ctx = talloc_stackframe(); bool ret; snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle, fsp->fsp_name); if (snapdir == NULL) { DEBUG(0,("shadow:snapdir not found for %s in get_shadow_copy_data\n", handle->conn->connectpath)); errno = EINVAL; talloc_free(tmp_ctx); return -1; } ret = check_access_snapdir(handle, snapdir); if (!ret) { DEBUG(0,("access denied on listing snapdir %s\n", snapdir)); errno = EACCES; talloc_free(tmp_ctx); return -1; } snapdir_smb_fname = synthetic_smb_fname(talloc_tos(), snapdir, NULL, NULL); if (snapdir_smb_fname == NULL) { errno = ENOMEM; talloc_free(tmp_ctx); return -1; } p = SMB_VFS_NEXT_OPENDIR(handle, snapdir_smb_fname, NULL, 0); if (!p) { DEBUG(2,("shadow_copy2: SMB_VFS_NEXT_OPENDIR() failed for '%s'" " - %s\n", snapdir, strerror(errno))); talloc_free(tmp_ctx); errno = ENOSYS; return -1; } shadow_copy2_data->num_volumes = 0; shadow_copy2_data->labels = NULL; while ((d = SMB_VFS_NEXT_READDIR(handle, p, NULL))) { char snapshot[GMT_NAME_LEN+1]; SHADOW_COPY_LABEL *tlabels; /* * ignore names not of the right form in the snapshot * directory */ if (!shadow_copy2_snapshot_to_gmt( handle, d->d_name, snapshot, sizeof(snapshot))) { DEBUG(6, ("shadow_copy2_get_shadow_copy_data: " "ignoring %s\n", d->d_name)); continue; } DEBUG(6,("shadow_copy2_get_shadow_copy_data: %s -> %s\n", d->d_name, snapshot)); if (!labels) { /* the caller doesn't want the labels */ shadow_copy2_data->num_volumes++; continue; } tlabels = talloc_realloc(shadow_copy2_data, shadow_copy2_data->labels, SHADOW_COPY_LABEL, shadow_copy2_data->num_volumes+1); if (tlabels == NULL) { DEBUG(0,("shadow_copy2: out of memory\n")); SMB_VFS_NEXT_CLOSEDIR(handle, p); talloc_free(tmp_ctx); return -1; } strlcpy(tlabels[shadow_copy2_data->num_volumes], snapshot, sizeof(*tlabels)); shadow_copy2_data->num_volumes++; shadow_copy2_data->labels = tlabels; } SMB_VFS_NEXT_CLOSEDIR(handle,p); shadow_copy2_sort_data(handle, shadow_copy2_data); talloc_free(tmp_ctx); return 0; } static NTSTATUS shadow_copy2_fget_nt_acl(vfs_handle_struct *handle, struct files_struct *fsp, uint32_t security_info, TALLOC_CTX *mem_ctx, struct security_descriptor **ppdesc) { time_t timestamp; char *stripped; NTSTATUS status; char *conv; struct smb_filename *smb_fname = NULL; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fsp->fsp_name->base_name, ×tamp, &stripped)) { return map_nt_error_from_unix(errno); } if (timestamp == 0) { return SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info, mem_ctx, ppdesc); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return map_nt_error_from_unix(errno); } smb_fname = synthetic_smb_fname(talloc_tos(), conv, NULL, NULL); if (smb_fname == NULL) { TALLOC_FREE(conv); return NT_STATUS_NO_MEMORY; } status = SMB_VFS_NEXT_GET_NT_ACL(handle, smb_fname, security_info, mem_ctx, ppdesc); TALLOC_FREE(conv); TALLOC_FREE(smb_fname); return status; } static NTSTATUS shadow_copy2_get_nt_acl(vfs_handle_struct *handle, const struct smb_filename *smb_fname, uint32_t security_info, TALLOC_CTX *mem_ctx, struct security_descriptor **ppdesc) { time_t timestamp; char *stripped; NTSTATUS status; char *conv; struct smb_filename *conv_smb_fname = NULL; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, smb_fname->base_name, ×tamp, &stripped)) { return map_nt_error_from_unix(errno); } if (timestamp == 0) { return SMB_VFS_NEXT_GET_NT_ACL(handle, smb_fname, security_info, mem_ctx, ppdesc); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return map_nt_error_from_unix(errno); } conv_smb_fname = synthetic_smb_fname(talloc_tos(), conv, NULL, NULL); if (conv_smb_fname == NULL) { TALLOC_FREE(conv); return NT_STATUS_NO_MEMORY; } status = SMB_VFS_NEXT_GET_NT_ACL(handle, conv_smb_fname, security_info, mem_ctx, ppdesc); TALLOC_FREE(conv); TALLOC_FREE(conv_smb_fname); return status; } static int shadow_copy2_mkdir(vfs_handle_struct *handle, const struct smb_filename *smb_fname, mode_t mode) { time_t timestamp; char *stripped; int ret, saved_errno; char *conv; struct smb_filename *conv_smb_fname = NULL; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, smb_fname->base_name, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_MKDIR(handle, smb_fname, mode); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } conv_smb_fname = synthetic_smb_fname(talloc_tos(), conv, NULL, NULL); if (conv_smb_fname == NULL) { TALLOC_FREE(conv); return -1; } ret = SMB_VFS_NEXT_MKDIR(handle, conv_smb_fname, mode); saved_errno = errno; TALLOC_FREE(conv); TALLOC_FREE(conv_smb_fname); errno = saved_errno; return ret; } static int shadow_copy2_rmdir(vfs_handle_struct *handle, const struct smb_filename *smb_fname) { time_t timestamp; char *stripped; int ret, saved_errno; char *conv; struct smb_filename *conv_smb_fname = NULL; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, smb_fname->base_name, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_RMDIR(handle, smb_fname); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } conv_smb_fname = synthetic_smb_fname(talloc_tos(), conv, NULL, NULL); if (conv_smb_fname == NULL) { TALLOC_FREE(conv); return -1; } ret = SMB_VFS_NEXT_RMDIR(handle, conv_smb_fname); saved_errno = errno; TALLOC_FREE(conv_smb_fname); TALLOC_FREE(conv); errno = saved_errno; return ret; } static int shadow_copy2_chflags(vfs_handle_struct *handle, const char *fname, unsigned int flags) { time_t timestamp; char *stripped; int ret, saved_errno; char *conv; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_CHFLAGS(handle, fname, flags); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } ret = SMB_VFS_NEXT_CHFLAGS(handle, conv, flags); saved_errno = errno; TALLOC_FREE(conv); errno = saved_errno; return ret; } static ssize_t shadow_copy2_getxattr(vfs_handle_struct *handle, const char *fname, const char *aname, void *value, size_t size) { time_t timestamp; char *stripped; ssize_t ret; int saved_errno; char *conv; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_GETXATTR(handle, fname, aname, value, size); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } ret = SMB_VFS_NEXT_GETXATTR(handle, conv, aname, value, size); saved_errno = errno; TALLOC_FREE(conv); errno = saved_errno; return ret; } static ssize_t shadow_copy2_listxattr(struct vfs_handle_struct *handle, const char *fname, char *list, size_t size) { time_t timestamp; char *stripped; ssize_t ret; int saved_errno; char *conv; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_LISTXATTR(handle, fname, list, size); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } ret = SMB_VFS_NEXT_LISTXATTR(handle, conv, list, size); saved_errno = errno; TALLOC_FREE(conv); errno = saved_errno; return ret; } static int shadow_copy2_removexattr(vfs_handle_struct *handle, const char *fname, const char *aname) { time_t timestamp; char *stripped; int ret, saved_errno; char *conv; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_REMOVEXATTR(handle, fname, aname); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } ret = SMB_VFS_NEXT_REMOVEXATTR(handle, conv, aname); saved_errno = errno; TALLOC_FREE(conv); errno = saved_errno; return ret; } static int shadow_copy2_setxattr(struct vfs_handle_struct *handle, const char *fname, const char *aname, const void *value, size_t size, int flags) { time_t timestamp; char *stripped; ssize_t ret; int saved_errno; char *conv; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_SETXATTR(handle, fname, aname, value, size, flags); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } ret = SMB_VFS_NEXT_SETXATTR(handle, conv, aname, value, size, flags); saved_errno = errno; TALLOC_FREE(conv); errno = saved_errno; return ret; } static int shadow_copy2_chmod_acl(vfs_handle_struct *handle, const struct smb_filename *smb_fname, mode_t mode) { time_t timestamp; char *stripped; ssize_t ret; int saved_errno; char *conv = NULL; struct smb_filename *conv_smb_fname = NULL; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, smb_fname->base_name, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_CHMOD_ACL(handle, smb_fname, mode); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } conv_smb_fname = synthetic_smb_fname(talloc_tos(), conv, NULL, NULL); if (conv_smb_fname == NULL) { TALLOC_FREE(conv); errno = ENOMEM; return -1; } ret = SMB_VFS_NEXT_CHMOD_ACL(handle, conv_smb_fname, mode); saved_errno = errno; TALLOC_FREE(conv); TALLOC_FREE(conv_smb_fname); errno = saved_errno; return ret; } static int shadow_copy2_get_real_filename(struct vfs_handle_struct *handle, const char *path, const char *name, TALLOC_CTX *mem_ctx, char **found_name) { time_t timestamp; char *stripped; ssize_t ret; int saved_errno; char *conv; DEBUG(10, ("shadow_copy2_get_real_filename called for path=[%s], " "name=[%s]\n", path, name)); if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, path, ×tamp, &stripped)) { DEBUG(10, ("shadow_copy2_strip_snapshot failed\n")); return -1; } if (timestamp == 0) { DEBUG(10, ("timestamp == 0\n")); return SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name, mem_ctx, found_name); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { DEBUG(10, ("shadow_copy2_convert failed\n")); return -1; } DEBUG(10, ("Calling NEXT_GET_REAL_FILE_NAME for conv=[%s], " "name=[%s]\n", conv, name)); ret = SMB_VFS_NEXT_GET_REAL_FILENAME(handle, conv, name, mem_ctx, found_name); DEBUG(10, ("NEXT_REAL_FILE_NAME returned %d\n", (int)ret)); saved_errno = errno; TALLOC_FREE(conv); errno = saved_errno; return ret; } static const char *shadow_copy2_connectpath(struct vfs_handle_struct *handle, const char *fname) { time_t timestamp; char *stripped = NULL; char *tmp = NULL; char *result = NULL; int saved_errno; size_t rootpath_len = 0; DBG_DEBUG("Calc connect path for [%s]\n", fname); if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname, ×tamp, &stripped)) { goto done; } if (timestamp == 0) { return SMB_VFS_NEXT_CONNECTPATH(handle, fname); } tmp = shadow_copy2_do_convert(talloc_tos(), handle, stripped, timestamp, &rootpath_len); if (tmp == NULL) { goto done; } DBG_DEBUG("converted path is [%s] root path is [%.*s]\n", tmp, (int)rootpath_len, tmp); tmp[rootpath_len] = '\0'; result = SMB_VFS_NEXT_REALPATH(handle, tmp); if (result == NULL) { goto done; } DBG_DEBUG("connect path is [%s]\n", result); done: saved_errno = errno; TALLOC_FREE(tmp); TALLOC_FREE(stripped); errno = saved_errno; return result; } static uint64_t shadow_copy2_disk_free(vfs_handle_struct *handle, const char *path, uint64_t *bsize, uint64_t *dfree, uint64_t *dsize) { time_t timestamp; char *stripped; ssize_t ret; int saved_errno; char *conv; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, path, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_DISK_FREE(handle, path, bsize, dfree, dsize); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } ret = SMB_VFS_NEXT_DISK_FREE(handle, conv, bsize, dfree, dsize); saved_errno = errno; TALLOC_FREE(conv); errno = saved_errno; return ret; } static int shadow_copy2_get_quota(vfs_handle_struct *handle, const char *path, enum SMB_QUOTA_TYPE qtype, unid_t id, SMB_DISK_QUOTA *dq) { time_t timestamp; char *stripped; int ret; int saved_errno; char *conv; if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, path, ×tamp, &stripped)) { return -1; } if (timestamp == 0) { return SMB_VFS_NEXT_GET_QUOTA(handle, path, qtype, id, dq); } conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp); TALLOC_FREE(stripped); if (conv == NULL) { return -1; } ret = SMB_VFS_NEXT_GET_QUOTA(handle, conv, qtype, id, dq); saved_errno = errno; TALLOC_FREE(conv); errno = saved_errno; return ret; } static int shadow_copy2_connect(struct vfs_handle_struct *handle, const char *service, const char *user) { struct shadow_copy2_config *config; int ret; const char *snapdir; const char *gmt_format; const char *sort_order; const char *basedir = NULL; const char *snapsharepath = NULL; const char *mount_point; DEBUG(10, (__location__ ": cnum[%u], connectpath[%s]\n", (unsigned)handle->conn->cnum, handle->conn->connectpath)); ret = SMB_VFS_NEXT_CONNECT(handle, service, user); if (ret < 0) { return ret; } config = talloc_zero(handle->conn, struct shadow_copy2_config); if (config == NULL) { DEBUG(0, ("talloc_zero() failed\n")); errno = ENOMEM; return -1; } gmt_format = lp_parm_const_string(SNUM(handle->conn), "shadow", "format", GMT_FORMAT); config->gmt_format = talloc_strdup(config, gmt_format); if (config->gmt_format == NULL) { DEBUG(0, ("talloc_strdup() failed\n")); errno = ENOMEM; return -1; } config->use_sscanf = lp_parm_bool(SNUM(handle->conn), "shadow", "sscanf", false); config->use_localtime = lp_parm_bool(SNUM(handle->conn), "shadow", "localtime", false); snapdir = lp_parm_const_string(SNUM(handle->conn), "shadow", "snapdir", ".snapshots"); config->snapdir = talloc_strdup(config, snapdir); if (config->snapdir == NULL) { DEBUG(0, ("talloc_strdup() failed\n")); errno = ENOMEM; return -1; } config->snapdirseverywhere = lp_parm_bool(SNUM(handle->conn), "shadow", "snapdirseverywhere", false); config->crossmountpoints = lp_parm_bool(SNUM(handle->conn), "shadow", "crossmountpoints", false); if (config->crossmountpoints && !config->snapdirseverywhere) { DBG_WARNING("Warning: 'crossmountpoints' depends on " "'snapdirseverywhere'. Disabling crossmountpoints.\n"); } config->fixinodes = lp_parm_bool(SNUM(handle->conn), "shadow", "fixinodes", false); sort_order = lp_parm_const_string(SNUM(handle->conn), "shadow", "sort", "desc"); config->sort_order = talloc_strdup(config, sort_order); if (config->sort_order == NULL) { DEBUG(0, ("talloc_strdup() failed\n")); errno = ENOMEM; return -1; } mount_point = lp_parm_const_string(SNUM(handle->conn), "shadow", "mountpoint", NULL); if (mount_point != NULL) { if (mount_point[0] != '/') { DEBUG(1, (__location__ " Warning: 'mountpoint' is " "relative ('%s'), but it has to be an " "absolute path. Ignoring provided value.\n", mount_point)); mount_point = NULL; } else { char *p; p = strstr(handle->conn->connectpath, mount_point); if (p != handle->conn->connectpath) { DBG_WARNING("Warning: the share root (%s) is " "not a subdirectory of the " "specified mountpoint (%s). " "Ignoring provided value.\n", handle->conn->connectpath, mount_point); mount_point = NULL; } } } if (mount_point != NULL) { config->mount_point = talloc_strdup(config, mount_point); if (config->mount_point == NULL) { DEBUG(0, (__location__ " talloc_strdup() failed\n")); return -1; } } else { config->mount_point = shadow_copy2_find_mount_point(config, handle); if (config->mount_point == NULL) { DBG_WARNING("shadow_copy2_find_mount_point " "of the share root '%s' failed: %s\n", handle->conn->connectpath, strerror(errno)); return -1; } } basedir = lp_parm_const_string(SNUM(handle->conn), "shadow", "basedir", NULL); if (basedir != NULL) { if (basedir[0] != '/') { DEBUG(1, (__location__ " Warning: 'basedir' is " "relative ('%s'), but it has to be an " "absolute path. Disabling basedir.\n", basedir)); basedir = NULL; } else { char *p; p = strstr(basedir, config->mount_point); if (p != basedir) { DEBUG(1, ("Warning: basedir (%s) is not a " "subdirectory of the share root's " "mount point (%s). " "Disabling basedir\n", basedir, config->mount_point)); basedir = NULL; } } } if (config->snapdirseverywhere && basedir != NULL) { DEBUG(1, (__location__ " Warning: 'basedir' is incompatible " "with 'snapdirseverywhere'. Disabling basedir.\n")); basedir = NULL; } snapsharepath = lp_parm_const_string(SNUM(handle->conn), "shadow", "snapsharepath", NULL); if (snapsharepath != NULL) { if (snapsharepath[0] == '/') { DBG_WARNING("Warning: 'snapsharepath' is " "absolute ('%s'), but it has to be a " "relative path. Disabling snapsharepath.\n", snapsharepath); snapsharepath = NULL; } if (config->snapdirseverywhere && snapsharepath != NULL) { DBG_WARNING("Warning: 'snapsharepath' is incompatible " "with 'snapdirseverywhere'. Disabling " "snapsharepath.\n"); snapsharepath = NULL; } } if (basedir != NULL && snapsharepath != NULL) { DBG_WARNING("Warning: 'snapsharepath' is incompatible with " "'basedir'. Disabling snapsharepath\n"); snapsharepath = NULL; } if (snapsharepath != NULL) { config->rel_connectpath = talloc_strdup(config, snapsharepath); if (config->rel_connectpath == NULL) { DBG_ERR("talloc_strdup() failed\n"); errno = ENOMEM; return -1; } } if (basedir == NULL) { basedir = config->mount_point; } if (config->rel_connectpath == NULL && strlen(basedir) != strlen(handle->conn->connectpath)) { config->rel_connectpath = talloc_strdup(config, handle->conn->connectpath + strlen(basedir)); if (config->rel_connectpath == NULL) { DEBUG(0, ("talloc_strdup() failed\n")); errno = ENOMEM; return -1; } } if (config->snapdir[0] == '/') { config->snapdir_absolute = true; if (config->snapdirseverywhere == true) { DEBUG(1, (__location__ " Warning: An absolute snapdir " "is incompatible with 'snapdirseverywhere', " "setting 'snapdirseverywhere' to false.\n")); config->snapdirseverywhere = false; } if (config->crossmountpoints == true) { DEBUG(1, (__location__ " Warning: 'crossmountpoints' " "is not supported with an absolute snapdir. " "Disabling it.\n")); config->crossmountpoints = false; } config->snapshot_basepath = config->snapdir; } else { config->snapshot_basepath = talloc_asprintf(config, "%s/%s", config->mount_point, config->snapdir); if (config->snapshot_basepath == NULL) { DEBUG(0, ("talloc_asprintf() failed\n")); errno = ENOMEM; return -1; } } DEBUG(10, ("shadow_copy2_connect: configuration:\n" " share root: '%s'\n" " mountpoint: '%s'\n" " rel share root: '%s'\n" " snapdir: '%s'\n" " snapshot base path: '%s'\n" " format: '%s'\n" " use sscanf: %s\n" " snapdirs everywhere: %s\n" " cross mountpoints: %s\n" " fix inodes: %s\n" " sort order: %s\n" "", handle->conn->connectpath, config->mount_point, config->rel_connectpath, config->snapdir, config->snapshot_basepath, config->gmt_format, config->use_sscanf ? "yes" : "no", config->snapdirseverywhere ? "yes" : "no", config->crossmountpoints ? "yes" : "no", config->fixinodes ? "yes" : "no", config->sort_order )); SMB_VFS_HANDLE_SET_DATA(handle, config, NULL, struct shadow_copy2_config, return -1); return 0; } static struct vfs_fn_pointers vfs_shadow_copy2_fns = { .connect_fn = shadow_copy2_connect, .opendir_fn = shadow_copy2_opendir, .disk_free_fn = shadow_copy2_disk_free, .get_quota_fn = shadow_copy2_get_quota, .rename_fn = shadow_copy2_rename, .link_fn = shadow_copy2_link, .symlink_fn = shadow_copy2_symlink, .stat_fn = shadow_copy2_stat, .lstat_fn = shadow_copy2_lstat, .fstat_fn = shadow_copy2_fstat, .open_fn = shadow_copy2_open, .unlink_fn = shadow_copy2_unlink, .chmod_fn = shadow_copy2_chmod, .chown_fn = shadow_copy2_chown, .chdir_fn = shadow_copy2_chdir, .ntimes_fn = shadow_copy2_ntimes, .readlink_fn = shadow_copy2_readlink, .mknod_fn = shadow_copy2_mknod, .realpath_fn = shadow_copy2_realpath, .get_nt_acl_fn = shadow_copy2_get_nt_acl, .fget_nt_acl_fn = shadow_copy2_fget_nt_acl, .get_shadow_copy_data_fn = shadow_copy2_get_shadow_copy_data, .mkdir_fn = shadow_copy2_mkdir, .rmdir_fn = shadow_copy2_rmdir, .getxattr_fn = shadow_copy2_getxattr, .listxattr_fn = shadow_copy2_listxattr, .removexattr_fn = shadow_copy2_removexattr, .setxattr_fn = shadow_copy2_setxattr, .chmod_acl_fn = shadow_copy2_chmod_acl, .chflags_fn = shadow_copy2_chflags, .get_real_filename_fn = shadow_copy2_get_real_filename, .connectpath_fn = shadow_copy2_connectpath, }; NTSTATUS vfs_shadow_copy2_init(void); NTSTATUS vfs_shadow_copy2_init(void) { return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "shadow_copy2", &vfs_shadow_copy2_fns); }