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 "smbd/smbd.h"
26 #include "smbd/globals.h"
27 #include "fake_file.h"
28 #include "transfer_file.h"
31 #include "../librpc/gen_ndr/open_files.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
,(off_t
)st
.st_ex_size
) == (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 static int compare_share_mode_times(const void *p1
, const void *p2
)
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
);
166 /****************************************************************************
167 If any deferred opens are waiting on this close, notify them.
168 ****************************************************************************/
170 static void notify_deferred_opens(struct smbd_server_connection
*sconn
,
171 struct share_mode_lock
*lck
)
173 struct server_id self
= messaging_server_id(sconn
->msg_ctx
);
174 uint32_t i
, num_deferred
;
175 struct share_mode_entry
*deferred
;
177 if (!should_notify_deferred_opens(sconn
)) {
182 for (i
=0; i
<lck
->data
->num_share_modes
; i
++) {
183 struct share_mode_entry
*e
= &lck
->data
->share_modes
[i
];
185 if (!is_deferred_open_entry(e
)) {
188 if (share_mode_stale_pid(lck
->data
, i
)) {
193 if (num_deferred
== 0) {
197 deferred
= talloc_array(talloc_tos(), struct share_mode_entry
,
199 if (deferred
== NULL
) {
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
;
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.
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.
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.
229 qsort(deferred
, num_deferred
, sizeof(struct share_mode_entry
),
230 compare_share_mode_times
);
232 for (i
=0; i
<num_deferred
; i
++) {
233 struct share_mode_entry
*e
= &deferred
[i
];
235 if (procid_equal(&self
, &e
->pid
)) {
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
242 schedule_deferred_open_message_smb(sconn
, e
->op_mid
);
244 char msg
[MSG_SMB_SHARE_MODE_ENTRY_SIZE
];
246 share_mode_entry_to_message(msg
, e
);
248 messaging_send_buf(sconn
->msg_ctx
, e
->pid
,
251 MSG_SMB_SHARE_MODE_ENTRY_SIZE
);
254 TALLOC_FREE(deferred
);
257 /****************************************************************************
259 ****************************************************************************/
261 NTSTATUS
delete_all_streams(connection_struct
*conn
, const char *fname
)
263 struct stream_struct
*stream_info
= NULL
;
265 unsigned int num_streams
= 0;
266 TALLOC_CTX
*frame
= talloc_stackframe();
269 status
= vfs_streaminfo(conn
, NULL
, fname
, talloc_tos(),
270 &num_streams
, &stream_info
);
272 if (NT_STATUS_EQUAL(status
, NT_STATUS_NOT_IMPLEMENTED
)) {
273 DEBUG(10, ("no streams around\n"));
278 if (!NT_STATUS_IS_OK(status
)) {
279 DEBUG(10, ("vfs_streaminfo failed: %s\n",
284 DEBUG(10, ("delete_all_streams found %d streams\n",
287 if (num_streams
== 0) {
292 for (i
=0; i
<num_streams
; i
++) {
294 struct smb_filename
*smb_fname_stream
= NULL
;
296 if (strequal(stream_info
[i
].name
, "::$DATA")) {
300 status
= create_synthetic_smb_fname(talloc_tos(), fname
,
301 stream_info
[i
].name
, NULL
,
304 if (!NT_STATUS_IS_OK(status
)) {
305 DEBUG(0, ("talloc_aprintf failed\n"));
309 res
= SMB_VFS_UNLINK(conn
, smb_fname_stream
);
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
),
316 TALLOC_FREE(smb_fname_stream
);
319 TALLOC_FREE(smb_fname_stream
);
327 /****************************************************************************
328 Deal with removing a share mode on last close.
329 ****************************************************************************/
331 static NTSTATUS
close_remove_share_mode(files_struct
*fsp
,
332 enum file_close_type close_type
)
334 connection_struct
*conn
= fsp
->conn
;
335 bool delete_file
= false;
336 bool changed_user
= false;
337 struct share_mode_lock
*lck
= NULL
;
338 NTSTATUS status
= NT_STATUS_OK
;
341 const struct security_unix_token
*del_token
= NULL
;
342 const struct security_token
*del_nt_token
= NULL
;
343 bool got_tokens
= false;
345 /* Ensure any pending write time updates are done. */
346 if (fsp
->update_write_time_event
) {
347 update_write_time_handler(fsp
->conn
->sconn
->ev_ctx
,
348 fsp
->update_write_time_event
,
354 * Lock the share entries, and determine if we should delete
355 * on close. If so delete whilst the lock is still in effect.
356 * This prevents race conditions with the file being created. JRA.
359 lck
= get_existing_share_mode_lock(talloc_tos(), fsp
->file_id
);
361 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
362 "lock for file %s\n", fsp_str_dbg(fsp
)));
363 status
= NT_STATUS_INVALID_PARAMETER
;
367 if (fsp
->write_time_forced
) {
368 DEBUG(10,("close_remove_share_mode: write time forced "
371 set_close_write_time(fsp
, lck
->data
->changed_write_time
);
372 } else if (fsp
->update_write_time_on_close
) {
373 /* Someone had a pending write. */
374 if (null_timespec(fsp
->close_write_time
)) {
375 DEBUG(10,("close_remove_share_mode: update to current time "
378 /* Update to current time due to "normal" write. */
379 set_close_write_time(fsp
, timespec_current());
381 DEBUG(10,("close_remove_share_mode: write time pending "
384 /* Update to time set on close call. */
385 set_close_write_time(fsp
, fsp
->close_write_time
);
389 if (!del_share_mode(lck
, fsp
)) {
390 DEBUG(0, ("close_remove_share_mode: Could not delete share "
391 "entry for file %s\n",
395 if (fsp
->initial_delete_on_close
&&
396 !is_delete_on_close_set(lck
, fsp
->name_hash
)) {
397 bool became_user
= False
;
399 /* Initial delete on close was set and no one else
400 * wrote a real delete on close. */
402 if (get_current_vuid(conn
) != fsp
->vuid
) {
403 become_user(conn
, fsp
->vuid
);
406 fsp
->delete_on_close
= true;
407 set_delete_on_close_lck(fsp
, lck
, True
,
408 get_current_nttok(conn
),
409 get_current_utok(conn
));
415 delete_file
= is_delete_on_close_set(lck
, fsp
->name_hash
);
419 /* See if others still have the file open via this pathname.
420 If this is the case, then don't delete. If all opens are
422 for (i
=0; i
<lck
->data
->num_share_modes
; i
++) {
423 struct share_mode_entry
*e
= &lck
->data
->share_modes
[i
];
424 if (is_valid_share_mode_entry(e
) &&
425 e
->name_hash
== fsp
->name_hash
) {
426 if (fsp
->posix_open
&& (e
->flags
& SHARE_MODE_FLAG_POSIX_OPEN
)) {
429 if (share_mode_stale_pid(lck
->data
, i
)) {
438 /* Notify any deferred opens waiting on this close. */
439 notify_deferred_opens(conn
->sconn
, lck
);
440 reply_to_oplock_break_requests(fsp
);
443 * NT can set delete_on_close of the last open
444 * reference to a file.
447 if (!(close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) ||
454 * Ok, we have to delete the file
457 DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
458 "- deleting file.\n", fsp_str_dbg(fsp
)));
461 * Don't try to update the write time when we delete the file
463 fsp
->update_write_time_on_close
= false;
465 got_tokens
= get_delete_on_close_token(lck
, fsp
->name_hash
,
466 &del_nt_token
, &del_token
);
467 SMB_ASSERT(got_tokens
);
469 if (!unix_token_equal(del_token
, get_current_utok(conn
))) {
470 /* Become the user who requested the delete. */
472 DEBUG(5,("close_remove_share_mode: file %s. "
473 "Change user to uid %u\n",
475 (unsigned int)del_token
->uid
));
477 if (!push_sec_ctx()) {
478 smb_panic("close_remove_share_mode: file %s. failed to push "
482 set_sec_ctx(del_token
->uid
,
491 /* We can only delete the file if the name we have is still valid and
492 hasn't been renamed. */
494 tmp_status
= vfs_stat_fsp(fsp
);
495 if (!NT_STATUS_IS_OK(tmp_status
)) {
496 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
497 "was set and stat failed with error %s\n",
498 fsp_str_dbg(fsp
), nt_errstr(tmp_status
)));
500 * Don't save the errno here, we ignore this error
505 id
= vfs_file_id_from_sbuf(conn
, &fsp
->fsp_name
->st
);
507 if (!file_id_equal(&fsp
->file_id
, &id
)) {
508 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
509 "was set and dev and/or inode does not match\n",
511 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
514 file_id_string_tos(&fsp
->file_id
),
515 file_id_string_tos(&id
)));
517 * Don't save the errno here, we ignore this error
522 if ((conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
523 && !is_ntfs_stream_smb_fname(fsp
->fsp_name
)) {
525 status
= delete_all_streams(conn
, fsp
->fsp_name
->base_name
);
527 if (!NT_STATUS_IS_OK(status
)) {
528 DEBUG(5, ("delete_all_streams failed: %s\n",
535 if (SMB_VFS_UNLINK(conn
, fsp
->fsp_name
) != 0) {
537 * This call can potentially fail as another smbd may
538 * have had the file open with delete on close set and
539 * deleted it when its last reference to this file
540 * went away. Hence we log this but not at debug level
544 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
545 "was set and unlink failed with error %s\n",
546 fsp_str_dbg(fsp
), strerror(errno
)));
548 status
= map_nt_error_from_unix(errno
);
551 /* As we now have POSIX opens which can unlink
552 * with other open files we may have taken
553 * this code path with more than one share mode
554 * entry - ensure we only delete once by resetting
555 * the delete on close flag. JRA.
558 fsp
->delete_on_close
= false;
559 set_delete_on_close_lck(fsp
, lck
, false, NULL
, NULL
);
572 * Do the notification after we released the share
573 * mode lock. Inside notify_fname we take out another
574 * tdb lock. With ctdb also accessing our databases,
575 * this can lead to deadlocks. Putting this notify
576 * after the TALLOC_FREE(lck) above we avoid locking
577 * two records simultaneously. Notifies are async and
578 * informational only, so calling the notify_fname
579 * without holding the share mode lock should not do
582 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
583 FILE_NOTIFY_CHANGE_FILE_NAME
,
584 fsp
->fsp_name
->base_name
);
590 void set_close_write_time(struct files_struct
*fsp
, struct timespec ts
)
592 DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts
))));
594 if (null_timespec(ts
)) {
597 fsp
->write_time_forced
= false;
598 fsp
->update_write_time_on_close
= true;
599 fsp
->close_write_time
= ts
;
602 static NTSTATUS
update_write_time_on_close(struct files_struct
*fsp
)
604 struct smb_file_time ft
;
606 struct share_mode_lock
*lck
= NULL
;
610 if (!fsp
->update_write_time_on_close
) {
614 if (null_timespec(fsp
->close_write_time
)) {
615 fsp
->close_write_time
= timespec_current();
618 /* Ensure we have a valid stat struct for the source. */
619 status
= vfs_stat_fsp(fsp
);
620 if (!NT_STATUS_IS_OK(status
)) {
624 if (!VALID_STAT(fsp
->fsp_name
->st
)) {
625 /* if it doesn't seem to be a real file */
630 * get_existing_share_mode_lock() isn't really the right
631 * call here, as we're being called after
632 * close_remove_share_mode() inside close_normal_file()
633 * so it's quite normal to not have an existing share
634 * mode here. However, get_share_mode_lock() doesn't
635 * work because that will create a new share mode if
636 * one doesn't exist - so stick with this call (just
637 * ignore any error we get if the share mode doesn't
641 lck
= get_existing_share_mode_lock(talloc_tos(), fsp
->file_id
);
643 /* On close if we're changing the real file time we
644 * must update it in the open file db too. */
645 (void)set_write_time(fsp
->file_id
, fsp
->close_write_time
);
647 /* Close write times overwrite sticky write times
648 so we must replace any sticky write time here. */
649 if (!null_timespec(lck
->data
->changed_write_time
)) {
650 (void)set_sticky_write_time(fsp
->file_id
, fsp
->close_write_time
);
655 ft
.mtime
= fsp
->close_write_time
;
656 /* As this is a close based update, we are not directly changing the
657 file attributes from a client call, but indirectly from a write. */
658 status
= smb_set_file_time(fsp
->conn
, fsp
, fsp
->fsp_name
, &ft
, false);
659 if (!NT_STATUS_IS_OK(status
)) {
660 DEBUG(10,("update_write_time_on_close: smb_set_file_time "
661 "on file %s returned %s\n",
670 static NTSTATUS
ntstatus_keeperror(NTSTATUS s1
, NTSTATUS s2
)
672 if (!NT_STATUS_IS_OK(s1
)) {
678 /****************************************************************************
681 close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
682 printing and magic scripts are only run on normal close.
683 delete on close is done on normal and shutdown close.
684 ****************************************************************************/
686 static NTSTATUS
close_normal_file(struct smb_request
*req
, files_struct
*fsp
,
687 enum file_close_type close_type
)
689 NTSTATUS status
= NT_STATUS_OK
;
691 connection_struct
*conn
= fsp
->conn
;
695 * If we're finishing async io on a close we can get a write
696 * error here, we must remember this.
698 ret
= wait_for_aio_completion(fsp
);
700 status
= ntstatus_keeperror(
701 status
, map_nt_error_from_unix(ret
));
705 * If we're flushing on a close we can get a write
706 * error here, we must remember this.
709 tmp
= close_filestruct(fsp
);
710 status
= ntstatus_keeperror(status
, tmp
);
712 if (fsp
->print_file
) {
713 /* FIXME: return spool errors */
714 print_spool_end(fsp
, close_type
);
719 /* Remove the oplock before potentially deleting the file. */
720 if(fsp
->oplock_type
) {
721 release_file_oplock(fsp
);
724 /* If this is an old DOS or FCB open and we have multiple opens on
725 the same handle we only have one share mode. Ensure we only remove
726 the share mode on the last close. */
728 if (fsp
->fh
->ref_count
== 1) {
729 /* Should we return on error here... ? */
730 tmp
= close_remove_share_mode(fsp
, close_type
);
731 status
= ntstatus_keeperror(status
, tmp
);
734 locking_close_file(conn
->sconn
->msg_ctx
, fsp
, close_type
);
737 status
= ntstatus_keeperror(status
, tmp
);
739 /* check for magic scripts */
740 if (close_type
== NORMAL_CLOSE
) {
741 tmp
= check_magic(fsp
);
742 status
= ntstatus_keeperror(status
, tmp
);
746 * Ensure pending modtime is set after close.
749 tmp
= update_write_time_on_close(fsp
);
750 if (NT_STATUS_EQUAL(tmp
, NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
751 /* Someone renamed the file or a parent directory containing
752 * this file. We can't do anything about this, we don't have
753 * an "update timestamp by fd" call in POSIX. Eat the error. */
758 status
= ntstatus_keeperror(status
, tmp
);
760 DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
761 conn
->session_info
->unix_info
->unix_name
, fsp_str_dbg(fsp
),
762 conn
->num_files_open
- 1,
763 nt_errstr(status
) ));
768 /****************************************************************************
769 Static function used by reply_rmdir to delete an entire directory
770 tree recursively. Return True on ok, False on fail.
771 ****************************************************************************/
773 static bool recursive_rmdir(TALLOC_CTX
*ctx
,
774 connection_struct
*conn
,
775 struct smb_filename
*smb_dname
)
777 const char *dname
= NULL
;
778 char *talloced
= NULL
;
782 struct smb_Dir
*dir_hnd
;
784 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname
));
786 dir_hnd
= OpenDir(talloc_tos(), conn
, smb_dname
->base_name
, NULL
, 0);
790 while((dname
= ReadDirName(dir_hnd
, &offset
, &st
, &talloced
))) {
791 struct smb_filename
*smb_dname_full
= NULL
;
792 char *fullname
= NULL
;
793 bool do_break
= true;
796 if (ISDOT(dname
) || ISDOTDOT(dname
)) {
797 TALLOC_FREE(talloced
);
801 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
, &st
,
803 TALLOC_FREE(talloced
);
807 /* Construct the full name. */
808 fullname
= talloc_asprintf(ctx
,
810 smb_dname
->base_name
,
817 status
= create_synthetic_smb_fname(talloc_tos(), fullname
,
820 if (!NT_STATUS_IS_OK(status
)) {
824 if(SMB_VFS_LSTAT(conn
, smb_dname_full
) != 0) {
828 if(smb_dname_full
->st
.st_ex_mode
& S_IFDIR
) {
829 if(!recursive_rmdir(ctx
, conn
, smb_dname_full
)) {
832 if(SMB_VFS_RMDIR(conn
,
833 smb_dname_full
->base_name
) != 0) {
836 } else if(SMB_VFS_UNLINK(conn
, smb_dname_full
) != 0) {
840 /* Successful iteration. */
844 TALLOC_FREE(smb_dname_full
);
845 TALLOC_FREE(fullname
);
846 TALLOC_FREE(talloced
);
852 TALLOC_FREE(dir_hnd
);
856 /****************************************************************************
857 The internals of the rmdir code - called elsewhere.
858 ****************************************************************************/
860 static NTSTATUS
rmdir_internals(TALLOC_CTX
*ctx
, files_struct
*fsp
)
862 connection_struct
*conn
= fsp
->conn
;
863 struct smb_filename
*smb_dname
= fsp
->fsp_name
;
866 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname
));
868 /* Might be a symlink. */
869 if(SMB_VFS_LSTAT(conn
, smb_dname
) != 0) {
870 return map_nt_error_from_unix(errno
);
873 if (S_ISLNK(smb_dname
->st
.st_ex_mode
)) {
874 /* Is what it points to a directory ? */
875 if(SMB_VFS_STAT(conn
, smb_dname
) != 0) {
876 return map_nt_error_from_unix(errno
);
878 if (!(S_ISDIR(smb_dname
->st
.st_ex_mode
))) {
879 return NT_STATUS_NOT_A_DIRECTORY
;
881 ret
= SMB_VFS_UNLINK(conn
, smb_dname
);
883 ret
= SMB_VFS_RMDIR(conn
, smb_dname
->base_name
);
886 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
887 FILE_NOTIFY_CHANGE_DIR_NAME
,
888 smb_dname
->base_name
);
892 if(((errno
== ENOTEMPTY
)||(errno
== EEXIST
)) && *lp_veto_files(SNUM(conn
))) {
894 * Check to see if the only thing in this directory are
895 * vetoed files/directories. If so then delete them and
896 * retry. If we fail to delete any of them (and we *don't*
897 * do a recursive delete) then fail the rmdir.
900 const char *dname
= NULL
;
901 char *talloced
= NULL
;
903 struct smb_Dir
*dir_hnd
= OpenDir(talloc_tos(), conn
,
904 smb_dname
->base_name
, NULL
,
907 if(dir_hnd
== NULL
) {
912 while ((dname
= ReadDirName(dir_hnd
, &dirpos
, &st
,
913 &talloced
)) != NULL
) {
914 if((strcmp(dname
, ".") == 0) || (strcmp(dname
, "..")==0)) {
915 TALLOC_FREE(talloced
);
918 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
,
920 TALLOC_FREE(talloced
);
923 if(!IS_VETO_PATH(conn
, dname
)) {
924 TALLOC_FREE(dir_hnd
);
925 TALLOC_FREE(talloced
);
929 TALLOC_FREE(talloced
);
932 /* We only have veto files/directories.
933 * Are we allowed to delete them ? */
935 if(!lp_recursive_veto_delete(SNUM(conn
))) {
936 TALLOC_FREE(dir_hnd
);
941 /* Do a recursive delete. */
942 RewindDir(dir_hnd
,&dirpos
);
943 while ((dname
= ReadDirName(dir_hnd
, &dirpos
, &st
,
944 &talloced
)) != NULL
) {
945 struct smb_filename
*smb_dname_full
= NULL
;
946 char *fullname
= NULL
;
947 bool do_break
= true;
950 if (ISDOT(dname
) || ISDOTDOT(dname
)) {
951 TALLOC_FREE(talloced
);
954 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
,
956 TALLOC_FREE(talloced
);
960 fullname
= talloc_asprintf(ctx
,
962 smb_dname
->base_name
,
970 status
= create_synthetic_smb_fname(talloc_tos(),
974 if (!NT_STATUS_IS_OK(status
)) {
975 errno
= map_errno_from_nt_status(status
);
979 if(SMB_VFS_LSTAT(conn
, smb_dname_full
) != 0) {
982 if(smb_dname_full
->st
.st_ex_mode
& S_IFDIR
) {
983 if(!recursive_rmdir(ctx
, conn
,
987 if(SMB_VFS_RMDIR(conn
,
988 smb_dname_full
->base_name
) != 0) {
991 } else if(SMB_VFS_UNLINK(conn
, smb_dname_full
) != 0) {
995 /* Successful iteration. */
999 TALLOC_FREE(fullname
);
1000 TALLOC_FREE(smb_dname_full
);
1001 TALLOC_FREE(talloced
);
1005 TALLOC_FREE(dir_hnd
);
1006 /* Retry the rmdir */
1007 ret
= SMB_VFS_RMDIR(conn
, smb_dname
->base_name
);
1013 DEBUG(3,("rmdir_internals: couldn't remove directory %s : "
1014 "%s\n", smb_fname_str_dbg(smb_dname
),
1016 return map_nt_error_from_unix(errno
);
1019 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
1020 FILE_NOTIFY_CHANGE_DIR_NAME
,
1021 smb_dname
->base_name
);
1023 return NT_STATUS_OK
;
1026 /****************************************************************************
1027 Close a directory opened by an NT SMB call.
1028 ****************************************************************************/
1030 static NTSTATUS
close_directory(struct smb_request
*req
, files_struct
*fsp
,
1031 enum file_close_type close_type
)
1033 struct share_mode_lock
*lck
= NULL
;
1034 bool delete_dir
= False
;
1035 NTSTATUS status
= NT_STATUS_OK
;
1036 NTSTATUS status1
= NT_STATUS_OK
;
1037 const struct security_token
*del_nt_token
= NULL
;
1038 const struct security_unix_token
*del_token
= NULL
;
1041 * NT can set delete_on_close of the last open
1042 * reference to a directory also.
1045 lck
= get_existing_share_mode_lock(talloc_tos(), fsp
->file_id
);
1047 DEBUG(0, ("close_directory: Could not get share mode lock for "
1048 "%s\n", fsp_str_dbg(fsp
)));
1049 status
= NT_STATUS_INVALID_PARAMETER
;
1053 if (!del_share_mode(lck
, fsp
)) {
1054 DEBUG(0, ("close_directory: Could not delete share entry for "
1055 "%s\n", fsp_str_dbg(fsp
)));
1058 if (fsp
->initial_delete_on_close
) {
1059 bool became_user
= False
;
1061 /* Initial delete on close was set - for
1062 * directories we don't care if anyone else
1063 * wrote a real delete on close. */
1065 if (get_current_vuid(fsp
->conn
) != fsp
->vuid
) {
1066 become_user(fsp
->conn
, fsp
->vuid
);
1069 send_stat_cache_delete_message(fsp
->conn
->sconn
->msg_ctx
,
1070 fsp
->fsp_name
->base_name
);
1071 set_delete_on_close_lck(fsp
, lck
, true,
1072 get_current_nttok(fsp
->conn
),
1073 get_current_utok(fsp
->conn
));
1074 fsp
->delete_on_close
= true;
1080 delete_dir
= get_delete_on_close_token(lck
, fsp
->name_hash
,
1081 &del_nt_token
, &del_token
);
1085 /* See if others still have the dir open. If this is the
1086 * case, then don't delete. If all opens are POSIX delete now. */
1087 for (i
=0; i
<lck
->data
->num_share_modes
; i
++) {
1088 struct share_mode_entry
*e
= &lck
->data
->share_modes
[i
];
1089 if (is_valid_share_mode_entry(e
) &&
1090 e
->name_hash
== fsp
->name_hash
) {
1091 if (fsp
->posix_open
&& (e
->flags
& SHARE_MODE_FLAG_POSIX_OPEN
)) {
1094 if (share_mode_stale_pid(lck
->data
, i
)) {
1103 if ((close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) &&
1106 /* Become the user who requested the delete. */
1108 if (!push_sec_ctx()) {
1109 smb_panic("close_directory: failed to push sec_ctx.\n");
1112 set_sec_ctx(del_token
->uid
,
1120 if ((fsp
->conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
1121 && !is_ntfs_stream_smb_fname(fsp
->fsp_name
)) {
1123 status
= delete_all_streams(fsp
->conn
, fsp
->fsp_name
->base_name
);
1124 if (!NT_STATUS_IS_OK(status
)) {
1125 DEBUG(5, ("delete_all_streams failed: %s\n",
1126 nt_errstr(status
)));
1131 status
= rmdir_internals(talloc_tos(), fsp
);
1133 DEBUG(5,("close_directory: %s. Delete on close was set - "
1134 "deleting directory returned %s.\n",
1135 fsp_str_dbg(fsp
), nt_errstr(status
)));
1137 /* unbecome user. */
1141 * Ensure we remove any change notify requests that would
1142 * now fail as the directory has been deleted.
1145 if(NT_STATUS_IS_OK(status
)) {
1146 remove_pending_change_notify_requests_by_fid(fsp
, NT_STATUS_DELETE_PENDING
);
1150 remove_pending_change_notify_requests_by_fid(
1154 status1
= fd_close(fsp
);
1156 if (!NT_STATUS_IS_OK(status1
)) {
1157 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
1158 fsp_str_dbg(fsp
), fsp
->fh
->fd
, errno
,
1163 * Do the code common to files and directories.
1165 close_filestruct(fsp
);
1166 file_free(req
, fsp
);
1170 if (NT_STATUS_IS_OK(status
) && !NT_STATUS_IS_OK(status1
)) {
1176 /****************************************************************************
1177 Close a files_struct.
1178 ****************************************************************************/
1180 NTSTATUS
close_file(struct smb_request
*req
, files_struct
*fsp
,
1181 enum file_close_type close_type
)
1184 struct files_struct
*base_fsp
= fsp
->base_fsp
;
1186 if(fsp
->is_directory
) {
1187 status
= close_directory(req
, fsp
, close_type
);
1188 } else if (fsp
->fake_file_handle
!= NULL
) {
1189 status
= close_fake_file(req
, fsp
);
1191 status
= close_normal_file(req
, fsp
, close_type
);
1194 if ((base_fsp
!= NULL
) && (close_type
!= SHUTDOWN_CLOSE
)) {
1197 * fsp was a stream, the base fsp can't be a stream as well
1199 * For SHUTDOWN_CLOSE this is not possible here, because
1200 * SHUTDOWN_CLOSE only happens from files.c which walks the
1201 * complete list of files. If we mess with more than one fsp
1202 * those loops will become confused.
1205 SMB_ASSERT(base_fsp
->base_fsp
== NULL
);
1206 close_file(req
, base_fsp
, close_type
);
1212 /****************************************************************************
1213 Deal with an (authorized) message to close a file given the share mode
1215 ****************************************************************************/
1217 void msg_close_file(struct messaging_context
*msg_ctx
,
1220 struct server_id server_id
,
1223 files_struct
*fsp
= NULL
;
1224 struct share_mode_entry e
;
1225 struct smbd_server_connection
*sconn
=
1226 talloc_get_type_abort(private_data
,
1227 struct smbd_server_connection
);
1229 message_to_share_mode_entry(&e
, (char *)data
->data
);
1232 char *sm_str
= share_mode_str(NULL
, 0, &e
);
1234 smb_panic("talloc failed");
1236 DEBUG(10,("msg_close_file: got request to close share mode "
1237 "entry %s\n", sm_str
));
1238 TALLOC_FREE(sm_str
);
1241 fsp
= file_find_dif(sconn
, e
.id
, e
.share_file_id
);
1243 DEBUG(10,("msg_close_file: failed to find file.\n"));
1246 close_file(NULL
, fsp
, NORMAL_CLOSE
);