?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
smbd: Ignore OPEN_RETRY and BREAK_RESPONSE
[Samba/id10ts.git] / source3 / smbd / close.c
blob46aa3563900d879c98f89603db6dce689c91f10d
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 reply_to_oplock_break_requests(fsp);
446
447 /*
448 * NT can set delete_on_close of the last open
449 * reference to a file.
450 */
451
452 normal_close = (close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE);
453
454 if (!normal_close || !delete_file) {
455
456 if (!del_share_mode(lck, fsp)) {
457 DEBUG(0, ("close_remove_share_mode: Could not delete "
458 "share entry for file %s\n",
459 fsp_str_dbg(fsp)));
460 }
461
462 TALLOC_FREE(lck);
463 return NT_STATUS_OK;
464 }
465
466 /*
467 * Ok, we have to delete the file
468 */
469
470 DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
471 "- deleting file.\n", fsp_str_dbg(fsp)));
472
473 /*
474 * Don't try to update the write time when we delete the file
475 */
476 fsp->update_write_time_on_close = false;
477
478 got_tokens = get_delete_on_close_token(lck, fsp->name_hash,
479 &del_nt_token, &del_token);
480 SMB_ASSERT(got_tokens);
481
482 if (!unix_token_equal(del_token, get_current_utok(conn))) {
483 /* Become the user who requested the delete. */
484
485 DEBUG(5,("close_remove_share_mode: file %s. "
486 "Change user to uid %u\n",
487 fsp_str_dbg(fsp),
488 (unsigned int)del_token->uid));
489
490 if (!push_sec_ctx()) {
491 smb_panic("close_remove_share_mode: file %s. failed to push "
492 "sec_ctx.\n");
493 }
494
495 set_sec_ctx(del_token->uid,
496 del_token->gid,
497 del_token->ngroups,
498 del_token->groups,
499 del_nt_token);
500
501 changed_user = true;
502 }
503
504 /* We can only delete the file if the name we have is still valid and
505 hasn't been renamed. */
506
507 tmp_status = vfs_stat_fsp(fsp);
508 if (!NT_STATUS_IS_OK(tmp_status)) {
509 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
510 "was set and stat failed with error %s\n",
511 fsp_str_dbg(fsp), nt_errstr(tmp_status)));
512 /*
513 * Don't save the errno here, we ignore this error
514 */
515 goto done;
516 }
517
518 id = vfs_file_id_from_sbuf(conn, &fsp->fsp_name->st);
519
520 if (!file_id_equal(&fsp->file_id, &id)) {
521 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
522 "was set and dev and/or inode does not match\n",
523 fsp_str_dbg(fsp)));
524 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
525 "stat file_id %s\n",
526 fsp_str_dbg(fsp),
527 file_id_string_tos(&fsp->file_id),
528 file_id_string_tos(&id)));
529 /*
530 * Don't save the errno here, we ignore this error
531 */
532 goto done;
533 }
534
535 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
536 && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
537
538 status = delete_all_streams(conn, fsp->fsp_name->base_name);
539
540 if (!NT_STATUS_IS_OK(status)) {
541 DEBUG(5, ("delete_all_streams failed: %s\n",
542 nt_errstr(status)));
543 goto done;
544 }
545 }
546
547
548 if (SMB_VFS_UNLINK(conn, fsp->fsp_name) != 0) {
549 /*
550 * This call can potentially fail as another smbd may
551 * have had the file open with delete on close set and
552 * deleted it when its last reference to this file
553 * went away. Hence we log this but not at debug level
554 * zero.
555 */
556
557 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
558 "was set and unlink failed with error %s\n",
559 fsp_str_dbg(fsp), strerror(errno)));
560
561 status = map_nt_error_from_unix(errno);
562 }
563
564 /* As we now have POSIX opens which can unlink
565 * with other open files we may have taken
566 * this code path with more than one share mode
567 * entry - ensure we only delete once by resetting
568 * the delete on close flag. JRA.
569 */
570
571 fsp->delete_on_close = false;
572 set_delete_on_close_lck(fsp, lck, false, NULL, NULL);
573
574 done:
575
576 if (changed_user) {
577 /* unbecome user. */
578 pop_sec_ctx();
579 }
580
581 if (!del_share_mode(lck, fsp)) {
582 DEBUG(0, ("close_remove_share_mode: Could not delete share "
583 "entry for file %s\n", fsp_str_dbg(fsp)));
584 }
585
586 TALLOC_FREE(lck);
587
588 if (delete_file) {
589 /*
590 * Do the notification after we released the share
591 * mode lock. Inside notify_fname we take out another
592 * tdb lock. With ctdb also accessing our databases,
593 * this can lead to deadlocks. Putting this notify
594 * after the TALLOC_FREE(lck) above we avoid locking
595 * two records simultaneously. Notifies are async and
596 * informational only, so calling the notify_fname
597 * without holding the share mode lock should not do
598 * any harm.
599 */
600 notify_fname(conn, NOTIFY_ACTION_REMOVED,
601 FILE_NOTIFY_CHANGE_FILE_NAME,
602 fsp->fsp_name->base_name);
603 }
604
605 return status;
606 }
607
608 void set_close_write_time(struct files_struct *fsp, struct timespec ts)
609 {
610 DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts))));
611
612 if (null_timespec(ts)) {
613 return;
614 }
615 fsp->write_time_forced = false;
616 fsp->update_write_time_on_close = true;
617 fsp->close_write_time = ts;
618 }
619
620 static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
621 {
622 struct smb_file_time ft;
623 NTSTATUS status;
624 struct share_mode_lock *lck = NULL;
625
626 ZERO_STRUCT(ft);
627
628 if (!fsp->update_write_time_on_close) {
629 return NT_STATUS_OK;
630 }
631
632 if (null_timespec(fsp->close_write_time)) {
633 fsp->close_write_time = timespec_current();
634 }
635
636 /* Ensure we have a valid stat struct for the source. */
637 status = vfs_stat_fsp(fsp);
638 if (!NT_STATUS_IS_OK(status)) {
639 return status;
640 }
641
642 if (!VALID_STAT(fsp->fsp_name->st)) {
643 /* if it doesn't seem to be a real file */
644 return NT_STATUS_OK;
645 }
646
647 /*
648 * get_existing_share_mode_lock() isn't really the right
649 * call here, as we're being called after
650 * close_remove_share_mode() inside close_normal_file()
651 * so it's quite normal to not have an existing share
652 * mode here. However, get_share_mode_lock() doesn't
653 * work because that will create a new share mode if
654 * one doesn't exist - so stick with this call (just
655 * ignore any error we get if the share mode doesn't
656 * exist.
657 */
658
659 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
660 if (lck) {
661 /* On close if we're changing the real file time we
662 * must update it in the open file db too. */
663 (void)set_write_time(fsp->file_id, fsp->close_write_time);
664
665 /* Close write times overwrite sticky write times
666 so we must replace any sticky write time here. */
667 if (!null_timespec(lck->data->changed_write_time)) {
668 (void)set_sticky_write_time(fsp->file_id, fsp->close_write_time);
669 }
670 TALLOC_FREE(lck);
671 }
672
673 ft.mtime = fsp->close_write_time;
674 /* As this is a close based update, we are not directly changing the
675 file attributes from a client call, but indirectly from a write. */
676 status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, &ft, false);
677 if (!NT_STATUS_IS_OK(status)) {
678 DEBUG(10,("update_write_time_on_close: smb_set_file_time "
679 "on file %s returned %s\n",
680 fsp_str_dbg(fsp),
681 nt_errstr(status)));
682 return status;
683 }
684
685 return status;
686 }
687
688 static NTSTATUS ntstatus_keeperror(NTSTATUS s1, NTSTATUS s2)
689 {
690 if (!NT_STATUS_IS_OK(s1)) {
691 return s1;
692 }
693 return s2;
694 }
695
696 /****************************************************************************
697 Close a file.
698
699 close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
700 printing and magic scripts are only run on normal close.
701 delete on close is done on normal and shutdown close.
702 ****************************************************************************/
703
704 static NTSTATUS close_normal_file(struct smb_request *req, files_struct *fsp,
705 enum file_close_type close_type)
706 {
707 NTSTATUS status = NT_STATUS_OK;
708 NTSTATUS tmp;
709 connection_struct *conn = fsp->conn;
710 bool is_durable = false;
711
712 if (fsp->num_aio_requests != 0) {
713
714 if (close_type != SHUTDOWN_CLOSE) {
715 /*
716 * reply_close and the smb2 close must have
717 * taken care of this. No other callers of
718 * close_file should ever have created async
719 * I/O.
720 *
721 * We need to panic here because if we close()
722 * the fd while we have outstanding async I/O
723 * requests, in the worst case we could end up
724 * writing to the wrong file.
725 */
726 DEBUG(0, ("fsp->num_aio_requests=%u\n",
727 fsp->num_aio_requests));
728 smb_panic("can not close with outstanding aio "
729 "requests");
730 }
731
732 /*
733 * For shutdown close, just drop the async requests
734 * including a potential close request pending for
735 * this fsp. Drop the close request first, the
736 * destructor for the aio_requests would execute it.
737 */
738 TALLOC_FREE(fsp->deferred_close);
739
740 while (fsp->num_aio_requests != 0) {
741 /*
742 * The destructor of the req will remove
743 * itself from the fsp
744 */
745 TALLOC_FREE(fsp->aio_requests[0]);
746 }
747 }
748
749 /*
750 * If we're flushing on a close we can get a write
751 * error here, we must remember this.
752 */
753
754 tmp = close_filestruct(fsp);
755 status = ntstatus_keeperror(status, tmp);
756
757 if (NT_STATUS_IS_OK(status) && fsp->op != NULL) {
758 is_durable = fsp->op->global->durable;
759 }
760
761 if (close_type != SHUTDOWN_CLOSE) {
762 is_durable = false;
763 }
764
765 if (is_durable) {
766 DATA_BLOB new_cookie = data_blob_null;
767
768 tmp = SMB_VFS_DURABLE_DISCONNECT(fsp,
769 fsp->op->global->backend_cookie,
770 fsp->op,
771 &new_cookie);
772 if (NT_STATUS_IS_OK(tmp)) {
773 struct timeval tv;
774 NTTIME now;
775
776 if (req != NULL) {
777 tv = req->request_time;
778 } else {
779 tv = timeval_current();
780 }
781 now = timeval_to_nttime(&tv);
782
783 data_blob_free(&fsp->op->global->backend_cookie);
784 fsp->op->global->backend_cookie = new_cookie;
785
786 fsp->op->compat = NULL;
787 tmp = smbXsrv_open_close(fsp->op, now);
788 if (!NT_STATUS_IS_OK(tmp)) {
789 DEBUG(1, ("Failed to update smbXsrv_open "
790 "record when disconnecting durable "
791 "handle for file %s: %s - "
792 "proceeding with normal close\n",
793 fsp_str_dbg(fsp), nt_errstr(tmp)));
794 }
795 scavenger_schedule_disconnected(fsp);
796 } else {
797 DEBUG(1, ("Failed to disconnect durable handle for "
798 "file %s: %s - proceeding with normal "
799 "close\n", fsp_str_dbg(fsp), nt_errstr(tmp)));
800 }
801 if (!NT_STATUS_IS_OK(tmp)) {
802 is_durable = false;
803 }
804 }
805
806 if (is_durable) {
807 /*
808 * This is the case where we successfully disconnected
809 * a durable handle and closed the underlying file.
810 * In all other cases, we proceed with a genuine close.
811 */
812 DEBUG(10, ("%s disconnected durable handle for file %s\n",
813 conn->session_info->unix_info->unix_name,
814 fsp_str_dbg(fsp)));
815 file_free(req, fsp);
816 return NT_STATUS_OK;
817 }
818
819 if (fsp->op != NULL) {
820 /*
821 * Make sure the handle is not marked as durable anymore
822 */
823 fsp->op->global->durable = false;
824 }
825
826 if (fsp->print_file) {
827 /* FIXME: return spool errors */
828 print_spool_end(fsp, close_type);
829 file_free(req, fsp);
830 return NT_STATUS_OK;
831 }
832
833 /* Remove the oplock before potentially deleting the file. */
834 if(fsp->oplock_type) {
835 release_file_oplock(fsp);
836 }
837
838 /* If this is an old DOS or FCB open and we have multiple opens on
839 the same handle we only have one share mode. Ensure we only remove
840 the share mode on the last close. */
841
842 if (fsp->fh->ref_count == 1) {
843 /* Should we return on error here... ? */
844 tmp = close_remove_share_mode(fsp, close_type);
845 status = ntstatus_keeperror(status, tmp);
846 }
847
848 locking_close_file(conn->sconn->msg_ctx, fsp, close_type);
849
850 tmp = fd_close(fsp);
851 status = ntstatus_keeperror(status, tmp);
852
853 /* check for magic scripts */
854 if (close_type == NORMAL_CLOSE) {
855 tmp = check_magic(fsp);
856 status = ntstatus_keeperror(status, tmp);
857 }
858
859 /*
860 * Ensure pending modtime is set after close.
861 */
862
863 tmp = update_write_time_on_close(fsp);
864 if (NT_STATUS_EQUAL(tmp, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
865 /* Someone renamed the file or a parent directory containing
866 * this file. We can't do anything about this, we don't have
867 * an "update timestamp by fd" call in POSIX. Eat the error. */
868
869 tmp = NT_STATUS_OK;
870 }
871
872 status = ntstatus_keeperror(status, tmp);
873
874 DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
875 conn->session_info->unix_info->unix_name, fsp_str_dbg(fsp),
876 conn->num_files_open - 1,
877 nt_errstr(status) ));
878
879 file_free(req, fsp);
880 return status;
881 }
882 /****************************************************************************
883 Function used by reply_rmdir to delete an entire directory
884 tree recursively. Return True on ok, False on fail.
885 ****************************************************************************/
886
887 bool recursive_rmdir(TALLOC_CTX *ctx,
888 connection_struct *conn,
889 struct smb_filename *smb_dname)
890 {
891 const char *dname = NULL;
892 char *talloced = NULL;
893 bool ret = True;
894 long offset = 0;
895 SMB_STRUCT_STAT st;
896 struct smb_Dir *dir_hnd;
897
898 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
899
900 dir_hnd = OpenDir(talloc_tos(), conn, smb_dname->base_name, NULL, 0);
901 if(dir_hnd == NULL)
902 return False;
903
904 while((dname = ReadDirName(dir_hnd, &offset, &st, &talloced))) {
905 struct smb_filename *smb_dname_full = NULL;
906 char *fullname = NULL;
907 bool do_break = true;
908
909 if (ISDOT(dname) || ISDOTDOT(dname)) {
910 TALLOC_FREE(talloced);
911 continue;
912 }
913
914 if (!is_visible_file(conn, smb_dname->base_name, dname, &st,
915 false)) {
916 TALLOC_FREE(talloced);
917 continue;
918 }
919
920 /* Construct the full name. */
921 fullname = talloc_asprintf(ctx,
922 "%s/%s",
923 smb_dname->base_name,
924 dname);
925 if (!fullname) {
926 errno = ENOMEM;
927 goto err_break;
928 }
929
930 smb_dname_full = synthetic_smb_fname(talloc_tos(), fullname,
931 NULL, NULL);
932 if (smb_dname_full == NULL) {
933 errno = ENOMEM;
934 goto err_break;
935 }
936
937 if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
938 goto err_break;
939 }
940
941 if(smb_dname_full->st.st_ex_mode & S_IFDIR) {
942 if(!recursive_rmdir(ctx, conn, smb_dname_full)) {
943 goto err_break;
944 }
945 if(SMB_VFS_RMDIR(conn,
946 smb_dname_full->base_name) != 0) {
947 goto err_break;
948 }
949 } else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) {
950 goto err_break;
951 }
952
953 /* Successful iteration. */
954 do_break = false;
955
956 err_break:
957 TALLOC_FREE(smb_dname_full);
958 TALLOC_FREE(fullname);
959 TALLOC_FREE(talloced);
960 if (do_break) {
961 ret = false;
962 break;
963 }
964 }
965 TALLOC_FREE(dir_hnd);
966 return ret;
967 }
968
969 /****************************************************************************
970 The internals of the rmdir code - called elsewhere.
971 ****************************************************************************/
972
973 static NTSTATUS rmdir_internals(TALLOC_CTX *ctx, files_struct *fsp)
974 {
975 connection_struct *conn = fsp->conn;
976 struct smb_filename *smb_dname = fsp->fsp_name;
977 int ret;
978
979 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
980
981 /* Might be a symlink. */
982 if(SMB_VFS_LSTAT(conn, smb_dname) != 0) {
983 return map_nt_error_from_unix(errno);
984 }
985
986 if (S_ISLNK(smb_dname->st.st_ex_mode)) {
987 /* Is what it points to a directory ? */
988 if(SMB_VFS_STAT(conn, smb_dname) != 0) {
989 return map_nt_error_from_unix(errno);
990 }
991 if (!(S_ISDIR(smb_dname->st.st_ex_mode))) {
992 return NT_STATUS_NOT_A_DIRECTORY;
993 }
994 ret = SMB_VFS_UNLINK(conn, smb_dname);
995 } else {
996 ret = SMB_VFS_RMDIR(conn, smb_dname->base_name);
997 }
998 if (ret == 0) {
999 notify_fname(conn, NOTIFY_ACTION_REMOVED,
1000 FILE_NOTIFY_CHANGE_DIR_NAME,
1001 smb_dname->base_name);
1002 return NT_STATUS_OK;
1003 }
1004
1005 if(((errno == ENOTEMPTY)||(errno == EEXIST)) && *lp_veto_files(talloc_tos(), SNUM(conn))) {
1006 /*
1007 * Check to see if the only thing in this directory are
1008 * vetoed files/directories. If so then delete them and
1009 * retry. If we fail to delete any of them (and we *don't*
1010 * do a recursive delete) then fail the rmdir.
1011 */
1012 SMB_STRUCT_STAT st;
1013 const char *dname = NULL;
1014 char *talloced = NULL;
1015 long dirpos = 0;
1016 struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn,
1017 smb_dname->base_name, NULL,
1018 0);
1019
1020 if(dir_hnd == NULL) {
1021 errno = ENOTEMPTY;
1022 goto err;
1023 }
1024
1025 while ((dname = ReadDirName(dir_hnd, &dirpos, &st,
1026 &talloced)) != NULL) {
1027 if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0)) {
1028 TALLOC_FREE(talloced);
1029 continue;
1030 }
1031 if (!is_visible_file(conn, smb_dname->base_name, dname,
1032 &st, false)) {
1033 TALLOC_FREE(talloced);
1034 continue;
1035 }
1036 if(!IS_VETO_PATH(conn, dname)) {
1037 TALLOC_FREE(dir_hnd);
1038 TALLOC_FREE(talloced);
1039 errno = ENOTEMPTY;
1040 goto err;
1041 }
1042 TALLOC_FREE(talloced);
1043 }
1044
1045 /* We only have veto files/directories.
1046 * Are we allowed to delete them ? */
1047
1048 if(!lp_recursive_veto_delete(SNUM(conn))) {
1049 TALLOC_FREE(dir_hnd);
1050 errno = ENOTEMPTY;
1051 goto err;
1052 }
1053
1054 /* Do a recursive delete. */
1055 RewindDir(dir_hnd,&dirpos);
1056 while ((dname = ReadDirName(dir_hnd, &dirpos, &st,
1057 &talloced)) != NULL) {
1058 struct smb_filename *smb_dname_full = NULL;
1059 char *fullname = NULL;
1060 bool do_break = true;
1061
1062 if (ISDOT(dname) || ISDOTDOT(dname)) {
1063 TALLOC_FREE(talloced);
1064 continue;
1065 }
1066 if (!is_visible_file(conn, smb_dname->base_name, dname,
1067 &st, false)) {
1068 TALLOC_FREE(talloced);
1069 continue;
1070 }
1071
1072 fullname = talloc_asprintf(ctx,
1073 "%s/%s",
1074 smb_dname->base_name,
1075 dname);
1076
1077 if(!fullname) {
1078 errno = ENOMEM;
1079 goto err_break;
1080 }
1081
1082 smb_dname_full = synthetic_smb_fname(
1083 talloc_tos(), fullname, NULL, NULL);
1084 if (smb_dname_full == NULL) {
1085 errno = ENOMEM;
1086 goto err_break;
1087 }
1088
1089 if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
1090 goto err_break;
1091 }
1092 if(smb_dname_full->st.st_ex_mode & S_IFDIR) {
1093 if(!recursive_rmdir(ctx, conn,
1094 smb_dname_full)) {
1095 goto err_break;
1096 }
1097 if(SMB_VFS_RMDIR(conn,
1098 smb_dname_full->base_name) != 0) {
1099 goto err_break;
1100 }
1101 } else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) {
1102 goto err_break;
1103 }
1104
1105 /* Successful iteration. */
1106 do_break = false;
1107
1108 err_break:
1109 TALLOC_FREE(fullname);
1110 TALLOC_FREE(smb_dname_full);
1111 TALLOC_FREE(talloced);
1112 if (do_break)
1113 break;
1114 }
1115 TALLOC_FREE(dir_hnd);
1116 /* Retry the rmdir */
1117 ret = SMB_VFS_RMDIR(conn, smb_dname->base_name);
1118 }
1119
1120 err:
1121
1122 if (ret != 0) {
1123 DEBUG(3,("rmdir_internals: couldn't remove directory %s : "
1124 "%s\n", smb_fname_str_dbg(smb_dname),
1125 strerror(errno)));
1126 return map_nt_error_from_unix(errno);
1127 }
1128
1129 notify_fname(conn, NOTIFY_ACTION_REMOVED,
1130 FILE_NOTIFY_CHANGE_DIR_NAME,
1131 smb_dname->base_name);
1132
1133 return NT_STATUS_OK;
1134 }
1135
1136 /****************************************************************************
1137 Close a directory opened by an NT SMB call.
1138 ****************************************************************************/
1139
1140 static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp,
1141 enum file_close_type close_type)
1142 {
1143 struct server_id self = messaging_server_id(fsp->conn->sconn->msg_ctx);
1144 struct share_mode_lock *lck = NULL;
1145 bool delete_dir = False;
1146 NTSTATUS status = NT_STATUS_OK;
1147 NTSTATUS status1 = NT_STATUS_OK;
1148 const struct security_token *del_nt_token = NULL;
1149 const struct security_unix_token *del_token = NULL;
1150
1151 /*
1152 * NT can set delete_on_close of the last open
1153 * reference to a directory also.
1154 */
1155
1156 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1157 if (lck == NULL) {
1158 DEBUG(0, ("close_directory: Could not get share mode lock for "
1159 "%s\n", fsp_str_dbg(fsp)));
1160 return NT_STATUS_INVALID_PARAMETER;
1161 }
1162
1163 if (fsp->initial_delete_on_close) {
1164 bool became_user = False;
1165
1166 /* Initial delete on close was set - for
1167 * directories we don't care if anyone else
1168 * wrote a real delete on close. */
1169
1170 if (get_current_vuid(fsp->conn) != fsp->vuid) {
1171 become_user(fsp->conn, fsp->vuid);
1172 became_user = True;
1173 }
1174 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1175 fsp->fsp_name->base_name);
1176 set_delete_on_close_lck(fsp, lck, true,
1177 get_current_nttok(fsp->conn),
1178 get_current_utok(fsp->conn));
1179 fsp->delete_on_close = true;
1180 if (became_user) {
1181 unbecome_user();
1182 }
1183 }
1184
1185 delete_dir = get_delete_on_close_token(lck, fsp->name_hash,
1186 &del_nt_token, &del_token);
1187
1188 if (delete_dir) {
1189 int i;
1190 /* See if others still have the dir open. If this is the
1191 * case, then don't delete. If all opens are POSIX delete now. */
1192 for (i=0; i<lck->data->num_share_modes; i++) {
1193 struct share_mode_entry *e = &lck->data->share_modes[i];
1194 if (is_valid_share_mode_entry(e) &&
1195 e->name_hash == fsp->name_hash) {
1196 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
1197 continue;
1198 }
1199 if (serverid_equal(&self, &e->pid) &&
1200 (e->share_file_id == fsp->fh->gen_id)) {
1201 continue;
1202 }
1203 if (share_mode_stale_pid(lck->data, i)) {
1204 continue;
1205 }
1206 delete_dir = False;
1207 break;
1208 }
1209 }
1210 }
1211
1212 if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
1213 delete_dir) {
1214
1215 /* Become the user who requested the delete. */
1216
1217 if (!push_sec_ctx()) {
1218 smb_panic("close_directory: failed to push sec_ctx.\n");
1219 }
1220
1221 set_sec_ctx(del_token->uid,
1222 del_token->gid,
1223 del_token->ngroups,
1224 del_token->groups,
1225 del_nt_token);
1226
1227 if (!del_share_mode(lck, fsp)) {
1228 DEBUG(0, ("close_directory: Could not delete share entry for "
1229 "%s\n", fsp_str_dbg(fsp)));
1230 }
1231
1232 TALLOC_FREE(lck);
1233
1234 if ((fsp->conn->fs_capabilities & FILE_NAMED_STREAMS)
1235 && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
1236
1237 status = delete_all_streams(fsp->conn, fsp->fsp_name->base_name);
1238 if (!NT_STATUS_IS_OK(status)) {
1239 DEBUG(5, ("delete_all_streams failed: %s\n",
1240 nt_errstr(status)));
1241 return status;
1242 }
1243 }
1244
1245 status = rmdir_internals(talloc_tos(), fsp);
1246
1247 DEBUG(5,("close_directory: %s. Delete on close was set - "
1248 "deleting directory returned %s.\n",
1249 fsp_str_dbg(fsp), nt_errstr(status)));
1250
1251 /* unbecome user. */
1252 pop_sec_ctx();
1253
1254 /*
1255 * Ensure we remove any change notify requests that would
1256 * now fail as the directory has been deleted.
1257 */
1258
1259 if(NT_STATUS_IS_OK(status)) {
1260 remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING);
1261 }
1262 } else {
1263 if (!del_share_mode(lck, fsp)) {
1264 DEBUG(0, ("close_directory: Could not delete share entry for "
1265 "%s\n", fsp_str_dbg(fsp)));
1266 }
1267
1268 TALLOC_FREE(lck);
1269 remove_pending_change_notify_requests_by_fid(
1270 fsp, NT_STATUS_OK);
1271 }
1272
1273 status1 = fd_close(fsp);
1274
1275 if (!NT_STATUS_IS_OK(status1)) {
1276 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
1277 fsp_str_dbg(fsp), fsp->fh->fd, errno,
1278 strerror(errno)));
1279 }
1280
1281 /*
1282 * Do the code common to files and directories.
1283 */
1284 close_filestruct(fsp);
1285 file_free(req, fsp);
1286
1287 if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(status1)) {
1288 status = status1;
1289 }
1290 return status;
1291 }
1292
1293 /****************************************************************************
1294 Close a files_struct.
1295 ****************************************************************************/
1296
1297 NTSTATUS close_file(struct smb_request *req, files_struct *fsp,
1298 enum file_close_type close_type)
1299 {
1300 NTSTATUS status;
1301 struct files_struct *base_fsp = fsp->base_fsp;
1302
1303 if(fsp->is_directory) {
1304 status = close_directory(req, fsp, close_type);
1305 } else if (fsp->fake_file_handle != NULL) {
1306 status = close_fake_file(req, fsp);
1307 } else {
1308 status = close_normal_file(req, fsp, close_type);
1309 }
1310
1311 if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) {
1312
1313 /*
1314 * fsp was a stream, the base fsp can't be a stream as well
1315 *
1316 * For SHUTDOWN_CLOSE this is not possible here, because
1317 * SHUTDOWN_CLOSE only happens from files.c which walks the
1318 * complete list of files. If we mess with more than one fsp
1319 * those loops will become confused.
1320 */
1321
1322 SMB_ASSERT(base_fsp->base_fsp == NULL);
1323 close_file(req, base_fsp, close_type);
1324 }
1325
1326 return status;
1327 }
1328
1329 /****************************************************************************
1330 Deal with an (authorized) message to close a file given the share mode
1331 entry.
1332 ****************************************************************************/
1333
1334 void msg_close_file(struct messaging_context *msg_ctx,
1335 void *private_data,
1336 uint32_t msg_type,
1337 struct server_id server_id,
1338 DATA_BLOB *data)
1339 {
1340 files_struct *fsp = NULL;
1341 struct share_mode_entry e;
1342 struct smbd_server_connection *sconn =
1343 talloc_get_type_abort(private_data,
1344 struct smbd_server_connection);
1345
1346 message_to_share_mode_entry(&e, (char *)data->data);
1347
1348 if(DEBUGLVL(10)) {
1349 char *sm_str = share_mode_str(NULL, 0, &e);
1350 if (!sm_str) {
1351 smb_panic("talloc failed");
1352 }
1353 DEBUG(10,("msg_close_file: got request to close share mode "
1354 "entry %s\n", sm_str));
1355 TALLOC_FREE(sm_str);
1356 }
1357
1358 fsp = file_find_dif(sconn, e.id, e.share_file_id);
1359 if (!fsp) {
1360 DEBUG(10,("msg_close_file: failed to find file.\n"));
1361 return;
1362 }
1363 close_file(NULL, fsp, NORMAL_CLOSE);
1364 }
Working branch of Samba for id10ts