source3/smbd/close.c

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