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_magicscript(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_magicscript(talloc_tos(), SNUM(conn)),p)) {
  67                 status = NT_STATUS_OK;
  68                 goto out;
  69         }
  70
  71         if (*lp_magicoutput(talloc_tos(), SNUM(conn))) {
  72                 magic_output = lp_magicoutput(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, 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 static int compare_share_mode_times(const void *p1, const void *p2)
 161 {
 162         const struct share_mode_entry *s1 = (const struct share_mode_entry *)p1;
 163         const struct share_mode_entry *s2 = (const struct share_mode_entry *)p2;
 164         return timeval_compare(&s1->time, &s2->time);
 165 }
 166
 167 /****************************************************************************
 168  Delete all streams
 169 ****************************************************************************/
 170
 171 NTSTATUS delete_all_streams(connection_struct *conn, const char *fname)
 172 {
 173         struct stream_struct *stream_info = NULL;
 174         int i;
 175         unsigned int num_streams = 0;
 176         TALLOC_CTX *frame = talloc_stackframe();
 177         NTSTATUS status;
 178
 179         status = vfs_streaminfo(conn, NULL, fname, talloc_tos(),
 180                                 &num_streams, &stream_info);
 181
 182         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
 183                 DEBUG(10, ("no streams around\n"));
 184                 TALLOC_FREE(frame);
 185                 return NT_STATUS_OK;
 186         }
 187
 188         if (!NT_STATUS_IS_OK(status)) {
 189                 DEBUG(10, ("vfs_streaminfo failed: %s\n",
 190                            nt_errstr(status)));
 191                 goto fail;
 192         }
 193
 194         DEBUG(10, ("delete_all_streams found %d streams\n",
 195                    num_streams));
 196
 197         if (num_streams == 0) {
 198                 TALLOC_FREE(frame);
 199                 return NT_STATUS_OK;
 200         }
 201
 202         for (i=0; i<num_streams; i++) {
 203                 int res;
 204                 struct smb_filename *smb_fname_stream;
 205
 206                 if (strequal(stream_info[i].name, "::$DATA")) {
 207                         continue;
 208                 }
 209
 210                 smb_fname_stream = synthetic_smb_fname(
 211                         talloc_tos(), fname, stream_info[i].name, NULL);
 212
 213                 if (smb_fname_stream == NULL) {
 214                         DEBUG(0, ("talloc_aprintf failed\n"));
 215                         status = NT_STATUS_NO_MEMORY;
 216                         goto fail;
 217                 }
 218
 219                 res = SMB_VFS_UNLINK(conn, smb_fname_stream);
 220
 221                 if (res == -1) {
 222                         status = map_nt_error_from_unix(errno);
 223                         DEBUG(10, ("Could not delete stream %s: %s\n",
 224                                    smb_fname_str_dbg(smb_fname_stream),
 225                                    strerror(errno)));
 226                         TALLOC_FREE(smb_fname_stream);
 227                         break;
 228                 }
 229                 TALLOC_FREE(smb_fname_stream);
 230         }
 231
 232  fail:
 233         TALLOC_FREE(frame);
 234         return status;
 235 }
 236
 237 /****************************************************************************
 238  Deal with removing a share mode on last close.
 239 ****************************************************************************/
 240
 241 static NTSTATUS close_remove_share_mode(files_struct *fsp,
 242                                         enum file_close_type close_type)
 243 {
 244         connection_struct *conn = fsp->conn;
 245         struct server_id self = messaging_server_id(conn->sconn->msg_ctx);
 246         bool delete_file = false;
 247         bool changed_user = false;
 248         struct share_mode_lock *lck = NULL;
 249         NTSTATUS status = NT_STATUS_OK;
 250         NTSTATUS tmp_status;
 251         struct file_id id;
 252         const struct security_unix_token *del_token = NULL;
 253         const struct security_token *del_nt_token = NULL;
 254         bool got_tokens = false;
 255         bool normal_close;
 256
 257         /* Ensure any pending write time updates are done. */
 258         if (fsp->update_write_time_event) {
 259                 update_write_time_handler(fsp->conn->sconn->ev_ctx,
 260                                         fsp->update_write_time_event,
 261                                         timeval_current(),
 262                                         (void *)fsp);
 263         }
 264
 265         /*
 266          * Lock the share entries, and determine if we should delete
 267          * on close. If so delete whilst the lock is still in effect.
 268          * This prevents race conditions with the file being created. JRA.
 269          */
 270
 271         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
 272         if (lck == NULL) {
 273                 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
 274                           "lock for file %s\n", fsp_str_dbg(fsp)));
 275                 return NT_STATUS_INVALID_PARAMETER;
 276         }
 277
 278         if (fsp->write_time_forced) {
 279                 DEBUG(10,("close_remove_share_mode: write time forced "
 280                         "for file %s\n",
 281                         fsp_str_dbg(fsp)));
 282                 set_close_write_time(fsp, lck->data->changed_write_time);
 283         } else if (fsp->update_write_time_on_close) {
 284                 /* Someone had a pending write. */
 285                 if (null_timespec(fsp->close_write_time)) {
 286                         DEBUG(10,("close_remove_share_mode: update to current time "
 287                                 "for file %s\n",
 288                                 fsp_str_dbg(fsp)));
 289                         /* Update to current time due to "normal" write. */
 290                         set_close_write_time(fsp, timespec_current());
 291                 } else {
 292                         DEBUG(10,("close_remove_share_mode: write time pending "
 293                                 "for file %s\n",
 294                                 fsp_str_dbg(fsp)));
 295                         /* Update to time set on close call. */
 296                         set_close_write_time(fsp, fsp->close_write_time);
 297                 }
 298         }
 299
 300         if (fsp->initial_delete_on_close &&
 301                         !is_delete_on_close_set(lck, fsp->name_hash)) {
 302                 bool became_user = False;
 303
 304                 /* Initial delete on close was set and no one else
 305                  * wrote a real delete on close. */
 306
 307                 if (get_current_vuid(conn) != fsp->vuid) {
 308                         become_user(conn, fsp->vuid);
 309                         became_user = True;
 310                 }
 311                 fsp->delete_on_close = true;
 312                 set_delete_on_close_lck(fsp, lck, True,
 313                                 get_current_nttok(conn),
 314                                 get_current_utok(conn));
 315                 if (became_user) {
 316                         unbecome_user();
 317                 }
 318         }
 319
 320         delete_file = is_delete_on_close_set(lck, fsp->name_hash);
 321
 322         if (delete_file) {
 323                 int i;
 324                 /* See if others still have the file open via this pathname.
 325                    If this is the case, then don't delete. If all opens are
 326                    POSIX delete now. */
 327                 for (i=0; i<lck->data->num_share_modes; i++) {
 328                         struct share_mode_entry *e = &lck->data->share_modes[i];
 329
 330                         if (!is_valid_share_mode_entry(e)) {
 331                                 continue;
 332                         }
 333                         if (e->name_hash != fsp->name_hash) {
 334                                 continue;
 335                         }
 336                         if (fsp->posix_open
 337                             && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
 338                                 continue;
 339                         }
 340                         if (serverid_equal(&self, &e->pid) &&
 341                             (e->share_file_id == fsp->fh->gen_id)) {
 342                                 continue;
 343                         }
 344                         if (share_mode_stale_pid(lck->data, i)) {
 345                                 continue;
 346                         }
 347                         delete_file = False;
 348                         break;
 349                 }
 350         }
 351
 352         /*
 353          * NT can set delete_on_close of the last open
 354          * reference to a file.
 355          */
 356
 357         normal_close = (close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE);
 358
 359         if (!normal_close || !delete_file) {
 360
 361                 if (!del_share_mode(lck, fsp)) {
 362                         DEBUG(0, ("close_remove_share_mode: Could not delete "
 363                                   "share entry for file %s\n",
 364                                   fsp_str_dbg(fsp)));
 365                 }
 366
 367                 TALLOC_FREE(lck);
 368                 return NT_STATUS_OK;
 369         }
 370
 371         /*
 372          * Ok, we have to delete the file
 373          */
 374
 375         DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
 376                  "- deleting file.\n", fsp_str_dbg(fsp)));
 377
 378         /*
 379          * Don't try to update the write time when we delete the file
 380          */
 381         fsp->update_write_time_on_close = false;
 382
 383         got_tokens = get_delete_on_close_token(lck, fsp->name_hash,
 384                                         &del_nt_token, &del_token);
 385         SMB_ASSERT(got_tokens);
 386
 387         if (!unix_token_equal(del_token, get_current_utok(conn))) {
 388                 /* Become the user who requested the delete. */
 389
 390                 DEBUG(5,("close_remove_share_mode: file %s. "
 391                         "Change user to uid %u\n",
 392                         fsp_str_dbg(fsp),
 393                         (unsigned int)del_token->uid));
 394
 395                 if (!push_sec_ctx()) {
 396                         smb_panic("close_remove_share_mode: file %s. failed to push "
 397                                   "sec_ctx.\n");
 398                 }
 399
 400                 set_sec_ctx(del_token->uid,
 401                             del_token->gid,
 402                             del_token->ngroups,
 403                             del_token->groups,
 404                             del_nt_token);
 405
 406                 changed_user = true;
 407         }
 408
 409         /* We can only delete the file if the name we have is still valid and
 410            hasn't been renamed. */
 411
 412         tmp_status = vfs_stat_fsp(fsp);
 413         if (!NT_STATUS_IS_OK(tmp_status)) {
 414                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 415                          "was set and stat failed with error %s\n",
 416                          fsp_str_dbg(fsp), nt_errstr(tmp_status)));
 417                 /*
 418                  * Don't save the errno here, we ignore this error
 419                  */
 420                 goto done;
 421         }
 422
 423         id = vfs_file_id_from_sbuf(conn, &fsp->fsp_name->st);
 424
 425         if (!file_id_equal(&fsp->file_id, &id)) {
 426                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 427                          "was set and dev and/or inode does not match\n",
 428                          fsp_str_dbg(fsp)));
 429                 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
 430                          "stat file_id %s\n",
 431                          fsp_str_dbg(fsp),
 432                          file_id_string_tos(&fsp->file_id),
 433                          file_id_string_tos(&id)));
 434                 /*
 435                  * Don't save the errno here, we ignore this error
 436                  */
 437                 goto done;
 438         }
 439
 440         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
 441             && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
 442
 443                 status = delete_all_streams(conn, fsp->fsp_name->base_name);
 444
 445                 if (!NT_STATUS_IS_OK(status)) {
 446                         DEBUG(5, ("delete_all_streams failed: %s\n",
 447                                   nt_errstr(status)));
 448                         goto done;
 449                 }
 450         }
 451
 452
 453         if (SMB_VFS_UNLINK(conn, fsp->fsp_name) != 0) {
 454                 /*
 455                  * This call can potentially fail as another smbd may
 456                  * have had the file open with delete on close set and
 457                  * deleted it when its last reference to this file
 458                  * went away. Hence we log this but not at debug level
 459                  * zero.
 460                  */
 461
 462                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
 463                          "was set and unlink failed with error %s\n",
 464                          fsp_str_dbg(fsp), strerror(errno)));
 465
 466                 status = map_nt_error_from_unix(errno);
 467         }
 468
 469         /* As we now have POSIX opens which can unlink
 470          * with other open files we may have taken
 471          * this code path with more than one share mode
 472          * entry - ensure we only delete once by resetting
 473          * the delete on close flag. JRA.
 474          */
 475
 476         fsp->delete_on_close = false;
 477         set_delete_on_close_lck(fsp, lck, false, NULL, NULL);
 478
 479  done:
 480
 481         if (changed_user) {
 482                 /* unbecome user. */
 483                 pop_sec_ctx();
 484         }
 485
 486         if (!del_share_mode(lck, fsp)) {
 487                 DEBUG(0, ("close_remove_share_mode: Could not delete share "
 488                           "entry for file %s\n", fsp_str_dbg(fsp)));
 489         }
 490
 491         TALLOC_FREE(lck);
 492
 493         if (delete_file) {
 494                 /*
 495                  * Do the notification after we released the share
 496                  * mode lock. Inside notify_fname we take out another
 497                  * tdb lock. With ctdb also accessing our databases,
 498                  * this can lead to deadlocks. Putting this notify
 499                  * after the TALLOC_FREE(lck) above we avoid locking
 500                  * two records simultaneously. Notifies are async and
 501                  * informational only, so calling the notify_fname
 502                  * without holding the share mode lock should not do
 503                  * any harm.
 504                  */
 505                 notify_fname(conn, NOTIFY_ACTION_REMOVED,
 506                              FILE_NOTIFY_CHANGE_FILE_NAME,
 507                              fsp->fsp_name->base_name);
 508         }
 509
 510         return status;
 511 }
 512
 513 void set_close_write_time(struct files_struct *fsp, struct timespec ts)
 514 {
 515         DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts))));
 516
 517         if (null_timespec(ts)) {
 518                 return;
 519         }
 520         fsp->write_time_forced = false;
 521         fsp->update_write_time_on_close = true;
 522         fsp->close_write_time = ts;
 523 }
 524
 525 static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
 526 {
 527         struct smb_file_time ft;
 528         NTSTATUS status;
 529         struct share_mode_lock *lck = NULL;
 530
 531         ZERO_STRUCT(ft);
 532
 533         if (!fsp->update_write_time_on_close) {
 534                 return NT_STATUS_OK;
 535         }
 536
 537         if (null_timespec(fsp->close_write_time)) {
 538                 fsp->close_write_time = timespec_current();
 539         }
 540
 541         /* Ensure we have a valid stat struct for the source. */
 542         status = vfs_stat_fsp(fsp);
 543         if (!NT_STATUS_IS_OK(status)) {
 544                 return status;
 545         }
 546
 547         if (!VALID_STAT(fsp->fsp_name->st)) {
 548                 /* if it doesn't seem to be a real file */
 549                 return NT_STATUS_OK;
 550         }
 551
 552         /*
 553          * get_existing_share_mode_lock() isn't really the right
 554          * call here, as we're being called after
 555          * close_remove_share_mode() inside close_normal_file()
 556          * so it's quite normal to not have an existing share
 557          * mode here. However, get_share_mode_lock() doesn't
 558          * work because that will create a new share mode if
 559          * one doesn't exist - so stick with this call (just
 560          * ignore any error we get if the share mode doesn't
 561          * exist.
 562          */
 563
 564         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
 565         if (lck) {
 566                 /* On close if we're changing the real file time we
 567                  * must update it in the open file db too. */
 568                 (void)set_write_time(fsp->file_id, fsp->close_write_time);
 569
 570                 /* Close write times overwrite sticky write times
 571                    so we must replace any sticky write time here. */
 572                 if (!null_timespec(lck->data->changed_write_time)) {
 573                         (void)set_sticky_write_time(fsp->file_id, fsp->close_write_time);
 574                 }
 575                 TALLOC_FREE(lck);
 576         }
 577
 578         ft.mtime = fsp->close_write_time;
 579         /* As this is a close based update, we are not directly changing the
 580            file attributes from a client call, but indirectly from a write. */
 581         status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, &ft, false);
 582         if (!NT_STATUS_IS_OK(status)) {
 583                 DEBUG(10,("update_write_time_on_close: smb_set_file_time "
 584                         "on file %s returned %s\n",
 585                         fsp_str_dbg(fsp),
 586                         nt_errstr(status)));
 587                 return status;
 588         }
 589
 590         return status;
 591 }
 592
 593 static NTSTATUS ntstatus_keeperror(NTSTATUS s1, NTSTATUS s2)
 594 {
 595         if (!NT_STATUS_IS_OK(s1)) {
 596                 return s1;
 597         }
 598         return s2;
 599 }
 600
 601 /****************************************************************************
 602  Close a file.
 603
 604  close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
 605  printing and magic scripts are only run on normal close.
 606  delete on close is done on normal and shutdown close.
 607 ****************************************************************************/
 608
 609 static NTSTATUS close_normal_file(struct smb_request *req, files_struct *fsp,
 610                                   enum file_close_type close_type)
 611 {
 612         NTSTATUS status = NT_STATUS_OK;
 613         NTSTATUS tmp;
 614         connection_struct *conn = fsp->conn;
 615         bool is_durable = false;
 616
 617         if (fsp->num_aio_requests != 0) {
 618
 619                 if (close_type != SHUTDOWN_CLOSE) {
 620                         /*
 621                          * reply_close and the smb2 close must have
 622                          * taken care of this. No other callers of
 623                          * close_file should ever have created async
 624                          * I/O.
 625                          *
 626                          * We need to panic here because if we close()
 627                          * the fd while we have outstanding async I/O
 628                          * requests, in the worst case we could end up
 629                          * writing to the wrong file.
 630                          */
 631                         DEBUG(0, ("fsp->num_aio_requests=%u\n",
 632                                   fsp->num_aio_requests));
 633                         smb_panic("can not close with outstanding aio "
 634                                   "requests");
 635                 }
 636
 637                 /*
 638                  * For shutdown close, just drop the async requests
 639                  * including a potential close request pending for
 640                  * this fsp. Drop the close request first, the
 641                  * destructor for the aio_requests would execute it.
 642                  */
 643                 TALLOC_FREE(fsp->deferred_close);
 644
 645                 while (fsp->num_aio_requests != 0) {
 646                         /*
 647                          * The destructor of the req will remove
 648                          * itself from the fsp
 649                          */
 650                         TALLOC_FREE(fsp->aio_requests[0]);
 651                 }
 652         }
 653
 654         /*
 655          * If we're flushing on a close we can get a write
 656          * error here, we must remember this.
 657          */
 658
 659         tmp = close_filestruct(fsp);
 660         status = ntstatus_keeperror(status, tmp);
 661
 662         if (NT_STATUS_IS_OK(status) && fsp->op != NULL) {
 663                 is_durable = fsp->op->global->durable;
 664         }
 665
 666         if (close_type != SHUTDOWN_CLOSE) {
 667                 is_durable = false;
 668         }
 669
 670         if (is_durable) {
 671                 DATA_BLOB new_cookie = data_blob_null;
 672
 673                 tmp = SMB_VFS_DURABLE_DISCONNECT(fsp,
 674                                         fsp->op->global->backend_cookie,
 675                                         fsp->op,
 676                                         &new_cookie);
 677                 if (NT_STATUS_IS_OK(tmp)) {
 678                         struct timeval tv;
 679                         NTTIME now;
 680
 681                         if (req != NULL) {
 682                                 tv = req->request_time;
 683                         } else {
 684                                 tv = timeval_current();
 685                         }
 686                         now = timeval_to_nttime(&tv);
 687
 688                         data_blob_free(&fsp->op->global->backend_cookie);
 689                         fsp->op->global->backend_cookie = new_cookie;
 690
 691                         fsp->op->compat = NULL;
 692                         tmp = smbXsrv_open_close(fsp->op, now);
 693                         if (!NT_STATUS_IS_OK(tmp)) {
 694                                 DEBUG(1, ("Failed to update smbXsrv_open "
 695                                           "record when disconnecting durable "
 696                                           "handle for file %s: %s - "
 697                                           "proceeding with normal close\n",
 698                                           fsp_str_dbg(fsp), nt_errstr(tmp)));
 699                         }
 700                         scavenger_schedule_disconnected(fsp);
 701                 } else {
 702                         DEBUG(1, ("Failed to disconnect durable handle for "
 703                                   "file %s: %s - proceeding with normal "
 704                                   "close\n", fsp_str_dbg(fsp), nt_errstr(tmp)));
 705                 }
 706                 if (!NT_STATUS_IS_OK(tmp)) {
 707                         is_durable = false;
 708                 }
 709         }
 710
 711         if (is_durable) {
 712                 /*
 713                  * This is the case where we successfully disconnected
 714                  * a durable handle and closed the underlying file.
 715                  * In all other cases, we proceed with a genuine close.
 716                  */
 717                 DEBUG(10, ("%s disconnected durable handle for file %s\n",
 718                            conn->session_info->unix_info->unix_name,
 719                            fsp_str_dbg(fsp)));
 720                 file_free(req, fsp);
 721                 return NT_STATUS_OK;
 722         }
 723
 724         if (fsp->op != NULL) {
 725                 /*
 726                  * Make sure the handle is not marked as durable anymore
 727                  */
 728                 fsp->op->global->durable = false;
 729         }
 730
 731         if (fsp->print_file) {
 732                 /* FIXME: return spool errors */
 733                 print_spool_end(fsp, close_type);
 734                 file_free(req, fsp);
 735                 return NT_STATUS_OK;
 736         }
 737
 738         /* Remove the oplock before potentially deleting the file. */
 739         if(fsp->oplock_type) {
 740                 release_file_oplock(fsp);
 741         }
 742
 743         /* If this is an old DOS or FCB open and we have multiple opens on
 744            the same handle we only have one share mode. Ensure we only remove
 745            the share mode on the last close. */
 746
 747         if (fsp->fh->ref_count == 1) {
 748                 /* Should we return on error here... ? */
 749                 tmp = close_remove_share_mode(fsp, close_type);
 750                 status = ntstatus_keeperror(status, tmp);
 751         }
 752
 753         locking_close_file(conn->sconn->msg_ctx, fsp, close_type);
 754
 755         tmp = fd_close(fsp);
 756         status = ntstatus_keeperror(status, tmp);
 757
 758         /* check for magic scripts */
 759         if (close_type == NORMAL_CLOSE) {
 760                 tmp = check_magic(fsp);
 761                 status = ntstatus_keeperror(status, tmp);
 762         }
 763
 764         /*
 765          * Ensure pending modtime is set after close.
 766          */
 767
 768         tmp = update_write_time_on_close(fsp);
 769         if (NT_STATUS_EQUAL(tmp, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
 770                 /* Someone renamed the file or a parent directory containing
 771                  * this file. We can't do anything about this, we don't have
 772                  * an "update timestamp by fd" call in POSIX. Eat the error. */
 773
 774                 tmp = NT_STATUS_OK;
 775         }
 776
 777         status = ntstatus_keeperror(status, tmp);
 778
 779         DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
 780                 conn->session_info->unix_info->unix_name, fsp_str_dbg(fsp),
 781                 conn->num_files_open - 1,
 782                 nt_errstr(status) ));
 783
 784         file_free(req, fsp);
 785         return status;
 786 }
 787 /****************************************************************************
 788  Function used by reply_rmdir to delete an entire directory
 789  tree recursively. Return True on ok, False on fail.
 790 ****************************************************************************/
 791
 792 bool recursive_rmdir(TALLOC_CTX *ctx,
 793                      connection_struct *conn,
 794                      struct smb_filename *smb_dname)
 795 {
 796         const char *dname = NULL;
 797         char *talloced = NULL;
 798         bool ret = True;
 799         long offset = 0;
 800         SMB_STRUCT_STAT st;
 801         struct smb_Dir *dir_hnd;
 802
 803         SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
 804
 805         dir_hnd = OpenDir(talloc_tos(), conn, smb_dname->base_name, NULL, 0);
 806         if(dir_hnd == NULL)
 807                 return False;
 808
 809         while((dname = ReadDirName(dir_hnd, &offset, &st, &talloced))) {
 810                 struct smb_filename *smb_dname_full = NULL;
 811                 char *fullname = NULL;
 812                 bool do_break = true;
 813
 814                 if (ISDOT(dname) || ISDOTDOT(dname)) {
 815                         TALLOC_FREE(talloced);
 816                         continue;
 817                 }
 818
 819                 if (!is_visible_file(conn, smb_dname->base_name, dname, &st,
 820                                      false)) {
 821                         TALLOC_FREE(talloced);
 822                         continue;
 823                 }
 824
 825                 /* Construct the full name. */
 826                 fullname = talloc_asprintf(ctx,
 827                                 "%s/%s",
 828                                 smb_dname->base_name,
 829                                 dname);
 830                 if (!fullname) {
 831                         errno = ENOMEM;
 832                         goto err_break;
 833                 }
 834
 835                 smb_dname_full = synthetic_smb_fname(talloc_tos(), fullname,
 836                                                      NULL, NULL);
 837                 if (smb_dname_full == NULL) {
 838                         errno = ENOMEM;
 839                         goto err_break;
 840                 }
 841
 842                 if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
 843                         goto err_break;
 844                 }
 845
 846                 if(smb_dname_full->st.st_ex_mode & S_IFDIR) {
 847                         if(!recursive_rmdir(ctx, conn, smb_dname_full)) {
 848                                 goto err_break;
 849                         }
 850                         if(SMB_VFS_RMDIR(conn,
 851                                          smb_dname_full->base_name) != 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->base_name);
 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->base_name, 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_recursive_veto_delete(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->base_name) != 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->base_name);
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
1056         /*
1057          * NT can set delete_on_close of the last open
1058          * reference to a directory also.
1059          */
1060
1061         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1062         if (lck == NULL) {
1063                 DEBUG(0, ("close_directory: Could not get share mode lock for "
1064                           "%s\n", fsp_str_dbg(fsp)));
1065                 return NT_STATUS_INVALID_PARAMETER;
1066         }
1067
1068         if (fsp->initial_delete_on_close) {
1069                 bool became_user = False;
1070
1071                 /* Initial delete on close was set - for
1072                  * directories we don't care if anyone else
1073                  * wrote a real delete on close. */
1074
1075                 if (get_current_vuid(fsp->conn) != fsp->vuid) {
1076                         become_user(fsp->conn, fsp->vuid);
1077                         became_user = True;
1078                 }
1079                 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1080                                                fsp->fsp_name->base_name);
1081                 set_delete_on_close_lck(fsp, lck, true,
1082                                 get_current_nttok(fsp->conn),
1083                                 get_current_utok(fsp->conn));
1084                 fsp->delete_on_close = true;
1085                 if (became_user) {
1086                         unbecome_user();
1087                 }
1088         }
1089
1090         delete_dir = get_delete_on_close_token(lck, fsp->name_hash,
1091                                         &del_nt_token, &del_token);
1092
1093         if (delete_dir) {
1094                 int i;
1095                 /* See if others still have the dir open. If this is the
1096                  * case, then don't delete. If all opens are POSIX delete now. */
1097                 for (i=0; i<lck->data->num_share_modes; i++) {
1098                         struct share_mode_entry *e = &lck->data->share_modes[i];
1099                         if (is_valid_share_mode_entry(e) &&
1100                                         e->name_hash == fsp->name_hash) {
1101                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
1102                                         continue;
1103                                 }
1104                                 if (serverid_equal(&self, &e->pid) &&
1105                                     (e->share_file_id == fsp->fh->gen_id)) {
1106                                         continue;
1107                                 }
1108                                 if (share_mode_stale_pid(lck->data, i)) {
1109                                         continue;
1110                                 }
1111                                 delete_dir = False;
1112                                 break;
1113                         }
1114                 }
1115         }
1116
1117         if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
1118                                 delete_dir) {
1119
1120                 /* Become the user who requested the delete. */
1121
1122                 if (!push_sec_ctx()) {
1123                         smb_panic("close_directory: failed to push sec_ctx.\n");
1124                 }
1125
1126                 set_sec_ctx(del_token->uid,
1127                                 del_token->gid,
1128                                 del_token->ngroups,
1129                                 del_token->groups,
1130                                 del_nt_token);
1131
1132                 if (!del_share_mode(lck, fsp)) {
1133                         DEBUG(0, ("close_directory: Could not delete share entry for "
1134                                   "%s\n", fsp_str_dbg(fsp)));
1135                 }
1136
1137                 TALLOC_FREE(lck);
1138
1139                 if ((fsp->conn->fs_capabilities & FILE_NAMED_STREAMS)
1140                     && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
1141
1142                         status = delete_all_streams(fsp->conn, fsp->fsp_name->base_name);
1143                         if (!NT_STATUS_IS_OK(status)) {
1144                                 DEBUG(5, ("delete_all_streams failed: %s\n",
1145                                           nt_errstr(status)));
1146                                 return status;
1147                         }
1148                 }
1149
1150                 status = rmdir_internals(talloc_tos(), fsp);
1151
1152                 DEBUG(5,("close_directory: %s. Delete on close was set - "
1153                          "deleting directory returned %s.\n",
1154                          fsp_str_dbg(fsp), nt_errstr(status)));
1155
1156                 /* unbecome user. */
1157                 pop_sec_ctx();
1158
1159                 /*
1160                  * Ensure we remove any change notify requests that would
1161                  * now fail as the directory has been deleted.
1162                  */
1163
1164                 if(NT_STATUS_IS_OK(status)) {
1165                         remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING);
1166                 }
1167         } else {
1168                 if (!del_share_mode(lck, fsp)) {
1169                         DEBUG(0, ("close_directory: Could not delete share entry for "
1170                                   "%s\n", fsp_str_dbg(fsp)));
1171                 }
1172
1173                 TALLOC_FREE(lck);
1174                 remove_pending_change_notify_requests_by_fid(
1175                         fsp, NT_STATUS_OK);
1176         }
1177
1178         status1 = fd_close(fsp);
1179
1180         if (!NT_STATUS_IS_OK(status1)) {
1181                 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
1182                           fsp_str_dbg(fsp), fsp->fh->fd, errno,
1183                           strerror(errno)));
1184         }
1185
1186         /*
1187          * Do the code common to files and directories.
1188          */
1189         close_filestruct(fsp);
1190         file_free(req, fsp);
1191
1192         if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(status1)) {
1193                 status = status1;
1194         }
1195         return status;
1196 }
1197
1198 /****************************************************************************
1199  Close a files_struct.
1200 ****************************************************************************/
1201
1202 NTSTATUS close_file(struct smb_request *req, files_struct *fsp,
1203                     enum file_close_type close_type)
1204 {
1205         NTSTATUS status;
1206         struct files_struct *base_fsp = fsp->base_fsp;
1207
1208         if(fsp->is_directory) {
1209                 status = close_directory(req, fsp, close_type);
1210         } else if (fsp->fake_file_handle != NULL) {
1211                 status = close_fake_file(req, fsp);
1212         } else {
1213                 status = close_normal_file(req, fsp, close_type);
1214         }
1215
1216         if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) {
1217
1218                 /*
1219                  * fsp was a stream, the base fsp can't be a stream as well
1220                  *
1221                  * For SHUTDOWN_CLOSE this is not possible here, because
1222                  * SHUTDOWN_CLOSE only happens from files.c which walks the
1223                  * complete list of files. If we mess with more than one fsp
1224                  * those loops will become confused.
1225                  */
1226
1227                 SMB_ASSERT(base_fsp->base_fsp == NULL);
1228                 close_file(req, base_fsp, close_type);
1229         }
1230
1231         return status;
1232 }
1233
1234 /****************************************************************************
1235  Deal with an (authorized) message to close a file given the share mode
1236  entry.
1237 ****************************************************************************/
1238
1239 void msg_close_file(struct messaging_context *msg_ctx,
1240                         void *private_data,
1241                         uint32_t msg_type,
1242                         struct server_id server_id,
1243                         DATA_BLOB *data)
1244 {
1245         files_struct *fsp = NULL;
1246         struct share_mode_entry e;
1247         struct smbd_server_connection *sconn =
1248                 talloc_get_type_abort(private_data,
1249                 struct smbd_server_connection);
1250
1251         message_to_share_mode_entry(&e, (char *)data->data);
1252
1253         if(DEBUGLVL(10)) {
1254                 char *sm_str = share_mode_str(NULL, 0, &e);
1255                 if (!sm_str) {
1256                         smb_panic("talloc failed");
1257                 }
1258                 DEBUG(10,("msg_close_file: got request to close share mode "
1259                         "entry %s\n", sm_str));
1260                 TALLOC_FREE(sm_str);
1261         }
1262
1263         fsp = file_find_dif(sconn, e.id, e.share_file_id);
1264         if (!fsp) {
1265                 DEBUG(10,("msg_close_file: failed to find file.\n"));
1266                 return;
1267         }
1268         close_file(NULL, fsp, NORMAL_CLOSE);
1269 }