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