Prefix VFS API macros with SMB_ for consistency and to avoid problems with VFS_ macro...
[tprouty/samba.git] / source / modules / vfs_recycle.c
1 /*
2  * Recycle bin VFS module for Samba.
3  *
4  * Copyright (C) 2001, Brandon Stone, Amherst College, <bbstone@amherst.edu>.
5  * Copyright (C) 2002, Jeremy Allison - modified to make a VFS module.
6  * Copyright (C) 2002, Alexander Bokovoy - cascaded VFS adoption,
7  * Copyright (C) 2002, Juergen Hasch - added some options.
8  * Copyright (C) 2002, Simo Sorce
9  * Copyright (C) 2002, Stefan (metze) Metzmacher
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24  */
25
26 #include "includes.h"
27
28 #define ALLOC_CHECK(ptr, label) do { if ((ptr) == NULL) { DEBUG(0, ("recycle.bin: out of memory!\n")); errno = ENOMEM; goto label; } } while(0)
29
30 static int vfs_recycle_debug_level = DBGC_VFS;
31
32 #undef DBGC_CLASS
33 #define DBGC_CLASS vfs_recycle_debug_level
34  
35 static int recycle_connect(vfs_handle_struct *handle, connection_struct *conn, const char *service, const char *user);
36 static void recycle_disconnect(vfs_handle_struct *handle, connection_struct *conn);
37 static int recycle_unlink(vfs_handle_struct *handle, connection_struct *conn, const char *name);
38
39 static vfs_op_tuple recycle_ops[] = {
40
41         /* Disk operations */
42         {SMB_VFS_OP(recycle_connect),   SMB_VFS_OP_CONNECT,     SMB_VFS_LAYER_TRANSPARENT},
43         {SMB_VFS_OP(recycle_disconnect),        SMB_VFS_OP_DISCONNECT,  SMB_VFS_LAYER_TRANSPARENT},
44
45         /* File operations */
46         {SMB_VFS_OP(recycle_unlink),    SMB_VFS_OP_UNLINK,      SMB_VFS_LAYER_TRANSPARENT},
47
48         {SMB_VFS_OP(NULL),              SMB_VFS_OP_NOOP,        SMB_VFS_LAYER_NOOP}
49 };
50
51 static int recycle_connect(vfs_handle_struct *handle, connection_struct *conn, const char *service, const char *user)
52 {
53         DEBUG(10,("recycle_connect() connect to service[%s] as user[%s].\n",
54                 service,user));
55
56         return SMB_VFS_NEXT_CONNECT(handle, conn, service, user);               
57 }
58
59 static void recycle_disconnect(vfs_handle_struct *handle, connection_struct *conn)
60 {
61         DEBUG(10,("recycle_disconnect() connect to service[%s].\n",
62                 lp_servicename(SNUM(conn))));
63
64         SMB_VFS_NEXT_DISCONNECT(handle, conn);  
65 }
66
67 static const char *recycle_repository(vfs_handle_struct *handle)
68 {
69         const char *tmp_str = NULL;
70         
71
72         tmp_str = lp_parm_const_string(SNUM(handle->conn), "recycle", "repository",".recycle");
73
74         DEBUG(10, ("recycle: repository = %s\n", tmp_str));
75         
76         return tmp_str;
77 }
78
79 static BOOL recycle_keep_dir_tree(vfs_handle_struct *handle)
80 {
81         BOOL ret;
82         
83         ret = lp_parm_bool(SNUM(handle->conn), "recycle", "keeptree", False);
84
85         DEBUG(10, ("recycle_bin: keeptree = %s\n", ret?"True":"False"));
86         
87         return ret;
88 }
89
90 static BOOL recycle_versions(vfs_handle_struct *handle)
91 {
92         BOOL ret;
93
94         ret = lp_parm_bool(SNUM(handle->conn), "recycle", "versions", False);
95
96         DEBUG(10, ("recycle: versions = %s\n", ret?"True":"False"));
97         
98         return ret;
99 }
100
101 static BOOL recycle_touch(vfs_handle_struct *handle)
102 {
103         BOOL ret;
104
105         ret = lp_parm_bool(SNUM(handle->conn), "recycle", "touch", False);
106
107         DEBUG(10, ("recycle: touch = %s\n", ret?"True":"False"));
108         
109         return ret;
110 }
111
112 static const char **recycle_exclude(vfs_handle_struct *handle)
113 {
114         const char **tmp_lp;
115         
116         tmp_lp = lp_parm_string_list(SNUM(handle->conn), "recycle", "exclude", NULL);
117
118         DEBUG(10, ("recycle: exclude = %s ...\n", tmp_lp?*tmp_lp:""));
119         
120         return tmp_lp;
121 }
122
123 static const char **recycle_exclude_dir(vfs_handle_struct *handle)
124 {
125         const char **tmp_lp;
126         
127         tmp_lp = lp_parm_string_list(SNUM(handle->conn), "recycle", "exclude_dir", NULL);
128
129         DEBUG(10, ("recycle: exclude_dir = %s ...\n", tmp_lp?*tmp_lp:""));
130         
131         return tmp_lp;
132 }
133
134 static const char **recycle_noversions(vfs_handle_struct *handle)
135 {
136         const char **tmp_lp;
137         
138         tmp_lp = lp_parm_string_list(SNUM(handle->conn), "recycle", "noversions", NULL);
139
140         DEBUG(10, ("recycle: noversions = %s\n", tmp_lp?*tmp_lp:""));
141         
142         return tmp_lp;
143 }
144
145 static int recycle_maxsize(vfs_handle_struct *handle)
146 {
147         int maxsize;
148         
149         maxsize = lp_parm_int(SNUM(handle->conn), "recycle", "maxsize", -1);
150
151         DEBUG(10, ("recycle: maxsize = %d\n", maxsize));
152         
153         return maxsize;
154 }
155
156 static BOOL recycle_directory_exist(vfs_handle_struct *handle, const char *dname)
157 {
158         SMB_STRUCT_STAT st;
159
160         if (SMB_VFS_NEXT_STAT(handle, handle->conn, dname, &st) == 0) {
161                 if (S_ISDIR(st.st_mode)) {
162                         return True;
163                 }
164         }
165
166         return False;
167 }
168
169 static BOOL recycle_file_exist(vfs_handle_struct *handle, const char *fname)
170 {
171         SMB_STRUCT_STAT st;
172
173         if (SMB_VFS_NEXT_STAT(handle, handle->conn, fname, &st) == 0) {
174                 if (S_ISREG(st.st_mode)) {
175                         return True;
176                 }
177         }
178
179         return False;
180 }
181
182 /**
183  * Return file size
184  * @param conn connection
185  * @param fname file name
186  * @return size in bytes
187  **/
188 static SMB_OFF_T recycle_get_file_size(vfs_handle_struct *handle, const char *fname)
189 {
190         SMB_STRUCT_STAT st;
191
192         if (SMB_VFS_NEXT_STAT(handle, handle->conn, fname, &st) != 0) {
193                 DEBUG(0,("recycle: stat for %s returned %s\n", fname, strerror(errno)));
194                 return (SMB_OFF_T)0;
195         }
196
197         return(st.st_size);
198 }
199
200 /**
201  * Create directory tree
202  * @param conn connection
203  * @param dname Directory tree to be created
204  * @return Returns True for success
205  **/
206 static BOOL recycle_create_dir(vfs_handle_struct *handle, const char *dname)
207 {
208         int len;
209         mode_t mode;
210         char *new_dir = NULL;
211         char *tmp_str = NULL;
212         char *token;
213         char *tok_str;
214         BOOL ret = False;
215
216         mode = S_IREAD | S_IWRITE | S_IEXEC;
217
218         tmp_str = strdup(dname);
219         ALLOC_CHECK(tmp_str, done);
220         tok_str = tmp_str;
221
222         len = strlen(dname);
223         new_dir = (char *)malloc(len + 1);
224         ALLOC_CHECK(new_dir, done);
225         *new_dir = '\0';
226
227         /* Create directory tree if neccessary */
228         for(token = strtok(tok_str, "/"); token; token = strtok(NULL, "/")) {
229                 safe_strcat(new_dir, token, len);
230                 if (recycle_directory_exist(handle, new_dir))
231                         DEBUG(10, ("recycle: dir %s already exists\n", new_dir));
232                 else {
233                         DEBUG(5, ("recycle: creating new dir %s\n", new_dir));
234                         if (SMB_VFS_NEXT_MKDIR(handle, handle->conn, new_dir, mode) != 0) {
235                                 DEBUG(1,("recycle: mkdir failed for %s with error: %s\n", new_dir, strerror(errno)));
236                                 ret = False;
237                                 goto done;
238                         }
239                 }
240                 safe_strcat(new_dir, "/", len);
241         }
242
243         ret = True;
244 done:
245         SAFE_FREE(tmp_str);
246         SAFE_FREE(new_dir);
247         return ret;
248 }
249
250 /**
251  * Check if needle is contained exactly in haystack
252  * @param haystack list of parameters separated by delimimiter character
253  * @param needle string to be matched exactly to haystack
254  * @return True if found
255  **/
256 static BOOL checkparam(const char **haystack_list, const char *needle)
257 {
258         int i;
259
260         if (haystack_list == NULL || haystack_list[0] == NULL ||
261                 *haystack_list[0] == '\0' || needle == NULL || *needle == '\0') {
262                 return False;
263         }
264
265         for(i=0; haystack_list[i] ; i++) {
266                 if(strequal(haystack_list[i], needle)) {
267                         return True;
268                 }
269         }
270
271         return False;
272 }
273
274 /**
275  * Check if needle is contained in haystack, * and ? patterns are resolved
276  * @param haystack list of parameters separated by delimimiter character
277  * @param needle string to be matched exectly to haystack including pattern matching
278  * @return True if found
279  **/
280 static BOOL matchparam(const char **haystack_list, const char *needle)
281 {
282         int i;
283
284         if (haystack_list == NULL || haystack_list[0] == NULL ||
285                 *haystack_list[0] == '\0' || needle == NULL || *needle == '\0') {
286                 return False;
287         }
288
289         for(i=0; haystack_list[i] ; i++) {
290                 if(!unix_wild_match((char *)haystack_list[i], (char *)needle)) {
291                         return True;
292                 }
293         }
294
295         return False;
296 }
297
298 /**
299  * Touch access date
300  **/
301 static void recycle_do_touch(vfs_handle_struct *handle, const char *fname)
302 {
303         SMB_STRUCT_STAT st;
304         struct utimbuf tb;
305         time_t currtime;
306         
307         if (SMB_VFS_NEXT_STAT(handle, handle->conn, fname, &st) != 0) {
308                 DEBUG(0,("recycle: stat for %s returned %s\n", fname, strerror(errno)));
309                 return;
310         }
311         currtime = time(&currtime);
312         tb.actime = currtime;
313         tb.modtime = st.st_mtime;
314
315         if (SMB_VFS_NEXT_UTIME(handle, handle->conn, fname, &tb) == -1 ) {
316                 DEBUG(0, ("recycle: touching %s failed, reason = %s\n", fname, strerror(errno)));
317         }
318 }
319
320 /**
321  * Check if file should be recycled
322  **/
323 static int recycle_unlink(vfs_handle_struct *handle, connection_struct *conn, const char *file_name)
324 {
325         char *path_name = NULL;
326         char *temp_name = NULL;
327         char *final_name = NULL;
328         const char *base;
329         char *repository = NULL;
330         int i = 1;
331         int maxsize;
332         SMB_OFF_T file_size; /* space_avail;    */
333         BOOL exist;
334         int rc = -1;
335
336         repository = alloc_sub_conn(conn, (char *)recycle_repository(handle));
337         ALLOC_CHECK(repository, done);
338         /* shouldn't we allow absolute path names here? --metze */
339         trim_string(repository, "/", "/");
340         
341         if(!repository || *(repository) == '\0') {
342                 DEBUG(3, ("recycle: repository path not set, purging %s...\n", file_name));
343                 rc = SMB_VFS_NEXT_UNLINK(handle, conn, file_name);
344                 goto done;
345         }
346
347         /* we don't recycle the recycle bin... */
348         if (strncmp(file_name, repository, strlen(repository)) == 0) {
349                 DEBUG(3, ("recycle: File is within recycling bin, unlinking ...\n"));
350                 rc = SMB_VFS_NEXT_UNLINK(handle, conn, file_name);
351                 goto done;
352         }
353
354         file_size = recycle_get_file_size(handle, file_name);
355         /* it is wrong to purge filenames only because they are empty imho
356          *   --- simo
357          *
358         if(fsize == 0) {
359                 DEBUG(3, ("recycle: File %s is empty, purging...\n", file_name));
360                 rc = SMB_VFS_NEXT_UNLINK(handle,conn,file_name);
361                 goto done;
362         }
363          */
364
365         /* FIXME: this is wrong, we should check the hole size of the recycle bin is
366          * not greater then maxsize, not the size of the single file, also it is better
367          * to remove older files
368          */
369         maxsize = recycle_maxsize(handle);
370         if(maxsize > 0 && file_size > maxsize) {
371                 DEBUG(3, ("recycle: File %s exceeds maximum recycle size, purging... \n", file_name));
372                 rc = SMB_VFS_NEXT_UNLINK(handle, conn, file_name);
373                 goto done;
374         }
375
376         /* FIXME: this is wrong: moving files with rename does not change the disk space
377          * allocation
378          *
379         space_avail = SMB_VFS_NEXT_DISK_FREE(handle, conn, ".", True, &bsize, &dfree, &dsize) * 1024L;
380         DEBUG(5, ("space_avail = %Lu, file_size = %Lu\n", space_avail, file_size));
381         if(space_avail < file_size) {
382                 DEBUG(3, ("recycle: Not enough diskspace, purging file %s\n", file_name));
383                 rc = SMB_VFS_NEXT_UNLINK(handle, conn, file_name);
384                 goto done;
385         }
386          */
387
388         /* extract filename and path */
389         base = strrchr(file_name, '/');
390         if (base == NULL) {
391                 base = file_name;
392                 path_name = strdup("/");
393                 ALLOC_CHECK(path_name, done);
394         }
395         else {
396                 path_name = strdup(file_name);
397                 ALLOC_CHECK(path_name, done);
398                 path_name[base - file_name] = '\0';
399                 base++;
400         }
401
402         DEBUG(10, ("recycle: fname = %s\n", file_name));        /* original filename with path */
403         DEBUG(10, ("recycle: fpath = %s\n", path_name));        /* original path */
404         DEBUG(10, ("recycle: base = %s\n", base));              /* filename without path */
405
406         if (matchparam(recycle_exclude(handle), base)) {
407                 DEBUG(3, ("recycle: file %s is excluded \n", base));
408                 rc = SMB_VFS_NEXT_UNLINK(handle, conn, file_name);
409                 goto done;
410         }
411
412         /* FIXME: this check will fail if we have more than one level of directories,
413          * we shoud check for every level 1, 1/2, 1/2/3, 1/2/3/4 .... 
414          *      ---simo
415          */
416         if (checkparam(recycle_exclude_dir(handle), path_name)) {
417                 DEBUG(3, ("recycle: directory %s is excluded \n", path_name));
418                 rc = SMB_VFS_NEXT_UNLINK(handle, conn, file_name);
419                 goto done;
420         }
421
422         if (recycle_keep_dir_tree(handle) == True) {
423                 asprintf(&temp_name, "%s/%s", repository, path_name);
424         } else {
425                 temp_name = strdup(repository);
426         }
427         ALLOC_CHECK(temp_name, done);
428
429         exist = recycle_directory_exist(handle, temp_name);
430         if (exist) {
431                 DEBUG(10, ("recycle: Directory already exists\n"));
432         } else {
433                 DEBUG(10, ("recycle: Creating directory %s\n", temp_name));
434                 if (recycle_create_dir(handle, temp_name) == False) {
435                         DEBUG(3, ("recycle: Could not create directory, purging %s...\n", file_name));
436                         rc = SMB_VFS_NEXT_UNLINK(handle, conn, file_name);
437                         goto done;
438                 }
439         }
440
441         asprintf(&final_name, "%s/%s", temp_name, base);
442         ALLOC_CHECK(final_name, done);
443         DEBUG(10, ("recycle: recycled file name: %s\n", final_name));           /* new filename with path */
444
445         /* check if we should delete file from recycle bin */
446         if (recycle_file_exist(handle, final_name)) {
447                 if (recycle_versions(handle) == False || matchparam(recycle_noversions(handle), base) == True) {
448                         DEBUG(3, ("recycle: Removing old file %s from recycle bin\n", final_name));
449                         if (SMB_VFS_NEXT_UNLINK(handle, conn, final_name) != 0) {
450                                 DEBUG(1, ("recycle: Error deleting old file: %s\n", strerror(errno)));
451                         }
452                 }
453         }
454
455         /* rename file we move to recycle bin */
456         i = 1;
457         while (recycle_file_exist(handle, final_name)) {
458                 snprintf(final_name, PATH_MAX -1, "%s/Copy #%d of %s", temp_name, i++, base);
459         }
460
461         DEBUG(10, ("recycle: Moving %s to %s\n", file_name, final_name));
462         rc = SMB_VFS_NEXT_RENAME(handle, conn, file_name, final_name);
463         if (rc != 0) {
464                 DEBUG(3, ("recycle: Move error %d (%s), purging file %s (%s)\n", errno, strerror(errno), file_name, final_name));
465                 rc = SMB_VFS_NEXT_UNLINK(handle, conn, file_name);
466                 goto done;
467         }
468
469         /* touch access date of moved file */
470         if (recycle_touch(handle) == True )
471                 recycle_do_touch(handle, final_name);
472
473 done:
474         SAFE_FREE(path_name);
475         SAFE_FREE(temp_name);
476         SAFE_FREE(final_name);
477         SAFE_FREE(repository);
478         return rc;
479 }
480
481 NTSTATUS vfs_recycle_init(void)
482 {
483         NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "recycle", recycle_ops);
484
485         if (NT_STATUS_IS_ERR(ret))
486                 return ret;
487         
488         vfs_recycle_debug_level = debug_add_class("recycle");
489         if (vfs_recycle_debug_level == -1) {
490                 vfs_recycle_debug_level = DBGC_VFS;
491                 DEBUG(0, ("vfs_recycle: Couldn't register custom debugging class!\n"));
492         } else {
493                 DEBUG(10, ("vfs_recycle: Debug class number of 'recycle': %d\n", vfs_recycle_debug_level));
494         }
495         
496         return ret;
497 }