wins: fix null pointer crash in nss_wins module.
[Samba.git] / source / smbd / close.c
blob3afc037f69cd6d50ac28c4b5cee484052a3e0b33
1 /*
2 Unix SMB/CIFS implementation.
3 file closing
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/>.
22 #include "includes.h"
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)
32 int ret;
33 const char *magic_output = NULL;
34 SMB_STRUCT_STAT st;
35 int tmp_fd, outfd;
36 TALLOC_CTX *ctx = NULL;
37 const char *p;
38 struct connection_struct *conn = fsp->conn;
40 if (!*lp_magicscript(SNUM(conn))) {
41 return;
44 DEBUG(5,("checking magic for %s\n",fsp->fsp_name));
46 if (!(p = strrchr_m(fsp->fsp_name,'/'))) {
47 p = fsp->fsp_name;
48 } else {
49 p++;
52 if (!strequal(lp_magicscript(SNUM(conn)),p)) {
53 return;
56 ctx = talloc_stackframe();
58 if (*lp_magicoutput(SNUM(conn))) {
59 magic_output = lp_magicoutput(SNUM(conn));
60 } else {
61 magic_output = talloc_asprintf(ctx,
62 "%s.out",
63 fsp->fsp_name);
65 if (!magic_output) {
66 TALLOC_FREE(ctx);
67 return;
70 chmod(fsp->fsp_name,0755);
71 ret = smbrun(fsp->fsp_name,&tmp_fd);
72 DEBUG(3,("Invoking magic command %s gave %d\n",
73 fsp->fsp_name,ret));
75 unlink(fsp->fsp_name);
76 if (ret != 0 || tmp_fd == -1) {
77 if (tmp_fd != -1) {
78 close(tmp_fd);
80 TALLOC_FREE(ctx);
81 return;
83 outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
84 if (outfd == -1) {
85 close(tmp_fd);
86 TALLOC_FREE(ctx);
87 return;
90 if (sys_fstat(tmp_fd,&st) == -1) {
91 close(tmp_fd);
92 close(outfd);
93 return;
96 transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_size);
97 close(tmp_fd);
98 close(outfd);
99 TALLOC_FREE(ctx);
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;
109 connection_struct *conn = fsp->conn;
111 if (fsp->fh->fd != -1) {
112 if(flush_write_cache(fsp, CLOSE_FLUSH) == -1) {
113 status = map_nt_error_from_unix(errno);
115 delete_write_cache(fsp);
118 conn->num_files_open--;
119 return status;
122 /****************************************************************************
123 If any deferred opens are waiting on this close, notify them.
124 ****************************************************************************/
126 static void notify_deferred_opens(struct share_mode_lock *lck)
128 int i;
130 for (i=0; i<lck->num_share_modes; i++) {
131 struct share_mode_entry *e = &lck->share_modes[i];
133 if (!is_deferred_open_entry(e)) {
134 continue;
137 if (procid_is_me(&e->pid)) {
139 * We need to notify ourself to retry the open. Do
140 * this by finding the queued SMB record, moving it to
141 * the head of the queue and changing the wait time to
142 * zero.
144 schedule_deferred_open_smb_message(e->op_mid);
145 } else {
146 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
148 share_mode_entry_to_message(msg, e);
150 messaging_send_buf(smbd_messaging_context(),
151 e->pid, MSG_SMB_OPEN_RETRY,
152 (uint8 *)msg,
153 MSG_SMB_SHARE_MODE_ENTRY_SIZE);
158 /****************************************************************************
159 Delete all streams
160 ****************************************************************************/
162 static NTSTATUS delete_all_streams(connection_struct *conn, const char *fname)
164 struct stream_struct *stream_info;
165 int i;
166 unsigned int num_streams;
167 TALLOC_CTX *frame = talloc_stackframe();
168 NTSTATUS status;
170 status = SMB_VFS_STREAMINFO(conn, NULL, fname, talloc_tos(),
171 &num_streams, &stream_info);
173 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
174 DEBUG(10, ("no streams around\n"));
175 TALLOC_FREE(frame);
176 return NT_STATUS_OK;
179 if (!NT_STATUS_IS_OK(status)) {
180 DEBUG(10, ("SMB_VFS_STREAMINFO failed: %s\n",
181 nt_errstr(status)));
182 goto fail;
185 DEBUG(10, ("delete_all_streams found %d streams\n",
186 num_streams));
188 if (num_streams == 0) {
189 TALLOC_FREE(frame);
190 return NT_STATUS_OK;
193 for (i=0; i<num_streams; i++) {
194 int res;
195 char *streamname;
197 if (strequal(stream_info[i].name, "::$DATA")) {
198 continue;
201 streamname = talloc_asprintf(talloc_tos(), "%s%s", fname,
202 stream_info[i].name);
204 if (streamname == NULL) {
205 DEBUG(0, ("talloc_aprintf failed\n"));
206 status = NT_STATUS_NO_MEMORY;
207 goto fail;
210 res = SMB_VFS_UNLINK(conn, streamname);
212 TALLOC_FREE(streamname);
214 if (res == -1) {
215 status = map_nt_error_from_unix(errno);
216 DEBUG(10, ("Could not delete stream %s: %s\n",
217 streamname, strerror(errno)));
218 break;
222 fail:
223 TALLOC_FREE(frame);
224 return status;
227 /****************************************************************************
228 Deal with removing a share mode on last close.
229 ****************************************************************************/
231 static NTSTATUS close_remove_share_mode(files_struct *fsp,
232 enum file_close_type close_type)
234 connection_struct *conn = fsp->conn;
235 bool delete_file = false;
236 bool changed_user = false;
237 struct share_mode_lock *lck;
238 SMB_STRUCT_STAT sbuf;
239 NTSTATUS status = NT_STATUS_OK;
240 int ret;
241 struct file_id id;
244 * Lock the share entries, and determine if we should delete
245 * on close. If so delete whilst the lock is still in effect.
246 * This prevents race conditions with the file being created. JRA.
249 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
250 NULL);
252 if (lck == NULL) {
253 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
254 "lock for file %s\n", fsp->fsp_name));
255 return NT_STATUS_INVALID_PARAMETER;
258 if (fsp->write_time_forced) {
259 set_close_write_time(fsp, lck->changed_write_time);
262 if (!del_share_mode(lck, fsp)) {
263 DEBUG(0, ("close_remove_share_mode: Could not delete share "
264 "entry for file %s\n", fsp->fsp_name));
267 if (fsp->initial_delete_on_close && (lck->delete_token == NULL)) {
268 bool became_user = False;
270 /* Initial delete on close was set and no one else
271 * wrote a real delete on close. */
273 if (current_user.vuid != fsp->vuid) {
274 become_user(conn, fsp->vuid);
275 became_user = True;
277 set_delete_on_close_lck(lck, True, &current_user.ut);
278 if (became_user) {
279 unbecome_user();
283 delete_file = lck->delete_on_close;
285 if (delete_file) {
286 int i;
287 /* See if others still have the file open. If this is the
288 * case, then don't delete. If all opens are POSIX delete now. */
289 for (i=0; i<lck->num_share_modes; i++) {
290 struct share_mode_entry *e = &lck->share_modes[i];
291 if (is_valid_share_mode_entry(e)) {
292 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
293 continue;
295 delete_file = False;
296 break;
301 /* Notify any deferred opens waiting on this close. */
302 notify_deferred_opens(lck);
303 reply_to_oplock_break_requests(fsp);
306 * NT can set delete_on_close of the last open
307 * reference to a file.
310 if (!(close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE)
311 || !delete_file
312 || (lck->delete_token == NULL)) {
313 TALLOC_FREE(lck);
314 return NT_STATUS_OK;
318 * Ok, we have to delete the file
321 DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
322 "- deleting file.\n", fsp->fsp_name));
325 * Don't try to update the write time when we delete the file
327 fsp->update_write_time_on_close = false;
329 if (!unix_token_equal(lck->delete_token, &current_user.ut)) {
330 /* Become the user who requested the delete. */
332 DEBUG(5,("close_remove_share_mode: file %s. "
333 "Change user to uid %u\n",
334 fsp->fsp_name,
335 (unsigned int)lck->delete_token->uid));
337 if (!push_sec_ctx()) {
338 smb_panic("close_remove_share_mode: file %s. failed to push "
339 "sec_ctx.\n");
342 set_sec_ctx(lck->delete_token->uid,
343 lck->delete_token->gid,
344 lck->delete_token->ngroups,
345 lck->delete_token->groups,
346 NULL);
348 changed_user = true;
351 /* We can only delete the file if the name we have is still valid and
352 hasn't been renamed. */
354 if (fsp->posix_open) {
355 ret = SMB_VFS_LSTAT(conn,fsp->fsp_name,&sbuf);
356 } else {
357 ret = SMB_VFS_STAT(conn,fsp->fsp_name,&sbuf);
360 if (ret != 0) {
361 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
362 "was set and stat failed with error %s\n",
363 fsp->fsp_name, strerror(errno) ));
365 * Don't save the errno here, we ignore this error
367 goto done;
370 id = vfs_file_id_from_sbuf(conn, &sbuf);
372 if (!file_id_equal(&fsp->file_id, &id)) {
373 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
374 "was set and dev and/or inode does not match\n",
375 fsp->fsp_name ));
376 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
377 "stat file_id %s\n",
378 fsp->fsp_name,
379 file_id_string_tos(&fsp->file_id),
380 file_id_string_tos(&id)));
382 * Don't save the errno here, we ignore this error
384 goto done;
387 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
388 && !is_ntfs_stream_name(fsp->fsp_name)) {
390 status = delete_all_streams(conn, fsp->fsp_name);
392 if (!NT_STATUS_IS_OK(status)) {
393 DEBUG(5, ("delete_all_streams failed: %s\n",
394 nt_errstr(status)));
395 goto done;
400 if (SMB_VFS_UNLINK(conn,fsp->fsp_name) != 0) {
402 * This call can potentially fail as another smbd may
403 * have had the file open with delete on close set and
404 * deleted it when its last reference to this file
405 * went away. Hence we log this but not at debug level
406 * zero.
409 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
410 "was set and unlink failed with error %s\n",
411 fsp->fsp_name, strerror(errno) ));
413 status = map_nt_error_from_unix(errno);
416 notify_fname(conn, NOTIFY_ACTION_REMOVED,
417 FILE_NOTIFY_CHANGE_FILE_NAME,
418 fsp->fsp_name);
420 /* As we now have POSIX opens which can unlink
421 * with other open files we may have taken
422 * this code path with more than one share mode
423 * entry - ensure we only delete once by resetting
424 * the delete on close flag. JRA.
427 set_delete_on_close_lck(lck, False, NULL);
429 done:
431 if (changed_user) {
432 /* unbecome user. */
433 pop_sec_ctx();
436 TALLOC_FREE(lck);
437 return status;
440 void set_close_write_time(struct files_struct *fsp, struct timespec ts)
442 DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts))));
444 if (null_timespec(ts)) {
445 return;
448 * if the write time on close is explict set, then don't
449 * need to fix it up to the value in the locking db
451 fsp->write_time_forced = false;
453 fsp->update_write_time_on_close = true;
454 fsp->close_write_time = ts;
457 static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
459 SMB_STRUCT_STAT sbuf;
460 struct timespec ts[2];
461 NTSTATUS status;
463 ZERO_STRUCT(sbuf);
464 ZERO_STRUCT(ts);
466 if (!fsp->update_write_time_on_close) {
467 return NT_STATUS_OK;
470 if (null_timespec(fsp->close_write_time)) {
471 fsp->close_write_time = timespec_current();
474 /* Ensure we have a valid stat struct for the source. */
475 if (fsp->fh->fd != -1) {
476 if (SMB_VFS_FSTAT(fsp, &sbuf) == -1) {
477 return map_nt_error_from_unix(errno);
479 } else {
480 if (SMB_VFS_STAT(fsp->conn,fsp->fsp_name,&sbuf) == -1) {
481 return map_nt_error_from_unix(errno);
485 if (!VALID_STAT(sbuf)) {
486 /* if it doesn't seem to be a real file */
487 return NT_STATUS_OK;
490 ts[1] = fsp->close_write_time;
491 status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name,
492 &sbuf, ts, true);
493 if (!NT_STATUS_IS_OK(status)) {
494 return status;
497 return NT_STATUS_OK;
500 /****************************************************************************
501 Close a file.
503 close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
504 printing and magic scripts are only run on normal close.
505 delete on close is done on normal and shutdown close.
506 ****************************************************************************/
508 static NTSTATUS close_normal_file(files_struct *fsp, enum file_close_type close_type)
510 NTSTATUS status = NT_STATUS_OK;
511 NTSTATUS saved_status1 = NT_STATUS_OK;
512 NTSTATUS saved_status2 = NT_STATUS_OK;
513 NTSTATUS saved_status3 = NT_STATUS_OK;
514 NTSTATUS saved_status4 = NT_STATUS_OK;
515 connection_struct *conn = fsp->conn;
517 if (fsp->aio_write_behind) {
519 * If we're finishing write behind on a close we can get a write
520 * error here, we must remember this.
522 int ret = wait_for_aio_completion(fsp);
523 if (ret) {
524 saved_status1 = map_nt_error_from_unix(ret);
526 } else {
527 cancel_aio_by_fsp(fsp);
531 * If we're flushing on a close we can get a write
532 * error here, we must remember this.
535 saved_status2 = close_filestruct(fsp);
537 if (fsp->print_file) {
538 print_fsp_end(fsp, close_type);
539 file_free(fsp);
540 return NT_STATUS_OK;
543 /* If this is an old DOS or FCB open and we have multiple opens on
544 the same handle we only have one share mode. Ensure we only remove
545 the share mode on the last close. */
547 if (fsp->fh->ref_count == 1) {
548 /* Should we return on error here... ? */
549 saved_status3 = close_remove_share_mode(fsp, close_type);
552 if(fsp->oplock_type) {
553 release_file_oplock(fsp);
556 locking_close_file(smbd_messaging_context(), fsp);
558 status = fd_close(fsp);
560 /* check for magic scripts */
561 if (close_type == NORMAL_CLOSE) {
562 check_magic(fsp);
566 * Ensure pending modtime is set after close.
569 saved_status4 = update_write_time_on_close(fsp);
571 if (NT_STATUS_IS_OK(status)) {
572 if (!NT_STATUS_IS_OK(saved_status1)) {
573 status = saved_status1;
574 } else if (!NT_STATUS_IS_OK(saved_status2)) {
575 status = saved_status2;
576 } else if (!NT_STATUS_IS_OK(saved_status3)) {
577 status = saved_status3;
578 } else if (!NT_STATUS_IS_OK(saved_status4)) {
579 status = saved_status4;
583 DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
584 conn->user,fsp->fsp_name,
585 conn->num_files_open,
586 nt_errstr(status) ));
588 file_free(fsp);
589 return status;
592 /****************************************************************************
593 Close a directory opened by an NT SMB call.
594 ****************************************************************************/
596 static NTSTATUS close_directory(files_struct *fsp, 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,
608 NULL);
610 if (lck == 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);
628 became_user = True;
630 send_stat_cache_delete_message(fsp->fsp_name);
631 set_delete_on_close_lck(lck, True, &current_user.ut);
632 if (became_user) {
633 unbecome_user();
637 delete_dir = lck->delete_on_close;
639 if (delete_dir) {
640 int i;
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)) {
647 continue;
649 delete_dir = False;
650 break;
655 if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
656 delete_dir &&
657 lck->delete_token) {
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,
669 NULL);
671 TALLOC_FREE(lck);
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)));
680 /* unbecome user. */
681 pop_sec_ctx();
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);
691 } else {
692 TALLOC_FREE(lck);
693 remove_pending_change_notify_requests_by_fid(
694 fsp, NT_STATUS_OK);
698 * Do the code common to files and directories.
700 close_filestruct(fsp);
701 file_free(fsp);
702 return status;
705 /****************************************************************************
706 Close a 'stat file' opened internally.
707 ****************************************************************************/
709 static NTSTATUS close_stat(files_struct *fsp)
712 * Do the code common to files and directories.
714 close_filestruct(fsp);
715 file_free(fsp);
716 return NT_STATUS_OK;
719 /****************************************************************************
720 Close a files_struct.
721 ****************************************************************************/
723 NTSTATUS close_file(files_struct *fsp, enum file_close_type close_type)
725 NTSTATUS status;
726 struct files_struct *base_fsp = fsp->base_fsp;
728 if(fsp->is_directory) {
729 status = close_directory(fsp, close_type);
730 } else if (fsp->is_stat) {
731 status = close_stat(fsp);
732 } else if (fsp->fake_file_handle != NULL) {
733 status = close_fake_file(fsp);
734 } else {
735 status = close_normal_file(fsp, close_type);
738 if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) {
741 * fsp was a stream, the base fsp can't be a stream as well
743 * For SHUTDOWN_CLOSE this is not possible here, because
744 * SHUTDOWN_CLOSE only happens from files.c which walks the
745 * complete list of files. If we mess with more than one fsp
746 * those loops will become confused.
749 SMB_ASSERT(base_fsp->base_fsp == NULL);
750 close_file(base_fsp, close_type);
753 return status;