?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
smbd: Remove the unused fsp->pending_break_messages array
[Samba/bjacke.git] / source3 / smbd / close.c
blob3389649226edccb0c13a332bbacac24c8c964d7c
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
7
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.
12
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.
17
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/>.
20 */
21
22 #include "includes.h"
23 #include "system/filesys.h"
24 #include "printing.h"
25 #include "smbd/smbd.h"
26 #include "smbd/globals.h"
27 #include "smbd/scavenger.h"
28 #include "fake_file.h"
29 #include "transfer_file.h"
30 #include "auth.h"
31 #include "messages.h"
32 #include "../librpc/gen_ndr/open_files.h"
33
34 /****************************************************************************
35 Run a file if it is a magic script.
36 ****************************************************************************/
37
38 static NTSTATUS check_magic(struct files_struct *fsp)
39 {
40 int ret;
41 const char *magic_output = NULL;
42 SMB_STRUCT_STAT st;
43 int tmp_fd, outfd;
44 TALLOC_CTX *ctx = NULL;
45 const char *p;
46 struct connection_struct *conn = fsp->conn;
47 char *fname = NULL;
48 NTSTATUS status;
49
50 if (!*lp_magicscript(talloc_tos(), SNUM(conn))) {
51 return NT_STATUS_OK;
52 }
53
54 DEBUG(5,("checking magic for %s\n", fsp_str_dbg(fsp)));
55
56 ctx = talloc_stackframe();
57
58 fname = fsp->fsp_name->base_name;
59
60 if (!(p = strrchr_m(fname,'/'))) {
61 p = fname;
62 } else {
63 p++;
64 }
65
66 if (!strequal(lp_magicscript(talloc_tos(), SNUM(conn)),p)) {
67 status = NT_STATUS_OK;
68 goto out;
69 }
70
71 if (*lp_magicoutput(talloc_tos(), SNUM(conn))) {
72 magic_output = lp_magicoutput(talloc_tos(), SNUM(conn));
73 } else {
74 magic_output = talloc_asprintf(ctx,
75 "%s.out",
76 fname);
77 }
78 if (!magic_output) {
79 status = NT_STATUS_NO_MEMORY;
80 goto out;
81 }
82
83 /* Ensure we don't depend on user's PATH. */
84 p = talloc_asprintf(ctx, "./%s", fname);
85 if (!p) {
86 status = NT_STATUS_NO_MEMORY;
87 goto out;
88 }
89
90 if (chmod(fname, 0755) == -1) {
91 status = map_nt_error_from_unix(errno);
92 goto out;
93 }
94 ret = smbrun(p,&tmp_fd);
95 DEBUG(3,("Invoking magic command %s gave %d\n",
96 p,ret));
97
98 unlink(fname);
99 if (ret != 0 || tmp_fd == -1) {
100 if (tmp_fd != -1) {
101 close(tmp_fd);
102 }
103 status = NT_STATUS_UNSUCCESSFUL;
104 goto out;
105 }
106 outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
107 if (outfd == -1) {
108 int err = errno;
109 close(tmp_fd);
110 status = map_nt_error_from_unix(err);
111 goto out;
112 }
113
114 if (sys_fstat(tmp_fd, &st, false) == -1) {
115 int err = errno;
116 close(tmp_fd);
117 close(outfd);
118 status = map_nt_error_from_unix(err);
119 goto out;
120 }
121
122 if (transfer_file(tmp_fd,outfd,(off_t)st.st_ex_size) == (off_t)-1) {
123 int err = errno;
124 close(tmp_fd);
125 close(outfd);
126 status = map_nt_error_from_unix(err);
127 goto out;
128 }
129 close(tmp_fd);
130 if (close(outfd) == -1) {
131 status = map_nt_error_from_unix(errno);
132 goto out;
133 }
134
135 status = NT_STATUS_OK;
136
137 out:
138 TALLOC_FREE(ctx);
139 return status;
140 }
141
142 /****************************************************************************
143 Common code to close a file or a directory.
144 ****************************************************************************/
145
146 static NTSTATUS close_filestruct(files_struct *fsp)
147 {
148 NTSTATUS status = NT_STATUS_OK;
149
150 if (fsp->fh->fd != -1) {
151 if(flush_write_cache(fsp, CLOSE_FLUSH) == -1) {
152 status = map_nt_error_from_unix(errno);
153 }
154 delete_write_cache(fsp);
155 }
156
157 return status;
158 }
159
160 static int compare_share_mode_times(const void *p1, const void *p2)
161 {
162 const struct share_mode_entry *s1 = (const struct share_mode_entry *)p1;
163 const struct share_mode_entry *s2 = (const struct share_mode_entry *)p2;
164 return timeval_compare(&s1->time, &s2->time);
165 }
166
167 /****************************************************************************
168 If any deferred opens are waiting on this close, notify them.
169 ****************************************************************************/
170
171 static void notify_deferred_opens(struct smbd_server_connection *sconn,
172 struct share_mode_lock *lck)
173 {
174 struct server_id self = messaging_server_id(sconn->msg_ctx);
175 uint32_t i, num_deferred;
176 struct share_mode_entry *deferred;
177
178 if (!should_notify_deferred_opens(sconn)) {
179 return;
180 }
181
182 num_deferred = 0;
183 for (i=0; i<lck->data->num_share_modes; i++) {
184 struct share_mode_entry *e = &lck->data->share_modes[i];
185
186 if (!is_deferred_open_entry(e)) {
187 continue;
188 }
189 if (share_mode_stale_pid(lck->data, i)) {
190 continue;
191 }
192 num_deferred += 1;
193 }
194 if (num_deferred == 0) {
195 return;
196 }
197
198 deferred = talloc_array(talloc_tos(), struct share_mode_entry,
199 num_deferred);
200 if (deferred == NULL) {
201 return;
202 }
203
204 num_deferred = 0;
205 for (i=0; i<lck->data->num_share_modes; i++) {
206 struct share_mode_entry *e = &lck->data->share_modes[i];
207 if (is_deferred_open_entry(e)) {
208 deferred[num_deferred] = *e;
209 num_deferred += 1;
210 }
211 }
212
213 /*
214 * We need to sort the notifications by initial request time. Imagine
215 * two opens come in asyncronously, both conflicting with the open we
216 * just close here. If we don't sort the notifications, the one that
217 * came in last might get the response before the one that came in
218 * first. This is demonstrated with the smbtorture4 raw.mux test.
219 *
220 * As long as we had the UNUSED_SHARE_MODE_ENTRY, we happened to
221 * survive this particular test. Without UNUSED_SHARE_MODE_ENTRY, we
222 * shuffle the share mode entries around a bit, so that we do not
223 * survive raw.mux anymore.
224 *
225 * We could have kept the ordering in del_share_mode, but as the
226 * ordering was never formalized I think it is better to do it here
227 * where it is necessary.
228 */
229
230 qsort(deferred, num_deferred, sizeof(struct share_mode_entry),
231 compare_share_mode_times);
232
233 for (i=0; i<num_deferred; i++) {
234 struct share_mode_entry *e = &deferred[i];
235
236 if (serverid_equal(&self, &e->pid)) {
237 /*
238 * We need to notify ourself to retry the open. Do
239 * this by finding the queued SMB record, moving it to
240 * the head of the queue and changing the wait time to
241 * zero.
242 */
243 schedule_deferred_open_message_smb(sconn, e->op_mid);
244 } else {
245 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
246
247 share_mode_entry_to_message(msg, e);
248
249 messaging_send_buf(sconn->msg_ctx, e->pid,
250 MSG_SMB_OPEN_RETRY,
251 (uint8 *)msg,
252 MSG_SMB_SHARE_MODE_ENTRY_SIZE);
253 }
254 }
255 TALLOC_FREE(deferred);
256 }
257
258 /****************************************************************************
259 Delete all streams
260 ****************************************************************************/
261
262 NTSTATUS delete_all_streams(connection_struct *conn, const char *fname)
263 {
264 struct stream_struct *stream_info = NULL;
265 int i;
266 unsigned int num_streams = 0;
267 TALLOC_CTX *frame = talloc_stackframe();
268 NTSTATUS status;
269
270 status = vfs_streaminfo(conn, NULL, fname, talloc_tos(),
271 &num_streams, &stream_info);
272
273 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
274 DEBUG(10, ("no streams around\n"));
275 TALLOC_FREE(frame);
276 return NT_STATUS_OK;
277 }
278
279 if (!NT_STATUS_IS_OK(status)) {
280 DEBUG(10, ("vfs_streaminfo failed: %s\n",
281 nt_errstr(status)));
282 goto fail;
283 }
284
285 DEBUG(10, ("delete_all_streams found %d streams\n",
286 num_streams));
287
288 if (num_streams == 0) {
289 TALLOC_FREE(frame);
290 return NT_STATUS_OK;
291 }
292
293 for (i=0; i<num_streams; i++) {
294 int res;
295 struct smb_filename *smb_fname_stream;
296
297 if (strequal(stream_info[i].name, "::$DATA")) {
298 continue;
299 }
300
301 smb_fname_stream = synthetic_smb_fname(
302 talloc_tos(), fname, stream_info[i].name, NULL);
303
304 if (smb_fname_stream == NULL) {
305 DEBUG(0, ("talloc_aprintf failed\n"));
306 status = NT_STATUS_NO_MEMORY;
307 goto fail;
308 }
309
310 res = SMB_VFS_UNLINK(conn, smb_fname_stream);
311
312 if (res == -1) {
313 status = map_nt_error_from_unix(errno);
314 DEBUG(10, ("Could not delete stream %s: %s\n",
315 smb_fname_str_dbg(smb_fname_stream),
316 strerror(errno)));
317 TALLOC_FREE(smb_fname_stream);
318 break;
319 }
320 TALLOC_FREE(smb_fname_stream);
321 }
322
323 fail:
324 TALLOC_FREE(frame);
325 return status;
326 }
327
328 /****************************************************************************
329 Deal with removing a share mode on last close.
330 ****************************************************************************/
331
332 static NTSTATUS close_remove_share_mode(files_struct *fsp,
333 enum file_close_type close_type)
334 {
335 connection_struct *conn = fsp->conn;
336 struct server_id self = messaging_server_id(conn->sconn->msg_ctx);
337 bool delete_file = false;
338 bool changed_user = false;
339 struct share_mode_lock *lck = NULL;
340 NTSTATUS status = NT_STATUS_OK;
341 NTSTATUS tmp_status;
342 struct file_id id;
343 const struct security_unix_token *del_token = NULL;
344 const struct security_token *del_nt_token = NULL;
345 bool got_tokens = false;
346 bool normal_close;
347
348 /* Ensure any pending write time updates are done. */
349 if (fsp->update_write_time_event) {
350 update_write_time_handler(fsp->conn->sconn->ev_ctx,
351 fsp->update_write_time_event,
352 timeval_current(),
353 (void *)fsp);
354 }
355
356 /*
357 * Lock the share entries, and determine if we should delete
358 * on close. If so delete whilst the lock is still in effect.
359 * This prevents race conditions with the file being created. JRA.
360 */
361
362 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
363 if (lck == NULL) {
364 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
365 "lock for file %s\n", fsp_str_dbg(fsp)));
366 return NT_STATUS_INVALID_PARAMETER;
367 }
368
369 if (fsp->write_time_forced) {
370 DEBUG(10,("close_remove_share_mode: write time forced "
371 "for file %s\n",
372 fsp_str_dbg(fsp)));
373 set_close_write_time(fsp, lck->data->changed_write_time);
374 } else if (fsp->update_write_time_on_close) {
375 /* Someone had a pending write. */
376 if (null_timespec(fsp->close_write_time)) {
377 DEBUG(10,("close_remove_share_mode: update to current time "
378 "for file %s\n",
379 fsp_str_dbg(fsp)));
380 /* Update to current time due to "normal" write. */
381 set_close_write_time(fsp, timespec_current());
382 } else {
383 DEBUG(10,("close_remove_share_mode: write time pending "
384 "for file %s\n",
385 fsp_str_dbg(fsp)));
386 /* Update to time set on close call. */
387 set_close_write_time(fsp, fsp->close_write_time);
388 }
389 }
390
391 if (fsp->initial_delete_on_close &&
392 !is_delete_on_close_set(lck, fsp->name_hash)) {
393 bool became_user = False;
394
395 /* Initial delete on close was set and no one else
396 * wrote a real delete on close. */
397
398 if (get_current_vuid(conn) != fsp->vuid) {
399 become_user(conn, fsp->vuid);
400 became_user = True;
401 }
402 fsp->delete_on_close = true;
403 set_delete_on_close_lck(fsp, lck, True,
404 get_current_nttok(conn),
405 get_current_utok(conn));
406 if (became_user) {
407 unbecome_user();
408 }
409 }
410
411 delete_file = is_delete_on_close_set(lck, fsp->name_hash);
412
413 if (delete_file) {
414 int i;
415 /* See if others still have the file open via this pathname.
416 If this is the case, then don't delete. If all opens are
417 POSIX delete now. */
418 for (i=0; i<lck->data->num_share_modes; i++) {
419 struct share_mode_entry *e = &lck->data->share_modes[i];
420
421 if (!is_valid_share_mode_entry(e)) {
422 continue;
423 }
424 if (e->name_hash != fsp->name_hash) {
425 continue;
426 }
427 if (fsp->posix_open
428 && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
429 continue;
430 }
431 if (serverid_equal(&self, &e->pid) &&
432 (e->share_file_id == fsp->fh->gen_id)) {
433 continue;
434 }
435 if (share_mode_stale_pid(lck->data, i)) {
436 continue;
437 }
438 delete_file = False;
439 break;
440 }
441 }
442
443 /* Notify any deferred opens waiting on this close. */
444 notify_deferred_opens(conn->sconn, lck);
445
446 /*
447 * NT can set delete_on_close of the last open
448 * reference to a file.
449 */
450
451 normal_close = (close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE);
452
453 if (!normal_close || !delete_file) {
454
455 if (!del_share_mode(lck, fsp)) {
456 DEBUG(0, ("close_remove_share_mode: Could not delete "
457 "share entry for file %s\n",
458 fsp_str_dbg(fsp)));
459 }
460
461 TALLOC_FREE(lck);
462 return NT_STATUS_OK;
463 }
464
465 /*
466 * Ok, we have to delete the file
467 */
468
469 DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
470 "- deleting file.\n", fsp_str_dbg(fsp)));
471
472 /*
473 * Don't try to update the write time when we delete the file
474 */
475 fsp->update_write_time_on_close = false;
476
477 got_tokens = get_delete_on_close_token(lck, fsp->name_hash,
478 &del_nt_token, &del_token);
479 SMB_ASSERT(got_tokens);
480
481 if (!unix_token_equal(del_token, get_current_utok(conn))) {
482 /* Become the user who requested the delete. */
483
484 DEBUG(5,("close_remove_share_mode: file %s. "
485 "Change user to uid %u\n",
486 fsp_str_dbg(fsp),
487 (unsigned int)del_token->uid));
488
489 if (!push_sec_ctx()) {
490 smb_panic("close_remove_share_mode: file %s. failed to push "
491 "sec_ctx.\n");
492 }
493
494 set_sec_ctx(del_token->uid,
495 del_token->gid,
496 del_token->ngroups,
497 del_token->groups,
498 del_nt_token);
499
500 changed_user = true;
501 }
502
503 /* We can only delete the file if the name we have is still valid and
504 hasn't been renamed. */
505
506 tmp_status = vfs_stat_fsp(fsp);
507 if (!NT_STATUS_IS_OK(tmp_status)) {
508 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
509 "was set and stat failed with error %s\n",
510 fsp_str_dbg(fsp), nt_errstr(tmp_status)));
511 /*
512 * Don't save the errno here, we ignore this error
513 */
514 goto done;
515 }
516
517 id = vfs_file_id_from_sbuf(conn, &fsp->fsp_name->st);
518
519 if (!file_id_equal(&fsp->file_id, &id)) {
520 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
521 "was set and dev and/or inode does not match\n",
522 fsp_str_dbg(fsp)));
523 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
524 "stat file_id %s\n",
525 fsp_str_dbg(fsp),
526 file_id_string_tos(&fsp->file_id),
527 file_id_string_tos(&id)));
528 /*
529 * Don't save the errno here, we ignore this error
530 */
531 goto done;
532 }
533
534 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
535 && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
536
537 status = delete_all_streams(conn, fsp->fsp_name->base_name);
538
539 if (!NT_STATUS_IS_OK(status)) {
540 DEBUG(5, ("delete_all_streams failed: %s\n",
541 nt_errstr(status)));
542 goto done;
543 }
544 }
545
546
547 if (SMB_VFS_UNLINK(conn, fsp->fsp_name) != 0) {
548 /*
549 * This call can potentially fail as another smbd may
550 * have had the file open with delete on close set and
551 * deleted it when its last reference to this file
552 * went away. Hence we log this but not at debug level
553 * zero.
554 */
555
556 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
557 "was set and unlink failed with error %s\n",
558 fsp_str_dbg(fsp), strerror(errno)));
559
560 status = map_nt_error_from_unix(errno);
561 }
562
563 /* As we now have POSIX opens which can unlink
564 * with other open files we may have taken
565 * this code path with more than one share mode
566 * entry - ensure we only delete once by resetting
567 * the delete on close flag. JRA.
568 */
569
570 fsp->delete_on_close = false;
571 set_delete_on_close_lck(fsp, lck, false, NULL, NULL);
572
573 done:
574
575 if (changed_user) {
576 /* unbecome user. */
577 pop_sec_ctx();
578 }
579
580 if (!del_share_mode(lck, fsp)) {
581 DEBUG(0, ("close_remove_share_mode: Could not delete share "
582 "entry for file %s\n", fsp_str_dbg(fsp)));
583 }
584
585 TALLOC_FREE(lck);
586
587 if (delete_file) {
588 /*
589 * Do the notification after we released the share
590 * mode lock. Inside notify_fname we take out another
591 * tdb lock. With ctdb also accessing our databases,
592 * this can lead to deadlocks. Putting this notify
593 * after the TALLOC_FREE(lck) above we avoid locking
594 * two records simultaneously. Notifies are async and
595 * informational only, so calling the notify_fname
596 * without holding the share mode lock should not do
597 * any harm.
598 */
599 notify_fname(conn, NOTIFY_ACTION_REMOVED,
600 FILE_NOTIFY_CHANGE_FILE_NAME,
601 fsp->fsp_name->base_name);
602 }
603
604 return status;
605 }
606
607 void set_close_write_time(struct files_struct *fsp, struct timespec ts)
608 {
609 DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts))));
610
611 if (null_timespec(ts)) {
612 return;
613 }
614 fsp->write_time_forced = false;
615 fsp->update_write_time_on_close = true;
616 fsp->close_write_time = ts;
617 }
618
619 static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
620 {
621 struct smb_file_time ft;
622 NTSTATUS status;
623 struct share_mode_lock *lck = NULL;
624
625 ZERO_STRUCT(ft);
626
627 if (!fsp->update_write_time_on_close) {
628 return NT_STATUS_OK;
629 }
630
631 if (null_timespec(fsp->close_write_time)) {
632 fsp->close_write_time = timespec_current();
633 }
634
635 /* Ensure we have a valid stat struct for the source. */
636 status = vfs_stat_fsp(fsp);
637 if (!NT_STATUS_IS_OK(status)) {
638 return status;
639 }
640
641 if (!VALID_STAT(fsp->fsp_name->st)) {
642 /* if it doesn't seem to be a real file */
643 return NT_STATUS_OK;
644 }
645
646 /*
647 * get_existing_share_mode_lock() isn't really the right
648 * call here, as we're being called after
649 * close_remove_share_mode() inside close_normal_file()
650 * so it's quite normal to not have an existing share
651 * mode here. However, get_share_mode_lock() doesn't
652 * work because that will create a new share mode if
653 * one doesn't exist - so stick with this call (just
654 * ignore any error we get if the share mode doesn't
655 * exist.
656 */
657
658 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
659 if (lck) {
660 /* On close if we're changing the real file time we
661 * must update it in the open file db too. */
662 (void)set_write_time(fsp->file_id, fsp->close_write_time);
663
664 /* Close write times overwrite sticky write times
665 so we must replace any sticky write time here. */
666 if (!null_timespec(lck->data->changed_write_time)) {
667 (void)set_sticky_write_time(fsp->file_id, fsp->close_write_time);
668 }
669 TALLOC_FREE(lck);
670 }
671
672 ft.mtime = fsp->close_write_time;
673 /* As this is a close based update, we are not directly changing the
674 file attributes from a client call, but indirectly from a write. */
675 status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, &ft, false);
676 if (!NT_STATUS_IS_OK(status)) {
677 DEBUG(10,("update_write_time_on_close: smb_set_file_time "
678 "on file %s returned %s\n",
679 fsp_str_dbg(fsp),
680 nt_errstr(status)));
681 return status;
682 }
683
684 return status;
685 }
686
687 static NTSTATUS ntstatus_keeperror(NTSTATUS s1, NTSTATUS s2)
688 {
689 if (!NT_STATUS_IS_OK(s1)) {
690 return s1;
691 }
692 return s2;
693 }
694
695 /****************************************************************************
696 Close a file.
697
698 close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
699 printing and magic scripts are only run on normal close.
700 delete on close is done on normal and shutdown close.
701 ****************************************************************************/
702
703 static NTSTATUS close_normal_file(struct smb_request *req, files_struct *fsp,
704 enum file_close_type close_type)
705 {
706 NTSTATUS status = NT_STATUS_OK;
707 NTSTATUS tmp;
708 connection_struct *conn = fsp->conn;
709 bool is_durable = false;
710
711 if (fsp->num_aio_requests != 0) {
712
713 if (close_type != SHUTDOWN_CLOSE) {
714 /*
715 * reply_close and the smb2 close must have
716 * taken care of this. No other callers of
717 * close_file should ever have created async
718 * I/O.
719 *
720 * We need to panic here because if we close()
721 * the fd while we have outstanding async I/O
722 * requests, in the worst case we could end up
723 * writing to the wrong file.
724 */
725 DEBUG(0, ("fsp->num_aio_requests=%u\n",
726 fsp->num_aio_requests));
727 smb_panic("can not close with outstanding aio "
728 "requests");
729 }
730
731 /*
732 * For shutdown close, just drop the async requests
733 * including a potential close request pending for
734 * this fsp. Drop the close request first, the
735 * destructor for the aio_requests would execute it.
736 */
737 TALLOC_FREE(fsp->deferred_close);
738
739 while (fsp->num_aio_requests != 0) {
740 /*
741 * The destructor of the req will remove
742 * itself from the fsp
743 */
744 TALLOC_FREE(fsp->aio_requests[0]);
745 }
746 }
747
748 /*
749 * If we're flushing on a close we can get a write
750 * error here, we must remember this.
751 */
752
753 tmp = close_filestruct(fsp);
754 status = ntstatus_keeperror(status, tmp);
755
756 if (NT_STATUS_IS_OK(status) && fsp->op != NULL) {
757 is_durable = fsp->op->global->durable;
758 }
759
760 if (close_type != SHUTDOWN_CLOSE) {
761 is_durable = false;
762 }
763
764 if (is_durable) {
765 DATA_BLOB new_cookie = data_blob_null;
766
767 tmp = SMB_VFS_DURABLE_DISCONNECT(fsp,
768 fsp->op->global->backend_cookie,
769 fsp->op,
770 &new_cookie);
771 if (NT_STATUS_IS_OK(tmp)) {
772 struct timeval tv;
773 NTTIME now;
774
775 if (req != NULL) {
776 tv = req->request_time;
777 } else {
778 tv = timeval_current();
779 }
780 now = timeval_to_nttime(&tv);
781
782 data_blob_free(&fsp->op->global->backend_cookie);
783 fsp->op->global->backend_cookie = new_cookie;
784
785 fsp->op->compat = NULL;
786 tmp = smbXsrv_open_close(fsp->op, now);
787 if (!NT_STATUS_IS_OK(tmp)) {
788 DEBUG(1, ("Failed to update smbXsrv_open "
789 "record when disconnecting durable "
790 "handle for file %s: %s - "
791 "proceeding with normal close\n",
792 fsp_str_dbg(fsp), nt_errstr(tmp)));
793 }
794 scavenger_schedule_disconnected(fsp);
795 } else {
796 DEBUG(1, ("Failed to disconnect durable handle for "
797 "file %s: %s - proceeding with normal "
798 "close\n", fsp_str_dbg(fsp), nt_errstr(tmp)));
799 }
800 if (!NT_STATUS_IS_OK(tmp)) {
801 is_durable = false;
802 }
803 }
804
805 if (is_durable) {
806 /*
807 * This is the case where we successfully disconnected
808 * a durable handle and closed the underlying file.
809 * In all other cases, we proceed with a genuine close.
810 */
811 DEBUG(10, ("%s disconnected durable handle for file %s\n",
812 conn->session_info->unix_info->unix_name,
813 fsp_str_dbg(fsp)));
814 file_free(req, fsp);
815 return NT_STATUS_OK;
816 }
817
818 if (fsp->op != NULL) {
819 /*
820 * Make sure the handle is not marked as durable anymore
821 */
822 fsp->op->global->durable = false;
823 }
824
825 if (fsp->print_file) {
826 /* FIXME: return spool errors */
827 print_spool_end(fsp, close_type);
828 file_free(req, fsp);
829 return NT_STATUS_OK;
830 }
831
832 /* Remove the oplock before potentially deleting the file. */
833 if(fsp->oplock_type) {
834 release_file_oplock(fsp);
835 }
836
837 /* If this is an old DOS or FCB open and we have multiple opens on
838 the same handle we only have one share mode. Ensure we only remove
839 the share mode on the last close. */
840
841 if (fsp->fh->ref_count == 1) {
842 /* Should we return on error here... ? */
843 tmp = close_remove_share_mode(fsp, close_type);
844 status = ntstatus_keeperror(status, tmp);
845 }
846
847 locking_close_file(conn->sconn->msg_ctx, fsp, close_type);
848
849 tmp = fd_close(fsp);
850 status = ntstatus_keeperror(status, tmp);
851
852 /* check for magic scripts */
853 if (close_type == NORMAL_CLOSE) {
854 tmp = check_magic(fsp);
855 status = ntstatus_keeperror(status, tmp);
856 }
857
858 /*
859 * Ensure pending modtime is set after close.
860 */
861
862 tmp = update_write_time_on_close(fsp);
863 if (NT_STATUS_EQUAL(tmp, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
864 /* Someone renamed the file or a parent directory containing
865 * this file. We can't do anything about this, we don't have
866 * an "update timestamp by fd" call in POSIX. Eat the error. */
867
868 tmp = NT_STATUS_OK;
869 }
870
871 status = ntstatus_keeperror(status, tmp);
872
873 DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
874 conn->session_info->unix_info->unix_name, fsp_str_dbg(fsp),
875 conn->num_files_open - 1,
876 nt_errstr(status) ));
877
878 file_free(req, fsp);
879 return status;
880 }
881 /****************************************************************************
882 Function used by reply_rmdir to delete an entire directory
883 tree recursively. Return True on ok, False on fail.
884 ****************************************************************************/
885
886 bool recursive_rmdir(TALLOC_CTX *ctx,
887 connection_struct *conn,
888 struct smb_filename *smb_dname)
889 {
890 const char *dname = NULL;
891 char *talloced = NULL;
892 bool ret = True;
893 long offset = 0;
894 SMB_STRUCT_STAT st;
895 struct smb_Dir *dir_hnd;
896
897 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
898
899 dir_hnd = OpenDir(talloc_tos(), conn, smb_dname->base_name, NULL, 0);
900 if(dir_hnd == NULL)
901 return False;
902
903 while((dname = ReadDirName(dir_hnd, &offset, &st, &talloced))) {
904 struct smb_filename *smb_dname_full = NULL;
905 char *fullname = NULL;
906 bool do_break = true;
907
908 if (ISDOT(dname) || ISDOTDOT(dname)) {
909 TALLOC_FREE(talloced);
910 continue;
911 }
912
913 if (!is_visible_file(conn, smb_dname->base_name, dname, &st,
914 false)) {
915 TALLOC_FREE(talloced);
916 continue;
917 }
918
919 /* Construct the full name. */
920 fullname = talloc_asprintf(ctx,
921 "%s/%s",
922 smb_dname->base_name,
923 dname);
924 if (!fullname) {
925 errno = ENOMEM;
926 goto err_break;
927 }
928
929 smb_dname_full = synthetic_smb_fname(talloc_tos(), fullname,
930 NULL, NULL);
931 if (smb_dname_full == NULL) {
932 errno = ENOMEM;
933 goto err_break;
934 }
935
936 if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
937 goto err_break;
938 }
939
940 if(smb_dname_full->st.st_ex_mode & S_IFDIR) {
941 if(!recursive_rmdir(ctx, conn, smb_dname_full)) {
942 goto err_break;
943 }
944 if(SMB_VFS_RMDIR(conn,
945 smb_dname_full->base_name) != 0) {
946 goto err_break;
947 }
948 } else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) {
949 goto err_break;
950 }
951
952 /* Successful iteration. */
953 do_break = false;
954
955 err_break:
956 TALLOC_FREE(smb_dname_full);
957 TALLOC_FREE(fullname);
958 TALLOC_FREE(talloced);
959 if (do_break) {
960 ret = false;
961 break;
962 }
963 }
964 TALLOC_FREE(dir_hnd);
965 return ret;
966 }
967
968 /****************************************************************************
969 The internals of the rmdir code - called elsewhere.
970 ****************************************************************************/
971
972 static NTSTATUS rmdir_internals(TALLOC_CTX *ctx, files_struct *fsp)
973 {
974 connection_struct *conn = fsp->conn;
975 struct smb_filename *smb_dname = fsp->fsp_name;
976 int ret;
977
978 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
979
980 /* Might be a symlink. */
981 if(SMB_VFS_LSTAT(conn, smb_dname) != 0) {
982 return map_nt_error_from_unix(errno);
983 }
984
985 if (S_ISLNK(smb_dname->st.st_ex_mode)) {
986 /* Is what it points to a directory ? */
987 if(SMB_VFS_STAT(conn, smb_dname) != 0) {
988 return map_nt_error_from_unix(errno);
989 }
990 if (!(S_ISDIR(smb_dname->st.st_ex_mode))) {
991 return NT_STATUS_NOT_A_DIRECTORY;
992 }
993 ret = SMB_VFS_UNLINK(conn, smb_dname);
994 } else {
995 ret = SMB_VFS_RMDIR(conn, smb_dname->base_name);
996 }
997 if (ret == 0) {
998 notify_fname(conn, NOTIFY_ACTION_REMOVED,
999 FILE_NOTIFY_CHANGE_DIR_NAME,
1000 smb_dname->base_name);
1001 return NT_STATUS_OK;
1002 }
1003
1004 if(((errno == ENOTEMPTY)||(errno == EEXIST)) && *lp_veto_files(talloc_tos(), SNUM(conn))) {
1005 /*
1006 * Check to see if the only thing in this directory are
1007 * vetoed files/directories. If so then delete them and
1008 * retry. If we fail to delete any of them (and we *don't*
1009 * do a recursive delete) then fail the rmdir.
1010 */
1011 SMB_STRUCT_STAT st;
1012 const char *dname = NULL;
1013 char *talloced = NULL;
1014 long dirpos = 0;
1015 struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn,
1016 smb_dname->base_name, NULL,
1017 0);
1018
1019 if(dir_hnd == NULL) {
1020 errno = ENOTEMPTY;
1021 goto err;
1022 }
1023
1024 while ((dname = ReadDirName(dir_hnd, &dirpos, &st,
1025 &talloced)) != NULL) {
1026 if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0)) {
1027 TALLOC_FREE(talloced);
1028 continue;
1029 }
1030 if (!is_visible_file(conn, smb_dname->base_name, dname,
1031 &st, false)) {
1032 TALLOC_FREE(talloced);
1033 continue;
1034 }
1035 if(!IS_VETO_PATH(conn, dname)) {
1036 TALLOC_FREE(dir_hnd);
1037 TALLOC_FREE(talloced);
1038 errno = ENOTEMPTY;
1039 goto err;
1040 }
1041 TALLOC_FREE(talloced);
1042 }
1043
1044 /* We only have veto files/directories.
1045 * Are we allowed to delete them ? */
1046
1047 if(!lp_recursive_veto_delete(SNUM(conn))) {
1048 TALLOC_FREE(dir_hnd);
1049 errno = ENOTEMPTY;
1050 goto err;
1051 }
1052
1053 /* Do a recursive delete. */
1054 RewindDir(dir_hnd,&dirpos);
1055 while ((dname = ReadDirName(dir_hnd, &dirpos, &st,
1056 &talloced)) != NULL) {
1057 struct smb_filename *smb_dname_full = NULL;
1058 char *fullname = NULL;
1059 bool do_break = true;
1060
1061 if (ISDOT(dname) || ISDOTDOT(dname)) {
1062 TALLOC_FREE(talloced);
1063 continue;
1064 }
1065 if (!is_visible_file(conn, smb_dname->base_name, dname,
1066 &st, false)) {
1067 TALLOC_FREE(talloced);
1068 continue;
1069 }
1070
1071 fullname = talloc_asprintf(ctx,
1072 "%s/%s",
1073 smb_dname->base_name,
1074 dname);
1075
1076 if(!fullname) {
1077 errno = ENOMEM;
1078 goto err_break;
1079 }
1080
1081 smb_dname_full = synthetic_smb_fname(
1082 talloc_tos(), fullname, NULL, NULL);
1083 if (smb_dname_full == NULL) {
1084 errno = ENOMEM;
1085 goto err_break;
1086 }
1087
1088 if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
1089 goto err_break;
1090 }
1091 if(smb_dname_full->st.st_ex_mode & S_IFDIR) {
1092 if(!recursive_rmdir(ctx, conn,
1093 smb_dname_full)) {
1094 goto err_break;
1095 }
1096 if(SMB_VFS_RMDIR(conn,
1097 smb_dname_full->base_name) != 0) {
1098 goto err_break;
1099 }
1100 } else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) {
1101 goto err_break;
1102 }
1103
1104 /* Successful iteration. */
1105 do_break = false;
1106
1107 err_break:
1108 TALLOC_FREE(fullname);
1109 TALLOC_FREE(smb_dname_full);
1110 TALLOC_FREE(talloced);
1111 if (do_break)
1112 break;
1113 }
1114 TALLOC_FREE(dir_hnd);
1115 /* Retry the rmdir */
1116 ret = SMB_VFS_RMDIR(conn, smb_dname->base_name);
1117 }
1118
1119 err:
1120
1121 if (ret != 0) {
1122 DEBUG(3,("rmdir_internals: couldn't remove directory %s : "
1123 "%s\n", smb_fname_str_dbg(smb_dname),
1124 strerror(errno)));
1125 return map_nt_error_from_unix(errno);
1126 }
1127
1128 notify_fname(conn, NOTIFY_ACTION_REMOVED,
1129 FILE_NOTIFY_CHANGE_DIR_NAME,
1130 smb_dname->base_name);
1131
1132 return NT_STATUS_OK;
1133 }
1134
1135 /****************************************************************************
1136 Close a directory opened by an NT SMB call.
1137 ****************************************************************************/
1138
1139 static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp,
1140 enum file_close_type close_type)
1141 {
1142 struct server_id self = messaging_server_id(fsp->conn->sconn->msg_ctx);
1143 struct share_mode_lock *lck = NULL;
1144 bool delete_dir = False;
1145 NTSTATUS status = NT_STATUS_OK;
1146 NTSTATUS status1 = NT_STATUS_OK;
1147 const struct security_token *del_nt_token = NULL;
1148 const struct security_unix_token *del_token = NULL;
1149
1150 /*
1151 * NT can set delete_on_close of the last open
1152 * reference to a directory also.
1153 */
1154
1155 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1156 if (lck == NULL) {
1157 DEBUG(0, ("close_directory: Could not get share mode lock for "
1158 "%s\n", fsp_str_dbg(fsp)));
1159 return NT_STATUS_INVALID_PARAMETER;
1160 }
1161
1162 if (fsp->initial_delete_on_close) {
1163 bool became_user = False;
1164
1165 /* Initial delete on close was set - for
1166 * directories we don't care if anyone else
1167 * wrote a real delete on close. */
1168
1169 if (get_current_vuid(fsp->conn) != fsp->vuid) {
1170 become_user(fsp->conn, fsp->vuid);
1171 became_user = True;
1172 }
1173 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1174 fsp->fsp_name->base_name);
1175 set_delete_on_close_lck(fsp, lck, true,
1176 get_current_nttok(fsp->conn),
1177 get_current_utok(fsp->conn));
1178 fsp->delete_on_close = true;
1179 if (became_user) {
1180 unbecome_user();
1181 }
1182 }
1183
1184 delete_dir = get_delete_on_close_token(lck, fsp->name_hash,
1185 &del_nt_token, &del_token);
1186
1187 if (delete_dir) {
1188 int i;
1189 /* See if others still have the dir open. If this is the
1190 * case, then don't delete. If all opens are POSIX delete now. */
1191 for (i=0; i<lck->data->num_share_modes; i++) {
1192 struct share_mode_entry *e = &lck->data->share_modes[i];
1193 if (is_valid_share_mode_entry(e) &&
1194 e->name_hash == fsp->name_hash) {
1195 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
1196 continue;
1197 }
1198 if (serverid_equal(&self, &e->pid) &&
1199 (e->share_file_id == fsp->fh->gen_id)) {
1200 continue;
1201 }
1202 if (share_mode_stale_pid(lck->data, i)) {
1203 continue;
1204 }
1205 delete_dir = False;
1206 break;
1207 }
1208 }
1209 }
1210
1211 if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
1212 delete_dir) {
1213
1214 /* Become the user who requested the delete. */
1215
1216 if (!push_sec_ctx()) {
1217 smb_panic("close_directory: failed to push sec_ctx.\n");
1218 }
1219
1220 set_sec_ctx(del_token->uid,
1221 del_token->gid,
1222 del_token->ngroups,
1223 del_token->groups,
1224 del_nt_token);
1225
1226 if (!del_share_mode(lck, fsp)) {
1227 DEBUG(0, ("close_directory: Could not delete share entry for "
1228 "%s\n", fsp_str_dbg(fsp)));
1229 }
1230
1231 TALLOC_FREE(lck);
1232
1233 if ((fsp->conn->fs_capabilities & FILE_NAMED_STREAMS)
1234 && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
1235
1236 status = delete_all_streams(fsp->conn, fsp->fsp_name->base_name);
1237 if (!NT_STATUS_IS_OK(status)) {
1238 DEBUG(5, ("delete_all_streams failed: %s\n",
1239 nt_errstr(status)));
1240 return status;
1241 }
1242 }
1243
1244 status = rmdir_internals(talloc_tos(), fsp);
1245
1246 DEBUG(5,("close_directory: %s. Delete on close was set - "
1247 "deleting directory returned %s.\n",
1248 fsp_str_dbg(fsp), nt_errstr(status)));
1249
1250 /* unbecome user. */
1251 pop_sec_ctx();
1252
1253 /*
1254 * Ensure we remove any change notify requests that would
1255 * now fail as the directory has been deleted.
1256 */
1257
1258 if(NT_STATUS_IS_OK(status)) {
1259 remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING);
1260 }
1261 } else {
1262 if (!del_share_mode(lck, fsp)) {
1263 DEBUG(0, ("close_directory: Could not delete share entry for "
1264 "%s\n", fsp_str_dbg(fsp)));
1265 }
1266
1267 TALLOC_FREE(lck);
1268 remove_pending_change_notify_requests_by_fid(
1269 fsp, NT_STATUS_OK);
1270 }
1271
1272 status1 = fd_close(fsp);
1273
1274 if (!NT_STATUS_IS_OK(status1)) {
1275 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
1276 fsp_str_dbg(fsp), fsp->fh->fd, errno,
1277 strerror(errno)));
1278 }
1279
1280 /*
1281 * Do the code common to files and directories.
1282 */
1283 close_filestruct(fsp);
1284 file_free(req, fsp);
1285
1286 if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(status1)) {
1287 status = status1;
1288 }
1289 return status;
1290 }
1291
1292 /****************************************************************************
1293 Close a files_struct.
1294 ****************************************************************************/
1295
1296 NTSTATUS close_file(struct smb_request *req, files_struct *fsp,
1297 enum file_close_type close_type)
1298 {
1299 NTSTATUS status;
1300 struct files_struct *base_fsp = fsp->base_fsp;
1301
1302 if(fsp->is_directory) {
1303 status = close_directory(req, fsp, close_type);
1304 } else if (fsp->fake_file_handle != NULL) {
1305 status = close_fake_file(req, fsp);
1306 } else {
1307 status = close_normal_file(req, fsp, close_type);
1308 }
1309
1310 if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) {
1311
1312 /*
1313 * fsp was a stream, the base fsp can't be a stream as well
1314 *
1315 * For SHUTDOWN_CLOSE this is not possible here, because
1316 * SHUTDOWN_CLOSE only happens from files.c which walks the
1317 * complete list of files. If we mess with more than one fsp
1318 * those loops will become confused.
1319 */
1320
1321 SMB_ASSERT(base_fsp->base_fsp == NULL);
1322 close_file(req, base_fsp, close_type);
1323 }
1324
1325 return status;
1326 }
1327
1328 /****************************************************************************
1329 Deal with an (authorized) message to close a file given the share mode
1330 entry.
1331 ****************************************************************************/
1332
1333 void msg_close_file(struct messaging_context *msg_ctx,
1334 void *private_data,
1335 uint32_t msg_type,
1336 struct server_id server_id,
1337 DATA_BLOB *data)
1338 {
1339 files_struct *fsp = NULL;
1340 struct share_mode_entry e;
1341 struct smbd_server_connection *sconn =
1342 talloc_get_type_abort(private_data,
1343 struct smbd_server_connection);
1344
1345 message_to_share_mode_entry(&e, (char *)data->data);
1346
1347 if(DEBUGLVL(10)) {
1348 char *sm_str = share_mode_str(NULL, 0, &e);
1349 if (!sm_str) {
1350 smb_panic("talloc failed");
1351 }
1352 DEBUG(10,("msg_close_file: got request to close share mode "
1353 "entry %s\n", sm_str));
1354 TALLOC_FREE(sm_str);
1355 }
1356
1357 fsp = file_find_dif(sconn, e.id, e.share_file_id);
1358 if (!fsp) {
1359 DEBUG(10,("msg_close_file: failed to find file.\n"));
1360 return;
1361 }
1362 close_file(NULL, fsp, NORMAL_CLOSE);
1363 }
stuff from bjacke