source3/modules/vfs_shadow_copy.c

   1 /*
   2  * implementation of an Shadow Copy module
   3  *
   4  * Copyright (C) Stefan Metzmacher      2003-2004
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "includes.h"
  21 #include "smbd/smbd.h"
  22 #include "ntioctl.h"
  23
  24 /*
  25     Please read the VFS module Samba-HowTo-Collection.
  26     there's a chapter about this module
  27
  28     For this share
  29     Z:\
  30
  31     the ShadowCopies are in this directories
  32
  33     Z:\@GMT-2003.08.05-12.00.00\
  34     Z:\@GMT-2003.08.05-12.01.00\
  35     Z:\@GMT-2003.08.05-12.02.00\
  36
  37     e.g.
  38
  39     Z:\testfile.txt
  40     Z:\@GMT-2003.08.05-12.02.00\testfile.txt
  41
  42     or:
  43
  44     Z:\testdir\testfile.txt
  45     Z:\@GMT-2003.08.05-12.02.00\testdir\testfile.txt
  46
  47
  48     Note: Files must differ to be displayed via Windows Explorer!
  49           Directories are always displayed...
  50 */
  51
  52 static int vfs_shadow_copy_debug_level = DBGC_VFS;
  53
  54 #undef DBGC_CLASS
  55 #define DBGC_CLASS vfs_shadow_copy_debug_level
  56
  57 #define SHADOW_COPY_PREFIX "@GMT-"
  58 #define SHADOW_COPY_SAMPLE "@GMT-2004.02.18-15.44.00"
  59
  60 typedef struct {
  61         int pos;
  62         int num;
  63         struct dirent *dirs;
  64 } shadow_copy_Dir;
  65
  66 static bool shadow_copy_match_name(const char *name)
  67 {
  68         if (strncmp(SHADOW_COPY_PREFIX,name, sizeof(SHADOW_COPY_PREFIX)-1)==0 &&
  69                 (strlen(SHADOW_COPY_SAMPLE) == strlen(name))) {
  70                 return True;
  71         }
  72
  73         return False;
  74 }
  75
  76 static DIR *shadow_copy_fdopendir(vfs_handle_struct *handle, files_struct *fsp, const char *mask, uint32_t attr)
  77 {
  78         shadow_copy_Dir *dirp;
  79         DIR *p = SMB_VFS_NEXT_FDOPENDIR(handle,fsp,mask,attr);
  80
  81         if (!p) {
  82                 DEBUG(10,("shadow_copy_opendir: SMB_VFS_NEXT_FDOPENDIR() failed for [%s]\n",
  83                         smb_fname_str_dbg(fsp->fsp_name)));
  84                 return NULL;
  85         }
  86
  87         dirp = SMB_MALLOC_P(shadow_copy_Dir);
  88         if (!dirp) {
  89                 DEBUG(0,("shadow_copy_fdopendir: Out of memory\n"));
  90                 SMB_VFS_NEXT_CLOSEDIR(handle,p);
  91                 /* We have now closed the fd in fsp. */
  92                 fsp_set_fd(fsp, -1);
  93                 return NULL;
  94         }
  95
  96         ZERO_STRUCTP(dirp);
  97
  98         while (True) {
  99                 struct dirent *d;
 100
 101                 d = SMB_VFS_NEXT_READDIR(handle, fsp, p, NULL);
 102                 if (d == NULL) {
 103                         break;
 104                 }
 105
 106                 if (shadow_copy_match_name(d->d_name)) {
 107                         DEBUG(8,("shadow_copy_fdopendir: hide [%s]\n",d->d_name));
 108                         continue;
 109                 }
 110
 111                 DEBUG(10,("shadow_copy_fdopendir: not hide [%s]\n",d->d_name));
 112
 113                 dirp->dirs = SMB_REALLOC_ARRAY(dirp->dirs,struct dirent, dirp->num+1);
 114                 if (!dirp->dirs) {
 115                         DEBUG(0,("shadow_copy_fdopendir: Out of memory\n"));
 116                         break;
 117                 }
 118
 119                 dirp->dirs[dirp->num++] = *d;
 120         }
 121
 122         SMB_VFS_NEXT_CLOSEDIR(handle,p);
 123         /* We have now closed the fd in fsp. */
 124         fsp_set_fd(fsp, -1);
 125         return((DIR *)dirp);
 126 }
 127
 128 static struct dirent *shadow_copy_readdir(vfs_handle_struct *handle,
 129                                           struct files_struct *dirfsp,
 130                                           DIR *_dirp,
 131                                           SMB_STRUCT_STAT *sbuf)
 132 {
 133         shadow_copy_Dir *dirp = (shadow_copy_Dir *)_dirp;
 134
 135         if (dirp->pos < dirp->num) {
 136                 return &(dirp->dirs[dirp->pos++]);
 137         }
 138
 139         return NULL;
 140 }
 141
 142 static void shadow_copy_seekdir(struct vfs_handle_struct *handle, DIR *_dirp, long offset)
 143 {
 144         shadow_copy_Dir *dirp = (shadow_copy_Dir *)_dirp;
 145
 146         if (offset < dirp->num) {
 147                 dirp->pos = offset ;
 148         }
 149 }
 150
 151 static long shadow_copy_telldir(struct vfs_handle_struct *handle, DIR *_dirp)
 152 {
 153         shadow_copy_Dir *dirp = (shadow_copy_Dir *)_dirp;
 154         return( dirp->pos ) ;
 155 }
 156
 157 static void shadow_copy_rewinddir(struct vfs_handle_struct *handle, DIR *_dirp)
 158 {
 159         shadow_copy_Dir *dirp = (shadow_copy_Dir *)_dirp;
 160         dirp->pos = 0 ;
 161 }
 162
 163 static int shadow_copy_closedir(vfs_handle_struct *handle, DIR *_dirp)
 164 {
 165         shadow_copy_Dir *dirp = (shadow_copy_Dir *)_dirp;
 166
 167         SAFE_FREE(dirp->dirs);
 168         SAFE_FREE(dirp);
 169
 170         return 0;
 171 }
 172
 173 static int shadow_copy_get_shadow_copy_data(vfs_handle_struct *handle,
 174                                             files_struct *fsp,
 175                                             struct shadow_copy_data *shadow_copy_data,
 176                                             bool labels)
 177 {
 178         struct smb_Dir *dir_hnd = NULL;
 179         const char *dname = NULL;
 180         char *talloced = NULL;
 181         long offset = 0;
 182         NTSTATUS status;
 183         struct smb_filename *smb_fname = synthetic_smb_fname(talloc_tos(),
 184                                                 fsp->conn->connectpath,
 185                                                 NULL,
 186                                                 NULL,
 187                                                 0,
 188                                                 0);
 189         if (smb_fname == NULL) {
 190                 errno = ENOMEM;
 191                 return -1;
 192         }
 193
 194         status = OpenDir_ntstatus(talloc_tos(),
 195                                   handle->conn,
 196                                   smb_fname,
 197                                   NULL,
 198                                   0,
 199                                   &dir_hnd);
 200         TALLOC_FREE(smb_fname);
 201         if (!NT_STATUS_IS_OK(status)) {
 202                 DBG_ERR("OpenDir() failed for [%s]\n", fsp->conn->connectpath);
 203                 errno = map_errno_from_nt_status(status);
 204                 return -1;
 205         }
 206
 207         shadow_copy_data->num_volumes = 0;
 208         shadow_copy_data->labels = NULL;
 209
 210         while (True) {
 211                 SHADOW_COPY_LABEL *tlabels;
 212                 int ret;
 213
 214                 dname = ReadDirName(dir_hnd, &offset, NULL, &talloced);
 215                 if (dname == NULL) {
 216                         break;
 217                 }
 218
 219                 /* */
 220                 if (!shadow_copy_match_name(dname)) {
 221                         DBG_DEBUG("ignore [%s]\n", dname);
 222                         TALLOC_FREE(talloced);
 223                         continue;
 224                 }
 225
 226                 DBG_DEBUG("not ignore [%s]\n", dname);
 227
 228                 if (!labels) {
 229                         shadow_copy_data->num_volumes++;
 230                         TALLOC_FREE(talloced);
 231                         continue;
 232                 }
 233
 234                 tlabels = (SHADOW_COPY_LABEL *)TALLOC_REALLOC(shadow_copy_data,
 235                                                                         shadow_copy_data->labels,
 236                                                                         (shadow_copy_data->num_volumes+1)*sizeof(SHADOW_COPY_LABEL));
 237                 if (tlabels == NULL) {
 238                         DEBUG(0,("shadow_copy_get_shadow_copy_data: Out of memory\n"));
 239                         TALLOC_FREE(talloced);
 240                         TALLOC_FREE(dir_hnd);
 241                         return -1;
 242                 }
 243
 244                 ret = strlcpy(tlabels[shadow_copy_data->num_volumes], dname,
 245                               sizeof(tlabels[shadow_copy_data->num_volumes]));
 246                 if (ret != sizeof(tlabels[shadow_copy_data->num_volumes]) - 1) {
 247                         DBG_ERR("malformed label %s\n", dname);
 248                         TALLOC_FREE(talloced);
 249                         TALLOC_FREE(dir_hnd);
 250                         return -1;
 251                 }
 252                 shadow_copy_data->num_volumes++;
 253
 254                 shadow_copy_data->labels = tlabels;
 255                 TALLOC_FREE(talloced);
 256         }
 257
 258         TALLOC_FREE(dir_hnd);
 259         return 0;
 260 }
 261
 262 static struct vfs_fn_pointers vfs_shadow_copy_fns = {
 263         .fdopendir_fn = shadow_copy_fdopendir,
 264         .readdir_fn = shadow_copy_readdir,
 265         .seekdir_fn = shadow_copy_seekdir,
 266         .telldir_fn = shadow_copy_telldir,
 267         .rewind_dir_fn = shadow_copy_rewinddir,
 268         .closedir_fn = shadow_copy_closedir,
 269         .get_shadow_copy_data_fn = shadow_copy_get_shadow_copy_data,
 270 };
 271
 272 static_decl_vfs;
 273 NTSTATUS vfs_shadow_copy_init(TALLOC_CTX *ctx)
 274 {
 275         NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
 276                                         "shadow_copy", &vfs_shadow_copy_fns);
 277
 278         if (!NT_STATUS_IS_OK(ret))
 279                 return ret;
 280
 281         vfs_shadow_copy_debug_level = debug_add_class("shadow_copy");
 282         if (vfs_shadow_copy_debug_level == -1) {
 283                 vfs_shadow_copy_debug_level = DBGC_VFS;
 284                 DEBUG(0, ("%s: Couldn't register custom debugging class!\n",
 285                         "vfs_shadow_copy_init"));
 286         } else {
 287                 DEBUG(10, ("%s: Debug class number of '%s': %d\n",
 288                         "vfs_shadow_copy_init","shadow_copy",vfs_shadow_copy_debug_level));
 289         }
 290
 291         return ret;
 292 }