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