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-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                                   NULL);
 251
 252         if (lck == NULL) {
 253                 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
 254                           "lock for file %s\n", fsp->fsp_name));
 255                 return NT_STATUS_INVALID_PARAMETER;
 256         }
 257
 258         if (!del_share_mode(lck, fsp)) {
 259                 DEBUG(0, ("close_remove_share_mode: Could not delete share "
 260                           "entry for file %s\n", fsp->fsp_name));
 261         }
 262
 263         if (fsp->initial_delete_on_close && (lck->delete_token == NULL)) {
 264                 bool became_user = False;
 265
 266                 /* Initial delete on close was set and no one else
 267                  * wrote a real delete on close. */
 268
 269                 if (current_user.vuid != fsp->vuid) {
 270                         become_user(conn, fsp->vuid);
 271                         became_user = True;
 272                 }
 273                 set_delete_on_close_lck(lck, True, &current_user.ut);
 274                 if (became_user) {
 275                         unbecome_user();
 276                 }
 277         }
 278
 279         delete_file = lck->delete_on_close;
 280
 281         if (delete_file) {
 282                 int i;
 283                 /* See if others still have the file open. If this is the
 284                  * case, then don't delete. If all opens are POSIX delete now. */
 285                 for (i=0; i<lck->num_share_modes; i++) {
 286                         struct share_mode_entry *e = &lck->share_modes[i];
 287                         if (is_valid_share_mode_entry(e)) {
 288                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
 289                                         continue;
 290                                 }
 291                                 delete_file = False;
 292                                 break;
 293                         }
 294                 }
 295         }
 296
 297         /* Notify any deferred opens waiting on this close. */
 298         notify_deferred_opens(lck);
 299         reply_to_oplock_break_requests(fsp);
 300
 301         /*
 302          * NT can set delete_on_close of the last open
 303          * reference to a file.
 304          */
 305
 306         if (!(close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE)
 307             || !delete_file
 308             || (lck->delete_token == NULL)) {
 309                 TALLOC_FREE(lck);
 310                 return NT_STATUS_OK;
 311         }
 312
 313         /*
 314          * Ok, we have to delete the file
 315          */
 316
 317         DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
 318                  "- deleting file.\n", fsp->fsp_name));
 319
 320         if (!unix_token_equal(lck->delete_token, &current_user.ut)) {
 321                 /* Become the user who requested the delete. */
 322
 323                 DEBUG(5,("close_remove_share_mode: file %s. "
 324                         "Change user to uid %u\n",
 325                         fsp->fsp_name,
 326                         (unsigned int)lck->delete_token->uid));
 327
 328                 if (!push_sec_ctx()) {
 329                         smb_panic("close_remove_share_mode: file %s. failed to push "
 330                                   "sec_ctx.\n");
 331                 }
 332
 333                 set_sec_ctx(lck->delete_token->uid,
 334                             lck->delete_token->gid,
 335                             lck->delete_token->ngroups,
 336                             lck->delete_token->groups,
 337                             NULL);
 338
 339                 changed_user = true;
 340         }
 341
 342         /* We can only delete the file if the name we have is still valid and
 343            hasn't been renamed. */
 344
 345         if (fsp->posix_open) {
 346                 ret = SMB_VFS_LSTAT(conn,fsp->fsp_name,&sbuf);
 347         } else {
 348                 ret = SMB_VFS_STAT(conn,fsp->fsp_name,&sbuf);
 349         }
 350
 351         if (ret != 0) {
 352                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 353                          "was set and stat failed with error %s\n",
 354                          fsp->fsp_name, strerror(errno) ));
 355                 /*
 356                  * Don't save the errno here, we ignore this error
 357                  */
 358                 goto done;
 359         }
 360
 361         id = vfs_file_id_from_sbuf(conn, &sbuf);
 362
 363         if (!file_id_equal(&fsp->file_id, &id)) {
 364                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 365                          "was set and dev and/or inode does not match\n",
 366                          fsp->fsp_name ));
 367                 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
 368                          "stat file_id %s\n",
 369                          fsp->fsp_name,
 370                          file_id_string_tos(&fsp->file_id),
 371                          file_id_string_tos(&id)));
 372                 /*
 373                  * Don't save the errno here, we ignore this error
 374                  */
 375                 goto done;
 376         }
 377
 378         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
 379             && !is_ntfs_stream_name(fsp->fsp_name)) {
 380
 381                 status = delete_all_streams(conn, fsp->fsp_name);
 382
 383                 if (!NT_STATUS_IS_OK(status)) {
 384                         DEBUG(5, ("delete_all_streams failed: %s\n",
 385                                   nt_errstr(status)));
 386                         goto done;
 387                 }
 388         }
 389
 390
 391         if (SMB_VFS_UNLINK(conn,fsp->fsp_name) != 0) {
 392                 /*
 393                  * This call can potentially fail as another smbd may
 394                  * have had the file open with delete on close set and
 395                  * deleted it when its last reference to this file
 396                  * went away. Hence we log this but not at debug level
 397                  * zero.
 398                  */
 399
 400                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 401                          "was set and unlink failed with error %s\n",
 402                          fsp->fsp_name, strerror(errno) ));
 403
 404                 status = map_nt_error_from_unix(errno);
 405         }
 406
 407         notify_fname(conn, NOTIFY_ACTION_REMOVED,
 408                      FILE_NOTIFY_CHANGE_FILE_NAME,
 409                      fsp->fsp_name);
 410
 411         /* As we now have POSIX opens which can unlink
 412          * with other open files we may have taken
 413          * this code path with more than one share mode
 414          * entry - ensure we only delete once by resetting
 415          * the delete on close flag. JRA.
 416          */
 417
 418         set_delete_on_close_lck(lck, False, NULL);
 419
 420  done:
 421
 422         if (changed_user) {
 423                 /* unbecome user. */
 424                 pop_sec_ctx();
 425         }
 426
 427         TALLOC_FREE(lck);
 428         return status;
 429 }
 430
 431 /****************************************************************************
 432  Close a file.
 433
 434  close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
 435  printing and magic scripts are only run on normal close.
 436  delete on close is done on normal and shutdown close.
 437 ****************************************************************************/
 438
 439 static NTSTATUS close_normal_file(files_struct *fsp, enum file_close_type close_type)
 440 {
 441         NTSTATUS status = NT_STATUS_OK;
 442         NTSTATUS saved_status1 = NT_STATUS_OK;
 443         NTSTATUS saved_status2 = NT_STATUS_OK;
 444         NTSTATUS saved_status3 = NT_STATUS_OK;
 445         connection_struct *conn = fsp->conn;
 446
 447         if (fsp->aio_write_behind) {
 448                 /*
 449                  * If we're finishing write behind on a close we can get a write
 450                  * error here, we must remember this.
 451                  */
 452                 int ret = wait_for_aio_completion(fsp);
 453                 if (ret) {
 454                         saved_status1 = map_nt_error_from_unix(ret);
 455                 }
 456         } else {
 457                 cancel_aio_by_fsp(fsp);
 458         }
 459
 460         /*
 461          * If we're flushing on a close we can get a write
 462          * error here, we must remember this.
 463          */
 464
 465         saved_status2 = close_filestruct(fsp);
 466
 467         if (fsp->print_file) {
 468                 print_fsp_end(fsp, close_type);
 469                 file_free(fsp);
 470                 return NT_STATUS_OK;
 471         }
 472
 473         /* If this is an old DOS or FCB open and we have multiple opens on
 474            the same handle we only have one share mode. Ensure we only remove
 475            the share mode on the last close. */
 476
 477         if (fsp->fh->ref_count == 1) {
 478                 /* Should we return on error here... ? */
 479                 saved_status3 = close_remove_share_mode(fsp, close_type);
 480         }
 481
 482         if(fsp->oplock_type) {
 483                 release_file_oplock(fsp);
 484         }
 485
 486         locking_close_file(smbd_messaging_context(), fsp);
 487
 488         status = fd_close(fsp);
 489
 490         /* check for magic scripts */
 491         if (close_type == NORMAL_CLOSE) {
 492                 check_magic(fsp);
 493         }
 494
 495         /*
 496          * Ensure pending modtime is set after close.
 497          */
 498
 499         if (fsp->pending_modtime_owner && !null_timespec(fsp->pending_modtime)) {
 500                 set_filetime(conn, fsp->fsp_name, fsp->pending_modtime);
 501         } else if (!null_timespec(fsp->last_write_time)) {
 502                 set_filetime(conn, fsp->fsp_name, fsp->last_write_time);
 503         }
 504
 505         if (NT_STATUS_IS_OK(status)) {
 506                 if (!NT_STATUS_IS_OK(saved_status1)) {
 507                         status = saved_status1;
 508                 } else if (!NT_STATUS_IS_OK(saved_status2)) {
 509                         status = saved_status2;
 510                 } else if (!NT_STATUS_IS_OK(saved_status3)) {
 511                         status = saved_status3;
 512                 }
 513         }
 514
 515         DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
 516                 conn->user,fsp->fsp_name,
 517                 conn->num_files_open,
 518                 nt_errstr(status) ));
 519
 520         file_free(fsp);
 521         return status;
 522 }
 523
 524 /****************************************************************************
 525  Close a directory opened by an NT SMB call.
 526 ****************************************************************************/
 527
 528 static NTSTATUS close_directory(files_struct *fsp, enum file_close_type close_type)
 529 {
 530         struct share_mode_lock *lck = 0;
 531         bool delete_dir = False;
 532         NTSTATUS status = NT_STATUS_OK;
 533
 534         /*
 535          * NT can set delete_on_close of the last open
 536          * reference to a directory also.
 537          */
 538
 539         lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
 540                                   NULL);
 541
 542         if (lck == NULL) {
 543                 DEBUG(0, ("close_directory: Could not get share mode lock for %s\n", fsp->fsp_name));
 544                 return NT_STATUS_INVALID_PARAMETER;
 545         }
 546
 547         if (!del_share_mode(lck, fsp)) {
 548                 DEBUG(0, ("close_directory: Could not delete share entry for %s\n", fsp->fsp_name));
 549         }
 550
 551         if (fsp->initial_delete_on_close) {
 552                 bool became_user = False;
 553
 554                 /* Initial delete on close was set - for
 555                  * directories we don't care if anyone else
 556                  * wrote a real delete on close. */
 557
 558                 if (current_user.vuid != fsp->vuid) {
 559                         become_user(fsp->conn, fsp->vuid);
 560                         became_user = True;
 561                 }
 562                 send_stat_cache_delete_message(fsp->fsp_name);
 563                 set_delete_on_close_lck(lck, True, &current_user.ut);
 564                 if (became_user) {
 565                         unbecome_user();
 566                 }
 567         }
 568
 569         delete_dir = lck->delete_on_close;
 570
 571         if (delete_dir) {
 572                 int i;
 573                 /* See if others still have the dir open. If this is the
 574                  * case, then don't delete. If all opens are POSIX delete now. */
 575                 for (i=0; i<lck->num_share_modes; i++) {
 576                         struct share_mode_entry *e = &lck->share_modes[i];
 577                         if (is_valid_share_mode_entry(e)) {
 578                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
 579                                         continue;
 580                                 }
 581                                 delete_dir = False;
 582                                 break;
 583                         }
 584                 }
 585         }
 586
 587         if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
 588                                 delete_dir &&
 589                                 lck->delete_token) {
 590
 591                 /* Become the user who requested the delete. */
 592
 593                 if (!push_sec_ctx()) {
 594                         smb_panic("close_directory: failed to push sec_ctx.\n");
 595                 }
 596
 597                 set_sec_ctx(lck->delete_token->uid,
 598                                 lck->delete_token->gid,
 599                                 lck->delete_token->ngroups,
 600                                 lck->delete_token->groups,
 601                                 NULL);
 602
 603                 TALLOC_FREE(lck);
 604
 605                 status = rmdir_internals(talloc_tos(),
 606                                 fsp->conn, fsp->fsp_name);
 607
 608                 DEBUG(5,("close_directory: %s. Delete on close was set - "
 609                          "deleting directory returned %s.\n",
 610                          fsp->fsp_name, nt_errstr(status)));
 611
 612                 /* unbecome user. */
 613                 pop_sec_ctx();
 614
 615                 /*
 616                  * Ensure we remove any change notify requests that would
 617                  * now fail as the directory has been deleted.
 618                  */
 619
 620                 if(NT_STATUS_IS_OK(status)) {
 621                         remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING);
 622                 }
 623         } else {
 624                 TALLOC_FREE(lck);
 625                 remove_pending_change_notify_requests_by_fid(
 626                         fsp, NT_STATUS_OK);
 627         }
 628
 629         /*
 630          * Do the code common to files and directories.
 631          */
 632         close_filestruct(fsp);
 633         file_free(fsp);
 634         return status;
 635 }
 636
 637 /****************************************************************************
 638  Close a 'stat file' opened internally.
 639 ****************************************************************************/
 640
 641 static NTSTATUS close_stat(files_struct *fsp)
 642 {
 643         /*
 644          * Do the code common to files and directories.
 645          */
 646         close_filestruct(fsp);
 647         file_free(fsp);
 648         return NT_STATUS_OK;
 649 }
 650
 651 /****************************************************************************
 652  Close a files_struct.
 653 ****************************************************************************/
 654
 655 NTSTATUS close_file(files_struct *fsp, enum file_close_type close_type)
 656 {
 657         NTSTATUS status;
 658         struct files_struct *base_fsp = fsp->base_fsp;
 659
 660         if(fsp->is_directory) {
 661                 status = close_directory(fsp, close_type);
 662         } else if (fsp->is_stat) {
 663                 status = close_stat(fsp);
 664         } else if (fsp->fake_file_handle != NULL) {
 665                 status = close_fake_file(fsp);
 666         } else {
 667                 status = close_normal_file(fsp, close_type);
 668         }
 669
 670         if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) {
 671
 672                 /*
 673                  * fsp was a stream, the base fsp can't be a stream as well
 674                  *
 675                  * For SHUTDOWN_CLOSE this is not possible here, because
 676                  * SHUTDOWN_CLOSE only happens from files.c which walks the
 677                  * complete list of files. If we mess with more than one fsp
 678                  * those loops will become confused.
 679                  */
 680
 681                 SMB_ASSERT(base_fsp->base_fsp == NULL);
 682                 close_file(base_fsp, close_type);
 683         }
 684
 685         return status;
 686 }