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/>.
24 extern struct current_user current_user;
26 /****************************************************************************
27 Run a file if it is a magic script.
28 ****************************************************************************/
30 static NTSTATUS check_magic(struct files_struct *fsp)
33 const char *magic_output = NULL;
36 TALLOC_CTX *ctx = NULL;
38 struct connection_struct *conn = fsp->conn;
42 if (!*lp_magicscript(SNUM(conn))) {
46 DEBUG(5,("checking magic for %s\n", fsp_str_dbg(fsp)));
48 ctx = talloc_stackframe();
50 fname = fsp->fsp_name->base_name;
52 if (!(p = strrchr_m(fname,'/'))) {
58 if (!strequal(lp_magicscript(SNUM(conn)),p)) {
59 status = NT_STATUS_OK;
63 if (*lp_magicoutput(SNUM(conn))) {
64 magic_output = lp_magicoutput(SNUM(conn));
66 magic_output = talloc_asprintf(ctx,
71 status = NT_STATUS_NO_MEMORY;
75 /* Ensure we don't depend on user's PATH. */
76 p = talloc_asprintf(ctx, "./%s", fname);
78 status = NT_STATUS_NO_MEMORY;
82 if (chmod(fname, 0755) == -1) {
83 status = map_nt_error_from_unix(errno);
86 ret = smbrun(p,&tmp_fd);
87 DEBUG(3,("Invoking magic command %s gave %d\n",
91 if (ret != 0 || tmp_fd == -1) {
95 status = NT_STATUS_UNSUCCESSFUL;
98 outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
102 status = map_nt_error_from_unix(err);
106 if (sys_fstat(tmp_fd,&st) == -1) {
110 status = map_nt_error_from_unix(err);
114 if (transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_ex_size) == (SMB_OFF_T)-1) {
118 status = map_nt_error_from_unix(err);
122 if (close(outfd) == -1) {
123 status = map_nt_error_from_unix(errno);
127 status = NT_STATUS_OK;
134 /****************************************************************************
135 Common code to close a file or a directory.
136 ****************************************************************************/
138 static NTSTATUS close_filestruct(files_struct *fsp)
140 NTSTATUS status = NT_STATUS_OK;
142 if (fsp->fh->fd != -1) {
143 if(flush_write_cache(fsp, CLOSE_FLUSH) == -1) {
144 status = map_nt_error_from_unix(errno);
146 delete_write_cache(fsp);
152 /****************************************************************************
153 If any deferred opens are waiting on this close, notify them.
154 ****************************************************************************/
156 static void notify_deferred_opens(struct share_mode_lock *lck)
160 if (!should_notify_deferred_opens()) {
164 for (i=0; i<lck->num_share_modes; i++) {
165 struct share_mode_entry *e = &lck->share_modes[i];
167 if (!is_deferred_open_entry(e)) {
171 if (procid_is_me(&e->pid)) {
173 * We need to notify ourself to retry the open. Do
174 * this by finding the queued SMB record, moving it to
175 * the head of the queue and changing the wait time to
178 schedule_deferred_open_smb_message(e->op_mid);
180 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
182 share_mode_entry_to_message(msg, e);
184 messaging_send_buf(smbd_messaging_context(),
185 e->pid, MSG_SMB_OPEN_RETRY,
187 MSG_SMB_SHARE_MODE_ENTRY_SIZE);
192 /****************************************************************************
194 ****************************************************************************/
196 NTSTATUS delete_all_streams(connection_struct *conn, const char *fname)
198 struct stream_struct *stream_info;
200 unsigned int num_streams;
201 TALLOC_CTX *frame = talloc_stackframe();
204 status = SMB_VFS_STREAMINFO(conn, NULL, fname, talloc_tos(),
205 &num_streams, &stream_info);
207 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
208 DEBUG(10, ("no streams around\n"));
213 if (!NT_STATUS_IS_OK(status)) {
214 DEBUG(10, ("SMB_VFS_STREAMINFO failed: %s\n",
219 DEBUG(10, ("delete_all_streams found %d streams\n",
222 if (num_streams == 0) {
227 for (i=0; i<num_streams; i++) {
229 struct smb_filename *smb_fname_stream = NULL;
231 if (strequal(stream_info[i].name, "::$DATA")) {
235 status = create_synthetic_smb_fname(talloc_tos(), fname,
236 stream_info[i].name, NULL,
239 if (!NT_STATUS_IS_OK(status)) {
240 DEBUG(0, ("talloc_aprintf failed\n"));
244 res = SMB_VFS_UNLINK(conn, smb_fname_stream);
247 status = map_nt_error_from_unix(errno);
248 DEBUG(10, ("Could not delete stream %s: %s\n",
249 smb_fname_str_dbg(smb_fname_stream),
251 TALLOC_FREE(smb_fname_stream);
254 TALLOC_FREE(smb_fname_stream);
262 /****************************************************************************
263 Deal with removing a share mode on last close.
264 ****************************************************************************/
266 static NTSTATUS close_remove_share_mode(files_struct *fsp,
267 enum file_close_type close_type)
269 connection_struct *conn = fsp->conn;
270 bool delete_file = false;
271 bool changed_user = false;
272 struct share_mode_lock *lck = NULL;
273 NTSTATUS status = NT_STATUS_OK;
278 * Lock the share entries, and determine if we should delete
279 * on close. If so delete whilst the lock is still in effect.
280 * This prevents race conditions with the file being created. JRA.
283 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
287 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
288 "lock for file %s\n", fsp_str_dbg(fsp)));
289 status = NT_STATUS_INVALID_PARAMETER;
293 if (fsp->write_time_forced) {
294 set_close_write_time(fsp, lck->changed_write_time);
297 if (!del_share_mode(lck, fsp)) {
298 DEBUG(0, ("close_remove_share_mode: Could not delete share "
299 "entry for file %s\n",
303 if (fsp->initial_delete_on_close && (lck->delete_token == NULL)) {
304 bool became_user = False;
306 /* Initial delete on close was set and no one else
307 * wrote a real delete on close. */
309 if (current_user.vuid != fsp->vuid) {
310 become_user(conn, fsp->vuid);
313 set_delete_on_close_lck(lck, True, ¤t_user.ut);
319 delete_file = lck->delete_on_close;
323 /* See if others still have the file open. If this is the
324 * case, then don't delete. If all opens are POSIX delete now. */
325 for (i=0; i<lck->num_share_modes; i++) {
326 struct share_mode_entry *e = &lck->share_modes[i];
327 if (is_valid_share_mode_entry(e)) {
328 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
337 /* Notify any deferred opens waiting on this close. */
338 notify_deferred_opens(lck);
339 reply_to_oplock_break_requests(fsp);
342 * NT can set delete_on_close of the last open
343 * reference to a file.
346 if (!(close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE)
348 || (lck->delete_token == NULL)) {
354 * Ok, we have to delete the file
357 DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
358 "- deleting file.\n", fsp_str_dbg(fsp)));
361 * Don't try to update the write time when we delete the file
363 fsp->update_write_time_on_close = false;
365 if (!unix_token_equal(lck->delete_token, ¤t_user.ut)) {
366 /* Become the user who requested the delete. */
368 DEBUG(5,("close_remove_share_mode: file %s. "
369 "Change user to uid %u\n",
371 (unsigned int)lck->delete_token->uid));
373 if (!push_sec_ctx()) {
374 smb_panic("close_remove_share_mode: file %s. failed to push "
378 set_sec_ctx(lck->delete_token->uid,
379 lck->delete_token->gid,
380 lck->delete_token->ngroups,
381 lck->delete_token->groups,
387 /* We can only delete the file if the name we have is still valid and
388 hasn't been renamed. */
390 tmp_status = vfs_stat_fsp(fsp);
391 if (!NT_STATUS_IS_OK(tmp_status)) {
392 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
393 "was set and stat failed with error %s\n",
394 fsp_str_dbg(fsp), nt_errstr(tmp_status)));
396 * Don't save the errno here, we ignore this error
401 id = vfs_file_id_from_sbuf(conn, &fsp->fsp_name->st);
403 if (!file_id_equal(&fsp->file_id, &id)) {
404 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
405 "was set and dev and/or inode does not match\n",
407 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
410 file_id_string_tos(&fsp->file_id),
411 file_id_string_tos(&id)));
413 * Don't save the errno here, we ignore this error
418 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
419 && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
421 status = delete_all_streams(conn, fsp->fsp_name->base_name);
423 if (!NT_STATUS_IS_OK(status)) {
424 DEBUG(5, ("delete_all_streams failed: %s\n",
431 if (SMB_VFS_UNLINK(conn, fsp->fsp_name) != 0) {
433 * This call can potentially fail as another smbd may
434 * have had the file open with delete on close set and
435 * deleted it when its last reference to this file
436 * went away. Hence we log this but not at debug level
440 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
441 "was set and unlink failed with error %s\n",
442 fsp_str_dbg(fsp), strerror(errno)));
444 status = map_nt_error_from_unix(errno);
447 notify_fname(conn, NOTIFY_ACTION_REMOVED,
448 FILE_NOTIFY_CHANGE_FILE_NAME,
449 fsp->fsp_name->base_name);
451 /* As we now have POSIX opens which can unlink
452 * with other open files we may have taken
453 * this code path with more than one share mode
454 * entry - ensure we only delete once by resetting
455 * the delete on close flag. JRA.
458 set_delete_on_close_lck(lck, False, NULL);
471 void set_close_write_time(struct files_struct *fsp, struct timespec ts)
473 DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts))));
475 if (null_timespec(ts)) {
479 * if the write time on close is explict set, then don't
480 * need to fix it up to the value in the locking db
482 fsp->write_time_forced = false;
484 fsp->update_write_time_on_close = true;
485 fsp->close_write_time = ts;
488 static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
490 struct smb_file_time ft;
495 if (!fsp->update_write_time_on_close) {
499 if (null_timespec(fsp->close_write_time)) {
500 fsp->close_write_time = timespec_current();
503 /* Ensure we have a valid stat struct for the source. */
504 status = vfs_stat_fsp(fsp);
505 if (!NT_STATUS_IS_OK(status)) {
509 if (!VALID_STAT(fsp->fsp_name->st)) {
510 /* if it doesn't seem to be a real file */
514 ft.mtime = fsp->close_write_time;
515 status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, &ft, true);
516 if (!NT_STATUS_IS_OK(status)) {
523 static NTSTATUS ntstatus_keeperror(NTSTATUS s1, NTSTATUS s2)
525 if (!NT_STATUS_IS_OK(s1)) {
531 /****************************************************************************
534 close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
535 printing and magic scripts are only run on normal close.
536 delete on close is done on normal and shutdown close.
537 ****************************************************************************/
539 static NTSTATUS close_normal_file(struct smb_request *req, files_struct *fsp,
540 enum file_close_type close_type)
542 NTSTATUS status = NT_STATUS_OK;
544 connection_struct *conn = fsp->conn;
546 if (fsp->aio_write_behind) {
548 * If we're finishing write behind on a close we can get a write
549 * error here, we must remember this.
551 int ret = wait_for_aio_completion(fsp);
553 status = ntstatus_keeperror(
554 status, map_nt_error_from_unix(ret));
557 cancel_aio_by_fsp(fsp);
561 * If we're flushing on a close we can get a write
562 * error here, we must remember this.
565 tmp = close_filestruct(fsp);
566 status = ntstatus_keeperror(status, tmp);
568 if (fsp->print_file) {
569 print_fsp_end(fsp, close_type);
574 /* Remove the oplock before potentially deleting the file. */
575 if(fsp->oplock_type) {
576 release_file_oplock(fsp);
579 /* If this is an old DOS or FCB open and we have multiple opens on
580 the same handle we only have one share mode. Ensure we only remove
581 the share mode on the last close. */
583 if (fsp->fh->ref_count == 1) {
584 /* Should we return on error here... ? */
585 tmp = close_remove_share_mode(fsp, close_type);
586 status = ntstatus_keeperror(status, tmp);
589 locking_close_file(smbd_messaging_context(), fsp);
592 status = ntstatus_keeperror(status, tmp);
594 /* check for magic scripts */
595 if (close_type == NORMAL_CLOSE) {
596 tmp = check_magic(fsp);
597 status = ntstatus_keeperror(status, tmp);
601 * Ensure pending modtime is set after close.
604 tmp = update_write_time_on_close(fsp);
605 if (NT_STATUS_EQUAL(tmp, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
606 /* Someone renamed the file or a parent directory containing
607 * this file. We can't do anything about this, we don't have
608 * an "update timestamp by fd" call in POSIX. Eat the error. */
613 status = ntstatus_keeperror(status, tmp);
615 DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
616 conn->server_info->unix_name, fsp_str_dbg(fsp),
617 conn->num_files_open - 1,
618 nt_errstr(status) ));
624 /****************************************************************************
625 Close a directory opened by an NT SMB call.
626 ****************************************************************************/
628 static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp,
629 enum file_close_type close_type)
631 struct share_mode_lock *lck = NULL;
632 bool delete_dir = False;
633 NTSTATUS status = NT_STATUS_OK;
636 * NT can set delete_on_close of the last open
637 * reference to a directory also.
640 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
644 DEBUG(0, ("close_directory: Could not get share mode lock for "
645 "%s\n", fsp_str_dbg(fsp)));
646 status = NT_STATUS_INVALID_PARAMETER;
650 if (!del_share_mode(lck, fsp)) {
651 DEBUG(0, ("close_directory: Could not delete share entry for "
652 "%s\n", fsp_str_dbg(fsp)));
655 if (fsp->initial_delete_on_close) {
656 bool became_user = False;
658 /* Initial delete on close was set - for
659 * directories we don't care if anyone else
660 * wrote a real delete on close. */
662 if (current_user.vuid != fsp->vuid) {
663 become_user(fsp->conn, fsp->vuid);
666 send_stat_cache_delete_message(fsp->fsp_name->base_name);
667 set_delete_on_close_lck(lck, True, ¤t_user.ut);
673 delete_dir = lck->delete_on_close;
677 /* See if others still have the dir open. If this is the
678 * case, then don't delete. If all opens are POSIX delete now. */
679 for (i=0; i<lck->num_share_modes; i++) {
680 struct share_mode_entry *e = &lck->share_modes[i];
681 if (is_valid_share_mode_entry(e)) {
682 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
691 if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
695 /* Become the user who requested the delete. */
697 if (!push_sec_ctx()) {
698 smb_panic("close_directory: failed to push sec_ctx.\n");
701 set_sec_ctx(lck->delete_token->uid,
702 lck->delete_token->gid,
703 lck->delete_token->ngroups,
704 lck->delete_token->groups,
709 status = rmdir_internals(talloc_tos(), fsp->conn,
712 DEBUG(5,("close_directory: %s. Delete on close was set - "
713 "deleting directory returned %s.\n",
714 fsp_str_dbg(fsp), nt_errstr(status)));
720 * Ensure we remove any change notify requests that would
721 * now fail as the directory has been deleted.
724 if(NT_STATUS_IS_OK(status)) {
725 remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING);
729 remove_pending_change_notify_requests_by_fid(
733 status = fd_close(fsp);
735 if (!NT_STATUS_IS_OK(status)) {
736 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
737 fsp_str_dbg(fsp), fsp->fh->fd, errno,
742 dptr_CloseDir(fsp->dptr);
746 * Do the code common to files and directories.
748 close_filestruct(fsp);
756 /****************************************************************************
757 Close a files_struct.
758 ****************************************************************************/
760 NTSTATUS close_file(struct smb_request *req, files_struct *fsp,
761 enum file_close_type close_type)
764 struct files_struct *base_fsp = fsp->base_fsp;
766 if(fsp->is_directory) {
767 status = close_directory(req, fsp, close_type);
768 } else if (fsp->fake_file_handle != NULL) {
769 status = close_fake_file(req, fsp);
771 status = close_normal_file(req, fsp, close_type);
774 if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) {
777 * fsp was a stream, the base fsp can't be a stream as well
779 * For SHUTDOWN_CLOSE this is not possible here, because
780 * SHUTDOWN_CLOSE only happens from files.c which walks the
781 * complete list of files. If we mess with more than one fsp
782 * those loops will become confused.
785 SMB_ASSERT(base_fsp->base_fsp == NULL);
786 close_file(req, base_fsp, close_type);
792 /****************************************************************************
793 Deal with an (authorized) message to close a file given the share mode
795 ****************************************************************************/
797 void msg_close_file(struct messaging_context *msg_ctx,
800 struct server_id server_id,
803 files_struct *fsp = NULL;
804 struct share_mode_entry e;
806 message_to_share_mode_entry(&e, (char *)data->data);
809 char *sm_str = share_mode_str(NULL, 0, &e);
811 smb_panic("talloc failed");
813 DEBUG(10,("msg_close_file: got request to close share mode "
814 "entry %s\n", sm_str));
818 fsp = file_find_dif(e.id, e.share_file_id);
820 DEBUG(10,("msg_close_file: failed to find file.\n"));
823 close_file(NULL, fsp, NORMAL_CLOSE);