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 uint32_t i
, num_deferred
;
174 struct share_mode_entry
*deferred
;
176 if (!should_notify_deferred_opens()) {
181 for (i
=0; i
<lck
->data
->num_share_modes
; i
++) {
182 struct share_mode_entry
*e
= &lck
->data
->share_modes
[i
];
184 if (!is_deferred_open_entry(e
)) {
187 if (share_mode_stale_pid(lck
->data
, i
)) {
192 if (num_deferred
== 0) {
196 deferred
= talloc_array(talloc_tos(), struct share_mode_entry
,
198 if (deferred
== NULL
) {
203 for (i
=0; i
<lck
->data
->num_share_modes
; i
++) {
204 struct share_mode_entry
*e
= &lck
->data
->share_modes
[i
];
205 if (is_deferred_open_entry(e
)) {
206 deferred
[num_deferred
] = *e
;
212 * We need to sort the notifications by initial request time. Imagine
213 * two opens come in asyncronously, both conflicting with the open we
214 * just close here. If we don't sort the notifications, the one that
215 * came in last might get the response before the one that came in
216 * first. This is demonstrated with the smbtorture4 raw.mux test.
218 * As long as we had the UNUSED_SHARE_MODE_ENTRY, we happened to
219 * survive this particular test. Without UNUSED_SHARE_MODE_ENTRY, we
220 * shuffle the share mode entries around a bit, so that we do not
221 * survive raw.mux anymore.
223 * We could have kept the ordering in del_share_mode, but as the
224 * ordering was never formalized I think it is better to do it here
225 * where it is necessary.
228 qsort(deferred
, num_deferred
, sizeof(struct share_mode_entry
),
229 compare_share_mode_times
);
231 for (i
=0; i
<num_deferred
; i
++) {
232 struct share_mode_entry
*e
= &deferred
[i
];
234 if (procid_is_me(&e
->pid
)) {
236 * We need to notify ourself to retry the open. Do
237 * this by finding the queued SMB record, moving it to
238 * the head of the queue and changing the wait time to
241 schedule_deferred_open_message_smb(sconn
, e
->op_mid
);
243 char msg
[MSG_SMB_SHARE_MODE_ENTRY_SIZE
];
245 share_mode_entry_to_message(msg
, e
);
247 messaging_send_buf(sconn
->msg_ctx
, e
->pid
,
250 MSG_SMB_SHARE_MODE_ENTRY_SIZE
);
253 TALLOC_FREE(deferred
);
256 /****************************************************************************
258 ****************************************************************************/
260 NTSTATUS
delete_all_streams(connection_struct
*conn
, const char *fname
)
262 struct stream_struct
*stream_info
= NULL
;
264 unsigned int num_streams
= 0;
265 TALLOC_CTX
*frame
= talloc_stackframe();
268 status
= vfs_streaminfo(conn
, NULL
, fname
, talloc_tos(),
269 &num_streams
, &stream_info
);
271 if (NT_STATUS_EQUAL(status
, NT_STATUS_NOT_IMPLEMENTED
)) {
272 DEBUG(10, ("no streams around\n"));
277 if (!NT_STATUS_IS_OK(status
)) {
278 DEBUG(10, ("vfs_streaminfo failed: %s\n",
283 DEBUG(10, ("delete_all_streams found %d streams\n",
286 if (num_streams
== 0) {
291 for (i
=0; i
<num_streams
; i
++) {
293 struct smb_filename
*smb_fname_stream
= NULL
;
295 if (strequal(stream_info
[i
].name
, "::$DATA")) {
299 status
= create_synthetic_smb_fname(talloc_tos(), fname
,
300 stream_info
[i
].name
, NULL
,
303 if (!NT_STATUS_IS_OK(status
)) {
304 DEBUG(0, ("talloc_aprintf failed\n"));
308 res
= SMB_VFS_UNLINK(conn
, smb_fname_stream
);
311 status
= map_nt_error_from_unix(errno
);
312 DEBUG(10, ("Could not delete stream %s: %s\n",
313 smb_fname_str_dbg(smb_fname_stream
),
315 TALLOC_FREE(smb_fname_stream
);
318 TALLOC_FREE(smb_fname_stream
);
326 /****************************************************************************
327 Deal with removing a share mode on last close.
328 ****************************************************************************/
330 static NTSTATUS
close_remove_share_mode(files_struct
*fsp
,
331 enum file_close_type close_type
)
333 connection_struct
*conn
= fsp
->conn
;
334 bool delete_file
= false;
335 bool changed_user
= false;
336 struct share_mode_lock
*lck
= NULL
;
337 NTSTATUS status
= NT_STATUS_OK
;
340 const struct security_unix_token
*del_token
= NULL
;
341 const struct security_token
*del_nt_token
= NULL
;
342 bool got_tokens
= false;
344 /* Ensure any pending write time updates are done. */
345 if (fsp
->update_write_time_event
) {
346 update_write_time_handler(fsp
->conn
->sconn
->ev_ctx
,
347 fsp
->update_write_time_event
,
353 * Lock the share entries, and determine if we should delete
354 * on close. If so delete whilst the lock is still in effect.
355 * This prevents race conditions with the file being created. JRA.
358 lck
= get_existing_share_mode_lock(talloc_tos(), fsp
->file_id
);
360 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
361 "lock for file %s\n", fsp_str_dbg(fsp
)));
362 status
= NT_STATUS_INVALID_PARAMETER
;
366 if (fsp
->write_time_forced
) {
367 DEBUG(10,("close_remove_share_mode: write time forced "
370 set_close_write_time(fsp
, lck
->data
->changed_write_time
);
371 } else if (fsp
->update_write_time_on_close
) {
372 /* Someone had a pending write. */
373 if (null_timespec(fsp
->close_write_time
)) {
374 DEBUG(10,("close_remove_share_mode: update to current time "
377 /* Update to current time due to "normal" write. */
378 set_close_write_time(fsp
, timespec_current());
380 DEBUG(10,("close_remove_share_mode: write time pending "
383 /* Update to time set on close call. */
384 set_close_write_time(fsp
, fsp
->close_write_time
);
388 if (!del_share_mode(lck
, fsp
)) {
389 DEBUG(0, ("close_remove_share_mode: Could not delete share "
390 "entry for file %s\n",
394 if (fsp
->initial_delete_on_close
&&
395 !is_delete_on_close_set(lck
, fsp
->name_hash
)) {
396 bool became_user
= False
;
398 /* Initial delete on close was set and no one else
399 * wrote a real delete on close. */
401 if (get_current_vuid(conn
) != fsp
->vuid
) {
402 become_user(conn
, fsp
->vuid
);
405 fsp
->delete_on_close
= true;
406 set_delete_on_close_lck(fsp
, lck
, True
,
407 get_current_nttok(conn
),
408 get_current_utok(conn
));
414 delete_file
= is_delete_on_close_set(lck
, fsp
->name_hash
);
418 /* See if others still have the file open via this pathname.
419 If this is the case, then don't delete. If all opens are
421 for (i
=0; i
<lck
->data
->num_share_modes
; i
++) {
422 struct share_mode_entry
*e
= &lck
->data
->share_modes
[i
];
423 if (is_valid_share_mode_entry(e
) &&
424 e
->name_hash
== fsp
->name_hash
) {
425 if (fsp
->posix_open
&& (e
->flags
& SHARE_MODE_FLAG_POSIX_OPEN
)) {
428 if (share_mode_stale_pid(lck
->data
, i
)) {
437 /* Notify any deferred opens waiting on this close. */
438 notify_deferred_opens(conn
->sconn
, lck
);
439 reply_to_oplock_break_requests(fsp
);
442 * NT can set delete_on_close of the last open
443 * reference to a file.
446 if (!(close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) ||
453 * Ok, we have to delete the file
456 DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
457 "- deleting file.\n", fsp_str_dbg(fsp
)));
460 * Don't try to update the write time when we delete the file
462 fsp
->update_write_time_on_close
= false;
464 got_tokens
= get_delete_on_close_token(lck
, fsp
->name_hash
,
465 &del_nt_token
, &del_token
);
466 SMB_ASSERT(got_tokens
);
468 if (!unix_token_equal(del_token
, get_current_utok(conn
))) {
469 /* Become the user who requested the delete. */
471 DEBUG(5,("close_remove_share_mode: file %s. "
472 "Change user to uid %u\n",
474 (unsigned int)del_token
->uid
));
476 if (!push_sec_ctx()) {
477 smb_panic("close_remove_share_mode: file %s. failed to push "
481 set_sec_ctx(del_token
->uid
,
490 /* We can only delete the file if the name we have is still valid and
491 hasn't been renamed. */
493 tmp_status
= vfs_stat_fsp(fsp
);
494 if (!NT_STATUS_IS_OK(tmp_status
)) {
495 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
496 "was set and stat failed with error %s\n",
497 fsp_str_dbg(fsp
), nt_errstr(tmp_status
)));
499 * Don't save the errno here, we ignore this error
504 id
= vfs_file_id_from_sbuf(conn
, &fsp
->fsp_name
->st
);
506 if (!file_id_equal(&fsp
->file_id
, &id
)) {
507 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
508 "was set and dev and/or inode does not match\n",
510 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
513 file_id_string_tos(&fsp
->file_id
),
514 file_id_string_tos(&id
)));
516 * Don't save the errno here, we ignore this error
521 if ((conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
522 && !is_ntfs_stream_smb_fname(fsp
->fsp_name
)) {
524 status
= delete_all_streams(conn
, fsp
->fsp_name
->base_name
);
526 if (!NT_STATUS_IS_OK(status
)) {
527 DEBUG(5, ("delete_all_streams failed: %s\n",
534 if (SMB_VFS_UNLINK(conn
, fsp
->fsp_name
) != 0) {
536 * This call can potentially fail as another smbd may
537 * have had the file open with delete on close set and
538 * deleted it when its last reference to this file
539 * went away. Hence we log this but not at debug level
543 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
544 "was set and unlink failed with error %s\n",
545 fsp_str_dbg(fsp
), strerror(errno
)));
547 status
= map_nt_error_from_unix(errno
);
550 /* As we now have POSIX opens which can unlink
551 * with other open files we may have taken
552 * this code path with more than one share mode
553 * entry - ensure we only delete once by resetting
554 * the delete on close flag. JRA.
557 fsp
->delete_on_close
= false;
558 set_delete_on_close_lck(fsp
, lck
, false, NULL
, NULL
);
571 * Do the notification after we released the share
572 * mode lock. Inside notify_fname we take out another
573 * tdb lock. With ctdb also accessing our databases,
574 * this can lead to deadlocks. Putting this notify
575 * after the TALLOC_FREE(lck) above we avoid locking
576 * two records simultaneously. Notifies are async and
577 * informational only, so calling the notify_fname
578 * without holding the share mode lock should not do
581 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
582 FILE_NOTIFY_CHANGE_FILE_NAME
,
583 fsp
->fsp_name
->base_name
);
589 void set_close_write_time(struct files_struct
*fsp
, struct timespec ts
)
591 DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts
))));
593 if (null_timespec(ts
)) {
596 fsp
->write_time_forced
= false;
597 fsp
->update_write_time_on_close
= true;
598 fsp
->close_write_time
= ts
;
601 static NTSTATUS
update_write_time_on_close(struct files_struct
*fsp
)
603 struct smb_file_time ft
;
605 struct share_mode_lock
*lck
= NULL
;
609 if (!fsp
->update_write_time_on_close
) {
613 if (null_timespec(fsp
->close_write_time
)) {
614 fsp
->close_write_time
= timespec_current();
617 /* Ensure we have a valid stat struct for the source. */
618 status
= vfs_stat_fsp(fsp
);
619 if (!NT_STATUS_IS_OK(status
)) {
623 if (!VALID_STAT(fsp
->fsp_name
->st
)) {
624 /* if it doesn't seem to be a real file */
628 /* On close if we're changing the real file time we
629 * must update it in the open file db too. */
630 (void)set_write_time(fsp
->file_id
, fsp
->close_write_time
);
632 lck
= get_existing_share_mode_lock(talloc_tos(), fsp
->file_id
);
634 /* Close write times overwrite sticky write times
635 so we must replace any sticky write time here. */
636 if (!null_timespec(lck
->data
->changed_write_time
)) {
637 (void)set_sticky_write_time(fsp
->file_id
, fsp
->close_write_time
);
642 ft
.mtime
= fsp
->close_write_time
;
643 /* As this is a close based update, we are not directly changing the
644 file attributes from a client call, but indirectly from a write. */
645 status
= smb_set_file_time(fsp
->conn
, fsp
, fsp
->fsp_name
, &ft
, false);
646 if (!NT_STATUS_IS_OK(status
)) {
647 DEBUG(10,("update_write_time_on_close: smb_set_file_time "
648 "on file %s returned %s\n",
657 static NTSTATUS
ntstatus_keeperror(NTSTATUS s1
, NTSTATUS s2
)
659 if (!NT_STATUS_IS_OK(s1
)) {
665 /****************************************************************************
668 close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
669 printing and magic scripts are only run on normal close.
670 delete on close is done on normal and shutdown close.
671 ****************************************************************************/
673 static NTSTATUS
close_normal_file(struct smb_request
*req
, files_struct
*fsp
,
674 enum file_close_type close_type
)
676 NTSTATUS status
= NT_STATUS_OK
;
678 connection_struct
*conn
= fsp
->conn
;
682 * If we're finishing async io on a close we can get a write
683 * error here, we must remember this.
685 ret
= wait_for_aio_completion(fsp
);
687 status
= ntstatus_keeperror(
688 status
, map_nt_error_from_unix(ret
));
692 * If we're flushing on a close we can get a write
693 * error here, we must remember this.
696 tmp
= close_filestruct(fsp
);
697 status
= ntstatus_keeperror(status
, tmp
);
699 if (fsp
->print_file
) {
700 /* FIXME: return spool errors */
701 print_spool_end(fsp
, close_type
);
706 /* Remove the oplock before potentially deleting the file. */
707 if(fsp
->oplock_type
) {
708 release_file_oplock(fsp
);
711 /* If this is an old DOS or FCB open and we have multiple opens on
712 the same handle we only have one share mode. Ensure we only remove
713 the share mode on the last close. */
715 if (fsp
->fh
->ref_count
== 1) {
716 /* Should we return on error here... ? */
717 tmp
= close_remove_share_mode(fsp
, close_type
);
718 status
= ntstatus_keeperror(status
, tmp
);
721 locking_close_file(conn
->sconn
->msg_ctx
, fsp
, close_type
);
724 status
= ntstatus_keeperror(status
, tmp
);
726 /* check for magic scripts */
727 if (close_type
== NORMAL_CLOSE
) {
728 tmp
= check_magic(fsp
);
729 status
= ntstatus_keeperror(status
, tmp
);
733 * Ensure pending modtime is set after close.
736 tmp
= update_write_time_on_close(fsp
);
737 if (NT_STATUS_EQUAL(tmp
, NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
738 /* Someone renamed the file or a parent directory containing
739 * this file. We can't do anything about this, we don't have
740 * an "update timestamp by fd" call in POSIX. Eat the error. */
745 status
= ntstatus_keeperror(status
, tmp
);
747 DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
748 conn
->session_info
->unix_info
->unix_name
, fsp_str_dbg(fsp
),
749 conn
->num_files_open
- 1,
750 nt_errstr(status
) ));
755 /****************************************************************************
756 Static function used by reply_rmdir to delete an entire directory
757 tree recursively. Return True on ok, False on fail.
758 ****************************************************************************/
760 static bool recursive_rmdir(TALLOC_CTX
*ctx
,
761 connection_struct
*conn
,
762 struct smb_filename
*smb_dname
)
764 const char *dname
= NULL
;
765 char *talloced
= NULL
;
769 struct smb_Dir
*dir_hnd
;
771 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname
));
773 dir_hnd
= OpenDir(talloc_tos(), conn
, smb_dname
->base_name
, NULL
, 0);
777 while((dname
= ReadDirName(dir_hnd
, &offset
, &st
, &talloced
))) {
778 struct smb_filename
*smb_dname_full
= NULL
;
779 char *fullname
= NULL
;
780 bool do_break
= true;
783 if (ISDOT(dname
) || ISDOTDOT(dname
)) {
784 TALLOC_FREE(talloced
);
788 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
, &st
,
790 TALLOC_FREE(talloced
);
794 /* Construct the full name. */
795 fullname
= talloc_asprintf(ctx
,
797 smb_dname
->base_name
,
804 status
= create_synthetic_smb_fname(talloc_tos(), fullname
,
807 if (!NT_STATUS_IS_OK(status
)) {
811 if(SMB_VFS_LSTAT(conn
, smb_dname_full
) != 0) {
815 if(smb_dname_full
->st
.st_ex_mode
& S_IFDIR
) {
816 if(!recursive_rmdir(ctx
, conn
, smb_dname_full
)) {
819 if(SMB_VFS_RMDIR(conn
,
820 smb_dname_full
->base_name
) != 0) {
823 } else if(SMB_VFS_UNLINK(conn
, smb_dname_full
) != 0) {
827 /* Successful iteration. */
831 TALLOC_FREE(smb_dname_full
);
832 TALLOC_FREE(fullname
);
833 TALLOC_FREE(talloced
);
839 TALLOC_FREE(dir_hnd
);
843 /****************************************************************************
844 The internals of the rmdir code - called elsewhere.
845 ****************************************************************************/
847 static NTSTATUS
rmdir_internals(TALLOC_CTX
*ctx
, files_struct
*fsp
)
849 connection_struct
*conn
= fsp
->conn
;
850 struct smb_filename
*smb_dname
= fsp
->fsp_name
;
853 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname
));
855 /* Might be a symlink. */
856 if(SMB_VFS_LSTAT(conn
, smb_dname
) != 0) {
857 return map_nt_error_from_unix(errno
);
860 if (S_ISLNK(smb_dname
->st
.st_ex_mode
)) {
861 /* Is what it points to a directory ? */
862 if(SMB_VFS_STAT(conn
, smb_dname
) != 0) {
863 return map_nt_error_from_unix(errno
);
865 if (!(S_ISDIR(smb_dname
->st
.st_ex_mode
))) {
866 return NT_STATUS_NOT_A_DIRECTORY
;
868 ret
= SMB_VFS_UNLINK(conn
, smb_dname
);
870 ret
= SMB_VFS_RMDIR(conn
, smb_dname
->base_name
);
873 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
874 FILE_NOTIFY_CHANGE_DIR_NAME
,
875 smb_dname
->base_name
);
879 if(((errno
== ENOTEMPTY
)||(errno
== EEXIST
)) && *lp_veto_files(SNUM(conn
))) {
881 * Check to see if the only thing in this directory are
882 * vetoed files/directories. If so then delete them and
883 * retry. If we fail to delete any of them (and we *don't*
884 * do a recursive delete) then fail the rmdir.
887 const char *dname
= NULL
;
888 char *talloced
= NULL
;
890 struct smb_Dir
*dir_hnd
= OpenDir(talloc_tos(), conn
,
891 smb_dname
->base_name
, NULL
,
894 if(dir_hnd
== NULL
) {
899 while ((dname
= ReadDirName(dir_hnd
, &dirpos
, &st
,
900 &talloced
)) != NULL
) {
901 if((strcmp(dname
, ".") == 0) || (strcmp(dname
, "..")==0)) {
902 TALLOC_FREE(talloced
);
905 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
,
907 TALLOC_FREE(talloced
);
910 if(!IS_VETO_PATH(conn
, dname
)) {
911 TALLOC_FREE(dir_hnd
);
912 TALLOC_FREE(talloced
);
916 TALLOC_FREE(talloced
);
919 /* We only have veto files/directories.
920 * Are we allowed to delete them ? */
922 if(!lp_recursive_veto_delete(SNUM(conn
))) {
923 TALLOC_FREE(dir_hnd
);
928 /* Do a recursive delete. */
929 RewindDir(dir_hnd
,&dirpos
);
930 while ((dname
= ReadDirName(dir_hnd
, &dirpos
, &st
,
931 &talloced
)) != NULL
) {
932 struct smb_filename
*smb_dname_full
= NULL
;
933 char *fullname
= NULL
;
934 bool do_break
= true;
937 if (ISDOT(dname
) || ISDOTDOT(dname
)) {
938 TALLOC_FREE(talloced
);
941 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
,
943 TALLOC_FREE(talloced
);
947 fullname
= talloc_asprintf(ctx
,
949 smb_dname
->base_name
,
957 status
= create_synthetic_smb_fname(talloc_tos(),
961 if (!NT_STATUS_IS_OK(status
)) {
962 errno
= map_errno_from_nt_status(status
);
966 if(SMB_VFS_LSTAT(conn
, smb_dname_full
) != 0) {
969 if(smb_dname_full
->st
.st_ex_mode
& S_IFDIR
) {
970 if(!recursive_rmdir(ctx
, conn
,
974 if(SMB_VFS_RMDIR(conn
,
975 smb_dname_full
->base_name
) != 0) {
978 } else if(SMB_VFS_UNLINK(conn
, smb_dname_full
) != 0) {
982 /* Successful iteration. */
986 TALLOC_FREE(fullname
);
987 TALLOC_FREE(smb_dname_full
);
988 TALLOC_FREE(talloced
);
992 TALLOC_FREE(dir_hnd
);
993 /* Retry the rmdir */
994 ret
= SMB_VFS_RMDIR(conn
, smb_dname
->base_name
);
1000 DEBUG(3,("rmdir_internals: couldn't remove directory %s : "
1001 "%s\n", smb_fname_str_dbg(smb_dname
),
1003 return map_nt_error_from_unix(errno
);
1006 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
1007 FILE_NOTIFY_CHANGE_DIR_NAME
,
1008 smb_dname
->base_name
);
1010 return NT_STATUS_OK
;
1013 /****************************************************************************
1014 Close a directory opened by an NT SMB call.
1015 ****************************************************************************/
1017 static NTSTATUS
close_directory(struct smb_request
*req
, files_struct
*fsp
,
1018 enum file_close_type close_type
)
1020 struct share_mode_lock
*lck
= NULL
;
1021 bool delete_dir
= False
;
1022 NTSTATUS status
= NT_STATUS_OK
;
1023 NTSTATUS status1
= NT_STATUS_OK
;
1024 const struct security_token
*del_nt_token
= NULL
;
1025 const struct security_unix_token
*del_token
= NULL
;
1028 * NT can set delete_on_close of the last open
1029 * reference to a directory also.
1032 lck
= get_existing_share_mode_lock(talloc_tos(), fsp
->file_id
);
1034 DEBUG(0, ("close_directory: Could not get share mode lock for "
1035 "%s\n", fsp_str_dbg(fsp
)));
1036 status
= NT_STATUS_INVALID_PARAMETER
;
1040 if (!del_share_mode(lck
, fsp
)) {
1041 DEBUG(0, ("close_directory: Could not delete share entry for "
1042 "%s\n", fsp_str_dbg(fsp
)));
1045 if (fsp
->initial_delete_on_close
) {
1046 bool became_user
= False
;
1048 /* Initial delete on close was set - for
1049 * directories we don't care if anyone else
1050 * wrote a real delete on close. */
1052 if (get_current_vuid(fsp
->conn
) != fsp
->vuid
) {
1053 become_user(fsp
->conn
, fsp
->vuid
);
1056 send_stat_cache_delete_message(fsp
->conn
->sconn
->msg_ctx
,
1057 fsp
->fsp_name
->base_name
);
1058 set_delete_on_close_lck(fsp
, lck
, true,
1059 get_current_nttok(fsp
->conn
),
1060 get_current_utok(fsp
->conn
));
1061 fsp
->delete_on_close
= true;
1067 delete_dir
= get_delete_on_close_token(lck
, fsp
->name_hash
,
1068 &del_nt_token
, &del_token
);
1072 /* See if others still have the dir open. If this is the
1073 * case, then don't delete. If all opens are POSIX delete now. */
1074 for (i
=0; i
<lck
->data
->num_share_modes
; i
++) {
1075 struct share_mode_entry
*e
= &lck
->data
->share_modes
[i
];
1076 if (is_valid_share_mode_entry(e
) &&
1077 e
->name_hash
== fsp
->name_hash
) {
1078 if (fsp
->posix_open
&& (e
->flags
& SHARE_MODE_FLAG_POSIX_OPEN
)) {
1087 if ((close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) &&
1090 /* Become the user who requested the delete. */
1092 if (!push_sec_ctx()) {
1093 smb_panic("close_directory: failed to push sec_ctx.\n");
1096 set_sec_ctx(del_token
->uid
,
1104 if ((fsp
->conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
1105 && !is_ntfs_stream_smb_fname(fsp
->fsp_name
)) {
1107 status
= delete_all_streams(fsp
->conn
, fsp
->fsp_name
->base_name
);
1108 if (!NT_STATUS_IS_OK(status
)) {
1109 DEBUG(5, ("delete_all_streams failed: %s\n",
1110 nt_errstr(status
)));
1115 status
= rmdir_internals(talloc_tos(), fsp
);
1117 DEBUG(5,("close_directory: %s. Delete on close was set - "
1118 "deleting directory returned %s.\n",
1119 fsp_str_dbg(fsp
), nt_errstr(status
)));
1121 /* unbecome user. */
1125 * Ensure we remove any change notify requests that would
1126 * now fail as the directory has been deleted.
1129 if(NT_STATUS_IS_OK(status
)) {
1130 remove_pending_change_notify_requests_by_fid(fsp
, NT_STATUS_DELETE_PENDING
);
1134 remove_pending_change_notify_requests_by_fid(
1138 status1
= fd_close(fsp
);
1140 if (!NT_STATUS_IS_OK(status1
)) {
1141 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
1142 fsp_str_dbg(fsp
), fsp
->fh
->fd
, errno
,
1147 * Do the code common to files and directories.
1149 close_filestruct(fsp
);
1150 file_free(req
, fsp
);
1154 if (NT_STATUS_IS_OK(status
) && !NT_STATUS_IS_OK(status1
)) {
1160 /****************************************************************************
1161 Close a files_struct.
1162 ****************************************************************************/
1164 NTSTATUS
close_file(struct smb_request
*req
, files_struct
*fsp
,
1165 enum file_close_type close_type
)
1168 struct files_struct
*base_fsp
= fsp
->base_fsp
;
1170 if(fsp
->is_directory
) {
1171 status
= close_directory(req
, fsp
, close_type
);
1172 } else if (fsp
->fake_file_handle
!= NULL
) {
1173 status
= close_fake_file(req
, fsp
);
1175 status
= close_normal_file(req
, fsp
, close_type
);
1178 if ((base_fsp
!= NULL
) && (close_type
!= SHUTDOWN_CLOSE
)) {
1181 * fsp was a stream, the base fsp can't be a stream as well
1183 * For SHUTDOWN_CLOSE this is not possible here, because
1184 * SHUTDOWN_CLOSE only happens from files.c which walks the
1185 * complete list of files. If we mess with more than one fsp
1186 * those loops will become confused.
1189 SMB_ASSERT(base_fsp
->base_fsp
== NULL
);
1190 close_file(req
, base_fsp
, close_type
);
1196 /****************************************************************************
1197 Deal with an (authorized) message to close a file given the share mode
1199 ****************************************************************************/
1201 void msg_close_file(struct messaging_context
*msg_ctx
,
1204 struct server_id server_id
,
1207 files_struct
*fsp
= NULL
;
1208 struct share_mode_entry e
;
1209 struct smbd_server_connection
*sconn
=
1210 talloc_get_type_abort(private_data
,
1211 struct smbd_server_connection
);
1213 message_to_share_mode_entry(&e
, (char *)data
->data
);
1216 char *sm_str
= share_mode_str(NULL
, 0, &e
);
1218 smb_panic("talloc failed");
1220 DEBUG(10,("msg_close_file: got request to close share mode "
1221 "entry %s\n", sm_str
));
1222 TALLOC_FREE(sm_str
);
1225 fsp
= file_find_dif(sconn
, e
.id
, e
.share_file_id
);
1227 DEBUG(10,("msg_close_file: failed to find file.\n"));
1230 close_file(NULL
, fsp
, NORMAL_CLOSE
);