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);
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 : {
132 0 : shadow_copy_Dir *dirp = (shadow_copy_Dir *)_dirp;
133 :
134 0 : if (dirp->pos < dirp->num) {
135 0 : return &(dirp->dirs[dirp->pos++]);
136 : }
137 :
138 0 : return NULL;
139 : }
140 :
141 0 : static void shadow_copy_rewinddir(struct vfs_handle_struct *handle, DIR *_dirp)
142 : {
143 0 : shadow_copy_Dir *dirp = (shadow_copy_Dir *)_dirp;
144 0 : dirp->pos = 0 ;
145 0 : }
146 :
147 0 : static int shadow_copy_closedir(vfs_handle_struct *handle, DIR *_dirp)
148 : {
149 0 : shadow_copy_Dir *dirp = (shadow_copy_Dir *)_dirp;
150 :
151 0 : SAFE_FREE(dirp->dirs);
152 0 : SAFE_FREE(dirp);
153 :
154 0 : return 0;
155 : }
156 :
157 0 : static int shadow_copy_get_shadow_copy_data(vfs_handle_struct *handle,
158 : files_struct *fsp,
159 : struct shadow_copy_data *shadow_copy_data,
160 : bool labels)
161 : {
162 0 : struct smb_Dir *dir_hnd = NULL;
163 0 : const char *dname = NULL;
164 0 : char *talloced = NULL;
165 : NTSTATUS status;
166 0 : struct smb_filename *smb_fname = synthetic_smb_fname(talloc_tos(),
167 0 : fsp->conn->connectpath,
168 : NULL,
169 : NULL,
170 : 0,
171 : 0);
172 0 : if (smb_fname == NULL) {
173 0 : errno = ENOMEM;
174 0 : return -1;
175 : }
176 :
177 0 : status = OpenDir(talloc_tos(),
178 0 : handle->conn,
179 : smb_fname,
180 : NULL,
181 : 0,
182 : &dir_hnd);
183 0 : TALLOC_FREE(smb_fname);
184 0 : if (!NT_STATUS_IS_OK(status)) {
185 0 : DBG_ERR("OpenDir() failed for [%s]\n", fsp->conn->connectpath);
186 0 : errno = map_errno_from_nt_status(status);
187 0 : return -1;
188 : }
189 :
190 0 : shadow_copy_data->num_volumes = 0;
191 0 : shadow_copy_data->labels = NULL;
192 :
193 0 : while (True) {
194 : SHADOW_COPY_LABEL *tlabels;
195 : int ret;
196 :
197 0 : dname = ReadDirName(dir_hnd, &talloced);
198 0 : if (dname == NULL) {
199 0 : break;
200 : }
201 :
202 : /* */
203 0 : if (!shadow_copy_match_name(dname)) {
204 0 : DBG_DEBUG("ignore [%s]\n", dname);
205 0 : TALLOC_FREE(talloced);
206 0 : continue;
207 : }
208 :
209 0 : DBG_DEBUG("not ignore [%s]\n", dname);
210 :
211 0 : if (!labels) {
212 0 : shadow_copy_data->num_volumes++;
213 0 : TALLOC_FREE(talloced);
214 0 : continue;
215 : }
216 :
217 0 : tlabels = (SHADOW_COPY_LABEL *)TALLOC_REALLOC(shadow_copy_data,
218 : shadow_copy_data->labels,
219 : (shadow_copy_data->num_volumes+1)*sizeof(SHADOW_COPY_LABEL));
220 0 : if (tlabels == NULL) {
221 0 : DEBUG(0,("shadow_copy_get_shadow_copy_data: Out of memory\n"));
222 0 : TALLOC_FREE(talloced);
223 0 : TALLOC_FREE(dir_hnd);
224 0 : return -1;
225 : }
226 :
227 0 : ret = strlcpy(tlabels[shadow_copy_data->num_volumes], dname,
228 : sizeof(tlabels[shadow_copy_data->num_volumes]));
229 0 : if (ret != sizeof(tlabels[shadow_copy_data->num_volumes]) - 1) {
230 0 : DBG_ERR("malformed label %s\n", dname);
231 0 : TALLOC_FREE(talloced);
232 0 : TALLOC_FREE(dir_hnd);
233 0 : return -1;
234 : }
235 0 : shadow_copy_data->num_volumes++;
236 :
237 0 : shadow_copy_data->labels = tlabels;
238 0 : TALLOC_FREE(talloced);
239 : }
240 :
241 0 : TALLOC_FREE(dir_hnd);
242 0 : return 0;
243 : }
244 :
245 : static struct vfs_fn_pointers vfs_shadow_copy_fns = {
246 : .fdopendir_fn = shadow_copy_fdopendir,
247 : .readdir_fn = shadow_copy_readdir,
248 : .rewind_dir_fn = shadow_copy_rewinddir,
249 : .closedir_fn = shadow_copy_closedir,
250 : .get_shadow_copy_data_fn = shadow_copy_get_shadow_copy_data,
251 : };
252 :
253 : static_decl_vfs;
254 27 : NTSTATUS vfs_shadow_copy_init(TALLOC_CTX *ctx)
255 : {
256 27 : NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
257 : "shadow_copy", &vfs_shadow_copy_fns);
258 :
259 27 : if (!NT_STATUS_IS_OK(ret))
260 0 : return ret;
261 :
262 27 : vfs_shadow_copy_debug_level = debug_add_class("shadow_copy");
263 27 : if (vfs_shadow_copy_debug_level == -1) {
264 0 : vfs_shadow_copy_debug_level = DBGC_VFS;
265 0 : DEBUG(0, ("%s: Couldn't register custom debugging class!\n",
266 : "vfs_shadow_copy_init"));
267 : } else {
268 27 : DEBUG(10, ("%s: Debug class number of '%s': %d\n",
269 : "vfs_shadow_copy_init","shadow_copy",vfs_shadow_copy_debug_level));
270 : }
271 :
272 27 : return ret;
273 : }
|
