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 #include "system/filesys.h"
  24 #include "printing.h"
  25 #include "smbd/smbd.h"
  26 #include "smbd/globals.h"
  27 #include "fake_file.h"
  28 #include "transfer_file.h"
  29 #include "auth.h"
  30 #include "messages.h"
  31 #include "../librpc/gen_ndr/open_files.h"
  32
  33 /****************************************************************************
  34  Run a file if it is a magic script.
  35 ****************************************************************************/
  36
  37 static NTSTATUS check_magic(struct files_struct *fsp)
  38 {
  39         int ret;
  40         const char *magic_output = NULL;
  41         SMB_STRUCT_STAT st;
  42         int tmp_fd, outfd;
  43         TALLOC_CTX *ctx = NULL;
  44         const char *p;
  45         struct connection_struct *conn = fsp->conn;
  46         char *fname = NULL;
  47         NTSTATUS status;
  48
  49         if (!*lp_magicscript(SNUM(conn))) {
  50                 return NT_STATUS_OK;
  51         }
  52
  53         DEBUG(5,("checking magic for %s\n", fsp_str_dbg(fsp)));
  54
  55         ctx = talloc_stackframe();
  56
  57         fname = fsp->fsp_name->base_name;
  58
  59         if (!(p = strrchr_m(fname,'/'))) {
  60                 p = fname;
  61         } else {
  62                 p++;
  63         }
  64
  65         if (!strequal(lp_magicscript(SNUM(conn)),p)) {
  66                 status = NT_STATUS_OK;
  67                 goto out;
  68         }
  69
  70         if (*lp_magicoutput(SNUM(conn))) {
  71                 magic_output = lp_magicoutput(SNUM(conn));
  72         } else {
  73                 magic_output = talloc_asprintf(ctx,
  74                                 "%s.out",
  75                                 fname);
  76         }
  77         if (!magic_output) {
  78                 status = NT_STATUS_NO_MEMORY;
  79                 goto out;
  80         }
  81
  82         /* Ensure we don't depend on user's PATH. */
  83         p = talloc_asprintf(ctx, "./%s", fname);
  84         if (!p) {
  85                 status = NT_STATUS_NO_MEMORY;
  86                 goto out;
  87         }
  88
  89         if (chmod(fname, 0755) == -1) {
  90                 status = map_nt_error_from_unix(errno);
  91                 goto out;
  92         }
  93         ret = smbrun(p,&tmp_fd);
  94         DEBUG(3,("Invoking magic command %s gave %d\n",
  95                 p,ret));
  96
  97         unlink(fname);
  98         if (ret != 0 || tmp_fd == -1) {
  99                 if (tmp_fd != -1) {
 100                         close(tmp_fd);
 101                 }
 102                 status = NT_STATUS_UNSUCCESSFUL;
 103                 goto out;
 104         }
 105         outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
 106         if (outfd == -1) {
 107                 int err = errno;
 108                 close(tmp_fd);
 109                 status = map_nt_error_from_unix(err);
 110                 goto out;
 111         }
 112
 113         if (sys_fstat(tmp_fd, &st, false) == -1) {
 114                 int err = errno;
 115                 close(tmp_fd);
 116                 close(outfd);
 117                 status = map_nt_error_from_unix(err);
 118                 goto out;
 119         }
 120
 121         if (transfer_file(tmp_fd,outfd,(off_t)st.st_ex_size) == (off_t)-1) {
 122                 int err = errno;
 123                 close(tmp_fd);
 124                 close(outfd);
 125                 status = map_nt_error_from_unix(err);
 126                 goto out;
 127         }
 128         close(tmp_fd);
 129         if (close(outfd) == -1) {
 130                 status = map_nt_error_from_unix(errno);
 131                 goto out;
 132         }
 133
 134         status = NT_STATUS_OK;
 135
 136  out:
 137         TALLOC_FREE(ctx);
 138         return status;
 139 }
 140
 141 /****************************************************************************
 142   Common code to close a file or a directory.
 143 ****************************************************************************/
 144
 145 static NTSTATUS close_filestruct(files_struct *fsp)
 146 {
 147         NTSTATUS status = NT_STATUS_OK;
 148
 149         if (fsp->fh->fd != -1) {
 150                 if(flush_write_cache(fsp, CLOSE_FLUSH) == -1) {
 151                         status = map_nt_error_from_unix(errno);
 152                 }
 153                 delete_write_cache(fsp);
 154         }
 155
 156         return status;
 157 }
 158
 159 static int compare_share_mode_times(const void *p1, const void *p2)
 160 {
 161         const struct share_mode_entry *s1 = (const struct share_mode_entry *)p1;
 162         const struct share_mode_entry *s2 = (const struct share_mode_entry *)p2;
 163         return timeval_compare(&s1->time, &s2->time);
 164 }
 165
 166 /****************************************************************************
 167  If any deferred opens are waiting on this close, notify them.
 168 ****************************************************************************/
 169
 170 static void notify_deferred_opens(struct smbd_server_connection *sconn,
 171                                   struct share_mode_lock *lck)
 172 {
 173         uint32_t i, num_deferred;
 174         struct share_mode_entry *deferred;
 175
 176         if (!should_notify_deferred_opens()) {
 177                 return;
 178         }
 179
 180         num_deferred = 0;
 181         for (i=0; i<lck->data->num_share_modes; i++) {
 182                 if (is_deferred_open_entry(&lck->data->share_modes[i])) {
 183                         num_deferred += 1;
 184                 }
 185         }
 186         if (num_deferred == 0) {
 187                 return;
 188         }
 189
 190         deferred = talloc_array(talloc_tos(), struct share_mode_entry,
 191                                 num_deferred);
 192         if (deferred == NULL) {
 193                 return;
 194         }
 195
 196         num_deferred = 0;
 197         for (i=0; i<lck->data->num_share_modes; i++) {
 198                 struct share_mode_entry *e = &lck->data->share_modes[i];
 199                 if (is_deferred_open_entry(e)) {
 200                         deferred[num_deferred] = *e;
 201                         num_deferred += 1;
 202                 }
 203         }
 204
 205         /*
 206          * We need to sort the notifications by initial request time. Imagine
 207          * two opens come in asyncronously, both conflicting with the open we
 208          * just close here. If we don't sort the notifications, the one that
 209          * came in last might get the response before the one that came in
 210          * first. This is demonstrated with the smbtorture4 raw.mux test.
 211          *
 212          * As long as we had the UNUSED_SHARE_MODE_ENTRY, we happened to
 213          * survive this particular test. Without UNUSED_SHARE_MODE_ENTRY, we
 214          * shuffle the share mode entries around a bit, so that we do not
 215          * survive raw.mux anymore.
 216          *
 217          * We could have kept the ordering in del_share_mode, but as the
 218          * ordering was never formalized I think it is better to do it here
 219          * where it is necessary.
 220          */
 221
 222         qsort(deferred, num_deferred, sizeof(struct share_mode_entry),
 223               compare_share_mode_times);
 224
 225         for (i=0; i<num_deferred; i++) {
 226                 struct share_mode_entry *e = &deferred[i];
 227
 228                 if (procid_is_me(&e->pid)) {
 229                         /*
 230                          * We need to notify ourself to retry the open.  Do
 231                          * this by finding the queued SMB record, moving it to
 232                          * the head of the queue and changing the wait time to
 233                          * zero.
 234                          */
 235                         schedule_deferred_open_message_smb(sconn, e->op_mid);
 236                 } else {
 237                         char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
 238
 239                         share_mode_entry_to_message(msg, e);
 240
 241                         messaging_send_buf(sconn->msg_ctx, e->pid,
 242                                            MSG_SMB_OPEN_RETRY,
 243                                            (uint8 *)msg,
 244                                            MSG_SMB_SHARE_MODE_ENTRY_SIZE);
 245                 }
 246         }
 247         TALLOC_FREE(deferred);
 248 }
 249
 250 /****************************************************************************
 251  Delete all streams
 252 ****************************************************************************/
 253
 254 NTSTATUS delete_all_streams(connection_struct *conn, const char *fname)
 255 {
 256         struct stream_struct *stream_info = NULL;
 257         int i;
 258         unsigned int num_streams = 0;
 259         TALLOC_CTX *frame = talloc_stackframe();
 260         NTSTATUS status;
 261
 262         status = vfs_streaminfo(conn, NULL, fname, talloc_tos(),
 263                                 &num_streams, &stream_info);
 264
 265         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
 266                 DEBUG(10, ("no streams around\n"));
 267                 TALLOC_FREE(frame);
 268                 return NT_STATUS_OK;
 269         }
 270
 271         if (!NT_STATUS_IS_OK(status)) {
 272                 DEBUG(10, ("vfs_streaminfo failed: %s\n",
 273                            nt_errstr(status)));
 274                 goto fail;
 275         }
 276
 277         DEBUG(10, ("delete_all_streams found %d streams\n",
 278                    num_streams));
 279
 280         if (num_streams == 0) {
 281                 TALLOC_FREE(frame);
 282                 return NT_STATUS_OK;
 283         }
 284
 285         for (i=0; i<num_streams; i++) {
 286                 int res;
 287                 struct smb_filename *smb_fname_stream = NULL;
 288
 289                 if (strequal(stream_info[i].name, "::$DATA")) {
 290                         continue;
 291                 }
 292
 293                 status = create_synthetic_smb_fname(talloc_tos(), fname,
 294                                                     stream_info[i].name, NULL,
 295                                                     &smb_fname_stream);
 296
 297                 if (!NT_STATUS_IS_OK(status)) {
 298                         DEBUG(0, ("talloc_aprintf failed\n"));
 299                         goto fail;
 300                 }
 301
 302                 res = SMB_VFS_UNLINK(conn, smb_fname_stream);
 303
 304                 if (res == -1) {
 305                         status = map_nt_error_from_unix(errno);
 306                         DEBUG(10, ("Could not delete stream %s: %s\n",
 307                                    smb_fname_str_dbg(smb_fname_stream),
 308                                    strerror(errno)));
 309                         TALLOC_FREE(smb_fname_stream);
 310                         break;
 311                 }
 312                 TALLOC_FREE(smb_fname_stream);
 313         }
 314
 315  fail:
 316         TALLOC_FREE(frame);
 317         return status;
 318 }
 319
 320 /****************************************************************************
 321  Deal with removing a share mode on last close.
 322 ****************************************************************************/
 323
 324 static NTSTATUS close_remove_share_mode(files_struct *fsp,
 325                                         enum file_close_type close_type)
 326 {
 327         connection_struct *conn = fsp->conn;
 328         bool delete_file = false;
 329         bool changed_user = false;
 330         struct share_mode_lock *lck = NULL;
 331         NTSTATUS status = NT_STATUS_OK;
 332         NTSTATUS tmp_status;
 333         struct file_id id;
 334         const struct security_unix_token *del_token = NULL;
 335         const struct security_token *del_nt_token = NULL;
 336         bool got_tokens = false;
 337
 338         /* Ensure any pending write time updates are done. */
 339         if (fsp->update_write_time_event) {
 340                 update_write_time_handler(fsp->conn->sconn->ev_ctx,
 341                                         fsp->update_write_time_event,
 342                                         timeval_current(),
 343                                         (void *)fsp);
 344         }
 345
 346         /*
 347          * Lock the share entries, and determine if we should delete
 348          * on close. If so delete whilst the lock is still in effect.
 349          * This prevents race conditions with the file being created. JRA.
 350          */
 351
 352         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
 353         if (lck == NULL) {
 354                 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
 355                           "lock for file %s\n", fsp_str_dbg(fsp)));
 356                 status = NT_STATUS_INVALID_PARAMETER;
 357                 goto done;
 358         }
 359
 360         if (fsp->write_time_forced) {
 361                 DEBUG(10,("close_remove_share_mode: write time forced "
 362                         "for file %s\n",
 363                         fsp_str_dbg(fsp)));
 364                 set_close_write_time(fsp, lck->data->changed_write_time);
 365         } else if (fsp->update_write_time_on_close) {
 366                 /* Someone had a pending write. */
 367                 if (null_timespec(fsp->close_write_time)) {
 368                         DEBUG(10,("close_remove_share_mode: update to current time "
 369                                 "for file %s\n",
 370                                 fsp_str_dbg(fsp)));
 371                         /* Update to current time due to "normal" write. */
 372                         set_close_write_time(fsp, timespec_current());
 373                 } else {
 374                         DEBUG(10,("close_remove_share_mode: write time pending "
 375                                 "for file %s\n",
 376                                 fsp_str_dbg(fsp)));
 377                         /* Update to time set on close call. */
 378                         set_close_write_time(fsp, fsp->close_write_time);
 379                 }
 380         }
 381
 382         if (!del_share_mode(lck, fsp)) {
 383                 DEBUG(0, ("close_remove_share_mode: Could not delete share "
 384                           "entry for file %s\n",
 385                           fsp_str_dbg(fsp)));
 386         }
 387
 388         if (fsp->initial_delete_on_close &&
 389                         !is_delete_on_close_set(lck, fsp->name_hash)) {
 390                 bool became_user = False;
 391
 392                 /* Initial delete on close was set and no one else
 393                  * wrote a real delete on close. */
 394
 395                 if (get_current_vuid(conn) != fsp->vuid) {
 396                         become_user(conn, fsp->vuid);
 397                         became_user = True;
 398                 }
 399                 fsp->delete_on_close = true;
 400                 set_delete_on_close_lck(fsp, lck, True,
 401                                 get_current_nttok(conn),
 402                                 get_current_utok(conn));
 403                 if (became_user) {
 404                         unbecome_user();
 405                 }
 406         }
 407
 408         delete_file = is_delete_on_close_set(lck, fsp->name_hash);
 409
 410         if (delete_file) {
 411                 int i;
 412                 /* See if others still have the file open via this pathname.
 413                    If this is the case, then don't delete. If all opens are
 414                    POSIX delete now. */
 415                 for (i=0; i<lck->data->num_share_modes; i++) {
 416                         struct share_mode_entry *e = &lck->data->share_modes[i];
 417                         if (is_valid_share_mode_entry(e) &&
 418                                         e->name_hash == fsp->name_hash) {
 419                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
 420                                         continue;
 421                                 }
 422                                 delete_file = False;
 423                                 break;
 424                         }
 425                 }
 426         }
 427
 428         /* Notify any deferred opens waiting on this close. */
 429         notify_deferred_opens(conn->sconn, lck);
 430         reply_to_oplock_break_requests(fsp);
 431
 432         /*
 433          * NT can set delete_on_close of the last open
 434          * reference to a file.
 435          */
 436
 437         if (!(close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) ||
 438                         !delete_file) {
 439                 TALLOC_FREE(lck);
 440                 return NT_STATUS_OK;
 441         }
 442
 443         /*
 444          * Ok, we have to delete the file
 445          */
 446
 447         DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
 448                  "- deleting file.\n", fsp_str_dbg(fsp)));
 449
 450         /*
 451          * Don't try to update the write time when we delete the file
 452          */
 453         fsp->update_write_time_on_close = false;
 454
 455         got_tokens = get_delete_on_close_token(lck, fsp->name_hash,
 456                                         &del_nt_token, &del_token);
 457         SMB_ASSERT(got_tokens);
 458
 459         if (!unix_token_equal(del_token, get_current_utok(conn))) {
 460                 /* Become the user who requested the delete. */
 461
 462                 DEBUG(5,("close_remove_share_mode: file %s. "
 463                         "Change user to uid %u\n",
 464                         fsp_str_dbg(fsp),
 465                         (unsigned int)del_token->uid));
 466
 467                 if (!push_sec_ctx()) {
 468                         smb_panic("close_remove_share_mode: file %s. failed to push "
 469                                   "sec_ctx.\n");
 470                 }
 471
 472                 set_sec_ctx(del_token->uid,
 473                             del_token->gid,
 474                             del_token->ngroups,
 475                             del_token->groups,
 476                             del_nt_token);
 477
 478                 changed_user = true;
 479         }
 480
 481         /* We can only delete the file if the name we have is still valid and
 482            hasn't been renamed. */
 483
 484         tmp_status = vfs_stat_fsp(fsp);
 485         if (!NT_STATUS_IS_OK(tmp_status)) {
 486                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 487                          "was set and stat failed with error %s\n",
 488                          fsp_str_dbg(fsp), nt_errstr(tmp_status)));
 489                 /*
 490                  * Don't save the errno here, we ignore this error
 491                  */
 492                 goto done;
 493         }
 494
 495         id = vfs_file_id_from_sbuf(conn, &fsp->fsp_name->st);
 496
 497         if (!file_id_equal(&fsp->file_id, &id)) {
 498                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 499                          "was set and dev and/or inode does not match\n",
 500                          fsp_str_dbg(fsp)));
 501                 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
 502                          "stat file_id %s\n",
 503                          fsp_str_dbg(fsp),
 504                          file_id_string_tos(&fsp->file_id),
 505                          file_id_string_tos(&id)));
 506                 /*
 507                  * Don't save the errno here, we ignore this error
 508                  */
 509                 goto done;
 510         }
 511
 512         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
 513             && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
 514
 515                 status = delete_all_streams(conn, fsp->fsp_name->base_name);
 516
 517                 if (!NT_STATUS_IS_OK(status)) {
 518                         DEBUG(5, ("delete_all_streams failed: %s\n",
 519                                   nt_errstr(status)));
 520                         goto done;
 521                 }
 522         }
 523
 524
 525         if (SMB_VFS_UNLINK(conn, fsp->fsp_name) != 0) {
 526                 /*
 527                  * This call can potentially fail as another smbd may
 528                  * have had the file open with delete on close set and
 529                  * deleted it when its last reference to this file
 530                  * went away. Hence we log this but not at debug level
 531                  * zero.
 532                  */
 533
 534                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 535                          "was set and unlink failed with error %s\n",
 536                          fsp_str_dbg(fsp), strerror(errno)));
 537
 538                 status = map_nt_error_from_unix(errno);
 539         }
 540
 541         /* As we now have POSIX opens which can unlink
 542          * with other open files we may have taken
 543          * this code path with more than one share mode
 544          * entry - ensure we only delete once by resetting
 545          * the delete on close flag. JRA.
 546          */
 547
 548         fsp->delete_on_close = false;
 549         set_delete_on_close_lck(fsp, lck, false, NULL, NULL);
 550
 551  done:
 552
 553         if (changed_user) {
 554                 /* unbecome user. */
 555                 pop_sec_ctx();
 556         }
 557
 558         TALLOC_FREE(lck);
 559
 560         if (delete_file) {
 561                 /*
 562                  * Do the notification after we released the share
 563                  * mode lock. Inside notify_fname we take out another
 564                  * tdb lock. With ctdb also accessing our databases,
 565                  * this can lead to deadlocks. Putting this notify
 566                  * after the TALLOC_FREE(lck) above we avoid locking
 567                  * two records simultaneously. Notifies are async and
 568                  * informational only, so calling the notify_fname
 569                  * without holding the share mode lock should not do
 570                  * any harm.
 571                  */
 572                 notify_fname(conn, NOTIFY_ACTION_REMOVED,
 573                              FILE_NOTIFY_CHANGE_FILE_NAME,
 574                              fsp->fsp_name->base_name);
 575         }
 576
 577         return status;
 578 }
 579
 580 void set_close_write_time(struct files_struct *fsp, struct timespec ts)
 581 {
 582         DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts))));
 583
 584         if (null_timespec(ts)) {
 585                 return;
 586         }
 587         fsp->write_time_forced = false;
 588         fsp->update_write_time_on_close = true;
 589         fsp->close_write_time = ts;
 590 }
 591
 592 static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
 593 {
 594         struct smb_file_time ft;
 595         NTSTATUS status;
 596         struct share_mode_lock *lck = NULL;
 597
 598         ZERO_STRUCT(ft);
 599
 600         if (!fsp->update_write_time_on_close) {
 601                 return NT_STATUS_OK;
 602         }
 603
 604         if (null_timespec(fsp->close_write_time)) {
 605                 fsp->close_write_time = timespec_current();
 606         }
 607
 608         /* Ensure we have a valid stat struct for the source. */
 609         status = vfs_stat_fsp(fsp);
 610         if (!NT_STATUS_IS_OK(status)) {
 611                 return status;
 612         }
 613
 614         if (!VALID_STAT(fsp->fsp_name->st)) {
 615                 /* if it doesn't seem to be a real file */
 616                 return NT_STATUS_OK;
 617         }
 618
 619         /* On close if we're changing the real file time we
 620          * must update it in the open file db too. */
 621         (void)set_write_time(fsp->file_id, fsp->close_write_time);
 622
 623         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
 624         if (lck) {
 625                 /* Close write times overwrite sticky write times
 626                    so we must replace any sticky write time here. */
 627                 if (!null_timespec(lck->data->changed_write_time)) {
 628                         (void)set_sticky_write_time(fsp->file_id, fsp->close_write_time);
 629                 }
 630                 TALLOC_FREE(lck);
 631         }
 632
 633         ft.mtime = fsp->close_write_time;
 634         /* As this is a close based update, we are not directly changing the
 635            file attributes from a client call, but indirectly from a write. */
 636         status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, &ft, false);
 637         if (!NT_STATUS_IS_OK(status)) {
 638                 DEBUG(10,("update_write_time_on_close: smb_set_file_time "
 639                         "on file %s returned %s\n",
 640                         fsp_str_dbg(fsp),
 641                         nt_errstr(status)));
 642                 return status;
 643         }
 644
 645         return status;
 646 }
 647
 648 static NTSTATUS ntstatus_keeperror(NTSTATUS s1, NTSTATUS s2)
 649 {
 650         if (!NT_STATUS_IS_OK(s1)) {
 651                 return s1;
 652         }
 653         return s2;
 654 }
 655
 656 /****************************************************************************
 657  Close a file.
 658
 659  close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
 660  printing and magic scripts are only run on normal close.
 661  delete on close is done on normal and shutdown close.
 662 ****************************************************************************/
 663
 664 static NTSTATUS close_normal_file(struct smb_request *req, files_struct *fsp,
 665                                   enum file_close_type close_type)
 666 {
 667         NTSTATUS status = NT_STATUS_OK;
 668         NTSTATUS tmp;
 669         connection_struct *conn = fsp->conn;
 670         int ret;
 671
 672         /*
 673          * If we're finishing async io on a close we can get a write
 674          * error here, we must remember this.
 675          */
 676         ret = wait_for_aio_completion(fsp);
 677         if (ret) {
 678                 status = ntstatus_keeperror(
 679                         status, map_nt_error_from_unix(ret));
 680         }
 681
 682         if (fsp->smbXsrv->global->durable && close_type == SHUTDOWN_CLOSE) {
 683                 struct share_mode_lock *lck;
 684
 685                 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
 686                 if (lck != NULL) {
 687                         lck->data->share_modes[0].pid.pid = UINT64_MAX;
 688                         lck->data->share_modes[0].pid.task_id = UINT32_MAX;
 689                         lck->data->share_modes[0].pid.vnn = UINT32_MAX;
 690                         lck->data->share_modes[0].pid.unique_id = UINT64_MAX; //todo place NTTIME expire timer here
 691                         lck->data->modified = true;
 692                 }
 693                 TALLOC_FREE(lck);
 694
 695                 tmp = fd_close(fsp);
 696                 status = ntstatus_keeperror(status, tmp);
 697                 file_free(req, fsp);
 698                 return status;
 699         }
 700
 701         /*
 702          * If we're flushing on a close we can get a write
 703          * error here, we must remember this.
 704          */
 705
 706         tmp = close_filestruct(fsp);
 707         status = ntstatus_keeperror(status, tmp);
 708
 709         if (fsp->print_file) {
 710                 /* FIXME: return spool errors */
 711                 print_spool_end(fsp, close_type);
 712                 file_free(req, fsp);
 713                 return NT_STATUS_OK;
 714         }
 715
 716         /* Remove the oplock before potentially deleting the file. */
 717         if(fsp->oplock_type) {
 718                 release_file_oplock(fsp);
 719         }
 720
 721         /* If this is an old DOS or FCB open and we have multiple opens on
 722            the same handle we only have one share mode. Ensure we only remove
 723            the share mode on the last close. */
 724
 725         if (fsp->fh->ref_count == 1) {
 726                 /* Should we return on error here... ? */
 727                 tmp = close_remove_share_mode(fsp, close_type);
 728                 status = ntstatus_keeperror(status, tmp);
 729         }
 730
 731         locking_close_file(conn->sconn->msg_ctx, fsp, close_type);
 732
 733         tmp = fd_close(fsp);
 734         status = ntstatus_keeperror(status, tmp);
 735
 736         /* check for magic scripts */
 737         if (close_type == NORMAL_CLOSE) {
 738                 tmp = check_magic(fsp);
 739                 status = ntstatus_keeperror(status, tmp);
 740         }
 741
 742         /*
 743          * Ensure pending modtime is set after close.
 744          */
 745
 746         tmp = update_write_time_on_close(fsp);
 747         if (NT_STATUS_EQUAL(tmp, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
 748                 /* Someone renamed the file or a parent directory containing
 749                  * this file. We can't do anything about this, we don't have
 750                  * an "update timestamp by fd" call in POSIX. Eat the error. */
 751
 752                 tmp = NT_STATUS_OK;
 753         }
 754
 755         status = ntstatus_keeperror(status, tmp);
 756
 757         DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
 758                 conn->session_info->unix_info->unix_name, fsp_str_dbg(fsp),
 759                 conn->num_files_open - 1,
 760                 nt_errstr(status) ));
 761
 762         file_free(req, fsp);
 763         return status;
 764 }
 765 /****************************************************************************
 766  Static function used by reply_rmdir to delete an entire directory
 767  tree recursively. Return True on ok, False on fail.
 768 ****************************************************************************/
 769
 770 static bool recursive_rmdir(TALLOC_CTX *ctx,
 771                         connection_struct *conn,
 772                         struct smb_filename *smb_dname)
 773 {
 774         const char *dname = NULL;
 775         char *talloced = NULL;
 776         bool ret = True;
 777         long offset = 0;
 778         SMB_STRUCT_STAT st;
 779         struct smb_Dir *dir_hnd;
 780
 781         SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
 782
 783         dir_hnd = OpenDir(talloc_tos(), conn, smb_dname->base_name, NULL, 0);
 784         if(dir_hnd == NULL)
 785                 return False;
 786
 787         while((dname = ReadDirName(dir_hnd, &offset, &st, &talloced))) {
 788                 struct smb_filename *smb_dname_full = NULL;
 789                 char *fullname = NULL;
 790                 bool do_break = true;
 791                 NTSTATUS status;
 792
 793                 if (ISDOT(dname) || ISDOTDOT(dname)) {
 794                         TALLOC_FREE(talloced);
 795                         continue;
 796                 }
 797
 798                 if (!is_visible_file(conn, smb_dname->base_name, dname, &st,
 799                                      false)) {
 800                         TALLOC_FREE(talloced);
 801                         continue;
 802                 }
 803
 804                 /* Construct the full name. */
 805                 fullname = talloc_asprintf(ctx,
 806                                 "%s/%s",
 807                                 smb_dname->base_name,
 808                                 dname);
 809                 if (!fullname) {
 810                         errno = ENOMEM;
 811                         goto err_break;
 812                 }
 813
 814                 status = create_synthetic_smb_fname(talloc_tos(), fullname,
 815                                                     NULL, NULL,
 816                                                     &smb_dname_full);
 817                 if (!NT_STATUS_IS_OK(status)) {
 818                         goto err_break;
 819                 }
 820
 821                 if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
 822                         goto err_break;
 823                 }
 824
 825                 if(smb_dname_full->st.st_ex_mode & S_IFDIR) {
 826                         if(!recursive_rmdir(ctx, conn, smb_dname_full)) {
 827                                 goto err_break;
 828                         }
 829                         if(SMB_VFS_RMDIR(conn,
 830                                          smb_dname_full->base_name) != 0) {
 831                                 goto err_break;
 832                         }
 833                 } else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) {
 834                         goto err_break;
 835                 }
 836
 837                 /* Successful iteration. */
 838                 do_break = false;
 839
 840          err_break:
 841                 TALLOC_FREE(smb_dname_full);
 842                 TALLOC_FREE(fullname);
 843                 TALLOC_FREE(talloced);
 844                 if (do_break) {
 845                         ret = false;
 846                         break;
 847                 }
 848         }
 849         TALLOC_FREE(dir_hnd);
 850         return ret;
 851 }
 852
 853 /****************************************************************************
 854  The internals of the rmdir code - called elsewhere.
 855 ****************************************************************************/
 856
 857 static NTSTATUS rmdir_internals(TALLOC_CTX *ctx, files_struct *fsp)
 858 {
 859         connection_struct *conn = fsp->conn;
 860         struct smb_filename *smb_dname = fsp->fsp_name;
 861         int ret;
 862
 863         SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
 864
 865         /* Might be a symlink. */
 866         if(SMB_VFS_LSTAT(conn, smb_dname) != 0) {
 867                 return map_nt_error_from_unix(errno);
 868         }
 869
 870         if (S_ISLNK(smb_dname->st.st_ex_mode)) {
 871                 /* Is what it points to a directory ? */
 872                 if(SMB_VFS_STAT(conn, smb_dname) != 0) {
 873                         return map_nt_error_from_unix(errno);
 874                 }
 875                 if (!(S_ISDIR(smb_dname->st.st_ex_mode))) {
 876                         return NT_STATUS_NOT_A_DIRECTORY;
 877                 }
 878                 ret = SMB_VFS_UNLINK(conn, smb_dname);
 879         } else {
 880                 ret = SMB_VFS_RMDIR(conn, smb_dname->base_name);
 881         }
 882         if (ret == 0) {
 883                 notify_fname(conn, NOTIFY_ACTION_REMOVED,
 884                              FILE_NOTIFY_CHANGE_DIR_NAME,
 885                              smb_dname->base_name);
 886                 return NT_STATUS_OK;
 887         }
 888
 889         if(((errno == ENOTEMPTY)||(errno == EEXIST)) && *lp_veto_files(SNUM(conn))) {
 890                 /*
 891                  * Check to see if the only thing in this directory are
 892                  * vetoed files/directories. If so then delete them and
 893                  * retry. If we fail to delete any of them (and we *don't*
 894                  * do a recursive delete) then fail the rmdir.
 895                  */
 896                 SMB_STRUCT_STAT st;
 897                 const char *dname = NULL;
 898                 char *talloced = NULL;
 899                 long dirpos = 0;
 900                 struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn,
 901                                                   smb_dname->base_name, NULL,
 902                                                   0);
 903
 904                 if(dir_hnd == NULL) {
 905                         errno = ENOTEMPTY;
 906                         goto err;
 907                 }
 908
 909                 while ((dname = ReadDirName(dir_hnd, &dirpos, &st,
 910                                             &talloced)) != NULL) {
 911                         if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0)) {
 912                                 TALLOC_FREE(talloced);
 913                                 continue;
 914                         }
 915                         if (!is_visible_file(conn, smb_dname->base_name, dname,
 916                                              &st, false)) {
 917                                 TALLOC_FREE(talloced);
 918                                 continue;
 919                         }
 920                         if(!IS_VETO_PATH(conn, dname)) {
 921                                 TALLOC_FREE(dir_hnd);
 922                                 TALLOC_FREE(talloced);
 923                                 errno = ENOTEMPTY;
 924                                 goto err;
 925                         }
 926                         TALLOC_FREE(talloced);
 927                 }
 928
 929                 /* We only have veto files/directories.
 930                  * Are we allowed to delete them ? */
 931
 932                 if(!lp_recursive_veto_delete(SNUM(conn))) {
 933                         TALLOC_FREE(dir_hnd);
 934                         errno = ENOTEMPTY;
 935                         goto err;
 936                 }
 937
 938                 /* Do a recursive delete. */
 939                 RewindDir(dir_hnd,&dirpos);
 940                 while ((dname = ReadDirName(dir_hnd, &dirpos, &st,
 941                                             &talloced)) != NULL) {
 942                         struct smb_filename *smb_dname_full = NULL;
 943                         char *fullname = NULL;
 944                         bool do_break = true;
 945                         NTSTATUS status;
 946
 947                         if (ISDOT(dname) || ISDOTDOT(dname)) {
 948                                 TALLOC_FREE(talloced);
 949                                 continue;
 950                         }
 951                         if (!is_visible_file(conn, smb_dname->base_name, dname,
 952                                              &st, false)) {
 953                                 TALLOC_FREE(talloced);
 954                                 continue;
 955                         }
 956
 957                         fullname = talloc_asprintf(ctx,
 958                                         "%s/%s",
 959                                         smb_dname->base_name,
 960                                         dname);
 961
 962                         if(!fullname) {
 963                                 errno = ENOMEM;
 964                                 goto err_break;
 965                         }
 966
 967                         status = create_synthetic_smb_fname(talloc_tos(),
 968                                                             fullname, NULL,
 969                                                             NULL,
 970                                                             &smb_dname_full);
 971                         if (!NT_STATUS_IS_OK(status)) {
 972                                 errno = map_errno_from_nt_status(status);
 973                                 goto err_break;
 974                         }
 975
 976                         if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
 977                                 goto err_break;
 978                         }
 979                         if(smb_dname_full->st.st_ex_mode & S_IFDIR) {
 980                                 if(!recursive_rmdir(ctx, conn,
 981                                                     smb_dname_full)) {
 982                                         goto err_break;
 983                                 }
 984                                 if(SMB_VFS_RMDIR(conn,
 985                                         smb_dname_full->base_name) != 0) {
 986                                         goto err_break;
 987                                 }
 988                         } else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) {
 989                                 goto err_break;
 990                         }
 991
 992                         /* Successful iteration. */
 993                         do_break = false;
 994
 995                  err_break:
 996                         TALLOC_FREE(fullname);
 997                         TALLOC_FREE(smb_dname_full);
 998                         TALLOC_FREE(talloced);
 999                         if (do_break)
