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 "smbd/scavenger.h"
28 #include "fake_file.h"
29 #include "transfer_file.h"
32 #include "../librpc/gen_ndr/open_files.h"
34 /****************************************************************************
35 Run a file if it is a magic script.
36 ****************************************************************************/
38 static NTSTATUS
check_magic(struct files_struct
*fsp
)
41 const char *magic_output
= NULL
;
44 TALLOC_CTX
*ctx
= NULL
;
46 struct connection_struct
*conn
= fsp
->conn
;
50 if (!*lp_magicscript(talloc_tos(), SNUM(conn
))) {
54 DEBUG(5,("checking magic for %s\n", fsp_str_dbg(fsp
)));
56 ctx
= talloc_stackframe();
58 fname
= fsp
->fsp_name
->base_name
;
60 if (!(p
= strrchr_m(fname
,'/'))) {
66 if (!strequal(lp_magicscript(talloc_tos(), SNUM(conn
)),p
)) {
67 status
= NT_STATUS_OK
;
71 if (*lp_magicoutput(talloc_tos(), SNUM(conn
))) {
72 magic_output
= lp_magicoutput(talloc_tos(), SNUM(conn
));
74 magic_output
= talloc_asprintf(ctx
,
79 status
= NT_STATUS_NO_MEMORY
;
83 /* Ensure we don't depend on user's PATH. */
84 p
= talloc_asprintf(ctx
, "./%s", fname
);
86 status
= NT_STATUS_NO_MEMORY
;
90 if (chmod(fname
, 0755) == -1) {
91 status
= map_nt_error_from_unix(errno
);
94 ret
= smbrun(p
,&tmp_fd
);
95 DEBUG(3,("Invoking magic command %s gave %d\n",
99 if (ret
!= 0 || tmp_fd
== -1) {
103 status
= NT_STATUS_UNSUCCESSFUL
;
106 outfd
= open(magic_output
, O_CREAT
|O_EXCL
|O_RDWR
, 0600);
110 status
= map_nt_error_from_unix(err
);
114 if (sys_fstat(tmp_fd
, &st
, false) == -1) {
118 status
= map_nt_error_from_unix(err
);
122 if (transfer_file(tmp_fd
,outfd
,(off_t
)st
.st_ex_size
) == (off_t
)-1) {
126 status
= map_nt_error_from_unix(err
);
130 if (close(outfd
) == -1) {
131 status
= map_nt_error_from_unix(errno
);
135 status
= NT_STATUS_OK
;
142 /****************************************************************************
143 Common code to close a file or a directory.
144 ****************************************************************************/
146 static NTSTATUS
close_filestruct(files_struct
*fsp
)
148 NTSTATUS status
= NT_STATUS_OK
;
150 if (fsp
->fh
->fd
!= -1) {
151 if(flush_write_cache(fsp
, CLOSE_FLUSH
) == -1) {
152 status
= map_nt_error_from_unix(errno
);
154 delete_write_cache(fsp
);
160 static int compare_share_mode_times(const void *p1
, const void *p2
)
162 const struct share_mode_entry
*s1
= (const struct share_mode_entry
*)p1
;
163 const struct share_mode_entry
*s2
= (const struct share_mode_entry
*)p2
;
164 return timeval_compare(&s1
->time
, &s2
->time
);
167 /****************************************************************************
169 ****************************************************************************/
171 NTSTATUS
delete_all_streams(connection_struct
*conn
, const char *fname
)
173 struct stream_struct
*stream_info
= NULL
;
175 unsigned int num_streams
= 0;
176 TALLOC_CTX
*frame
= talloc_stackframe();
179 status
= vfs_streaminfo(conn
, NULL
, fname
, talloc_tos(),
180 &num_streams
, &stream_info
);
182 if (NT_STATUS_EQUAL(status
, NT_STATUS_NOT_IMPLEMENTED
)) {
183 DEBUG(10, ("no streams around\n"));
188 if (!NT_STATUS_IS_OK(status
)) {
189 DEBUG(10, ("vfs_streaminfo failed: %s\n",
194 DEBUG(10, ("delete_all_streams found %d streams\n",
197 if (num_streams
== 0) {
202 for (i
=0; i
<num_streams
; i
++) {
204 struct smb_filename
*smb_fname_stream
;
206 if (strequal(stream_info
[i
].name
, "::$DATA")) {
210 smb_fname_stream
= synthetic_smb_fname(
211 talloc_tos(), fname
, stream_info
[i
].name
, NULL
);
213 if (smb_fname_stream
== NULL
) {
214 DEBUG(0, ("talloc_aprintf failed\n"));
215 status
= NT_STATUS_NO_MEMORY
;
219 res
= SMB_VFS_UNLINK(conn
, smb_fname_stream
);
222 status
= map_nt_error_from_unix(errno
);
223 DEBUG(10, ("Could not delete stream %s: %s\n",
224 smb_fname_str_dbg(smb_fname_stream
),
226 TALLOC_FREE(smb_fname_stream
);
229 TALLOC_FREE(smb_fname_stream
);
237 /****************************************************************************
238 Deal with removing a share mode on last close.
239 ****************************************************************************/
241 static NTSTATUS
close_remove_share_mode(files_struct
*fsp
,
242 enum file_close_type close_type
)
244 connection_struct
*conn
= fsp
->conn
;
245 struct server_id self
= messaging_server_id(conn
->sconn
->msg_ctx
);
246 bool delete_file
= false;
247 bool changed_user
= false;
248 struct share_mode_lock
*lck
= NULL
;
249 NTSTATUS status
= NT_STATUS_OK
;
252 const struct security_unix_token
*del_token
= NULL
;
253 const struct security_token
*del_nt_token
= NULL
;
254 bool got_tokens
= false;
257 /* Ensure any pending write time updates are done. */
258 if (fsp
->update_write_time_event
) {
259 update_write_time_handler(fsp
->conn
->sconn
->ev_ctx
,
260 fsp
->update_write_time_event
,
266 * Lock the share entries, and determine if we should delete
267 * on close. If so delete whilst the lock is still in effect.
268 * This prevents race conditions with the file being created. JRA.
271 lck
= get_existing_share_mode_lock(talloc_tos(), fsp
->file_id
);
273 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
274 "lock for file %s\n", fsp_str_dbg(fsp
)));
275 return NT_STATUS_INVALID_PARAMETER
;
278 if (fsp
->write_time_forced
) {
279 DEBUG(10,("close_remove_share_mode: write time forced "
282 set_close_write_time(fsp
, lck
->data
->changed_write_time
);
283 } else if (fsp
->update_write_time_on_close
) {
284 /* Someone had a pending write. */
285 if (null_timespec(fsp
->close_write_time
)) {
286 DEBUG(10,("close_remove_share_mode: update to current time "
289 /* Update to current time due to "normal" write. */
290 set_close_write_time(fsp
, timespec_current());
292 DEBUG(10,("close_remove_share_mode: write time pending "
295 /* Update to time set on close call. */
296 set_close_write_time(fsp
, fsp
->close_write_time
);
300 if (fsp
->initial_delete_on_close
&&
301 !is_delete_on_close_set(lck
, fsp
->name_hash
)) {
302 bool became_user
= False
;
304 /* Initial delete on close was set and no one else
305 * wrote a real delete on close. */
307 if (get_current_vuid(conn
) != fsp
->vuid
) {
308 become_user(conn
, fsp
->vuid
);
311 fsp
->delete_on_close
= true;
312 set_delete_on_close_lck(fsp
, lck
, True
,
313 get_current_nttok(conn
),
314 get_current_utok(conn
));
320 delete_file
= is_delete_on_close_set(lck
, fsp
->name_hash
);
324 /* See if others still have the file open via this pathname.
325 If this is the case, then don't delete. If all opens are
327 for (i
=0; i
<lck
->data
->num_share_modes
; i
++) {
328 struct share_mode_entry
*e
= &lck
->data
->share_modes
[i
];
330 if (!is_valid_share_mode_entry(e
)) {
333 if (e
->name_hash
!= fsp
->name_hash
) {
337 && (e
->flags
& SHARE_MODE_FLAG_POSIX_OPEN
)) {
340 if (serverid_equal(&self
, &e
->pid
) &&
341 (e
->share_file_id
== fsp
->fh
->gen_id
)) {
344 if (share_mode_stale_pid(lck
->data
, i
)) {
353 * NT can set delete_on_close of the last open
354 * reference to a file.
357 normal_close
= (close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
);
359 if (!normal_close
|| !delete_file
) {
361 if (!del_share_mode(lck
, fsp
)) {
362 DEBUG(0, ("close_remove_share_mode: Could not delete "
363 "share entry for file %s\n",
372 * Ok, we have to delete the file
375 DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
376 "- deleting file.\n", fsp_str_dbg(fsp
)));
379 * Don't try to update the write time when we delete the file
381 fsp
->update_write_time_on_close
= false;
383 got_tokens
= get_delete_on_close_token(lck
, fsp
->name_hash
,
384 &del_nt_token
, &del_token
);
385 SMB_ASSERT(got_tokens
);
387 if (!unix_token_equal(del_token
, get_current_utok(conn
))) {
388 /* Become the user who requested the delete. */
390 DEBUG(5,("close_remove_share_mode: file %s. "
391 "Change user to uid %u\n",
393 (unsigned int)del_token
->uid
));
395 if (!push_sec_ctx()) {
396 smb_panic("close_remove_share_mode: file %s. failed to push "
400 set_sec_ctx(del_token
->uid
,
409 /* We can only delete the file if the name we have is still valid and
410 hasn't been renamed. */
412 tmp_status
= vfs_stat_fsp(fsp
);
413 if (!NT_STATUS_IS_OK(tmp_status
)) {
414 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
415 "was set and stat failed with error %s\n",
416 fsp_str_dbg(fsp
), nt_errstr(tmp_status
)));
418 * Don't save the errno here, we ignore this error
423 id
= vfs_file_id_from_sbuf(conn
, &fsp
->fsp_name
->st
);
425 if (!file_id_equal(&fsp
->file_id
, &id
)) {
426 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
427 "was set and dev and/or inode does not match\n",
429 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
432 file_id_string_tos(&fsp
->file_id
),
433 file_id_string_tos(&id
)));
435 * Don't save the errno here, we ignore this error
440 if ((conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
441 && !is_ntfs_stream_smb_fname(fsp
->fsp_name
)) {
443 status
= delete_all_streams(conn
, fsp
->fsp_name
->base_name
);
445 if (!NT_STATUS_IS_OK(status
)) {
446 DEBUG(5, ("delete_all_streams failed: %s\n",
453 if (SMB_VFS_UNLINK(conn
, fsp
->fsp_name
) != 0) {
455 * This call can potentially fail as another smbd may
456 * have had the file open with delete on close set and
457 * deleted it when its last reference to this file
458 * went away. Hence we log this but not at debug level
462 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
463 "was set and unlink failed with error %s\n",
464 fsp_str_dbg(fsp
), strerror(errno
)));
466 status
= map_nt_error_from_unix(errno
);
469 /* As we now have POSIX opens which can unlink
470 * with other open files we may have taken
471 * this code path with more than one share mode
472 * entry - ensure we only delete once by resetting
473 * the delete on close flag. JRA.
476 fsp
->delete_on_close
= false;
477 set_delete_on_close_lck(fsp
, lck
, false, NULL
, NULL
);
486 if (!del_share_mode(lck
, fsp
)) {
487 DEBUG(0, ("close_remove_share_mode: Could not delete share "
488 "entry for file %s\n", fsp_str_dbg(fsp
)));
495 * Do the notification after we released the share
496 * mode lock. Inside notify_fname we take out another
497 * tdb lock. With ctdb also accessing our databases,
498 * this can lead to deadlocks. Putting this notify
499 * after the TALLOC_FREE(lck) above we avoid locking
500 * two records simultaneously. Notifies are async and
501 * informational only, so calling the notify_fname
502 * without holding the share mode lock should not do
505 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
506 FILE_NOTIFY_CHANGE_FILE_NAME
,
507 fsp
->fsp_name
->base_name
);
513 void set_close_write_time(struct files_struct
*fsp
, struct timespec ts
)
515 DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts
))));
517 if (null_timespec(ts
)) {
520 fsp
->write_time_forced
= false;
521 fsp
->update_write_time_on_close
= true;
522 fsp
->close_write_time
= ts
;
525 static NTSTATUS
update_write_time_on_close(struct files_struct
*fsp
)
527 struct smb_file_time ft
;
529 struct share_mode_lock
*lck
= NULL
;
533 if (!fsp
->update_write_time_on_close
) {
537 if (null_timespec(fsp
->close_write_time
)) {
538 fsp
->close_write_time
= timespec_current();
541 /* Ensure we have a valid stat struct for the source. */
542 status
= vfs_stat_fsp(fsp
);
543 if (!NT_STATUS_IS_OK(status
)) {
547 if (!VALID_STAT(fsp
->fsp_name
->st
)) {
548 /* if it doesn't seem to be a real file */
553 * get_existing_share_mode_lock() isn't really the right
554 * call here, as we're being called after
555 * close_remove_share_mode() inside close_normal_file()
556 * so it's quite normal to not have an existing share
557 * mode here. However, get_share_mode_lock() doesn't
558 * work because that will create a new share mode if
559 * one doesn't exist - so stick with this call (just
560 * ignore any error we get if the share mode doesn't
564 lck
= get_existing_share_mode_lock(talloc_tos(), fsp
->file_id
);
566 /* On close if we're changing the real file time we
567 * must update it in the open file db too. */
568 (void)set_write_time(fsp
->file_id
, fsp
->close_write_time
);
570 /* Close write times overwrite sticky write times
571 so we must replace any sticky write time here. */
572 if (!null_timespec(lck
->data
->changed_write_time
)) {
573 (void)set_sticky_write_time(fsp
->file_id
, fsp
->close_write_time
);
578 ft
.mtime
= fsp
->close_write_time
;
579 /* As this is a close based update, we are not directly changing the
580 file attributes from a client call, but indirectly from a write. */
581 status
= smb_set_file_time(fsp
->conn
, fsp
, fsp
->fsp_name
, &ft
, false);
582 if (!NT_STATUS_IS_OK(status
)) {
583 DEBUG(10,("update_write_time_on_close: smb_set_file_time "
584 "on file %s returned %s\n",
593 static NTSTATUS
ntstatus_keeperror(NTSTATUS s1
, NTSTATUS s2
)
595 if (!NT_STATUS_IS_OK(s1
)) {
601 /****************************************************************************
604 close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
605 printing and magic scripts are only run on normal close.
606 delete on close is done on normal and shutdown close.
607 ****************************************************************************/
609 static NTSTATUS
close_normal_file(struct smb_request
*req
, files_struct
*fsp
,
610 enum file_close_type close_type
)
612 NTSTATUS status
= NT_STATUS_OK
;
614 connection_struct
*conn
= fsp
->conn
;
615 bool is_durable
= false;
617 if (fsp
->num_aio_requests
!= 0) {
619 if (close_type
!= SHUTDOWN_CLOSE
) {
621 * reply_close and the smb2 close must have
622 * taken care of this. No other callers of
623 * close_file should ever have created async
626 * We need to panic here because if we close()
627 * the fd while we have outstanding async I/O
628 * requests, in the worst case we could end up
629 * writing to the wrong file.
631 DEBUG(0, ("fsp->num_aio_requests=%u\n",
632 fsp
->num_aio_requests
));
633 smb_panic("can not close with outstanding aio "
638 * For shutdown close, just drop the async requests
639 * including a potential close request pending for
640 * this fsp. Drop the close request first, the
641 * destructor for the aio_requests would execute it.
643 TALLOC_FREE(fsp
->deferred_close
);
645 while (fsp
->num_aio_requests
!= 0) {
647 * The destructor of the req will remove
648 * itself from the fsp
650 TALLOC_FREE(fsp
->aio_requests
[0]);
655 * If we're flushing on a close we can get a write
656 * error here, we must remember this.
659 tmp
= close_filestruct(fsp
);
660 status
= ntstatus_keeperror(status
, tmp
);
662 if (NT_STATUS_IS_OK(status
) && fsp
->op
!= NULL
) {
663 is_durable
= fsp
->op
->global
->durable
;
666 if (close_type
!= SHUTDOWN_CLOSE
) {
671 DATA_BLOB new_cookie
= data_blob_null
;
673 tmp
= SMB_VFS_DURABLE_DISCONNECT(fsp
,
674 fsp
->op
->global
->backend_cookie
,
677 if (NT_STATUS_IS_OK(tmp
)) {
682 tv
= req
->request_time
;
684 tv
= timeval_current();
686 now
= timeval_to_nttime(&tv
);
688 data_blob_free(&fsp
->op
->global
->backend_cookie
);
689 fsp
->op
->global
->backend_cookie
= new_cookie
;
691 fsp
->op
->compat
= NULL
;
692 tmp
= smbXsrv_open_close(fsp
->op
, now
);
693 if (!NT_STATUS_IS_OK(tmp
)) {
694 DEBUG(1, ("Failed to update smbXsrv_open "
695 "record when disconnecting durable "
696 "handle for file %s: %s - "
697 "proceeding with normal close\n",
698 fsp_str_dbg(fsp
), nt_errstr(tmp
)));
700 scavenger_schedule_disconnected(fsp
);
702 DEBUG(1, ("Failed to disconnect durable handle for "
703 "file %s: %s - proceeding with normal "
704 "close\n", fsp_str_dbg(fsp
), nt_errstr(tmp
)));
706 if (!NT_STATUS_IS_OK(tmp
)) {
713 * This is the case where we successfully disconnected
714 * a durable handle and closed the underlying file.
715 * In all other cases, we proceed with a genuine close.
717 DEBUG(10, ("%s disconnected durable handle for file %s\n",
718 conn
->session_info
->unix_info
->unix_name
,
724 if (fsp
->op
!= NULL
) {
726 * Make sure the handle is not marked as durable anymore
728 fsp
->op
->global
->durable
= false;
731 if (fsp
->print_file
) {
732 /* FIXME: return spool errors */
733 print_spool_end(fsp
, close_type
);
738 /* Remove the oplock before potentially deleting the file. */
739 if(fsp
->oplock_type
) {
740 release_file_oplock(fsp
);
743 /* If this is an old DOS or FCB open and we have multiple opens on
744 the same handle we only have one share mode. Ensure we only remove
745 the share mode on the last close. */
747 if (fsp
->fh
->ref_count
== 1) {
748 /* Should we return on error here... ? */
749 tmp
= close_remove_share_mode(fsp
, close_type
);
750 status
= ntstatus_keeperror(status
, tmp
);
753 locking_close_file(conn
->sconn
->msg_ctx
, fsp
, close_type
);
756 status
= ntstatus_keeperror(status
, tmp
);
758 /* check for magic scripts */
759 if (close_type
== NORMAL_CLOSE
) {
760 tmp
= check_magic(fsp
);
761 status
= ntstatus_keeperror(status
, tmp
);
765 * Ensure pending modtime is set after close.
768 tmp
= update_write_time_on_close(fsp
);
769 if (NT_STATUS_EQUAL(tmp
, NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
770 /* Someone renamed the file or a parent directory containing
771 * this file. We can't do anything about this, we don't have
772 * an "update timestamp by fd" call in POSIX. Eat the error. */
777 status
= ntstatus_keeperror(status
, tmp
);
779 DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
780 conn
->session_info
->unix_info
->unix_name
, fsp_str_dbg(fsp
),
781 conn
->num_files_open
- 1,
782 nt_errstr(status
) ));
787 /****************************************************************************
788 Function used by reply_rmdir to delete an entire directory
789 tree recursively. Return True on ok, False on fail.
790 ****************************************************************************/
792 bool recursive_rmdir(TALLOC_CTX
*ctx
,
793 connection_struct
*conn
,
794 struct smb_filename
*smb_dname
)
796 const char *dname
= NULL
;
797 char *talloced
= NULL
;
801 struct smb_Dir
*dir_hnd
;
803 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname
));
805 dir_hnd
= OpenDir(talloc_tos(), conn
, smb_dname
->base_name
, NULL
, 0);
809 while((dname
= ReadDirName(dir_hnd
, &offset
, &st
, &talloced
))) {
810 struct smb_filename
*smb_dname_full
= NULL
;
811 char *fullname
= NULL
;
812 bool do_break
= true;
814 if (ISDOT(dname
) || ISDOTDOT(dname
)) {
815 TALLOC_FREE(talloced
);
819 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
, &st
,
821 TALLOC_FREE(talloced
);
825 /* Construct the full name. */
826 fullname
= talloc_asprintf(ctx
,
828 smb_dname
->base_name
,
835 smb_dname_full
= synthetic_smb_fname(talloc_tos(), fullname
,
837 if (smb_dname_full
== NULL
) {
842 if(SMB_VFS_LSTAT(conn
, smb_dname_full
) != 0) {
846 if(smb_dname_full
->st
.st_ex_mode
& S_IFDIR
) {
847 if(!recursive_rmdir(ctx
, conn
, smb_dname_full
)) {
850 if(SMB_VFS_RMDIR(conn
,
851 smb_dname_full
->base_name
) != 0) {
854 } else if(SMB_VFS_UNLINK(conn
, smb_dname_full
) != 0) {
858 /* Successful iteration. */
862 TALLOC_FREE(smb_dname_full
);
863 TALLOC_FREE(fullname
);
864 TALLOC_FREE(talloced
);
870 TALLOC_FREE(dir_hnd
);
874 /****************************************************************************
875 The internals of the rmdir code - called elsewhere.
876 ****************************************************************************/
878 static NTSTATUS
rmdir_internals(TALLOC_CTX
*ctx
, files_struct
*fsp
)
880 connection_struct
*conn
= fsp
->conn
;
881 struct smb_filename
*smb_dname
= fsp
->fsp_name
;
884 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname
));
886 /* Might be a symlink. */
887 if(SMB_VFS_LSTAT(conn
, smb_dname
) != 0) {
888 return map_nt_error_from_unix(errno
);
891 if (S_ISLNK(smb_dname
->st
.st_ex_mode
)) {
892 /* Is what it points to a directory ? */
893 if(SMB_VFS_STAT(conn
, smb_dname
) != 0) {
894 return map_nt_error_from_unix(errno
);
896 if (!(S_ISDIR(smb_dname
->st
.st_ex_mode
))) {
897 return NT_STATUS_NOT_A_DIRECTORY
;
899 ret
= SMB_VFS_UNLINK(conn
, smb_dname
);
901 ret
= SMB_VFS_RMDIR(conn
, smb_dname
->base_name
);
904 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
905 FILE_NOTIFY_CHANGE_DIR_NAME
,
906 smb_dname
->base_name
);
910 if(((errno
== ENOTEMPTY
)||(errno
== EEXIST
)) && *lp_veto_files(talloc_tos(), SNUM(conn
))) {
912 * Check to see if the only thing in this directory are
913 * vetoed files/directories. If so then delete them and
914 * retry. If we fail to delete any of them (and we *don't*
915 * do a recursive delete) then fail the rmdir.
918 const char *dname
= NULL
;
919 char *talloced
= NULL
;
921 struct smb_Dir
*dir_hnd
= OpenDir(talloc_tos(), conn
,
922 smb_dname
->base_name
, NULL
,
925 if(dir_hnd
== NULL
) {
930 while ((dname
= ReadDirName(dir_hnd
, &dirpos
, &st
,
931 &talloced
)) != NULL
) {
932 if((strcmp(dname
, ".") == 0) || (strcmp(dname
, "..")==0)) {
933 TALLOC_FREE(talloced
);
936 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
,
938 TALLOC_FREE(talloced
);
941 if(!IS_VETO_PATH(conn
, dname
)) {
942 TALLOC_FREE(dir_hnd
);
943 TALLOC_FREE(talloced
);
947 TALLOC_FREE(talloced
);
950 /* We only have veto files/directories.
951 * Are we allowed to delete them ? */
953 if(!lp_recursive_veto_delete(SNUM(conn
))) {
954 TALLOC_FREE(dir_hnd
);
959 /* Do a recursive delete. */
960 RewindDir(dir_hnd
,&dirpos
);
961 while ((dname
= ReadDirName(dir_hnd
, &dirpos
, &st
,
962 &talloced
)) != NULL
) {
963 struct smb_filename
*smb_dname_full
= NULL
;
964 char *fullname
= NULL
;
965 bool do_break
= true;
967 if (ISDOT(dname
) || ISDOTDOT(dname
)) {
968 TALLOC_FREE(talloced
);
971 if (!is_visible_file(conn
, smb_dname
->base_name
, dname
,
973 TALLOC_FREE(talloced
);
977 fullname
= talloc_asprintf(ctx
,
979 smb_dname
->base_name
,
987 smb_dname_full
= synthetic_smb_fname(
988 talloc_tos(), fullname
, NULL
, NULL
);
989 if (smb_dname_full
== NULL
) {
994 if(SMB_VFS_LSTAT(conn
, smb_dname_full
) != 0) {
997 if(smb_dname_full
->st
.st_ex_mode
& S_IFDIR
) {
998 if(!recursive_rmdir(ctx
, conn
,
1002 if(SMB_VFS_RMDIR(conn
,
1003 smb_dname_full
->base_name
) != 0) {
1006 } else if(SMB_VFS_UNLINK(conn
, smb_dname_full
) != 0) {
1010 /* Successful iteration. */
1014 TALLOC_FREE(fullname
);
1015 TALLOC_FREE(smb_dname_full
);
1016 TALLOC_FREE(talloced
);
1020 TALLOC_FREE(dir_hnd
);
1021 /* Retry the rmdir */
1022 ret
= SMB_VFS_RMDIR(conn
, smb_dname
->base_name
);
1028 DEBUG(3,("rmdir_internals: couldn't remove directory %s : "
1029 "%s\n", smb_fname_str_dbg(smb_dname
),
1031 return map_nt_error_from_unix(errno
);
1034 notify_fname(conn
, NOTIFY_ACTION_REMOVED
,
1035 FILE_NOTIFY_CHANGE_DIR_NAME
,
1036 smb_dname
->base_name
);
1038 return NT_STATUS_OK
;
1041 /****************************************************************************
1042 Close a directory opened by an NT SMB call.
1043 ****************************************************************************/
1045 static NTSTATUS
close_directory(struct smb_request
*req
, files_struct
*fsp
,
1046 enum file_close_type close_type
)
1048 struct server_id self
= messaging_server_id(fsp
->conn
->sconn
->msg_ctx
);
1049 struct share_mode_lock
*lck
= NULL
;
1050 bool delete_dir
= False
;
1051 NTSTATUS status
= NT_STATUS_OK
;
1052 NTSTATUS status1
= NT_STATUS_OK
;
1053 const struct security_token
*del_nt_token
= NULL
;
1054 const struct security_unix_token
*del_token
= NULL
;
1057 * NT can set delete_on_close of the last open
1058 * reference to a directory also.
1061 lck
= get_existing_share_mode_lock(talloc_tos(), fsp
->file_id
);
1063 DEBUG(0, ("close_directory: Could not get share mode lock for "
1064 "%s\n", fsp_str_dbg(fsp
)));
1065 return NT_STATUS_INVALID_PARAMETER
;
1068 if (fsp
->initial_delete_on_close
) {
1069 bool became_user
= False
;
1071 /* Initial delete on close was set - for
1072 * directories we don't care if anyone else
1073 * wrote a real delete on close. */
1075 if (get_current_vuid(fsp
->conn
) != fsp
->vuid
) {
1076 become_user(fsp
->conn
, fsp
->vuid
);
1079 send_stat_cache_delete_message(fsp
->conn
->sconn
->msg_ctx
,
1080 fsp
->fsp_name
->base_name
);
1081 set_delete_on_close_lck(fsp
, lck
, true,
1082 get_current_nttok(fsp
->conn
),
1083 get_current_utok(fsp
->conn
));
1084 fsp
->delete_on_close
= true;
1090 delete_dir
= get_delete_on_close_token(lck
, fsp
->name_hash
,
1091 &del_nt_token
, &del_token
);
1095 /* See if others still have the dir open. If this is the
1096 * case, then don't delete. If all opens are POSIX delete now. */
1097 for (i
=0; i
<lck
->data
->num_share_modes
; i
++) {
1098 struct share_mode_entry
*e
= &lck
->data
->share_modes
[i
];
1099 if (is_valid_share_mode_entry(e
) &&
1100 e
->name_hash
== fsp
->name_hash
) {
1101 if (fsp
->posix_open
&& (e
->flags
& SHARE_MODE_FLAG_POSIX_OPEN
)) {
1104 if (serverid_equal(&self
, &e
->pid
) &&
1105 (e
->share_file_id
== fsp
->fh
->gen_id
)) {
1108 if (share_mode_stale_pid(lck
->data
, i
)) {
1117 if ((close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) &&
1120 /* Become the user who requested the delete. */
1122 if (!push_sec_ctx()) {
1123 smb_panic("close_directory: failed to push sec_ctx.\n");
1126 set_sec_ctx(del_token
->uid
,
1132 if (!del_share_mode(lck
, fsp
)) {
1133 DEBUG(0, ("close_directory: Could not delete share entry for "
1134 "%s\n", fsp_str_dbg(fsp
)));
1139 if ((fsp
->conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
1140 && !is_ntfs_stream_smb_fname(fsp
->fsp_name
)) {
1142 status
= delete_all_streams(fsp
->conn
, fsp
->fsp_name
->base_name
);
1143 if (!NT_STATUS_IS_OK(status
)) {
1144 DEBUG(5, ("delete_all_streams failed: %s\n",
1145 nt_errstr(status
)));
1150 status
= rmdir_internals(talloc_tos(), fsp
);
1152 DEBUG(5,("close_directory: %s. Delete on close was set - "
1153 "deleting directory returned %s.\n",
1154 fsp_str_dbg(fsp
), nt_errstr(status
)));
1156 /* unbecome user. */
1160 * Ensure we remove any change notify requests that would
1161 * now fail as the directory has been deleted.
1164 if(NT_STATUS_IS_OK(status
)) {
1165 remove_pending_change_notify_requests_by_fid(fsp
, NT_STATUS_DELETE_PENDING
);
1168 if (!del_share_mode(lck
, fsp
)) {
1169 DEBUG(0, ("close_directory: Could not delete share entry for "
1170 "%s\n", fsp_str_dbg(fsp
)));
1174 remove_pending_change_notify_requests_by_fid(
1178 status1
= fd_close(fsp
);
1180 if (!NT_STATUS_IS_OK(status1
)) {
1181 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
1182 fsp_str_dbg(fsp
), fsp
->fh
->fd
, errno
,
1187 * Do the code common to files and directories.
1189 close_filestruct(fsp
);
1190 file_free(req
, fsp
);
1192 if (NT_STATUS_IS_OK(status
) && !NT_STATUS_IS_OK(status1
)) {
1198 /****************************************************************************
1199 Close a files_struct.
1200 ****************************************************************************/
1202 NTSTATUS
close_file(struct smb_request
*req
, files_struct
*fsp
,
1203 enum file_close_type close_type
)
1206 struct files_struct
*base_fsp
= fsp
->base_fsp
;
1208 if(fsp
->is_directory
) {
1209 status
= close_directory(req
, fsp
, close_type
);
1210 } else if (fsp
->fake_file_handle
!= NULL
) {
1211 status
= close_fake_file(req
, fsp
);
1213 status
= close_normal_file(req
, fsp
, close_type
);
1216 if ((base_fsp
!= NULL
) && (close_type
!= SHUTDOWN_CLOSE
)) {
1219 * fsp was a stream, the base fsp can't be a stream as well
1221 * For SHUTDOWN_CLOSE this is not possible here, because
1222 * SHUTDOWN_CLOSE only happens from files.c which walks the
1223 * complete list of files. If we mess with more than one fsp
1224 * those loops will become confused.
1227 SMB_ASSERT(base_fsp
->base_fsp
== NULL
);
1228 close_file(req
, base_fsp
, close_type
);
1234 /****************************************************************************
1235 Deal with an (authorized) message to close a file given the share mode
1237 ****************************************************************************/
1239 void msg_close_file(struct messaging_context
*msg_ctx
,
1242 struct server_id server_id
,
1245 files_struct
*fsp
= NULL
;
1246 struct share_mode_entry e
;
1247 struct smbd_server_connection
*sconn
=
1248 talloc_get_type_abort(private_data
,
1249 struct smbd_server_connection
);
1251 message_to_share_mode_entry(&e
, (char *)data
->data
);
1254 char *sm_str
= share_mode_str(NULL
, 0, &e
);
1256 smb_panic("talloc failed");
1258 DEBUG(10,("msg_close_file: got request to close share mode "
1259 "entry %s\n", sm_str
));
1260 TALLOC_FREE(sm_str
);
1263 fsp
= file_find_dif(sconn
, e
.id
, e
.share_file_id
);
1265 DEBUG(10,("msg_close_file: failed to find file.\n"));
1268 close_file(NULL
, fsp
, NORMAL_CLOSE
);