Run a file if it is a magic script.
****************************************************************************/
-static void check_magic(files_struct *fsp,connection_struct *conn)
+static NTSTATUS check_magic(struct files_struct *fsp)
{
int ret;
const char *magic_output = NULL;
int tmp_fd, outfd;
TALLOC_CTX *ctx = NULL;
const char *p;
+ struct connection_struct *conn = fsp->conn;
+ char *fname = NULL;
+ NTSTATUS status;
if (!*lp_magicscript(SNUM(conn))) {
- return;
+ return NT_STATUS_OK;
}
- DEBUG(5,("checking magic for %s\n",fsp->fsp_name));
+ DEBUG(5,("checking magic for %s\n", fsp_str_dbg(fsp)));
+
+ ctx = talloc_stackframe();
+
+ fname = fsp->fsp_name->base_name;
- if (!(p = strrchr_m(fsp->fsp_name,'/'))) {
- p = fsp->fsp_name;
+ if (!(p = strrchr_m(fname,'/'))) {
+ p = fname;
} else {
p++;
}
if (!strequal(lp_magicscript(SNUM(conn)),p)) {
- return;
+ status = NT_STATUS_OK;
+ goto out;
}
- 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);
+ fname);
}
if (!magic_output) {
- TALLOC_FREE(ctx);
- return;
+ status = NT_STATUS_NO_MEMORY;
+ goto out;
+ }
+
+ /* Ensure we don't depend on user's PATH. */
+ p = talloc_asprintf(ctx, "./%s", fname);
+ if (!p) {
+ status = NT_STATUS_NO_MEMORY;
+ goto out;
}
- chmod(fsp->fsp_name,0755);
- ret = smbrun(fsp->fsp_name,&tmp_fd);
+ if (chmod(fname, 0755) == -1) {
+ status = map_nt_error_from_unix(errno);
+ goto out;
+ }
+ ret = smbrun(p,&tmp_fd);
DEBUG(3,("Invoking magic command %s gave %d\n",
- fsp->fsp_name,ret));
+ p,ret));
- unlink(fsp->fsp_name);
+ unlink(fname);
if (ret != 0 || tmp_fd == -1) {
if (tmp_fd != -1) {
close(tmp_fd);
}
- TALLOC_FREE(ctx);
- return;
+ status = NT_STATUS_UNSUCCESSFUL;
+ goto out;
}
outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
if (outfd == -1) {
+ int err = errno;
close(tmp_fd);
- TALLOC_FREE(ctx);
- return;
+ status = map_nt_error_from_unix(err);
+ goto out;
}
if (sys_fstat(tmp_fd,&st) == -1) {
+ int err = errno;
close(tmp_fd);
close(outfd);
- return;
+ status = map_nt_error_from_unix(err);
+ goto out;
}
- transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_size);
+ if (transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_ex_size) == (SMB_OFF_T)-1) {
+ int err = errno;
+ close(tmp_fd);
+ close(outfd);
+ status = map_nt_error_from_unix(err);
+ goto out;
+ }
close(tmp_fd);
- close(outfd);
+ if (close(outfd) == -1) {
+ status = map_nt_error_from_unix(errno);
+ goto out;
+ }
+
+ status = NT_STATUS_OK;
+
+ out:
TALLOC_FREE(ctx);
+ return status;
}
/****************************************************************************
static NTSTATUS close_filestruct(files_struct *fsp)
{
NTSTATUS status = NT_STATUS_OK;
- connection_struct *conn = fsp->conn;
-
+
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--;
return status;
-}
+}
/****************************************************************************
If any deferred opens are waiting on this close, notify them.
static void notify_deferred_opens(struct share_mode_lock *lck)
{
int i;
+
+ if (!should_notify_deferred_opens()) {
+ return;
+ }
for (i=0; i<lck->num_share_modes; i++) {
struct share_mode_entry *e = &lck->share_modes[i];
}
}
+/****************************************************************************
+ Delete all streams
+****************************************************************************/
+
+NTSTATUS delete_all_streams(connection_struct *conn, const char *fname)
+{
+ 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;
+ }
+
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(10, ("SMB_VFS_STREAMINFO failed: %s\n",
+ nt_errstr(status)));
+ goto fail;
+ }
+
+ DEBUG(10, ("delete_all_streams found %d streams\n",
+ num_streams));
+
+ if (num_streams == 0) {
+ TALLOC_FREE(frame);
+ return NT_STATUS_OK;
+ }
+
+ for (i=0; i<num_streams; i++) {
+ int res;
+ struct smb_filename *smb_fname_stream = NULL;
+
+ if (strequal(stream_info[i].name, "::$DATA")) {
+ continue;
+ }
+
+ status = create_synthetic_smb_fname(talloc_tos(), fname,
+ stream_info[i].name, NULL,
+ &smb_fname_stream);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0, ("talloc_aprintf failed\n"));
+ goto fail;
+ }
+
+ res = SMB_VFS_UNLINK(conn, smb_fname_stream);
+
+ if (res == -1) {
+ status = map_nt_error_from_unix(errno);
+ DEBUG(10, ("Could not delete stream %s: %s\n",
+ smb_fname_str_dbg(smb_fname_stream),
+ strerror(errno)));
+ TALLOC_FREE(smb_fname_stream);
+ break;
+ }
+ TALLOC_FREE(smb_fname_stream);
+ }
+
+ fail:
+ TALLOC_FREE(frame);
+ return status;
+}
+
/****************************************************************************
Deal with removing a share mode on last close.
****************************************************************************/
enum file_close_type close_type)
{
connection_struct *conn = fsp->conn;
- bool delete_file = False;
- struct share_mode_lock *lck;
- SMB_STRUCT_STAT sbuf;
+ bool delete_file = false;
+ bool changed_user = false;
+ struct share_mode_lock *lck = NULL;
NTSTATUS status = NT_STATUS_OK;
int ret;
struct file_id id;
* This prevents race conditions with the file being created. JRA.
*/
- lck = get_share_mode_lock(NULL, fsp->file_id, NULL, NULL);
+ 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;
+ "lock for file %s\n", fsp_str_dbg(fsp)));
+ status = NT_STATUS_INVALID_PARAMETER;
+ goto done;
+ }
+
+ 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));
+ "entry for file %s\n",
+ fsp_str_dbg(fsp)));
}
if (fsp->initial_delete_on_close && (lck->delete_token == NULL)) {
*/
DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
- "- deleting file.\n", fsp->fsp_name));
+ "- deleting file.\n", fsp_str_dbg(fsp)));
- /* Become the user who requested the delete. */
+ /*
+ * Don't try to update the write time when we delete the file
+ */
+ fsp->update_write_time_on_close = false;
- if (!push_sec_ctx()) {
- smb_panic("close_remove_share_mode: file %s. failed to push "
- "sec_ctx.\n");
- }
+ if (!unix_token_equal(lck->delete_token, ¤t_user.ut)) {
+ /* Become the user who requested the delete. */
+
+ DEBUG(5,("close_remove_share_mode: file %s. "
+ "Change user to uid %u\n",
+ fsp_str_dbg(fsp),
+ (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);
+ 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);
+ ret = SMB_VFS_LSTAT(conn, fsp->fsp_name);
} else {
- ret = SMB_VFS_STAT(conn,fsp->fsp_name,&sbuf);
+ ret = SMB_VFS_STAT(conn, fsp->fsp_name);
}
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) ));
+ fsp_str_dbg(fsp), strerror(errno)));
/*
* Don't save the errno here, we ignore this error
*/
goto done;
}
- id = vfs_file_id_from_sbuf(conn, &sbuf);
+ id = vfs_file_id_from_sbuf(conn, &fsp->fsp_name->st);
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 ));
+ fsp_str_dbg(fsp)));
DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
"stat file_id %s\n",
- fsp->fsp_name,
+ fsp_str_dbg(fsp),
file_id_string_tos(&fsp->file_id),
file_id_string_tos(&id)));
/*
goto done;
}
- if (SMB_VFS_UNLINK(conn,fsp->fsp_name) != 0) {
+ if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
+ && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
+
+ status = delete_all_streams(conn, fsp->fsp_name->base_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
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) ));
+ fsp_str_dbg(fsp), strerror(errno)));
status = map_nt_error_from_unix(errno);
}
notify_fname(conn, NOTIFY_ACTION_REMOVED,
FILE_NOTIFY_CHANGE_FILE_NAME,
- fsp->fsp_name);
+ fsp->fsp_name->base_name);
/* As we now have POSIX opens which can unlink
* with other open files we may have taken
done:
- /* unbecome user. */
- pop_sec_ctx();
-
+ 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;
+ }
+ /*
+ * 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)
+{
+ struct smb_file_time ft;
+ NTSTATUS status;
+ int ret = -1;
+
+ ZERO_STRUCT(ft);
+
+ 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) {
+ ret = SMB_VFS_FSTAT(fsp, &fsp->fsp_name->st);
+ } else {
+ if (fsp->posix_open) {
+ ret = SMB_VFS_LSTAT(fsp->conn, fsp->fsp_name);
+ } else {
+ ret = SMB_VFS_STAT(fsp->conn, fsp->fsp_name);
+ }
+ }
+
+ if (ret == -1) {
+ return map_nt_error_from_unix(errno);
+ }
+
+ if (!VALID_STAT(fsp->fsp_name->st)) {
+ /* if it doesn't seem to be a real file */
+ return NT_STATUS_OK;
+ }
+
+ ft.mtime = fsp->close_write_time;
+ status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, &ft, true);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ return status;
+}
+
+static NTSTATUS ntstatus_keeperror(NTSTATUS s1, NTSTATUS s2)
+{
+ if (!NT_STATUS_IS_OK(s1)) {
+ return s1;
+ }
+ return s2;
+}
+
/****************************************************************************
Close a file.
delete on close is done on normal and shutdown close.
****************************************************************************/
-static NTSTATUS close_normal_file(files_struct *fsp, enum file_close_type close_type)
+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 tmp;
connection_struct *conn = fsp->conn;
if (fsp->aio_write_behind) {
*/
int ret = wait_for_aio_completion(fsp);
if (ret) {
- saved_status1 = map_nt_error_from_unix(ret);
+ status = ntstatus_keeperror(
+ status, map_nt_error_from_unix(ret));
}
} else {
cancel_aio_by_fsp(fsp);
* error here, we must remember this.
*/
- saved_status2 = close_filestruct(fsp);
+ tmp = close_filestruct(fsp);
+ status = ntstatus_keeperror(status, tmp);
if (fsp->print_file) {
print_fsp_end(fsp, close_type);
- file_free(fsp);
+ file_free(req, fsp);
return NT_STATUS_OK;
}
+ /* Remove the oplock before potentially deleting the file. */
+ if(fsp->oplock_type) {
+ release_file_oplock(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) {
- release_file_oplock(fsp);
+ tmp = close_remove_share_mode(fsp, close_type);
+ status = ntstatus_keeperror(status, tmp);
}
locking_close_file(smbd_messaging_context(), fsp);
- status = fd_close(conn, fsp);
+ tmp = fd_close(fsp);
+ status = ntstatus_keeperror(status, tmp);
/* check for magic scripts */
if (close_type == NORMAL_CLOSE) {
- check_magic(fsp,conn);
+ tmp = check_magic(fsp);
+ status = ntstatus_keeperror(status, tmp);
}
/*
* Ensure pending modtime is set after close.
*/
- if (fsp->pending_modtime_owner && !null_timespec(fsp->pending_modtime)) {
- set_filetime(conn, fsp->fsp_name, fsp->pending_modtime);
- } else if (!null_timespec(fsp->last_write_time)) {
- set_filetime(conn, fsp->fsp_name, fsp->last_write_time);
- }
+ tmp = update_write_time_on_close(fsp);
+ if (NT_STATUS_EQUAL(tmp, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+ /* Someone renamed the file or a parent directory containing
+ * this file. We can't do anything about this, we don't have
+ * an "update timestamp by fd" call in POSIX. Eat the error. */
- 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;
- }
+ tmp = NT_STATUS_OK;
}
+ status = ntstatus_keeperror(status, tmp);
+
DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
- conn->user,fsp->fsp_name,
- conn->num_files_open,
+ conn->server_info->unix_name, fsp_str_dbg(fsp),
+ conn->num_files_open - 1,
nt_errstr(status) ));
- file_free(fsp);
+ file_free(req, fsp);
return status;
}
Close a directory opened by an NT SMB call.
****************************************************************************/
-static NTSTATUS close_directory(files_struct *fsp, enum file_close_type close_type)
+static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp,
+ enum file_close_type close_type)
{
- struct share_mode_lock *lck = 0;
+ struct share_mode_lock *lck = NULL;
bool delete_dir = False;
NTSTATUS status = NT_STATUS_OK;
* reference to a directory also.
*/
- lck = get_share_mode_lock(NULL, fsp->file_id, NULL, NULL);
+ 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;
+ DEBUG(0, ("close_directory: Could not get share mode lock for "
+ "%s\n", fsp_str_dbg(fsp)));
+ status = NT_STATUS_INVALID_PARAMETER;
+ goto out;
}
if (!del_share_mode(lck, fsp)) {
- DEBUG(0, ("close_directory: Could not delete share entry for %s\n", fsp->fsp_name));
+ DEBUG(0, ("close_directory: Could not delete share entry for "
+ "%s\n", fsp_str_dbg(fsp)));
}
if (fsp->initial_delete_on_close) {
become_user(fsp->conn, fsp->vuid);
became_user = True;
}
- send_stat_cache_delete_message(fsp->fsp_name);
+ send_stat_cache_delete_message(fsp->fsp_name->base_name);
set_delete_on_close_lck(lck, True, ¤t_user.ut);
if (became_user) {
unbecome_user();
TALLOC_FREE(lck);
- status = rmdir_internals(talloc_tos(),
- fsp->conn, fsp->fsp_name);
+ 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)));
+ fsp_str_dbg(fsp), nt_errstr(status)));
/* unbecome user. */
pop_sec_ctx();
fsp, NT_STATUS_OK);
}
+ status = fd_close(fsp);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
+ fsp_str_dbg(fsp), fsp->fh->fd, errno,
+ strerror(errno)));
+ }
+
+ if (fsp->dptr) {
+ dptr_CloseDir(fsp->dptr);
+ }
+
/*
* Do the code common to files and directories.
*/
close_filestruct(fsp);
- file_free(fsp);
+ file_free(req, fsp);
+
+ out:
+ TALLOC_FREE(lck);
return status;
}
/****************************************************************************
- Close a 'stat file' opened internally.
+ Close a files_struct.
****************************************************************************/
-static NTSTATUS 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);
- file_free(fsp);
- return NT_STATUS_OK;
+ 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.
****************************************************************************/
-
-NTSTATUS close_file(files_struct *fsp, enum file_close_type close_type)
+
+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, close_type);
- } else if (fsp->is_stat) {
- return close_stat(fsp);
- } else if (fsp->fake_file_handle != NULL) {
- return close_fake_file(fsp);
+ 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;
}
- return close_normal_file(fsp, close_type);
+ close_file(NULL, fsp, NORMAL_CLOSE);
}
git.samba.org / metze / samba / wip.git / blobdiff