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