samba-mirror/source3/modules/vfs_shadow_copy2.c

/* 
 * implementation of an Shadow Copy module - version 2
 *
 * Copyright (C) Andrew Tridgell     2007
 *
 * 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"

/*

  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

  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.

  Note that the directory names in the snapshot directory must take the form
  @GMT-YYYY.MM.DD-HH.MM.SS
  
  The following command would generate a correctly formatted directory name:
     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 */

/*
  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;
}

/*
  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;

	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;
	}

	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;
		}
	}

	relpath = fname + GMT_NAME_LEN;
	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, 
			      GMT_NAME_LEN, fname, 
			      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)
{
	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, char *resolved_path)
{
	const char *gmt;

	if (shadow_copy2_match_name(fname, &gmt)
	    && (gmt[GMT_NAME_LEN] == '\0')) {
		char *copy, *result;

		copy = talloc_strdup(talloc_tos(), fname);
		if (copy == NULL) {
			errno = ENOMEM;
			return NULL;
		}

		copy[gmt - fname] = '.';

		DEBUG(10, ("calling NEXT_REALPATH with %s\n", copy));
		result = SMB_VFS_NEXT_REALPATH(handle, copy, resolved_path);
		TALLOC_FREE(copy);
		return result;
	}
        SHADOW2_NEXT(REALPATH, (handle, name, resolved_path), char *, NULL);
}

static const char *shadow_copy2_connectpath(struct vfs_handle_struct *handle,
					    const char *fname)
{
	TALLOC_CTX *tmp_ctx = talloc_stackframe();
	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;
	}

	fname = shadow_copy2_normalise_path(talloc_tos(), 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_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);

	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;
	}

	talloc_free(tmp_ctx);

	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 */
		if (!shadow_copy2_match_name(d->d_name, NULL)) {
			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);
			return -1;
		}

		strlcpy(tlabels[shadow_copy2_data->num_volumes], d->d_name, sizeof(*tlabels));
		shadow_copy2_data->num_volumes++;
		shadow_copy2_data->labels = tlabels;
	}

	SMB_VFS_NEXT_CLOSEDIR(handle,p);
	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 = 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;
}