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 NTSTATUS 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         char *fname = NULL;
  40         NTSTATUS status;
  41
  42         if (!*lp_magicscript(SNUM(conn))) {
  43                 return NT_STATUS_OK;
  44         }
  45
  46         DEBUG(5,("checking magic for %s\n", fsp_str_dbg(fsp)));
  47
  48         ctx = talloc_stackframe();
  49
  50         fname = fsp->fsp_name->base_name;
  51
  52         if (!(p = strrchr_m(fname,'/'))) {
  53                 p = fname;
  54         } else {
  55                 p++;
  56         }
  57
  58         if (!strequal(lp_magicscript(SNUM(conn)),p)) {
  59                 status = NT_STATUS_OK;
  60                 goto out;
  61         }
  62
  63         if (*lp_magicoutput(SNUM(conn))) {
  64                 magic_output = lp_magicoutput(SNUM(conn));
  65         } else {
  66                 magic_output = talloc_asprintf(ctx,
  67                                 "%s.out",
  68                                 fname);
  69         }
  70         if (!magic_output) {
  71                 status = NT_STATUS_NO_MEMORY;
  72                 goto out;
  73         }
  74
  75         /* Ensure we don't depend on user's PATH. */
  76         p = talloc_asprintf(ctx, "./%s", fname);
  77         if (!p) {
  78                 status = NT_STATUS_NO_MEMORY;
  79                 goto out;
  80         }
  81
  82         if (chmod(fname, 0755) == -1) {
  83                 status = map_nt_error_from_unix(errno);
  84                 goto out;
  85         }
  86         ret = smbrun(p,&tmp_fd);
  87         DEBUG(3,("Invoking magic command %s gave %d\n",
  88                 p,ret));
  89
  90         unlink(fname);
  91         if (ret != 0 || tmp_fd == -1) {
  92                 if (tmp_fd != -1) {
  93                         close(tmp_fd);
  94                 }
  95                 status = NT_STATUS_UNSUCCESSFUL;
  96                 goto out;
  97         }
  98         outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
  99         if (outfd == -1) {
 100                 int err = errno;
 101                 close(tmp_fd);
 102                 status = map_nt_error_from_unix(err);
 103                 goto out;
 104         }
 105
 106         if (sys_fstat(tmp_fd,&st) == -1) {
 107                 int err = errno;
 108                 close(tmp_fd);
 109                 close(outfd);
 110                 status = map_nt_error_from_unix(err);
 111                 goto out;
 112         }
 113
 114         if (transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_ex_size) == (SMB_OFF_T)-1) {
 115                 int err = errno;
 116                 close(tmp_fd);
 117                 close(outfd);
 118                 status = map_nt_error_from_unix(err);
 119                 goto out;
 120         }
 121         close(tmp_fd);
 122         if (close(outfd) == -1) {
 123                 status = map_nt_error_from_unix(errno);
 124                 goto out;
 125         }
 126
 127         status = NT_STATUS_OK;
 128
 129  out:
 130         TALLOC_FREE(ctx);
 131         return status;
 132 }
 133
 134 /****************************************************************************
 135   Common code to close a file or a directory.
 136 ****************************************************************************/
 137
 138 static NTSTATUS close_filestruct(files_struct *fsp)
 139 {
 140         NTSTATUS status = NT_STATUS_OK;
 141
 142         if (fsp->fh->fd != -1) {
 143                 if(flush_write_cache(fsp, CLOSE_FLUSH) == -1) {
 144                         status = map_nt_error_from_unix(errno);
 145                 }
 146                 delete_write_cache(fsp);
 147         }
 148
 149         return status;
 150 }
 151
 152 /****************************************************************************
 153  If any deferred opens are waiting on this close, notify them.
 154 ****************************************************************************/
 155
 156 static void notify_deferred_opens(struct share_mode_lock *lck)
 157 {
 158         int i;
 159
 160         if (!should_notify_deferred_opens()) {
 161                 return;
 162         }
 163
 164         for (i=0; i<lck->num_share_modes; i++) {
 165                 struct share_mode_entry *e = &lck->share_modes[i];
 166
 167                 if (!is_deferred_open_entry(e)) {
 168                         continue;
 169                 }
 170
 171                 if (procid_is_me(&e->pid)) {
 172                         /*
 173                          * We need to notify ourself to retry the open.  Do
 174                          * this by finding the queued SMB record, moving it to
 175                          * the head of the queue and changing the wait time to
 176                          * zero.
 177                          */
 178                         schedule_deferred_open_smb_message(e->op_mid);
 179                 } else {
 180                         char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
 181
 182                         share_mode_entry_to_message(msg, e);
 183
 184                         messaging_send_buf(smbd_messaging_context(),
 185                                            e->pid, MSG_SMB_OPEN_RETRY,
 186                                            (uint8 *)msg,
 187                                            MSG_SMB_SHARE_MODE_ENTRY_SIZE);
 188                 }
 189         }
 190 }
 191
 192 /****************************************************************************
 193  Delete all streams
 194 ****************************************************************************/
 195
 196 NTSTATUS delete_all_streams(connection_struct *conn, const char *fname)
 197 {
 198         struct stream_struct *stream_info;
 199         int i;
 200         unsigned int num_streams;
 201         TALLOC_CTX *frame = talloc_stackframe();
 202         NTSTATUS status;
 203
 204         status = SMB_VFS_STREAMINFO(conn, NULL, fname, talloc_tos(),
 205                                     &num_streams, &stream_info);
 206
 207         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
 208                 DEBUG(10, ("no streams around\n"));
 209                 TALLOC_FREE(frame);
 210                 return NT_STATUS_OK;
 211         }
 212
 213         if (!NT_STATUS_IS_OK(status)) {
 214                 DEBUG(10, ("SMB_VFS_STREAMINFO failed: %s\n",
 215                            nt_errstr(status)));
 216                 goto fail;
 217         }
 218
 219         DEBUG(10, ("delete_all_streams found %d streams\n",
 220                    num_streams));
 221
 222         if (num_streams == 0) {
 223                 TALLOC_FREE(frame);
 224                 return NT_STATUS_OK;
 225         }
 226
 227         for (i=0; i<num_streams; i++) {
 228                 int res;
 229                 struct smb_filename *smb_fname_stream = NULL;
 230
 231                 if (strequal(stream_info[i].name, "::$DATA")) {
 232                         continue;
 233                 }
 234
 235                 status = create_synthetic_smb_fname(talloc_tos(), fname,
 236                                                     stream_info[i].name, NULL,
 237                                                     &smb_fname_stream);
 238
 239                 if (!NT_STATUS_IS_OK(status)) {
 240                         DEBUG(0, ("talloc_aprintf failed\n"));
 241                         goto fail;
 242                 }
 243
 244                 res = SMB_VFS_UNLINK(conn, smb_fname_stream);
 245
 246                 if (res == -1) {
 247                         status = map_nt_error_from_unix(errno);
 248                         DEBUG(10, ("Could not delete stream %s: %s\n",
 249                                    smb_fname_str_dbg(smb_fname_stream),
 250                                    strerror(errno)));
 251                         TALLOC_FREE(smb_fname_stream);
 252                         break;
 253                 }
 254                 TALLOC_FREE(smb_fname_stream);
 255         }
 256
 257  fail:
 258         TALLOC_FREE(frame);
 259         return status;
 260 }
 261
 262 /****************************************************************************
 263  Deal with removing a share mode on last close.
 264 ****************************************************************************/
 265
 266 static NTSTATUS close_remove_share_mode(files_struct *fsp,
 267                                         enum file_close_type close_type)
 268 {
 269         connection_struct *conn = fsp->conn;
 270         bool delete_file = false;
 271         bool changed_user = false;
 272         struct share_mode_lock *lck = NULL;
 273         NTSTATUS status = NT_STATUS_OK;
 274         NTSTATUS tmp_status;
 275         struct file_id id;
 276
 277         /*
 278          * Lock the share entries, and determine if we should delete
 279          * on close. If so delete whilst the lock is still in effect.
 280          * This prevents race conditions with the file being created. JRA.
 281          */
 282
 283         lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
 284                                   NULL);
 285
 286         if (lck == NULL) {
 287                 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
 288                           "lock for file %s\n", fsp_str_dbg(fsp)));
 289                 status = NT_STATUS_INVALID_PARAMETER;
 290                 goto done;
 291         }
 292
 293         if (fsp->write_time_forced) {
 294                 DEBUG(10,("close_remove_share_mode: write time forced "
 295                         "for file %s\n",
 296                         fsp_str_dbg(fsp)));
 297                 set_close_write_time(lck, fsp, lck->changed_write_time);
 298         } else if (fsp->update_write_time_on_close) {
 299                 DEBUG(10,("close_remove_share_mode: update_write_time_on_close "
 300                         "set for file %s\n",
 301                         fsp_str_dbg(fsp)));
 302                 if (null_timespec(fsp->close_write_time)) {
 303                         set_close_write_time(lck, fsp, timespec_current());
 304                 } else {
 305                         set_close_write_time(lck, fsp, fsp->close_write_time);
 306                 }
 307         }
 308
 309         if (!del_share_mode(lck, fsp)) {
 310                 DEBUG(0, ("close_remove_share_mode: Could not delete share "
 311                           "entry for file %s\n",
 312                           fsp_str_dbg(fsp)));
 313         }
 314
 315         if (fsp->initial_delete_on_close && (lck->delete_token == NULL)) {
 316                 bool became_user = False;
 317
 318                 /* Initial delete on close was set and no one else
 319                  * wrote a real delete on close. */
 320
 321                 if (current_user.vuid != fsp->vuid) {
 322                         become_user(conn, fsp->vuid);
 323                         became_user = True;
 324                 }
 325                 set_delete_on_close_lck(lck, True, &current_user.ut);
 326                 if (became_user) {
 327                         unbecome_user();
 328                 }
 329         }
 330
 331         delete_file = lck->delete_on_close;
 332
 333         if (delete_file) {
 334                 int i;
 335                 /* See if others still have the file open. If this is the
 336                  * case, then don't delete. If all opens are POSIX delete now. */
 337                 for (i=0; i<lck->num_share_modes; i++) {
 338                         struct share_mode_entry *e = &lck->share_modes[i];
 339                         if (is_valid_share_mode_entry(e)) {
 340                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
 341                                         continue;
 342                                 }
 343                                 delete_file = False;
 344                                 break;
 345                         }
 346                 }
 347         }
 348
 349         /* Notify any deferred opens waiting on this close. */
 350         notify_deferred_opens(lck);
 351         reply_to_oplock_break_requests(fsp);
 352
 353         /*
 354          * NT can set delete_on_close of the last open
 355          * reference to a file.
 356          */
 357
 358         if (!(close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE)
 359             || !delete_file
 360             || (lck->delete_token == NULL)) {
 361                 TALLOC_FREE(lck);
 362                 return NT_STATUS_OK;
 363         }
 364
 365         /*
 366          * Ok, we have to delete the file
 367          */
 368
 369         DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
 370                  "- deleting file.\n", fsp_str_dbg(fsp)));
 371
 372         /*
 373          * Don't try to update the write time when we delete the file
 374          */
 375         fsp->update_write_time_on_close = false;
 376
 377         if (!unix_token_equal(lck->delete_token, &current_user.ut)) {
 378                 /* Become the user who requested the delete. */
 379
 380                 DEBUG(5,("close_remove_share_mode: file %s. "
 381                         "Change user to uid %u\n",
 382                         fsp_str_dbg(fsp),
 383                         (unsigned int)lck->delete_token->uid));
 384
 385                 if (!push_sec_ctx()) {
 386                         smb_panic("close_remove_share_mode: file %s. failed to push "
 387                                   "sec_ctx.\n");
 388                 }
 389
 390                 set_sec_ctx(lck->delete_token->uid,
 391                             lck->delete_token->gid,
 392                             lck->delete_token->ngroups,
 393                             lck->delete_token->groups,
 394                             NULL);
 395
 396                 changed_user = true;
 397         }
 398
 399         /* We can only delete the file if the name we have is still valid and
 400            hasn't been renamed. */
 401
 402         tmp_status = vfs_stat_fsp(fsp);
 403         if (!NT_STATUS_IS_OK(tmp_status)) {
 404                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 405                          "was set and stat failed with error %s\n",
 406                          fsp_str_dbg(fsp), nt_errstr(tmp_status)));
 407                 /*
 408                  * Don't save the errno here, we ignore this error
 409                  */
 410                 goto done;
 411         }
 412
 413         id = vfs_file_id_from_sbuf(conn, &fsp->fsp_name->st);
 414
 415         if (!file_id_equal(&fsp->file_id, &id)) {
 416                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 417                          "was set and dev and/or inode does not match\n",
 418                          fsp_str_dbg(fsp)));
 419                 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
 420                          "stat file_id %s\n",
 421                          fsp_str_dbg(fsp),
 422                          file_id_string_tos(&fsp->file_id),
 423                          file_id_string_tos(&id)));
 424                 /*
 425                  * Don't save the errno here, we ignore this error
 426                  */
 427                 goto done;
 428         }
 429
 430         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
 431             && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
 432
 433                 status = delete_all_streams(conn, fsp->fsp_name->base_name);
 434
 435                 if (!NT_STATUS_IS_OK(status)) {
 436                         DEBUG(5, ("delete_all_streams failed: %s\n",
 437                                   nt_errstr(status)));
 438                         goto done;
 439                 }
 440         }
 441
 442
 443         if (SMB_VFS_UNLINK(conn, fsp->fsp_name) != 0) {
 444                 /*
 445                  * This call can potentially fail as another smbd may
 446                  * have had the file open with delete on close set and
 447                  * deleted it when its last reference to this file
 448                  * went away. Hence we log this but not at debug level
 449                  * zero.
 450                  */
 451
 452                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 453                          "was set and unlink failed with error %s\n",
 454                          fsp_str_dbg(fsp), strerror(errno)));
 455
 456                 status = map_nt_error_from_unix(errno);
 457         }
 458
 459         notify_fname(conn, NOTIFY_ACTION_REMOVED,
 460                      FILE_NOTIFY_CHANGE_FILE_NAME,
 461                      fsp->fsp_name->base_name);
 462
 463         /* As we now have POSIX opens which can unlink
 464          * with other open files we may have taken
 465          * this code path with more than one share mode
 466          * entry - ensure we only delete once by resetting
 467          * the delete on close flag. JRA.
 468          */
 469
 470         set_delete_on_close_lck(lck, False, NULL);
 471
 472  done:
 473
 474         if (changed_user) {
 475                 /* unbecome user. */
 476                 pop_sec_ctx();
 477         }
 478
 479         TALLOC_FREE(lck);
 480         return status;
 481 }
 482
 483 void set_close_write_time(struct share_mode_lock *lck,
 484                         struct files_struct *fsp, struct timespec ts)
 485 {
 486         DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts))));
 487
 488         if (null_timespec(ts)) {
 489                 return;
 490         }
 491         /*
 492          * if the write time on close is explict set, then don't
 493          * need to fix it up to the value in the locking db
 494          */
 495         fsp->write_time_forced = false;
 496
 497         fsp->update_write_time_on_close = true;
 498         fsp->close_write_time = ts;
 499
 500         /* On close if we're changing the real file time we
 501          * must update it in the open file db too. */
 502         (void)set_write_time(fsp->file_id, ts);
 503         /* If someone has a sticky write time then update it as well. */
 504         if (lck && !null_timespec(lck->changed_write_time)) {
 505                 (void)set_sticky_write_time(fsp->file_id, ts);
 506         }
 507 }
 508
 509 static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
 510 {
 511         struct smb_file_time ft;
 512         NTSTATUS status;
 513
 514         ZERO_STRUCT(ft);
 515
 516         if (!fsp->update_write_time_on_close) {
 517                 return NT_STATUS_OK;
 518         }
 519
 520         if (null_timespec(fsp->close_write_time)) {
 521                 fsp->close_write_time = timespec_current();
 522         }
 523
 524         /* Ensure we have a valid stat struct for the source. */
 525         status = vfs_stat_fsp(fsp);
 526         if (!NT_STATUS_IS_OK(status)) {
 527                 return status;
 528         }
 529
 530         if (!VALID_STAT(fsp->fsp_name->st)) {
 531                 /* if it doesn't seem to be a real file */
 532                 return NT_STATUS_OK;
 533         }
 534
 535         ft.mtime = fsp->close_write_time;
 536         status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, &ft, true);
 537         if (!NT_STATUS_IS_OK(status)) {
 538                 return status;
 539         }
 540
 541         return status;
 542 }
 543
 544 static NTSTATUS ntstatus_keeperror(NTSTATUS s1, NTSTATUS s2)
 545 {
 546         if (!NT_STATUS_IS_OK(s1)) {
 547                 return s1;
 548         }
 549         return s2;
 550 }
 551
 552 /****************************************************************************
 553  Close a file.
 554
 555  close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
 556  printing and magic scripts are only run on normal close.
 557  delete on close is done on normal and shutdown close.
 558 ****************************************************************************/
 559
 560 static NTSTATUS close_normal_file(struct smb_request *req, files_struct *fsp,
 561                                   enum file_close_type close_type)
 562 {
 563         NTSTATUS status = NT_STATUS_OK;
 564         NTSTATUS tmp;
 565         connection_struct *conn = fsp->conn;
 566
 567         if (fsp->aio_write_behind) {
 568                 /*
 569                  * If we're finishing write behind on a close we can get a write
 570                  * error here, we must remember this.
 571                  */
 572                 int ret = wait_for_aio_completion(fsp);
 573                 if (ret) {
 574                         status = ntstatus_keeperror(
 575                                 status, map_nt_error_from_unix(ret));
 576                 }
 577         } else {
 578                 cancel_aio_by_fsp(fsp);
 579         }
 580
 581         /*
 582          * If we're flushing on a close we can get a write
 583          * error here, we must remember this.
 584          */
 585
 586         tmp = close_filestruct(fsp);
 587         status = ntstatus_keeperror(status, tmp);
 588
 589         if (fsp->print_file) {
 590                 print_fsp_end(fsp, close_type);
 591                 file_free(req, fsp);
 592                 return NT_STATUS_OK;
 593         }
 594
 595         /* Remove the oplock before potentially deleting the file. */
 596         if(fsp->oplock_type) {
 597                 release_file_oplock(fsp);
 598         }
 599
 600         /* If this is an old DOS or FCB open and we have multiple opens on
 601            the same handle we only have one share mode. Ensure we only remove
 602            the share mode on the last close. */
 603
 604         if (fsp->fh->ref_count == 1) {
 605                 /* Should we return on error here... ? */
 606                 tmp = close_remove_share_mode(fsp, close_type);
 607                 status = ntstatus_keeperror(status, tmp);
 608         }
 609
 610         locking_close_file(smbd_messaging_context(), fsp);
 611
 612         tmp = fd_close(fsp);
 613         status = ntstatus_keeperror(status, tmp);
 614
 615         /* check for magic scripts */
 616         if (close_type == NORMAL_CLOSE) {
 617                 tmp = check_magic(fsp);
 618                 status = ntstatus_keeperror(status, tmp);
 619         }
 620
 621         /*
 622          * Ensure pending modtime is set after close.
 623          */
 624
 625         tmp = update_write_time_on_close(fsp);
 626         if (NT_STATUS_EQUAL(tmp, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
 627                 /* Someone renamed the file or a parent directory containing
 628                  * this file. We can't do anything about this, we don't have
 629                  * an "update timestamp by fd" call in POSIX. Eat the error. */
 630
 631                 tmp = NT_STATUS_OK;
 632         }
 633
 634         status = ntstatus_keeperror(status, tmp);
 635
 636         DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
 637                 conn->server_info->unix_name, fsp_str_dbg(fsp),
 638                 conn->num_files_open - 1,
 639                 nt_errstr(status) ));
 640
 641         file_free(req, fsp);
 642         return status;
 643 }
 644
 645 /****************************************************************************
 646  Close a directory opened by an NT SMB call.
 647 ****************************************************************************/
 648
 649 static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp,
 650                                 enum file_close_type close_type)
 651 {
 652         struct share_mode_lock *lck = NULL;
 653         bool delete_dir = False;
 654         NTSTATUS status = NT_STATUS_OK;
 655
 656         /*
 657          * NT can set delete_on_close of the last open
 658          * reference to a directory also.
 659          */
 660
 661         lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
 662                                   NULL);
 663
 664         if (lck == NULL) {
 665                 DEBUG(0, ("close_directory: Could not get share mode lock for "
 666                           "%s\n", fsp_str_dbg(fsp)));
 667                 status = NT_STATUS_INVALID_PARAMETER;
 668                 goto out;
 669         }
 670
 671         if (!del_share_mode(lck, fsp)) {
 672                 DEBUG(0, ("close_directory: Could not delete share entry for "
 673                           "%s\n", fsp_str_dbg(fsp)));
 674         }
 675
 676         if (fsp->initial_delete_on_close) {
 677                 bool became_user = False;
 678
 679                 /* Initial delete on close was set - for
 680                  * directories we don't care if anyone else
 681                  * wrote a real delete on close. */
 682
 683                 if (current_user.vuid != fsp->vuid) {
 684                         become_user(fsp->conn, fsp->vuid);
 685                         became_user = True;
 686                 }
 687                 send_stat_cache_delete_message(fsp->fsp_name->base_name);
 688                 set_delete_on_close_lck(lck, True, &current_user.ut);
 689                 if (became_user) {
 690                         unbecome_user();
 691                 }
 692         }
 693
 694         delete_dir = lck->delete_on_close;
 695
 696         if (delete_dir) {
 697                 int i;
 698                 /* See if others still have the dir open. If this is the
 699                  * case, then don't delete. If all opens are POSIX delete now. */
 700                 for (i=0; i<lck->num_share_modes; i++) {
 701                         struct share_mode_entry *e = &lck->share_modes[i];
 702                         if (is_valid_share_mode_entry(e)) {
 703                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
 704                                         continue;
 705                                 }
 706                                 delete_dir = False;
 707                                 break;
 708                         }
 709                 }
 710         }
 711
 712         if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
 713                                 delete_dir &&
 714                                 lck->delete_token) {
 715
 716                 /* Become the user who requested the delete. */
 717
 718                 if (!push_sec_ctx()) {
 719                         smb_panic("close_directory: failed to push sec_ctx.\n");
 720                 }
 721
 722                 set_sec_ctx(lck->delete_token->uid,
 723                                 lck->delete_token->gid,
 724                                 lck->delete_token->ngroups,
 725                                 lck->delete_token->groups,
 726                                 NULL);
 727
 728                 TALLOC_FREE(lck);
 729
 730                 status = rmdir_internals(talloc_tos(), fsp->conn,
 731                                          fsp->fsp_name);
 732
 733                 DEBUG(5,("close_directory: %s. Delete on close was set - "
 734                          "deleting directory returned %s.\n",
 735                          fsp_str_dbg(fsp), nt_errstr(status)));
 736
 737                 /* unbecome user. */
 738                 pop_sec_ctx();
 739
 740                 /*
 741                  * Ensure we remove any change notify requests that would
 742                  * now fail as the directory has been deleted.
 743                  */
 744
 745                 if(NT_STATUS_IS_OK(status)) {
 746                         remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING);
 747                 }
 748         } else {
 749                 TALLOC_FREE(lck);
 750                 remove_pending_change_notify_requests_by_fid(
 751                         fsp, NT_STATUS_OK);
 752         }
 753
 754         status = fd_close(fsp);
 755
 756         if (!NT_STATUS_IS_OK(status)) {
 757                 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
 758                           fsp_str_dbg(fsp), fsp->fh->fd, errno,
 759                           strerror(errno)));
 760         }
 761
 762         if (fsp->dptr) {
 763                 dptr_CloseDir(fsp->dptr);
 764         }
 765
 766         /*
 767          * Do the code common to files and directories.
 768          */
 769         close_filestruct(fsp);
 770         file_free(req, fsp);
 771
 772  out:
 773         TALLOC_FREE(lck);
 774         return status;
 775 }
 776
 777 /****************************************************************************
 778  Close a files_struct.
 779 ****************************************************************************/
 780
 781 NTSTATUS close_file(struct smb_request *req, files_struct *fsp,
 782                     enum file_close_type close_type)
 783 {
 784         NTSTATUS status;
 785         struct files_struct *base_fsp = fsp->base_fsp;
 786
 787         if(fsp->is_directory) {
 788                 status = close_directory(req, fsp, close_type);
 789         } else if (fsp->fake_file_handle != NULL) {
 790                 status = close_fake_file(req, fsp);
 791         } else {
 792                 status = close_normal_file(req, fsp, close_type);
 793         }
 794
 795         if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) {
 796
 797                 /*
 798                  * fsp was a stream, the base fsp can't be a stream as well
 799                  *
 800                  * For SHUTDOWN_CLOSE this is not possible here, because
 801                  * SHUTDOWN_CLOSE only happens from files.c which walks the
 802                  * complete list of files. If we mess with more than one fsp
 803                  * those loops will become confused.
 804                  */
 805
 806                 SMB_ASSERT(base_fsp->base_fsp == NULL);
 807                 close_file(req, base_fsp, close_type);
 808         }
 809
 810         return status;
 811 }
 812
 813 /****************************************************************************
 814  Deal with an (authorized) message to close a file given the share mode
 815  entry.
 816 ****************************************************************************/
 817
 818 void msg_close_file(struct messaging_context *msg_ctx,
 819                         void *private_data,
 820                         uint32_t msg_type,
 821                         struct server_id server_id,
 822                         DATA_BLOB *data)
 823 {
 824         files_struct *fsp = NULL;
 825         struct share_mode_entry e;
 826
 827         message_to_share_mode_entry(&e, (char *)data->data);
 828
 829         if(DEBUGLVL(10)) {
 830                 char *sm_str = share_mode_str(NULL, 0, &e);
 831                 if (!sm_str) {
 832                         smb_panic("talloc failed");
 833                 }
 834                 DEBUG(10,("msg_close_file: got request to close share mode "
 835                         "entry %s\n", sm_str));
 836                 TALLOC_FREE(sm_str);
 837         }
 838
 839         fsp = file_find_dif(e.id, e.share_file_id);
 840         if (!fsp) {
 841                 DEBUG(10,("msg_close_file: failed to find file.\n"));
 842                 return;
 843         }
 844         close_file(NULL, fsp, NORMAL_CLOSE);
 845 }