1000                                 break;
1001                 }
1002                 TALLOC_FREE(dir_hnd);
1003                 /* Retry the rmdir */
1004                 ret = SMB_VFS_RMDIR(conn, smb_dname->base_name);
1005         }
1006
1007   err:
1008
1009         if (ret != 0) {
1010                 DEBUG(3,("rmdir_internals: couldn't remove directory %s : "
1011                          "%s\n", smb_fname_str_dbg(smb_dname),
1012                          strerror(errno)));
1013                 return map_nt_error_from_unix(errno);
1014         }
1015
1016         notify_fname(conn, NOTIFY_ACTION_REMOVED,
1017                      FILE_NOTIFY_CHANGE_DIR_NAME,
1018                      smb_dname->base_name);
1019
1020         return NT_STATUS_OK;
1021 }
1022
1023 /****************************************************************************
1024  Close a directory opened by an NT SMB call.
1025 ****************************************************************************/
1026
1027 static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp,
1028                                 enum file_close_type close_type)
1029 {
1030         struct share_mode_lock *lck = NULL;
1031         bool delete_dir = False;
1032         NTSTATUS status = NT_STATUS_OK;
1033         NTSTATUS status1 = NT_STATUS_OK;
1034         const struct security_token *del_nt_token = NULL;
1035         const struct security_unix_token *del_token = NULL;
1036
1037         /*
1038          * NT can set delete_on_close of the last open
1039          * reference to a directory also.
1040          */
1041
1042         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1043         if (lck == NULL) {
1044                 DEBUG(0, ("close_directory: Could not get share mode lock for "
1045                           "%s\n", fsp_str_dbg(fsp)));
1046                 status = NT_STATUS_INVALID_PARAMETER;
1047                 goto out;
1048         }
1049
1050         if (!del_share_mode(lck, fsp)) {
1051                 DEBUG(0, ("close_directory: Could not delete share entry for "
1052                           "%s\n", fsp_str_dbg(fsp)));
1053         }
1054
1055         if (fsp->initial_delete_on_close) {
1056                 bool became_user = False;
1057
1058                 /* Initial delete on close was set - for
1059                  * directories we don't care if anyone else
1060                  * wrote a real delete on close. */
1061
1062                 if (get_current_vuid(fsp->conn) != fsp->vuid) {
1063                         become_user(fsp->conn, fsp->vuid);
1064                         became_user = True;
1065                 }
1066                 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1067                                                fsp->fsp_name->base_name);
1068                 set_delete_on_close_lck(fsp, lck, true,
1069                                 get_current_nttok(fsp->conn),
1070                                 get_current_utok(fsp->conn));
1071                 fsp->delete_on_close = true;
1072                 if (became_user) {
1073                         unbecome_user();
1074                 }
1075         }
1076
1077         delete_dir = get_delete_on_close_token(lck, fsp->name_hash,
1078                                         &del_nt_token, &del_token);
1079
1080         if (delete_dir) {
1081                 int i;
1082                 /* See if others still have the dir open. If this is the
1083                  * case, then don't delete. If all opens are POSIX delete now. */
1084                 for (i=0; i<lck->data->num_share_modes; i++) {
1085                         struct share_mode_entry *e = &lck->data->share_modes[i];
1086                         if (is_valid_share_mode_entry(e) &&
1087                                         e->name_hash == fsp->name_hash) {
1088                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
1089                                         continue;
1090                                 }
1091                                 delete_dir = False;
1092                                 break;
1093                         }
1094                 }
1095         }
1096
1097         if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
1098                                 delete_dir) {
1099
1100                 /* Become the user who requested the delete. */
1101
1102                 if (!push_sec_ctx()) {
1103                         smb_panic("close_directory: failed to push sec_ctx.\n");
1104                 }
1105
1106                 set_sec_ctx(del_token->uid,
1107                                 del_token->gid,
1108                                 del_token->ngroups,
1109                                 del_token->groups,
1110                                 del_nt_token);
1111
1112                 TALLOC_FREE(lck);
1113
1114                 if ((fsp->conn->fs_capabilities & FILE_NAMED_STREAMS)
1115                     && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
1116
1117                         status = delete_all_streams(fsp->conn, fsp->fsp_name->base_name);
1118                         if (!NT_STATUS_IS_OK(status)) {
1119                                 DEBUG(5, ("delete_all_streams failed: %s\n",
1120                                           nt_errstr(status)));
1121                                 goto out;
1122                         }
1123                 }
1124
1125                 status = rmdir_internals(talloc_tos(), fsp);
1126
1127                 DEBUG(5,("close_directory: %s. Delete on close was set - "
1128                          "deleting directory returned %s.\n",
1129                          fsp_str_dbg(fsp), nt_errstr(status)));
1130
1131                 /* unbecome user. */
1132                 pop_sec_ctx();
1133
1134                 /*
1135                  * Ensure we remove any change notify requests that would
1136                  * now fail as the directory has been deleted.
1137                  */
1138
1139                 if(NT_STATUS_IS_OK(status)) {
1140                         remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING);
1141                 }
1142         } else {
1143                 TALLOC_FREE(lck);
1144                 remove_pending_change_notify_requests_by_fid(
1145                         fsp, NT_STATUS_OK);
1146         }
1147
1148         status1 = fd_close(fsp);
1149
1150         if (!NT_STATUS_IS_OK(status1)) {
1151                 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
1152                           fsp_str_dbg(fsp), fsp->fh->fd, errno,
1153                           strerror(errno)));
1154         }
1155
1156         /*
1157          * Do the code common to files and directories.
1158          */
1159         close_filestruct(fsp);
1160         file_free(req, fsp);
1161
1162  out:
1163         TALLOC_FREE(lck);
1164         if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(status1)) {
1165                 status = status1;
1166         }
1167         return status;
1168 }
1169
1170 /****************************************************************************
1171  Close a files_struct.
1172 ****************************************************************************/
1173
1174 NTSTATUS close_file(struct smb_request *req, files_struct *fsp,
1175                     enum file_close_type close_type)
1176 {
1177         NTSTATUS status;
1178         struct files_struct *base_fsp = fsp->base_fsp;
1179
1180         if(fsp->is_directory) {
1181                 status = close_directory(req, fsp, close_type);
1182         } else if (fsp->fake_file_handle != NULL) {
1183                 status = close_fake_file(req, fsp);
1184         } else {
1185                 status = close_normal_file(req, fsp, close_type);
1186         }
1187
1188         if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) {
1189
1190                 /*
1191                  * fsp was a stream, the base fsp can't be a stream as well
1192                  *
1193                  * For SHUTDOWN_CLOSE this is not possible here, because
1194                  * SHUTDOWN_CLOSE only happens from files.c which walks the
1195                  * complete list of files. If we mess with more than one fsp
1196                  * those loops will become confused.
1197                  */
1198
1199                 SMB_ASSERT(base_fsp->base_fsp == NULL);
1200                 close_file(req, base_fsp, close_type);
1201         }
1202
1203         return status;
1204 }
1205
1206 /****************************************************************************
1207  Deal with an (authorized) message to close a file given the share mode
1208  entry.
1209 ****************************************************************************/
1210
1211 void msg_close_file(struct messaging_context *msg_ctx,
1212                         void *private_data,
1213                         uint32_t msg_type,
1214                         struct server_id server_id,
1215                         DATA_BLOB *data)
1216 {
1217         files_struct *fsp = NULL;
1218         struct share_mode_entry e;
1219         struct smbd_server_connection *sconn =
1220                 talloc_get_type_abort(private_data,
1221                 struct smbd_server_connection);
1222
1223         message_to_share_mode_entry(&e, (char *)data->data);
1224
1225         if(DEBUGLVL(10)) {
1226                 char *sm_str = share_mode_str(NULL, 0, &e);
1227                 if (!sm_str) {
1228                         smb_panic("talloc failed");
1229                 }
1230                 DEBUG(10,("msg_close_file: got request to close share mode "
1231                         "entry %s\n", sm_str));
1232                 TALLOC_FREE(sm_str);
1233         }
1234
1235         fsp = file_find_dif(sconn, e.id, e.share_file_id);
1236         if (!fsp) {
1237                 DEBUG(10,("msg_close_file: failed to find file.\n"));
1238                 return;
1239         }
1240         close_file(NULL, fsp, NORMAL_CLOSE);
1241 }