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-2007.
   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 3 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, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23
  24 extern struct current_user current_user;
  25
  26 /****************************************************************************
  27  Run a file if it is a magic script.
  28 ****************************************************************************/
  29
  30 static void check_magic(files_struct *fsp,connection_struct *conn)
  31 {
  32         int ret;
  33         const char *magic_output = NULL;
  34         SMB_STRUCT_STAT st;
  35         int tmp_fd, outfd;
  36         TALLOC_CTX *ctx = NULL;
  37         const char *p;
  38
  39         if (!*lp_magicscript(SNUM(conn))) {
  40                 return;
  41         }
  42
  43         DEBUG(5,("checking magic for %s\n",fsp->fsp_name));
  44
  45         if (!(p = strrchr_m(fsp->fsp_name,'/'))) {
  46                 p = fsp->fsp_name;
  47         } else {
  48                 p++;
  49         }
  50
  51         if (!strequal(lp_magicscript(SNUM(conn)),p)) {
  52                 return;
  53         }
  54
  55         ctx = talloc_stackframe();
  56
  57         if (*lp_magicoutput(SNUM(conn))) {
  58                 magic_output = lp_magicoutput(SNUM(conn));
  59         } else {
  60                 magic_output = talloc_asprintf(ctx,
  61                                 "%s.out",
  62                                 fsp->fsp_name);
  63         }
  64         if (!magic_output) {
  65                 TALLOC_FREE(ctx);
  66                 return;
  67         }
  68
  69         chmod(fsp->fsp_name,0755);
  70         ret = smbrun(fsp->fsp_name,&tmp_fd);
  71         DEBUG(3,("Invoking magic command %s gave %d\n",
  72                 fsp->fsp_name,ret));
  73
  74         unlink(fsp->fsp_name);
  75         if (ret != 0 || tmp_fd == -1) {
  76                 if (tmp_fd != -1) {
  77                         close(tmp_fd);
  78                 }
  79                 TALLOC_FREE(ctx);
  80                 return;
  81         }
  82         outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
  83         if (outfd == -1) {
  84                 close(tmp_fd);
  85                 TALLOC_FREE(ctx);
  86                 return;
  87         }
  88
  89         if (sys_fstat(tmp_fd,&st) == -1) {
  90                 close(tmp_fd);
  91                 close(outfd);
  92                 return;
  93         }
  94
  95         transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_size);
  96         close(tmp_fd);
  97         close(outfd);
  98         TALLOC_FREE(ctx);
  99 }
 100
 101 /****************************************************************************
 102   Common code to close a file or a directory.
 103 ****************************************************************************/
 104
 105 static NTSTATUS close_filestruct(files_struct *fsp)
 106 {
 107         NTSTATUS status = NT_STATUS_OK;
 108         connection_struct *conn = fsp->conn;
 109
 110         if (fsp->fh->fd != -1) {
 111                 if(flush_write_cache(fsp, CLOSE_FLUSH) == -1) {
 112                         status = map_nt_error_from_unix(errno);
 113                 }
 114                 delete_write_cache(fsp);
 115         }
 116
 117         conn->num_files_open--;
 118         return status;
 119 }
 120
 121 /****************************************************************************
 122  If any deferred opens are waiting on this close, notify them.
 123 ****************************************************************************/
 124
 125 static void notify_deferred_opens(struct share_mode_lock *lck)
 126 {
 127         int i;
 128
 129         for (i=0; i<lck->num_share_modes; i++) {
 130                 struct share_mode_entry *e = &lck->share_modes[i];
 131
 132                 if (!is_deferred_open_entry(e)) {
 133                         continue;
 134                 }
 135
 136                 if (procid_is_me(&e->pid)) {
 137                         /*
 138                          * We need to notify ourself to retry the open.  Do
 139                          * this by finding the queued SMB record, moving it to
 140                          * the head of the queue and changing the wait time to
 141                          * zero.
 142                          */
 143                         schedule_deferred_open_smb_message(e->op_mid);
 144                 } else {
 145                         char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
 146
 147                         share_mode_entry_to_message(msg, e);
 148
 149                         messaging_send_buf(smbd_messaging_context(),
 150                                            e->pid, MSG_SMB_OPEN_RETRY,
 151                                            (uint8 *)msg,
 152                                            MSG_SMB_SHARE_MODE_ENTRY_SIZE);
 153                 }
 154         }
 155 }
 156
 157 /****************************************************************************
 158  Deal with removing a share mode on last close.
 159 ****************************************************************************/
 160
 161 static NTSTATUS close_remove_share_mode(files_struct *fsp,
 162                                         enum file_close_type close_type)
 163 {
 164         connection_struct *conn = fsp->conn;
 165         BOOL delete_file = False;
 166         struct share_mode_lock *lck;
 167         SMB_STRUCT_STAT sbuf;
 168         NTSTATUS status = NT_STATUS_OK;
 169         int ret;
 170         struct file_id id;
 171
 172         /*
 173          * Lock the share entries, and determine if we should delete
 174          * on close. If so delete whilst the lock is still in effect.
 175          * This prevents race conditions with the file being created. JRA.
 176          */
 177
 178         lck = get_share_mode_lock(NULL, fsp->file_id, NULL, NULL);
 179
 180         if (lck == NULL) {
 181                 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
 182                           "lock for file %s\n", fsp->fsp_name));
 183                 return NT_STATUS_INVALID_PARAMETER;
 184         }
 185
 186         if (!del_share_mode(lck, fsp)) {
 187                 DEBUG(0, ("close_remove_share_mode: Could not delete share "
 188                           "entry for file %s\n", fsp->fsp_name));
 189         }
 190
 191         if (fsp->initial_delete_on_close && (lck->delete_token == NULL)) {
 192                 BOOL became_user = False;
 193
 194                 /* Initial delete on close was set and no one else
 195                  * wrote a real delete on close. */
 196
 197                 if (current_user.vuid != fsp->vuid) {
 198                         become_user(conn, fsp->vuid);
 199                         became_user = True;
 200                 }
 201                 set_delete_on_close_lck(lck, True, &current_user.ut);
 202                 if (became_user) {
 203                         unbecome_user();
 204                 }
 205         }
 206
 207         delete_file = lck->delete_on_close;
 208
 209         if (delete_file) {
 210                 int i;
 211                 /* See if others still have the file open. If this is the
 212                  * case, then don't delete. If all opens are POSIX delete now. */
 213                 for (i=0; i<lck->num_share_modes; i++) {
 214                         struct share_mode_entry *e = &lck->share_modes[i];
 215                         if (is_valid_share_mode_entry(e)) {
 216                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
 217                                         continue;
 218                                 }
 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 == NULL)) {
 237                 TALLOC_FREE(lck);
 238                 return NT_STATUS_OK;
 239         }
 240
 241         /*
 242          * Ok, we have to delete the file
 243          */
 244
 245         DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
 246                  "- deleting file.\n", fsp->fsp_name));
 247
 248         /* Become the user who requested the delete. */
 249
 250         if (!push_sec_ctx()) {
 251                 smb_panic("close_remove_share_mode: file %s. failed to push "
 252                           "sec_ctx.\n");
 253         }
 254
 255         set_sec_ctx(lck->delete_token->uid,
 256                     lck->delete_token->gid,
 257                     lck->delete_token->ngroups,
 258                     lck->delete_token->groups,
 259                     NULL);
 260
 261         /* We can only delete the file if the name we have is still valid and
 262            hasn't been renamed. */
 263
 264         if (fsp->posix_open) {
 265                 ret = SMB_VFS_LSTAT(conn,fsp->fsp_name,&sbuf);
 266         } else {
 267                 ret = SMB_VFS_STAT(conn,fsp->fsp_name,&sbuf);
 268         }
 269
 270         if (ret != 0) {
 271                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 272                          "was set and stat failed with error %s\n",
 273                          fsp->fsp_name, strerror(errno) ));
 274                 /*
 275                  * Don't save the errno here, we ignore this error
 276                  */
 277                 goto done;
 278         }
 279
 280         id = vfs_file_id_from_sbuf(conn, &sbuf);
 281
 282         if (!file_id_equal(&fsp->file_id, &id)) {
 283                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 284                          "was set and dev and/or inode does not match\n",
 285                          fsp->fsp_name ));
 286                 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
 287                          "stat file_id %s\n",
 288                          fsp->fsp_name,
 289                          file_id_string_tos(&fsp->file_id),
 290                          file_id_string_tos(&id)));
 291                 /*
 292                  * Don't save the errno here, we ignore this error
 293                  */
 294                 goto done;
 295         }
 296
 297         if (SMB_VFS_UNLINK(conn,fsp->fsp_name) != 0) {
 298                 /*
 299                  * This call can potentially fail as another smbd may
 300                  * have had the file open with delete on close set and
 301                  * deleted it when its last reference to this file
 302                  * went away. Hence we log this but not at debug level
 303                  * zero.
 304                  */
 305
 306                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 307                          "was set and unlink failed with error %s\n",
 308                          fsp->fsp_name, strerror(errno) ));
 309
 310                 status = map_nt_error_from_unix(errno);
 311         }
 312
 313         notify_fname(conn, NOTIFY_ACTION_REMOVED,
 314                      FILE_NOTIFY_CHANGE_FILE_NAME,
 315                      fsp->fsp_name);
 316
 317         /* As we now have POSIX opens which can unlink
 318          * with other open files we may have taken
 319          * this code path with more than one share mode
 320          * entry - ensure we only delete once by resetting
 321          * the delete on close flag. JRA.
 322          */
 323
 324         set_delete_on_close_lck(lck, False, NULL);
 325
 326  done:
 327
 328         /* unbecome user. */
 329         pop_sec_ctx();
 330
 331         TALLOC_FREE(lck);
 332         return status;
 333 }
 334
 335 /****************************************************************************
 336  Close a file.
 337
 338  close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
 339  printing and magic scripts are only run on normal close.
 340  delete on close is done on normal and shutdown close.
 341 ****************************************************************************/
 342
 343 static NTSTATUS close_normal_file(files_struct *fsp, enum file_close_type close_type)
 344 {
 345         NTSTATUS status = NT_STATUS_OK;
 346         NTSTATUS saved_status1 = NT_STATUS_OK;
 347         NTSTATUS saved_status2 = NT_STATUS_OK;
 348         connection_struct *conn = fsp->conn;
 349
 350         cancel_aio_by_fsp(fsp);
 351
 352         /*
 353          * If we're flushing on a close we can get a write
 354          * error here, we must remember this.
 355          */
 356
 357         saved_status1 = close_filestruct(fsp);
 358
 359         if (fsp->print_file) {
 360                 print_fsp_end(fsp, close_type);
 361                 file_free(fsp);
 362                 return NT_STATUS_OK;
 363         }
 364
 365         /* If this is an old DOS or FCB open and we have multiple opens on
 366            the same handle we only have one share mode. Ensure we only remove
 367            the share mode on the last close. */
 368
 369         if (fsp->fh->ref_count == 1) {
 370                 /* Should we return on error here... ? */
 371                 saved_status2 = close_remove_share_mode(fsp, close_type);
 372         }
 373
 374         if(fsp->oplock_type) {
 375                 release_file_oplock(fsp);
 376         }
 377
 378         locking_close_file(smbd_messaging_context(), fsp);
 379
 380         status = fd_close(conn, fsp);
 381
 382         /* check for magic scripts */
 383         if (close_type == NORMAL_CLOSE) {
 384                 check_magic(fsp,conn);
 385         }
 386
 387         /*
 388          * Ensure pending modtime is set after close.
 389          */
 390
 391         if (fsp->pending_modtime_owner && !null_timespec(fsp->pending_modtime)) {
 392                 set_filetime(conn, fsp->fsp_name, fsp->pending_modtime);
 393         } else if (!null_timespec(fsp->last_write_time)) {
 394                 set_filetime(conn, fsp->fsp_name, fsp->last_write_time);
 395         }
 396
 397         if (NT_STATUS_IS_OK(status)) {
 398                 if (!NT_STATUS_IS_OK(saved_status1)) {
 399                         status = saved_status1;
 400                 } else if (!NT_STATUS_IS_OK(saved_status2)) {
 401                         status = saved_status2;
 402                 }
 403         }
 404
 405         DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
 406                 conn->user,fsp->fsp_name,
 407                 conn->num_files_open,
 408                 nt_errstr(status) ));
 409
 410         file_free(fsp);
 411         return status;
 412 }
 413
 414 /****************************************************************************
 415  Close a directory opened by an NT SMB call.
 416 ****************************************************************************/
 417
 418 static NTSTATUS close_directory(files_struct *fsp, enum file_close_type close_type)
 419 {
 420         struct share_mode_lock *lck = 0;
 421         BOOL delete_dir = False;
 422         NTSTATUS status = NT_STATUS_OK;
 423
 424         /*
 425          * NT can set delete_on_close of the last open
 426          * reference to a directory also.
 427          */
 428
 429         lck = get_share_mode_lock(NULL, fsp->file_id, NULL, NULL);
 430
 431         if (lck == NULL) {
 432                 DEBUG(0, ("close_directory: Could not get share mode lock for %s\n", fsp->fsp_name));
 433                 return NT_STATUS_INVALID_PARAMETER;
 434         }
 435
 436         if (!del_share_mode(lck, fsp)) {
 437                 DEBUG(0, ("close_directory: Could not delete share entry for %s\n", fsp->fsp_name));
 438         }
 439
 440         if (fsp->initial_delete_on_close) {
 441                 BOOL became_user = False;
 442
 443                 /* Initial delete on close was set - for
 444                  * directories we don't care if anyone else
 445                  * wrote a real delete on close. */
 446
 447                 if (current_user.vuid != fsp->vuid) {
 448                         become_user(fsp->conn, fsp->vuid);
 449                         became_user = True;
 450                 }
 451                 send_stat_cache_delete_message(fsp->fsp_name);
 452                 set_delete_on_close_lck(lck, True, &current_user.ut);
 453                 if (became_user) {
 454                         unbecome_user();
 455                 }
 456         }
 457
 458         delete_dir = lck->delete_on_close;
 459
 460         if (delete_dir) {
 461                 int i;
 462                 /* See if others still have the dir open. If this is the
 463                  * case, then don't delete. If all opens are POSIX delete now. */
 464                 for (i=0; i<lck->num_share_modes; i++) {
 465                         struct share_mode_entry *e = &lck->share_modes[i];
 466                         if (is_valid_share_mode_entry(e)) {
 467                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
 468                                         continue;
 469                                 }
 470                                 delete_dir = False;
 471                                 break;
 472                         }
 473                 }
 474         }
 475
 476         if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
 477                                 delete_dir &&
 478                                 lck->delete_token) {
 479
 480                 /* Become the user who requested the delete. */
 481
 482                 if (!push_sec_ctx()) {
 483                         smb_panic("close_directory: failed to push sec_ctx.\n");
 484                 }
 485
 486                 set_sec_ctx(lck->delete_token->uid,
 487                                 lck->delete_token->gid,
 488                                 lck->delete_token->ngroups,
 489                                 lck->delete_token->groups,
 490                                 NULL);
 491
 492                 TALLOC_FREE(lck);
 493
 494                 status = rmdir_internals(talloc_tos(),
 495                                 fsp->conn, fsp->fsp_name);
 496
 497                 DEBUG(5,("close_directory: %s. Delete on close was set - "
 498                          "deleting directory returned %s.\n",
 499                          fsp->fsp_name, nt_errstr(status)));
 500
 501                 /* unbecome user. */
 502                 pop_sec_ctx();
 503
 504                 /*
 505                  * Ensure we remove any change notify requests that would
 506                  * now fail as the directory has been deleted.
 507                  */
 508
 509                 if(NT_STATUS_IS_OK(status)) {
 510                         remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING);
 511                 }
 512         } else {
 513                 TALLOC_FREE(lck);
 514                 remove_pending_change_notify_requests_by_fid(
 515                         fsp, NT_STATUS_OK);
 516         }
 517
 518         /*
 519          * Do the code common to files and directories.
 520          */
 521         close_filestruct(fsp);
 522         file_free(fsp);
 523         return status;
 524 }
 525
 526 /****************************************************************************
 527  Close a 'stat file' opened internally.
 528 ****************************************************************************/
 529
 530 NTSTATUS close_stat(files_struct *fsp)
 531 {
 532         /*
 533          * Do the code common to files and directories.
 534          */
 535         close_filestruct(fsp);
 536         file_free(fsp);
 537         return NT_STATUS_OK;
 538 }
 539
 540 /****************************************************************************
 541  Close a files_struct.
 542 ****************************************************************************/
 543
 544 NTSTATUS close_file(files_struct *fsp, enum file_close_type close_type)
 545 {
 546         if(fsp->is_directory) {
 547                 return close_directory(fsp, close_type);
 548         } else if (fsp->is_stat) {
 549                 return close_stat(fsp);
 550         } else if (fsp->fake_file_handle != NULL) {
 551                 return close_fake_file(fsp);
 552         }
 553         return close_normal_file(fsp, close_type);
 554 }