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