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(talloc_tos(), 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(talloc_tos(), SNUM(conn
)),p
)) {
66 status
= NT_STATUS_OK
;
70 if (*lp_magicoutput(talloc_tos(), SNUM(conn
))) {
71 magic_output
= lp_magicoutput(talloc_tos(), 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 (serverid_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 struct server_id self
= messaging_server_id(conn
->sconn
->msg_ctx
);
336 bool delete_file
= false;
337 bool changed_user
= false;
338 struct share_mode_lock
*lck
= NULL
;
339 NTSTATUS status
= NT_STATUS_OK
;
342 const struct security_unix_token
*del_token
= NULL
;
343 const struct security_token
*del_nt_token
= NULL
;
344 bool got_tokens
= false;
347 /* Ensure any pending write time updates are done. */
348 if (fsp
->update_write_time_event
) {
349 update_write_time_handler(fsp
->conn
->sconn
->ev_ctx
,
350 fsp
->update_write_time_event
,
356 * Lock the share entries, and determine if we should delete
357 * on close. If so delete whilst the lock is still in effect.
358 * This prevents race conditions with the file being created. JRA.
361 lck
= get_existing_share_mode_lock(talloc_tos(), fsp
->file_id
);
363 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
364 "lock for file %s\n", fsp_str_dbg(fsp
)));
365 return NT_STATUS_INVALID_PARAMETER
;
368 if (fsp
->write_time_forced
) {
369 DEBUG(10,("close_remove_share_mode: write time forced "
372 set_close_write_time(fsp
, lck
->data
->changed_write_time
);
373 } else if (fsp
->update_write_time_on_close
) {
374 /* Someone had a pending write. */
375 if (null_timespec(fsp
->close_write_time
)) {
376 DEBUG(10,("close_remove_share_mode: update to current time "
379 /* Update to current time due to "normal" write. */
380 set_close_write_time(fsp
, timespec_current());
382 DEBUG(10,("close_remove_share_mode: write time pending "
385 /* Update to time set on close call. */
386 set_close_write_time(fsp
, fsp
->close_write_time
);
390 if (fsp
->initial_delete_on_close
&&
391 !is_delete_on_close_set(lck
, fsp
->name_hash
)) {
392 bool became_user
= False
;
394 /* Initial delete on close was set and no one else
395 * wrote a real delete on close. */
397 if (get_current_vuid(conn
) != fsp
->vuid
) {
398 become_user(conn
, fsp
->vuid
);
401 fsp
->delete_on_close
= true;
402 set_delete_on_close_lck(fsp
, lck
, True
,
403 get_current_nttok(conn
),
404 get_current_utok(conn
));
410 delete_file
= is_delete_on_close_set(lck
, fsp
->name_hash
);
414 /* See if others still have the file open via this pathname.
415 If this is the case, then don't delete. If all opens are
417 for (i
=0; i
<lck
->data
->num_share_modes
; i
++) {
418 struct share_mode_entry
*e
= &lck
->data
->share_modes
[i
];
420 if (!is_valid_share_mode_entry(e
)) {
423 if (e
->name_hash
!= fsp
->name_hash
) {
427 && (e
->flags
& SHARE_MODE_FLAG_POSIX_OPEN
)) {
430 if (serverid_equal(&self
, &e
->pid
) &&
431 (e
->share_file_id
== fsp
->fh
->gen_id
)) {
434 if (share_mode_stale_pid(lck
->data
, i
)) {
442 /* Notify any deferred opens waiting on this close. */
443 notify_deferred_opens(conn
->sconn
, lck
);
444 reply_to_oplock_break_requests(fsp
);
447 * NT can set delete_on_close of the last open
448 * reference to a file.
451 normal_close
= (close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
);
453 if (!normal_close
|| !delete_file
) {
455 if (!del_share_mode(lck
, fsp
)) {
456 DEBUG(0, ("close_remove_share_mode: Could not delete "
457 "share entry for file %s\n",
466 * Ok, we have to delete the file
469 DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
470 "- deleting file.\n", fsp_str_dbg(fsp
)));
473 * Don't try to update the write time when we delete the file
475 fsp
->update_write_time_on_close
= false;
477 got_tokens
= get_delete_on_close_token(lck
, fsp
->name_hash
,
478 &del_nt_token
, &del_token
);
479 SMB_ASSERT(got_tokens
);
481 if (!unix_token_equal(del_token
, get_current_utok(conn
))) {
482 /* Become the user who requested the delete. */
484 DEBUG(5,("close_remove_share_mode: file %s. "
485 "Change user to uid %u\n",
487 (unsigned int)del_token
->uid
));
489 if (!push_sec_ctx()) {
490 smb_panic("close_remove_share_mode: file %s. failed to push "
494 set_sec_ctx(del_token
->uid
,
503 /* We can only delete the file if the name we have is still valid and
504 hasn't been renamed. */
506 tmp_status
= vfs_stat_fsp(fsp
);
507 if (!NT_STATUS_IS_OK(tmp_status
)) {
508 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
509 "was set and stat failed with error %s\n",
510 fsp_str_dbg(fsp
), nt_errstr(tmp_status
)));
512 * Don't save the errno here, we ignore this error
517 id
= vfs_file_id_from_sbuf(conn
, &fsp
->fsp_name
->st
);
519 if (!file_id_equal(&fsp
->file_id
, &id
)) {
520 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
521 "was set and dev and/or inode does not match\n",
523 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
526 file_id_string_tos(&fsp
->file_id
),
527 file_id_string_tos(&id
)));
529 * Don't save the errno here, we ignore this error
534 if ((conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
535 && !is_ntfs_stream_smb_fname(fsp
->fsp_name
)) {
537 status
= delete_all_streams(conn
, fsp
->fsp_name
->base_name
);
539 if (!NT_STATUS_IS_OK(status
)) {
540 DEBUG(5, ("delete_all_streams failed: %s\n",
547 if (SMB_VFS_UNLINK(conn
, fsp
->fsp_name
) != 0) {
549 * This call can potentially fail as another smbd may
550 * have had the file open with delete on close set and
551 * deleted it when its last reference to this file
552 * went away. Hence we log this but not at debug level
556 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
557 "was set and unlink failed with error %s\n",
558 fsp_str_dbg(fsp
), strerror(errno
)));
560 status
= map_nt_error_from_unix(errno
);
563 /* As we now have POSIX opens which can unlink
564 * with other open files we may have taken
565 * this code path with more than one share mode
566 * entry - ensure we only delete once by resetting
567 * the delete on close flag. JRA.
570 fsp
->delete_on_close
= false;
571 set_delete_on_close_lck(fsp
, lck
, false, NULL
, NULL
);
580 if (!del_share_mode(lck
, fsp
)) {
581 DEBUG(0, ("close_remove_share_mode: Could not delete share "
582 "entry for file %s\n", fsp_str_dbg(fsp
)));
589 * Do the notification after we released the share
590 * mode lock. Inside notify_fname we take out another
591 * tdb lock. With ctdb also accessing our databases,
592 * this can lead to deadlocks. Putting this notify
593 * after the TALLOC_FREE(lck) above we avoid locking
594 * two records simultaneously. Notifies are async and
595 * informational only, so calling the notify_fname
596 * without holding the share mode lock should not do
599 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
600 FILE_NOTIFY_CHANGE_FILE_NAME
,
601 fsp
->fsp_name
->base_name
);
607 void set_close_write_time(struct files_struct
*fsp
, struct timespec ts
)
609 DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts
))));
611 if (null_timespec(ts
)) {
614 fsp
->write_time_forced
= false;
615 fsp
->update_write_time_on_close
= true;
616 fsp
->close_write_time
= ts
;
619 static NTSTATUS
update_write_time_on_close(struct files_struct
*fsp
)
621 struct smb_file_time ft
;
623 struct share_mode_lock
*lck
= NULL
;
627 if (!fsp
->update_write_time_on_close
) {
631 if (null_timespec(fsp
->close_write_time
)) {
632 fsp
->close_write_time
= timespec_current();
635 /* Ensure we have a valid stat struct for the source. */
636 status
= vfs_stat_fsp(fsp
);
637 if (!NT_STATUS_IS_OK(status
)) {
641 if (!VALID_STAT(fsp
->fsp_name
->st
)) {
642 /* if it doesn't seem to be a real file */
647 * get_existing_share_mode_lock() isn't really the right
648 * call here, as we're being called after
649 * close_remove_share_mode() inside close_normal_file()
650 * so it's quite normal to not have an existing share
651 * mode here. However, get_share_mode_lock() doesn't
652 * work because that will create a new share mode if
653 * one doesn't exist - so stick with this call (just
654 * ignore any error we get if the share mode doesn't
658 lck
= get_existing_share_mode_lock(talloc_tos(), fsp
->file_id
);
660 /* On close if we're changing the real file time we
661 * must update it in the open file db too. */
662 (void)set_write_time(fsp
->file_id
, fsp
->close_write_time
);
664 /* Close write times overwrite sticky write times
665 so we must replace any sticky write time here. */
666 if (!null_timespec(lck
->data
->changed_write_time
)) {
667 (void)set_sticky_write_time(fsp
->file_id
, fsp
->close_write_time
);
672 ft
.mtime
= fsp
->close_write_time
;
673 /* As this is a close based update, we are not directly changing the
674 file attributes from a client call, but indirectly from a write. */
675 status
= smb_set_file_time(fsp
->conn
, fsp
, fsp
->fsp_name
, &ft
, false);
676 if (!NT_STATUS_IS_OK(status
)) {
677 DEBUG(10,("update_write_time_on_close: smb_set_file_time "
678 "on file %s returned %s\n",
687 static NTSTATUS
ntstatus_keeperror(NTSTATUS s1
, NTSTATUS s2
)
689 if (!NT_STATUS_IS_OK(s1
)) {
695 /****************************************************************************
698 close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
699 printing and magic scripts are only run on normal close.
700 delete on close is done on normal and shutdown close.
701 ****************************************************************************/
703 static NTSTATUS
close_normal_file(struct smb_request
*req
, files_struct
*fsp
,
704 enum file_close_type close_type
)
706 NTSTATUS status
= NT_STATUS_OK
;
708 connection_struct
*conn
= fsp
->conn
;
709 bool is_durable
= false;
711 if (fsp
->num_aio_requests
!= 0) {
713 if (close_type
!= SHUTDOWN_CLOSE
) {
715 * reply_close and the smb2 close must have
716 * taken care of this. No other callers of
717 * close_file should ever have created async
720 * We need to panic here because if we close()
721 * the fd while we have outstanding async I/O
722 * requests, in the worst case we could end up
723 * writing to the wrong file.
725 DEBUG(0, ("fsp->num_aio_requests=%u\n",
726 fsp
->num_aio_requests
));
727 smb_panic("can not close with outstanding aio "
732 * For shutdown close, just drop the async requests
733 * including a potential close request pending for
734 * this fsp. Drop the close request first, the
735 * destructor for the aio_requests would execute it.
737 TALLOC_FREE(fsp
->deferred_close
);
739 while (fsp
->num_aio_requests
!= 0) {
741 * The destructor of the req will remove
742 * itself from the fsp
744 TALLOC_FREE(fsp
->aio_requests
[0]);
749 * If we're flushing on a close we can get a write
750 * error here, we must remember this.
753 tmp
= close_filestruct(fsp
);
754 status
= ntstatus_keeperror(status
, tmp
);
756 if (NT_STATUS_IS_OK(status
) && fsp
->op
!= NULL
) {
757 is_durable
= fsp
->op
->global
->durable
;
760 if (close_type
!= SHUTDOWN_CLOSE
) {
765 DATA_BLOB new_cookie
= data_blob_null
;
767 tmp
= SMB_VFS_DURABLE_DISCONNECT(fsp
,
768 fsp
->op
->global
->backend_cookie
,
771 if (NT_STATUS_IS_OK(tmp
)) {
772 data_blob_free(&fsp
->op
->global
->backend_cookie
);
773 fsp
->op
->global
->backend_cookie
= new_cookie
;
775 tmp
= smbXsrv_open_update(fsp
->op
);
777 if (!NT_STATUS_IS_OK(tmp
)) {
784 * This is the case where we successfully disconnected
785 * a durable handle and closed the underlying file.
786 * In all other cases, we proceed with a genuine close.
792 if (fsp
->op
!= NULL
) {
794 * Make sure the handle is not marked as durable anymore
796 fsp
->op
->global
->durable
= false;
799 if (fsp
->print_file
) {
800 /* FIXME: return spool errors */
801 print_spool_end(fsp
, close_type
);
806 /* Remove the oplock before potentially deleting the file. */
807 if(fsp
->oplock_type
) {
808 release_file_oplock(fsp
);
811 /* If this is an old DOS or FCB open and we have multiple opens on
812 the same handle we only have one share mode. Ensure we only remove
813 the share mode on the last close. */
815 if (fsp
->fh
->ref_count
== 1) {
816 /* Should we return on error here... ? */
817 tmp
= close_remove_share_mode(fsp
, close_type
);
818 status
= ntstatus_keeperror(status
, tmp
);
821 locking_close_file(conn
->sconn
->msg_ctx
, fsp
, close_type
);
824 status
= ntstatus_keeperror(status
, tmp
);
826 /* check for magic scripts */
827 if (close_type
== NORMAL_CLOSE
) {
828 tmp
= check_magic(fsp
);
829 status
= ntstatus_keeperror(status
, tmp
);
833 * Ensure pending modtime is set after close.
836 tmp
= update_write_time_on_close(fsp
);
837 if (NT_STATUS_EQUAL(tmp
, NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
838 /* Someone renamed the file or a parent directory containing
839 * this file. We can't do anything about this, we don't have
840 * an "update timestamp by fd" call in POSIX. Eat the error. */
845 status
= ntstatus_keeperror(status
, tmp
);
847 DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
848 conn
->session_info
->unix_info
->unix_name
, fsp_str_dbg(fsp
),
849 conn
->num_files_open
- 1,
850 nt_errstr(status
) ));
855 /****************************************************************************
856 Function used by reply_rmdir to delete an entire directory
857 tree recursively. Return True on ok, False on fail.
858 ****************************************************************************/
860 bool recursive_rmdir(TALLOC_CTX
*ctx
,
861 connection_struct
*conn
,
862 struct smb_filename
*smb_dname
)
864 const char *dname
= NULL
;
865 char *talloced
= NULL
;
869 struct smb_Dir
*dir_hnd
;
871 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname
));
873 dir_hnd
= OpenDir(talloc_tos(), conn
, smb_dname
->base_name
, NULL
, 0);
877 while((dname
= ReadDirName(dir_hnd
, &offset
, &st
, &talloced
))) {
878 struct smb_filename
*smb_dname_full
= NULL
;
879 char *fullname
= NULL
;
880 bool do_break
= true;
883 if (ISDOT(dname
) || ISDOTDOT(dname
)) {
884 TALLOC_FREE(talloced
);
888 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
, &st
,
890 TALLOC_FREE(talloced
);
894 /* Construct the full name. */
895 fullname
= talloc_asprintf(ctx
,
897 smb_dname
->base_name
,
904 status
= create_synthetic_smb_fname(talloc_tos(), fullname
,
907 if (!NT_STATUS_IS_OK(status
)) {
911 if(SMB_VFS_LSTAT(conn
, smb_dname_full
) != 0) {
915 if(smb_dname_full
->st
.st_ex_mode
& S_IFDIR
) {
916 if(!recursive_rmdir(ctx
, conn
, smb_dname_full
)) {
919 if(SMB_VFS_RMDIR(conn
,
920 smb_dname_full
->base_name
) != 0) {
923 } else if(SMB_VFS_UNLINK(conn
, smb_dname_full
) != 0) {
927 /* Successful iteration. */
931 TALLOC_FREE(smb_dname_full
);
932 TALLOC_FREE(fullname
);
933 TALLOC_FREE(talloced
);
939 TALLOC_FREE(dir_hnd
);
943 /****************************************************************************
944 The internals of the rmdir code - called elsewhere.
945 ****************************************************************************/
947 static NTSTATUS
rmdir_internals(TALLOC_CTX
*ctx
, files_struct
*fsp
)
949 connection_struct
*conn
= fsp
->conn
;
950 struct smb_filename
*smb_dname
= fsp
->fsp_name
;
953 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname
));
955 /* Might be a symlink. */
956 if(SMB_VFS_LSTAT(conn
, smb_dname
) != 0) {
957 return map_nt_error_from_unix(errno
);
960 if (S_ISLNK(smb_dname
->st
.st_ex_mode
)) {
961 /* Is what it points to a directory ? */
962 if(SMB_VFS_STAT(conn
, smb_dname
) != 0) {
963 return map_nt_error_from_unix(errno
);
965 if (!(S_ISDIR(smb_dname
->st
.st_ex_mode
))) {
966 return NT_STATUS_NOT_A_DIRECTORY
;
968 ret
= SMB_VFS_UNLINK(conn
, smb_dname
);
970 ret
= SMB_VFS_RMDIR(conn
, smb_dname
->base_name
);
973 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
974 FILE_NOTIFY_CHANGE_DIR_NAME
,
975 smb_dname
->base_name
);
979 if(((errno
== ENOTEMPTY
)||(errno
== EEXIST
)) && *lp_veto_files(talloc_tos(), SNUM(conn
))) {
981 * Check to see if the only thing in this directory are
982 * vetoed files/directories. If so then delete them and
983 * retry. If we fail to delete any of them (and we *don't*
984 * do a recursive delete) then fail the rmdir.
987 const char *dname
= NULL
;
988 char *talloced
= NULL
;
990 struct smb_Dir
*dir_hnd
= OpenDir(talloc_tos(), conn
,
991 smb_dname
->base_name
, NULL
,
994 if(dir_hnd
== NULL
) {
999 while ((dname
= ReadDirName(dir_hnd
, &dirpos
, &st
,
1000 &talloced
)) != NULL
) {
1001 if((strcmp(dname
, ".") == 0) || (strcmp(dname
, "..")==0)) {
1002 TALLOC_FREE(talloced
);
1005 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
,
1007 TALLOC_FREE(talloced
);
1010 if(!IS_VETO_PATH(conn
, dname
)) {
1011 TALLOC_FREE(dir_hnd
);
1012 TALLOC_FREE(talloced
);
1016 TALLOC_FREE(talloced
);
1019 /* We only have veto files/directories.
1020 * Are we allowed to delete them ? */
1022 if(!lp_recursive_veto_delete(SNUM(conn
))) {
1023 TALLOC_FREE(dir_hnd
);
1028 /* Do a recursive delete. */
1029 RewindDir(dir_hnd
,&dirpos
);
1030 while ((dname
= ReadDirName(dir_hnd
, &dirpos
, &st
,
1031 &talloced
)) != NULL
) {
1032 struct smb_filename
*smb_dname_full
= NULL
;
1033 char *fullname
= NULL
;
1034 bool do_break
= true;
1037 if (ISDOT(dname
) || ISDOTDOT(dname
)) {
1038 TALLOC_FREE(talloced
);
1041 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
,
1043 TALLOC_FREE(talloced
);
1047 fullname
= talloc_asprintf(ctx
,
1049 smb_dname
->base_name
,
1057 status
= create_synthetic_smb_fname(talloc_tos(),
1061 if (!NT_STATUS_IS_OK(status
)) {
1062 errno
= map_errno_from_nt_status(status
);
1066 if(SMB_VFS_LSTAT(conn
, smb_dname_full
) != 0) {
1069 if(smb_dname_full
->st
.st_ex_mode
& S_IFDIR
) {
1070 if(!recursive_rmdir(ctx
, conn
,
1074 if(SMB_VFS_RMDIR(conn
,
1075 smb_dname_full
->base_name
) != 0) {
1078 } else if(SMB_VFS_UNLINK(conn
, smb_dname_full
) != 0) {
1082 /* Successful iteration. */
1086 TALLOC_FREE(fullname
);
1087 TALLOC_FREE(smb_dname_full
);
1088 TALLOC_FREE(talloced
);
1092 TALLOC_FREE(dir_hnd
);
1093 /* Retry the rmdir */
1094 ret
= SMB_VFS_RMDIR(conn
, smb_dname
->base_name
);
1100 DEBUG(3,("rmdir_internals: couldn't remove directory %s : "
1101 "%s\n", smb_fname_str_dbg(smb_dname
),
1103 return map_nt_error_from_unix(errno
);
1106 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
1107 FILE_NOTIFY_CHANGE_DIR_NAME
,
1108 smb_dname
->base_name
);
1110 return NT_STATUS_OK
;
1113 /****************************************************************************
1114 Close a directory opened by an NT SMB call.
1115 ****************************************************************************/
1117 static NTSTATUS
close_directory(struct smb_request
*req
, files_struct
*fsp
,
1118 enum file_close_type close_type
)
1120 struct server_id self
= messaging_server_id(fsp
->conn
->sconn
->msg_ctx
);
1121 struct share_mode_lock
*lck
= NULL
;
1122 bool delete_dir
= False
;
1123 NTSTATUS status
= NT_STATUS_OK
;
1124 NTSTATUS status1
= NT_STATUS_OK
;
1125 const struct security_token
*del_nt_token
= NULL
;
1126 const struct security_unix_token
*del_token
= NULL
;
1129 * NT can set delete_on_close of the last open
1130 * reference to a directory also.
1133 lck
= get_existing_share_mode_lock(talloc_tos(), fsp
->file_id
);
1135 DEBUG(0, ("close_directory: Could not get share mode lock for "
1136 "%s\n", fsp_str_dbg(fsp
)));
1137 return NT_STATUS_INVALID_PARAMETER
;
1140 if (fsp
->initial_delete_on_close
) {
1141 bool became_user
= False
;
1143 /* Initial delete on close was set - for
1144 * directories we don't care if anyone else
1145 * wrote a real delete on close. */
1147 if (get_current_vuid(fsp
->conn
) != fsp
->vuid
) {
1148 become_user(fsp
->conn
, fsp
->vuid
);
1151 send_stat_cache_delete_message(fsp
->conn
->sconn
->msg_ctx
,
1152 fsp
->fsp_name
->base_name
);
1153 set_delete_on_close_lck(fsp
, lck
, true,
1154 get_current_nttok(fsp
->conn
),
1155 get_current_utok(fsp
->conn
));
1156 fsp
->delete_on_close
= true;
1162 delete_dir
= get_delete_on_close_token(lck
, fsp
->name_hash
,
1163 &del_nt_token
, &del_token
);
1167 /* See if others still have the dir open. If this is the
1168 * case, then don't delete. If all opens are POSIX delete now. */
1169 for (i
=0; i
<lck
->data
->num_share_modes
; i
++) {
1170 struct share_mode_entry
*e
= &lck
->data
->share_modes
[i
];
1171 if (is_valid_share_mode_entry(e
) &&
1172 e
->name_hash
== fsp
->name_hash
) {
1173 if (fsp
->posix_open
&& (e
->flags
& SHARE_MODE_FLAG_POSIX_OPEN
)) {
1176 if (serverid_equal(&self
, &e
->pid
) &&
1177 (e
->share_file_id
== fsp
->fh
->gen_id
)) {
1180 if (share_mode_stale_pid(lck
->data
, i
)) {
1189 if ((close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) &&
1192 /* Become the user who requested the delete. */
1194 if (!push_sec_ctx()) {
1195 smb_panic("close_directory: failed to push sec_ctx.\n");
1198 set_sec_ctx(del_token
->uid
,
1204 if (!del_share_mode(lck
, fsp
)) {
1205 DEBUG(0, ("close_directory: Could not delete share entry for "
1206 "%s\n", fsp_str_dbg(fsp
)));
1211 if ((fsp
->conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
1212 && !is_ntfs_stream_smb_fname(fsp
->fsp_name
)) {
1214 status
= delete_all_streams(fsp
->conn
, fsp
->fsp_name
->base_name
);
1215 if (!NT_STATUS_IS_OK(status
)) {
1216 DEBUG(5, ("delete_all_streams failed: %s\n",
1217 nt_errstr(status
)));
1222 status
= rmdir_internals(talloc_tos(), fsp
);
1224 DEBUG(5,("close_directory: %s. Delete on close was set - "
1225 "deleting directory returned %s.\n",
1226 fsp_str_dbg(fsp
), nt_errstr(status
)));
1228 /* unbecome user. */
1232 * Ensure we remove any change notify requests that would
1233 * now fail as the directory has been deleted.
1236 if(NT_STATUS_IS_OK(status
)) {
1237 remove_pending_change_notify_requests_by_fid(fsp
, NT_STATUS_DELETE_PENDING
);
1240 if (!del_share_mode(lck
, fsp
)) {
1241 DEBUG(0, ("close_directory: Could not delete share entry for "
1242 "%s\n", fsp_str_dbg(fsp
)));
1246 remove_pending_change_notify_requests_by_fid(
1250 status1
= fd_close(fsp
);
1252 if (!NT_STATUS_IS_OK(status1
)) {
1253 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
1254 fsp_str_dbg(fsp
), fsp
->fh
->fd
, errno
,
1259 * Do the code common to files and directories.
1261 close_filestruct(fsp
);
1262 file_free(req
, fsp
);
1264 if (NT_STATUS_IS_OK(status
) && !NT_STATUS_IS_OK(status1
)) {
1270 /****************************************************************************
1271 Close a files_struct.
1272 ****************************************************************************/
1274 NTSTATUS
close_file(struct smb_request
*req
, files_struct
*fsp
,
1275 enum file_close_type close_type
)
1278 struct files_struct
*base_fsp
= fsp
->base_fsp
;
1280 if(fsp
->is_directory
) {
1281 status
= close_directory(req
, fsp
, close_type
);
1282 } else if (fsp
->fake_file_handle
!= NULL
) {
1283 status
= close_fake_file(req
, fsp
);
1285 status
= close_normal_file(req
, fsp
, close_type
);
1288 if ((base_fsp
!= NULL
) && (close_type
!= SHUTDOWN_CLOSE
)) {
1291 * fsp was a stream, the base fsp can't be a stream as well
1293 * For SHUTDOWN_CLOSE this is not possible here, because
1294 * SHUTDOWN_CLOSE only happens from files.c which walks the
1295 * complete list of files. If we mess with more than one fsp
1296 * those loops will become confused.
1299 SMB_ASSERT(base_fsp
->base_fsp
== NULL
);
1300 close_file(req
, base_fsp
, close_type
);
1306 /****************************************************************************
1307 Deal with an (authorized) message to close a file given the share mode
1309 ****************************************************************************/
1311 void msg_close_file(struct messaging_context
*msg_ctx
,
1314 struct server_id server_id
,
1317 files_struct
*fsp
= NULL
;
1318 struct share_mode_entry e
;
1319 struct smbd_server_connection
*sconn
=
1320 talloc_get_type_abort(private_data
,
1321 struct smbd_server_connection
);
1323 message_to_share_mode_entry(&e
, (char *)data
->data
);
1326 char *sm_str
= share_mode_str(NULL
, 0, &e
);
1328 smb_panic("talloc failed");
1330 DEBUG(10,("msg_close_file: got request to close share mode "
1331 "entry %s\n", sm_str
));
1332 TALLOC_FREE(sm_str
);
1335 fsp
= file_find_dif(sconn
, e
.id
, e
.share_file_id
);
1337 DEBUG(10,("msg_close_file: failed to find file.\n"));
1340 close_file(NULL
, fsp
, NORMAL_CLOSE
);