X-Git-Url: http://git.samba.org/samba.git/?a=blobdiff_plain;f=source3%2Fsmbd%2Fclose.c;h=d4c531ab1955cbca0fe3e5c48d5951f7ae07ba46;hb=c530009401f111bc62008a2a75cdad5b9d5ee7d1;hp=0700aeaa0a6b4eaf0335f1154bac71441bbac909;hpb=04bf12b176d5abe06b7f1401810369bcafe0b611;p=sfrench%2Fsamba-autobuild%2F.git diff --git a/source3/smbd/close.c b/source3/smbd/close.c index 0700aeaa0a6..d4c531ab195 100644 --- a/source3/smbd/close.c +++ b/source3/smbd/close.c @@ -1,311 +1,775 @@ -/* +/* Unix SMB/CIFS implementation. file closing Copyright (C) Andrew Tridgell 1992-1998 - + Copyright (C) Jeremy Allison 1992-2007. + Copyright (C) Volker Lendecke 2005 + This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. - + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - + You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with this program. If not, see . */ #include "includes.h" +extern struct current_user current_user; + /**************************************************************************** Run a file if it is a magic script. ****************************************************************************/ -static void check_magic(files_struct *fsp,connection_struct *conn) +static void check_magic(struct files_struct *fsp) { - if (!*lp_magicscript(SNUM(conn))) + int ret; + const char *magic_output = NULL; + SMB_STRUCT_STAT st; + int tmp_fd, outfd; + TALLOC_CTX *ctx = NULL; + const char *p; + struct connection_struct *conn = fsp->conn; + + if (!*lp_magicscript(SNUM(conn))) { return; + } DEBUG(5,("checking magic for %s\n",fsp->fsp_name)); - { - char *p; - if (!(p = strrchr_m(fsp->fsp_name,'/'))) - p = fsp->fsp_name; - else - p++; - - if (!strequal(lp_magicscript(SNUM(conn)),p)) - return; - } - - { - int ret; - pstring magic_output; - pstring fname; - SMB_STRUCT_STAT st; - int tmp_fd, outfd; - - pstrcpy(fname,fsp->fsp_name); - if (*lp_magicoutput(SNUM(conn))) - pstrcpy(magic_output,lp_magicoutput(SNUM(conn))); - else - slprintf(magic_output,sizeof(fname)-1, "%s.out",fname); - - chmod(fname,0755); - ret = smbrun(fname,&tmp_fd); - DEBUG(3,("Invoking magic command %s gave %d\n",fname,ret)); - unlink(fname); - if (ret != 0 || tmp_fd == -1) { - if (tmp_fd != -1) - close(tmp_fd); - return; - } - outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600); - if (outfd == -1) { - close(tmp_fd); - return; - } + if (!(p = strrchr_m(fsp->fsp_name,'/'))) { + p = fsp->fsp_name; + } else { + p++; + } + + if (!strequal(lp_magicscript(SNUM(conn)),p)) { + return; + } + + ctx = talloc_stackframe(); + + if (*lp_magicoutput(SNUM(conn))) { + magic_output = lp_magicoutput(SNUM(conn)); + } else { + magic_output = talloc_asprintf(ctx, + "%s.out", + fsp->fsp_name); + } + if (!magic_output) { + TALLOC_FREE(ctx); + return; + } + + chmod(fsp->fsp_name,0755); + ret = smbrun(fsp->fsp_name,&tmp_fd); + DEBUG(3,("Invoking magic command %s gave %d\n", + fsp->fsp_name,ret)); - if (sys_fstat(tmp_fd,&st) == -1) { + unlink(fsp->fsp_name); + if (ret != 0 || tmp_fd == -1) { + if (tmp_fd != -1) { close(tmp_fd); - close(outfd); - return; } + TALLOC_FREE(ctx); + return; + } + outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600); + if (outfd == -1) { + close(tmp_fd); + TALLOC_FREE(ctx); + return; + } - transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_size); + if (sys_fstat(tmp_fd,&st) == -1) { close(tmp_fd); close(outfd); + return; } + + transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_size); + close(tmp_fd); + close(outfd); + TALLOC_FREE(ctx); } /**************************************************************************** Common code to close a file or a directory. ****************************************************************************/ -static int close_filestruct(files_struct *fsp) -{ +static NTSTATUS close_filestruct(files_struct *fsp) +{ + NTSTATUS status = NT_STATUS_OK; connection_struct *conn = fsp->conn; - int ret = 0; - if (fsp->fd != -1) { - if(flush_write_cache(fsp, CLOSE_FLUSH) == -1) - ret = -1; - + if (fsp->fh->fd != -1) { + if(flush_write_cache(fsp, CLOSE_FLUSH) == -1) { + status = map_nt_error_from_unix(errno); + } delete_write_cache(fsp); } conn->num_files_open--; - SAFE_FREE(fsp->wbmpx_ptr); - - return ret; + return status; } /**************************************************************************** - Close a file. + If any deferred opens are waiting on this close, notify them. +****************************************************************************/ - If normal_close is 1 then this came from a normal SMBclose (or equivalent) - operation otherwise it came as the result of some other operation such as - the closing of the connection. In the latter case printing and - magic scripts are not run. +static void notify_deferred_opens(struct share_mode_lock *lck) +{ + int i; + + for (i=0; inum_share_modes; i++) { + struct share_mode_entry *e = &lck->share_modes[i]; + + if (!is_deferred_open_entry(e)) { + continue; + } + + if (procid_is_me(&e->pid)) { + /* + * We need to notify ourself to retry the open. Do + * this by finding the queued SMB record, moving it to + * the head of the queue and changing the wait time to + * zero. + */ + schedule_deferred_open_smb_message(e->op_mid); + } else { + char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE]; + + share_mode_entry_to_message(msg, e); + + messaging_send_buf(smbd_messaging_context(), + e->pid, MSG_SMB_OPEN_RETRY, + (uint8 *)msg, + MSG_SMB_SHARE_MODE_ENTRY_SIZE); + } + } +} + +/**************************************************************************** + Delete all streams ****************************************************************************/ -static int close_normal_file(files_struct *fsp, BOOL normal_close) +static NTSTATUS delete_all_streams(connection_struct *conn, const char *fname) { - share_mode_entry *share_entry = NULL; - size_t share_entry_count = 0; - BOOL delete_on_close = False; - connection_struct *conn = fsp->conn; - int err = 0; - int err1 = 0; + struct stream_struct *stream_info; + int i; + unsigned int num_streams; + TALLOC_CTX *frame = talloc_stackframe(); + NTSTATUS status; + + status = SMB_VFS_STREAMINFO(conn, NULL, fname, talloc_tos(), + &num_streams, &stream_info); + + if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) { + DEBUG(10, ("no streams around\n")); + TALLOC_FREE(frame); + return NT_STATUS_OK; + } - remove_pending_lock_requests_by_fid(fsp); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(10, ("SMB_VFS_STREAMINFO failed: %s\n", + nt_errstr(status))); + goto fail; + } - /* - * If we're flushing on a close we can get a write - * error here, we must remember this. - */ + DEBUG(10, ("delete_all_streams found %d streams\n", + num_streams)); - if (close_filestruct(fsp) == -1) - err1 = -1; + if (num_streams == 0) { + TALLOC_FREE(frame); + return NT_STATUS_OK; + } - if (fsp->print_file) { - print_fsp_end(fsp, normal_close); - file_free(fsp); - return 0; + for (i=0; iconn; + bool delete_file = false; + bool changed_user = false; + struct share_mode_lock *lck; + SMB_STRUCT_STAT sbuf; + NTSTATUS status = NT_STATUS_OK; + int ret; + struct file_id id; + /* * Lock the share entries, and determine if we should delete * on close. If so delete whilst the lock is still in effect. * This prevents race conditions with the file being created. JRA. */ - lock_share_entry_fsp(fsp); + lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL, + NULL); + + if (lck == NULL) { + DEBUG(0, ("close_remove_share_mode: Could not get share mode " + "lock for file %s\n", fsp->fsp_name)); + return NT_STATUS_INVALID_PARAMETER; + } + + if (fsp->write_time_forced) { + set_close_write_time(fsp, lck->changed_write_time); + } + + if (!del_share_mode(lck, fsp)) { + DEBUG(0, ("close_remove_share_mode: Could not delete share " + "entry for file %s\n", fsp->fsp_name)); + } + + if (fsp->initial_delete_on_close && (lck->delete_token == NULL)) { + bool became_user = False; + + /* Initial delete on close was set and no one else + * wrote a real delete on close. */ + + if (current_user.vuid != fsp->vuid) { + become_user(conn, fsp->vuid); + became_user = True; + } + set_delete_on_close_lck(lck, True, ¤t_user.ut); + if (became_user) { + unbecome_user(); + } + } + + delete_file = lck->delete_on_close; + + if (delete_file) { + int i; + /* See if others still have the file open. If this is the + * case, then don't delete. If all opens are POSIX delete now. */ + for (i=0; inum_share_modes; i++) { + struct share_mode_entry *e = &lck->share_modes[i]; + if (is_valid_share_mode_entry(e)) { + if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) { + continue; + } + delete_file = False; + break; + } + } + } + + /* Notify any deferred opens waiting on this close. */ + notify_deferred_opens(lck); + reply_to_oplock_break_requests(fsp); + + /* + * NT can set delete_on_close of the last open + * reference to a file. + */ + + if (!(close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) + || !delete_file + || (lck->delete_token == NULL)) { + TALLOC_FREE(lck); + return NT_STATUS_OK; + } + + /* + * Ok, we have to delete the file + */ + + DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set " + "- deleting file.\n", fsp->fsp_name)); + + /* + * Don't try to update the write time when we delete the file + */ + fsp->update_write_time_on_close = false; + + if (!unix_token_equal(lck->delete_token, ¤t_user.ut)) { + /* Become the user who requested the delete. */ - if (fsp->delete_on_close) { + DEBUG(5,("close_remove_share_mode: file %s. " + "Change user to uid %u\n", + fsp->fsp_name, + (unsigned int)lck->delete_token->uid)); + if (!push_sec_ctx()) { + smb_panic("close_remove_share_mode: file %s. failed to push " + "sec_ctx.\n"); + } + + set_sec_ctx(lck->delete_token->uid, + lck->delete_token->gid, + lck->delete_token->ngroups, + lck->delete_token->groups, + NULL); + + changed_user = true; + } + + /* We can only delete the file if the name we have is still valid and + hasn't been renamed. */ + + if (fsp->posix_open) { + ret = SMB_VFS_LSTAT(conn,fsp->fsp_name,&sbuf); + } else { + ret = SMB_VFS_STAT(conn,fsp->fsp_name,&sbuf); + } + + if (ret != 0) { + DEBUG(5,("close_remove_share_mode: file %s. Delete on close " + "was set and stat failed with error %s\n", + fsp->fsp_name, strerror(errno) )); /* - * Modify the share mode entry for all files open - * on this device and inode to tell other smbds we have - * changed the delete on close flag. The last closer will delete the file - * if flag is set. + * Don't save the errno here, we ignore this error */ + goto done; + } - NTSTATUS status =set_delete_on_close_over_all(fsp, fsp->delete_on_close); - if (NT_STATUS_V(status) != NT_STATUS_V(NT_STATUS_OK)) - DEBUG(0,("close_normal_file: failed to change delete on close flag for file %s\n", - fsp->fsp_name )); + id = vfs_file_id_from_sbuf(conn, &sbuf); + + if (!file_id_equal(&fsp->file_id, &id)) { + DEBUG(5,("close_remove_share_mode: file %s. Delete on close " + "was set and dev and/or inode does not match\n", + fsp->fsp_name )); + DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, " + "stat file_id %s\n", + fsp->fsp_name, + file_id_string_tos(&fsp->file_id), + file_id_string_tos(&id))); + /* + * Don't save the errno here, we ignore this error + */ + goto done; } - share_entry_count = del_share_mode(fsp, &share_entry); + if ((conn->fs_capabilities & FILE_NAMED_STREAMS) + && !is_ntfs_stream_name(fsp->fsp_name)) { - DEBUG(10,("close_normal_file: share_entry_count = %lu for file %s\n", - (unsigned long)share_entry_count, fsp->fsp_name )); + status = delete_all_streams(conn, fsp->fsp_name); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(5, ("delete_all_streams failed: %s\n", + nt_errstr(status))); + goto done; + } + } + + + if (SMB_VFS_UNLINK(conn,fsp->fsp_name) != 0) { + /* + * This call can potentially fail as another smbd may + * have had the file open with delete on close set and + * deleted it when its last reference to this file + * went away. Hence we log this but not at debug level + * zero. + */ + + DEBUG(5,("close_remove_share_mode: file %s. Delete on close " + "was set and unlink failed with error %s\n", + fsp->fsp_name, strerror(errno) )); + + status = map_nt_error_from_unix(errno); + } + + notify_fname(conn, NOTIFY_ACTION_REMOVED, + FILE_NOTIFY_CHANGE_FILE_NAME, + fsp->fsp_name); + + /* As we now have POSIX opens which can unlink + * with other open files we may have taken + * this code path with more than one share mode + * entry - ensure we only delete once by resetting + * the delete on close flag. JRA. + */ + + set_delete_on_close_lck(lck, False, NULL); + + done: + + if (changed_user) { + /* unbecome user. */ + pop_sec_ctx(); + } + + TALLOC_FREE(lck); + return status; +} + +void set_close_write_time(struct files_struct *fsp, struct timespec ts) +{ + DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts)))); + + if (null_timespec(ts)) { + return; + } /* - * We delete on close if it's the last open, and the - * delete on close flag was set in the entry we just deleted. + * if the write time on close is explict set, then don't + * need to fix it up to the value in the locking db */ + fsp->write_time_forced = false; + + fsp->update_write_time_on_close = true; + fsp->close_write_time = ts; +} + +static NTSTATUS update_write_time_on_close(struct files_struct *fsp) +{ + SMB_STRUCT_STAT sbuf; + struct timespec ts[2]; + NTSTATUS status; + + ZERO_STRUCT(sbuf); + ZERO_STRUCT(ts); + + if (!fsp->update_write_time_on_close) { + return NT_STATUS_OK; + } + + if (null_timespec(fsp->close_write_time)) { + fsp->close_write_time = timespec_current(); + } + + /* Ensure we have a valid stat struct for the source. */ + if (fsp->fh->fd != -1) { + if (SMB_VFS_FSTAT(fsp, &sbuf) == -1) { + return map_nt_error_from_unix(errno); + } + } else { + if (SMB_VFS_STAT(fsp->conn,fsp->fsp_name,&sbuf) == -1) { + return map_nt_error_from_unix(errno); + } + } + + if (!VALID_STAT(sbuf)) { + /* if it doesn't seem to be a real file */ + return NT_STATUS_OK; + } + + ts[1] = fsp->close_write_time; + status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, + &sbuf, ts, true); + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + return NT_STATUS_OK; +} - if ((share_entry_count == 0) && share_entry && - GET_DELETE_ON_CLOSE_FLAG(share_entry->share_mode) ) - delete_on_close = True; +/**************************************************************************** + Close a file. - SAFE_FREE(share_entry); + close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE. + printing and magic scripts are only run on normal close. + delete on close is done on normal and shutdown close. +****************************************************************************/ + +static NTSTATUS close_normal_file(struct smb_request *req, files_struct *fsp, + enum file_close_type close_type) +{ + NTSTATUS status = NT_STATUS_OK; + NTSTATUS saved_status1 = NT_STATUS_OK; + NTSTATUS saved_status2 = NT_STATUS_OK; + NTSTATUS saved_status3 = NT_STATUS_OK; + NTSTATUS saved_status4 = NT_STATUS_OK; + connection_struct *conn = fsp->conn; + if (fsp->aio_write_behind) { + /* + * If we're finishing write behind on a close we can get a write + * error here, we must remember this. + */ + int ret = wait_for_aio_completion(fsp); + if (ret) { + saved_status1 = map_nt_error_from_unix(ret); + } + } else { + cancel_aio_by_fsp(fsp); + } + /* - * NT can set delete_on_close of the last open - * reference to a file. + * If we're flushing on a close we can get a write + * error here, we must remember this. */ - if (normal_close && delete_on_close) { - DEBUG(5,("close_file: file %s. Delete on close was set - deleting file.\n", - fsp->fsp_name)); - if(SMB_VFS_UNLINK(conn,fsp->fsp_name) != 0) { - /* - * This call can potentially fail as another smbd may have - * had the file open with delete on close set and deleted - * it when its last reference to this file went away. Hence - * we log this but not at debug level zero. - */ - - DEBUG(5,("close_file: file %s. Delete on close was set and unlink failed \ -with error %s\n", fsp->fsp_name, strerror(errno) )); - } - process_pending_change_notify_queue((time_t)0); + saved_status2 = close_filestruct(fsp); + + if (fsp->print_file) { + print_fsp_end(fsp, close_type); + file_free(req, fsp); + return NT_STATUS_OK; } - unlock_share_entry_fsp(fsp); + /* If this is an old DOS or FCB open and we have multiple opens on + the same handle we only have one share mode. Ensure we only remove + the share mode on the last close. */ + + if (fsp->fh->ref_count == 1) { + /* Should we return on error here... ? */ + saved_status3 = close_remove_share_mode(fsp, close_type); + } - if(fsp->oplock_type) + if(fsp->oplock_type) { release_file_oplock(fsp); + } - locking_close_file(fsp); + locking_close_file(smbd_messaging_context(), fsp); - err = fd_close(conn, fsp); + status = fd_close(fsp); /* check for magic scripts */ - if (normal_close) { - check_magic(fsp,conn); + if (close_type == NORMAL_CLOSE) { + check_magic(fsp); } /* * Ensure pending modtime is set after close. */ - if(fsp->pending_modtime) { - int saved_errno = errno; - set_filetime(conn, fsp->fsp_name, fsp->pending_modtime); - errno = saved_errno; + saved_status4 = update_write_time_on_close(fsp); + + if (NT_STATUS_IS_OK(status)) { + if (!NT_STATUS_IS_OK(saved_status1)) { + status = saved_status1; + } else if (!NT_STATUS_IS_OK(saved_status2)) { + status = saved_status2; + } else if (!NT_STATUS_IS_OK(saved_status3)) { + status = saved_status3; + } else if (!NT_STATUS_IS_OK(saved_status4)) { + status = saved_status4; + } } DEBUG(2,("%s closed file %s (numopen=%d) %s\n", - conn->user,fsp->fsp_name, - conn->num_files_open, err ? strerror(err) : "")); - - if (fsp->fsp_name) - string_free(&fsp->fsp_name); - - file_free(fsp); + conn->server_info->unix_name,fsp->fsp_name, + conn->num_files_open, + nt_errstr(status) )); - if (err == -1 || err1 == -1) - return -1; - else - return 0; + file_free(req, fsp); + return status; } /**************************************************************************** Close a directory opened by an NT SMB call. ****************************************************************************/ -static int close_directory(files_struct *fsp, BOOL normal_close) +static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp, + enum file_close_type close_type) { - remove_pending_change_notify_requests_by_fid(fsp); + struct share_mode_lock *lck = 0; + bool delete_dir = False; + NTSTATUS status = NT_STATUS_OK; /* * NT can set delete_on_close of the last open * reference to a directory also. */ - if (normal_close && fsp->directory_delete_on_close) { - BOOL ok = rmdir_internals(fsp->conn, fsp->fsp_name); - DEBUG(5,("close_directory: %s. Delete on close was set - deleting directory %s.\n", - fsp->fsp_name, ok ? "succeeded" : "failed" )); + lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL, + NULL); + + if (lck == NULL) { + DEBUG(0, ("close_directory: Could not get share mode lock for %s\n", fsp->fsp_name)); + return NT_STATUS_INVALID_PARAMETER; + } + + if (!del_share_mode(lck, fsp)) { + DEBUG(0, ("close_directory: Could not delete share entry for %s\n", fsp->fsp_name)); + } + + if (fsp->initial_delete_on_close) { + bool became_user = False; + + /* Initial delete on close was set - for + * directories we don't care if anyone else + * wrote a real delete on close. */ + + if (current_user.vuid != fsp->vuid) { + become_user(fsp->conn, fsp->vuid); + became_user = True; + } + send_stat_cache_delete_message(fsp->fsp_name); + set_delete_on_close_lck(lck, True, ¤t_user.ut); + if (became_user) { + unbecome_user(); + } + } + + delete_dir = lck->delete_on_close; + + if (delete_dir) { + int i; + /* See if others still have the dir open. If this is the + * case, then don't delete. If all opens are POSIX delete now. */ + for (i=0; inum_share_modes; i++) { + struct share_mode_entry *e = &lck->share_modes[i]; + if (is_valid_share_mode_entry(e)) { + if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) { + continue; + } + delete_dir = False; + break; + } + } + } + + if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) && + delete_dir && + lck->delete_token) { + + /* Become the user who requested the delete. */ + + if (!push_sec_ctx()) { + smb_panic("close_directory: failed to push sec_ctx.\n"); + } + + set_sec_ctx(lck->delete_token->uid, + lck->delete_token->gid, + lck->delete_token->ngroups, + lck->delete_token->groups, + NULL); + + TALLOC_FREE(lck); + + status = rmdir_internals(talloc_tos(), + fsp->conn, fsp->fsp_name); + + DEBUG(5,("close_directory: %s. Delete on close was set - " + "deleting directory returned %s.\n", + fsp->fsp_name, nt_errstr(status))); + + /* unbecome user. */ + pop_sec_ctx(); /* * Ensure we remove any change notify requests that would * now fail as the directory has been deleted. */ - if(ok) - remove_pending_change_notify_requests_by_filename(fsp); - process_pending_change_notify_queue((time_t)0); + if(NT_STATUS_IS_OK(status)) { + remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING); + } + } else { + TALLOC_FREE(lck); + remove_pending_change_notify_requests_by_fid( + fsp, NT_STATUS_OK); } /* * Do the code common to files and directories. */ close_filestruct(fsp); - - if (fsp->fsp_name) - string_free(&fsp->fsp_name); - - file_free(fsp); - return 0; + file_free(req, fsp); + return status; } /**************************************************************************** - Close a 'stat file' opened internally. + Close a files_struct. ****************************************************************************/ -static int close_stat(files_struct *fsp) +NTSTATUS close_file(struct smb_request *req, files_struct *fsp, + enum file_close_type close_type) { - /* - * Do the code common to files and directories. - */ - close_filestruct(fsp); - - if (fsp->fsp_name) - string_free(&fsp->fsp_name); - - file_free(fsp); - return 0; + NTSTATUS status; + struct files_struct *base_fsp = fsp->base_fsp; + + if(fsp->is_directory) { + status = close_directory(req, fsp, close_type); + } else if (fsp->fake_file_handle != NULL) { + status = close_fake_file(req, fsp); + } else { + status = close_normal_file(req, fsp, close_type); + } + + if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) { + + /* + * fsp was a stream, the base fsp can't be a stream as well + * + * For SHUTDOWN_CLOSE this is not possible here, because + * SHUTDOWN_CLOSE only happens from files.c which walks the + * complete list of files. If we mess with more than one fsp + * those loops will become confused. + */ + + SMB_ASSERT(base_fsp->base_fsp == NULL); + close_file(req, base_fsp, close_type); + } + + return status; } /**************************************************************************** - Close a files_struct. + Deal with an (authorized) message to close a file given the share mode + entry. ****************************************************************************/ - -int close_file(files_struct *fsp, BOOL normal_close) + +void msg_close_file(struct messaging_context *msg_ctx, + void *private_data, + uint32_t msg_type, + struct server_id server_id, + DATA_BLOB *data) { - if(fsp->is_directory) - return close_directory(fsp, normal_close); - else if (fsp->is_stat) - return close_stat(fsp); - else - return close_normal_file(fsp, normal_close); + files_struct *fsp = NULL; + struct share_mode_entry e; + + message_to_share_mode_entry(&e, (char *)data->data); + + if(DEBUGLVL(10)) { + char *sm_str = share_mode_str(NULL, 0, &e); + if (!sm_str) { + smb_panic("talloc failed"); + } + DEBUG(10,("msg_close_file: got request to close share mode " + "entry %s\n", sm_str)); + TALLOC_FREE(sm_str); + } + + fsp = file_find_dif(e.id, e.share_file_id); + if (!fsp) { + DEBUG(10,("msg_close_file: failed to find file.\n")); + return; + } + close_file(NULL, fsp, NORMAL_CLOSE); }