source/smbd/close.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    file closing
   4    Copyright (C) Andrew Tridgell 1992-1998
   5    Copyright (C) Jeremy Allison 1992-2004.
   6    Copyright (C) Volker Lendecke 2005
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25 /****************************************************************************
  26  Run a file if it is a magic script.
  27 ****************************************************************************/
  28
  29 static void check_magic(files_struct *fsp,connection_struct *conn)
  30 {
  31         if (!*lp_magicscript(SNUM(conn)))
  32                 return;
  33
  34         DEBUG(5,("checking magic for %s\n",fsp->fsp_name));
  35
  36         {
  37                 char *p;
  38                 if (!(p = strrchr_m(fsp->fsp_name,'/')))
  39                         p = fsp->fsp_name;
  40                 else
  41                         p++;
  42
  43                 if (!strequal(lp_magicscript(SNUM(conn)),p))
  44                         return;
  45         }
  46
  47         {
  48                 int ret;
  49                 pstring magic_output;
  50                 pstring fname;
  51                 SMB_STRUCT_STAT st;
  52                 int tmp_fd, outfd;
  53
  54                 pstrcpy(fname,fsp->fsp_name);
  55                 if (*lp_magicoutput(SNUM(conn)))
  56                         pstrcpy(magic_output,lp_magicoutput(SNUM(conn)));
  57                 else
  58                         slprintf(magic_output,sizeof(fname)-1, "%s.out",fname);
  59
  60                 chmod(fname,0755);
  61                 ret = smbrun(fname,&tmp_fd);
  62                 DEBUG(3,("Invoking magic command %s gave %d\n",fname,ret));
  63                 unlink(fname);
  64                 if (ret != 0 || tmp_fd == -1) {
  65                         if (tmp_fd != -1)
  66                                 close(tmp_fd);
  67                         return;
  68                 }
  69                 outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
  70                 if (outfd == -1) {
  71                         close(tmp_fd);
  72                         return;
  73                 }
  74
  75                 if (sys_fstat(tmp_fd,&st) == -1) {
  76                         close(tmp_fd);
  77                         close(outfd);
  78                         return;
  79                 }
  80
  81                 transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_size);
  82                 close(tmp_fd);
  83                 close(outfd);
  84         }
  85 }
  86
  87 /****************************************************************************
  88   Common code to close a file or a directory.
  89 ****************************************************************************/
  90
  91 static int close_filestruct(files_struct *fsp)
  92 {
  93         connection_struct *conn = fsp->conn;
  94         int ret = 0;
  95
  96         if (fsp->fh->fd != -1) {
  97                 if(flush_write_cache(fsp, CLOSE_FLUSH) == -1)
  98                         ret = -1;
  99
 100                 delete_write_cache(fsp);
 101         }
 102
 103         conn->num_files_open--;
 104         SAFE_FREE(fsp->wbmpx_ptr);
 105
 106         return ret;
 107 }
 108
 109 /****************************************************************************
 110  If any deferred opens are waiting on this close, notify them.
 111 ****************************************************************************/
 112
 113 static void notify_deferred_opens(files_struct *fsp)
 114 {
 115         deferred_open_entry *de_array = NULL;
 116         int num_de_entries, i;
 117         pid_t mypid = sys_getpid();
 118
 119         if (!lp_defer_sharing_violations()) {
 120                 return;
 121         }
 122
 123         num_de_entries = get_deferred_opens(fsp->conn, fsp->dev, fsp->inode, &de_array);
 124         for (i = 0; i < num_de_entries; i++) {
 125                 deferred_open_entry *entry = &de_array[i];
 126                 if (entry->pid == mypid) {
 127                         /*
 128                          * We need to notify ourself to retry the open.
 129                          * Do this by finding the queued SMB record, moving it
 130                          * to the head of the queue and changing the wait time to zero.
 131                          */
 132                         schedule_sharing_violation_open_smb_message(entry->mid);
 133                 } else {
 134                         send_deferred_open_retry_message(entry);
 135                 }
 136         }
 137         SAFE_FREE(de_array);
 138 }
 139
 140 /****************************************************************************
 141  Close a file.
 142
 143  If normal_close is 1 then this came from a normal SMBclose (or equivalent)
 144  operation otherwise it came as the result of some other operation such as
 145  the closing of the connection. In the latter case printing and
 146  magic scripts are not run.
 147 ****************************************************************************/
 148
 149 static int close_normal_file(files_struct *fsp, BOOL normal_close)
 150 {
 151         share_mode_entry *share_entry = NULL;
 152         size_t share_entry_count = 0;
 153         BOOL delete_file = False;
 154         connection_struct *conn = fsp->conn;
 155         int saved_errno = 0;
 156         int err = 0;
 157         int err1 = 0;
 158
 159         remove_pending_lock_requests_by_fid(fsp);
 160
 161         if (fsp->aio_write_behind) {
 162                 /*
 163                  * If we're finishing write behind on a close we can get a write
 164                  * error here, we must remember this.
 165                  */
 166                 int ret = wait_for_aio_completion(fsp);
 167                 if (ret) {
 168                         saved_errno = ret;
 169                         err1 = -1;
 170                 }
 171         } else {
 172                 cancel_aio_by_fsp(fsp);
 173         }
 174
 175         /*
 176          * If we're flushing on a close we can get a write
 177          * error here, we must remember this.
 178          */
 179
 180         if (close_filestruct(fsp) == -1) {
 181                 saved_errno = errno;
 182                 err1 = -1;
 183         }
 184
 185         if (fsp->print_file) {
 186                 print_fsp_end(fsp, normal_close);
 187                 file_free(fsp);
 188                 return 0;
 189         }
 190
 191         /*
 192          * Lock the share entries, and determine if we should delete
 193          * on close. If so delete whilst the lock is still in effect.
 194          * This prevents race conditions with the file being created. JRA.
 195          */
 196
 197         lock_share_entry_fsp(fsp);
 198
 199         share_entry_count = del_share_mode(fsp, &share_entry,
 200                                            &delete_file);
 201
 202         DEBUG(10,("close_normal_file: share_entry_count = %lu for file %s\n",
 203                 (unsigned long)share_entry_count, fsp->fsp_name ));
 204
 205         if (share_entry_count != 0) {
 206                 /* We're not the last ones -- don't delete */
 207                 delete_file = False;
 208         }
 209
 210         SAFE_FREE(share_entry);
 211
 212         /* Notify any deferred opens waiting on this close. */
 213         notify_deferred_opens(fsp);
 214
 215         /*
 216          * NT can set delete_on_close of the last open
 217          * reference to a file.
 218          */
 219
 220         if (normal_close && delete_file) {
 221                 DEBUG(5,("close_file: file %s. Delete on close was set - deleting file.\n",
 222                         fsp->fsp_name));
 223                 if(SMB_VFS_UNLINK(conn,fsp->fsp_name) != 0) {
 224                         /*
 225                          * This call can potentially fail as another smbd may have
 226                          * had the file open with delete on close set and deleted
 227                          * it when its last reference to this file went away. Hence
 228                          * we log this but not at debug level zero.
 229                          */
 230
 231                 DEBUG(5,("close_file: file %s. Delete on close was set and unlink failed \
 232 with error %s\n", fsp->fsp_name, strerror(errno) ));
 233                 }
 234                 process_pending_change_notify_queue((time_t)0);
 235         }
 236
 237         unlock_share_entry_fsp(fsp);
 238
 239         if(fsp->oplock_type)
 240                 release_file_oplock(fsp);
 241
 242         locking_close_file(fsp);
 243
 244         err = fd_close(conn, fsp);
 245
 246         /* Only save errno if fd_close failed and we don't already
 247            have an errno saved from a flush call. */
 248         if ((err1 != -1) && (err == -1)) {
 249                 saved_errno = errno;
 250         }
 251
 252         /* check for magic scripts */
 253         if (normal_close) {
 254                 check_magic(fsp,conn);
 255         }
 256
 257         /*
 258          * Ensure pending modtime is set after close.
 259          */
 260
 261         if(fsp->pending_modtime && fsp->pending_modtime_owner) {
 262                 set_filetime(conn, fsp->fsp_name, fsp->pending_modtime);
 263         } else if (fsp->last_write_time) {
 264                 set_filetime(conn, fsp->fsp_name, fsp->last_write_time);
 265         }
 266
 267         DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
 268                 conn->user,fsp->fsp_name,
 269                 conn->num_files_open,
 270                 (err == -1 || err1 == -1) ? strerror(saved_errno) : ""));
 271
 272         if (fsp->fsp_name)
 273                 string_free(&fsp->fsp_name);
 274
 275         file_free(fsp);
 276
 277         if (err == -1 || err1 == -1) {
 278                 errno = saved_errno;
 279                 return saved_errno;
 280         } else {
 281                 return 0;
 282         }
 283 }
 284
 285 /****************************************************************************
 286  Close a directory opened by an NT SMB call.
 287 ****************************************************************************/
 288
 289 static int close_directory(files_struct *fsp, BOOL normal_close)
 290 {
 291         remove_pending_change_notify_requests_by_fid(fsp);
 292
 293         /*
 294          * NT can set delete_on_close of the last open
 295          * reference to a directory also.
 296          */
 297
 298         if (normal_close &&
 299             get_delete_on_close_flag(fsp->dev, fsp->inode)) {
 300                 BOOL ok = rmdir_internals(fsp->conn, fsp->fsp_name);
 301                 DEBUG(5,("close_directory: %s. Delete on close was set - deleting directory %s.\n",
 302                         fsp->fsp_name, ok ? "succeeded" : "failed" ));
 303
 304                 /*
 305                  * Ensure we remove any change notify requests that would
 306                  * now fail as the directory has been deleted.
 307                  */
 308
 309                 if(ok) {
 310                         remove_pending_change_notify_requests_by_filename(fsp);
 311                 }
 312                 process_pending_change_notify_queue((time_t)0);
 313         }
 314
 315         /*
 316          * Do the code common to files and directories.
 317          */
 318         close_filestruct(fsp);
 319
 320         if (fsp->fsp_name) {
 321                 string_free(&fsp->fsp_name);
 322         }
 323
 324         file_free(fsp);
 325         return 0;
 326 }
 327
 328 /****************************************************************************
 329  Close a 'stat file' opened internally.
 330 ****************************************************************************/
 331
 332 static int close_stat(files_struct *fsp)
 333 {
 334         /*
 335          * Do the code common to files and directories.
 336          */
 337         close_filestruct(fsp);
 338
 339         if (fsp->fsp_name)
 340                 string_free(&fsp->fsp_name);
 341
 342         file_free(fsp);
 343         return 0;
 344 }
 345
 346 /****************************************************************************
 347  Close a files_struct.
 348 ****************************************************************************/
 349
 350 int close_file(files_struct *fsp, BOOL normal_close)
 351 {
 352         if(fsp->is_directory)
 353                 return close_directory(fsp, normal_close);
 354         else if (fsp->is_stat)
 355                 return close_stat(fsp);
 356         else
 357                 return close_normal_file(fsp, normal_close);
 358 }