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(files_struct
*fsp
, enum file_close_type close_type
)
508 NTSTATUS status
= NT_STATUS_OK
;
509 NTSTATUS saved_status1
= NT_STATUS_OK
;
510 NTSTATUS saved_status2
= NT_STATUS_OK
;
511 NTSTATUS saved_status3
= NT_STATUS_OK
;
512 NTSTATUS saved_status4
= NT_STATUS_OK
;
513 connection_struct
*conn
= fsp
->conn
;
515 if (fsp
->aio_write_behind
) {
517 * If we're finishing write behind on a close we can get a write
518 * error here, we must remember this.
520 int ret
= wait_for_aio_completion(fsp
);
522 saved_status1
= map_nt_error_from_unix(ret
);
525 cancel_aio_by_fsp(fsp
);
529 * If we're flushing on a close we can get a write
530 * error here, we must remember this.
533 saved_status2
= close_filestruct(fsp
);
535 if (fsp
->print_file
) {
536 print_fsp_end(fsp
, close_type
);
541 /* If this is an old DOS or FCB open and we have multiple opens on
542 the same handle we only have one share mode. Ensure we only remove
543 the share mode on the last close. */
545 if (fsp
->fh
->ref_count
== 1) {
546 /* Should we return on error here... ? */
547 saved_status3
= close_remove_share_mode(fsp
, close_type
);
550 if(fsp
->oplock_type
) {
551 release_file_oplock(fsp
);
554 locking_close_file(smbd_messaging_context(), fsp
);
556 status
= fd_close(fsp
);
558 /* check for magic scripts */
559 if (close_type
== NORMAL_CLOSE
) {
564 * Ensure pending modtime is set after close.
567 saved_status4
= update_write_time_on_close(fsp
);
569 if (NT_STATUS_IS_OK(status
)) {
570 if (!NT_STATUS_IS_OK(saved_status1
)) {
571 status
= saved_status1
;
572 } else if (!NT_STATUS_IS_OK(saved_status2
)) {
573 status
= saved_status2
;
574 } else if (!NT_STATUS_IS_OK(saved_status3
)) {
575 status
= saved_status3
;
576 } else if (!NT_STATUS_IS_OK(saved_status4
)) {
577 status
= saved_status4
;
581 DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
582 conn
->user
,fsp
->fsp_name
,
583 conn
->num_files_open
- 1,
584 nt_errstr(status
) ));
590 /****************************************************************************
591 Close a directory opened by an NT SMB call.
592 ****************************************************************************/
594 static NTSTATUS
close_directory(files_struct
*fsp
, enum file_close_type close_type
)
596 struct share_mode_lock
*lck
= 0;
597 bool delete_dir
= False
;
598 NTSTATUS status
= NT_STATUS_OK
;
601 * NT can set delete_on_close of the last open
602 * reference to a directory also.
605 lck
= get_share_mode_lock(talloc_tos(), fsp
->file_id
, NULL
, NULL
,
609 DEBUG(0, ("close_directory: Could not get share mode lock for %s\n", fsp
->fsp_name
));
610 return NT_STATUS_INVALID_PARAMETER
;
613 if (!del_share_mode(lck
, fsp
)) {
614 DEBUG(0, ("close_directory: Could not delete share entry for %s\n", fsp
->fsp_name
));
617 if (fsp
->initial_delete_on_close
) {
618 bool became_user
= False
;
620 /* Initial delete on close was set - for
621 * directories we don't care if anyone else
622 * wrote a real delete on close. */
624 if (current_user
.vuid
!= fsp
->vuid
) {
625 become_user(fsp
->conn
, fsp
->vuid
);
628 send_stat_cache_delete_message(fsp
->fsp_name
);
629 set_delete_on_close_lck(lck
, True
, ¤t_user
.ut
);
635 delete_dir
= lck
->delete_on_close
;
639 /* See if others still have the dir open. If this is the
640 * case, then don't delete. If all opens are POSIX delete now. */
641 for (i
=0; i
<lck
->num_share_modes
; i
++) {
642 struct share_mode_entry
*e
= &lck
->share_modes
[i
];
643 if (is_valid_share_mode_entry(e
)) {
644 if (fsp
->posix_open
&& (e
->flags
& SHARE_MODE_FLAG_POSIX_OPEN
)) {
653 if ((close_type
== NORMAL_CLOSE
|| close_type
== SHUTDOWN_CLOSE
) &&
657 /* Become the user who requested the delete. */
659 if (!push_sec_ctx()) {
660 smb_panic("close_directory: failed to push sec_ctx.\n");
663 set_sec_ctx(lck
->delete_token
->uid
,
664 lck
->delete_token
->gid
,
665 lck
->delete_token
->ngroups
,
666 lck
->delete_token
->groups
,
671 status
= rmdir_internals(talloc_tos(),
672 fsp
->conn
, fsp
->fsp_name
);
674 DEBUG(5,("close_directory: %s. Delete on close was set - "
675 "deleting directory returned %s.\n",
676 fsp
->fsp_name
, nt_errstr(status
)));
682 * Ensure we remove any change notify requests that would
683 * now fail as the directory has been deleted.
686 if(NT_STATUS_IS_OK(status
)) {
687 remove_pending_change_notify_requests_by_fid(fsp
, NT_STATUS_DELETE_PENDING
);
691 remove_pending_change_notify_requests_by_fid(
696 * Do the code common to files and directories.
698 close_filestruct(fsp
);
703 /****************************************************************************
704 Close a 'stat file' opened internally.
705 ****************************************************************************/
707 static NTSTATUS
close_stat(files_struct
*fsp
)
710 * Do the code common to files and directories.
712 close_filestruct(fsp
);
717 /****************************************************************************
718 Close a files_struct.
719 ****************************************************************************/
721 NTSTATUS
close_file(files_struct
*fsp
, enum file_close_type close_type
)
724 struct files_struct
*base_fsp
= fsp
->base_fsp
;
726 if(fsp
->is_directory
) {
727 status
= close_directory(fsp
, close_type
);
728 } else if (fsp
->is_stat
) {
729 status
= close_stat(fsp
);
730 } else if (fsp
->fake_file_handle
!= NULL
) {
731 status
= close_fake_file(fsp
);
733 status
= close_normal_file(fsp
, close_type
);
736 if ((base_fsp
!= NULL
) && (close_type
!= SHUTDOWN_CLOSE
)) {
739 * fsp was a stream, the base fsp can't be a stream as well
741 * For SHUTDOWN_CLOSE this is not possible here, because
742 * SHUTDOWN_CLOSE only happens from files.c which walks the
743 * complete list of files. If we mess with more than one fsp
744 * those loops will become confused.
747 SMB_ASSERT(base_fsp
->base_fsp
== NULL
);
748 close_file(base_fsp
, close_type
);
754 /****************************************************************************
755 Deal with an (authorized) message to close a file given the share mode
757 ****************************************************************************/
759 void msg_close_file(struct messaging_context
*msg_ctx
,
762 struct server_id server_id
,
765 files_struct
*fsp
= NULL
;
766 struct share_mode_entry e
;
768 message_to_share_mode_entry(&e
, (char *)data
->data
);
771 char *sm_str
= share_mode_str(NULL
, 0, &e
);
773 smb_panic("talloc failed");
775 DEBUG(10,("msg_close_file: got request to close share mode "
776 "entry %s\n", sm_str
));
780 fsp
= file_find_dif(e
.id
, e
.share_file_id
);
782 DEBUG(10,("msg_close_file: failed to find file.\n"));
785 close_file(fsp
, NORMAL_CLOSE
);