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  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #include "includes.h"
  26
  27 #define ALLOC_CHECK(ptr, label) do { if ((ptr) == NULL) { DEBUG(0, ("recycle.bin: out of memory!\n")); errno = ENOMEM; goto label; } } while(0)
  28
  29 static int vfs_recycle_debug_level = DBGC_VFS;
  30
  31 #undef DBGC_CLASS
  32 #define DBGC_CLASS vfs_recycle_debug_level
  33
  34 static const char *delimiter = "|";             /* delimiter for options */
  35
  36 /* One per connection */
  37
  38 typedef struct recycle_bin_struct
  39 {
  40         TALLOC_CTX *ctx;
  41         char    *repository;            /* name of the recycle bin directory */
  42         BOOL    keep_dir_tree;          /* keep directory structure of deleted file in recycle bin */
  43         BOOL    versions;               /* create versions of deleted files with identical name */
  44         BOOL    touch;                  /* touch access date of deleted file */
  45         char    *exclude;               /* which files to exclude */
  46         char    *exclude_dir;           /* which directories to exclude */
  47         char    *noversions;            /* which files to exclude from versioning */
  48         SMB_OFF_T maxsize;              /* maximum file size to be saved */
  49 } recycle_bin_struct;
  50
  51 /* VFS operations */
  52 static struct vfs_ops default_vfs_ops;   /* For passthrough operation */
  53
  54 static int recycle_connect(struct connection_struct *conn, const char *service, const char *user);
  55 static void recycle_disconnect(struct connection_struct *conn);
  56 static int recycle_unlink(connection_struct *, const char *);
  57
  58 #define VFS_OP(x) ((void *) x)
  59
  60 static vfs_op_tuple recycle_ops[] = {
  61
  62         /* Disk operations */
  63         {VFS_OP(recycle_connect),       SMB_VFS_OP_CONNECT,     SMB_VFS_LAYER_TRANSPARENT},
  64         {VFS_OP(recycle_disconnect),    SMB_VFS_OP_DISCONNECT,  SMB_VFS_LAYER_TRANSPARENT},
  65
  66         /* File operations */
  67         {VFS_OP(recycle_unlink),        SMB_VFS_OP_UNLINK,      SMB_VFS_LAYER_TRANSPARENT},
  68
  69         {NULL,                          SMB_VFS_OP_NOOP,        SMB_VFS_LAYER_NOOP}
  70 };
  71
  72 static BOOL check_bool_param(const char *value)
  73 {
  74         if (strwicmp(value, "yes") == 0 ||
  75             strwicmp(value, "true") == 0 ||
  76             strwicmp(value, "1") == 0)
  77                 return True;
  78
  79         return False;
  80 }
  81
  82 /**
  83  * VFS initialisation function.
  84  *
  85  * @retval initialised vfs_op_tuple array
  86  **/
  87 vfs_op_tuple *vfs_init(int *vfs_version, struct vfs_ops *def_vfs_ops,
  88                         struct smb_vfs_handle_struct *vfs_handle)
  89 {
  90         DEBUG(10, ("Initializing VFS module recycle\n"));
  91         *vfs_version = SMB_VFS_INTERFACE_VERSION;
  92         memcpy(&default_vfs_ops, def_vfs_ops, sizeof(struct vfs_ops));
  93         vfs_recycle_debug_level = debug_add_class("vfs_recycle_bin");
  94         if (vfs_recycle_debug_level == -1) {
  95                 vfs_recycle_debug_level = DBGC_VFS;
  96                 DEBUG(0, ("vfs_recycle: Couldn't register custom debugging class!\n"));
  97         } else {
  98                 DEBUG(0, ("vfs_recycle: Debug class number of 'vfs_recycle': %d\n", vfs_recycle_debug_level));
  99         }
 100
 101         return recycle_ops;
 102 }
 103
 104 /**
 105  * VFS finalization function.
 106  *
 107  **/
 108 void vfs_done(connection_struct *conn)
 109 {
 110         DEBUG(10,("Called for connection %d\n", SNUM(conn)));
 111 }
 112
 113 static int recycle_connect(struct connection_struct *conn, const char *service, const char *user)
 114 {
 115         TALLOC_CTX *ctx = NULL;
 116         recycle_bin_struct *recbin;
 117         char *servicename;
 118         char *tmp_str;
 119
 120         DEBUG(10, ("Called for service %s (%d) as user %s\n", service, SNUM(conn), user));
 121
 122         if (!(ctx = talloc_init_named("recycle bin"))) {
 123                 DEBUG(0, ("Failed to allocate memory in VFS module recycle_bin\n"));
 124                 return 0;
 125         }
 126
 127         recbin = talloc(ctx,sizeof(recycle_bin_struct));
 128         if ( recbin == NULL) {
 129                 DEBUG(0, ("Failed to allocate memory in VFS module recycle_bin\n"));
 130                 return -1;
 131         }
 132         recbin->ctx = ctx;
 133
 134         /* Set defaults */
 135         recbin->repository = talloc_strdup(ctx, ".recycle");
 136         ALLOC_CHECK(recbin->repository, error);
 137         recbin->keep_dir_tree = False;
 138         recbin->versions = False;
 139         recbin->touch = False;
 140         recbin->exclude = "";
 141         recbin->exclude_dir = "";
 142         recbin->noversions = "";
 143         recbin->maxsize = 0;
 144
 145         /* parse configuration options */
 146         servicename = talloc_strdup(recbin->ctx, lp_servicename(SNUM(conn)));
 147         DEBUG(10, ("servicename = %s\n",servicename));
 148         if ((tmp_str = lp_parm_string(servicename, "vfs_recycle_bin", "repository")) != NULL) {
 149                 recbin->repository = talloc_sub_conn(ctx, conn, tmp_str);
 150                 ALLOC_CHECK(recbin->repository, error);
 151                 trim_string(recbin->repository, "/", "/");
 152                 DEBUG(5, ("recycle.bin: repository = %s\n", recbin->repository));
 153         }
 154         if ((tmp_str = lp_parm_string(servicename, "vfs_recycle_bin", "keeptree")) != NULL) {
 155                 if (check_bool_param(tmp_str) == True)
 156                         recbin->keep_dir_tree = True;
 157                 DEBUG(5, ("recycle.bin: keeptree = %s\n", tmp_str));
 158         }
 159         if ((tmp_str = lp_parm_string(servicename, "vfs_recycle_bin", "versions")) != NULL) {
 160                 if (check_bool_param(tmp_str) == True)
 161                         recbin->versions = True;
 162                 DEBUG(5, ("recycle.bin: versions = %s\n", tmp_str));
 163         }
 164         if ((tmp_str = lp_parm_string(servicename, "vfs_recycle_bin", "touch")) != NULL) {
 165                 if (check_bool_param(tmp_str) == True)
 166                         recbin->touch = True;
 167                 DEBUG(5, ("recycle.bin: touch = %s\n", tmp_str));
 168         }
 169         if ((tmp_str = lp_parm_string(servicename, "vfs_recycle_bin", "maxsize")) != NULL) {
 170                 recbin->maxsize = strtoul(tmp_str, NULL, 10);
 171                 if (recbin->maxsize == 0) {
 172                         recbin->maxsize = -1;
 173                         DEBUG(5, ("recycle.bin: maxsize = -infinite-\n"));
 174                 } else {
 175                         DEBUG(5, ("recycle.bin: maxsize = %ld\n", (long int)recbin->maxsize));
 176                 }
 177         }
 178         if ((tmp_str = lp_parm_string(servicename, "vfs_recycle_bin", "exclude")) != NULL) {
 179                 recbin->exclude = talloc_strdup(ctx, tmp_str);
 180                 ALLOC_CHECK(recbin->exclude, error);
 181                 DEBUG(5, ("recycle.bin: exclude = %s\n", recbin->exclude));
 182         }
 183         if ((tmp_str = lp_parm_string(servicename,"vfs_recycle_bin", "exclude_dir")) != NULL) {
 184                 recbin->exclude_dir = talloc_strdup(ctx, tmp_str);
 185                 ALLOC_CHECK(recbin->exclude_dir, error);
 186                 DEBUG(5, ("recycle.bin: exclude_dir = %s\n", recbin->exclude_dir));
 187         }
 188         if ((tmp_str = lp_parm_string(servicename,"vfs_recycle_bin", "noversions")) != NULL) {
 189                 recbin->noversions = talloc_strdup(ctx, tmp_str);
 190                 ALLOC_CHECK(recbin->noversions, error);
 191                 DEBUG(5, ("recycle.bin: noversions = %s\n", recbin->noversions));
 192         }
 193
 194         conn->vfs_private = (void *)recbin;
 195         return default_vfs_ops.connect(conn, service, user);
 196
 197 error:
 198         talloc_destroy(ctx);
 199         return -1;
 200 }
 201
 202 static void recycle_disconnect(struct connection_struct *conn)
 203 {
 204         DEBUG(10, ("Disconnecting VFS module recycle bin\n"));
 205         if (conn->vfs_private) {
 206                 talloc_destroy(((recycle_bin_struct *)conn->vfs_private)->ctx);
 207                 conn->vfs_private = NULL;
 208         }
 209         default_vfs_ops.disconnect(conn);
 210 }
 211
 212 static BOOL recycle_directory_exist(connection_struct *conn, const char *dname)
 213 {
 214         SMB_STRUCT_STAT st;
 215
 216         if (default_vfs_ops.stat(conn, dname, &st) == 0) {
 217                 if (S_ISDIR(st.st_mode)) {
 218                         return True;
 219                 }
 220         }
 221
 222         return False;
 223 }
 224
 225 static BOOL recycle_file_exist(connection_struct *conn, const char *fname)
 226 {
 227         SMB_STRUCT_STAT st;
 228
 229         if (default_vfs_ops.stat(conn, fname, &st) == 0) {
 230                 if (S_ISREG(st.st_mode)) {
 231                         return True;
 232                 }
 233         }
 234
 235         return False;
 236 }
 237
 238 /**
 239  * Return file size
 240  * @param conn connection
 241  * @param fname file name
 242  * @return size in bytes
 243  **/
 244 static SMB_OFF_T recycle_get_file_size(connection_struct *conn, const char *fname)
 245 {
 246         SMB_STRUCT_STAT st;
 247         if (default_vfs_ops.stat(conn, fname, &st) != 0) {
 248                 DEBUG(0,("recycle.bin: stat for %s returned %s\n", fname, strerror(errno)));
 249                 return (SMB_OFF_T)0;
 250         }
 251         return(st.st_size);
 252 }
 253
 254 /**
 255  * Create directory tree
 256  * @param conn connection
 257  * @param dname Directory tree to be created
 258  * @return Returns True for success
 259  **/
 260 static BOOL recycle_create_dir(connection_struct *conn, const char *dname)
 261 {
 262         int len;
 263         mode_t mode;
 264         char *new_dir = NULL;
 265         char *tmp_str = NULL;
 266         char *token;
 267         char *tok_str;
 268         BOOL ret = False;
 269
 270         mode = S_IREAD | S_IWRITE | S_IEXEC;
 271
 272         tmp_str = strdup(dname);
 273         ALLOC_CHECK(tmp_str, done);
 274         tok_str = tmp_str;
 275
 276         len = strlen(dname);
 277         new_dir = (char *)malloc(len + 1);
 278         ALLOC_CHECK(new_dir, done);
 279         *new_dir = '\0';
 280
 281         /* Create directory tree if neccessary */
 282         for(token = strtok(tok_str, "/"); token; token = strtok(NULL, "/")) {
 283                 safe_strcat(new_dir, token, len);
 284                 if (recycle_directory_exist(conn, new_dir))
 285                         DEBUG(10, ("recycle.bin: dir %s already exists\n", new_dir));
 286                 else {
 287                         DEBUG(5, ("recycle.bin: creating new dir %s\n", new_dir));
 288                         if (default_vfs_ops.mkdir(conn, new_dir, mode) != 0) {
 289                                 DEBUG(1,("recycle.bin: mkdir failed for %s with error: %s\n", new_dir, strerror(errno)));
 290                                 ret = False;
 291                                 goto done;
 292                         }
 293                 }
 294                 safe_strcat(new_dir, "/", len);
 295                 }
 296
 297         ret = True;
 298 done:
 299         SAFE_FREE(tmp_str);
 300         SAFE_FREE(new_dir);
 301         return ret;
 302 }
 303
 304 /**
 305  * Check if needle is contained exactly in haystack
 306  * @param haystack list of parameters separated by delimimiter character
 307  * @param needle string to be matched exactly to haystack
 308  * @return True if found
 309  **/
 310 static BOOL checkparam(const char *haystack, const char *needle)
 311 {
 312         char *token;
 313         char *tok_str;
 314         char *tmp_str;
 315         BOOL ret = False;
 316
 317         if (haystack == NULL || strlen(haystack) == 0 || needle == NULL || strlen(needle) == 0) {
 318                 return False;
 319         }
 320
 321         tmp_str = strdup(haystack);
 322         ALLOC_CHECK(tmp_str, done);
 323         token = tok_str = tmp_str;
 324
 325         for(token = strtok(tok_str, delimiter); token; token = strtok(NULL, delimiter)) {
 326                 if(strcmp(token, needle) == 0) {
 327                         ret = True;
 328                         goto done;
 329                 }
 330         }
 331 done:
 332         SAFE_FREE(tmp_str);
 333         return ret;
 334 }
 335
 336 /**
 337  * Check if needle is contained in haystack, * and ? patterns are resolved
 338  * @param haystack list of parameters separated by delimimiter character
 339  * @param needle string to be matched exectly to haystack including pattern matching
 340  * @return True if found
 341  **/
 342 static BOOL matchparam(const char *haystack, const char *needle)
 343 {
 344         char *token;
 345         char *tok_str;
 346         char *tmp_str;
 347         BOOL ret = False;
 348
 349         if (haystack == NULL || strlen(haystack) == 0 || needle == NULL || strlen(needle) == 0) {
 350                 return False;
 351         }
 352
 353         tmp_str = strdup(haystack);
 354         ALLOC_CHECK(tmp_str, done);
 355         token = tok_str = tmp_str;
 356
 357         for(token = strtok(tok_str, delimiter); token; token = strtok(NULL, delimiter)) {
 358                 if (!unix_wild_match(token, needle)) {
 359                         ret = True;
 360                         goto done;
 361                 }
 362         }
 363 done:
 364         SAFE_FREE(tmp_str);
 365         return ret;
 366 }
 367
 368 /**
 369  * Touch access date
 370  **/
 371 static void recycle_touch(connection_struct *conn, const char *fname)
 372 {
 373         SMB_STRUCT_STAT st;
 374         struct utimbuf tb;
 375         time_t currtime;
 376
 377         if (default_vfs_ops.stat(conn, fname, &st) != 0) {
 378                 DEBUG(0,("recycle.bin: stat for %s returned %s\n", fname, strerror(errno)));
 379                 return;
 380         }
 381         currtime = time(&currtime);
 382         tb.actime = currtime;
 383         tb.modtime = st.st_mtime;
 384
 385         if (default_vfs_ops.utime(conn, fname, &tb) == -1 )
 386                 DEBUG(0, ("recycle.bin: touching %s failed, reason = %s\n", fname, strerror(errno)));
 387         }
 388
 389 /**
 390  * Check if file should be recycled
 391  **/
 392 static int recycle_unlink(connection_struct *conn, const char *inname)
 393 {
 394         recycle_bin_struct *recbin;
 395         char *file_name = NULL;
 396         char *path_name = NULL;
 397         char *temp_name = NULL;
 398         char *final_name = NULL;
 399         char *base;
 400         int i;
 401         SMB_BIG_UINT dfree, dsize, bsize;
 402         SMB_OFF_T file_size, space_avail;
 403         BOOL exist;
 404         int rc = -1;
 405
 406         file_name = strdup(inname);
 407         ALLOC_CHECK(file_name, done);
 408
 409         if (conn->vfs_private)
 410                 recbin = (recycle_bin_struct *)conn->vfs_private;
 411         else {
 412                 DEBUG(0, ("Recycle bin not initialized!\n"));
 413                 rc = default_vfs_ops.unlink(conn, file_name);
 414                 goto done;
 415         }
 416
 417         if(!recbin->repository || *(recbin->repository) == '\0') {
 418                 DEBUG(3, ("Recycle path not set, purging %s...\n", file_name));
 419                 rc = default_vfs_ops.unlink(conn, file_name);
 420                 goto done;
 421         }
 422
 423         /* we don't recycle the recycle bin... */
 424         if (strncmp(file_name, recbin->repository, strlen(recbin->repository)) == 0) {
 425                 DEBUG(3, ("File is within recycling bin, unlinking ...\n"));
 426                 rc = default_vfs_ops.unlink(conn, file_name);
 427                 goto done;
 428         }
 429
 430         file_size = recycle_get_file_size(conn, file_name);
 431         /* it is wrong to purge filenames only because they are empty imho
 432          *   --- simo
 433          *
 434         if(fsize == 0) {
 435                 DEBUG(3, ("File %s is empty, purging...\n", file_name));
 436                 rc = default_vfs_ops.unlink(conn,file_name);
 437                 goto done;
 438         }
 439          */
 440
 441         /* FIXME: this is wrong, we should check the hole size of the recycle bin is
 442          * not greater then maxsize, not the size of the single file, also it is better
 443          * to remove older files
 444          */
 445         if(recbin->maxsize > 0 && file_size > recbin->maxsize) {
 446                 DEBUG(3, ("File %s exceeds maximum recycle size, purging... \n", file_name));
 447                 rc = default_vfs_ops.unlink(conn, file_name);
 448                 goto done;
 449         }
 450
 451         /* FIXME: this is wrong: moving files with rename does not change the disk space
 452          * allocation
 453          *
 454         space_avail = default_vfs_ops.disk_free(conn, ".", True, &bsize, &dfree, &dsize) * 1024L;
 455         DEBUG(5, ("space_avail = %Lu, file_size = %Lu\n", space_avail, file_size));
 456         if(space_avail < file_size) {
 457                 DEBUG(3, ("Not enough diskspace, purging file %s\n", file_name));
 458                 rc = default_vfs_ops.unlink(conn, file_name);
 459                 goto done;
 460         }
 461          */
 462
 463         /* extract filename and path */
 464         path_name = (char *)malloc(PATH_MAX);
 465         ALLOC_CHECK(path_name, done);
 466         *path_name = '\0';
 467         safe_strcpy(path_name, file_name, PATH_MAX);
 468         base = strrchr(path_name, '/');
 469         if (base == NULL) {
 470                 base = file_name;
 471                 safe_strcpy(path_name, "/", PATH_MAX);
 472         }
 473         else {
 474                 *base = '\0';
 475                 base++;
 476         }
 477
 478         DEBUG(10, ("recycle.bin: fname = %s\n", file_name));    /* original filename with path */
 479         DEBUG(10, ("recycle.bin: fpath = %s\n", path_name));    /* original path */
 480         DEBUG(10, ("recycle.bin: base = %s\n", base));          /* filename without path */
 481
 482         if (matchparam(recbin->exclude, base)) {
 483                 DEBUG(3, ("recycle.bin: file %s is excluded \n", base));
 484                 rc = default_vfs_ops.unlink(conn, file_name);
 485                 goto done;
 486         }
 487
 488         /* FIXME: this check will fail if we have more than one level of directories,
 489          * we shoud check for every level 1, 1/2, 1/2/3, 1/2/3/4 ....
 490          *      ---simo
 491          */
 492         if (checkparam(recbin->exclude_dir, path_name)) {
 493                 DEBUG(3, ("recycle.bin: directory %s is excluded \n", path_name));
 494                 rc = default_vfs_ops.unlink(conn, file_name);
 495                 goto done;
 496         }
 497
 498         temp_name = (char *)malloc(PATH_MAX);
 499         ALLOC_CHECK(temp_name, done);
 500         safe_strcpy(temp_name, recbin->repository, PATH_MAX);
 501
 502         /* see if we need to recreate the original directory structure in the recycle bin */
 503         if (recbin->keep_dir_tree == True) {
 504                 safe_strcat(temp_name, "/", PATH_MAX);
 505                 safe_strcat(temp_name, path_name, PATH_MAX);
 506         }
 507
 508         exist = recycle_directory_exist(conn, temp_name);
 509         if (exist) {
 510                 DEBUG(10, ("recycle.bin: Directory already exists\n"));
 511         } else {
 512                 DEBUG(10, ("recycle.bin: Creating directory %s\n", temp_name));
 513                 if (recycle_create_dir(conn, temp_name) == False) {
 514                         DEBUG(3, ("Could not create directory, purging %s...\n", file_name));
 515                         rc = default_vfs_ops.unlink(conn, file_name);
 516                         goto done;
 517                 }
 518         }
 519
 520         final_name = (char *)malloc(PATH_MAX);
 521         ALLOC_CHECK(final_name, done);
 522         snprintf(final_name, PATH_MAX, "%s/%s", temp_name, base);
 523         DEBUG(10, ("recycle.bin: recycled file name%s\n", temp_name));          /* new filename with path */
 524
 525         /* check if we should delete file from recycle bin */
 526         if (recycle_file_exist(conn, final_name)) {
 527                 if (recbin->versions == False || matchparam(recbin->noversions, base) == True) {
 528                         DEBUG(3, ("recycle.bin: Removing old file %s from recycle bin\n", final_name));
 529                         if (default_vfs_ops.unlink(conn, final_name) != 0) {
 530                                 DEBUG(1, ("recycle.bin: Error deleting old file: %s\n", strerror(errno)));
 531                         }
 532                 }
 533         }
 534
 535         /* rename file we move to recycle bin */
 536         i = 1;
 537         while (recycle_file_exist(conn, final_name)) {
 538                 snprintf(final_name, PATH_MAX, "%s/Copy #%d of %s", temp_name, i++, base);
 539         }
 540
 541         DEBUG(10, ("recycle.bin: Moving %s to %s\n", file_name, final_name));
 542         rc = default_vfs_ops.rename(conn, file_name, final_name);
 543         if (rc != 0) {
 544                 DEBUG(3, ("recycle.bin: Move error %d (%s), purging file %s (%s)\n", errno, strerror(errno), file_name, final_name));
 545                 rc = default_vfs_ops.unlink(conn, file_name);
 546                 goto done;
 547         }
 548
 549         /* touch access date of moved file */
 550         if (recbin->touch == True )
 551                 recycle_touch(conn, final_name);
 552
 553 done:
 554         SAFE_FREE(file_name);
 555         SAFE_FREE(path_name);
 556         SAFE_FREE(temp_name);
 557         SAFE_FREE(final_name);
 558         return rc;
 559 }