source3/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                         message_send_pid(e->pid, MSG_SMB_OPEN_RETRY,
 134                                          e, sizeof(*e), True);
 135                 }
 136         }
 137 }
 138
 139 /****************************************************************************
 140  Close a file.
 141
 142  If normal_close is 1 then this came from a normal SMBclose (or equivalent)
 143  operation otherwise it came as the result of some other operation such as
 144  the closing of the connection. In the latter case printing and
 145  magic scripts are not run.
 146 ****************************************************************************/
 147
 148 static int close_normal_file(files_struct *fsp, BOOL normal_close)
 149 {
 150         BOOL delete_file = False;
 151         connection_struct *conn = fsp->conn;
 152         int saved_errno = 0;
 153         int err = 0;
 154         int err1 = 0;
 155         struct share_mode_lock *lck;
 156
 157         remove_pending_lock_requests_by_fid(fsp);
 158
 159         if (fsp->aio_write_behind) {
 160                 /*
 161                  * If we're finishing write behind on a close we can get a write
 162                  * error here, we must remember this.
 163                  */
 164                 int ret = wait_for_aio_completion(fsp);
 165                 if (ret) {
 166                         saved_errno = ret;
 167                         err1 = -1;
 168                 }
 169         } else {
 170                 cancel_aio_by_fsp(fsp);
 171         }
 172
 173         /*
 174          * If we're flushing on a close we can get a write
 175          * error here, we must remember this.
 176          */
 177
 178         if (close_filestruct(fsp) == -1) {
 179                 saved_errno = errno;
 180                 err1 = -1;
 181         }
 182
 183         if (fsp->print_file) {
 184                 print_fsp_end(fsp, normal_close);
 185                 file_free(fsp);
 186                 return 0;
 187         }
 188
 189         /*
 190          * Lock the share entries, and determine if we should delete
 191          * on close. If so delete whilst the lock is still in effect.
 192          * This prevents race conditions with the file being created. JRA.
 193          */
 194
 195         lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, fsp->fsp_name);
 196
 197         if (lck == NULL) {
 198                 DEBUG(0, ("Could not get share mode lock\n"));
 199                 return EINVAL;
 200         }
 201
 202         if (!del_share_mode(lck, fsp)) {
 203                 DEBUG(0, ("Could not delete share entry\n"));
 204         }
 205
 206         delete_file = lck->delete_on_close;
 207
 208         if (delete_file) {
 209                 int i;
 210                 /* See if others still have the file open. If this is the
 211                  * case, then don't delete */
 212                 for (i=0; i<lck->num_share_modes; i++) {
 213                         if (is_valid_share_mode_entry(&lck->share_modes[i])) {
 214                                 delete_file = False;
 215                                 break;
 216                         }
 217                 }
 218         }
 219
 220         /* Notify any deferred opens waiting on this close. */
 221         notify_deferred_opens(lck);
 222         reply_to_oplock_break_requests(fsp);
 223
 224         /*
 225          * NT can set delete_on_close of the last open
 226          * reference to a file.
 227          */
 228
 229         if (normal_close && delete_file) {
 230                 DEBUG(5,("close_file: file %s. Delete on close was set - deleting file.\n",
 231                         fsp->fsp_name));
 232                 if(SMB_VFS_UNLINK(conn,fsp->fsp_name) != 0) {
 233                         /*
 234                          * This call can potentially fail as another smbd may have
 235                          * had the file open with delete on close set and deleted
 236                          * it when its last reference to this file went away. Hence
 237                          * we log this but not at debug level zero.
 238                          */
 239
 240                 DEBUG(5,("close_file: file %s. Delete on close was set and unlink failed \
 241 with error %s\n", fsp->fsp_name, strerror(errno) ));
 242                 }
 243                 process_pending_change_notify_queue((time_t)0);
 244         }
 245
 246         talloc_free(lck);
 247
 248         if(fsp->oplock_type)
 249                 release_file_oplock(fsp);
 250
 251         locking_close_file(fsp);
 252
 253         err = fd_close(conn, fsp);
 254
 255         /* Only save errno if fd_close failed and we don't already
 256            have an errno saved from a flush call. */
 257         if ((err1 != -1) && (err == -1)) {
 258                 saved_errno = errno;
 259         }
 260
 261         /* check for magic scripts */
 262         if (normal_close) {
 263                 check_magic(fsp,conn);
 264         }
 265
 266         /*
 267          * Ensure pending modtime is set after close.
 268          */
 269
 270         if(fsp->pending_modtime && fsp->pending_modtime_owner) {
 271                 set_filetime(conn, fsp->fsp_name, fsp->pending_modtime);
 272         } else if (fsp->last_write_time) {
 273                 set_filetime(conn, fsp->fsp_name, fsp->last_write_time);
 274         }
 275
 276         DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
 277                 conn->user,fsp->fsp_name,
 278                 conn->num_files_open,
 279                 (err == -1 || err1 == -1) ? strerror(saved_errno) : ""));
 280
 281         if (fsp->fsp_name)
 282                 string_free(&fsp->fsp_name);
 283
 284         file_free(fsp);
 285
 286         if (err == -1 || err1 == -1) {
 287                 errno = saved_errno;
 288                 return saved_errno;
 289         } else {
 290                 return 0;
 291         }
 292 }
 293
 294 /****************************************************************************
 295  Close a directory opened by an NT SMB call.
 296 ****************************************************************************/
 297
 298 static int close_directory(files_struct *fsp, BOOL normal_close)
 299 {
 300         remove_pending_change_notify_requests_by_fid(fsp);
 301
 302         /*
 303          * NT can set delete_on_close of the last open
 304          * reference to a directory also.
 305          */
 306
 307         if (normal_close &&
 308             get_delete_on_close_flag(fsp->dev, fsp->inode, fsp->fsp_name)) {
 309                 BOOL ok = rmdir_internals(fsp->conn, fsp->fsp_name);
 310                 DEBUG(5,("close_directory: %s. Delete on close was set - deleting directory %s.\n",
 311                         fsp->fsp_name, ok ? "succeeded" : "failed" ));
 312
 313                 /*
 314                  * Ensure we remove any change notify requests that would
 315                  * now fail as the directory has been deleted.
 316                  */
 317
 318                 if(ok) {
 319                         remove_pending_change_notify_requests_by_filename(fsp);
 320                 }
 321                 process_pending_change_notify_queue((time_t)0);
 322         }
 323
 324         /*
 325          * Do the code common to files and directories.
 326          */
 327         close_filestruct(fsp);
 328
 329         if (fsp->fsp_name) {
 330                 string_free(&fsp->fsp_name);
 331         }
 332
 333         file_free(fsp);
 334         return 0;
 335 }
 336
 337 /****************************************************************************
 338  Close a 'stat file' opened internally.
 339 ****************************************************************************/
 340
 341 static int close_stat(files_struct *fsp)
 342 {
 343         /*
 344          * Do the code common to files and directories.
 345          */
 346         close_filestruct(fsp);
 347
 348         if (fsp->fsp_name)
 349                 string_free(&fsp->fsp_name);
 350
 351         file_free(fsp);
 352         return 0;
 353 }
 354
 355 /****************************************************************************
 356  Close a files_struct.
 357 ****************************************************************************/
 358
 359 int close_file(files_struct *fsp, BOOL normal_close)
 360 {
 361         if(fsp->is_directory)
 362                 return close_directory(fsp, normal_close);
 363         else if (fsp->is_stat)
 364                 return close_stat(fsp);
 365         else
 366                 return close_normal_file(fsp, normal_close);
 367 }