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 void check_magic(struct files_struct *fsp)
33 const char *magic_output = NULL;
36 TALLOC_CTX *ctx = NULL;
38 struct connection_struct *conn = fsp->conn;
40 if (!*lp_magicscript(SNUM(conn))) {
44 DEBUG(5,("checking magic for %s\n",fsp->fsp_name));
46 if (!(p = strrchr_m(fsp->fsp_name,'/'))) {
52 if (!strequal(lp_magicscript(SNUM(conn)),p)) {
56 ctx = talloc_stackframe();
58 if (*lp_magicoutput(SNUM(conn))) {
59 magic_output = lp_magicoutput(SNUM(conn));
61 magic_output = talloc_asprintf(ctx,
70 chmod(fsp->fsp_name,0755);
71 ret = smbrun(fsp->fsp_name,&tmp_fd);
72 DEBUG(3,("Invoking magic command %s gave %d\n",
75 unlink(fsp->fsp_name);
76 if (ret != 0 || tmp_fd == -1) {
83 outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
90 if (sys_fstat(tmp_fd,&st) == -1) {
96 transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_size);
102 /****************************************************************************
103 Common code to close a file or a directory.
104 ****************************************************************************/
106 static NTSTATUS close_filestruct(files_struct *fsp)
108 NTSTATUS status = NT_STATUS_OK;
110 if (fsp->fh->fd != -1) {
111 if(flush_write_cache(fsp, CLOSE_FLUSH) == -1) {
112 status = map_nt_error_from_unix(errno);
114 delete_write_cache(fsp);
120 /****************************************************************************
121 If any deferred opens are waiting on this close, notify them.
122 ****************************************************************************/
124 static void notify_deferred_opens(struct share_mode_lock *lck)
128 for (i=0; i<lck->num_share_modes; i++) {
129 struct share_mode_entry *e = &lck->share_modes[i];
131 if (!is_deferred_open_entry(e)) {
135 if (procid_is_me(&e->pid)) {
137 * We need to notify ourself to retry the open. Do
138 * this by finding the queued SMB record, moving it to
139 * the head of the queue and changing the wait time to
142 schedule_deferred_open_smb_message(e->op_mid);
144 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
146 share_mode_entry_to_message(msg, e);
148 messaging_send_buf(smbd_messaging_context(),
149 e->pid, MSG_SMB_OPEN_RETRY,
151 MSG_SMB_SHARE_MODE_ENTRY_SIZE);
156 /****************************************************************************
158 ****************************************************************************/
160 static NTSTATUS delete_all_streams(connection_struct *conn, const char *fname)
162 struct stream_struct *stream_info;
164 unsigned int num_streams;
165 TALLOC_CTX *frame = talloc_stackframe();
168 status = SMB_VFS_STREAMINFO(conn, NULL, fname, talloc_tos(),
169 &num_streams, &stream_info);
171 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
172 DEBUG(10, ("no streams around\n"));
177 if (!NT_STATUS_IS_OK(status)) {
178 DEBUG(10, ("SMB_VFS_STREAMINFO failed: %s\n",
183 DEBUG(10, ("delete_all_streams found %d streams\n",
186 if (num_streams == 0) {
191 for (i=0; i<num_streams; i++) {
195 if (strequal(stream_info[i].name, "::$DATA")) {
199 streamname = talloc_asprintf(talloc_tos(), "%s%s", fname,
200 stream_info[i].name);
202 if (streamname == NULL) {
203 DEBUG(0, ("talloc_aprintf failed\n"));
204 status = NT_STATUS_NO_MEMORY;
208 res = SMB_VFS_UNLINK(conn, streamname);
210 TALLOC_FREE(streamname);
213 status = map_nt_error_from_unix(errno);
214 DEBUG(10, ("Could not delete stream %s: %s\n",
215 streamname, strerror(errno)));
225 /****************************************************************************
226 Deal with removing a share mode on last close.
227 ****************************************************************************/
229 static NTSTATUS close_remove_share_mode(files_struct *fsp,
230 enum file_close_type close_type)
232 connection_struct *conn = fsp->conn;
233 bool delete_file = false;
234 bool changed_user = false;
235 struct share_mode_lock *lck;
236 SMB_STRUCT_STAT sbuf;
237 NTSTATUS status = NT_STATUS_OK;
242 * Lock the share entries, and determine if we should delete
243 * on close. If so delete whilst the lock is still in effect.
244 * This prevents race conditions with the file being created. JRA.
247 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
251 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
252 "lock for file %s\n", fsp->fsp_name));
253 return NT_STATUS_INVALID_PARAMETER;
256 if (fsp->write_time_forced) {
257 set_close_write_time(fsp, lck->changed_write_time);
260 if (!del_share_mode(lck, fsp)) {
261 DEBUG(0, ("close_remove_share_mode: Could not delete share "
262 "entry for file %s\n", fsp->fsp_name));
265 if (fsp->initial_delete_on_close && (lck->delete_token == NULL)) {
266 bool became_user = False;
268 /* Initial delete on close was set and no one else
269 * wrote a real delete on close. */
271 if (current_user.vuid != fsp->vuid) {
272 become_user(conn, fsp->vuid);
275 set_delete_on_close_lck(lck, True, ¤t_user.ut);
281 delete_file = lck->delete_on_close;
285 /* See if others still have the file open. If this is the
286 * case, then don't delete. If all opens are POSIX delete now. */
287 for (i=0; i<lck->num_share_modes; i++) {
288 struct share_mode_entry *e = &lck->share_modes[i];
289 if (is_valid_share_mode_entry(e)) {
290 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
299 /* Notify any deferred opens waiting on this close. */
300 notify_deferred_opens(lck);
301 reply_to_oplock_break_requests(fsp);
304 * NT can set delete_on_close of the last open
305 * reference to a file.
308 if (!(close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE)
310 || (lck->delete_token == NULL)) {
316 * Ok, we have to delete the file
319 DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
320 "- deleting file.\n", fsp->fsp_name));
323 * Don't try to update the write time when we delete the file
325 fsp->update_write_time_on_close = false;
327 if (!unix_token_equal(lck->delete_token, ¤t_user.ut)) {
328 /* Become the user who requested the delete. */
330 DEBUG(5,("close_remove_share_mode: file %s. "
331 "Change user to uid %u\n",
333 (unsigned int)lck->delete_token->uid));
335 if (!push_sec_ctx()) {
336 smb_panic("close_remove_share_mode: file %s. failed to push "
340 set_sec_ctx(lck->delete_token->uid,
341 lck->delete_token->gid,
342 lck->delete_token->ngroups,
343 lck->delete_token->groups,
349 /* We can only delete the file if the name we have is still valid and
350 hasn't been renamed. */
352 if (fsp->posix_open) {
353 ret = SMB_VFS_LSTAT(conn,fsp->fsp_name,&sbuf);
355 ret = SMB_VFS_STAT(conn,fsp->fsp_name,&sbuf);
359 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
360 "was set and stat failed with error %s\n",
361 fsp->fsp_name, strerror(errno) ));
363 * Don't save the errno here, we ignore this error
368 id = vfs_file_id_from_sbuf(conn, &sbuf);
370 if (!file_id_equal(&fsp->file_id, &id)) {
371 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
372 "was set and dev and/or inode does not match\n",
374 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
377 file_id_string_tos(&fsp->file_id),
378 file_id_string_tos(&id)));
380 * Don't save the errno here, we ignore this error
385 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
386 && !is_ntfs_stream_name(fsp->fsp_name)) {
388 status = delete_all_streams(conn, fsp->fsp_name);
390 if (!NT_STATUS_IS_OK(status)) {
391 DEBUG(5, ("delete_all_streams failed: %s\n",
398 if (SMB_VFS_UNLINK(conn,fsp->fsp_name) != 0) {
400 * This call can potentially fail as another smbd may
401 * have had the file open with delete on close set and
402 * deleted it when its last reference to this file
403 * went away. Hence we log this but not at debug level
407 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
408 "was set and unlink failed with error %s\n",
409 fsp->fsp_name, strerror(errno) ));
411 status = map_nt_error_from_unix(errno);
414 notify_fname(conn, NOTIFY_ACTION_REMOVED,
415 FILE_NOTIFY_CHANGE_FILE_NAME,
418 /* As we now have POSIX opens which can unlink
419 * with other open files we may have taken
420 * this code path with more than one share mode
421 * entry - ensure we only delete once by resetting
422 * the delete on close flag. JRA.
425 set_delete_on_close_lck(lck, False, NULL);
438 void set_close_write_time(struct files_struct *fsp, struct timespec ts)
440 DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts))));
442 if (null_timespec(ts)) {
446 * if the write time on close is explict set, then don't
447 * need to fix it up to the value in the locking db
449 fsp->write_time_forced = false;
451 fsp->update_write_time_on_close = true;
452 fsp->close_write_time = ts;
455 static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
457 SMB_STRUCT_STAT sbuf;
458 struct timespec ts[2];
464 if (!fsp->update_write_time_on_close) {
468 if (null_timespec(fsp->close_write_time)) {
469 fsp->close_write_time = timespec_current();
472 /* Ensure we have a valid stat struct for the source. */
473 if (fsp->fh->fd != -1) {
474 if (SMB_VFS_FSTAT(fsp, &sbuf) == -1) {
475 return map_nt_error_from_unix(errno);
478 if (SMB_VFS_STAT(fsp->conn,fsp->fsp_name,&sbuf) == -1) {
479 return map_nt_error_from_unix(errno);
483 if (!VALID_STAT(sbuf)) {
484 /* if it doesn't seem to be a real file */
488 ts[1] = fsp->close_write_time;
489 status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name,
491 if (!NT_STATUS_IS_OK(status)) {
498 /****************************************************************************
501 close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
502 printing and magic scripts are only run on normal close.
503 delete on close is done on normal and shutdown close.
504 ****************************************************************************/
506 static NTSTATUS close_normal_file(struct smb_request *req, files_struct *fsp,
507 enum file_close_type close_type)
509 NTSTATUS status = NT_STATUS_OK;
510 NTSTATUS saved_status1 = NT_STATUS_OK;
511 NTSTATUS saved_status2 = NT_STATUS_OK;
512 NTSTATUS saved_status3 = NT_STATUS_OK;
513 NTSTATUS saved_status4 = NT_STATUS_OK;
514 connection_struct *conn = fsp->conn;
516 if (fsp->aio_write_behind) {
518 * If we're finishing write behind on a close we can get a write
519 * error here, we must remember this.
521 int ret = wait_for_aio_completion(fsp);
523 saved_status1 = map_nt_error_from_unix(ret);
526 cancel_aio_by_fsp(fsp);
530 * If we're flushing on a close we can get a write
531 * error here, we must remember this.
534 saved_status2 = close_filestruct(fsp);
536 if (fsp->print_file) {
537 print_fsp_end(fsp, close_type);
542 /* If this is an old DOS or FCB open and we have multiple opens on
543 the same handle we only have one share mode. Ensure we only remove
544 the share mode on the last close. */
546 if (fsp->fh->ref_count == 1) {
547 /* Should we return on error here... ? */
548 saved_status3 = close_remove_share_mode(fsp, close_type);
551 if(fsp->oplock_type) {
552 release_file_oplock(fsp);
555 locking_close_file(smbd_messaging_context(), fsp);
557 status = fd_close(fsp);
559 /* check for magic scripts */
560 if (close_type == NORMAL_CLOSE) {
565 * Ensure pending modtime is set after close.
568 saved_status4 = update_write_time_on_close(fsp);
570 if (NT_STATUS_IS_OK(status)) {
571 if (!NT_STATUS_IS_OK(saved_status1)) {
572 status = saved_status1;
573 } else if (!NT_STATUS_IS_OK(saved_status2)) {
574 status = saved_status2;
575 } else if (!NT_STATUS_IS_OK(saved_status3)) {
576 status = saved_status3;
577 } else if (!NT_STATUS_IS_OK(saved_status4)) {
578 status = saved_status4;
582 DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
583 conn->server_info->unix_name,fsp->fsp_name,
584 conn->num_files_open - 1,
585 nt_errstr(status) ));
591 /****************************************************************************
592 Close a directory opened by an NT SMB call.
593 ****************************************************************************/
595 static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp,
596 enum file_close_type close_type)
598 struct share_mode_lock *lck = 0;
599 bool delete_dir = False;
600 NTSTATUS status = NT_STATUS_OK;
603 * NT can set delete_on_close of the last open
604 * reference to a directory also.
607 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
611 DEBUG(0, ("close_directory: Could not get share mode lock for %s\n", fsp->fsp_name));
612 return NT_STATUS_INVALID_PARAMETER;
615 if (!del_share_mode(lck, fsp)) {
616 DEBUG(0, ("close_directory: Could not delete share entry for %s\n", fsp->fsp_name));
619 if (fsp->initial_delete_on_close) {
620 bool became_user = False;
622 /* Initial delete on close was set - for
623 * directories we don't care if anyone else
624 * wrote a real delete on close. */
626 if (current_user.vuid != fsp->vuid) {
627 become_user(fsp->conn, fsp->vuid);
630 send_stat_cache_delete_message(fsp->fsp_name);
631 set_delete_on_close_lck(lck, True, ¤t_user.ut);
637 delete_dir = lck->delete_on_close;
641 /* See if others still have the dir open. If this is the
642 * case, then don't delete. If all opens are POSIX delete now. */
643 for (i=0; i<lck->num_share_modes; i++) {
644 struct share_mode_entry *e = &lck->share_modes[i];
645 if (is_valid_share_mode_entry(e)) {
646 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
655 if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
659 /* Become the user who requested the delete. */
661 if (!push_sec_ctx()) {
662 smb_panic("close_directory: failed to push sec_ctx.\n");
665 set_sec_ctx(lck->delete_token->uid,
666 lck->delete_token->gid,
667 lck->delete_token->ngroups,
668 lck->delete_token->groups,
673 status = rmdir_internals(talloc_tos(),
674 fsp->conn, fsp->fsp_name);
676 DEBUG(5,("close_directory: %s. Delete on close was set - "
677 "deleting directory returned %s.\n",
678 fsp->fsp_name, nt_errstr(status)));
684 * Ensure we remove any change notify requests that would
685 * now fail as the directory has been deleted.
688 if(NT_STATUS_IS_OK(status)) {
689 remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING);
693 remove_pending_change_notify_requests_by_fid(
698 * Do the code common to files and directories.
700 close_filestruct(fsp);
705 /****************************************************************************
706 Close a files_struct.
707 ****************************************************************************/
709 NTSTATUS close_file(struct smb_request *req, files_struct *fsp,
710 enum file_close_type close_type)
713 struct files_struct *base_fsp = fsp->base_fsp;
715 if(fsp->is_directory) {
716 status = close_directory(req, fsp, close_type);
717 } else if (fsp->fake_file_handle != NULL) {
718 status = close_fake_file(req, fsp);
720 status = close_normal_file(req, fsp, close_type);
723 if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) {
726 * fsp was a stream, the base fsp can't be a stream as well
728 * For SHUTDOWN_CLOSE this is not possible here, because
729 * SHUTDOWN_CLOSE only happens from files.c which walks the
730 * complete list of files. If we mess with more than one fsp
731 * those loops will become confused.
734 SMB_ASSERT(base_fsp->base_fsp == NULL);
735 close_file(req, base_fsp, close_type);
741 /****************************************************************************
742 Deal with an (authorized) message to close a file given the share mode
744 ****************************************************************************/
746 void msg_close_file(struct messaging_context *msg_ctx,
749 struct server_id server_id,
752 files_struct *fsp = NULL;
753 struct share_mode_entry e;
755 message_to_share_mode_entry(&e, (char *)data->data);
758 char *sm_str = share_mode_str(NULL, 0, &e);
760 smb_panic("talloc failed");
762 DEBUG(10,("msg_close_file: got request to close share mode "
763 "entry %s\n", sm_str));
767 fsp = file_find_dif(e.id, e.share_file_id);
769 DEBUG(10,("msg_close_file: failed to find file.\n"));
772 close_file(NULL, fsp, NORMAL_CLOSE);