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

          Line data    Source code
       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 3 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, see <http://www.gnu.org/licenses/>.
      23             :  */
      24             : 
      25             : #include "includes.h"
      26             : #include "smbd/smbd.h"
      27             : #include "system/filesys.h"
      28             : #include "../librpc/gen_ndr/ndr_netlogon.h"
      29             : #include "auth.h"
      30             : 
      31             : #define ALLOC_CHECK(ptr, label) do { if ((ptr) == NULL) { DEBUG(0, ("recycle.bin: out of memory!\n")); errno = ENOMEM; goto label; } } while(0)
      32             : 
      33             : static int vfs_recycle_debug_level = DBGC_VFS;
      34             : 
      35             : #undef DBGC_CLASS
      36             : #define DBGC_CLASS vfs_recycle_debug_level
      37             :  
      38           0 : static const char *recycle_repository(vfs_handle_struct *handle)
      39             : {
      40           0 :         const char *tmp_str = NULL;
      41             : 
      42           0 :         tmp_str = lp_parm_const_string(SNUM(handle->conn), "recycle", "repository",".recycle");
      43             : 
      44           0 :         DEBUG(10, ("recycle: repository = %s\n", tmp_str));
      45             : 
      46           0 :         return tmp_str;
      47             : }
      48             : 
      49           0 : static bool recycle_keep_dir_tree(vfs_handle_struct *handle)
      50             : {
      51             :         bool ret;
      52             : 
      53           0 :         ret = lp_parm_bool(SNUM(handle->conn), "recycle", "keeptree", False);
      54             : 
      55           0 :         DEBUG(10, ("recycle_bin: keeptree = %s\n", ret?"True":"False"));
      56             : 
      57           0 :         return ret;
      58             : }
      59             : 
      60           0 : static bool recycle_versions(vfs_handle_struct *handle)
      61             : {
      62             :         bool ret;
      63             : 
      64           0 :         ret = lp_parm_bool(SNUM(handle->conn), "recycle", "versions", False);
      65             : 
      66           0 :         DEBUG(10, ("recycle: versions = %s\n", ret?"True":"False"));
      67             : 
      68           0 :         return ret;
      69             : }
      70             : 
      71           0 : static bool recycle_touch(vfs_handle_struct *handle)
      72             : {
      73             :         bool ret;
      74             : 
      75           0 :         ret = lp_parm_bool(SNUM(handle->conn), "recycle", "touch", False);
      76             : 
      77           0 :         DEBUG(10, ("recycle: touch = %s\n", ret?"True":"False"));
      78             : 
      79           0 :         return ret;
      80             : }
      81             : 
      82           0 : static bool recycle_touch_mtime(vfs_handle_struct *handle)
      83             : {
      84             :         bool ret;
      85             : 
      86           0 :         ret = lp_parm_bool(SNUM(handle->conn), "recycle", "touch_mtime", False);
      87             : 
      88           0 :         DEBUG(10, ("recycle: touch_mtime = %s\n", ret?"True":"False"));
      89             : 
      90           0 :         return ret;
      91             : }
      92             : 
      93           0 : static const char **recycle_exclude(vfs_handle_struct *handle)
      94             : {
      95             :         const char **tmp_lp;
      96             : 
      97           0 :         tmp_lp = lp_parm_string_list(SNUM(handle->conn), "recycle", "exclude", NULL);
      98             : 
      99           0 :         DEBUG(10, ("recycle: exclude = %s ...\n", tmp_lp?*tmp_lp:""));
     100             : 
     101           0 :         return tmp_lp;
     102             : }
     103             : 
     104           0 : static const char **recycle_exclude_dir(vfs_handle_struct *handle)
     105             : {
     106             :         const char **tmp_lp;
     107             : 
     108           0 :         tmp_lp = lp_parm_string_list(SNUM(handle->conn), "recycle", "exclude_dir", NULL);
     109             : 
     110           0 :         DEBUG(10, ("recycle: exclude_dir = %s ...\n", tmp_lp?*tmp_lp:""));
     111             : 
     112           0 :         return tmp_lp;
     113             : }
     114             : 
     115           0 : static const char **recycle_noversions(vfs_handle_struct *handle)
     116             : {
     117             :         const char **tmp_lp;
     118             : 
     119           0 :         tmp_lp = lp_parm_string_list(SNUM(handle->conn), "recycle", "noversions", NULL);
     120             : 
     121           0 :         DEBUG(10, ("recycle: noversions = %s\n", tmp_lp?*tmp_lp:""));
     122             : 
     123           0 :         return tmp_lp;
     124             : }
     125             : 
     126           0 : static off_t recycle_maxsize(vfs_handle_struct *handle)
     127             : {
     128             :         off_t maxsize;
     129             : 
     130           0 :         maxsize = conv_str_size(lp_parm_const_string(SNUM(handle->conn),
     131             :                                             "recycle", "maxsize", NULL));
     132             : 
     133           0 :         DEBUG(10, ("recycle: maxsize = %lu\n", (long unsigned int)maxsize));
     134             : 
     135           0 :         return maxsize;
     136             : }
     137             : 
     138           0 : static off_t recycle_minsize(vfs_handle_struct *handle)
     139             : {
     140             :         off_t minsize;
     141             : 
     142           0 :         minsize = conv_str_size(lp_parm_const_string(SNUM(handle->conn),
     143             :                                             "recycle", "minsize", NULL));
     144             : 
     145           0 :         DEBUG(10, ("recycle: minsize = %lu\n", (long unsigned int)minsize));
     146             : 
     147           0 :         return minsize;
     148             : }
     149             : 
     150           0 : static mode_t recycle_directory_mode(vfs_handle_struct *handle)
     151             : {
     152             :         int dirmode;
     153             :         const char *buff;
     154             : 
     155           0 :         buff = lp_parm_const_string(SNUM(handle->conn), "recycle", "directory_mode", NULL);
     156             : 
     157           0 :         if (buff != NULL ) {
     158           0 :                 sscanf(buff, "%o", &dirmode);
     159             :         } else {
     160           0 :                 dirmode=S_IRUSR | S_IWUSR | S_IXUSR;
     161             :         }
     162             : 
     163           0 :         DEBUG(10, ("recycle: directory_mode = %o\n", dirmode));
     164           0 :         return (mode_t)dirmode;
     165             : }
     166             : 
     167           0 : static mode_t recycle_subdir_mode(vfs_handle_struct *handle)
     168             : {
     169             :         int dirmode;
     170             :         const char *buff;
     171             : 
     172           0 :         buff = lp_parm_const_string(SNUM(handle->conn), "recycle", "subdir_mode", NULL);
     173             : 
     174           0 :         if (buff != NULL ) {
     175           0 :                 sscanf(buff, "%o", &dirmode);
     176             :         } else {
     177           0 :                 dirmode=recycle_directory_mode(handle);
     178             :         }
     179             : 
     180           0 :         DEBUG(10, ("recycle: subdir_mode = %o\n", dirmode));
     181           0 :         return (mode_t)dirmode;
     182             : }
     183             : 
     184           0 : static bool recycle_directory_exist(vfs_handle_struct *handle, const char *dname)
     185             : {
     186           0 :         struct smb_filename smb_fname = {
     187             :                         .base_name = discard_const_p(char, dname)
     188             :         };
     189             : 
     190           0 :         if (SMB_VFS_STAT(handle->conn, &smb_fname) == 0) {
     191           0 :                 if (S_ISDIR(smb_fname.st.st_ex_mode)) {
     192           0 :                         return True;
     193             :                 }
     194             :         }
     195             : 
     196           0 :         return False;
     197             : }
     198             : 
     199           0 : static bool recycle_file_exist(vfs_handle_struct *handle,
     200             :                                const struct smb_filename *smb_fname)
     201             : {
     202           0 :         struct smb_filename *smb_fname_tmp = NULL;
     203           0 :         bool ret = false;
     204             : 
     205           0 :         smb_fname_tmp = cp_smb_filename(talloc_tos(), smb_fname);
     206           0 :         if (smb_fname_tmp == NULL) {
     207           0 :                 return false;
     208             :         }
     209             : 
     210           0 :         if (SMB_VFS_STAT(handle->conn, smb_fname_tmp) == 0) {
     211           0 :                 if (S_ISREG(smb_fname_tmp->st.st_ex_mode)) {
     212           0 :                         ret = true;
     213             :                 }
     214             :         }
     215             : 
     216           0 :         TALLOC_FREE(smb_fname_tmp);
     217           0 :         return ret;
     218             : }
     219             : 
     220             : /**
     221             :  * Return file size
     222             :  * @param conn connection
     223             :  * @param fname file name
     224             :  * @return size in bytes
     225             :  **/
     226           0 : static off_t recycle_get_file_size(vfs_handle_struct *handle,
     227             :                                        const struct smb_filename *smb_fname)
     228             : {
     229           0 :         struct smb_filename *smb_fname_tmp = NULL;
     230             :         off_t size;
     231             : 
     232           0 :         smb_fname_tmp = cp_smb_filename(talloc_tos(), smb_fname);
     233           0 :         if (smb_fname_tmp == NULL) {
     234           0 :                 size = (off_t)0;
     235           0 :                 goto out;
     236             :         }
     237             : 
     238           0 :         if (SMB_VFS_STAT(handle->conn, smb_fname_tmp) != 0) {
     239           0 :                 DBG_DEBUG("stat for %s returned %s\n",
     240             :                          smb_fname_str_dbg(smb_fname_tmp), strerror(errno));
     241           0 :                 size = (off_t)0;
     242           0 :                 goto out;
     243             :         }
     244             : 
     245           0 :         size = smb_fname_tmp->st.st_ex_size;
     246           0 :  out:
     247           0 :         TALLOC_FREE(smb_fname_tmp);
     248           0 :         return size;
     249             : }
     250             : 
     251             : /**
     252             :  * Create directory tree
     253             :  * @param conn connection
     254             :  * @param dname Directory tree to be created
     255             :  * @return Returns True for success
     256             :  **/
     257           0 : static bool recycle_create_dir(vfs_handle_struct *handle, const char *dname)
     258             : {
     259             :         size_t len;
     260             :         mode_t mode;
     261           0 :         char *new_dir = NULL;
     262           0 :         char *tmp_str = NULL;
     263             :         char *token;
     264             :         char *tok_str;
     265           0 :         bool ret = False;
     266             :         char *saveptr;
     267             : 
     268           0 :         mode = recycle_directory_mode(handle);
     269             : 
     270           0 :         tmp_str = SMB_STRDUP(dname);
     271           0 :         ALLOC_CHECK(tmp_str, done);
     272           0 :         tok_str = tmp_str;
     273             : 
     274           0 :         len = strlen(dname)+1;
     275           0 :         new_dir = (char *)SMB_MALLOC(len + 1);
     276           0 :         ALLOC_CHECK(new_dir, done);
     277           0 :         *new_dir = '\0';
     278           0 :         if (dname[0] == '/') {
     279             :                 /* Absolute path. */
     280           0 :                 if (strlcat(new_dir,"/",len+1) >= len+1) {
     281           0 :                         goto done;
     282             :                 }
     283             :         }
     284             : 
     285             :         /* Create directory tree if necessary */
     286           0 :         for(token = strtok_r(tok_str, "/", &saveptr); token;
     287           0 :             token = strtok_r(NULL, "/", &saveptr)) {
     288           0 :                 if (strlcat(new_dir, token, len+1) >= len+1) {
     289           0 :                         goto done;
     290             :                 }
     291           0 :                 if (recycle_directory_exist(handle, new_dir))
     292           0 :                         DEBUG(10, ("recycle: dir %s already exists\n", new_dir));
     293             :                 else {
     294           0 :                         struct smb_filename *smb_fname = NULL;
     295             :                         int retval;
     296             : 
     297           0 :                         DEBUG(5, ("recycle: creating new dir %s\n", new_dir));
     298             : 
     299           0 :                         smb_fname = synthetic_smb_fname(talloc_tos(),
     300             :                                                 new_dir,
     301             :                                                 NULL,
     302             :                                                 NULL,
     303             :                                                 0,
     304             :                                                 0);
     305           0 :                         if (smb_fname == NULL) {
     306           0 :                                 goto done;
     307             :                         }
     308             : 
     309           0 :                         retval = SMB_VFS_NEXT_MKDIRAT(handle,
     310             :                                         handle->conn->cwd_fsp,
     311             :                                         smb_fname,
     312             :                                         mode);
     313           0 :                         if (retval != 0) {
     314           0 :                                 DBG_WARNING("recycle: mkdirat failed "
     315             :                                         "for %s with error: %s\n",
     316             :                                         new_dir,
     317             :                                         strerror(errno));
     318           0 :                                 TALLOC_FREE(smb_fname);
     319           0 :                                 ret = False;
     320           0 :                                 goto done;
     321             :                         }
     322           0 :                         TALLOC_FREE(smb_fname);
     323             :                 }
     324           0 :                 if (strlcat(new_dir, "/", len+1) >= len+1) {
     325           0 :                         goto done;
     326             :                 }
     327           0 :                 mode = recycle_subdir_mode(handle);
     328             :         }
     329             : 
     330           0 :         ret = True;
     331           0 : done:
     332           0 :         SAFE_FREE(tmp_str);
     333           0 :         SAFE_FREE(new_dir);
     334           0 :         return ret;
     335             : }
     336             : 
     337             : /**
     338             :  * Check if any of the components of "exclude_list" are contained in path.
     339             :  * Return True if found
     340             :  **/
     341             : 
     342           0 : static bool matchdirparam(const char **dir_exclude_list, char *path)
     343             : {
     344           0 :         char *startp = NULL, *endp = NULL;
     345             : 
     346           0 :         if (dir_exclude_list == NULL || dir_exclude_list[0] == NULL ||
     347           0 :                 *dir_exclude_list[0] == '\0' || path == NULL || *path == '\0') {
     348           0 :                 return False;
     349             :         }
     350             : 
     351             :         /* 
     352             :          * Walk the components of path, looking for matches with the
     353             :          * exclude list on each component. 
     354             :          */
     355             : 
     356           0 :         for (startp = path; startp; startp = endp) {
     357             :                 int i;
     358             : 
     359           0 :                 while (*startp == '/') {
     360           0 :                         startp++;
     361             :                 }
     362           0 :                 endp = strchr(startp, '/');
     363           0 :                 if (endp) {
     364           0 :                         *endp = '\0';
     365             :                 }
     366             : 
     367           0 :                 for(i=0; dir_exclude_list[i] ; i++) {
     368           0 :                         if(unix_wild_match(dir_exclude_list[i], startp)) {
     369             :                                 /* Repair path. */
     370           0 :                                 if (endp) {
     371           0 :                                         *endp = '/';
     372             :                                 }
     373           0 :                                 return True;
     374             :                         }
     375             :                 }
     376             : 
     377             :                 /* Repair path. */
     378           0 :                 if (endp) {
     379           0 :                         *endp = '/';
     380             :                 }
     381             :         }
     382             : 
     383           0 :         return False;
     384             : }
     385             : 
     386             : /**
     387             :  * Check if needle is contained in haystack, * and ? patterns are resolved
     388             :  * @param haystack list of parameters separated by delimimiter character
     389             :  * @param needle string to be matched exectly to haystack including pattern matching
     390             :  * @return True if found
     391             :  **/
     392           0 : static bool matchparam(const char **haystack_list, const char *needle)
     393             : {
     394             :         int i;
     395             : 
     396           0 :         if (haystack_list == NULL || haystack_list[0] == NULL ||
     397           0 :                 *haystack_list[0] == '\0' || needle == NULL || *needle == '\0') {
     398           0 :                 return False;
     399             :         }
     400             : 
     401           0 :         for(i=0; haystack_list[i] ; i++) {
     402           0 :                 if(unix_wild_match(haystack_list[i], needle)) {
     403           0 :                         return True;
     404             :                 }
     405             :         }
     406             : 
     407           0 :         return False;
     408             : }
     409             : 
     410             : /**
     411             :  * Touch access or modify date
     412             :  **/
     413           0 : static void recycle_do_touch(vfs_handle_struct *handle,
     414             :                              const struct smb_filename *smb_fname,
     415             :                              bool touch_mtime)
     416             : {
     417           0 :         struct smb_filename *smb_fname_tmp = NULL;
     418             :         struct smb_file_time ft;
     419             :         int ret, err;
     420             :         NTSTATUS status;
     421             : 
     422           0 :         init_smb_file_time(&ft);
     423             : 
     424           0 :         status = synthetic_pathref(talloc_tos(),
     425           0 :                                    handle->conn->cwd_fsp,
     426           0 :                                    smb_fname->base_name,
     427           0 :                                    smb_fname->stream_name,
     428             :                                    NULL,
     429             :                                    smb_fname->twrp,
     430             :                                    smb_fname->flags,
     431             :                                    &smb_fname_tmp);
     432           0 :         if (!NT_STATUS_IS_OK(status)) {
     433           0 :                 DBG_DEBUG("synthetic_pathref for '%s' failed: %s\n",
     434             :                           smb_fname_str_dbg(smb_fname), nt_errstr(status));
     435           0 :                 return;
     436             :         }
     437             : 
     438             :         /* atime */
     439           0 :         ft.atime = timespec_current();
     440             :         /* mtime */
     441           0 :         ft.mtime = touch_mtime ? ft.atime : smb_fname_tmp->st.st_ex_mtime;
     442             : 
     443           0 :         become_root();
     444           0 :         ret = SMB_VFS_NEXT_FNTIMES(handle, smb_fname_tmp->fsp, &ft);
     445           0 :         err = errno;
     446           0 :         unbecome_root();
     447           0 :         if (ret == -1 ) {
     448           0 :                 DEBUG(0, ("recycle: touching %s failed, reason = %s\n",
     449             :                           smb_fname_str_dbg(smb_fname_tmp), strerror(err)));
     450             :         }
     451             : 
     452           0 :         TALLOC_FREE(smb_fname_tmp);
     453             : }
     454             : 
     455             : /**
     456             :  * Check if file should be recycled
     457             :  **/
     458           0 : static int recycle_unlink_internal(vfs_handle_struct *handle,
     459             :                                 struct files_struct *dirfsp,
     460             :                                 const struct smb_filename *smb_fname,
     461             :                                 int flags)
     462             : {
     463           0 :         const struct loadparm_substitution *lp_sub =
     464             :                 loadparm_s3_global_substitution();
     465           0 :         connection_struct *conn = handle->conn;
     466           0 :         struct smb_filename *full_fname = NULL;
     467           0 :         char *path_name = NULL;
     468           0 :         char *temp_name = NULL;
     469           0 :         char *final_name = NULL;
     470           0 :         struct smb_filename *smb_fname_final = NULL;
     471             :         const char *base;
     472           0 :         char *repository = NULL;
     473           0 :         int i = 1;
     474             :         off_t maxsize, minsize;
     475             :         off_t file_size; /* space_avail;        */
     476             :         bool exist;
     477           0 :         int rc = -1;
     478             : 
     479           0 :         repository = talloc_sub_full(NULL, lp_servicename(talloc_tos(), lp_sub, SNUM(conn)),
     480           0 :                                         conn->session_info->unix_info->unix_name,
     481           0 :                                         conn->connectpath,
     482           0 :                                         conn->session_info->unix_token->gid,
     483           0 :                                         conn->session_info->unix_info->sanitized_username,
     484           0 :                                         conn->session_info->info->domain_name,
     485             :                                         recycle_repository(handle));
     486           0 :         ALLOC_CHECK(repository, done);
     487             :         /* shouldn't we allow absolute path names here? --metze */
     488             :         /* Yes :-). JRA. */
     489           0 :         trim_char(repository, '\0', '/');
     490             : 
     491           0 :         if(!repository || *(repository) == '\0') {
     492           0 :                 DEBUG(3, ("recycle: repository path not set, purging %s...\n",
     493             :                           smb_fname_str_dbg(smb_fname)));
     494           0 :                 rc = SMB_VFS_NEXT_UNLINKAT(handle,
     495             :                                         dirfsp,
     496             :                                         smb_fname,
     497             :                                         flags);
     498           0 :                 goto done;
     499             :         }
     500             : 
     501           0 :         full_fname = full_path_from_dirfsp_atname(talloc_tos(),
     502             :                                                   dirfsp,
     503             :                                                   smb_fname);
     504           0 :         if (full_fname == NULL) {
     505           0 :                 return -1;
     506             :         }
     507             : 
     508             :         /* we don't recycle the recycle bin... */
     509           0 :         if (strncmp(full_fname->base_name, repository,
     510             :                     strlen(repository)) == 0) {
     511           0 :                 DEBUG(3, ("recycle: File is within recycling bin, unlinking ...\n"));
     512           0 :                 rc = SMB_VFS_NEXT_UNLINKAT(handle,
     513             :                                         dirfsp,
     514             :                                         smb_fname,
     515             :                                         flags);
     516           0 :                 goto done;
     517             :         }
     518             : 
     519           0 :         file_size = recycle_get_file_size(handle, full_fname);
     520             :         /* it is wrong to purge filenames only because they are empty imho
     521             :          *   --- simo
     522             :          *
     523             :         if(fsize == 0) {
     524             :                 DEBUG(3, ("recycle: File %s is empty, purging...\n", file_name));
     525             :                 rc = SMB_VFS_NEXT_UNLINKAT(handle,
     526             :                                         dirfsp,
     527             :                                         file_name,
     528             :                                         flags);
     529             :                 goto done;
     530             :         }
     531             :          */
     532             : 
     533             :         /* FIXME: this is wrong, we should check the whole size of the recycle bin is
     534             :          * not greater then maxsize, not the size of the single file, also it is better
     535             :          * to remove older files
     536             :          */
     537           0 :         maxsize = recycle_maxsize(handle);
     538           0 :         if(maxsize > 0 && file_size > maxsize) {
     539           0 :                 DEBUG(3, ("recycle: File %s exceeds maximum recycle size, "
     540             :                           "purging... \n", smb_fname_str_dbg(full_fname)));
     541           0 :                 rc = SMB_VFS_NEXT_UNLINKAT(handle,
     542             :                                         dirfsp,
     543             :                                         smb_fname,
     544             :                                         flags);
     545           0 :                 goto done;
     546             :         }
     547           0 :         minsize = recycle_minsize(handle);
     548           0 :         if(minsize > 0 && file_size < minsize) {
     549           0 :                 DEBUG(3, ("recycle: File %s lowers minimum recycle size, "
     550             :                           "purging... \n", smb_fname_str_dbg(full_fname)));
     551           0 :                 rc = SMB_VFS_NEXT_UNLINKAT(handle,
     552             :                                         dirfsp,
     553             :                                         smb_fname,
     554             :                                         flags);
     555           0 :                 goto done;
     556             :         }
     557             : 
     558             :         /* FIXME: this is wrong: moving files with rename does not change the disk space
     559             :          * allocation
     560             :          *
     561             :         space_avail = SMB_VFS_NEXT_DISK_FREE(handle, ".", True, &bsize, &dfree, &dsize) * 1024L;
     562             :         DEBUG(5, ("space_avail = %Lu, file_size = %Lu\n", space_avail, file_size));
     563             :         if(space_avail < file_size) {
     564             :                 DEBUG(3, ("recycle: Not enough diskspace, purging file %s\n", file_name));
     565             :                 rc = SMB_VFS_NEXT_UNLINKAT(handle,
     566             :                                         dirfsp,
     567             :                                         file_name,
     568             :                                         flags);
     569             :                 goto done;
     570             :         }
     571             :          */
     572             : 
     573             :         /* extract filename and path */
     574           0 :         base = strrchr(full_fname->base_name, '/');
     575           0 :         if (base == NULL) {
     576           0 :                 base = full_fname->base_name;
     577           0 :                 path_name = SMB_STRDUP("/");
     578           0 :                 ALLOC_CHECK(path_name, done);
     579             :         }
     580             :         else {
     581           0 :                 path_name = SMB_STRDUP(full_fname->base_name);
     582           0 :                 ALLOC_CHECK(path_name, done);
     583           0 :                 path_name[base - smb_fname->base_name] = '\0';
     584           0 :                 base++;
     585             :         }
     586             : 
     587             :         /* original filename with path */
     588           0 :         DEBUG(10, ("recycle: fname = %s\n", smb_fname_str_dbg(full_fname)));
     589             :         /* original path */
     590           0 :         DEBUG(10, ("recycle: fpath = %s\n", path_name));
     591             :         /* filename without path */
     592           0 :         DEBUG(10, ("recycle: base = %s\n", base));
     593             : 
     594           0 :         if (matchparam(recycle_exclude(handle), base)) {
     595           0 :                 DEBUG(3, ("recycle: file %s is excluded \n", base));
     596           0 :                 rc = SMB_VFS_NEXT_UNLINKAT(handle,
     597             :                                         dirfsp,
     598             :                                         smb_fname,
     599             :                                         flags);
     600           0 :                 goto done;
     601             :         }
     602             : 
     603           0 :         if (matchdirparam(recycle_exclude_dir(handle), path_name)) {
     604           0 :                 DEBUG(3, ("recycle: directory %s is excluded \n", path_name));
     605           0 :                 rc = SMB_VFS_NEXT_UNLINKAT(handle,
     606             :                                         dirfsp,
     607             :                                         smb_fname,
     608             :                                         flags);
     609           0 :                 goto done;
     610             :         }
     611             : 
     612           0 :         if (recycle_keep_dir_tree(handle) == True) {
     613           0 :                 if (asprintf(&temp_name, "%s/%s", repository, path_name) == -1) {
     614           0 :                         ALLOC_CHECK(temp_name, done);
     615             :                 }
     616             :         } else {
     617           0 :                 temp_name = SMB_STRDUP(repository);
     618             :         }
     619           0 :         ALLOC_CHECK(temp_name, done);
     620             : 
     621           0 :         exist = recycle_directory_exist(handle, temp_name);
     622           0 :         if (exist) {
     623           0 :                 DEBUG(10, ("recycle: Directory already exists\n"));
     624             :         } else {
     625           0 :                 DEBUG(10, ("recycle: Creating directory %s\n", temp_name));
     626           0 :                 if (recycle_create_dir(handle, temp_name) == False) {
     627           0 :                         DEBUG(3, ("recycle: Could not create directory, "
     628             :                                   "purging %s...\n",
     629             :                                   smb_fname_str_dbg(full_fname)));
     630           0 :                         rc = SMB_VFS_NEXT_UNLINKAT(handle,
     631             :                                         dirfsp,
     632             :                                         smb_fname,
     633             :                                         flags);
     634           0 :                         goto done;
     635             :                 }
     636             :         }
     637             : 
     638           0 :         if (asprintf(&final_name, "%s/%s", temp_name, base) == -1) {
     639           0 :                 ALLOC_CHECK(final_name, done);
     640             :         }
     641             : 
     642             :         /* Create smb_fname with final base name and orig stream name. */
     643           0 :         smb_fname_final = synthetic_smb_fname(talloc_tos(),
     644             :                                         final_name,
     645           0 :                                         full_fname->stream_name,
     646             :                                         NULL,
     647             :                                         full_fname->twrp,
     648             :                                         full_fname->flags);
     649           0 :         if (smb_fname_final == NULL) {
     650           0 :                 rc = SMB_VFS_NEXT_UNLINKAT(handle,
     651             :                                         dirfsp,
     652             :                                         smb_fname,
     653             :                                         flags);
     654           0 :                 goto done;
     655             :         }
     656             : 
     657             :         /* new filename with path */
     658           0 :         DEBUG(10, ("recycle: recycled file name: %s\n",
     659             :                    smb_fname_str_dbg(smb_fname_final)));
     660             : 
     661             :         /* check if we should delete file from recycle bin */
     662           0 :         if (recycle_file_exist(handle, smb_fname_final)) {
     663           0 :                 if (recycle_versions(handle) == False || matchparam(recycle_noversions(handle), base) == True) {
     664           0 :                         DEBUG(3, ("recycle: Removing old file %s from recycle "
     665             :                                   "bin\n", smb_fname_str_dbg(smb_fname_final)));
     666           0 :                         if (SMB_VFS_NEXT_UNLINKAT(handle,
     667             :                                                 dirfsp->conn->cwd_fsp,
     668             :                                                 smb_fname_final,
     669             :                                                 flags) != 0) {
     670           0 :                                 DEBUG(1, ("recycle: Error deleting old file: %s\n", strerror(errno)));
     671             :                         }
     672             :                 }
     673             :         }
     674             : 
     675             :         /* rename file we move to recycle bin */
     676           0 :         i = 1;
     677           0 :         while (recycle_file_exist(handle, smb_fname_final)) {
     678           0 :                 SAFE_FREE(final_name);
     679           0 :                 if (asprintf(&final_name, "%s/Copy #%d of %s", temp_name, i++, base) == -1) {
     680           0 :                         ALLOC_CHECK(final_name, done);
     681             :                 }
     682           0 :                 TALLOC_FREE(smb_fname_final->base_name);
     683           0 :                 smb_fname_final->base_name = talloc_strdup(smb_fname_final,
     684             :                                                            final_name);
     685           0 :                 if (smb_fname_final->base_name == NULL) {
     686           0 :                         rc = SMB_VFS_NEXT_UNLINKAT(handle,
     687             :                                                 dirfsp,
     688             :                                                 smb_fname,
     689             :                                                 flags);
     690           0 :                         goto done;
     691             :                 }
     692             :         }
     693             : 
     694           0 :         DEBUG(10, ("recycle: Moving %s to %s\n", smb_fname_str_dbg(full_fname),
     695             :                 smb_fname_str_dbg(smb_fname_final)));
     696           0 :         rc = SMB_VFS_NEXT_RENAMEAT(handle,
     697             :                         dirfsp,
     698             :                         smb_fname,
     699             :                         handle->conn->cwd_fsp,
     700             :                         smb_fname_final);
     701           0 :         if (rc != 0) {
     702           0 :                 DEBUG(3, ("recycle: Move error %d (%s), purging file %s "
     703             :                           "(%s)\n", errno, strerror(errno),
     704             :                           smb_fname_str_dbg(full_fname),
     705             :                           smb_fname_str_dbg(smb_fname_final)));
     706           0 :                 rc = SMB_VFS_NEXT_UNLINKAT(handle,
     707             :                                 dirfsp,
     708             :                                 smb_fname,
     709             :                                 flags);
     710           0 :                 goto done;
     711             :         }
     712             : 
     713             :         /* touch access date of moved file */
     714           0 :         if (recycle_touch(handle) == True || recycle_touch_mtime(handle))
     715           0 :                 recycle_do_touch(handle, smb_fname_final,
     716           0 :                                  recycle_touch_mtime(handle));
     717             : 
     718           0 : done:
     719           0 :         SAFE_FREE(path_name);
     720           0 :         SAFE_FREE(temp_name);
     721           0 :         SAFE_FREE(final_name);
     722           0 :         TALLOC_FREE(full_fname);
     723           0 :         TALLOC_FREE(smb_fname_final);
     724           0 :         TALLOC_FREE(repository);
     725           0 :         return rc;
     726             : }
     727             : 
     728           0 : static int recycle_unlinkat(vfs_handle_struct *handle,
     729             :                 struct files_struct *dirfsp,
     730             :                 const struct smb_filename *smb_fname,
     731             :                 int flags)
     732             : {
     733             :         int ret;
     734             : 
     735           0 :         if (flags & AT_REMOVEDIR) {
     736           0 :                 ret = SMB_VFS_NEXT_UNLINKAT(handle,
     737             :                                         dirfsp,
     738             :                                         smb_fname,
     739             :                                         flags);
     740             :         } else {
     741           0 :                 ret = recycle_unlink_internal(handle,
     742             :                                         dirfsp,
     743             :                                         smb_fname,
     744             :                                         flags);
     745             :         }
     746           0 :         return ret;
     747             : }
     748             : 
     749             : static struct vfs_fn_pointers vfs_recycle_fns = {
     750             :         .unlinkat_fn = recycle_unlinkat
     751             : };
     752             : 
     753             : static_decl_vfs;
     754          20 : NTSTATUS vfs_recycle_init(TALLOC_CTX *ctx)
     755             : {
     756          20 :         NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "recycle",
     757             :                                         &vfs_recycle_fns);
     758             : 
     759          20 :         if (!NT_STATUS_IS_OK(ret))
     760           0 :                 return ret;
     761             : 
     762          20 :         vfs_recycle_debug_level = debug_add_class("recycle");
     763          20 :         if (vfs_recycle_debug_level == -1) {
     764           0 :                 vfs_recycle_debug_level = DBGC_VFS;
     765           0 :                 DEBUG(0, ("vfs_recycle: Couldn't register custom debugging class!\n"));
     766             :         } else {
     767          20 :                 DEBUG(10, ("vfs_recycle: Debug class number of 'recycle': %d\n", vfs_recycle_debug_level));
     768             :         }
     769             : 
     770          20 :         return ret;
     771             : }

Generated by: LCOV version 1.13