source3/smbd/close.c

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