2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jeremy Allison 1992-2007.
6 Copyright (C) Volker Lendecke 2005
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.
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.
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/>.
23 #include "system/filesys.h"
25 #include "librpc/gen_ndr/messaging.h"
26 #include "smbd/smbd.h"
27 #include "smbd/globals.h"
28 #include "fake_file.h"
29 #include "transfer_file.h"
33 /****************************************************************************
34 Run a file if it is a magic script.
35 ****************************************************************************/
37 static NTSTATUS
check_magic(struct files_struct
*fsp
)
40 const char *magic_output
= NULL
;
43 TALLOC_CTX
*ctx
= NULL
;
45 struct connection_struct
*conn
= fsp
->conn
;
49 if (!*lp_magicscript(SNUM(conn
))) {
53 DEBUG(5,("checking magic for %s\n", fsp_str_dbg(fsp
)));
55 ctx
= talloc_stackframe();
57 fname
= fsp
->fsp_name
->base_name
;
59 if (!(p
= strrchr_m(fname
,'/'))) {
65 if (!strequal(lp_magicscript(SNUM(conn
)),p
)) {
66 status
= NT_STATUS_OK
;
70 if (*lp_magicoutput(SNUM(conn
))) {
71 magic_output
= lp_magicoutput(SNUM(conn
));
73 magic_output
= talloc_asprintf(ctx
,
78 status
= NT_STATUS_NO_MEMORY
;
82 /* Ensure we don't depend on user's PATH. */
83 p
= talloc_asprintf(ctx
, "./%s", fname
);
85 status
= NT_STATUS_NO_MEMORY
;
89 if (chmod(fname
, 0755) == -1) {
90 status
= map_nt_error_from_unix(errno
);
93 ret
= smbrun(p
,&tmp_fd
);
94 DEBUG(3,("Invoking magic command %s gave %d\n",
98 if (ret
!= 0 || tmp_fd
== -1) {
102 status
= NT_STATUS_UNSUCCESSFUL
;
105 outfd
= open(magic_output
, O_CREAT
|O_EXCL
|O_RDWR
, 0600);
109 status
= map_nt_error_from_unix(err
);
113 if (sys_fstat(tmp_fd
, &st
, false) == -1) {
117 status
= map_nt_error_from_unix(err
);
121 if (transfer_file(tmp_fd
,outfd
,(SMB_OFF_T
)st
.st_ex_size
) == (SMB_OFF_T
)-1) {
125 status
= map_nt_error_from_unix(err
);
129 if (close(outfd
) == -1) {
130 status
= map_nt_error_from_unix(errno
);
134 status
= NT_STATUS_OK
;
141 /****************************************************************************
142 Common code to close a file or a directory.
143 ****************************************************************************/
145 static NTSTATUS
close_filestruct(files_struct
*fsp
)
147 NTSTATUS status
= NT_STATUS_OK
;
149 if (fsp
->fh
->fd
!= -1) {
150 if(flush_write_cache(fsp
, CLOSE_FLUSH
) == -1) {
151 status
= map_nt_error_from_unix(errno
);
153 delete_write_cache(fsp
);
159 /****************************************************************************
160 If any deferred opens are waiting on this close, notify them.
161 ****************************************************************************/
163 static void notify_deferred_opens(struct messaging_context
*msg_ctx
,
164 struct share_mode_lock
*lck
)
168 if (!should_notify_deferred_opens()) {
172 for (i
=0; i
<lck
->num_share_modes
; i
++) {
173 struct share_mode_entry
*e
= &lck
->share_modes
[i
];
175 if (!is_deferred_open_entry(e
)) {
179 if (procid_is_me(&e
->pid
)) {
181 * We need to notify ourself to retry the open. Do
182 * this by finding the queued SMB record, moving it to
183 * the head of the queue and changing the wait time to
186 schedule_deferred_open_message_smb(e
->op_mid
);
188 char msg
[MSG_SMB_SHARE_MODE_ENTRY_SIZE
];
190 share_mode_entry_to_message(msg
, e
);
192 messaging_send_buf(msg_ctx
, e
->pid
, MSG_SMB_OPEN_RETRY
,
194 MSG_SMB_SHARE_MODE_ENTRY_SIZE
);
199 /****************************************************************************
201 ****************************************************************************/
203 NTSTATUS
delete_all_streams(connection_struct
*conn
, const char *fname
)
205 struct stream_struct
*stream_info
;
207 unsigned int num_streams
;
208 TALLOC_CTX
*frame
= talloc_stackframe();
211 status
= SMB_VFS_STREAMINFO(conn
, NULL
, fname
, talloc_tos(),
212 &num_streams
, &stream_info
);
214 if (NT_STATUS_EQUAL(status
, NT_STATUS_NOT_IMPLEMENTED
)) {
215 DEBUG(10, ("no streams around\n"));
220 if (!NT_STATUS_IS_OK(status
)) {
221 DEBUG(10, ("SMB_VFS_STREAMINFO failed: %s\n",
226 DEBUG(10, ("delete_all_streams found %d streams\n",
229 if (num_streams
== 0) {
234 for (i
=0; i
<num_streams
; i
++) {
236 struct smb_filename
*smb_fname_stream
= NULL
;
238 if (strequal(stream_info
[i
].name
, "::$DATA")) {
242 status
= create_synthetic_smb_fname(talloc_tos(), fname
,
243 stream_info
[i
].name
, NULL
,
246 if (!NT_STATUS_IS_OK(status
)) {
247 DEBUG(0, ("talloc_aprintf failed\n"));
251 res
= SMB_VFS_UNLINK(conn
, smb_fname_stream
);
254 status
= map_nt_error_from_unix(errno
);
255 DEBUG(10, ("Could not delete stream %s: %s\n",
256 smb_fname_str_dbg(smb_fname_stream
),
258 TALLOC_FREE(smb_fname_stream
);
261 TALLOC_FREE(smb_fname_stream
);
269 /****************************************************************************
270 Deal with removing a share mode on last close.
271 ****************************************************************************/
273 static NTSTATUS
close_remove_share_mode(files_struct
*fsp
,
274 enum file_close_type close_type
)
276 connection_struct
*conn
= fsp
->conn
;
277 bool delete_file
= false;
278 bool changed_user
= false;
279 struct share_mode_lock
*lck
= NULL
;
280 NTSTATUS status
= NT_STATUS_OK
;
283 const struct security_unix_token
*del_token
= NULL
;
285 /* Ensure any pending write time updates are done. */
286 if (fsp
->update_write_time_event
) {
287 update_write_time_handler(smbd_event_context(),
288 fsp
->update_write_time_event
,
294 * Lock the share entries, and determine if we should delete
295 * on close. If so delete whilst the lock is still in effect.
296 * This prevents race conditions with the file being created. JRA.
299 lck
= get_share_mode_lock(talloc_tos(), fsp
->file_id
, NULL
, NULL
,
303 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
304 "lock for file %s\n", fsp_str_dbg(fsp
)));
305 status
= NT_STATUS_INVALID_PARAMETER
;
309 if (fsp
->write_time_forced
) {
310 DEBUG(10,("close_remove_share_mode: write time forced "
313 set_close_write_time(fsp
, lck
->changed_write_time
);
314 } else if (fsp
->update_write_time_on_close
) {
315 /* Someone had a pending write. */
316 if (null_timespec(fsp
->close_write_time
)) {
317 DEBUG(10,("close_remove_share_mode: update to current time "
320 /* Update to current time due to "normal" write. */
321 set_close_write_time(fsp
, timespec_current());
323 DEBUG(10,("close_remove_share_mode: write time pending "
326 /* Update to time set on close call. */
327 set_close_write_time(fsp
, fsp
->close_write_time
);
331 if (!del_share_mode(lck
, fsp
)) {
332 DEBUG(0, ("close_remove_share_mode: Could not delete share "
333 "entry for file %s\n",
337 if (fsp
->initial_delete_on_close
&&
338 !is_delete_on_close_set(lck
, fsp
->name_hash
)) {
339 bool became_user
= False
;
341 /* Initial delete on close was set and no one else
342 * wrote a real delete on close. */
344 if (get_current_vuid(conn
) != fsp
->vuid
) {
345 become_user(conn
, fsp
->vuid
);
348 fsp
->delete_on_close
= true;
349 set_delete_on_close_lck(fsp
, lck
, True
, get_current_utok(conn
));
355 delete_file
= is_delete_on_close_set(lck
, fsp
->name_hash
);
359 /* See if others still have the file open via this pathname.
360 If this is the case, then don't delete. If all opens are
362 for (i
=0; i
<lck
->num_share_modes
; i
++) {
363 struct share_mode_entry
*e
= &lck
->share_modes
[i
];
364 if (is_valid_share_mode_entry(e
) &&
365 e
->name_hash
== fsp
->name_hash
) {
366 if (fsp
->posix_open
&& (e
->flags
& SHARE_MODE_FLAG_POSIX_OPEN
)) {
375 /* Notify any deferred opens waiting on this close. */
376 notify_deferred_opens(conn
->sconn
->msg_ctx
, lck
);
377 reply_to_oplock_break_requests(fsp
);
380 * NT can set delete_on_close of the last open
381 * reference to a file.
384 if (!(close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) ||
391 * Ok, we have to delete the file
394 DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
395 "- deleting file.\n", fsp_str_dbg(fsp
)));
398 * Don't try to update the write time when we delete the file
400 fsp
->update_write_time_on_close
= false;
402 del_token
= get_delete_on_close_token(lck
, fsp
->name_hash
);
403 SMB_ASSERT(del_token
!= NULL
);
405 if (!unix_token_equal(del_token
, get_current_utok(conn
))) {
406 /* Become the user who requested the delete. */
408 DEBUG(5,("close_remove_share_mode: file %s. "
409 "Change user to uid %u\n",
411 (unsigned int)del_token
->uid
));
413 if (!push_sec_ctx()) {
414 smb_panic("close_remove_share_mode: file %s. failed to push "
418 set_sec_ctx(del_token
->uid
,
427 /* We can only delete the file if the name we have is still valid and
428 hasn't been renamed. */
430 tmp_status
= vfs_stat_fsp(fsp
);
431 if (!NT_STATUS_IS_OK(tmp_status
)) {
432 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
433 "was set and stat failed with error %s\n",
434 fsp_str_dbg(fsp
), nt_errstr(tmp_status
)));
436 * Don't save the errno here, we ignore this error
441 id
= vfs_file_id_from_sbuf(conn
, &fsp
->fsp_name
->st
);
443 if (!file_id_equal(&fsp
->file_id
, &id
)) {
444 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
445 "was set and dev and/or inode does not match\n",
447 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
450 file_id_string_tos(&fsp
->file_id
),
451 file_id_string_tos(&id
)));
453 * Don't save the errno here, we ignore this error
458 if ((conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
459 && !is_ntfs_stream_smb_fname(fsp
->fsp_name
)) {
461 status
= delete_all_streams(conn
, fsp
->fsp_name
->base_name
);
463 if (!NT_STATUS_IS_OK(status
)) {
464 DEBUG(5, ("delete_all_streams failed: %s\n",
471 if (SMB_VFS_UNLINK(conn
, fsp
->fsp_name
) != 0) {
473 * This call can potentially fail as another smbd may
474 * have had the file open with delete on close set and
475 * deleted it when its last reference to this file
476 * went away. Hence we log this but not at debug level
480 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
481 "was set and unlink failed with error %s\n",
482 fsp_str_dbg(fsp
), strerror(errno
)));
484 status
= map_nt_error_from_unix(errno
);
487 /* As we now have POSIX opens which can unlink
488 * with other open files we may have taken
489 * this code path with more than one share mode
490 * entry - ensure we only delete once by resetting
491 * the delete on close flag. JRA.
494 fsp
->delete_on_close
= false;
495 set_delete_on_close_lck(fsp
, lck
, false, NULL
);
508 * Do the notification after we released the share
509 * mode lock. Inside notify_fname we take out another
510 * tdb lock. With ctdb also accessing our databases,
511 * this can lead to deadlocks. Putting this notify
512 * after the TALLOC_FREE(lck) above we avoid locking
513 * two records simultaneously. Notifies are async and
514 * informational only, so calling the notify_fname
515 * without holding the share mode lock should not do
518 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
519 FILE_NOTIFY_CHANGE_FILE_NAME
,
520 fsp
->fsp_name
->base_name
);
526 void set_close_write_time(struct files_struct
*fsp
, struct timespec ts
)
528 DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts
))));
530 if (null_timespec(ts
)) {
533 fsp
->write_time_forced
= false;
534 fsp
->update_write_time_on_close
= true;
535 fsp
->close_write_time
= ts
;
538 static NTSTATUS
update_write_time_on_close(struct files_struct
*fsp
)
540 struct smb_file_time ft
;
542 struct share_mode_lock
*lck
= NULL
;
546 if (!fsp
->update_write_time_on_close
) {
550 if (null_timespec(fsp
->close_write_time
)) {
551 fsp
->close_write_time
= timespec_current();
554 /* Ensure we have a valid stat struct for the source. */
555 status
= vfs_stat_fsp(fsp
);
556 if (!NT_STATUS_IS_OK(status
)) {
560 if (!VALID_STAT(fsp
->fsp_name
->st
)) {
561 /* if it doesn't seem to be a real file */
565 /* On close if we're changing the real file time we
566 * must update it in the open file db too. */
567 (void)set_write_time(fsp
->file_id
, fsp
->close_write_time
);
569 lck
= get_share_mode_lock(talloc_tos(), fsp
->file_id
, NULL
, NULL
, NULL
);
571 /* Close write times overwrite sticky write times
572 so we must replace any sticky write time here. */
573 if (!null_timespec(lck
->changed_write_time
)) {
574 (void)set_sticky_write_time(fsp
->file_id
, fsp
->close_write_time
);
579 ft
.mtime
= fsp
->close_write_time
;
580 /* We must use NULL for the fsp handle here, as smb_set_file_time()
581 checks the fsp access_mask, which may not include FILE_WRITE_ATTRIBUTES.
582 As this is a close based update, we are not directly changing the
583 file attributes from a client call, but indirectly from a write. */
584 status
= smb_set_file_time(fsp
->conn
, NULL
, fsp
->fsp_name
, &ft
, false);
585 if (!NT_STATUS_IS_OK(status
)) {
586 DEBUG(10,("update_write_time_on_close: smb_set_file_time "
587 "on file %s returned %s\n",
596 static NTSTATUS
ntstatus_keeperror(NTSTATUS s1
, NTSTATUS s2
)
598 if (!NT_STATUS_IS_OK(s1
)) {
604 /****************************************************************************
607 close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
608 printing and magic scripts are only run on normal close.
609 delete on close is done on normal and shutdown close.
610 ****************************************************************************/
612 static NTSTATUS
close_normal_file(struct smb_request
*req
, files_struct
*fsp
,
613 enum file_close_type close_type
)
615 NTSTATUS status
= NT_STATUS_OK
;
617 connection_struct
*conn
= fsp
->conn
;
619 if (close_type
== ERROR_CLOSE
) {
620 cancel_aio_by_fsp(fsp
);
623 * If we're finishing async io on a close we can get a write
624 * error here, we must remember this.
626 int ret
= wait_for_aio_completion(fsp
);
628 status
= ntstatus_keeperror(
629 status
, map_nt_error_from_unix(ret
));
634 * If we're flushing on a close we can get a write
635 * error here, we must remember this.
638 tmp
= close_filestruct(fsp
);
639 status
= ntstatus_keeperror(status
, tmp
);
641 if (fsp
->print_file
) {
642 /* FIXME: return spool errors */
643 print_spool_end(fsp
, close_type
);
648 /* Remove the oplock before potentially deleting the file. */
649 if(fsp
->oplock_type
) {
650 release_file_oplock(fsp
);
653 /* If this is an old DOS or FCB open and we have multiple opens on
654 the same handle we only have one share mode. Ensure we only remove
655 the share mode on the last close. */
657 if (fsp
->fh
->ref_count
== 1) {
658 /* Should we return on error here... ? */
659 tmp
= close_remove_share_mode(fsp
, close_type
);
660 status
= ntstatus_keeperror(status
, tmp
);
663 locking_close_file(conn
->sconn
->msg_ctx
, fsp
, close_type
);
666 status
= ntstatus_keeperror(status
, tmp
);
668 /* check for magic scripts */
669 if (close_type
== NORMAL_CLOSE
) {
670 tmp
= check_magic(fsp
);
671 status
= ntstatus_keeperror(status
, tmp
);
675 * Ensure pending modtime is set after close.
678 tmp
= update_write_time_on_close(fsp
);
679 if (NT_STATUS_EQUAL(tmp
, NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
680 /* Someone renamed the file or a parent directory containing
681 * this file. We can't do anything about this, we don't have
682 * an "update timestamp by fd" call in POSIX. Eat the error. */
687 status
= ntstatus_keeperror(status
, tmp
);
689 DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
690 conn
->session_info
->unix_name
, fsp_str_dbg(fsp
),
691 conn
->num_files_open
- 1,
692 nt_errstr(status
) ));
697 /****************************************************************************
698 Static function used by reply_rmdir to delete an entire directory
699 tree recursively. Return True on ok, False on fail.
700 ****************************************************************************/
702 static bool recursive_rmdir(TALLOC_CTX
*ctx
,
703 connection_struct
*conn
,
704 struct smb_filename
*smb_dname
)
706 const char *dname
= NULL
;
707 char *talloced
= NULL
;
711 struct smb_Dir
*dir_hnd
;
713 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname
));
715 dir_hnd
= OpenDir(talloc_tos(), conn
, smb_dname
->base_name
, NULL
, 0);
719 while((dname
= ReadDirName(dir_hnd
, &offset
, &st
, &talloced
))) {
720 struct smb_filename
*smb_dname_full
= NULL
;
721 char *fullname
= NULL
;
722 bool do_break
= true;
725 if (ISDOT(dname
) || ISDOTDOT(dname
)) {
726 TALLOC_FREE(talloced
);
730 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
, &st
,
732 TALLOC_FREE(talloced
);
736 /* Construct the full name. */
737 fullname
= talloc_asprintf(ctx
,
739 smb_dname
->base_name
,
746 status
= create_synthetic_smb_fname(talloc_tos(), fullname
,
749 if (!NT_STATUS_IS_OK(status
)) {
753 if(SMB_VFS_LSTAT(conn
, smb_dname_full
) != 0) {
757 if(smb_dname_full
->st
.st_ex_mode
& S_IFDIR
) {
758 if(!recursive_rmdir(ctx
, conn
, smb_dname_full
)) {
761 if(SMB_VFS_RMDIR(conn
,
762 smb_dname_full
->base_name
) != 0) {
765 } else if(SMB_VFS_UNLINK(conn
, smb_dname_full
) != 0) {
769 /* Successful iteration. */
773 TALLOC_FREE(smb_dname_full
);
774 TALLOC_FREE(fullname
);
775 TALLOC_FREE(talloced
);
781 TALLOC_FREE(dir_hnd
);
785 /****************************************************************************
786 The internals of the rmdir code - called elsewhere.
787 ****************************************************************************/
789 static NTSTATUS
rmdir_internals(TALLOC_CTX
*ctx
, files_struct
*fsp
)
791 connection_struct
*conn
= fsp
->conn
;
792 struct smb_filename
*smb_dname
= fsp
->fsp_name
;
795 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname
));
797 /* Might be a symlink. */
798 if(SMB_VFS_LSTAT(conn
, smb_dname
) != 0) {
799 return map_nt_error_from_unix(errno
);
802 if (S_ISLNK(smb_dname
->st
.st_ex_mode
)) {
803 /* Is what it points to a directory ? */
804 if(SMB_VFS_STAT(conn
, smb_dname
) != 0) {
805 return map_nt_error_from_unix(errno
);
807 if (!(S_ISDIR(smb_dname
->st
.st_ex_mode
))) {
808 return NT_STATUS_NOT_A_DIRECTORY
;
810 ret
= SMB_VFS_UNLINK(conn
, smb_dname
);
812 ret
= SMB_VFS_RMDIR(conn
, smb_dname
->base_name
);
815 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
816 FILE_NOTIFY_CHANGE_DIR_NAME
,
817 smb_dname
->base_name
);
821 if(((errno
== ENOTEMPTY
)||(errno
== EEXIST
)) && lp_veto_files(SNUM(conn
))) {
823 * Check to see if the only thing in this directory are
824 * vetoed files/directories. If so then delete them and
825 * retry. If we fail to delete any of them (and we *don't*
826 * do a recursive delete) then fail the rmdir.
829 const char *dname
= NULL
;
830 char *talloced
= NULL
;
832 struct smb_Dir
*dir_hnd
= OpenDir(talloc_tos(), conn
,
833 smb_dname
->base_name
, NULL
,
836 if(dir_hnd
== NULL
) {
841 while ((dname
= ReadDirName(dir_hnd
, &dirpos
, &st
,
842 &talloced
)) != NULL
) {
843 if((strcmp(dname
, ".") == 0) || (strcmp(dname
, "..")==0)) {
844 TALLOC_FREE(talloced
);
847 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
,
849 TALLOC_FREE(talloced
);
852 if(!IS_VETO_PATH(conn
, dname
)) {
853 TALLOC_FREE(dir_hnd
);
854 TALLOC_FREE(talloced
);
858 TALLOC_FREE(talloced
);
861 /* We only have veto files/directories.
862 * Are we allowed to delete them ? */
864 if(!lp_recursive_veto_delete(SNUM(conn
))) {
865 TALLOC_FREE(dir_hnd
);
870 /* Do a recursive delete. */
871 RewindDir(dir_hnd
,&dirpos
);
872 while ((dname
= ReadDirName(dir_hnd
, &dirpos
, &st
,
873 &talloced
)) != NULL
) {
874 struct smb_filename
*smb_dname_full
= NULL
;
875 char *fullname
= NULL
;
876 bool do_break
= true;
879 if (ISDOT(dname
) || ISDOTDOT(dname
)) {
880 TALLOC_FREE(talloced
);
883 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
,
885 TALLOC_FREE(talloced
);
889 fullname
= talloc_asprintf(ctx
,
891 smb_dname
->base_name
,
899 status
= create_synthetic_smb_fname(talloc_tos(),
903 if (!NT_STATUS_IS_OK(status
)) {
904 errno
= map_errno_from_nt_status(status
);
908 if(SMB_VFS_LSTAT(conn
, smb_dname_full
) != 0) {
911 if(smb_dname_full
->st
.st_ex_mode
& S_IFDIR
) {
912 if(!recursive_rmdir(ctx
, conn
,
916 if(SMB_VFS_RMDIR(conn
,
917 smb_dname_full
->base_name
) != 0) {
920 } else if(SMB_VFS_UNLINK(conn
, smb_dname_full
) != 0) {
924 /* Successful iteration. */
928 TALLOC_FREE(fullname
);
929 TALLOC_FREE(smb_dname_full
);
930 TALLOC_FREE(talloced
);
934 TALLOC_FREE(dir_hnd
);
935 /* Retry the rmdir */
936 ret
= SMB_VFS_RMDIR(conn
, smb_dname
->base_name
);
942 DEBUG(3,("rmdir_internals: couldn't remove directory %s : "
943 "%s\n", smb_fname_str_dbg(smb_dname
),
945 return map_nt_error_from_unix(errno
);
948 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
949 FILE_NOTIFY_CHANGE_DIR_NAME
,
950 smb_dname
->base_name
);
955 /****************************************************************************
956 Close a directory opened by an NT SMB call.
957 ****************************************************************************/
959 static NTSTATUS
close_directory(struct smb_request
*req
, files_struct
*fsp
,
960 enum file_close_type close_type
)
962 struct share_mode_lock
*lck
= NULL
;
963 bool delete_dir
= False
;
964 NTSTATUS status
= NT_STATUS_OK
;
965 NTSTATUS status1
= NT_STATUS_OK
;
966 const struct security_unix_token
*del_token
= NULL
;
969 * NT can set delete_on_close of the last open
970 * reference to a directory also.
973 lck
= get_share_mode_lock(talloc_tos(), fsp
->file_id
, NULL
, NULL
,
977 DEBUG(0, ("close_directory: Could not get share mode lock for "
978 "%s\n", fsp_str_dbg(fsp
)));
979 status
= NT_STATUS_INVALID_PARAMETER
;
983 if (!del_share_mode(lck
, fsp
)) {
984 DEBUG(0, ("close_directory: Could not delete share entry for "
985 "%s\n", fsp_str_dbg(fsp
)));
988 if (fsp
->initial_delete_on_close
) {
989 bool became_user
= False
;
991 /* Initial delete on close was set - for
992 * directories we don't care if anyone else
993 * wrote a real delete on close. */
995 if (get_current_vuid(fsp
->conn
) != fsp
->vuid
) {
996 become_user(fsp
->conn
, fsp
->vuid
);
999 send_stat_cache_delete_message(fsp
->conn
->sconn
->msg_ctx
,
1000 fsp
->fsp_name
->base_name
);
1001 set_delete_on_close_lck(fsp
, lck
, true,
1002 get_current_utok(fsp
->conn
));
1003 fsp
->delete_on_close
= true;
1009 del_token
= get_delete_on_close_token(lck
, fsp
->name_hash
);
1010 delete_dir
= (del_token
!= NULL
);
1014 /* See if others still have the dir open. If this is the
1015 * case, then don't delete. If all opens are POSIX delete now. */
1016 for (i
=0; i
<lck
->num_share_modes
; i
++) {
1017 struct share_mode_entry
*e
= &lck
->share_modes
[i
];
1018 if (is_valid_share_mode_entry(e
) &&
1019 e
->name_hash
== fsp
->name_hash
) {
1020 if (fsp
->posix_open
&& (e
->flags
& SHARE_MODE_FLAG_POSIX_OPEN
)) {
1029 if ((close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) &&
1032 /* Become the user who requested the delete. */
1034 if (!push_sec_ctx()) {
1035 smb_panic("close_directory: failed to push sec_ctx.\n");
1038 set_sec_ctx(del_token
->uid
,
1046 status
= rmdir_internals(talloc_tos(), fsp
);
1048 DEBUG(5,("close_directory: %s. Delete on close was set - "
1049 "deleting directory returned %s.\n",
1050 fsp_str_dbg(fsp
), nt_errstr(status
)));
1052 /* unbecome user. */
1056 * Ensure we remove any change notify requests that would
1057 * now fail as the directory has been deleted.
1060 if(NT_STATUS_IS_OK(status
)) {
1061 remove_pending_change_notify_requests_by_fid(fsp
, NT_STATUS_DELETE_PENDING
);
1065 remove_pending_change_notify_requests_by_fid(
1069 status1
= fd_close(fsp
);
1071 if (!NT_STATUS_IS_OK(status1
)) {
1072 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
1073 fsp_str_dbg(fsp
), fsp
->fh
->fd
, errno
,
1078 * Do the code common to files and directories.
1080 close_filestruct(fsp
);
1081 file_free(req
, fsp
);
1085 if (NT_STATUS_IS_OK(status
) && !NT_STATUS_IS_OK(status1
)) {
1091 /****************************************************************************
1092 Close a files_struct.
1093 ****************************************************************************/
1095 NTSTATUS
close_file(struct smb_request
*req
, files_struct
*fsp
,
1096 enum file_close_type close_type
)
1099 struct files_struct
*base_fsp
= fsp
->base_fsp
;
1101 if(fsp
->is_directory
) {
1102 status
= close_directory(req
, fsp
, close_type
);
1103 } else if (fsp
->fake_file_handle
!= NULL
) {
1104 status
= close_fake_file(req
, fsp
);
1106 status
= close_normal_file(req
, fsp
, close_type
);
1109 if ((base_fsp
!= NULL
) && (close_type
!= SHUTDOWN_CLOSE
)) {
1112 * fsp was a stream, the base fsp can't be a stream as well
1114 * For SHUTDOWN_CLOSE this is not possible here, because
1115 * SHUTDOWN_CLOSE only happens from files.c which walks the
1116 * complete list of files. If we mess with more than one fsp
1117 * those loops will become confused.
1120 SMB_ASSERT(base_fsp
->base_fsp
== NULL
);
1121 close_file(req
, base_fsp
, close_type
);
1127 /****************************************************************************
1128 Deal with an (authorized) message to close a file given the share mode
1130 ****************************************************************************/
1132 void msg_close_file(struct messaging_context
*msg_ctx
,
1135 struct server_id server_id
,
1138 struct smbd_server_connection
*sconn
;
1139 files_struct
*fsp
= NULL
;
1140 struct share_mode_entry e
;
1142 sconn
= msg_ctx_to_sconn(msg_ctx
);
1143 if (sconn
== NULL
) {
1144 DEBUG(1, ("could not find sconn\n"));
1148 message_to_share_mode_entry(&e
, (char *)data
->data
);
1151 char *sm_str
= share_mode_str(NULL
, 0, &e
);
1153 smb_panic("talloc failed");
1155 DEBUG(10,("msg_close_file: got request to close share mode "
1156 "entry %s\n", sm_str
));
1157 TALLOC_FREE(sm_str
);
1160 fsp
= file_find_dif(sconn
, e
.id
, e
.share_file_id
);
1162 DEBUG(10,("msg_close_file: failed to find file.\n"));
1165 close_file(NULL
, fsp
, NORMAL_CLOSE
);