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