?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
smbd: Convert rmdir_internals to synthetic_smb_fname
[Samba/vl.git] / source3 / smbd / close.c
blob3ad346332e58a92ed225b289c7f49130b3b2d7d8
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 "fake_file.h"
28 #include "transfer_file.h"
29 #include "auth.h"
30 #include "messages.h"
31 #include "../librpc/gen_ndr/open_files.h"
32
33 /****************************************************************************
34 Run a file if it is a magic script.
35 ****************************************************************************/
36
37 static NTSTATUS check_magic(struct files_struct *fsp)
38 {
39 int ret;
40 const char *magic_output = NULL;
41 SMB_STRUCT_STAT st;
42 int tmp_fd, outfd;
43 TALLOC_CTX *ctx = NULL;
44 const char *p;
45 struct connection_struct *conn = fsp->conn;
46 char *fname = NULL;
47 NTSTATUS status;
48
49 if (!*lp_magicscript(talloc_tos(), SNUM(conn))) {
50 return NT_STATUS_OK;
51 }
52
53 DEBUG(5,("checking magic for %s\n", fsp_str_dbg(fsp)));
54
55 ctx = talloc_stackframe();
56
57 fname = fsp->fsp_name->base_name;
58
59 if (!(p = strrchr_m(fname,'/'))) {
60 p = fname;
61 } else {
62 p++;
63 }
64
65 if (!strequal(lp_magicscript(talloc_tos(), SNUM(conn)),p)) {
66 status = NT_STATUS_OK;
67 goto out;
68 }
69
70 if (*lp_magicoutput(talloc_tos(), SNUM(conn))) {
71 magic_output = lp_magicoutput(talloc_tos(), SNUM(conn));
72 } else {
73 magic_output = talloc_asprintf(ctx,
74 "%s.out",
75 fname);
76 }
77 if (!magic_output) {
78 status = NT_STATUS_NO_MEMORY;
79 goto out;
80 }
81
82 /* Ensure we don't depend on user's PATH. */
83 p = talloc_asprintf(ctx, "./%s", fname);
84 if (!p) {
85 status = NT_STATUS_NO_MEMORY;
86 goto out;
87 }
88
89 if (chmod(fname, 0755) == -1) {
90 status = map_nt_error_from_unix(errno);
91 goto out;
92 }
93 ret = smbrun(p,&tmp_fd);
94 DEBUG(3,("Invoking magic command %s gave %d\n",
95 p,ret));
96
97 unlink(fname);
98 if (ret != 0 || tmp_fd == -1) {
99 if (tmp_fd != -1) {
100 close(tmp_fd);
101 }
102 status = NT_STATUS_UNSUCCESSFUL;
103 goto out;
104 }
105 outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
106 if (outfd == -1) {
107 int err = errno;
108 close(tmp_fd);
109 status = map_nt_error_from_unix(err);
110 goto out;
111 }
112
113 if (sys_fstat(tmp_fd, &st, false) == -1) {
114 int err = errno;
115 close(tmp_fd);
116 close(outfd);
117 status = map_nt_error_from_unix(err);
118 goto out;
119 }
120
121 if (transfer_file(tmp_fd,outfd,(off_t)st.st_ex_size) == (off_t)-1) {
122 int err = errno;
123 close(tmp_fd);
124 close(outfd);
125 status = map_nt_error_from_unix(err);
126 goto out;
127 }
128 close(tmp_fd);
129 if (close(outfd) == -1) {
130 status = map_nt_error_from_unix(errno);
131 goto out;
132 }
133
134 status = NT_STATUS_OK;
135
136 out:
137 TALLOC_FREE(ctx);
138 return status;
139 }
140
141 /****************************************************************************
142 Common code to close a file or a directory.
143 ****************************************************************************/
144
145 static NTSTATUS close_filestruct(files_struct *fsp)
146 {
147 NTSTATUS status = NT_STATUS_OK;
148
149 if (fsp->fh->fd != -1) {
150 if(flush_write_cache(fsp, CLOSE_FLUSH) == -1) {
151 status = map_nt_error_from_unix(errno);
152 }
153 delete_write_cache(fsp);
154 }
155
156 return status;
157 }
158
159 static int compare_share_mode_times(const void *p1, const void *p2)
160 {
161 const struct share_mode_entry *s1 = (const struct share_mode_entry *)p1;
162 const struct share_mode_entry *s2 = (const struct share_mode_entry *)p2;
163 return timeval_compare(&s1->time, &s2->time);
164 }
165
166 /****************************************************************************
167 If any deferred opens are waiting on this close, notify them.
168 ****************************************************************************/
169
170 static void notify_deferred_opens(struct smbd_server_connection *sconn,
171 struct share_mode_lock *lck)
172 {
173 struct server_id self = messaging_server_id(sconn->msg_ctx);
174 uint32_t i, num_deferred;
175 struct share_mode_entry *deferred;
176
177 if (!should_notify_deferred_opens(sconn)) {
178 return;
179 }
180
181 num_deferred = 0;
182 for (i=0; i<lck->data->num_share_modes; i++) {
183 struct share_mode_entry *e = &lck->data->share_modes[i];
184
185 if (!is_deferred_open_entry(e)) {
186 continue;
187 }
188 if (share_mode_stale_pid(lck->data, i)) {
189 continue;
190 }
191 num_deferred += 1;
192 }
193 if (num_deferred == 0) {
194 return;
195 }
196
197 deferred = talloc_array(talloc_tos(), struct share_mode_entry,
198 num_deferred);
199 if (deferred == NULL) {
200 return;
201 }
202
203 num_deferred = 0;
204 for (i=0; i<lck->data->num_share_modes; i++) {
205 struct share_mode_entry *e = &lck->data->share_modes[i];
206 if (is_deferred_open_entry(e)) {
207 deferred[num_deferred] = *e;
208 num_deferred += 1;
209 }
210 }
211
212 /*
213 * We need to sort the notifications by initial request time. Imagine
214 * two opens come in asyncronously, both conflicting with the open we
215 * just close here. If we don't sort the notifications, the one that
216 * came in last might get the response before the one that came in
217 * first. This is demonstrated with the smbtorture4 raw.mux test.
218 *
219 * As long as we had the UNUSED_SHARE_MODE_ENTRY, we happened to
220 * survive this particular test. Without UNUSED_SHARE_MODE_ENTRY, we
221 * shuffle the share mode entries around a bit, so that we do not
222 * survive raw.mux anymore.
223 *
224 * We could have kept the ordering in del_share_mode, but as the
225 * ordering was never formalized I think it is better to do it here
226 * where it is necessary.
227 */
228
229 qsort(deferred, num_deferred, sizeof(struct share_mode_entry),
230 compare_share_mode_times);
231
232 for (i=0; i<num_deferred; i++) {
233 struct share_mode_entry *e = &deferred[i];
234
235 if (serverid_equal(&self, &e->pid)) {
236 /*
237 * We need to notify ourself to retry the open. Do
238 * this by finding the queued SMB record, moving it to
239 * the head of the queue and changing the wait time to
240 * zero.
241 */
242 schedule_deferred_open_message_smb(sconn, e->op_mid);
243 } else {
244 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
245
246 share_mode_entry_to_message(msg, e);
247
248 messaging_send_buf(sconn->msg_ctx, e->pid,
249 MSG_SMB_OPEN_RETRY,
250 (uint8 *)msg,
251 MSG_SMB_SHARE_MODE_ENTRY_SIZE);
252 }
253 }
254 TALLOC_FREE(deferred);
255 }
256
257 /****************************************************************************
258 Delete all streams
259 ****************************************************************************/
260
261 NTSTATUS delete_all_streams(connection_struct *conn, const char *fname)
262 {
263 struct stream_struct *stream_info = NULL;
264 int i;
265 unsigned int num_streams = 0;
266 TALLOC_CTX *frame = talloc_stackframe();
267 NTSTATUS status;
268
269 status = vfs_streaminfo(conn, NULL, fname, talloc_tos(),
270 &num_streams, &stream_info);
271
272 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
273 DEBUG(10, ("no streams around\n"));
274 TALLOC_FREE(frame);
275 return NT_STATUS_OK;
276 }
277
278 if (!NT_STATUS_IS_OK(status)) {
279 DEBUG(10, ("vfs_streaminfo failed: %s\n",
280 nt_errstr(status)));
281 goto fail;
282 }
283
284 DEBUG(10, ("delete_all_streams found %d streams\n",
285 num_streams));
286
287 if (num_streams == 0) {
288 TALLOC_FREE(frame);
289 return NT_STATUS_OK;
290 }
291
292 for (i=0; i<num_streams; i++) {
293 int res;
294 struct smb_filename *smb_fname_stream;
295
296 if (strequal(stream_info[i].name, "::$DATA")) {
297 continue;
298 }
299
300 smb_fname_stream = synthetic_smb_fname(
301 talloc_tos(), fname, stream_info[i].name, NULL);
302
303 if (smb_fname_stream == NULL) {
304 DEBUG(0, ("talloc_aprintf failed\n"));
305 status = NT_STATUS_NO_MEMORY;
306 goto fail;
307 }
308
309 res = SMB_VFS_UNLINK(conn, smb_fname_stream);
310
311 if (res == -1) {
312 status = map_nt_error_from_unix(errno);
313 DEBUG(10, ("Could not delete stream %s: %s\n",
314 smb_fname_str_dbg(smb_fname_stream),
315 strerror(errno)));
316 TALLOC_FREE(smb_fname_stream);
317 break;
318 }
319 TALLOC_FREE(smb_fname_stream);
320 }
321
322 fail:
323 TALLOC_FREE(frame);
324 return status;
325 }
326
327 /****************************************************************************
328 Deal with removing a share mode on last close.
329 ****************************************************************************/
330
331 static NTSTATUS close_remove_share_mode(files_struct *fsp,
332 enum file_close_type close_type)
333 {
334 connection_struct *conn = fsp->conn;
335 struct server_id self = messaging_server_id(conn->sconn->msg_ctx);
336 bool delete_file = false;
337 bool changed_user = false;
338 struct share_mode_lock *lck = NULL;
339 NTSTATUS status = NT_STATUS_OK;
340 NTSTATUS tmp_status;
341 struct file_id id;
342 const struct security_unix_token *del_token = NULL;
343 const struct security_token *del_nt_token = NULL;
344 bool got_tokens = false;
345 bool normal_close;
346
347 /* Ensure any pending write time updates are done. */
348 if (fsp->update_write_time_event) {
349 update_write_time_handler(fsp->conn->sconn->ev_ctx,
350 fsp->update_write_time_event,
351 timeval_current(),
352 (void *)fsp);
353 }
354
355 /*
356 * Lock the share entries, and determine if we should delete
357 * on close. If so delete whilst the lock is still in effect.
358 * This prevents race conditions with the file being created. JRA.
359 */
360
361 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
362 if (lck == NULL) {
363 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
364 "lock for file %s\n", fsp_str_dbg(fsp)));
365 return NT_STATUS_INVALID_PARAMETER;
366 }
367
368 if (fsp->write_time_forced) {
369 DEBUG(10,("close_remove_share_mode: write time forced "
370 "for file %s\n",
371 fsp_str_dbg(fsp)));
372 set_close_write_time(fsp, lck->data->changed_write_time);
373 } else if (fsp->update_write_time_on_close) {
374 /* Someone had a pending write. */
375 if (null_timespec(fsp->close_write_time)) {
376 DEBUG(10,("close_remove_share_mode: update to current time "
377 "for file %s\n",
378 fsp_str_dbg(fsp)));
379 /* Update to current time due to "normal" write. */
380 set_close_write_time(fsp, timespec_current());
381 } else {
382 DEBUG(10,("close_remove_share_mode: write time pending "
383 "for file %s\n",
384 fsp_str_dbg(fsp)));
385 /* Update to time set on close call. */
386 set_close_write_time(fsp, fsp->close_write_time);
387 }
388 }
389
390 if (fsp->initial_delete_on_close &&
391 !is_delete_on_close_set(lck, fsp->name_hash)) {
392 bool became_user = False;
393
394 /* Initial delete on close was set and no one else
395 * wrote a real delete on close. */
396
397 if (get_current_vuid(conn) != fsp->vuid) {
398 become_user(conn, fsp->vuid);
399 became_user = True;
400 }
401 fsp->delete_on_close = true;
402 set_delete_on_close_lck(fsp, lck, True,
403 get_current_nttok(conn),
404 get_current_utok(conn));
405 if (became_user) {
406 unbecome_user();
407 }
408 }
409
410 delete_file = is_delete_on_close_set(lck, fsp->name_hash);
411
412 if (delete_file) {
413 int i;
414 /* See if others still have the file open via this pathname.
415 If this is the case, then don't delete. If all opens are
416 POSIX delete now. */
417 for (i=0; i<lck->data->num_share_modes; i++) {
418 struct share_mode_entry *e = &lck->data->share_modes[i];
419
420 if (!is_valid_share_mode_entry(e)) {
421 continue;
422 }
423 if (e->name_hash != fsp->name_hash) {
424 continue;
425 }
426 if (fsp->posix_open
427 && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
428 continue;
429 }
430 if (serverid_equal(&self, &e->pid) &&
431 (e->share_file_id == fsp->fh->gen_id)) {
432 continue;
433 }
434 if (share_mode_stale_pid(lck->data, i)) {
435 continue;
436 }
437 delete_file = False;
438 break;
439 }
440 }
441
442 /* Notify any deferred opens waiting on this close. */
443 notify_deferred_opens(conn->sconn, lck);
444 reply_to_oplock_break_requests(fsp);
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 } else {
795 DEBUG(1, ("Failed to disconnect durable handle for "
796 "file %s: %s - proceeding with normal "
797 "close\n", fsp_str_dbg(fsp), nt_errstr(tmp)));
798 }
799 if (!NT_STATUS_IS_OK(tmp)) {
800 is_durable = false;
801 }
802 }
803
804 if (is_durable) {
805 /*
806 * This is the case where we successfully disconnected
807 * a durable handle and closed the underlying file.
808 * In all other cases, we proceed with a genuine close.
809 */
810 DEBUG(10, ("%s disconnected durable handle for file %s\n",
811 conn->session_info->unix_info->unix_name,
812 fsp_str_dbg(fsp)));
813 file_free(req, fsp);
814 return NT_STATUS_OK;
815 }
816
817 if (fsp->op != NULL) {
818 /*
819 * Make sure the handle is not marked as durable anymore
820 */
821 fsp->op->global->durable = false;
822 }
823
824 if (fsp->print_file) {
825 /* FIXME: return spool errors */
826 print_spool_end(fsp, close_type);
827 file_free(req, fsp);
828 return NT_STATUS_OK;
829 }
830
831 /* Remove the oplock before potentially deleting the file. */
832 if(fsp->oplock_type) {
833 release_file_oplock(fsp);
834 }
835
836 /* If this is an old DOS or FCB open and we have multiple opens on
837 the same handle we only have one share mode. Ensure we only remove
838 the share mode on the last close. */
839
840 if (fsp->fh->ref_count == 1) {
841 /* Should we return on error here... ? */
842 tmp = close_remove_share_mode(fsp, close_type);
843 status = ntstatus_keeperror(status, tmp);
844 }
845
846 locking_close_file(conn->sconn->msg_ctx, fsp, close_type);
847
848 tmp = fd_close(fsp);
849 status = ntstatus_keeperror(status, tmp);
850
851 /* check for magic scripts */
852 if (close_type == NORMAL_CLOSE) {
853 tmp = check_magic(fsp);
854 status = ntstatus_keeperror(status, tmp);
855 }
856
857 /*
858 * Ensure pending modtime is set after close.
859 */
860
861 tmp = update_write_time_on_close(fsp);
862 if (NT_STATUS_EQUAL(tmp, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
863 /* Someone renamed the file or a parent directory containing
864 * this file. We can't do anything about this, we don't have
865 * an "update timestamp by fd" call in POSIX. Eat the error. */
866
867 tmp = NT_STATUS_OK;
868 }
869
870 status = ntstatus_keeperror(status, tmp);
871
872 DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
873 conn->session_info->unix_info->unix_name, fsp_str_dbg(fsp),
874 conn->num_files_open - 1,
875 nt_errstr(status) ));
876
877 file_free(req, fsp);
878 return status;
879 }
880 /****************************************************************************
881 Function used by reply_rmdir to delete an entire directory
882 tree recursively. Return True on ok, False on fail.
883 ****************************************************************************/
884
885 bool recursive_rmdir(TALLOC_CTX *ctx,
886 connection_struct *conn,
887 struct smb_filename *smb_dname)
888 {
889 const char *dname = NULL;
890 char *talloced = NULL;
891 bool ret = True;
892 long offset = 0;
893 SMB_STRUCT_STAT st;
894 struct smb_Dir *dir_hnd;
895
896 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
897
898 dir_hnd = OpenDir(talloc_tos(), conn, smb_dname->base_name, NULL, 0);
899 if(dir_hnd == NULL)
900 return False;
901
902 while((dname = ReadDirName(dir_hnd, &offset, &st, &talloced))) {
903 struct smb_filename *smb_dname_full = NULL;
904 char *fullname = NULL;
905 bool do_break = true;
906
907 if (ISDOT(dname) || ISDOTDOT(dname)) {
908 TALLOC_FREE(talloced);
909 continue;
910 }
911
912 if (!is_visible_file(conn, smb_dname->base_name, dname, &st,
913 false)) {
914 TALLOC_FREE(talloced);
915 continue;
916 }
917
918 /* Construct the full name. */
919 fullname = talloc_asprintf(ctx,
920 "%s/%s",
921 smb_dname->base_name,
922 dname);
923 if (!fullname) {
924 errno = ENOMEM;
925 goto err_break;
926 }
927
928 smb_dname_full = synthetic_smb_fname(talloc_tos(), fullname,
929 NULL, NULL);
930 if (smb_dname_full == NULL) {
931 errno = ENOMEM;
932 goto err_break;
933 }
934
935 if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
936 goto err_break;
937 }
938
939 if(smb_dname_full->st.st_ex_mode & S_IFDIR) {
940 if(!recursive_rmdir(ctx, conn, smb_dname_full)) {
941 goto err_break;
942 }
943 if(SMB_VFS_RMDIR(conn,
944 smb_dname_full->base_name) != 0) {
945 goto err_break;
946 }
947 } else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) {
948 goto err_break;
949 }
950
951 /* Successful iteration. */
952 do_break = false;
953
954 err_break:
955 TALLOC_FREE(smb_dname_full);
956 TALLOC_FREE(fullname);
957 TALLOC_FREE(talloced);
958 if (do_break) {
959 ret = false;
960 break;
961 }
962 }
963 TALLOC_FREE(dir_hnd);
964 return ret;
965 }
966
967 /****************************************************************************
968 The internals of the rmdir code - called elsewhere.
969 ****************************************************************************/
970
971 static NTSTATUS rmdir_internals(TALLOC_CTX *ctx, files_struct *fsp)
972 {
973 connection_struct *conn = fsp->conn;
974 struct smb_filename *smb_dname = fsp->fsp_name;
975 int ret;
976
977 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
978
979 /* Might be a symlink. */
980 if(SMB_VFS_LSTAT(conn, smb_dname) != 0) {
981 return map_nt_error_from_unix(errno);
982 }
983
984 if (S_ISLNK(smb_dname->st.st_ex_mode)) {
985 /* Is what it points to a directory ? */
986 if(SMB_VFS_STAT(conn, smb_dname) != 0) {
987 return map_nt_error_from_unix(errno);
988 }
989 if (!(S_ISDIR(smb_dname->st.st_ex_mode))) {
990 return NT_STATUS_NOT_A_DIRECTORY;
991 }
992 ret = SMB_VFS_UNLINK(conn, smb_dname);
993 } else {
994 ret = SMB_VFS_RMDIR(conn, smb_dname->base_name);
995 }
996 if (ret == 0) {
997 notify_fname(conn, NOTIFY_ACTION_REMOVED,
998 FILE_NOTIFY_CHANGE_DIR_NAME,
999 smb_dname->base_name);
1000 return NT_STATUS_OK;
1001 }
1002
1003 if(((errno == ENOTEMPTY)||(errno == EEXIST)) && *lp_veto_files(talloc_tos(), SNUM(conn))) {
1004 /*
1005 * Check to see if the only thing in this directory are
1006 * vetoed files/directories. If so then delete them and
1007 * retry. If we fail to delete any of them (and we *don't*
1008 * do a recursive delete) then fail the rmdir.
1009 */
1010 SMB_STRUCT_STAT st;
1011 const char *dname = NULL;
1012 char *talloced = NULL;
1013 long dirpos = 0;
1014 struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn,
1015 smb_dname->base_name, NULL,
1016 0);
1017
1018 if(dir_hnd == NULL) {
1019 errno = ENOTEMPTY;
1020 goto err;
1021 }
1022
1023 while ((dname = ReadDirName(dir_hnd, &dirpos, &st,
1024 &talloced)) != NULL) {
1025 if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0)) {
1026 TALLOC_FREE(talloced);
1027 continue;
1028 }
1029 if (!is_visible_file(conn, smb_dname->base_name, dname,
1030 &st, false)) {
1031 TALLOC_FREE(talloced);
1032 continue;
1033 }
1034 if(!IS_VETO_PATH(conn, dname)) {
1035 TALLOC_FREE(dir_hnd);
1036 TALLOC_FREE(talloced);
1037 errno = ENOTEMPTY;
1038 goto err;
1039 }
1040 TALLOC_FREE(talloced);
1041 }
1042
1043 /* We only have veto files/directories.
1044 * Are we allowed to delete them ? */
1045
1046 if(!lp_recursive_veto_delete(SNUM(conn))) {
1047 TALLOC_FREE(dir_hnd);
1048 errno = ENOTEMPTY;
1049 goto err;
1050 }
1051
1052 /* Do a recursive delete. */
1053 RewindDir(dir_hnd,&dirpos);
1054 while ((dname = ReadDirName(dir_hnd, &dirpos, &st,
1055 &talloced)) != NULL) {
1056 struct smb_filename *smb_dname_full = NULL;
1057 char *fullname = NULL;
1058 bool do_break = true;
1059
1060 if (ISDOT(dname) || ISDOTDOT(dname)) {
1061 TALLOC_FREE(talloced);
1062 continue;
1063 }
1064 if (!is_visible_file(conn, smb_dname->base_name, dname,
1065 &st, false)) {
1066 TALLOC_FREE(talloced);
1067 continue;
1068 }
1069
1070 fullname = talloc_asprintf(ctx,
1071 "%s/%s",
1072 smb_dname->base_name,
1073 dname);
1074
1075 if(!fullname) {
1076 errno = ENOMEM;
1077 goto err_break;
1078 }
1079
1080 smb_dname_full = synthetic_smb_fname(
1081 talloc_tos(), fullname, NULL, NULL);
1082 if (smb_dname_full == NULL) {
1083 errno = ENOMEM;
1084 goto err_break;
1085 }
1086
1087 if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
1088 goto err_break;
1089 }
1090 if(smb_dname_full->st.st_ex_mode & S_IFDIR) {
1091 if(!recursive_rmdir(ctx, conn,
1092 smb_dname_full)) {
1093 goto err_break;
1094 }
1095 if(SMB_VFS_RMDIR(conn,
1096 smb_dname_full->base_name) != 0) {
1097 goto err_break;
1098 }
1099 } else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) {
1100 goto err_break;
1101 }
1102
1103 /* Successful iteration. */
1104 do_break = false;
1105
1106 err_break:
1107 TALLOC_FREE(fullname);
1108 TALLOC_FREE(smb_dname_full);
1109 TALLOC_FREE(talloced);
1110 if (do_break)
1111 break;
1112 }
1113 TALLOC_FREE(dir_hnd);
1114 /* Retry the rmdir */
1115 ret = SMB_VFS_RMDIR(conn, smb_dname->base_name);
1116 }
1117
1118 err:
1119
1120 if (ret != 0) {
1121 DEBUG(3,("rmdir_internals: couldn't remove directory %s : "
1122 "%s\n", smb_fname_str_dbg(smb_dname),
1123 strerror(errno)));
1124 return map_nt_error_from_unix(errno);
1125 }
1126
1127 notify_fname(conn, NOTIFY_ACTION_REMOVED,
1128 FILE_NOTIFY_CHANGE_DIR_NAME,
1129 smb_dname->base_name);
1130
1131 return NT_STATUS_OK;
1132 }
1133
1134 /****************************************************************************
1135 Close a directory opened by an NT SMB call.
1136 ****************************************************************************/
1137
1138 static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp,
1139 enum file_close_type close_type)
1140 {
1141 struct server_id self = messaging_server_id(fsp->conn->sconn->msg_ctx);
1142 struct share_mode_lock *lck = NULL;
1143 bool delete_dir = False;
1144 NTSTATUS status = NT_STATUS_OK;
1145 NTSTATUS status1 = NT_STATUS_OK;
1146 const struct security_token *del_nt_token = NULL;
1147 const struct security_unix_token *del_token = NULL;
1148
1149 /*
1150 * NT can set delete_on_close of the last open
1151 * reference to a directory also.
1152 */
1153
1154 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1155 if (lck == NULL) {
1156 DEBUG(0, ("close_directory: Could not get share mode lock for "
1157 "%s\n", fsp_str_dbg(fsp)));
1158 return NT_STATUS_INVALID_PARAMETER;
1159 }
1160
1161 if (fsp->initial_delete_on_close) {
1162 bool became_user = False;
1163
1164 /* Initial delete on close was set - for
1165 * directories we don't care if anyone else
1166 * wrote a real delete on close. */
1167
1168 if (get_current_vuid(fsp->conn) != fsp->vuid) {
1169 become_user(fsp->conn, fsp->vuid);
1170 became_user = True;
1171 }
1172 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1173 fsp->fsp_name->base_name);
1174 set_delete_on_close_lck(fsp, lck, true,
1175 get_current_nttok(fsp->conn),
1176 get_current_utok(fsp->conn));
1177 fsp->delete_on_close = true;
1178 if (became_user) {
1179 unbecome_user();
1180 }
1181 }
1182
1183 delete_dir = get_delete_on_close_token(lck, fsp->name_hash,
1184 &del_nt_token, &del_token);
1185
1186 if (delete_dir) {
1187 int i;
1188 /* See if others still have the dir open. If this is the
1189 * case, then don't delete. If all opens are POSIX delete now. */
1190 for (i=0; i<lck->data->num_share_modes; i++) {
1191 struct share_mode_entry *e = &lck->data->share_modes[i];
1192 if (is_valid_share_mode_entry(e) &&
1193 e->name_hash == fsp->name_hash) {
1194 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
1195 continue;
1196 }
1197 if (serverid_equal(&self, &e->pid) &&
1198 (e->share_file_id == fsp->fh->gen_id)) {
1199 continue;
1200 }
1201 if (share_mode_stale_pid(lck->data, i)) {
1202 continue;
1203 }
1204 delete_dir = False;
1205 break;
1206 }
1207 }
1208 }
1209
1210 if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
1211 delete_dir) {
1212
1213 /* Become the user who requested the delete. */
1214
1215 if (!push_sec_ctx()) {
1216 smb_panic("close_directory: failed to push sec_ctx.\n");
1217 }
1218
1219 set_sec_ctx(del_token->uid,
1220 del_token->gid,
1221 del_token->ngroups,
1222 del_token->groups,
1223 del_nt_token);
1224
1225 if (!del_share_mode(lck, fsp)) {
1226 DEBUG(0, ("close_directory: Could not delete share entry for "
1227 "%s\n", fsp_str_dbg(fsp)));
1228 }
1229
1230 TALLOC_FREE(lck);
1231
1232 if ((fsp->conn->fs_capabilities & FILE_NAMED_STREAMS)
1233 && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
1234
1235 status = delete_all_streams(fsp->conn, fsp->fsp_name->base_name);
1236 if (!NT_STATUS_IS_OK(status)) {
1237 DEBUG(5, ("delete_all_streams failed: %s\n",
1238 nt_errstr(status)));
1239 return status;
1240 }
1241 }
1242
1243 status = rmdir_internals(talloc_tos(), fsp);
1244
1245 DEBUG(5,("close_directory: %s. Delete on close was set - "
1246 "deleting directory returned %s.\n",
1247 fsp_str_dbg(fsp), nt_errstr(status)));
1248
1249 /* unbecome user. */
1250 pop_sec_ctx();
1251
1252 /*
1253 * Ensure we remove any change notify requests that would
1254 * now fail as the directory has been deleted.
1255 */
1256
1257 if(NT_STATUS_IS_OK(status)) {
1258 remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING);
1259 }
1260 } else {
1261 if (!del_share_mode(lck, fsp)) {
1262 DEBUG(0, ("close_directory: Could not delete share entry for "
1263 "%s\n", fsp_str_dbg(fsp)));
1264 }
1265
1266 TALLOC_FREE(lck);
1267 remove_pending_change_notify_requests_by_fid(
1268 fsp, NT_STATUS_OK);
1269 }
1270
1271 status1 = fd_close(fsp);
1272
1273 if (!NT_STATUS_IS_OK(status1)) {
1274 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
1275 fsp_str_dbg(fsp), fsp->fh->fd, errno,
1276 strerror(errno)));
1277 }
1278
1279 /*
1280 * Do the code common to files and directories.
1281 */
1282 close_filestruct(fsp);
1283 file_free(req, fsp);
1284
1285 if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(status1)) {
1286 status = status1;
1287 }
1288 return status;
1289 }
1290
1291 /****************************************************************************
1292 Close a files_struct.
1293 ****************************************************************************/
1294
1295 NTSTATUS close_file(struct smb_request *req, files_struct *fsp,
1296 enum file_close_type close_type)
1297 {
1298 NTSTATUS status;
1299 struct files_struct *base_fsp = fsp->base_fsp;
1300
1301 if(fsp->is_directory) {
1302 status = close_directory(req, fsp, close_type);
1303 } else if (fsp->fake_file_handle != NULL) {
1304 status = close_fake_file(req, fsp);
1305 } else {
1306 status = close_normal_file(req, fsp, close_type);
1307 }
1308
1309 if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) {
1310
1311 /*
1312 * fsp was a stream, the base fsp can't be a stream as well
1313 *
1314 * For SHUTDOWN_CLOSE this is not possible here, because
1315 * SHUTDOWN_CLOSE only happens from files.c which walks the
1316 * complete list of files. If we mess with more than one fsp
1317 * those loops will become confused.
1318 */
1319
1320 SMB_ASSERT(base_fsp->base_fsp == NULL);
1321 close_file(req, base_fsp, close_type);
1322 }
1323
1324 return status;
1325 }
1326
1327 /****************************************************************************
1328 Deal with an (authorized) message to close a file given the share mode
1329 entry.
1330 ****************************************************************************/
1331
1332 void msg_close_file(struct messaging_context *msg_ctx,
1333 void *private_data,
1334 uint32_t msg_type,
1335 struct server_id server_id,
1336 DATA_BLOB *data)
1337 {
1338 files_struct *fsp = NULL;
1339 struct share_mode_entry e;
1340 struct smbd_server_connection *sconn =
1341 talloc_get_type_abort(private_data,
1342 struct smbd_server_connection);
1343
1344 message_to_share_mode_entry(&e, (char *)data->data);
1345
1346 if(DEBUGLVL(10)) {
1347 char *sm_str = share_mode_str(NULL, 0, &e);
1348 if (!sm_str) {
1349 smb_panic("talloc failed");
1350 }
1351 DEBUG(10,("msg_close_file: got request to close share mode "
1352 "entry %s\n", sm_str));
1353 TALLOC_FREE(sm_str);
1354 }
1355
1356 fsp = file_find_dif(sconn, e.id, e.share_file_id);
1357 if (!fsp) {
1358 DEBUG(10,("msg_close_file: failed to find file.\n"));
1359 return;
1360 }
1361 close_file(NULL, fsp, NORMAL_CLOSE);
1362 }