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 "lib/util/server_id.h"
  25 #include "printing.h"
  26 #include "locking/share_mode_lock.h"
  27 #include "smbd/smbd.h"
  28 #include "smbd/globals.h"
  29 #include "smbd/smbXsrv_open.h"
  30 #include "smbd/scavenger.h"
  31 #include "fake_file.h"
  32 #include "transfer_file.h"
  33 #include "auth.h"
  34 #include "messages.h"
  35 #include "../librpc/gen_ndr/open_files.h"
  36 #include "lib/util/tevent_ntstatus.h"
  37 #include "source3/smbd/dir.h"
  38
  39 /****************************************************************************
  40  Run a file if it is a magic script.
  41 ****************************************************************************/
  42
  43 static NTSTATUS check_magic(struct files_struct *fsp)
  44 {
  45         int ret;
  46         const struct loadparm_substitution *lp_sub =
  47                 loadparm_s3_global_substitution();
  48         const char *magic_output = NULL;
  49         SMB_STRUCT_STAT st;
  50         int tmp_fd, outfd;
  51         TALLOC_CTX *ctx = NULL;
  52         const char *p;
  53         struct connection_struct *conn = fsp->conn;
  54         char *fname = NULL;
  55         NTSTATUS status;
  56
  57         if (!*lp_magic_script(talloc_tos(), lp_sub, SNUM(conn))) {
  58                 return NT_STATUS_OK;
  59         }
  60
  61         DEBUG(5,("checking magic for %s\n", fsp_str_dbg(fsp)));
  62
  63         ctx = talloc_stackframe();
  64
  65         fname = fsp->fsp_name->base_name;
  66
  67         if (!(p = strrchr_m(fname,'/'))) {
  68                 p = fname;
  69         } else {
  70                 p++;
  71         }
  72
  73         if (!strequal(lp_magic_script(talloc_tos(), lp_sub, SNUM(conn)),p)) {
  74                 status = NT_STATUS_OK;
  75                 goto out;
  76         }
  77
  78         if (*lp_magic_output(talloc_tos(), lp_sub, SNUM(conn))) {
  79                 magic_output = lp_magic_output(talloc_tos(), lp_sub, SNUM(conn));
  80         } else {
  81                 magic_output = talloc_asprintf(ctx,
  82                                 "%s.out",
  83                                 fname);
  84         }
  85         if (!magic_output) {
  86                 status = NT_STATUS_NO_MEMORY;
  87                 goto out;
  88         }
  89
  90         /* Ensure we don't depend on user's PATH. */
  91         p = talloc_asprintf(ctx, "./%s", fname);
  92         if (!p) {
  93                 status = NT_STATUS_NO_MEMORY;
  94                 goto out;
  95         }
  96
  97         if (chmod(fname, 0755) == -1) {
  98                 status = map_nt_error_from_unix(errno);
  99                 goto out;
 100         }
 101         ret = smbrun(p, &tmp_fd, NULL);
 102         DEBUG(3,("Invoking magic command %s gave %d\n",
 103                 p,ret));
 104
 105         unlink(fname);
 106         if (ret != 0 || tmp_fd == -1) {
 107                 if (tmp_fd != -1) {
 108                         close(tmp_fd);
 109                 }
 110                 status = NT_STATUS_UNSUCCESSFUL;
 111                 goto out;
 112         }
 113         outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
 114         if (outfd == -1) {
 115                 int err = errno;
 116                 close(tmp_fd);
 117                 status = map_nt_error_from_unix(err);
 118                 goto out;
 119         }
 120
 121         if (sys_fstat(tmp_fd, &st, false) == -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
 129         if (transfer_file(tmp_fd,outfd,(off_t)st.st_ex_size) == (off_t)-1) {
 130                 int err = errno;
 131                 close(tmp_fd);
 132                 close(outfd);
 133                 status = map_nt_error_from_unix(err);
 134                 goto out;
 135         }
 136         close(tmp_fd);
 137         if (close(outfd) == -1) {
 138                 status = map_nt_error_from_unix(errno);
 139                 goto out;
 140         }
 141
 142         status = NT_STATUS_OK;
 143
 144  out:
 145         TALLOC_FREE(ctx);
 146         return status;
 147 }
 148
 149 /****************************************************************************
 150  Delete all streams
 151 ****************************************************************************/
 152
 153 NTSTATUS delete_all_streams(connection_struct *conn,
 154                         const struct smb_filename *smb_fname)
 155 {
 156         struct stream_struct *stream_info = NULL;
 157         unsigned int i;
 158         unsigned int num_streams = 0;
 159         TALLOC_CTX *frame = talloc_stackframe();
 160         NTSTATUS status;
 161
 162         status = vfs_fstreaminfo(smb_fname->fsp, talloc_tos(),
 163                                 &num_streams, &stream_info);
 164
 165         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
 166                 DEBUG(10, ("no streams around\n"));
 167                 TALLOC_FREE(frame);
 168                 return NT_STATUS_OK;
 169         }
 170
 171         if (!NT_STATUS_IS_OK(status)) {
 172                 DEBUG(10, ("vfs_fstreaminfo failed: %s\n",
 173                            nt_errstr(status)));
 174                 goto fail;
 175         }
 176
 177         DEBUG(10, ("delete_all_streams found %d streams\n",
 178                    num_streams));
 179
 180         if (num_streams == 0) {
 181                 TALLOC_FREE(frame);
 182                 return NT_STATUS_OK;
 183         }
 184
 185         for (i=0; i<num_streams; i++) {
 186                 int res;
 187                 struct smb_filename *smb_fname_stream;
 188
 189                 if (strequal(stream_info[i].name, "::$DATA")) {
 190                         continue;
 191                 }
 192
 193                 status = synthetic_pathref(talloc_tos(),
 194                                            conn->cwd_fsp,
 195                                            smb_fname->base_name,
 196                                            stream_info[i].name,
 197                                            NULL,
 198                                            smb_fname->twrp,
 199                                            (smb_fname->flags &
 200                                             ~SMB_FILENAME_POSIX_PATH),
 201                                            &smb_fname_stream);
 202                 if (!NT_STATUS_IS_OK(status)) {
 203                         DEBUG(0, ("talloc_aprintf failed\n"));
 204                         status = NT_STATUS_NO_MEMORY;
 205                         goto fail;
 206                 }
 207
 208                 res = SMB_VFS_UNLINKAT(conn,
 209                                 conn->cwd_fsp,
 210                                 smb_fname_stream,
 211                                 0);
 212
 213                 if (res == -1) {
 214                         status = map_nt_error_from_unix(errno);
 215                         DEBUG(10, ("Could not delete stream %s: %s\n",
 216                                    smb_fname_str_dbg(smb_fname_stream),
 217                                    strerror(errno)));
 218                         TALLOC_FREE(smb_fname_stream);
 219                         break;
 220                 }
 221                 TALLOC_FREE(smb_fname_stream);
 222         }
 223
 224  fail:
 225         TALLOC_FREE(frame);
 226         return status;
 227 }
 228
 229 struct has_other_nonposix_opens_state {
 230         files_struct *fsp;
 231         bool found_another;
 232 };
 233
 234 static bool has_other_nonposix_opens_fn(
 235         struct share_mode_entry *e,
 236         bool *modified,
 237         void *private_data)
 238 {
 239         struct has_other_nonposix_opens_state *state = private_data;
 240         struct files_struct *fsp = state->fsp;
 241
 242         if (e->name_hash != fsp->name_hash) {
 243                 return false;
 244         }
 245         if (e->flags & SHARE_MODE_FLAG_POSIX_OPEN) {
 246                 return false;
 247         }
 248         if (e->share_file_id == fh_get_gen_id(fsp->fh)) {
 249                 struct server_id self = messaging_server_id(
 250                         fsp->conn->sconn->msg_ctx);
 251                 if (server_id_equal(&self, &e->pid)) {
 252                         return false;
 253                 }
 254         }
 255         if (share_entry_stale_pid(e)) {
 256                 return false;
 257         }
 258
 259         state->found_another = true;
 260         return true;
 261 }
 262
 263 bool has_other_nonposix_opens(struct share_mode_lock *lck,
 264                               struct files_struct *fsp)
 265 {
 266         struct has_other_nonposix_opens_state state = { .fsp = fsp };
 267         bool ok;
 268
 269         ok = share_mode_forall_entries(
 270                 lck, has_other_nonposix_opens_fn, &state);
 271         if (!ok) {
 272                 return false;
 273         }
 274         return state.found_another;
 275 }
 276
 277 struct close_share_mode_lock_state {
 278         struct share_mode_entry_prepare_state prepare_state;
 279         const char *object_type;
 280         struct files_struct *fsp;
 281         enum file_close_type close_type;
 282         bool delete_object;
 283         bool got_tokens;
 284         const struct security_unix_token *del_token;
 285         const struct security_token *del_nt_token;
 286         bool reset_delete_on_close;
 287         share_mode_entry_prepare_unlock_fn_t cleanup_fn;
 288 };
 289
 290 static void close_share_mode_lock_prepare(struct share_mode_lock *lck,
 291                                           bool *keep_locked,
 292                                           void *private_data)
 293 {
 294         struct close_share_mode_lock_state *state =
 295                 (struct close_share_mode_lock_state *)private_data;
 296         struct files_struct *fsp = state->fsp;
 297         bool normal_close;
 298         bool ok;
 299
 300         /*
 301          * By default drop the g_lock again if we leave the
 302          * tdb chainlock.
 303          */
 304         *keep_locked = false;
 305
 306         if (fsp->oplock_type != NO_OPLOCK) {
 307                 ok = remove_share_oplock(lck, fsp);
 308                 if (!ok) {
 309                         struct file_id_buf buf;
 310
 311                         DBG_ERR("failed to remove share oplock for "
 312                                 "%s %s, %s, %s\n",
 313                                 state->object_type,
 314                                 fsp_str_dbg(fsp), fsp_fnum_dbg(fsp),
 315                                 file_id_str_buf(fsp->file_id, &buf));
 316                 }
 317         }
 318
 319         if (fsp->fsp_flags.write_time_forced) {
 320                 NTTIME mtime = share_mode_changed_write_time(lck);
 321                 struct timespec ts = nt_time_to_full_timespec(mtime);
 322
 323                 DBG_DEBUG("write time forced for %s %s\n",
 324                           state->object_type, fsp_str_dbg(fsp));
 325                 set_close_write_time(fsp, ts);
 326         } else if (fsp->fsp_flags.update_write_time_on_close) {
 327                 /* Someone had a pending write. */
 328                 if (is_omit_timespec(&fsp->close_write_time)) {
 329                         DBG_DEBUG("update to current time for %s %s\n",
 330                                   state->object_type, fsp_str_dbg(fsp));
 331                         /* Update to current time due to "normal" write. */
 332                         set_close_write_time(fsp, timespec_current());
 333                 } else {
 334                         DBG_DEBUG("write time pending for %s %s\n",
 335                                   state->object_type, fsp_str_dbg(fsp));
 336                         /* Update to time set on close call. */
 337                         set_close_write_time(fsp, fsp->close_write_time);
 338                 }
 339         }
 340
 341         if (fsp->fsp_flags.initial_delete_on_close &&
 342                         !is_delete_on_close_set(lck, fsp->name_hash)) {
 343                 /* Initial delete on close was set and no one else
 344                  * wrote a real delete on close. */
 345
 346                 fsp->fsp_flags.delete_on_close = true;
 347                 set_delete_on_close_lck(fsp, lck,
 348                                         fsp->conn->session_info->security_token,
 349                                         fsp->conn->session_info->unix_token);
 350         }
 351
 352         state->delete_object = is_delete_on_close_set(lck, fsp->name_hash) &&
 353                 !has_other_nonposix_opens(lck, fsp);
 354
 355         /*
 356          * NT can set delete_on_close of the last open
 357          * reference to a file.
 358          */
 359
 360         normal_close = (state->close_type == NORMAL_CLOSE || state->close_type == SHUTDOWN_CLOSE);
 361         if (!normal_close) {
 362                 /*
 363                  * Never try to delete the file/directory for ERROR_CLOSE
 364                  */
 365                 state->delete_object = false;
 366         }
 367
 368         if (!state->delete_object) {
 369                 ok = del_share_mode(lck, fsp);
 370                 if (!ok) {
 371                         DBG_ERR("Could not delete share entry for %s %s\n",
 372                                 state->object_type, fsp_str_dbg(fsp));
 373                 }
 374                 return;
 375         }
 376
 377         /*
 378          * We're going to remove the file/directory
 379          * so keep the g_lock after the tdb chainlock
 380          * is left, so we hold the share_mode_lock
 381          * also during the deletion
 382          */
 383         *keep_locked = true;
 384
 385         state->got_tokens = get_delete_on_close_token(lck, fsp->name_hash,
 386                                         &state->del_nt_token, &state->del_token);
 387         if (state->close_type != ERROR_CLOSE) {
 388                 SMB_ASSERT(state->got_tokens);
 389         }
 390 }
 391
 392 static void close_share_mode_lock_cleanup(struct share_mode_lock *lck,
 393                                           void *private_data)
 394 {
 395         struct close_share_mode_lock_state *state =
 396                 (struct close_share_mode_lock_state *)private_data;
 397         struct files_struct *fsp = state->fsp;
 398         bool ok;
 399
 400         if (state->reset_delete_on_close) {
 401                 reset_delete_on_close_lck(fsp, lck);
 402         }
 403
 404         ok = del_share_mode(lck, fsp);
 405         if (!ok) {
 406                 DBG_ERR("Could not delete share entry for %s %s\n",
 407                         state->object_type, fsp_str_dbg(fsp));
 408         }
 409 }
 410
 411 /****************************************************************************
 412  Deal with removing a share mode on last close.
 413 ****************************************************************************/
 414
 415 static NTSTATUS close_remove_share_mode(files_struct *fsp,
 416                                         enum file_close_type close_type)
 417 {
 418         connection_struct *conn = fsp->conn;
 419         struct close_share_mode_lock_state lck_state = {};
 420         bool changed_user = false;
 421         NTSTATUS status = NT_STATUS_OK;
 422         NTSTATUS tmp_status;
 423         NTSTATUS ulstatus;
 424         struct file_id id;
 425         struct smb_filename *parent_fname = NULL;
 426         struct smb_filename *base_fname = NULL;
 427         int ret;
 428
 429         /* Ensure any pending write time updates are done. */
 430         if (fsp->update_write_time_event) {
 431                 fsp_flush_write_time_update(fsp);
 432         }
 433
 434         /*
 435          * Lock the share entries, and determine if we should delete
 436          * on close. If so delete whilst the lock is still in effect.
 437          * This prevents race conditions with the file being created. JRA.
 438          */
 439
 440         lck_state = (struct close_share_mode_lock_state) {
 441                 .fsp                    = fsp,
 442                 .object_type            = "file",
 443                 .close_type             = close_type,
 444         };
 445
 446         status = share_mode_entry_prepare_lock_del(&lck_state.prepare_state,
 447                                                    fsp->file_id,
 448                                                    close_share_mode_lock_prepare,
 449                                                    &lck_state);
 450         if (!NT_STATUS_IS_OK(status)) {
 451                 DBG_ERR("share_mode_entry_prepare_lock_del() failed for %s - %s\n",
 452                         fsp_str_dbg(fsp), nt_errstr(status));
 453                 return status;
 454         }
 455
 456         /* Remove the oplock before potentially deleting the file. */
 457         if (fsp->oplock_type != NO_OPLOCK) {
 458                 release_file_oplock(fsp);
 459         }
 460
 461         /*
 462          * NT can set delete_on_close of the last open
 463          * reference to a file.
 464          */
 465
 466         if (!lck_state.delete_object) {
 467                 status = NT_STATUS_OK;
 468                 goto done;
 469         }
 470
 471         /*
 472          * Ok, we have to delete the file
 473          */
 474         lck_state.cleanup_fn = close_share_mode_lock_cleanup;
 475
 476         DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
 477                  "- deleting file.\n", fsp_str_dbg(fsp)));
 478
 479         /*
 480          * Don't try to update the write time when we delete the file
 481          */
 482         fsp->fsp_flags.update_write_time_on_close = false;
 483
 484         if (lck_state.got_tokens &&
 485             !unix_token_equal(lck_state.del_token, get_current_utok(conn)))
 486         {
 487                 /* Become the user who requested the delete. */
 488
 489                 DEBUG(5,("close_remove_share_mode: file %s. "
 490                         "Change user to uid %u\n",
 491                         fsp_str_dbg(fsp),
 492                         (unsigned int)lck_state.del_token->uid));
 493
 494                 if (!push_sec_ctx()) {
 495                         smb_panic("close_remove_share_mode: file %s. failed to push "
 496                                   "sec_ctx.\n");
 497                 }
 498
 499                 set_sec_ctx(lck_state.del_token->uid,
 500                             lck_state.del_token->gid,
 501                             lck_state.del_token->ngroups,
 502                             lck_state.del_token->groups,
 503                             lck_state.del_nt_token);
 504
 505                 changed_user = true;
 506         }
 507
 508         /* We can only delete the file if the name we have is still valid and
 509            hasn't been renamed. */
 510
 511         tmp_status = vfs_stat_fsp(fsp);
 512         if (!NT_STATUS_IS_OK(tmp_status)) {
 513                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 514                          "was set and stat failed with error %s\n",
 515                          fsp_str_dbg(fsp), nt_errstr(tmp_status)));
 516                 /*
 517                  * Don't save the errno here, we ignore this error
 518                  */
 519                 goto done;
 520         }
 521
 522         id = vfs_file_id_from_sbuf(conn, &fsp->fsp_name->st);
 523
 524         if (!file_id_equal(&fsp->file_id, &id)) {
 525                 struct file_id_buf ftmp1, ftmp2;
 526                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 527                          "was set and dev and/or inode does not match\n",
 528                          fsp_str_dbg(fsp)));
 529                 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
 530                          "stat file_id %s\n",
 531                          fsp_str_dbg(fsp),
 532                          file_id_str_buf(fsp->file_id, &ftmp1),
 533                          file_id_str_buf(id, &ftmp2)));
 534                 /*
 535                  * Don't save the errno here, we ignore this error
 536                  */
 537                 goto done;
 538         }
 539
 540         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
 541             && !fsp_is_alternate_stream(fsp)) {
 542
 543                 status = delete_all_streams(conn, fsp->fsp_name);
 544
 545                 if (!NT_STATUS_IS_OK(status)) {
 546                         DEBUG(5, ("delete_all_streams failed: %s\n",
 547                                   nt_errstr(status)));
 548                         goto done;
 549                 }
 550         }
 551
 552         if (fsp->fsp_flags.kernel_share_modes_taken) {
 553                 /*
 554                  * A file system sharemode could block the unlink;
 555                  * remove filesystem sharemodes first.
 556                  */
 557                 ret = SMB_VFS_FILESYSTEM_SHAREMODE(fsp, 0, 0);
 558                 if (ret == -1) {
 559                         DBG_INFO("Removing file system sharemode for %s "
 560                                  "failed: %s\n",
 561                                  fsp_str_dbg(fsp), strerror(errno));
 562                 }
 563
 564                 fsp->fsp_flags.kernel_share_modes_taken = false;
 565         }
 566
 567         status = parent_pathref(talloc_tos(),
 568                                 conn->cwd_fsp,
 569                                 fsp->fsp_name,
 570                                 &parent_fname,
 571                                 &base_fname);
 572         if (!NT_STATUS_IS_OK(status)) {
 573                 goto done;
 574         }
 575
 576         ret = SMB_VFS_UNLINKAT(conn,
 577                                parent_fname->fsp,
 578                                base_fname,
 579                                0);
 580         TALLOC_FREE(parent_fname);
 581         base_fname = NULL;
 582         if (ret != 0) {
 583                 /*
 584                  * This call can potentially fail as another smbd may
 585                  * have had the file open with delete on close set and
 586                  * deleted it when its last reference to this file
 587                  * went away. Hence we log this but not at debug level
 588                  * zero.
 589                  */
 590
 591                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 592                          "was set and unlink failed with error %s\n",
 593                          fsp_str_dbg(fsp), strerror(errno)));
 594
 595                 status = map_nt_error_from_unix(errno);
 596         }
 597
 598         /* As we now have POSIX opens which can unlink
 599          * with other open files we may have taken
 600          * this code path with more than one share mode
 601          * entry - ensure we only delete once by resetting
 602          * the delete on close flag. JRA.
 603          */
 604
 605         fsp->fsp_flags.delete_on_close = false;
 606         fsp->fsp_flags.fstat_before_close = false;
 607         lck_state.reset_delete_on_close = true;
 608
 609  done:
 610
 611         if (changed_user) {
 612                 /* unbecome user. */
 613                 pop_sec_ctx();
 614         }
 615
 616         if (fsp->fsp_flags.kernel_share_modes_taken) {
 617                 /* remove filesystem sharemodes */
 618                 ret = SMB_VFS_FILESYSTEM_SHAREMODE(fsp, 0, 0);
 619                 if (ret == -1) {
 620                         DBG_INFO("Removing file system sharemode for "
 621                                  "%s failed: %s\n",
 622                                  fsp_str_dbg(fsp), strerror(errno));
 623                 }
 624         }
 625
 626         ulstatus = share_mode_entry_prepare_unlock(&lck_state.prepare_state,
 627                                                    lck_state.cleanup_fn,
 628                                                    &lck_state);
 629         if (!NT_STATUS_IS_OK(ulstatus)) {
 630                 DBG_ERR("share_mode_entry_prepare_unlock() failed for %s - %s\n",
 631                         fsp_str_dbg(fsp), nt_errstr(ulstatus));
 632                 smb_panic("share_mode_entry_prepare_unlock() failed!");
 633         }
 634
 635         if (lck_state.delete_object) {
 636                 /*
 637                  * Do the notification after we released the share
 638                  * mode lock. Inside notify_fname we take out another
 639                  * tdb lock. With ctdb also accessing our databases,
 640                  * this can lead to deadlocks. Putting this notify
 641                  * after the TALLOC_FREE(lck) above we avoid locking
 642                  * two records simultaneously. Notifies are async and
 643                  * informational only, so calling the notify_fname
 644                  * without holding the share mode lock should not do
 645                  * any harm.
 646                  */
 647                 notify_fname(conn, NOTIFY_ACTION_REMOVED,
 648                              FILE_NOTIFY_CHANGE_FILE_NAME,
 649                              fsp->fsp_name->base_name);
 650         }
 651
 652         return status;
 653 }
 654
 655 void set_close_write_time(struct files_struct *fsp, struct timespec ts)
 656 {
 657         DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts))));
 658
 659         if (is_omit_timespec(&ts)) {
 660                 return;
 661         }
 662         fsp->fsp_flags.write_time_forced = false;
 663         fsp->fsp_flags.update_write_time_on_close = true;
 664         fsp->close_write_time = ts;
 665 }
 666
 667 static void update_write_time_on_close_share_mode_fn(struct share_mode_lock *lck,
 668                                                      void *private_data)
 669 {
 670         struct files_struct *fsp =
 671                 talloc_get_type_abort(private_data,
 672                 struct files_struct);
 673         NTTIME share_mtime = share_mode_changed_write_time(lck);
 674
 675         /*
 676          * On close if we're changing the real file time we
 677          * must update it in the open file db too.
 678          */
 679         share_mode_set_old_write_time(lck, fsp->close_write_time);
 680
 681         /*
 682          * Close write times overwrite sticky write times
 683          * so we must replace any sticky write time here.
 684          */
 685         if (!null_nttime(share_mtime)) {
 686                 share_mode_set_changed_write_time(lck, fsp->close_write_time);
 687         }
 688 }
 689
 690 static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
 691 {
 692         struct smb_file_time ft;
 693         NTSTATUS status;
 694
 695         init_smb_file_time(&ft);
 696
 697         if (!(fsp->fsp_flags.update_write_time_on_close)) {
 698                 return NT_STATUS_OK;
 699         }
 700
 701         if (is_omit_timespec(&fsp->close_write_time)) {
 702                 fsp->close_write_time = timespec_current();
 703         }
 704
 705         /* Ensure we have a valid stat struct for the source. */
 706         status = vfs_stat_fsp(fsp);
 707         if (!NT_STATUS_IS_OK(status)) {
 708                 return status;
 709         }
 710
 711         if (!VALID_STAT(fsp->fsp_name->st)) {
 712                 /* if it doesn't seem to be a real file */
 713                 return NT_STATUS_OK;
 714         }
 715
 716         /*
 717          * We're being called after close_remove_share_mode() inside
 718          * close_normal_file() so it's quite normal to not have an
 719          * existing share. So just ignore the result of
 720          * share_mode_do_locked_vfs_denied()...
 721          */
 722         share_mode_do_locked_vfs_denied(fsp->file_id,
 723                                         update_write_time_on_close_share_mode_fn,
 724                                         fsp);
 725
 726         ft.mtime = fsp->close_write_time;
 727         /* As this is a close based update, we are not directly changing the
 728            file attributes from a client call, but indirectly from a write. */
 729         status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, &ft, false);
 730         if (!NT_STATUS_IS_OK(status)) {
 731                 DEBUG(10,("update_write_time_on_close: smb_set_file_time "
 732                         "on file %s returned %s\n",
 733                         fsp_str_dbg(fsp),
 734                         nt_errstr(status)));
 735                 return status;
 736         }
 737
 738         return status;
 739 }
 740
 741 static NTSTATUS ntstatus_keeperror(NTSTATUS s1, NTSTATUS s2)
 742 {
 743         if (!NT_STATUS_IS_OK(s1)) {
 744                 return s1;
 745         }
 746         return s2;
 747 }
 748
 749 static void assert_no_pending_aio(struct files_struct *fsp,
 750                                   enum file_close_type close_type)
 751 {
 752         struct smbXsrv_client *client = global_smbXsrv_client;
 753         size_t num_connections_alive;
 754         unsigned num_requests = fsp->num_aio_requests;
 755
 756         if (num_requests == 0) {
 757                 return;
 758         }
 759
 760         num_connections_alive = smbXsrv_client_valid_connections(client);
 761
 762         if (close_type == SHUTDOWN_CLOSE && num_connections_alive == 0) {
 763                 /*
 764                  * fsp->aio_requests and the contents (fsp->aio_requests[x])
 765                  * are both independently owned by fsp and are not in a
 766                  * talloc hierarchy. This allows the fsp->aio_requests array to
 767                  * be reallocated independently of the array contents so it can
 768                  * grow on demand.
 769                  *
 770                  * This means we must ensure order of deallocation
 771                  * on a SHUTDOWN_CLOSE by deallocating the fsp->aio_requests[x]
 772                  * contents first, as their destructors access the
 773                  * fsp->aio_request array. If we don't deallocate them
 774                  * first, when fsp is deallocated fsp->aio_requests
 775                  * could have been deallocated *before* its contents
 776                  * fsp->aio_requests[x], causing a crash.
 777                  */
 778                 while (fsp->num_aio_requests != 0) {
 779                         /*
 780                          * NB. We *MUST* use
 781                          * talloc_free(fsp->aio_requests[0]),
 782                          * and *NOT* TALLOC_FREE() here, as
 783                          * TALLOC_FREE(fsp->aio_requests[0])
 784                          * will overwrite any new contents of
 785                          * fsp->aio_requests[0] that were
 786                          * copied into it via the destructor
 787                          * aio_del_req_from_fsp().
 788                          *
 789                          * BUG: https://bugzilla.samba.org/show_bug.cgi?id=14515
 790                          */
 791                         talloc_free(fsp->aio_requests[0]);
 792                 }
 793                 return;
 794         }
 795
 796         DBG_ERR("fsp->num_aio_requests=%u\n", num_requests);
 797         smb_panic("can not close with outstanding aio requests");
 798         return;
 799 }
 800
 801 /****************************************************************************
 802  Close a file.
 803
 804  close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
 805  printing and magic scripts are only run on normal close.
 806  delete on close is done on normal and shutdown close.
 807 ****************************************************************************/
 808
 809 static NTSTATUS close_normal_file(struct smb_request *req, files_struct *fsp,
 810                                   enum file_close_type close_type)
 811 {
 812         NTSTATUS status = NT_STATUS_OK;
 813         NTSTATUS tmp;
 814         connection_struct *conn = fsp->conn;
 815         bool is_durable = false;
 816
 817         SMB_ASSERT(fsp->fsp_flags.is_fsa);
 818
 819         assert_no_pending_aio(fsp, close_type);
 820
 821         while (talloc_array_length(fsp->blocked_smb1_lock_reqs) != 0) {
 822                 smbd_smb1_brl_finish_by_req(
 823                         fsp->blocked_smb1_lock_reqs[0],
 824                         NT_STATUS_RANGE_NOT_LOCKED);
 825         }
 826
 827         /*
 828          * If we're flushing on a close we can get a write
 829          * error here, we must remember this.
 830          */
 831
 832         if (NT_STATUS_IS_OK(status) && fsp->op != NULL) {
 833                 is_durable = fsp->op->global->durable;
 834         }
 835
 836         if (close_type != SHUTDOWN_CLOSE) {
 837                 is_durable = false;
 838         }
 839
 840         if (is_durable) {
 841                 DATA_BLOB new_cookie = data_blob_null;
 842
 843                 tmp = SMB_VFS_DURABLE_DISCONNECT(fsp,
 844                                         fsp->op->global->backend_cookie,
 845                                         fsp->op,
 846                                         &new_cookie);
 847                 if (NT_STATUS_IS_OK(tmp)) {
 848                         struct timeval tv;
 849                         NTTIME now;
 850
 851                         if (req != NULL) {
 852                                 tv = req->request_time;
 853                         } else {
 854                                 tv = timeval_current();
 855                         }
 856                         now = timeval_to_nttime(&tv);
 857
 858                         data_blob_free(&fsp->op->global->backend_cookie);
 859                         fsp->op->global->backend_cookie = new_cookie;
 860
 861                         fsp->op->compat = NULL;
 862                         tmp = smbXsrv_open_close(fsp->op, now);
 863                         if (!NT_STATUS_IS_OK(tmp)) {
 864                                 DEBUG(1, ("Failed to update smbXsrv_open "
 865                                           "record when disconnecting durable "
 866                                           "handle for file %s: %s - "
 867                                           "proceeding with normal close\n",
 868                                           fsp_str_dbg(fsp), nt_errstr(tmp)));
 869                         }
 870                         scavenger_schedule_disconnected(fsp);
 871                 } else {
 872                         DEBUG(1, ("Failed to disconnect durable handle for "
 873                                   "file %s: %s - proceeding with normal "
 874                                   "close\n", fsp_str_dbg(fsp), nt_errstr(tmp)));
 875                 }
 876                 if (!NT_STATUS_IS_OK(tmp)) {
 877                         is_durable = false;
 878                 }
 879         }
 880
 881         if (is_durable) {
 882                 /*
 883                  * This is the case where we successfully disconnected
 884                  * a durable handle and closed the underlying file.
 885                  * In all other cases, we proceed with a genuine close.
 886                  */
 887                 DEBUG(10, ("%s disconnected durable handle for file %s\n",
 888                            conn->session_info->unix_info->unix_name,
 889                            fsp_str_dbg(fsp)));
 890                 return NT_STATUS_OK;
 891         }
 892
 893         if (fsp->op != NULL) {
 894                 /*
 895                  * Make sure the handle is not marked as durable anymore
 896                  */
 897                 fsp->op->global->durable = false;
 898         }
 899
 900         /* If this is an old DOS or FCB open and we have multiple opens on
 901            the same handle we only have one share mode. Ensure we only remove
 902            the share mode on the last close. */
 903
 904         if (fh_get_refcount(fsp->fh) == 1) {
 905                 /* Should we return on error here... ? */
 906                 tmp = close_remove_share_mode(fsp, close_type);
 907                 status = ntstatus_keeperror(status, tmp);
 908         }
 909
 910         locking_close_file(fsp, close_type);
 911
 912         /*
 913          * Ensure pending modtime is set before closing underlying fd.
 914          */
 915
 916         tmp = update_write_time_on_close(fsp);
 917         if (NT_STATUS_EQUAL(tmp, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
 918                 /*
 919                  * Someone renamed the file or a parent directory containing
 920                  * this file. We can't do anything about this, eat the error.
 921                  */
 922                 tmp = NT_STATUS_OK;
 923         }
 924         status = ntstatus_keeperror(status, tmp);
 925
 926         tmp = fd_close(fsp);
 927         status = ntstatus_keeperror(status, tmp);
 928
 929         /* check for magic scripts */
 930         if (close_type == NORMAL_CLOSE) {
 931                 tmp = check_magic(fsp);
 932                 status = ntstatus_keeperror(status, tmp);
 933         }
 934
 935         DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
 936                 conn->session_info->unix_info->unix_name, fsp_str_dbg(fsp),
 937                 conn->num_files_open - 1,
 938                 nt_errstr(status) ));
 939
 940         return status;
 941 }
 942 /****************************************************************************
 943  Function used by reply_rmdir to delete an entire directory
 944  tree recursively. Return True on ok, False on fail.
 945 ****************************************************************************/
 946
 947 NTSTATUS recursive_rmdir(TALLOC_CTX *ctx,
 948                      connection_struct *conn,
 949                      struct smb_filename *smb_dname)
 950 {
 951         const char *dname = NULL;
 952         char *talloced = NULL;
 953         struct smb_Dir *dir_hnd = NULL;
 954         struct files_struct *dirfsp = NULL;
 955         int retval;
 956         NTSTATUS status = NT_STATUS_OK;
 957
 958         SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
 959
 960         status = OpenDir(talloc_tos(),
 961                          conn,
 962                          smb_dname,
 963                          NULL,
 964                          0,
 965                          &dir_hnd);
 966         if (!NT_STATUS_IS_OK(status)) {
 967                 return status;
 968         }
 969
 970         dirfsp = dir_hnd_fetch_fsp(dir_hnd);
 971
 972         while ((dname = ReadDirName(dir_hnd, &talloced))) {
 973                 struct smb_filename *atname = NULL;
 974                 struct smb_filename *smb_dname_full = NULL;
 975                 char *fullname = NULL;
 976                 bool do_break = true;
 977                 int unlink_flags = 0;
 978
 979                 if (ISDOT(dname) || ISDOTDOT(dname)) {
 980                         TALLOC_FREE(talloced);
 981                         continue;
 982                 }
 983
 984                 /* Construct the full name. */
 985                 fullname = talloc_asprintf(ctx,
 986                                 "%s/%s",
 987                                 smb_dname->base_name,
 988                                 dname);
 989                 if (!fullname) {
 990                         status = NT_STATUS_NO_MEMORY;
 991                         goto err_break;
 992                 }
 993
 994                 smb_dname_full = synthetic_smb_fname(talloc_tos(),
 995                                                 fullname,
 996                                                 NULL,
 997                                                 NULL,
 998                                                 smb_dname->twrp,
 999                                                 smb_dname->flags);
1000                 if (smb_dname_full == NULL) {
1001                         status = NT_STATUS_NO_MEMORY;
1002                         goto err_break;
1003                 }
1004
1005                 if (SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
1006                         status = map_nt_error_from_unix(errno);
1007                         goto err_break;
1008                 }
1009
1010                 if (smb_dname_full->st.st_ex_mode & S_IFDIR) {
1011                         status = recursive_rmdir(ctx, conn, smb_dname_full);
1012                         if (!NT_STATUS_IS_OK(status)) {
1013                                 goto err_break;
1014                         }
1015                         unlink_flags = AT_REMOVEDIR;
1016                 }
1017
1018                 status = synthetic_pathref(talloc_tos(),
1019                                            dirfsp,
1020                                            dname,
1021                                            NULL,
1022                                            &smb_dname_full->st,
1023                                            smb_dname_full->twrp,
1024                                            smb_dname_full->flags,
1025                                            &atname);
1026                 if (!NT_STATUS_IS_OK(status)) {
1027                         goto err_break;
1028                 }
1029
1030                 if (!is_visible_fsp(atname->fsp)) {
1031                         TALLOC_FREE(smb_dname_full);
1032                         TALLOC_FREE(fullname);
1033                         TALLOC_FREE(talloced);
1034                         TALLOC_FREE(atname);
1035                         continue;
1036                 }
1037
1038                 retval = SMB_VFS_UNLINKAT(conn,
1039                                           dirfsp,
1040                                           atname,
1041                                           unlink_flags);
1042                 if (retval != 0) {
1043                         status = map_nt_error_from_unix(errno);
1044                         goto err_break;
1045                 }
1046
1047                 /* Successful iteration. */
1048                 do_break = false;
1049
1050          err_break:
1051                 TALLOC_FREE(smb_dname_full);
1052                 TALLOC_FREE(fullname);
1053                 TALLOC_FREE(talloced);
1054                 TALLOC_FREE(atname);
1055                 if (do_break) {
1056                         break;
1057                 }
1058          }
1059         TALLOC_FREE(dir_hnd);
1060         return status;
1061 }
1062
1063 /****************************************************************************
1064  The internals of the rmdir code - called elsewhere.
1065 ****************************************************************************/
1066
1067 static NTSTATUS rmdir_internals(TALLOC_CTX *ctx, struct files_struct *fsp)
1068 {
1069         struct connection_struct *conn = fsp->conn;
1070         struct smb_filename *smb_dname = fsp->fsp_name;
1071         struct smb_filename *parent_fname = NULL;
1072         struct smb_filename *at_fname = NULL;
1073         const char *dname = NULL;
1074         char *talloced = NULL;
1075         struct smb_Dir *dir_hnd = NULL;
1076         struct files_struct *dirfsp = NULL;
1077         int unlink_flags = 0;
1078         NTSTATUS status;
1079         int ret;
1080
1081         SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
1082
1083         status = parent_pathref(talloc_tos(),
1084                                 conn->cwd_fsp,
1085                                 fsp->fsp_name,
1086                                 &parent_fname,
1087                                 &at_fname);
1088         if (!NT_STATUS_IS_OK(status)) {
1089                 return status;
1090         }
1091
1092         /*
1093          * Todo: use SMB_VFS_STATX() once it's available.
1094          */
1095
1096         /* Might be a symlink. */
1097         ret = SMB_VFS_LSTAT(conn, smb_dname);
1098         if (ret != 0) {
1099                 TALLOC_FREE(parent_fname);
1100                 return map_nt_error_from_unix(errno);
1101         }
1102
1103         if (S_ISLNK(smb_dname->st.st_ex_mode)) {
1104                 /* Is what it points to a directory ? */
1105                 ret = SMB_VFS_STAT(conn, smb_dname);
1106                 if (ret != 0) {
1107                         TALLOC_FREE(parent_fname);
1108                         return map_nt_error_from_unix(errno);
1109                 }
1110                 if (!(S_ISDIR(smb_dname->st.st_ex_mode))) {
1111                         TALLOC_FREE(parent_fname);
1112                         return NT_STATUS_NOT_A_DIRECTORY;
1113                 }
1114         } else {
1115                 unlink_flags = AT_REMOVEDIR;
1116         }
1117
1118         ret = SMB_VFS_UNLINKAT(conn,
1119                                parent_fname->fsp,
1120                                at_fname,
1121                                unlink_flags);
1122         if (ret == 0) {
1123                 TALLOC_FREE(parent_fname);
1124                 notify_fname(conn, NOTIFY_ACTION_REMOVED,
1125                              FILE_NOTIFY_CHANGE_DIR_NAME,
1126                              smb_dname->base_name);
1127                 return NT_STATUS_OK;
1128         }
1129
1130         if (!((errno == ENOTEMPTY) || (errno == EEXIST))) {
1131                 DEBUG(3,("rmdir_internals: couldn't remove directory %s : "
1132                          "%s\n", smb_fname_str_dbg(smb_dname),
1133                          strerror(errno)));
1134                 TALLOC_FREE(parent_fname);
1135                 return map_nt_error_from_unix(errno);
1136         }
1137
1138         /*
1139          * Here we know the initial directory unlink failed with
1140          * ENOTEMPTY or EEXIST so we know there are objects within.
1141          * If we don't have permission to delete files non
1142          * visible to the client just fail the directory delete.
1143          */
1144
1145         if (!lp_delete_veto_files(SNUM(conn))) {
1146                 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1147                 goto err;
1148         }
1149
1150         /*
1151          * Check to see if the only thing in this directory are
1152          * files non-visible to the client. If not, fail the delete.
1153          */
1154
1155         status = OpenDir(talloc_tos(),
1156                          conn,
1157                          smb_dname,
1158                          NULL,
1159                          0,
1160                          &dir_hnd);
1161         if (!NT_STATUS_IS_OK(status)) {
1162                 /*
1163                  * Note, we deliberately squash the error here
1164                  * to avoid leaking information about what we
1165                  * can't delete.
1166                  */
1167                 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1168                 goto err;
1169         }
1170
1171         dirfsp = dir_hnd_fetch_fsp(dir_hnd);
1172
1173         while ((dname = ReadDirName(dir_hnd, &talloced)) != NULL) {
1174                 struct smb_filename *smb_dname_full = NULL;
1175                 struct smb_filename *direntry_fname = NULL;
1176                 char *fullname = NULL;
1177                 int retval;
1178
1179                 if (ISDOT(dname) || ISDOTDOT(dname)) {
1180                         TALLOC_FREE(talloced);
1181                         continue;
1182                 }
1183                 if (IS_VETO_PATH(conn, dname)) {
1184                         TALLOC_FREE(talloced);
1185                         continue;
1186                 }
1187
1188                 fullname = talloc_asprintf(talloc_tos(),
1189                                            "%s/%s",
1190                                            smb_dname->base_name,
1191                                            dname);
1192
1193                 if (fullname == NULL) {
1194                         TALLOC_FREE(talloced);
1195                         status = NT_STATUS_NO_MEMORY;
1196                         goto err;
1197                 }
1198
1199                 smb_dname_full = synthetic_smb_fname(talloc_tos(),
1200                                                      fullname,
1201                                                      NULL,
1202                                                      NULL,
1203                                                      smb_dname->twrp,
1204                                                      smb_dname->flags);
1205                 if (smb_dname_full == NULL) {
1206                         TALLOC_FREE(talloced);
1207                         TALLOC_FREE(fullname);
1208                         status = NT_STATUS_NO_MEMORY;
1209                         goto err;
1210                 }
1211
1212                 retval = SMB_VFS_LSTAT(conn, smb_dname_full);
1213                 if (retval != 0) {
1214                         status = map_nt_error_from_unix(errno);
1215                         TALLOC_FREE(talloced);
1216                         TALLOC_FREE(fullname);
1217                         TALLOC_FREE(smb_dname_full);
1218                         goto err;
1219                 }
1220
1221                 if (S_ISLNK(smb_dname_full->st.st_ex_mode)) {
1222                         /* Could it be an msdfs link ? */
1223                         if (lp_host_msdfs() &&
1224                             lp_msdfs_root(SNUM(conn))) {
1225                                 struct smb_filename *smb_atname;
1226                                 smb_atname = synthetic_smb_fname(talloc_tos(),
1227                                                         dname,
1228                                                         NULL,
1229                                                         &smb_dname_full->st,
1230                                                         fsp->fsp_name->twrp,
1231                                                         fsp->fsp_name->flags);
1232                                 if (smb_atname == NULL) {
1233                                         TALLOC_FREE(talloced);
1234                                         TALLOC_FREE(fullname);
1235                                         TALLOC_FREE(smb_dname_full);
1236                                         status = NT_STATUS_NO_MEMORY;
1237                                         goto err;
1238                                 }
1239                                 if (is_msdfs_link(fsp, smb_atname)) {
1240                                         TALLOC_FREE(talloced);
1241                                         TALLOC_FREE(fullname);
1242                                         TALLOC_FREE(smb_dname_full);
1243                                         TALLOC_FREE(smb_atname);
1244                                         DBG_DEBUG("got msdfs link name %s "
1245                                                 "- can't delete directory %s\n",
1246                                                 dname,
1247                                                 fsp_str_dbg(fsp));
1248                                         status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1249                                         goto err;
1250                                 }
1251                                 TALLOC_FREE(smb_atname);
1252                         }
1253
1254                         /* Not a DFS link - could it be a dangling symlink ? */
1255                         retval = SMB_VFS_STAT(conn, smb_dname_full);
1256                         if (retval == -1 && (errno == ENOENT || errno == ELOOP)) {
1257                                 /*
1258                                  * Dangling symlink.
1259                                  * Allow delete as "delete veto files = yes"
1260                                  */
1261                                 TALLOC_FREE(talloced);
1262                                 TALLOC_FREE(fullname);
1263                                 TALLOC_FREE(smb_dname_full);
1264                                 continue;
1265                         }
1266
1267                         DBG_DEBUG("got symlink name %s - "
1268                                 "can't delete directory %s\n",
1269                                 dname,
1270                                 fsp_str_dbg(fsp));
1271                         TALLOC_FREE(talloced);
1272                         TALLOC_FREE(fullname);
1273                         TALLOC_FREE(smb_dname_full);
1274                         status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1275                         goto err;
1276                 }
1277
1278                 /* Not a symlink, get a pathref. */
1279                 status = synthetic_pathref(talloc_tos(),
1280                                            dirfsp,
1281                                            dname,
1282                                            NULL,
1283                                            &smb_dname_full->st,
1284                                            smb_dname->twrp,
1285                                            smb_dname->flags,
1286                                            &direntry_fname);
1287                 if (!NT_STATUS_IS_OK(status)) {
1288                         TALLOC_FREE(talloced);
1289                         TALLOC_FREE(fullname);
1290                         TALLOC_FREE(smb_dname_full);
1291                         goto err;
1292                 }
1293
1294                 if (!is_visible_fsp(direntry_fname->fsp)) {
1295                         TALLOC_FREE(talloced);
1296                         TALLOC_FREE(fullname);
1297                         TALLOC_FREE(smb_dname_full);
1298                         TALLOC_FREE(direntry_fname);
1299                         continue;
1300                 }
1301
1302                 /*
1303                  * We found a client visible name.
1304                  * We cannot delete this directory.
1305                  */
1306                 DBG_DEBUG("got name %s - "
1307                         "can't delete directory %s\n",
1308                         dname,
1309                         fsp_str_dbg(fsp));
1310                 TALLOC_FREE(talloced);
1311                 TALLOC_FREE(fullname);
1312                 TALLOC_FREE(smb_dname_full);
1313                 TALLOC_FREE(direntry_fname);
1314                 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1315                 goto err;
1316         }
1317
1318         /* Do a recursive delete. */
1319         RewindDir(dir_hnd);
1320
1321         while ((dname = ReadDirName(dir_hnd, &talloced)) != NULL) {
1322                 struct smb_filename *direntry_fname = NULL;
1323                 struct smb_filename *smb_dname_full = NULL;
1324                 char *fullname = NULL;
1325                 bool do_break = true;
1326                 int retval;
1327
1328                 if (ISDOT(dname) || ISDOTDOT(dname)) {
1329                         TALLOC_FREE(talloced);
1330                         continue;
1331                 }
1332
1333                 fullname = talloc_asprintf(ctx,
1334                                            "%s/%s",
1335                                            smb_dname->base_name,
1336                                            dname);
1337
1338                 if (fullname == NULL) {
1339                         status = NT_STATUS_NO_MEMORY;
1340                         goto err_break;
1341                 }
1342
1343                 smb_dname_full = synthetic_smb_fname(talloc_tos(),
1344                                                      fullname,
1345                                                      NULL,
1346                                                      NULL,
1347                                                      smb_dname->twrp,
1348                                                      smb_dname->flags);
1349                 if (smb_dname_full == NULL) {
1350                         status = NT_STATUS_NO_MEMORY;
1351                         goto err_break;
1352                 }
1353
1354                 /*
1355                  * Todo: use SMB_VFS_STATX() once that's available.
1356                  */
1357
1358                 retval = SMB_VFS_LSTAT(conn, smb_dname_full);
1359                 if (retval != 0) {
1360                         status = map_nt_error_from_unix(errno);
1361                         goto err_break;
1362                 }
1363
1364                 /*
1365                  * We are only dealing with VETO'ed objects
1366                  * here. If it's a symlink, just delete the
1367                  * link without caring what it is pointing
1368                  * to.
1369                  */
1370                 if (S_ISLNK(smb_dname_full->st.st_ex_mode)) {
1371                         direntry_fname = synthetic_smb_fname(talloc_tos(),
1372                                                         dname,
1373                                                         NULL,
1374                                                         &smb_dname_full->st,
1375                                                         smb_dname->twrp,
1376                                                         smb_dname->flags);
1377                         if (direntry_fname == NULL) {
1378                                 status = NT_STATUS_NO_MEMORY;
1379                                 goto err_break;
1380                         }
1381                 } else {
1382                         status = synthetic_pathref(talloc_tos(),
1383                                                    dirfsp,
1384                                                    dname,
1385                                                    NULL,
1386                                                    &smb_dname_full->st,
1387                                                    smb_dname->twrp,
1388                                                    smb_dname->flags,
1389                                                    &direntry_fname);
1390                         if (!NT_STATUS_IS_OK(status)) {
1391                                 goto err_break;
1392                         }
1393
1394                         if (!is_visible_fsp(direntry_fname->fsp)) {
1395                                 TALLOC_FREE(fullname);
1396                                 TALLOC_FREE(smb_dname_full);
1397                                 TALLOC_FREE(talloced);
1398                                 TALLOC_FREE(direntry_fname);
1399                                 continue;
1400                         }
1401                 }
1402
1403                 unlink_flags = 0;
1404
1405                 if (smb_dname_full->st.st_ex_mode & S_IFDIR) {
1406                         status = recursive_rmdir(ctx, conn, smb_dname_full);
1407                         if (!NT_STATUS_IS_OK(status)) {
1408                                 goto err_break;
1409                         }
1410                         unlink_flags = AT_REMOVEDIR;
1411                 }
1412
1413                 retval = SMB_VFS_UNLINKAT(conn,
1414                                           dirfsp,
1415                                           direntry_fname,
1416                                           unlink_flags);
1417                 if (retval != 0) {
1418                         status = map_nt_error_from_unix(errno);
1419                         goto err_break;
1420                 }
1421
1422                 /* Successful iteration. */
1423                 do_break = false;
1424
1425         err_break:
1426                 TALLOC_FREE(fullname);
1427                 TALLOC_FREE(smb_dname_full);
1428                 TALLOC_FREE(talloced);
1429                 TALLOC_FREE(direntry_fname);
1430                 if (do_break) {
1431                         break;
1432                 }
1433         }
1434
1435         /* If we get here, we know NT_STATUS_IS_OK(status) */
1436         SMB_ASSERT(NT_STATUS_IS_OK(status));
1437
1438         /* Retry the rmdir */
1439         ret = SMB_VFS_UNLINKAT(conn,
1440                                parent_fname->fsp,
1441                                at_fname,
1442                                AT_REMOVEDIR);
1443         if (ret != 0) {
1444                 status = map_nt_error_from_unix(errno);
1445         }
1446
1447   err:
1448
1449         TALLOC_FREE(dir_hnd);
1450         TALLOC_FREE(parent_fname);
1451
1452         if (!NT_STATUS_IS_OK(status)) {
1453                 DBG_NOTICE("couldn't remove directory %s : "
1454                          "%s\n", smb_fname_str_dbg(smb_dname),
1455                          nt_errstr(status));
1456                 return status;
1457         }
1458
1459         notify_fname(conn, NOTIFY_ACTION_REMOVED,
1460                      FILE_NOTIFY_CHANGE_DIR_NAME,
1461                      smb_dname->base_name);
1462
1463         return status;
1464 }
1465
1466 /****************************************************************************
1467  Close a directory opened by an NT SMB call.
1468 ****************************************************************************/
1469
1470 static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp,
1471                                 enum file_close_type close_type)
1472 {
1473         connection_struct *conn = fsp->conn;
1474         struct close_share_mode_lock_state lck_state = {};
1475         bool changed_user = false;
1476         NTSTATUS status = NT_STATUS_OK;
1477         NTSTATUS status1 = NT_STATUS_OK;
1478         NTSTATUS notify_status;
1479         NTSTATUS ulstatus;
1480
1481         SMB_ASSERT(fsp->fsp_flags.is_fsa);
1482
1483         if (conn_using_smb2(fsp->conn->sconn)) {
1484                 notify_status = NT_STATUS_NOTIFY_CLEANUP;
1485         } else {
1486                 notify_status = NT_STATUS_OK;
1487         }
1488
1489         assert_no_pending_aio(fsp, close_type);
1490
1491         /*
1492          * NT can set delete_on_close of the last open
1493          * reference to a directory also.
1494          */
1495
1496         lck_state = (struct close_share_mode_lock_state) {
1497                 .fsp                    = fsp,
1498                 .object_type            = "directory",
1499                 .close_type             = close_type,
1500         };
1501
1502         status = share_mode_entry_prepare_lock_del(&lck_state.prepare_state,
1503                                                    fsp->file_id,
1504                                                    close_share_mode_lock_prepare,
1505                                                    &lck_state);
1506         if (!NT_STATUS_IS_OK(status)) {
1507                 DBG_ERR("share_mode_entry_prepare_lock_del() failed for %s - %s\n",
1508                         fsp_str_dbg(fsp), nt_errstr(status));
1509                 return status;
1510         }
1511
1512         /*
1513          * We don't have directory leases yet, so assert it in order
1514          * to skip release_file_oplock().
1515          */
1516         SMB_ASSERT(fsp->oplock_type == NO_OPLOCK);
1517
1518         /*
1519          * NT can set delete_on_close of the last open
1520          * reference to a file.
1521          */
1522
1523         if (!lck_state.delete_object) {
1524                 status = NT_STATUS_OK;
1525                 goto done;
1526         }
1527
1528         /*
1529          * Ok, we have to delete the directory
1530          */
1531         lck_state.cleanup_fn = close_share_mode_lock_cleanup;
1532
1533         if (lck_state.got_tokens &&
1534             !unix_token_equal(lck_state.del_token, get_current_utok(conn)))
1535         {
1536                 /* Become the user who requested the delete. */
1537
1538                 DBG_INFO("dir %s. Change user to uid %u\n",
1539                          fsp_str_dbg(fsp),
1540                          (unsigned int)lck_state.del_token->uid);
1541
1542                 if (!push_sec_ctx()) {
1543                         smb_panic("close_directory: failed to push sec_ctx.\n");
1544                 }
1545
1546                 set_sec_ctx(lck_state.del_token->uid,
1547                             lck_state.del_token->gid,
1548                             lck_state.del_token->ngroups,
1549                             lck_state.del_token->groups,
1550                             lck_state.del_nt_token);
1551
1552                 changed_user = true;
1553         }
1554
1555         if ((fsp->conn->fs_capabilities & FILE_NAMED_STREAMS)
1556             && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
1557
1558                 status = delete_all_streams(fsp->conn, fsp->fsp_name);
1559                 if (!NT_STATUS_IS_OK(status)) {
1560                         DEBUG(5, ("delete_all_streams failed: %s\n",
1561                                   nt_errstr(status)));
1562                         goto done;
1563                 }
1564         }
1565
1566         status = rmdir_internals(talloc_tos(), fsp);
1567
1568         DEBUG(5,("close_directory: %s. Delete on close was set - "
1569                  "deleting directory returned %s.\n",
1570                  fsp_str_dbg(fsp), nt_errstr(status)));
1571
1572         /*
1573          * Ensure we remove any change notify requests that would
1574          * now fail as the directory has been deleted.
1575          */
1576
1577         if (NT_STATUS_IS_OK(status)) {
1578                 notify_status = NT_STATUS_DELETE_PENDING;
1579         }
1580
1581 done:
1582         if (changed_user) {
1583                 /* unbecome user. */
1584                 pop_sec_ctx();
1585         }
1586
1587         ulstatus = share_mode_entry_prepare_unlock(&lck_state.prepare_state,
1588                                                    lck_state.cleanup_fn,
1589                                                    &lck_state);
1590         if (!NT_STATUS_IS_OK(ulstatus)) {
1591                 DBG_ERR("share_mode_entry_prepare_unlock() failed for %s - %s\n",
1592                         fsp_str_dbg(fsp), nt_errstr(ulstatus));
1593                 smb_panic("share_mode_entry_prepare_unlock() failed!");
1594         }
1595
1596         remove_pending_change_notify_requests_by_fid(fsp, notify_status);
1597
1598         status1 = fd_close(fsp);
1599
1600         if (!NT_STATUS_IS_OK(status1)) {
1601                 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
1602                           fsp_str_dbg(fsp), fsp_get_pathref_fd(fsp), errno,
1603                           strerror(errno)));
1604         }
1605
1606         if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(status1)) {
1607                 status = status1;
1608         }
1609         return status;
1610 }
1611
1612 /****************************************************************************
1613  Rundown all SMB-related dependencies of a files struct
1614 ****************************************************************************/
1615
1616 NTSTATUS close_file_smb(struct smb_request *req,
1617                         struct files_struct *fsp,
1618                         enum file_close_type close_type)
1619 {
1620         NTSTATUS status;
1621
1622         /*
1623          * This fsp can never be an internal dirfsp. They must
1624          * be explicitly closed by TALLOC_FREE of the dir handle.
1625          */
1626         SMB_ASSERT(!fsp->fsp_flags.is_dirfsp);
1627
1628         /*
1629          * Never call directly on a base fsp
1630          */
1631         SMB_ASSERT(fsp->stream_fsp == NULL);
1632
1633         if (fsp->fake_file_handle != NULL) {
1634                 /*
1635                  * Named pipes are opened as fake files and
1636                  * can have pending aio requests. Ensure
1637                  * we clear out all pending aio on force
1638                  * shutdown of named pipes also.
1639                  * BUG: https://bugzilla.samba.org/show_bug.cgi?id=15423
1640                  */
1641                 assert_no_pending_aio(fsp, close_type);
1642                 status = close_fake_file(req, fsp);
1643         } else if (fsp->print_file != NULL) {
1644                 /* FIXME: return spool errors */
1645                 print_spool_end(fsp, close_type);
1646                 fd_close(fsp);
1647                 status = NT_STATUS_OK;
1648         } else if (!fsp->fsp_flags.is_fsa) {
1649                 if (close_type == NORMAL_CLOSE) {
1650                         DBG_ERR("unexpected NORMAL_CLOSE for [%s] "
1651                                 "is_fsa[%u] is_pathref[%u] is_directory[%u]\n",
1652                                 fsp_str_dbg(fsp),
1653                                 fsp->fsp_flags.is_fsa,
1654                                 fsp->fsp_flags.is_pathref,
1655                                 fsp->fsp_flags.is_directory);
1656                 }
1657                 SMB_ASSERT(close_type != NORMAL_CLOSE);
1658                 fd_close(fsp);
1659                 status = NT_STATUS_OK;
1660         } else if (fsp->fsp_flags.is_directory) {
1661                 status = close_directory(req, fsp, close_type);
1662         } else {
1663                 status = close_normal_file(req, fsp, close_type);
1664         }
1665
1666         if (fsp_is_alternate_stream(fsp)) {
1667                 /*
1668                  * fsp was a stream, its base_fsp can't be a stream
1669                  * as well
1670                  */
1671                 SMB_ASSERT(!fsp_is_alternate_stream(fsp->base_fsp));
1672
1673                 /*
1674                  * There's a 1:1 relationship between fsp and a base_fsp
1675                  */
1676                 SMB_ASSERT(fsp->base_fsp->stream_fsp == fsp);
1677
1678                 /*
1679                  * Make base_fsp look standalone now
1680                  */
1681                 fsp->base_fsp->stream_fsp = NULL;
1682
1683                 close_file_free(req, &fsp->base_fsp, close_type);
1684         }
1685
1686         fsp_unbind_smb(req, fsp);
1687
1688         return status;
1689 }
1690
1691 NTSTATUS close_file_free(struct smb_request *req,
1692                          struct files_struct **_fsp,
1693                          enum file_close_type close_type)
1694 {
1695         struct files_struct *fsp = *_fsp;
1696         NTSTATUS status;
1697
1698         status = close_file_smb(req, fsp, close_type);
1699
1700         file_free(req, fsp);
1701         *_fsp = NULL;
1702
1703         return status;
1704 }
1705
1706 /****************************************************************************
1707  Deal with an (authorized) message to close a file given the share mode
1708  entry.
1709 ****************************************************************************/
1710
1711 void msg_close_file(struct messaging_context *msg_ctx,
1712                         void *private_data,
1713                         uint32_t msg_type,
1714                         struct server_id server_id,
1715                         DATA_BLOB *data)
1716 {
1717         files_struct *fsp = NULL;
1718         struct file_id id;
1719         struct share_mode_entry e;
1720         struct smbd_server_connection *sconn =
1721                 talloc_get_type_abort(private_data,
1722                 struct smbd_server_connection);
1723
1724         message_to_share_mode_entry(&id, &e, (char *)data->data);
1725
1726         if(DEBUGLVL(10)) {
1727                 char *sm_str = share_mode_str(NULL, 0, &id, &e);
1728                 if (!sm_str) {
1729                         smb_panic("talloc failed");
1730                 }
1731                 DEBUG(10,("msg_close_file: got request to close share mode "
1732                         "entry %s\n", sm_str));
1733                 TALLOC_FREE(sm_str);
1734         }
1735
1736         fsp = file_find_dif(sconn, id, e.share_file_id);
1737         if (!fsp) {
1738                 DEBUG(10,("msg_close_file: failed to find file.\n"));
1739                 return;
1740         }
1741         close_file_free(NULL, &fsp, NORMAL_CLOSE);
1742 }