source3/smbd/close.c

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