LCOV - code coverage report
Current view: top level - source3/modules - vfs_shadow_copy.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 7 112 6.2 %
Date: 2021-09-23 10:06:22 Functions: 1 9 11.1 %

          Line data    Source code
       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           0 : static bool shadow_copy_match_name(const char *name)
      67             : {
      68           0 :         if (strncmp(SHADOW_COPY_PREFIX,name, sizeof(SHADOW_COPY_PREFIX)-1)==0 &&
      69           0 :                 (strlen(SHADOW_COPY_SAMPLE) == strlen(name))) {
      70           0 :                 return True;
      71             :         }
      72             : 
      73           0 :         return False;
      74             : }
      75             : 
      76           0 : 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           0 :         DIR *p = SMB_VFS_NEXT_FDOPENDIR(handle,fsp,mask,attr);
      80             : 
      81           0 :         if (!p) {
      82           0 :                 DEBUG(10,("shadow_copy_opendir: SMB_VFS_NEXT_FDOPENDIR() failed for [%s]\n",
      83             :                         smb_fname_str_dbg(fsp->fsp_name)));
      84           0 :                 return NULL;
      85             :         }
      86             : 
      87           0 :         dirp = SMB_MALLOC_P(shadow_copy_Dir);
      88           0 :         if (!dirp) {
      89           0 :                 DEBUG(0,("shadow_copy_fdopendir: Out of memory\n"));
      90           0 :                 SMB_VFS_NEXT_CLOSEDIR(handle,p);
      91             :                 /* We have now closed the fd in fsp. */
      92           0 :                 fsp_set_fd(fsp, -1);
      93           0 :                 return NULL;
      94             :         }
      95             : 
      96           0 :         ZERO_STRUCTP(dirp);
      97             : 
      98           0 :         while (True) {
      99             :                 struct dirent *d;
     100             : 
     101           0 :                 d = SMB_VFS_NEXT_READDIR(handle, fsp, p, NULL);
     102           0 :                 if (d == NULL) {
     103           0 :                         break;
     104             :                 }
     105             : 
     106           0 :                 if (shadow_copy_match_name(d->d_name)) {
     107           0 :                         DEBUG(8,("shadow_copy_fdopendir: hide [%s]\n",d->d_name));
     108           0 :                         continue;
     109             :                 }
     110             : 
     111           0 :                 DEBUG(10,("shadow_copy_fdopendir: not hide [%s]\n",d->d_name));
     112             : 
     113           0 :                 dirp->dirs = SMB_REALLOC_ARRAY(dirp->dirs,struct dirent, dirp->num+1);
     114           0 :                 if (!dirp->dirs) {
     115           0 :                         DEBUG(0,("shadow_copy_fdopendir: Out of memory\n"));
     116           0 :                         break;
     117             :                 }
     118             : 
     119           0 :                 dirp->dirs[dirp->num++] = *d;
     120             :         }
     121             : 
     122           0 :         SMB_VFS_NEXT_CLOSEDIR(handle,p);
     123             :         /* We have now closed the fd in fsp. */
     124           0 :         fsp_set_fd(fsp, -1);
     125           0 :         return((DIR *)dirp);
     126             : }
     127             : 
     128           0 : 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           0 :         shadow_copy_Dir *dirp = (shadow_copy_Dir *)_dirp;
     134             : 
     135           0 :         if (dirp->pos < dirp->num) {
     136           0 :                 return &(dirp->dirs[dirp->pos++]);
     137             :         }
     138             : 
     139           0 :         return NULL;
     140             : }
     141             : 
     142           0 : static void shadow_copy_seekdir(struct vfs_handle_struct *handle, DIR *_dirp, long offset)
     143             : {
     144           0 :         shadow_copy_Dir *dirp = (shadow_copy_Dir *)_dirp;
     145             : 
     146           0 :         if (offset < dirp->num) {
     147           0 :                 dirp->pos = offset ;
     148             :         }
     149           0 : }
     150             : 
     151           0 : static long shadow_copy_telldir(struct vfs_handle_struct *handle, DIR *_dirp)
     152             : {
     153           0 :         shadow_copy_Dir *dirp = (shadow_copy_Dir *)_dirp;
     154           0 :         return( dirp->pos ) ;
     155             : }
     156             : 
     157           0 : static void shadow_copy_rewinddir(struct vfs_handle_struct *handle, DIR *_dirp)
     158             : {
     159           0 :         shadow_copy_Dir *dirp = (shadow_copy_Dir *)_dirp;
     160           0 :         dirp->pos = 0 ;
     161           0 : }
     162             : 
     163           0 : static int shadow_copy_closedir(vfs_handle_struct *handle, DIR *_dirp)
     164             : {
     165           0 :         shadow_copy_Dir *dirp = (shadow_copy_Dir *)_dirp;
     166             : 
     167           0 :         SAFE_FREE(dirp->dirs);
     168           0 :         SAFE_FREE(dirp);
     169             :  
     170           0 :         return 0;       
     171             : }
     172             : 
     173           0 : 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           0 :         struct smb_Dir *dir_hnd = NULL;
     179           0 :         const char *dname = NULL;
     180           0 :         char *talloced = NULL;
     181           0 :         long offset = 0;
     182           0 :         struct smb_filename *smb_fname = synthetic_smb_fname(talloc_tos(),
     183           0 :                                                 fsp->conn->connectpath,
     184             :                                                 NULL,
     185             :                                                 NULL,
     186             :                                                 0,
     187             :                                                 0);
     188           0 :         if (smb_fname == NULL) {
     189           0 :                 errno = ENOMEM;
     190           0 :                 return -1;
     191             :         }
     192             : 
     193           0 :         dir_hnd = OpenDir(talloc_tos(), handle->conn, smb_fname, NULL, 0);
     194           0 :         TALLOC_FREE(smb_fname);
     195           0 :         if (dir_hnd == NULL) {
     196           0 :                 DBG_ERR("OpenDir() failed for [%s]\n", fsp->conn->connectpath);
     197           0 :                 return -1;
     198             :         }
     199             : 
     200           0 :         shadow_copy_data->num_volumes = 0;
     201           0 :         shadow_copy_data->labels = NULL;
     202             : 
     203           0 :         while (True) {
     204             :                 SHADOW_COPY_LABEL *tlabels;
     205             :                 int ret;
     206             : 
     207           0 :                 dname = ReadDirName(dir_hnd, &offset, NULL, &talloced);
     208           0 :                 if (dname == NULL) {
     209           0 :                         break;
     210             :                 }
     211             : 
     212             :                 /* */
     213           0 :                 if (!shadow_copy_match_name(dname)) {
     214           0 :                         DBG_DEBUG("ignore [%s]\n", dname);
     215           0 :                         TALLOC_FREE(talloced);
     216           0 :                         continue;
     217             :                 }
     218             : 
     219           0 :                 DBG_DEBUG("not ignore [%s]\n", dname);
     220             : 
     221           0 :                 if (!labels) {
     222           0 :                         shadow_copy_data->num_volumes++;
     223           0 :                         TALLOC_FREE(talloced);
     224           0 :                         continue;
     225             :                 }
     226             : 
     227           0 :                 tlabels = (SHADOW_COPY_LABEL *)TALLOC_REALLOC(shadow_copy_data,
     228             :                                                                         shadow_copy_data->labels,
     229             :                                                                         (shadow_copy_data->num_volumes+1)*sizeof(SHADOW_COPY_LABEL));
     230           0 :                 if (tlabels == NULL) {
     231           0 :                         DEBUG(0,("shadow_copy_get_shadow_copy_data: Out of memory\n"));
     232           0 :                         TALLOC_FREE(talloced);
     233           0 :                         TALLOC_FREE(dir_hnd);
     234           0 :                         return -1;
     235             :                 }
     236             : 
     237           0 :                 ret = strlcpy(tlabels[shadow_copy_data->num_volumes], dname,
     238             :                               sizeof(tlabels[shadow_copy_data->num_volumes]));
     239           0 :                 if (ret != sizeof(tlabels[shadow_copy_data->num_volumes]) - 1) {
     240           0 :                         DBG_ERR("malformed label %s\n", dname);
     241           0 :                         TALLOC_FREE(talloced);
     242           0 :                         TALLOC_FREE(dir_hnd);
     243           0 :                         return -1;
     244             :                 }
     245           0 :                 shadow_copy_data->num_volumes++;
     246             : 
     247           0 :                 shadow_copy_data->labels = tlabels;
     248           0 :                 TALLOC_FREE(talloced);
     249             :         }
     250             : 
     251           0 :         TALLOC_FREE(dir_hnd);
     252           0 :         return 0;
     253             : }
     254             : 
     255             : static struct vfs_fn_pointers vfs_shadow_copy_fns = {
     256             :         .fdopendir_fn = shadow_copy_fdopendir,
     257             :         .readdir_fn = shadow_copy_readdir,
     258             :         .seekdir_fn = shadow_copy_seekdir,
     259             :         .telldir_fn = shadow_copy_telldir,
     260             :         .rewind_dir_fn = shadow_copy_rewinddir,
     261             :         .closedir_fn = shadow_copy_closedir,
     262             :         .get_shadow_copy_data_fn = shadow_copy_get_shadow_copy_data,
     263             : };
     264             : 
     265             : static_decl_vfs;
     266          20 : NTSTATUS vfs_shadow_copy_init(TALLOC_CTX *ctx)
     267             : {
     268          20 :         NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
     269             :                                         "shadow_copy", &vfs_shadow_copy_fns);
     270             : 
     271          20 :         if (!NT_STATUS_IS_OK(ret))
     272           0 :                 return ret;
     273             : 
     274          20 :         vfs_shadow_copy_debug_level = debug_add_class("shadow_copy");
     275          20 :         if (vfs_shadow_copy_debug_level == -1) {
     276           0 :                 vfs_shadow_copy_debug_level = DBGC_VFS;
     277           0 :                 DEBUG(0, ("%s: Couldn't register custom debugging class!\n",
     278             :                         "vfs_shadow_copy_init"));
     279             :         } else {
     280          20 :                 DEBUG(10, ("%s: Debug class number of '%s': %d\n", 
     281             :                         "vfs_shadow_copy_init","shadow_copy",vfs_shadow_copy_debug_level));
     282             :         }
     283             : 
     284          20 :         return ret;
     285             : }

Generated by: LCOV version 1.13