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(struct files_struct *fsp)
  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         struct connection_struct *conn = fsp->conn;
  39
  40         if (!*lp_magicscript(SNUM(conn))) {
  41                 return;
  42         }
  43
  44         DEBUG(5,("checking magic for %s\n",fsp->fsp_name));
  45
  46         if (!(p = strrchr_m(fsp->fsp_name,'/'))) {
  47                 p = fsp->fsp_name;
  48         } else {
  49                 p++;
  50         }
  51
  52         if (!strequal(lp_magicscript(SNUM(conn)),p)) {
  53                 return;
  54         }
  55
  56         ctx = talloc_stackframe();
  57
  58         if (*lp_magicoutput(SNUM(conn))) {
  59                 magic_output = lp_magicoutput(SNUM(conn));
  60         } else {
  61                 magic_output = talloc_asprintf(ctx,
  62                                 "%s.out",
  63                                 fsp->fsp_name);
  64         }
  65         if (!magic_output) {
  66                 TALLOC_FREE(ctx);
  67                 return;
  68         }
  69
  70         chmod(fsp->fsp_name,0755);
  71         ret = smbrun(fsp->fsp_name,&tmp_fd);
  72         DEBUG(3,("Invoking magic command %s gave %d\n",
  73                 fsp->fsp_name,ret));
  74
  75         unlink(fsp->fsp_name);
  76         if (ret != 0 || tmp_fd == -1) {
  77                 if (tmp_fd != -1) {
  78                         close(tmp_fd);
  79                 }
  80                 TALLOC_FREE(ctx);
  81                 return;
  82         }
  83         outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
  84         if (outfd == -1) {
  85                 close(tmp_fd);
  86                 TALLOC_FREE(ctx);
  87                 return;
  88         }
  89
  90         if (sys_fstat(tmp_fd,&st) == -1) {
  91                 close(tmp_fd);
  92                 close(outfd);
  93                 return;
  94         }
  95
  96         transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_size);
  97         close(tmp_fd);
  98         close(outfd);
  99         TALLOC_FREE(ctx);
 100 }
 101
 102 /****************************************************************************
 103   Common code to close a file or a directory.
 104 ****************************************************************************/
 105
 106 static NTSTATUS close_filestruct(files_struct *fsp)
 107 {
 108         NTSTATUS status = NT_STATUS_OK;
 109         connection_struct *conn = fsp->conn;
 110
 111         if (fsp->fh->fd != -1) {
 112                 if(flush_write_cache(fsp, CLOSE_FLUSH) == -1) {
 113                         status = map_nt_error_from_unix(errno);
 114                 }
 115                 delete_write_cache(fsp);
 116         }
 117
 118         conn->num_files_open--;
 119         return status;
 120 }
 121
 122 /****************************************************************************
 123  If any deferred opens are waiting on this close, notify them.
 124 ****************************************************************************/
 125
 126 static void notify_deferred_opens(struct share_mode_lock *lck)
 127 {
 128         int i;
 129
 130         for (i=0; i<lck->num_share_modes; i++) {
 131                 struct share_mode_entry *e = &lck->share_modes[i];
 132
 133                 if (!is_deferred_open_entry(e)) {
 134                         continue;
 135                 }
 136
 137                 if (procid_is_me(&e->pid)) {
 138                         /*
 139                          * We need to notify ourself to retry the open.  Do
 140                          * this by finding the queued SMB record, moving it to
 141                          * the head of the queue and changing the wait time to
 142                          * zero.
 143                          */
 144                         schedule_deferred_open_smb_message(e->op_mid);
 145                 } else {
 146                         char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
 147
 148                         share_mode_entry_to_message(msg, e);
 149
 150                         messaging_send_buf(smbd_messaging_context(),
 151                                            e->pid, MSG_SMB_OPEN_RETRY,
 152                                            (uint8 *)msg,
 153                                            MSG_SMB_SHARE_MODE_ENTRY_SIZE);
 154                 }
 155         }
 156 }
 157
 158 /****************************************************************************
 159  Delete all streams
 160 ****************************************************************************/
 161
 162 static NTSTATUS delete_all_streams(connection_struct *conn, const char *fname)
 163 {
 164         struct stream_struct *stream_info;
 165         int i;
 166         unsigned int num_streams;
 167         TALLOC_CTX *frame = talloc_stackframe();
 168         NTSTATUS status;
 169
 170         status = SMB_VFS_STREAMINFO(conn, NULL, fname, talloc_tos(),
 171                                     &num_streams, &stream_info);
 172
 173         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
 174                 DEBUG(10, ("no streams around\n"));
 175                 TALLOC_FREE(frame);
 176                 return NT_STATUS_OK;
 177         }
 178
 179         if (!NT_STATUS_IS_OK(status)) {
 180                 DEBUG(10, ("SMB_VFS_STREAMINFO failed: %s\n",
 181                            nt_errstr(status)));
 182                 goto fail;
 183         }
 184
 185         DEBUG(10, ("delete_all_streams found %d streams\n",
 186                    num_streams));
 187
 188         if (num_streams == 0) {
 189                 TALLOC_FREE(frame);
 190                 return NT_STATUS_OK;
 191         }
 192
 193         for (i=0; i<num_streams; i++) {
 194                 int res;
 195                 char *streamname;
 196
 197                 if (strequal(stream_info[i].name, "::$DATA")) {
 198                         continue;
 199                 }
 200
 201                 streamname = talloc_asprintf(talloc_tos(), "%s%s", fname,
 202                                              stream_info[i].name);
 203
 204                 if (streamname == NULL) {
 205                         DEBUG(0, ("talloc_aprintf failed\n"));
 206                         status = NT_STATUS_NO_MEMORY;
 207                         goto fail;
 208                 }
 209
 210                 res = SMB_VFS_UNLINK(conn, streamname);
 211
 212                 TALLOC_FREE(streamname);
 213
 214                 if (res == -1) {
 215                         status = map_nt_error_from_unix(errno);
 216                         DEBUG(10, ("Could not delete stream %s: %s\n",
 217                                    streamname, strerror(errno)));
 218                         break;
 219                 }
 220         }
 221
 222  fail:
 223         TALLOC_FREE(frame);
 224         return status;
 225 }
 226
 227 /****************************************************************************
 228  Deal with removing a share mode on last close.
 229 ****************************************************************************/
 230
 231 static NTSTATUS close_remove_share_mode(files_struct *fsp,
 232                                         enum file_close_type close_type)
 233 {
 234         connection_struct *conn = fsp->conn;
 235         bool delete_file = false;
 236         bool changed_user = false;
 237         struct share_mode_lock *lck;
 238         SMB_STRUCT_STAT sbuf;
 239         NTSTATUS status = NT_STATUS_OK;
 240         int ret;
 241         struct file_id id;
 242
 243         /*
 244          * Lock the share entries, and determine if we should delete
 245          * on close. If so delete whilst the lock is still in effect.
 246          * This prevents race conditions with the file being created. JRA.
 247          */
 248
 249         lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL);
 250
 251         if (lck == NULL) {
 252                 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
 253                           "lock for file %s\n", fsp->fsp_name));
 254                 return NT_STATUS_INVALID_PARAMETER;
 255         }
 256
 257         if (!del_share_mode(lck, fsp)) {
 258                 DEBUG(0, ("close_remove_share_mode: Could not delete share "
 259                           "entry for file %s\n", fsp->fsp_name));
 260         }
 261
 262         if (fsp->initial_delete_on_close && (lck->delete_token == NULL)) {
 263                 bool became_user = False;
 264
 265                 /* Initial delete on close was set and no one else
 266                  * wrote a real delete on close. */
 267
 268                 if (current_user.vuid != fsp->vuid) {
 269                         become_user(conn, fsp->vuid);
 270                         became_user = True;
 271                 }
 272                 set_delete_on_close_lck(lck, True, &current_user.ut);
 273                 if (became_user) {
 274                         unbecome_user();
 275                 }
 276         }
 277
 278         delete_file = lck->delete_on_close;
 279
 280         if (delete_file) {
 281                 int i;
 282                 /* See if others still have the file open. If this is the
 283                  * case, then don't delete. If all opens are POSIX delete now. */
 284                 for (i=0; i<lck->num_share_modes; i++) {
 285                         struct share_mode_entry *e = &lck->share_modes[i];
 286                         if (is_valid_share_mode_entry(e)) {
 287                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
 288                                         continue;
 289                                 }
 290                                 delete_file = False;
 291                                 break;
 292                         }
 293                 }
 294         }
 295
 296         /* Notify any deferred opens waiting on this close. */
 297         notify_deferred_opens(lck);
 298         reply_to_oplock_break_requests(fsp);
 299
 300         /*
 301          * NT can set delete_on_close of the last open
 302          * reference to a file.
 303          */
 304
 305         if (!(close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE)
 306             || !delete_file
 307             || (lck->delete_token == NULL)) {
 308                 TALLOC_FREE(lck);
 309                 return NT_STATUS_OK;
 310         }
 311
 312         /*
 313          * Ok, we have to delete the file
 314          */
 315
 316         DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
 317                  "- deleting file.\n", fsp->fsp_name));
 318
 319         if (!unix_token_equal(lck->delete_token, &current_user.ut)) {
 320                 /* Become the user who requested the delete. */
 321
 322                 DEBUG(5,("close_remove_share_mode: file %s. "
 323                         "Change user to uid %u\n",
 324                         fsp->fsp_name,
 325                         (unsigned int)lck->delete_token->uid));
 326
 327                 if (!push_sec_ctx()) {
 328                         smb_panic("close_remove_share_mode: file %s. failed to push "
 329                                   "sec_ctx.\n");
 330                 }
 331
 332                 set_sec_ctx(lck->delete_token->uid,
 333                             lck->delete_token->gid,
 334                             lck->delete_token->ngroups,
 335                             lck->delete_token->groups,
 336                             NULL);
 337
 338                 changed_user = true;
 339         }
 340
 341         /* We can only delete the file if the name we have is still valid and
 342            hasn't been renamed. */
 343
 344         if (fsp->posix_open) {
 345                 ret = SMB_VFS_LSTAT(conn,fsp->fsp_name,&sbuf);
 346         } else {
 347                 ret = SMB_VFS_STAT(conn,fsp->fsp_name,&sbuf);
 348         }
 349
 350         if (ret != 0) {
 351                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 352                          "was set and stat failed with error %s\n",
 353                          fsp->fsp_name, strerror(errno) ));
 354                 /*
 355                  * Don't save the errno here, we ignore this error
 356                  */
 357                 goto done;
 358         }
 359
 360         id = vfs_file_id_from_sbuf(conn, &sbuf);
 361
 362         if (!file_id_equal(&fsp->file_id, &id)) {
 363                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 364                          "was set and dev and/or inode does not match\n",
 365                          fsp->fsp_name ));
 366                 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
 367                          "stat file_id %s\n",
 368                          fsp->fsp_name,
 369                          file_id_string_tos(&fsp->file_id),
 370                          file_id_string_tos(&id)));
 371                 /*
 372                  * Don't save the errno here, we ignore this error
 373                  */
 374                 goto done;
 375         }
 376
 377         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
 378             && !is_ntfs_stream_name(fsp->fsp_name)) {
 379
 380                 status = delete_all_streams(conn, fsp->fsp_name);
 381
 382                 if (!NT_STATUS_IS_OK(status)) {
 383                         DEBUG(5, ("delete_all_streams failed: %s\n",
 384                                   nt_errstr(status)));
 385                         goto done;
 386                 }
 387         }
 388
 389
 390         if (SMB_VFS_UNLINK(conn,fsp->fsp_name) != 0) {
 391                 /*
 392                  * This call can potentially fail as another smbd may
 393                  * have had the file open with delete on close set and
 394                  * deleted it when its last reference to this file
 395                  * went away. Hence we log this but not at debug level
 396                  * zero.
 397                  */
 398
 399                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 400                          "was set and unlink failed with error %s\n",
 401                          fsp->fsp_name, strerror(errno) ));
 402
 403                 status = map_nt_error_from_unix(errno);
 404         }
 405
 406         notify_fname(conn, NOTIFY_ACTION_REMOVED,
 407                      FILE_NOTIFY_CHANGE_FILE_NAME,
 408                      fsp->fsp_name);
 409
 410         /* As we now have POSIX opens which can unlink
 411          * with other open files we may have taken
 412          * this code path with more than one share mode
 413          * entry - ensure we only delete once by resetting
 414          * the delete on close flag. JRA.
 415          */
 416
 417         set_delete_on_close_lck(lck, False, NULL);
 418
 419  done:
 420
 421         if (changed_user) {
 422                 /* unbecome user. */
 423                 pop_sec_ctx();
 424         }
 425
 426         TALLOC_FREE(lck);
 427         return status;
 428 }
 429
 430 /****************************************************************************
 431  Close a file.
 432
 433  close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
 434  printing and magic scripts are only run on normal close.
 435  delete on close is done on normal and shutdown close.
 436 ****************************************************************************/
 437
 438 static NTSTATUS close_normal_file(files_struct *fsp, enum file_close_type close_type)
 439 {
 440         NTSTATUS status = NT_STATUS_OK;
 441         NTSTATUS saved_status1 = NT_STATUS_OK;
 442         NTSTATUS saved_status2 = NT_STATUS_OK;
 443         NTSTATUS saved_status3 = NT_STATUS_OK;
 444         connection_struct *conn = fsp->conn;
 445
 446         if (fsp->aio_write_behind) {
 447                 /*
 448                  * If we're finishing write behind on a close we can get a write
 449                  * error here, we must remember this.
 450                  */
 451                 int ret = wait_for_aio_completion(fsp);
 452                 if (ret) {
 453                         saved_status1 = map_nt_error_from_unix(ret);
 454                 }
 455         } else {
 456                 cancel_aio_by_fsp(fsp);
 457         }
 458
 459         /*
 460          * If we're flushing on a close we can get a write
 461          * error here, we must remember this.
 462          */
 463
 464         saved_status2 = close_filestruct(fsp);
 465
 466         if (fsp->print_file) {
 467                 print_fsp_end(fsp, close_type);
 468                 file_free(fsp);
 469                 return NT_STATUS_OK;
 470         }
 471
 472         /* If this is an old DOS or FCB open and we have multiple opens on
 473            the same handle we only have one share mode. Ensure we only remove
 474            the share mode on the last close. */
 475
 476         if (fsp->fh->ref_count == 1) {
 477                 /* Should we return on error here... ? */
 478                 saved_status3 = close_remove_share_mode(fsp, close_type);
 479         }
 480
 481         if(fsp->oplock_type) {
 482                 release_file_oplock(fsp);
 483         }
 484
 485         locking_close_file(smbd_messaging_context(), fsp);
 486
 487         status = fd_close(fsp);
 488
 489         /* check for magic scripts */
 490         if (close_type == NORMAL_CLOSE) {
 491                 check_magic(fsp);
 492         }
 493
 494         /*
 495          * Ensure pending modtime is set after close.
 496          */
 497
 498         if (fsp->pending_modtime_owner && !null_timespec(fsp->pending_modtime)) {
 499                 set_filetime(conn, fsp->fsp_name, fsp->pending_modtime);
 500         } else if (!null_timespec(fsp->last_write_time)) {
 501                 set_filetime(conn, fsp->fsp_name, fsp->last_write_time);
 502         }
 503
 504         if (NT_STATUS_IS_OK(status)) {
 505                 if (!NT_STATUS_IS_OK(saved_status1)) {
 506                         status = saved_status1;
 507                 } else if (!NT_STATUS_IS_OK(saved_status2)) {
 508                         status = saved_status2;
 509                 } else if (!NT_STATUS_IS_OK(saved_status3)) {
 510                         status = saved_status3;
 511                 }
 512         }
 513
 514         DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
 515                 conn->user,fsp->fsp_name,
 516                 conn->num_files_open,
 517                 nt_errstr(status) ));
 518
 519         file_free(fsp);
 520         return status;
 521 }
 522
 523 /****************************************************************************
 524  Close a directory opened by an NT SMB call.
 525 ****************************************************************************/
 526
 527 static NTSTATUS close_directory(files_struct *fsp, enum file_close_type close_type)
 528 {
 529         struct share_mode_lock *lck = 0;
 530         bool delete_dir = False;
 531         NTSTATUS status = NT_STATUS_OK;
 532
 533         /*
 534          * NT can set delete_on_close of the last open
 535          * reference to a directory also.
 536          */
 537
 538         lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL);
 539
 540         if (lck == NULL) {
 541                 DEBUG(0, ("close_directory: Could not get share mode lock for %s\n", fsp->fsp_name));
 542                 return NT_STATUS_INVALID_PARAMETER;
 543         }
 544
 545         if (!del_share_mode(lck, fsp)) {
 546                 DEBUG(0, ("close_directory: Could not delete share entry for %s\n", fsp->fsp_name));
 547         }
 548
 549         if (fsp->initial_delete_on_close) {
 550                 bool became_user = False;
 551
 552                 /* Initial delete on close was set - for
 553                  * directories we don't care if anyone else
 554                  * wrote a real delete on close. */
 555
 556                 if (current_user.vuid != fsp->vuid) {
 557                         become_user(fsp->conn, fsp->vuid);
 558                         became_user = True;
 559                 }
 560                 send_stat_cache_delete_message(fsp->fsp_name);
 561                 set_delete_on_close_lck(lck, True, &current_user.ut);
 562                 if (became_user) {
 563                         unbecome_user();
 564                 }
 565         }
 566
 567         delete_dir = lck->delete_on_close;
 568
 569         if (delete_dir) {
 570                 int i;
 571                 /* See if others still have the dir open. If this is the
 572                  * case, then don't delete. If all opens are POSIX delete now. */
 573                 for (i=0; i<lck->num_share_modes; i++) {
 574                         struct share_mode_entry *e = &lck->share_modes[i];
 575                         if (is_valid_share_mode_entry(e)) {
 576                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
 577                                         continue;
 578                                 }
 579                                 delete_dir = False;
 580                                 break;
 581                         }
 582                 }
 583         }
 584
 585         if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
 586                                 delete_dir &&
 587                                 lck->delete_token) {
 588
 589                 /* Become the user who requested the delete. */
 590
 591                 if (!push_sec_ctx()) {
 592                         smb_panic("close_directory: failed to push sec_ctx.\n");
 593                 }
 594
 595                 set_sec_ctx(lck->delete_token->uid,
 596                                 lck->delete_token->gid,
 597                                 lck->delete_token->ngroups,
 598                                 lck->delete_token->groups,
 599                                 NULL);
 600
 601                 TALLOC_FREE(lck);
 602
 603                 status = rmdir_internals(talloc_tos(),
 604                                 fsp->conn, fsp->fsp_name);
 605
 606                 DEBUG(5,("close_directory: %s. Delete on close was set - "
 607                          "deleting directory returned %s.\n",
 608                          fsp->fsp_name, nt_errstr(status)));
 609
 610                 /* unbecome user. */
 611                 pop_sec_ctx();
 612
 613                 /*
 614                  * Ensure we remove any change notify requests that would
 615                  * now fail as the directory has been deleted.
 616                  */
 617
 618                 if(NT_STATUS_IS_OK(status)) {
 619                         remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING);
 620                 }
 621         } else {
 622                 TALLOC_FREE(lck);
 623                 remove_pending_change_notify_requests_by_fid(
 624                         fsp, NT_STATUS_OK);
 625         }
 626
 627         /*
 628          * Do the code common to files and directories.
 629          */
 630         close_filestruct(fsp);
 631         file_free(fsp);
 632         return status;
 633 }
 634
 635 /****************************************************************************
 636  Close a 'stat file' opened internally.
 637 ****************************************************************************/
 638
 639 static NTSTATUS close_stat(files_struct *fsp)
 640 {
 641         /*
 642          * Do the code common to files and directories.
 643          */
 644         close_filestruct(fsp);
 645         file_free(fsp);
 646         return NT_STATUS_OK;
 647 }
 648
 649 /****************************************************************************
 650  Close a files_struct.
 651 ****************************************************************************/
 652
 653 NTSTATUS close_file(files_struct *fsp, enum file_close_type close_type)
 654 {
 655         NTSTATUS status;
 656         struct files_struct *base_fsp = fsp->base_fsp;
 657
 658         if(fsp->is_directory) {
 659                 status = close_directory(fsp, close_type);
 660         } else if (fsp->is_stat) {
 661                 status = close_stat(fsp);
 662         } else if (fsp->fake_file_handle != NULL) {
 663                 status = close_fake_file(fsp);
 664         } else {
 665                 status = close_normal_file(fsp, close_type);
 666         }
 667
 668         if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) {
 669
 670                 /*
 671                  * fsp was a stream, the base fsp can't be a stream as well
 672                  *
 673                  * For SHUTDOWN_CLOSE this is not possible here, because
 674                  * SHUTDOWN_CLOSE only happens from files.c which walks the
 675                  * complete list of files. If we mess with more than one fsp
 676                  * those loops will become confused.
 677                  */
 678
 679                 SMB_ASSERT(base_fsp->base_fsp == NULL);
 680                 close_file(base_fsp, close_type);
 681         }
 682
 683         return status;
 684 }