mirror of
https://github.com/samba-team/samba.git
synced 2024-12-24 21:34:56 +03:00
1003 lines
28 KiB
C
1003 lines
28 KiB
C
/*
|
|
* implementation of an Shadow Copy module - version 2
|
|
*
|
|
* Copyright (C) Andrew Tridgell 2007
|
|
* Copyright (C) Ed Plese 2009
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include "includes.h"
|
|
#include "smbd/smbd.h"
|
|
#include "system/filesys.h"
|
|
#include "ntioctl.h"
|
|
|
|
/*
|
|
|
|
This is a 2nd implemetation of a shadow copy module for exposing
|
|
snapshots to windows clients as shadow copies. This version has the
|
|
following features:
|
|
|
|
1) you don't need to populate your shares with symlinks to the
|
|
snapshots. This can be very important when you have thousands of
|
|
shares, or use [homes]
|
|
|
|
2) the inode number of the files is altered so it is different
|
|
from the original. This allows the 'restore' button to work
|
|
without a sharing violation
|
|
|
|
3) shadow copy results can be sorted before being sent to the
|
|
client. This is beneficial for filesystems that don't read
|
|
directories alphabetically (the default unix).
|
|
|
|
4) vanity naming for snapshots. Snapshots can be named in any
|
|
format compatible with str[fp]time conversions.
|
|
|
|
5) time stamps in snapshot names can be represented in localtime
|
|
rather than UTC.
|
|
|
|
Module options:
|
|
|
|
shadow:snapdir = <directory where snapshots are kept>
|
|
|
|
This is the directory containing the @GMT-* snapshot directories. If it is an absolute
|
|
path it is used as-is. If it is a relative path, then it is taken relative to the mount
|
|
point of the filesystem that the root of this share is on
|
|
|
|
shadow:basedir = <base directory that snapshots are from>
|
|
|
|
This is an optional parameter that specifies the directory that
|
|
the snapshots are relative to. It defaults to the filesystem
|
|
mount point
|
|
|
|
shadow:fixinodes = yes/no
|
|
|
|
If you enable shadow:fixinodes then this module will modify the
|
|
apparent inode number of files in the snapshot directories using
|
|
a hash of the files path. This is needed for snapshot systems
|
|
where the snapshots have the same device:inode number as the
|
|
original files (such as happens with GPFS snapshots). If you
|
|
don't set this option then the 'restore' button in the shadow
|
|
copy UI will fail with a sharing violation.
|
|
|
|
shadow:sort = asc/desc, or not specified for unsorted (default)
|
|
|
|
This is an optional parameter that specifies that the shadow
|
|
copy directories should be sorted before sending them to the
|
|
client. This can be beneficial as unix filesystems are usually
|
|
not listed alphabetically sorted. If enabled, you typically
|
|
want to specify descending order.
|
|
|
|
shadow:format = <format specification for snapshot names>
|
|
|
|
This is an optional parameter that specifies the format
|
|
specification for the naming of snapshots. The format must
|
|
be compatible with the conversion specifications recognized
|
|
by str[fp]time. The default value is "@GMT-%Y.%m.%d-%H.%M.%S".
|
|
|
|
shadow:localtime = yes/no (default is no)
|
|
|
|
This is an optional parameter that indicates whether the
|
|
snapshot names are in UTC/GMT or the local time.
|
|
|
|
|
|
The following command would generate a correctly formatted directory name
|
|
for use with the default parameters:
|
|
date -u +@GMT-%Y.%m.%d-%H.%M.%S
|
|
|
|
*/
|
|
|
|
static int vfs_shadow_copy2_debug_level = DBGC_VFS;
|
|
|
|
#undef DBGC_CLASS
|
|
#define DBGC_CLASS vfs_shadow_copy2_debug_level
|
|
|
|
#define GMT_NAME_LEN 24 /* length of a @GMT- name */
|
|
#define SHADOW_COPY2_GMT_FORMAT "@GMT-%Y.%m.%d-%H.%M.%S"
|
|
|
|
#define SHADOW_COPY2_DEFAULT_SORT NULL
|
|
#define SHADOW_COPY2_DEFAULT_FORMAT "@GMT-%Y.%m.%d-%H.%M.%S"
|
|
#define SHADOW_COPY2_DEFAULT_LOCALTIME false
|
|
|
|
/*
|
|
make very sure it is one of our special names
|
|
*/
|
|
static inline bool shadow_copy2_match_name(const char *name, const char **gmt_start)
|
|
{
|
|
unsigned year, month, day, hr, min, sec;
|
|
const char *p;
|
|
if (gmt_start) {
|
|
(*gmt_start) = NULL;
|
|
}
|
|
p = strstr_m(name, "@GMT-");
|
|
if (p == NULL) return false;
|
|
if (p > name && p[-1] != '/') return False;
|
|
if (sscanf(p, "@GMT-%04u.%02u.%02u-%02u.%02u.%02u", &year, &month,
|
|
&day, &hr, &min, &sec) != 6) {
|
|
return False;
|
|
}
|
|
if (p[24] != 0 && p[24] != '/') {
|
|
return False;
|
|
}
|
|
if (gmt_start) {
|
|
(*gmt_start) = p;
|
|
}
|
|
return True;
|
|
}
|
|
|
|
static char *shadow_copy2_snapshot_to_gmt(TALLOC_CTX *mem_ctx,
|
|
vfs_handle_struct *handle, const char *name)
|
|
{
|
|
struct tm timestamp;
|
|
time_t timestamp_t;
|
|
char gmt[GMT_NAME_LEN + 1];
|
|
const char *fmt;
|
|
|
|
fmt = lp_parm_const_string(SNUM(handle->conn), "shadow",
|
|
"format", SHADOW_COPY2_DEFAULT_FORMAT);
|
|
|
|
ZERO_STRUCT(timestamp);
|
|
if (strptime(name, fmt, ×tamp) == NULL) {
|
|
DEBUG(10, ("shadow_copy2_snapshot_to_gmt: no match %s: %s\n",
|
|
fmt, name));
|
|
return NULL;
|
|
}
|
|
|
|
DEBUG(10, ("shadow_copy2_snapshot_to_gmt: match %s: %s\n", fmt, name));
|
|
if (lp_parm_bool(SNUM(handle->conn), "shadow", "localtime",
|
|
SHADOW_COPY2_DEFAULT_LOCALTIME))
|
|
{
|
|
timestamp.tm_isdst = -1;
|
|
timestamp_t = mktime(×tamp);
|
|
gmtime_r(×tamp_t, ×tamp);
|
|
}
|
|
strftime(gmt, sizeof(gmt), SHADOW_COPY2_GMT_FORMAT, ×tamp);
|
|
|
|
return talloc_strdup(mem_ctx, gmt);
|
|
}
|
|
|
|
/*
|
|
shadow copy paths can also come into the server in this form:
|
|
|
|
/foo/bar/@GMT-XXXXX/some/file
|
|
|
|
This function normalises the filename to be of the form:
|
|
|
|
@GMT-XXXX/foo/bar/some/file
|
|
*/
|
|
static const char *shadow_copy2_normalise_path(TALLOC_CTX *mem_ctx, const char *path, const char *gmt_start)
|
|
{
|
|
char *pcopy;
|
|
char buf[GMT_NAME_LEN];
|
|
size_t prefix_len;
|
|
|
|
if (path == gmt_start) {
|
|
return path;
|
|
}
|
|
|
|
prefix_len = gmt_start - path - 1;
|
|
|
|
DEBUG(10, ("path=%s, gmt_start=%s, prefix_len=%d\n", path, gmt_start,
|
|
(int)prefix_len));
|
|
|
|
/*
|
|
* We've got a/b/c/@GMT-YYYY.MM.DD-HH.MM.SS/d/e. convert to
|
|
* @GMT-YYYY.MM.DD-HH.MM.SS/a/b/c/d/e before further
|
|
* processing. As many VFS calls provide a const char *,
|
|
* unfortunately we have to make a copy.
|
|
*/
|
|
|
|
pcopy = talloc_strdup(talloc_tos(), path);
|
|
if (pcopy == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
gmt_start = pcopy + prefix_len;
|
|
|
|
/*
|
|
* Copy away "@GMT-YYYY.MM.DD-HH.MM.SS"
|
|
*/
|
|
memcpy(buf, gmt_start+1, GMT_NAME_LEN);
|
|
|
|
/*
|
|
* Make space for it including a trailing /
|
|
*/
|
|
memmove(pcopy + GMT_NAME_LEN + 1, pcopy, prefix_len);
|
|
|
|
/*
|
|
* Move in "@GMT-YYYY.MM.DD-HH.MM.SS/" at the beginning again
|
|
*/
|
|
memcpy(pcopy, buf, GMT_NAME_LEN);
|
|
pcopy[GMT_NAME_LEN] = '/';
|
|
|
|
DEBUG(10, ("shadow_copy2_normalise_path: %s -> %s\n", path, pcopy));
|
|
|
|
return pcopy;
|
|
}
|
|
|
|
/*
|
|
convert a name to the shadow directory
|
|
*/
|
|
|
|
#define _SHADOW2_NEXT(op, args, rtype, eret, extra) do { \
|
|
const char *name = fname; \
|
|
const char *gmt_start; \
|
|
if (shadow_copy2_match_name(fname, &gmt_start)) { \
|
|
char *name2; \
|
|
rtype ret; \
|
|
name2 = convert_shadow2_name(handle, fname, gmt_start); \
|
|
if (name2 == NULL) { \
|
|
errno = EINVAL; \
|
|
return eret; \
|
|
} \
|
|
name = name2; \
|
|
ret = SMB_VFS_NEXT_ ## op args; \
|
|
talloc_free(name2); \
|
|
if (ret != eret) extra; \
|
|
return ret; \
|
|
} else { \
|
|
return SMB_VFS_NEXT_ ## op args; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define _SHADOW2_NEXT_SMB_FNAME(op, args, rtype, eret, extra) do { \
|
|
const char *gmt_start; \
|
|
if (shadow_copy2_match_name(smb_fname->base_name, &gmt_start)) { \
|
|
char *name2; \
|
|
char *smb_base_name_tmp = NULL; \
|
|
rtype ret; \
|
|
name2 = convert_shadow2_name(handle, smb_fname->base_name, gmt_start); \
|
|
if (name2 == NULL) { \
|
|
errno = EINVAL; \
|
|
return eret; \
|
|
} \
|
|
smb_base_name_tmp = smb_fname->base_name; \
|
|
smb_fname->base_name = name2; \
|
|
ret = SMB_VFS_NEXT_ ## op args; \
|
|
smb_fname->base_name = smb_base_name_tmp; \
|
|
talloc_free(name2); \
|
|
if (ret != eret) extra; \
|
|
return ret; \
|
|
} else { \
|
|
return SMB_VFS_NEXT_ ## op args; \
|
|
} \
|
|
} while (0)
|
|
|
|
/*
|
|
convert a name to the shadow directory: NTSTATUS-specific handling
|
|
*/
|
|
|
|
#define _SHADOW2_NTSTATUS_NEXT(op, args, eret, extra) do { \
|
|
const char *name = fname; \
|
|
const char *gmt_start; \
|
|
if (shadow_copy2_match_name(fname, &gmt_start)) { \
|
|
char *name2; \
|
|
NTSTATUS ret; \
|
|
name2 = convert_shadow2_name(handle, fname, gmt_start); \
|
|
if (name2 == NULL) { \
|
|
errno = EINVAL; \
|
|
return eret; \
|
|
} \
|
|
name = name2; \
|
|
ret = SMB_VFS_NEXT_ ## op args; \
|
|
talloc_free(name2); \
|
|
if (!NT_STATUS_EQUAL(ret, eret)) extra; \
|
|
return ret; \
|
|
} else { \
|
|
return SMB_VFS_NEXT_ ## op args; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define SHADOW2_NTSTATUS_NEXT(op, args, eret) _SHADOW2_NTSTATUS_NEXT(op, args, eret, )
|
|
|
|
#define SHADOW2_NEXT(op, args, rtype, eret) _SHADOW2_NEXT(op, args, rtype, eret, )
|
|
|
|
#define SHADOW2_NEXT_SMB_FNAME(op, args, rtype, eret) _SHADOW2_NEXT_SMB_FNAME(op, args, rtype, eret, )
|
|
|
|
#define SHADOW2_NEXT2(op, args) do { \
|
|
const char *gmt_start1, *gmt_start2; \
|
|
if (shadow_copy2_match_name(oldname, &gmt_start1) || \
|
|
shadow_copy2_match_name(newname, &gmt_start2)) { \
|
|
errno = EROFS; \
|
|
return -1; \
|
|
} else { \
|
|
return SMB_VFS_NEXT_ ## op args; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define SHADOW2_NEXT2_SMB_FNAME(op, args) do { \
|
|
const char *gmt_start1, *gmt_start2; \
|
|
if (shadow_copy2_match_name(smb_fname_src->base_name, &gmt_start1) || \
|
|
shadow_copy2_match_name(smb_fname_dst->base_name, &gmt_start2)) { \
|
|
errno = EROFS; \
|
|
return -1; \
|
|
} else { \
|
|
return SMB_VFS_NEXT_ ## op args; \
|
|
} \
|
|
} while (0)
|
|
|
|
|
|
/*
|
|
find the mount point of a filesystem
|
|
*/
|
|
static char *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;
|
|
}
|
|
|
|
/*
|
|
work out the location of the snapshot for this share
|
|
*/
|
|
static const char *shadow_copy2_find_snapdir(TALLOC_CTX *mem_ctx, vfs_handle_struct *handle)
|
|
{
|
|
const char *snapdir;
|
|
char *mount_point;
|
|
const char *ret;
|
|
|
|
snapdir = lp_parm_const_string(SNUM(handle->conn), "shadow", "snapdir", NULL);
|
|
if (snapdir == NULL) {
|
|
return NULL;
|
|
}
|
|
/* if its an absolute path, we're done */
|
|
if (*snapdir == '/') {
|
|
return snapdir;
|
|
}
|
|
|
|
/* other its relative to the filesystem mount point */
|
|
mount_point = find_mount_point(mem_ctx, handle);
|
|
if (mount_point == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
ret = talloc_asprintf(mem_ctx, "%s/%s", mount_point, snapdir);
|
|
talloc_free(mount_point);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
work out the location of the base directory for snapshots of this share
|
|
*/
|
|
static const char *shadow_copy2_find_basedir(TALLOC_CTX *mem_ctx, vfs_handle_struct *handle)
|
|
{
|
|
const char *basedir = lp_parm_const_string(SNUM(handle->conn), "shadow", "basedir", NULL);
|
|
|
|
/* other its the filesystem mount point */
|
|
if (basedir == NULL) {
|
|
basedir = find_mount_point(mem_ctx, handle);
|
|
}
|
|
|
|
return basedir;
|
|
}
|
|
|
|
/*
|
|
convert a filename from a share relative path, to a path in the
|
|
snapshot directory
|
|
*/
|
|
static char *convert_shadow2_name(vfs_handle_struct *handle, const char *fname, const char *gmt_path)
|
|
{
|
|
TALLOC_CTX *tmp_ctx = talloc_new(handle->data);
|
|
const char *snapdir, *relpath, *baseoffset, *basedir;
|
|
size_t baselen;
|
|
char *ret, *prefix;
|
|
|
|
struct tm timestamp;
|
|
time_t timestamp_t;
|
|
char snapshot[MAXPATHLEN];
|
|
const char *fmt;
|
|
|
|
fmt = lp_parm_const_string(SNUM(handle->conn), "shadow",
|
|
"format", SHADOW_COPY2_DEFAULT_FORMAT);
|
|
|
|
snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle);
|
|
if (snapdir == NULL) {
|
|
DEBUG(2,("no snapdir found for share at %s\n", handle->conn->connectpath));
|
|
talloc_free(tmp_ctx);
|
|
return NULL;
|
|
}
|
|
|
|
basedir = shadow_copy2_find_basedir(tmp_ctx, handle);
|
|
if (basedir == NULL) {
|
|
DEBUG(2,("no basedir found for share at %s\n", handle->conn->connectpath));
|
|
talloc_free(tmp_ctx);
|
|
return NULL;
|
|
}
|
|
|
|
prefix = talloc_asprintf(tmp_ctx, "%s/@GMT-", snapdir);
|
|
if (strncmp(fname, prefix, (talloc_get_size(prefix)-1)) == 0) {
|
|
/* this looks like as we have already normalized it, leave it untouched*/
|
|
talloc_free(tmp_ctx);
|
|
return talloc_strdup(handle->data, fname);
|
|
}
|
|
|
|
if (strncmp(fname, "@GMT-", 5) != 0) {
|
|
fname = shadow_copy2_normalise_path(tmp_ctx, fname, gmt_path);
|
|
if (fname == NULL) {
|
|
talloc_free(tmp_ctx);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
ZERO_STRUCT(timestamp);
|
|
relpath = strptime(fname, SHADOW_COPY2_GMT_FORMAT, ×tamp);
|
|
if (relpath == NULL) {
|
|
talloc_free(tmp_ctx);
|
|
return NULL;
|
|
}
|
|
|
|
/* relpath is the remaining portion of the path after the @GMT-xxx */
|
|
|
|
if (lp_parm_bool(SNUM(handle->conn), "shadow", "localtime",
|
|
SHADOW_COPY2_DEFAULT_LOCALTIME))
|
|
{
|
|
timestamp_t = timegm(×tamp);
|
|
localtime_r(×tamp_t, ×tamp);
|
|
}
|
|
|
|
strftime(snapshot, MAXPATHLEN, fmt, ×tamp);
|
|
|
|
baselen = strlen(basedir);
|
|
baseoffset = handle->conn->connectpath + baselen;
|
|
|
|
/* some sanity checks */
|
|
if (strncmp(basedir, handle->conn->connectpath, baselen) != 0 ||
|
|
(handle->conn->connectpath[baselen] != 0 && handle->conn->connectpath[baselen] != '/')) {
|
|
DEBUG(0,("convert_shadow2_name: basedir %s is not a parent of %s\n",
|
|
basedir, handle->conn->connectpath));
|
|
talloc_free(tmp_ctx);
|
|
return NULL;
|
|
}
|
|
|
|
if (*relpath == '/') relpath++;
|
|
if (*baseoffset == '/') baseoffset++;
|
|
|
|
ret = talloc_asprintf(handle->data, "%s/%s/%s/%s",
|
|
snapdir,
|
|
snapshot,
|
|
baseoffset,
|
|
relpath);
|
|
DEBUG(6,("convert_shadow2_name: '%s' -> '%s'\n", fname, ret));
|
|
talloc_free(tmp_ctx);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/*
|
|
simple string hash
|
|
*/
|
|
static uint32 string_hash(const char *s)
|
|
{
|
|
uint32 n = 0;
|
|
while (*s) {
|
|
n = ((n << 5) + n) ^ (uint32)(*s++);
|
|
}
|
|
return n;
|
|
}
|
|
|
|
/*
|
|
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)
|
|
{
|
|
if (lp_parm_bool(SNUM(handle->conn), "shadow", "fixinodes", False)) {
|
|
/* 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
|
|
*/
|
|
uint32_t shash = string_hash(fname) & 0xFF000000;
|
|
if (shash == 0) {
|
|
shash = 1;
|
|
}
|
|
sbuf->st_ex_ino ^= shash;
|
|
}
|
|
}
|
|
|
|
static int shadow_copy2_rename(vfs_handle_struct *handle,
|
|
const struct smb_filename *smb_fname_src,
|
|
const struct smb_filename *smb_fname_dst)
|
|
{
|
|
if (shadow_copy2_match_name(smb_fname_src->base_name, NULL)) {
|
|
errno = EXDEV;
|
|
return -1;
|
|
}
|
|
SHADOW2_NEXT2_SMB_FNAME(RENAME,
|
|
(handle, smb_fname_src, smb_fname_dst));
|
|
}
|
|
|
|
static int shadow_copy2_symlink(vfs_handle_struct *handle,
|
|
const char *oldname, const char *newname)
|
|
{
|
|
SHADOW2_NEXT2(SYMLINK, (handle, oldname, newname));
|
|
}
|
|
|
|
static int shadow_copy2_link(vfs_handle_struct *handle,
|
|
const char *oldname, const char *newname)
|
|
{
|
|
SHADOW2_NEXT2(LINK, (handle, oldname, newname));
|
|
}
|
|
|
|
static int shadow_copy2_open(vfs_handle_struct *handle,
|
|
struct smb_filename *smb_fname, files_struct *fsp,
|
|
int flags, mode_t mode)
|
|
{
|
|
SHADOW2_NEXT_SMB_FNAME(OPEN,
|
|
(handle, smb_fname, fsp, flags, mode),
|
|
int, -1);
|
|
}
|
|
|
|
static SMB_STRUCT_DIR *shadow_copy2_opendir(vfs_handle_struct *handle,
|
|
const char *fname, const char *mask, uint32 attr)
|
|
{
|
|
SHADOW2_NEXT(OPENDIR, (handle, name, mask, attr), SMB_STRUCT_DIR *, NULL);
|
|
}
|
|
|
|
static int shadow_copy2_stat(vfs_handle_struct *handle,
|
|
struct smb_filename *smb_fname)
|
|
{
|
|
_SHADOW2_NEXT_SMB_FNAME(STAT, (handle, smb_fname), int, -1,
|
|
convert_sbuf(handle, smb_fname->base_name,
|
|
&smb_fname->st));
|
|
}
|
|
|
|
static int shadow_copy2_lstat(vfs_handle_struct *handle,
|
|
struct smb_filename *smb_fname)
|
|
{
|
|
_SHADOW2_NEXT_SMB_FNAME(LSTAT, (handle, smb_fname), int, -1,
|
|
convert_sbuf(handle, smb_fname->base_name,
|
|
&smb_fname->st));
|
|
}
|
|
|
|
static int shadow_copy2_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
|
|
{
|
|
int ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
|
|
if (ret == 0 && shadow_copy2_match_name(fsp->fsp_name->base_name, NULL)) {
|
|
convert_sbuf(handle, fsp->fsp_name->base_name, sbuf);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
static int shadow_copy2_unlink(vfs_handle_struct *handle,
|
|
const struct smb_filename *smb_fname_in)
|
|
{
|
|
struct smb_filename *smb_fname = NULL;
|
|
NTSTATUS status;
|
|
|
|
status = copy_smb_filename(talloc_tos(), smb_fname_in, &smb_fname);
|
|
if (!NT_STATUS_IS_OK(status)) {
|
|
errno = map_errno_from_nt_status(status);
|
|
return -1;
|
|
}
|
|
|
|
SHADOW2_NEXT_SMB_FNAME(UNLINK, (handle, smb_fname), int, -1);
|
|
}
|
|
|
|
static int shadow_copy2_chmod(vfs_handle_struct *handle,
|
|
const char *fname, mode_t mode)
|
|
{
|
|
SHADOW2_NEXT(CHMOD, (handle, name, mode), int, -1);
|
|
}
|
|
|
|
static int shadow_copy2_chown(vfs_handle_struct *handle,
|
|
const char *fname, uid_t uid, gid_t gid)
|
|
{
|
|
SHADOW2_NEXT(CHOWN, (handle, name, uid, gid), int, -1);
|
|
}
|
|
|
|
static int shadow_copy2_chdir(vfs_handle_struct *handle,
|
|
const char *fname)
|
|
{
|
|
SHADOW2_NEXT(CHDIR, (handle, name), int, -1);
|
|
}
|
|
|
|
static int shadow_copy2_ntimes(vfs_handle_struct *handle,
|
|
const struct smb_filename *smb_fname_in,
|
|
struct smb_file_time *ft)
|
|
{
|
|
struct smb_filename *smb_fname = NULL;
|
|
NTSTATUS status;
|
|
|
|
status = copy_smb_filename(talloc_tos(), smb_fname_in, &smb_fname);
|
|
if (!NT_STATUS_IS_OK(status)) {
|
|
errno = map_errno_from_nt_status(status);
|
|
return -1;
|
|
}
|
|
|
|
SHADOW2_NEXT_SMB_FNAME(NTIMES, (handle, smb_fname, ft), int, -1);
|
|
}
|
|
|
|
static int shadow_copy2_readlink(vfs_handle_struct *handle,
|
|
const char *fname, char *buf, size_t bufsiz)
|
|
{
|
|
SHADOW2_NEXT(READLINK, (handle, name, buf, bufsiz), int, -1);
|
|
}
|
|
|
|
static int shadow_copy2_mknod(vfs_handle_struct *handle,
|
|
const char *fname, mode_t mode, SMB_DEV_T dev)
|
|
{
|
|
SHADOW2_NEXT(MKNOD, (handle, name, mode, dev), int, -1);
|
|
}
|
|
|
|
static char *shadow_copy2_realpath(vfs_handle_struct *handle,
|
|
const char *fname)
|
|
{
|
|
const char *gmt;
|
|
|
|
if (shadow_copy2_match_name(fname, &gmt)
|
|
&& (gmt[GMT_NAME_LEN] == '\0')) {
|
|
char *copy;
|
|
|
|
copy = talloc_strdup(talloc_tos(), fname);
|
|
if (copy == NULL) {
|
|
errno = ENOMEM;
|
|
return NULL;
|
|
}
|
|
|
|
copy[gmt - fname] = '.';
|
|
copy[gmt - fname + 1] = '\0';
|
|
|
|
DEBUG(10, ("calling NEXT_REALPATH with %s\n", copy));
|
|
SHADOW2_NEXT(REALPATH, (handle, name), char *,
|
|
NULL);
|
|
}
|
|
SHADOW2_NEXT(REALPATH, (handle, name), char *, NULL);
|
|
}
|
|
|
|
static const char *shadow_copy2_connectpath(struct vfs_handle_struct *handle,
|
|
const char *fname)
|
|
{
|
|
TALLOC_CTX *tmp_ctx;
|
|
const char *snapdir, *baseoffset, *basedir, *gmt_start;
|
|
size_t baselen;
|
|
char *ret;
|
|
|
|
DEBUG(10, ("shadow_copy2_connectpath called with %s\n", fname));
|
|
|
|
if (!shadow_copy2_match_name(fname, &gmt_start)) {
|
|
return handle->conn->connectpath;
|
|
}
|
|
|
|
/*
|
|
* We have to create a real temporary context because we have
|
|
* to put our result on talloc_tos(). Thus we can't use a
|
|
* talloc_stackframe() here.
|
|
*/
|
|
tmp_ctx = talloc_new(talloc_tos());
|
|
|
|
fname = shadow_copy2_normalise_path(tmp_ctx, fname, gmt_start);
|
|
if (fname == NULL) {
|
|
TALLOC_FREE(tmp_ctx);
|
|
return NULL;
|
|
}
|
|
|
|
snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle);
|
|
if (snapdir == NULL) {
|
|
DEBUG(2,("no snapdir found for share at %s\n",
|
|
handle->conn->connectpath));
|
|
TALLOC_FREE(tmp_ctx);
|
|
return NULL;
|
|
}
|
|
|
|
basedir = shadow_copy2_find_basedir(tmp_ctx, handle);
|
|
if (basedir == NULL) {
|
|
DEBUG(2,("no basedir found for share at %s\n",
|
|
handle->conn->connectpath));
|
|
TALLOC_FREE(tmp_ctx);
|
|
return NULL;
|
|
}
|
|
|
|
baselen = strlen(basedir);
|
|
baseoffset = handle->conn->connectpath + baselen;
|
|
|
|
/* some sanity checks */
|
|
if (strncmp(basedir, handle->conn->connectpath, baselen) != 0 ||
|
|
(handle->conn->connectpath[baselen] != 0
|
|
&& handle->conn->connectpath[baselen] != '/')) {
|
|
DEBUG(0,("shadow_copy2_connectpath: basedir %s is not a "
|
|
"parent of %s\n", basedir,
|
|
handle->conn->connectpath));
|
|
TALLOC_FREE(tmp_ctx);
|
|
return NULL;
|
|
}
|
|
|
|
if (*baseoffset == '/') baseoffset++;
|
|
|
|
ret = talloc_asprintf(talloc_tos(), "%s/%.*s/%s",
|
|
snapdir,
|
|
GMT_NAME_LEN, fname,
|
|
baseoffset);
|
|
DEBUG(6,("shadow_copy2_connectpath: '%s' -> '%s'\n", fname, ret));
|
|
TALLOC_FREE(tmp_ctx);
|
|
return ret;
|
|
}
|
|
|
|
static NTSTATUS shadow_copy2_get_nt_acl(vfs_handle_struct *handle,
|
|
const char *fname, uint32 security_info,
|
|
struct security_descriptor **ppdesc)
|
|
{
|
|
SHADOW2_NTSTATUS_NEXT(GET_NT_ACL, (handle, name, security_info, ppdesc), NT_STATUS_ACCESS_DENIED);
|
|
}
|
|
|
|
static int shadow_copy2_mkdir(vfs_handle_struct *handle, const char *fname, mode_t mode)
|
|
{
|
|
SHADOW2_NEXT(MKDIR, (handle, name, mode), int, -1);
|
|
}
|
|
|
|
static int shadow_copy2_rmdir(vfs_handle_struct *handle, const char *fname)
|
|
{
|
|
SHADOW2_NEXT(RMDIR, (handle, name), int, -1);
|
|
}
|
|
|
|
static int shadow_copy2_chflags(vfs_handle_struct *handle, const char *fname,
|
|
unsigned int flags)
|
|
{
|
|
SHADOW2_NEXT(CHFLAGS, (handle, name, flags), int, -1);
|
|
}
|
|
|
|
static ssize_t shadow_copy2_getxattr(vfs_handle_struct *handle,
|
|
const char *fname, const char *aname, void *value, size_t size)
|
|
{
|
|
SHADOW2_NEXT(GETXATTR, (handle, name, aname, value, size), ssize_t, -1);
|
|
}
|
|
|
|
static ssize_t shadow_copy2_lgetxattr(vfs_handle_struct *handle,
|
|
const char *fname, const char *aname, void *value, size_t size)
|
|
{
|
|
SHADOW2_NEXT(LGETXATTR, (handle, name, aname, value, size), ssize_t, -1);
|
|
}
|
|
|
|
static ssize_t shadow_copy2_listxattr(struct vfs_handle_struct *handle, const char *fname,
|
|
char *list, size_t size)
|
|
{
|
|
SHADOW2_NEXT(LISTXATTR, (handle, name, list, size), ssize_t, -1);
|
|
}
|
|
|
|
static int shadow_copy2_removexattr(struct vfs_handle_struct *handle, const char *fname,
|
|
const char *aname)
|
|
{
|
|
SHADOW2_NEXT(REMOVEXATTR, (handle, name, aname), int, -1);
|
|
}
|
|
|
|
static int shadow_copy2_lremovexattr(struct vfs_handle_struct *handle, const char *fname,
|
|
const char *aname)
|
|
{
|
|
SHADOW2_NEXT(LREMOVEXATTR, (handle, name, aname), int, -1);
|
|
}
|
|
|
|
static int shadow_copy2_setxattr(struct vfs_handle_struct *handle, const char *fname,
|
|
const char *aname, const void *value, size_t size, int flags)
|
|
{
|
|
SHADOW2_NEXT(SETXATTR, (handle, name, aname, value, size, flags), int, -1);
|
|
}
|
|
|
|
static int shadow_copy2_lsetxattr(struct vfs_handle_struct *handle, const char *fname,
|
|
const char *aname, const void *value, size_t size, int flags)
|
|
{
|
|
SHADOW2_NEXT(LSETXATTR, (handle, name, aname, value, size, flags), int, -1);
|
|
}
|
|
|
|
static int shadow_copy2_chmod_acl(vfs_handle_struct *handle,
|
|
const char *fname, mode_t mode)
|
|
{
|
|
SHADOW2_NEXT(CHMOD_ACL, (handle, name, mode), int, -1);
|
|
}
|
|
|
|
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,
|
|
SHADOW_COPY_DATA *shadow_copy2_data)
|
|
{
|
|
int (*cmpfunc)(const void *, const void *);
|
|
const char *sort;
|
|
|
|
sort = lp_parm_const_string(SNUM(handle->conn), "shadow",
|
|
"sort", SHADOW_COPY2_DEFAULT_SORT);
|
|
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);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
static int shadow_copy2_get_shadow_copy2_data(vfs_handle_struct *handle,
|
|
files_struct *fsp,
|
|
SHADOW_COPY_DATA *shadow_copy2_data,
|
|
bool labels)
|
|
{
|
|
SMB_STRUCT_DIR *p;
|
|
const char *snapdir;
|
|
SMB_STRUCT_DIRENT *d;
|
|
TALLOC_CTX *tmp_ctx = talloc_new(handle->data);
|
|
char *snapshot;
|
|
|
|
snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle);
|
|
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;
|
|
}
|
|
|
|
p = SMB_VFS_NEXT_OPENDIR(handle, snapdir, 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))) {
|
|
SHADOW_COPY_LABEL *tlabels;
|
|
|
|
/* ignore names not of the right form in the snapshot directory */
|
|
snapshot = shadow_copy2_snapshot_to_gmt(tmp_ctx, handle,
|
|
d->d_name);
|
|
DEBUG(6,("shadow_copy2_get_shadow_copy2_data: %s -> %s\n",
|
|
d->d_name, snapshot));
|
|
if (!snapshot) {
|
|
continue;
|
|
}
|
|
|
|
if (!labels) {
|
|
/* the caller doesn't want the labels */
|
|
shadow_copy2_data->num_volumes++;
|
|
continue;
|
|
}
|
|
|
|
tlabels = talloc_realloc(shadow_copy2_data->mem_ctx,
|
|
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));
|
|
talloc_free(snapshot);
|
|
|
|
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 struct vfs_fn_pointers vfs_shadow_copy2_fns = {
|
|
.opendir = shadow_copy2_opendir,
|
|
.mkdir = shadow_copy2_mkdir,
|
|
.rmdir = shadow_copy2_rmdir,
|
|
.chflags = shadow_copy2_chflags,
|
|
.getxattr = shadow_copy2_getxattr,
|
|
.lgetxattr = shadow_copy2_lgetxattr,
|
|
.listxattr = shadow_copy2_listxattr,
|
|
.removexattr = shadow_copy2_removexattr,
|
|
.lremovexattr = shadow_copy2_lremovexattr,
|
|
.setxattr = shadow_copy2_setxattr,
|
|
.lsetxattr = shadow_copy2_lsetxattr,
|
|
.open_fn = shadow_copy2_open,
|
|
.rename = shadow_copy2_rename,
|
|
.stat = shadow_copy2_stat,
|
|
.lstat = shadow_copy2_lstat,
|
|
.fstat = shadow_copy2_fstat,
|
|
.unlink = shadow_copy2_unlink,
|
|
.chmod = shadow_copy2_chmod,
|
|
.chown = shadow_copy2_chown,
|
|
.chdir = shadow_copy2_chdir,
|
|
.ntimes = shadow_copy2_ntimes,
|
|
.symlink = shadow_copy2_symlink,
|
|
.vfs_readlink = shadow_copy2_readlink,
|
|
.link = shadow_copy2_link,
|
|
.mknod = shadow_copy2_mknod,
|
|
.realpath = shadow_copy2_realpath,
|
|
.connectpath = shadow_copy2_connectpath,
|
|
.get_nt_acl = shadow_copy2_get_nt_acl,
|
|
.chmod_acl = shadow_copy2_chmod_acl,
|
|
.get_shadow_copy_data = shadow_copy2_get_shadow_copy2_data,
|
|
};
|
|
|
|
NTSTATUS vfs_shadow_copy2_init(void);
|
|
NTSTATUS vfs_shadow_copy2_init(void)
|
|
{
|
|
NTSTATUS ret;
|
|
|
|
ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "shadow_copy2",
|
|
&vfs_shadow_copy2_fns);
|
|
|
|
if (!NT_STATUS_IS_OK(ret))
|
|
return ret;
|
|
|
|
vfs_shadow_copy2_debug_level = debug_add_class("shadow_copy2");
|
|
if (vfs_shadow_copy2_debug_level == -1) {
|
|
vfs_shadow_copy2_debug_level = DBGC_VFS;
|
|
DEBUG(0, ("%s: Couldn't register custom debugging class!\n",
|
|
"vfs_shadow_copy2_init"));
|
|
} else {
|
|
DEBUG(10, ("%s: Debug class number of '%s': %d\n",
|
|
"vfs_shadow_copy2_init","shadow_copy2",vfs_shadow_copy2_debug_level));
|
|
}
|
|
|
|
return ret;
|
|
}
|