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