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(struct share_mode_lock *lck)
 114 {
 115         int i;
 116
 117         for (i=0; i<lck->num_share_modes; i++) {
 118                 struct share_mode_entry *e = &lck->share_modes[i];
 119
 120                 if (!is_deferred_open_entry(e)) {
 121                         continue;
 122                 }
 123
 124                 if (procid_is_me(&e->pid)) {
 125                         /*
 126                          * We need to notify ourself to retry the open.  Do
 127                          * this by finding the queued SMB record, moving it to
 128                          * the head of the queue and changing the wait time to
 129                          * zero.
 130                          */
 131                         schedule_deferred_open_smb_message(e->op_mid);
 132                 } else {
 133                         become_root();
 134                         message_send_pid(e->pid, MSG_SMB_OPEN_RETRY,
 135                                          e, sizeof(*e), True);
 136                         unbecome_root();
 137                 }
 138         }
 139 }
 140
 141 /****************************************************************************
 142  Close a file.
 143
 144  If normal_close is 1 then this came from a normal SMBclose (or equivalent)
 145  operation otherwise it came as the result of some other operation such as
 146  the closing of the connection. In the latter case printing and
 147  magic scripts are not run.
 148 ****************************************************************************/
 149
 150 static int close_normal_file(files_struct *fsp, BOOL normal_close)
 151 {
 152         BOOL delete_file = False;
 153         connection_struct *conn = fsp->conn;
 154         int saved_errno = 0;
 155         int err = 0;
 156         int err1 = 0;
 157         struct share_mode_lock *lck;
 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         lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
 198
 199         if (lck == NULL) {
 200                 DEBUG(0, ("close_file: Could not get share mode lock for file %s\n", fsp->fsp_name));
 201                 return EINVAL;
 202         }
 203
 204         if (!del_share_mode(lck, fsp)) {
 205                 DEBUG(0, ("close_file: Could not delete share entry for file %s\n", fsp->fsp_name));
 206         }
 207
 208         delete_file = lck->delete_on_close;
 209
 210         if (delete_file) {
 211                 int i;
 212                 /* See if others still have the file open. If this is the
 213                  * case, then don't delete */
 214                 for (i=0; i<lck->num_share_modes; i++) {
 215                         if (is_valid_share_mode_entry(&lck->share_modes[i])) {
 216                                 delete_file = False;
 217                                 break;
 218                         }
 219                 }
 220         }
 221
 222         /* Notify any deferred opens waiting on this close. */
 223         notify_deferred_opens(lck);
 224         reply_to_oplock_break_requests(fsp);
 225
 226         /*
 227          * NT can set delete_on_close of the last open
 228          * reference to a file.
 229          */
 230
 231         if (normal_close && delete_file) {
 232                 SMB_STRUCT_STAT sbuf;
 233
 234                 DEBUG(5,("close_file: file %s. Delete on close was set - deleting file.\n",
 235                         fsp->fsp_name));
 236
 237                 /* We can only delete the file if the name we have
 238                    is still valid and hasn't been renamed. */
 239
 240                 if(SMB_VFS_STAT(conn,fsp->fsp_name,&sbuf) != 0) {
 241                         DEBUG(5,("close_file: file %s. Delete on close was set "
 242                                 "and stat failed with error %s\n",
 243                                 fsp->fsp_name, strerror(errno) ));
 244                 } else {
 245                         if(sbuf.st_dev != fsp->dev || sbuf.st_ino != fsp->inode) {
 246                                 DEBUG(5,("close_file: file %s. Delete on close was set and "
 247                                         "dev and/or inode does not match\n",
 248                                         fsp->fsp_name ));
 249                                 DEBUG(5,("close_file: file %s. stored dev = %x, inode = %.0f "
 250                                         "stat dev = %x, inode = %.0f\n",
 251                                         fsp->fsp_name,
 252                                         (unsigned int)fsp->dev, (double)fsp->inode,
 253                                         (unsigned int)sbuf.st_dev, (double)sbuf.st_ino ));
 254
 255                         } else if(SMB_VFS_UNLINK(conn,fsp->fsp_name) != 0) {
 256                                 /*
 257                                  * This call can potentially fail as another smbd may have
 258                                  * had the file open with delete on close set and deleted
 259                                  * it when its last reference to this file went away. Hence
 260                                  * we log this but not at debug level zero.
 261                                  */
 262
 263                                 DEBUG(5,("close_file: file %s. Delete on close was set "
 264                                         "and unlink failed with error %s\n",
 265                                         fsp->fsp_name, strerror(errno) ));
 266                         }
 267                         process_pending_change_notify_queue((time_t)0);
 268                 }
 269         }
 270
 271         talloc_free(lck);
 272
 273         if(fsp->oplock_type)
 274                 release_file_oplock(fsp);
 275
 276         locking_close_file(fsp);
 277
 278         err = fd_close(conn, fsp);
 279
 280         /* Only save errno if fd_close failed and we don't already
 281            have an errno saved from a flush call. */
 282         if ((err1 != -1) && (err == -1)) {
 283                 saved_errno = errno;
 284         }
 285
 286         /* check for magic scripts */
 287         if (normal_close) {
 288                 check_magic(fsp,conn);
 289         }
 290
 291         /*
 292          * Ensure pending modtime is set after close.
 293          */
 294
 295         if(fsp->pending_modtime && fsp->pending_modtime_owner) {
 296                 set_filetime(conn, fsp->fsp_name, fsp->pending_modtime);
 297         } else if (fsp->last_write_time) {
 298                 set_filetime(conn, fsp->fsp_name, fsp->last_write_time);
 299         }
 300
 301         DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
 302                 conn->user,fsp->fsp_name,
 303                 conn->num_files_open,
 304                 (err == -1 || err1 == -1) ? strerror(saved_errno) : ""));
 305
 306         if (fsp->fsp_name)
 307                 string_free(&fsp->fsp_name);
 308
 309         file_free(fsp);
 310
 311         if (err == -1 || err1 == -1) {
 312                 errno = saved_errno;
 313                 return saved_errno;
 314         } else {
 315                 return 0;
 316         }
 317 }
 318
 319 /****************************************************************************
 320  Close a directory opened by an NT SMB call.
 321 ****************************************************************************/
 322
 323 static int close_directory(files_struct *fsp, BOOL normal_close)
 324 {
 325         struct share_mode_lock *lck = 0;
 326         BOOL delete_dir = False;
 327
 328         /*
 329          * NT can set delete_on_close of the last open
 330          * reference to a directory also.
 331          */
 332
 333         lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
 334
 335         if (lck == NULL) {
 336                 DEBUG(0, ("close_directory: Could not get share mode lock for %s\n", fsp->fsp_name));
 337                 return EINVAL;
 338         }
 339
 340         if (!del_share_mode(lck, fsp)) {
 341                 DEBUG(0, ("close_directory: Could not delete share entry for %s\n", fsp->fsp_name));
 342         }
 343
 344         delete_dir = lck->delete_on_close;
 345
 346         talloc_free(lck);
 347
 348         if (normal_close && delete_dir) {
 349                 BOOL ok = rmdir_internals(fsp->conn, fsp->fsp_name);
 350                 DEBUG(5,("close_directory: %s. Delete on close was set - deleting directory %s.\n",
 351                         fsp->fsp_name, ok ? "succeeded" : "failed" ));
 352
 353                 /*
 354                  * Ensure we remove any change notify requests that would
 355                  * now fail as the directory has been deleted.
 356                  */
 357
 358                 if(ok) {
 359                         remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING);
 360                         remove_pending_change_notify_requests_by_filename(fsp, NT_STATUS_DELETE_PENDING);
 361
 362                 }
 363                 process_pending_change_notify_queue((time_t)0);
 364         } else {
 365                 remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_CANCELLED);
 366         }
 367
 368         /*
 369          * Do the code common to files and directories.
 370          */
 371         close_filestruct(fsp);
 372
 373         if (fsp->fsp_name) {
 374                 string_free(&fsp->fsp_name);
 375         }
 376
 377         file_free(fsp);
 378         return 0;
 379 }
 380
 381 /****************************************************************************
 382  Close a 'stat file' opened internally.
 383 ****************************************************************************/
 384
 385 static int close_stat(files_struct *fsp)
 386 {
 387         /*
 388          * Do the code common to files and directories.
 389          */
 390         close_filestruct(fsp);
 391
 392         if (fsp->fsp_name)
 393                 string_free(&fsp->fsp_name);
 394
 395         file_free(fsp);
 396         return 0;
 397 }
 398
 399 /****************************************************************************
 400  Close a files_struct.
 401 ****************************************************************************/
 402
 403 int close_file(files_struct *fsp, BOOL normal_close)
 404 {
 405         if(fsp->is_directory)
 406                 return close_directory(fsp, normal_close);
 407         else if (fsp->is_stat)
 408                 return close_stat(fsp);
 409         else
 410                 return close_normal_file(fsp, normal_close);
 411 }