?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:dsdb:tests: Also pass tests if asserted identity is present
[Samba.git] / source3 / smbd / close.c
bloba4bdd56729a0a9e0bc7ac49c3ef1e04b1c552a9d
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 "lib/util/server_id.h"
25 #include "printing.h"
26 #include "locking/share_mode_lock.h"
27 #include "smbd/smbd.h"
28 #include "smbd/globals.h"
29 #include "smbd/smbXsrv_open.h"
30 #include "smbd/scavenger.h"
31 #include "fake_file.h"
32 #include "transfer_file.h"
33 #include "auth.h"
34 #include "messages.h"
35 #include "../librpc/gen_ndr/open_files.h"
36 #include "lib/util/tevent_ntstatus.h"
37
38 /****************************************************************************
39 Run a file if it is a magic script.
40 ****************************************************************************/
41
42 static NTSTATUS check_magic(struct files_struct *fsp)
43 {
44 int ret;
45 const struct loadparm_substitution *lp_sub =
46 loadparm_s3_global_substitution();
47 const char *magic_output = NULL;
48 SMB_STRUCT_STAT st;
49 int tmp_fd, outfd;
50 TALLOC_CTX *ctx = NULL;
51 const char *p;
52 struct connection_struct *conn = fsp->conn;
53 char *fname = NULL;
54 NTSTATUS status;
55
56 if (!*lp_magic_script(talloc_tos(), lp_sub, SNUM(conn))) {
57 return NT_STATUS_OK;
58 }
59
60 DEBUG(5,("checking magic for %s\n", fsp_str_dbg(fsp)));
61
62 ctx = talloc_stackframe();
63
64 fname = fsp->fsp_name->base_name;
65
66 if (!(p = strrchr_m(fname,'/'))) {
67 p = fname;
68 } else {
69 p++;
70 }
71
72 if (!strequal(lp_magic_script(talloc_tos(), lp_sub, SNUM(conn)),p)) {
73 status = NT_STATUS_OK;
74 goto out;
75 }
76
77 if (*lp_magic_output(talloc_tos(), lp_sub, SNUM(conn))) {
78 magic_output = lp_magic_output(talloc_tos(), lp_sub, SNUM(conn));
79 } else {
80 magic_output = talloc_asprintf(ctx,
81 "%s.out",
82 fname);
83 }
84 if (!magic_output) {
85 status = NT_STATUS_NO_MEMORY;
86 goto out;
87 }
88
89 /* Ensure we don't depend on user's PATH. */
90 p = talloc_asprintf(ctx, "./%s", fname);
91 if (!p) {
92 status = NT_STATUS_NO_MEMORY;
93 goto out;
94 }
95
96 if (chmod(fname, 0755) == -1) {
97 status = map_nt_error_from_unix(errno);
98 goto out;
99 }
100 ret = smbrun(p, &tmp_fd, NULL);
101 DEBUG(3,("Invoking magic command %s gave %d\n",
102 p,ret));
103
104 unlink(fname);
105 if (ret != 0 || tmp_fd == -1) {
106 if (tmp_fd != -1) {
107 close(tmp_fd);
108 }
109 status = NT_STATUS_UNSUCCESSFUL;
110 goto out;
111 }
112 outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
113 if (outfd == -1) {
114 int err = errno;
115 close(tmp_fd);
116 status = map_nt_error_from_unix(err);
117 goto out;
118 }
119
120 if (sys_fstat(tmp_fd, &st, false) == -1) {
121 int err = errno;
122 close(tmp_fd);
123 close(outfd);
124 status = map_nt_error_from_unix(err);
125 goto out;
126 }
127
128 if (transfer_file(tmp_fd,outfd,(off_t)st.st_ex_size) == (off_t)-1) {
129 int err = errno;
130 close(tmp_fd);
131 close(outfd);
132 status = map_nt_error_from_unix(err);
133 goto out;
134 }
135 close(tmp_fd);
136 if (close(outfd) == -1) {
137 status = map_nt_error_from_unix(errno);
138 goto out;
139 }
140
141 status = NT_STATUS_OK;
142
143 out:
144 TALLOC_FREE(ctx);
145 return status;
146 }
147
148 /****************************************************************************
149 Delete all streams
150 ****************************************************************************/
151
152 NTSTATUS delete_all_streams(connection_struct *conn,
153 const struct smb_filename *smb_fname)
154 {
155 struct stream_struct *stream_info = NULL;
156 unsigned int i;
157 unsigned int num_streams = 0;
158 TALLOC_CTX *frame = talloc_stackframe();
159 NTSTATUS status;
160
161 status = vfs_fstreaminfo(smb_fname->fsp, talloc_tos(),
162 &num_streams, &stream_info);
163
164 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
165 DEBUG(10, ("no streams around\n"));
166 TALLOC_FREE(frame);
167 return NT_STATUS_OK;
168 }
169
170 if (!NT_STATUS_IS_OK(status)) {
171 DEBUG(10, ("vfs_fstreaminfo failed: %s\n",
172 nt_errstr(status)));
173 goto fail;
174 }
175
176 DEBUG(10, ("delete_all_streams found %d streams\n",
177 num_streams));
178
179 if (num_streams == 0) {
180 TALLOC_FREE(frame);
181 return NT_STATUS_OK;
182 }
183
184 for (i=0; i<num_streams; i++) {
185 int res;
186 struct smb_filename *smb_fname_stream;
187
188 if (strequal(stream_info[i].name, "::$DATA")) {
189 continue;
190 }
191
192 status = synthetic_pathref(talloc_tos(),
193 conn->cwd_fsp,
194 smb_fname->base_name,
195 stream_info[i].name,
196 NULL,
197 smb_fname->twrp,
198 (smb_fname->flags &
199 ~SMB_FILENAME_POSIX_PATH),
200 &smb_fname_stream);
201 if (!NT_STATUS_IS_OK(status)) {
202 DEBUG(0, ("talloc_aprintf failed\n"));
203 status = NT_STATUS_NO_MEMORY;
204 goto fail;
205 }
206
207 res = SMB_VFS_UNLINKAT(conn,
208 conn->cwd_fsp,
209 smb_fname_stream,
210 0);
211
212 if (res == -1) {
213 status = map_nt_error_from_unix(errno);
214 DEBUG(10, ("Could not delete stream %s: %s\n",
215 smb_fname_str_dbg(smb_fname_stream),
216 strerror(errno)));
217 TALLOC_FREE(smb_fname_stream);
218 break;
219 }
220 TALLOC_FREE(smb_fname_stream);
221 }
222
223 fail:
224 TALLOC_FREE(frame);
225 return status;
226 }
227
228 struct has_other_nonposix_opens_state {
229 files_struct *fsp;
230 bool found_another;
231 };
232
233 static bool has_other_nonposix_opens_fn(
234 struct share_mode_entry *e,
235 bool *modified,
236 void *private_data)
237 {
238 struct has_other_nonposix_opens_state *state = private_data;
239 struct files_struct *fsp = state->fsp;
240
241 if (e->name_hash != fsp->name_hash) {
242 return false;
243 }
244 if ((fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) &&
245 (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
246 return false;
247 }
248 if (e->share_file_id == fh_get_gen_id(fsp->fh)) {
249 struct server_id self = messaging_server_id(
250 fsp->conn->sconn->msg_ctx);
251 if (server_id_equal(&self, &e->pid)) {
252 return false;
253 }
254 }
255 if (share_entry_stale_pid(e)) {
256 return false;
257 }
258
259 state->found_another = true;
260 return true;
261 }
262
263 bool has_other_nonposix_opens(struct share_mode_lock *lck,
264 struct files_struct *fsp)
265 {
266 struct has_other_nonposix_opens_state state = { .fsp = fsp };
267 bool ok;
268
269 ok = share_mode_forall_entries(
270 lck, has_other_nonposix_opens_fn, &state);
271 if (!ok) {
272 return false;
273 }
274 return state.found_another;
275 }
276
277 /****************************************************************************
278 Deal with removing a share mode on last close.
279 ****************************************************************************/
280
281 static NTSTATUS close_remove_share_mode(files_struct *fsp,
282 enum file_close_type close_type)
283 {
284 connection_struct *conn = fsp->conn;
285 bool delete_file = false;
286 bool changed_user = false;
287 struct share_mode_lock *lck = NULL;
288 NTSTATUS status = NT_STATUS_OK;
289 NTSTATUS tmp_status;
290 struct file_id id;
291 const struct security_unix_token *del_token = NULL;
292 const struct security_token *del_nt_token = NULL;
293 struct smb_filename *parent_fname = NULL;
294 struct smb_filename *base_fname = NULL;
295 bool got_tokens = false;
296 bool normal_close;
297 int ret;
298
299 /* Ensure any pending write time updates are done. */
300 if (fsp->update_write_time_event) {
301 fsp_flush_write_time_update(fsp);
302 }
303
304 /*
305 * Lock the share entries, and determine if we should delete
306 * on close. If so delete whilst the lock is still in effect.
307 * This prevents race conditions with the file being created. JRA.
308 */
309
310 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
311 if (lck == NULL) {
312 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
313 "lock for file %s\n", fsp_str_dbg(fsp)));
314 return NT_STATUS_INVALID_PARAMETER;
315 }
316
317 /* Remove the oplock before potentially deleting the file. */
318 if(fsp->oplock_type) {
319 remove_oplock(fsp);
320 }
321
322 if (fsp->fsp_flags.write_time_forced) {
323 NTTIME mtime = share_mode_changed_write_time(lck);
324 struct timespec ts = nt_time_to_full_timespec(mtime);
325
326 DEBUG(10,("close_remove_share_mode: write time forced "
327 "for file %s\n",
328 fsp_str_dbg(fsp)));
329 set_close_write_time(fsp, ts);
330 } else if (fsp->fsp_flags.update_write_time_on_close) {
331 /* Someone had a pending write. */
332 if (is_omit_timespec(&fsp->close_write_time)) {
333 DEBUG(10,("close_remove_share_mode: update to current time "
334 "for file %s\n",
335 fsp_str_dbg(fsp)));
336 /* Update to current time due to "normal" write. */
337 set_close_write_time(fsp, timespec_current());
338 } else {
339 DEBUG(10,("close_remove_share_mode: write time pending "
340 "for file %s\n",
341 fsp_str_dbg(fsp)));
342 /* Update to time set on close call. */
343 set_close_write_time(fsp, fsp->close_write_time);
344 }
345 }
346
347 if (fsp->fsp_flags.initial_delete_on_close &&
348 !is_delete_on_close_set(lck, fsp->name_hash)) {
349 /* Initial delete on close was set and no one else
350 * wrote a real delete on close. */
351
352 fsp->fsp_flags.delete_on_close = true;
353 set_delete_on_close_lck(fsp, lck,
354 fsp->conn->session_info->security_token,
355 fsp->conn->session_info->unix_token);
356 }
357
358 delete_file = is_delete_on_close_set(lck, fsp->name_hash) &&
359 !has_other_nonposix_opens(lck, fsp);
360
361 /*
362 * NT can set delete_on_close of the last open
363 * reference to a file.
364 */
365
366 normal_close = (close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE);
367
368 if (!normal_close || !delete_file) {
369 status = NT_STATUS_OK;
370 goto done;
371 }
372
373 /*
374 * Ok, we have to delete the file
375 */
376
377 DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
378 "- deleting file.\n", fsp_str_dbg(fsp)));
379
380 /*
381 * Don't try to update the write time when we delete the file
382 */
383 fsp->fsp_flags.update_write_time_on_close = false;
384
385 got_tokens = get_delete_on_close_token(lck, fsp->name_hash,
386 &del_nt_token, &del_token);
387 SMB_ASSERT(got_tokens);
388
389 if (!unix_token_equal(del_token, get_current_utok(conn))) {
390 /* Become the user who requested the delete. */
391
392 DEBUG(5,("close_remove_share_mode: file %s. "
393 "Change user to uid %u\n",
394 fsp_str_dbg(fsp),
395 (unsigned int)del_token->uid));
396
397 if (!push_sec_ctx()) {
398 smb_panic("close_remove_share_mode: file %s. failed to push "
399 "sec_ctx.\n");
400 }
401
402 set_sec_ctx(del_token->uid,
403 del_token->gid,
404 del_token->ngroups,
405 del_token->groups,
406 del_nt_token);
407
408 changed_user = true;
409 }
410
411 /* We can only delete the file if the name we have is still valid and
412 hasn't been renamed. */
413
414 tmp_status = vfs_stat_fsp(fsp);
415 if (!NT_STATUS_IS_OK(tmp_status)) {
416 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
417 "was set and stat failed with error %s\n",
418 fsp_str_dbg(fsp), nt_errstr(tmp_status)));
419 /*
420 * Don't save the errno here, we ignore this error
421 */
422 goto done;
423 }
424
425 id = vfs_file_id_from_sbuf(conn, &fsp->fsp_name->st);
426
427 if (!file_id_equal(&fsp->file_id, &id)) {
428 struct file_id_buf ftmp1, ftmp2;
429 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
430 "was set and dev and/or inode does not match\n",
431 fsp_str_dbg(fsp)));
432 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
433 "stat file_id %s\n",
434 fsp_str_dbg(fsp),
435 file_id_str_buf(fsp->file_id, &ftmp1),
436 file_id_str_buf(id, &ftmp2)));
437 /*
438 * Don't save the errno here, we ignore this error
439 */
440 goto done;
441 }
442
443 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
444 && !fsp_is_alternate_stream(fsp)) {
445
446 status = delete_all_streams(conn, fsp->fsp_name);
447
448 if (!NT_STATUS_IS_OK(status)) {
449 DEBUG(5, ("delete_all_streams failed: %s\n",
450 nt_errstr(status)));
451 goto done;
452 }
453 }
454
455 if (fsp->fsp_flags.kernel_share_modes_taken) {
456 /*
457 * A file system sharemode could block the unlink;
458 * remove filesystem sharemodes first.
459 */
460 ret = SMB_VFS_FILESYSTEM_SHAREMODE(fsp, 0, 0);
461 if (ret == -1) {
462 DBG_INFO("Removing file system sharemode for %s "
463 "failed: %s\n",
464 fsp_str_dbg(fsp), strerror(errno));
465 }
466
467 fsp->fsp_flags.kernel_share_modes_taken = false;
468 }
469
470 status = parent_pathref(talloc_tos(),
471 conn->cwd_fsp,
472 fsp->fsp_name,
473 &parent_fname,
474 &base_fname);
475 if (!NT_STATUS_IS_OK(status)) {
476 goto done;
477 }
478
479 ret = SMB_VFS_UNLINKAT(conn,
480 parent_fname->fsp,
481 base_fname,
482 0);
483 TALLOC_FREE(parent_fname);
484 base_fname = NULL;
485 if (ret != 0) {
486 /*
487 * This call can potentially fail as another smbd may
488 * have had the file open with delete on close set and
489 * deleted it when its last reference to this file
490 * went away. Hence we log this but not at debug level
491 * zero.
492 */
493
494 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
495 "was set and unlink failed with error %s\n",
496 fsp_str_dbg(fsp), strerror(errno)));
497
498 status = map_nt_error_from_unix(errno);
499 }
500
501 /* As we now have POSIX opens which can unlink
502 * with other open files we may have taken
503 * this code path with more than one share mode
504 * entry - ensure we only delete once by resetting
505 * the delete on close flag. JRA.
506 */
507
508 fsp->fsp_flags.delete_on_close = false;
509 reset_delete_on_close_lck(fsp, lck);
510
511 done:
512
513 if (changed_user) {
514 /* unbecome user. */
515 pop_sec_ctx();
516 }
517
518 if (fsp->fsp_flags.kernel_share_modes_taken) {
519 /* remove filesystem sharemodes */
520 ret = SMB_VFS_FILESYSTEM_SHAREMODE(fsp, 0, 0);
521 if (ret == -1) {
522 DBG_INFO("Removing file system sharemode for "
523 "%s failed: %s\n",
524 fsp_str_dbg(fsp), strerror(errno));
525 }
526 }
527
528 if (!del_share_mode(lck, fsp)) {
529 DEBUG(0, ("close_remove_share_mode: Could not delete share "
530 "entry for file %s\n", fsp_str_dbg(fsp)));
531 }
532
533 TALLOC_FREE(lck);
534
535 if (delete_file) {
536 /*
537 * Do the notification after we released the share
538 * mode lock. Inside notify_fname we take out another
539 * tdb lock. With ctdb also accessing our databases,
540 * this can lead to deadlocks. Putting this notify
541 * after the TALLOC_FREE(lck) above we avoid locking
542 * two records simultaneously. Notifies are async and
543 * informational only, so calling the notify_fname
544 * without holding the share mode lock should not do
545 * any harm.
546 */
547 notify_fname(conn, NOTIFY_ACTION_REMOVED,
548 FILE_NOTIFY_CHANGE_FILE_NAME,
549 fsp->fsp_name->base_name);
550 }
551
552 return status;
553 }
554
555 void set_close_write_time(struct files_struct *fsp, struct timespec ts)
556 {
557 DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts))));
558
559 if (is_omit_timespec(&ts)) {
560 return;
561 }
562 fsp->fsp_flags.write_time_forced = false;
563 fsp->fsp_flags.update_write_time_on_close = true;
564 fsp->close_write_time = ts;
565 }
566
567 static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
568 {
569 struct smb_file_time ft;
570 NTSTATUS status;
571 struct share_mode_lock *lck = NULL;
572
573 init_smb_file_time(&ft);
574
575 if (!(fsp->fsp_flags.update_write_time_on_close)) {
576 return NT_STATUS_OK;
577 }
578
579 if (is_omit_timespec(&fsp->close_write_time)) {
580 fsp->close_write_time = timespec_current();
581 }
582
583 /* Ensure we have a valid stat struct for the source. */
584 status = vfs_stat_fsp(fsp);
585 if (!NT_STATUS_IS_OK(status)) {
586 return status;
587 }
588
589 if (!VALID_STAT(fsp->fsp_name->st)) {
590 /* if it doesn't seem to be a real file */
591 return NT_STATUS_OK;
592 }
593
594 /*
595 * get_existing_share_mode_lock() isn't really the right
596 * call here, as we're being called after
597 * close_remove_share_mode() inside close_normal_file()
598 * so it's quite normal to not have an existing share
599 * mode here. However, get_share_mode_lock() doesn't
600 * work because that will create a new share mode if
601 * one doesn't exist - so stick with this call (just
602 * ignore any error we get if the share mode doesn't
603 * exist.
604 */
605
606 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
607 if (lck) {
608 NTTIME share_mtime = share_mode_changed_write_time(lck);
609 /* On close if we're changing the real file time we
610 * must update it in the open file db too. */
611 (void)set_write_time(fsp->file_id, fsp->close_write_time);
612
613 /* Close write times overwrite sticky write times
614 so we must replace any sticky write time here. */
615 if (!null_nttime(share_mtime)) {
616 (void)set_sticky_write_time(fsp->file_id, fsp->close_write_time);
617 }
618 TALLOC_FREE(lck);
619 }
620
621 ft.mtime = fsp->close_write_time;
622 /* As this is a close based update, we are not directly changing the
623 file attributes from a client call, but indirectly from a write. */
624 status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, &ft, false);
625 if (!NT_STATUS_IS_OK(status)) {
626 DEBUG(10,("update_write_time_on_close: smb_set_file_time "
627 "on file %s returned %s\n",
628 fsp_str_dbg(fsp),
629 nt_errstr(status)));
630 return status;
631 }
632
633 return status;
634 }
635
636 static NTSTATUS ntstatus_keeperror(NTSTATUS s1, NTSTATUS s2)
637 {
638 if (!NT_STATUS_IS_OK(s1)) {
639 return s1;
640 }
641 return s2;
642 }
643
644 static void assert_no_pending_aio(struct files_struct *fsp,
645 enum file_close_type close_type)
646 {
647 struct smbXsrv_client *client = global_smbXsrv_client;
648 size_t num_connections_alive;
649 unsigned num_requests = fsp->num_aio_requests;
650
651 if (num_requests == 0) {
652 return;
653 }
654
655 num_connections_alive = smbXsrv_client_valid_connections(client);
656
657 if (close_type == SHUTDOWN_CLOSE && num_connections_alive == 0) {
658 /*
659 * fsp->aio_requests and the contents (fsp->aio_requests[x])
660 * are both independently owned by fsp and are not in a
661 * talloc heirarchy. This allows the fsp->aio_requests array to
662 * be reallocated independently of the array contents so it can
663 * grow on demand.
664 *
665 * This means we must ensure order of deallocation
666 * on a SHUTDOWN_CLOSE by deallocating the fsp->aio_requests[x]
667 * contents first, as their destructors access the
668 * fsp->aio_request array. If we don't deallocate them
669 * first, when fsp is deallocated fsp->aio_requests
670 * could have been deallocated *before* its contents
671 * fsp->aio_requests[x], causing a crash.
672 */
673 while (fsp->num_aio_requests != 0) {
674 /*
675 * NB. We *MUST* use
676 * talloc_free(fsp->aio_requests[0]),
677 * and *NOT* TALLOC_FREE() here, as
678 * TALLOC_FREE(fsp->aio_requests[0])
679 * will overwrite any new contents of
680 * fsp->aio_requests[0] that were
681 * copied into it via the destructor
682 * aio_del_req_from_fsp().
683 *
684 * BUG: https://bugzilla.samba.org/show_bug.cgi?id=14515
685 */
686 talloc_free(fsp->aio_requests[0]);
687 }
688 return;
689 }
690
691 DBG_ERR("fsp->num_aio_requests=%u\n", num_requests);
692 smb_panic("can not close with outstanding aio requests");
693 return;
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 SMB_ASSERT(fsp->fsp_flags.is_fsa);
713
714 assert_no_pending_aio(fsp, close_type);
715
716 while (talloc_array_length(fsp->blocked_smb1_lock_reqs) != 0) {
717 smbd_smb1_brl_finish_by_req(
718 fsp->blocked_smb1_lock_reqs[0],
719 NT_STATUS_RANGE_NOT_LOCKED);
720 }
721
722 /*
723 * If we're flushing on a close we can get a write
724 * error here, we must remember this.
725 */
726
727 if (NT_STATUS_IS_OK(status) && fsp->op != NULL) {
728 is_durable = fsp->op->global->durable;
729 }
730
731 if (close_type != SHUTDOWN_CLOSE) {
732 is_durable = false;
733 }
734
735 if (is_durable) {
736 DATA_BLOB new_cookie = data_blob_null;
737
738 tmp = SMB_VFS_DURABLE_DISCONNECT(fsp,
739 fsp->op->global->backend_cookie,
740 fsp->op,
741 &new_cookie);
742 if (NT_STATUS_IS_OK(tmp)) {
743 struct timeval tv;
744 NTTIME now;
745
746 if (req != NULL) {
747 tv = req->request_time;
748 } else {
749 tv = timeval_current();
750 }
751 now = timeval_to_nttime(&tv);
752
753 data_blob_free(&fsp->op->global->backend_cookie);
754 fsp->op->global->backend_cookie = new_cookie;
755
756 fsp->op->compat = NULL;
757 tmp = smbXsrv_open_close(fsp->op, now);
758 if (!NT_STATUS_IS_OK(tmp)) {
759 DEBUG(1, ("Failed to update smbXsrv_open "
760 "record when disconnecting durable "
761 "handle for file %s: %s - "
762 "proceeding with normal close\n",
763 fsp_str_dbg(fsp), nt_errstr(tmp)));
764 }
765 scavenger_schedule_disconnected(fsp);
766 } else {
767 DEBUG(1, ("Failed to disconnect durable handle for "
768 "file %s: %s - proceeding with normal "
769 "close\n", fsp_str_dbg(fsp), nt_errstr(tmp)));
770 }
771 if (!NT_STATUS_IS_OK(tmp)) {
772 is_durable = false;
773 }
774 }
775
776 if (is_durable) {
777 /*
778 * This is the case where we successfully disconnected
779 * a durable handle and closed the underlying file.
780 * In all other cases, we proceed with a genuine close.
781 */
782 DEBUG(10, ("%s disconnected durable handle for file %s\n",
783 conn->session_info->unix_info->unix_name,
784 fsp_str_dbg(fsp)));
785 return NT_STATUS_OK;
786 }
787
788 if (fsp->op != NULL) {
789 /*
790 * Make sure the handle is not marked as durable anymore
791 */
792 fsp->op->global->durable = false;
793 }
794
795 /* If this is an old DOS or FCB open and we have multiple opens on
796 the same handle we only have one share mode. Ensure we only remove
797 the share mode on the last close. */
798
799 if (fh_get_refcount(fsp->fh) == 1) {
800 /* Should we return on error here... ? */
801 tmp = close_remove_share_mode(fsp, close_type);
802 status = ntstatus_keeperror(status, tmp);
803 }
804
805 locking_close_file(fsp, close_type);
806
807 /*
808 * Ensure pending modtime is set before closing underlying fd.
809 */
810
811 tmp = update_write_time_on_close(fsp);
812 if (NT_STATUS_EQUAL(tmp, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
813 /*
814 * Someone renamed the file or a parent directory containing
815 * this file. We can't do anything about this, eat the error.
816 */
817 tmp = NT_STATUS_OK;
818 }
819 status = ntstatus_keeperror(status, tmp);
820
821 tmp = fd_close(fsp);
822 status = ntstatus_keeperror(status, tmp);
823
824 /* check for magic scripts */
825 if (close_type == NORMAL_CLOSE) {
826 tmp = check_magic(fsp);
827 status = ntstatus_keeperror(status, tmp);
828 }
829
830 DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
831 conn->session_info->unix_info->unix_name, fsp_str_dbg(fsp),
832 conn->num_files_open - 1,
833 nt_errstr(status) ));
834
835 return status;
836 }
837 /****************************************************************************
838 Function used by reply_rmdir to delete an entire directory
839 tree recursively. Return True on ok, False on fail.
840 ****************************************************************************/
841
842 NTSTATUS recursive_rmdir(TALLOC_CTX *ctx,
843 connection_struct *conn,
844 struct smb_filename *smb_dname)
845 {
846 const char *dname = NULL;
847 char *talloced = NULL;
848 long offset = 0;
849 SMB_STRUCT_STAT st;
850 struct smb_Dir *dir_hnd = NULL;
851 struct files_struct *dirfsp = NULL;
852 int retval;
853 NTSTATUS status = NT_STATUS_OK;
854
855 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
856
857 status = OpenDir(talloc_tos(),
858 conn,
859 smb_dname,
860 NULL,
861 0,
862 &dir_hnd);
863 if (!NT_STATUS_IS_OK(status)) {
864 return status;
865 }
866
867 dirfsp = dir_hnd_fetch_fsp(dir_hnd);
868
869 while ((dname = ReadDirName(dir_hnd, &offset, &st, &talloced))) {
870 struct smb_filename *atname = NULL;
871 struct smb_filename *smb_dname_full = NULL;
872 char *fullname = NULL;
873 bool do_break = true;
874 int unlink_flags = 0;
875
876 if (ISDOT(dname) || ISDOTDOT(dname)) {
877 TALLOC_FREE(talloced);
878 continue;
879 }
880
881 /* Construct the full name. */
882 fullname = talloc_asprintf(ctx,
883 "%s/%s",
884 smb_dname->base_name,
885 dname);
886 if (!fullname) {
887 status = NT_STATUS_NO_MEMORY;
888 goto err_break;
889 }
890
891 smb_dname_full = synthetic_smb_fname(talloc_tos(),
892 fullname,
893 NULL,
894 NULL,
895 smb_dname->twrp,
896 smb_dname->flags);
897 if (smb_dname_full == NULL) {
898 status = NT_STATUS_NO_MEMORY;
899 goto err_break;
900 }
901
902 if (SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
903 status = map_nt_error_from_unix(errno);
904 goto err_break;
905 }
906
907 if (smb_dname_full->st.st_ex_mode & S_IFDIR) {
908 status = recursive_rmdir(ctx, conn, smb_dname_full);
909 if (!NT_STATUS_IS_OK(status)) {
910 goto err_break;
911 }
912 unlink_flags = AT_REMOVEDIR;
913 }
914
915 status = synthetic_pathref(talloc_tos(),
916 dirfsp,
917 dname,
918 NULL,
919 &smb_dname_full->st,
920 smb_dname_full->twrp,
921 smb_dname_full->flags,
922 &atname);
923 if (!NT_STATUS_IS_OK(status)) {
924 goto err_break;
925 }
926
927 if (!is_visible_fsp(atname->fsp)) {
928 TALLOC_FREE(smb_dname_full);
929 TALLOC_FREE(fullname);
930 TALLOC_FREE(talloced);
931 TALLOC_FREE(atname);
932 continue;
933 }
934
935 retval = SMB_VFS_UNLINKAT(conn,
936 dirfsp,
937 atname,
938 unlink_flags);
939 if (retval != 0) {
940 status = map_nt_error_from_unix(errno);
941 goto err_break;
942 }
943
944 /* Successful iteration. */
945 do_break = false;
946
947 err_break:
948 TALLOC_FREE(smb_dname_full);
949 TALLOC_FREE(fullname);
950 TALLOC_FREE(talloced);
951 TALLOC_FREE(atname);
952 if (do_break) {
953 break;
954 }
955 }
956 TALLOC_FREE(dir_hnd);
957 return status;
958 }
959
960 /****************************************************************************
961 The internals of the rmdir code - called elsewhere.
962 ****************************************************************************/
963
964 static NTSTATUS rmdir_internals(TALLOC_CTX *ctx, struct files_struct *fsp)
965 {
966 struct connection_struct *conn = fsp->conn;
967 struct smb_filename *smb_dname = fsp->fsp_name;
968 struct smb_filename *parent_fname = NULL;
969 struct smb_filename *at_fname = NULL;
970 SMB_STRUCT_STAT st;
971 const char *dname = NULL;
972 char *talloced = NULL;
973 long dirpos = 0;
974 struct smb_Dir *dir_hnd = NULL;
975 struct files_struct *dirfsp = NULL;
976 int unlink_flags = 0;
977 NTSTATUS status;
978 int ret;
979
980 SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
981
982 status = parent_pathref(talloc_tos(),
983 conn->cwd_fsp,
984 fsp->fsp_name,
985 &parent_fname,
986 &at_fname);
987 if (!NT_STATUS_IS_OK(status)) {
988 return status;
989 }
990
991 /*
992 * Todo: use SMB_VFS_STATX() once it's available.
993 */
994
995 /* Might be a symlink. */
996 ret = SMB_VFS_LSTAT(conn, smb_dname);
997 if (ret != 0) {
998 TALLOC_FREE(parent_fname);
999 return map_nt_error_from_unix(errno);
1000 }
1001
1002 if (S_ISLNK(smb_dname->st.st_ex_mode)) {
1003 /* Is what it points to a directory ? */
1004 ret = SMB_VFS_STAT(conn, smb_dname);
1005 if (ret != 0) {
1006 TALLOC_FREE(parent_fname);
1007 return map_nt_error_from_unix(errno);
1008 }
1009 if (!(S_ISDIR(smb_dname->st.st_ex_mode))) {
1010 TALLOC_FREE(parent_fname);
1011 return NT_STATUS_NOT_A_DIRECTORY;
1012 }
1013 } else {
1014 unlink_flags = AT_REMOVEDIR;
1015 }
1016
1017 ret = SMB_VFS_UNLINKAT(conn,
1018 parent_fname->fsp,
1019 at_fname,
1020 unlink_flags);
1021 if (ret == 0) {
1022 TALLOC_FREE(parent_fname);
1023 notify_fname(conn, NOTIFY_ACTION_REMOVED,
1024 FILE_NOTIFY_CHANGE_DIR_NAME,
1025 smb_dname->base_name);
1026 return NT_STATUS_OK;
1027 }
1028
1029 if (!((errno == ENOTEMPTY) || (errno == EEXIST))) {
1030 DEBUG(3,("rmdir_internals: couldn't remove directory %s : "
1031 "%s\n", smb_fname_str_dbg(smb_dname),
1032 strerror(errno)));
1033 TALLOC_FREE(parent_fname);
1034 return map_nt_error_from_unix(errno);
1035 }
1036
1037 /*
1038 * Here we know the initial directory unlink failed with
1039 * ENOTEMPTY or EEXIST so we know there are objects within.
1040 * If we don't have permission to delete files non
1041 * visible to the client just fail the directory delete.
1042 */
1043
1044 if (!lp_delete_veto_files(SNUM(conn))) {
1045 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1046 goto err;
1047 }
1048
1049 /*
1050 * Check to see if the only thing in this directory are
1051 * files non-visible to the client. If not, fail the delete.
1052 */
1053
1054 status = OpenDir(talloc_tos(),
1055 conn,
1056 smb_dname,
1057 NULL,
1058 0,
1059 &dir_hnd);
1060 if (!NT_STATUS_IS_OK(status)) {
1061 /*
1062 * Note, we deliberately squash the error here
1063 * to avoid leaking information about what we
1064 * can't delete.
1065 */
1066 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1067 goto err;
1068 }
1069
1070 dirfsp = dir_hnd_fetch_fsp(dir_hnd);
1071
1072 while ((dname = ReadDirName(dir_hnd, &dirpos, &st, &talloced)) != NULL) {
1073 struct smb_filename *smb_dname_full = NULL;
1074 struct smb_filename *direntry_fname = NULL;
1075 char *fullname = NULL;
1076 int retval;
1077
1078 if (ISDOT(dname) || ISDOTDOT(dname)) {
1079 TALLOC_FREE(talloced);
1080 continue;
1081 }
1082 if (IS_VETO_PATH(conn, dname)) {
1083 TALLOC_FREE(talloced);
1084 continue;
1085 }
1086
1087 fullname = talloc_asprintf(talloc_tos(),
1088 "%s/%s",
1089 smb_dname->base_name,
1090 dname);
1091
1092 if (fullname == NULL) {
1093 TALLOC_FREE(talloced);
1094 status = NT_STATUS_NO_MEMORY;
1095 goto err;
1096 }
1097
1098 smb_dname_full = synthetic_smb_fname(talloc_tos(),
1099 fullname,
1100 NULL,
1101 NULL,
1102 smb_dname->twrp,
1103 smb_dname->flags);
1104 if (smb_dname_full == NULL) {
1105 TALLOC_FREE(talloced);
1106 TALLOC_FREE(fullname);
1107 status = NT_STATUS_NO_MEMORY;
1108 goto err;
1109 }
1110
1111 retval = SMB_VFS_LSTAT(conn, smb_dname_full);
1112 if (retval != 0) {
1113 status = map_nt_error_from_unix(errno);
1114 TALLOC_FREE(talloced);
1115 TALLOC_FREE(fullname);
1116 TALLOC_FREE(smb_dname_full);
1117 goto err;
1118 }
1119
1120 if (S_ISLNK(smb_dname_full->st.st_ex_mode)) {
1121 /* Could it be an msdfs link ? */
1122 if (lp_host_msdfs() &&
1123 lp_msdfs_root(SNUM(conn))) {
1124 struct smb_filename *smb_atname;
1125 smb_atname = synthetic_smb_fname(talloc_tos(),
1126 dname,
1127 NULL,
1128 &smb_dname_full->st,
1129 fsp->fsp_name->twrp,
1130 fsp->fsp_name->flags);
1131 if (smb_atname == NULL) {
1132 TALLOC_FREE(talloced);
1133 TALLOC_FREE(fullname);
1134 TALLOC_FREE(smb_dname_full);
1135 status = NT_STATUS_NO_MEMORY;
1136 goto err;
1137 }
1138 if (is_msdfs_link(fsp, smb_atname)) {
1139 TALLOC_FREE(talloced);
1140 TALLOC_FREE(fullname);
1141 TALLOC_FREE(smb_dname_full);
1142 TALLOC_FREE(smb_atname);
1143 DBG_DEBUG("got msdfs link name %s "
1144 "- can't delete directory %s\n",
1145 dname,
1146 fsp_str_dbg(fsp));
1147 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1148 goto err;
1149 }
1150 TALLOC_FREE(smb_atname);
1151 }
1152
1153 /* Not a DFS link - could it be a dangling symlink ? */
1154 retval = SMB_VFS_STAT(conn, smb_dname_full);
1155 if (retval == -1 && (errno == ENOENT || errno == ELOOP)) {
1156 /*
1157 * Dangling symlink.
1158 * Allow delete as "delete veto files = yes"
1159 */
1160 TALLOC_FREE(talloced);
1161 TALLOC_FREE(fullname);
1162 TALLOC_FREE(smb_dname_full);
1163 continue;
1164 }
1165
1166 DBG_DEBUG("got symlink name %s - "
1167 "can't delete directory %s\n",
1168 dname,
1169 fsp_str_dbg(fsp));
1170 TALLOC_FREE(talloced);
1171 TALLOC_FREE(fullname);
1172 TALLOC_FREE(smb_dname_full);
1173 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1174 goto err;
1175 }
1176
1177 /* Not a symlink, get a pathref. */
1178 status = synthetic_pathref(talloc_tos(),
1179 dirfsp,
1180 dname,
1181 NULL,
1182 &smb_dname_full->st,
1183 smb_dname->twrp,
1184 smb_dname->flags,
1185 &direntry_fname);
1186 if (!NT_STATUS_IS_OK(status)) {
1187 TALLOC_FREE(talloced);
1188 TALLOC_FREE(fullname);
1189 TALLOC_FREE(smb_dname_full);
1190 goto err;
1191 }
1192
1193 if (!is_visible_fsp(direntry_fname->fsp)) {
1194 TALLOC_FREE(talloced);
1195 TALLOC_FREE(fullname);
1196 TALLOC_FREE(smb_dname_full);
1197 TALLOC_FREE(direntry_fname);
1198 continue;
1199 }
1200
1201 /*
1202 * We found a client visible name.
1203 * We cannot delete this directory.
1204 */
1205 DBG_DEBUG("got name %s - "
1206 "can't delete directory %s\n",
1207 dname,
1208 fsp_str_dbg(fsp));
1209 TALLOC_FREE(talloced);
1210 TALLOC_FREE(fullname);
1211 TALLOC_FREE(smb_dname_full);
1212 TALLOC_FREE(direntry_fname);
1213 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1214 goto err;
1215 }
1216
1217 /* Do a recursive delete. */
1218 RewindDir(dir_hnd,&dirpos);
1219
1220 while ((dname = ReadDirName(dir_hnd, &dirpos, &st, &talloced)) != NULL) {
1221 struct smb_filename *direntry_fname = NULL;
1222 struct smb_filename *smb_dname_full = NULL;
1223 char *fullname = NULL;
1224 bool do_break = true;
1225 int retval;
1226
1227 if (ISDOT(dname) || ISDOTDOT(dname)) {
1228 TALLOC_FREE(talloced);
1229 continue;
1230 }
1231
1232 fullname = talloc_asprintf(ctx,
1233 "%s/%s",
1234 smb_dname->base_name,
1235 dname);
1236
1237 if (fullname == NULL) {
1238 status = NT_STATUS_NO_MEMORY;
1239 goto err_break;
1240 }
1241
1242 smb_dname_full = synthetic_smb_fname(talloc_tos(),
1243 fullname,
1244 NULL,
1245 NULL,
1246 smb_dname->twrp,
1247 smb_dname->flags);
1248 if (smb_dname_full == NULL) {
1249 status = NT_STATUS_NO_MEMORY;
1250 goto err_break;
1251 }
1252
1253 /*
1254 * Todo: use SMB_VFS_STATX() once that's available.
1255 */
1256
1257 retval = SMB_VFS_LSTAT(conn, smb_dname_full);
1258 if (retval != 0) {
1259 status = map_nt_error_from_unix(errno);
1260 goto err_break;
1261 }
1262
1263 /*
1264 * We are only dealing with VETO'ed objects
1265 * here. If it's a symlink, just delete the
1266 * link without caring what it is pointing
1267 * to.
1268 */
1269 if (S_ISLNK(smb_dname_full->st.st_ex_mode)) {
1270 direntry_fname = synthetic_smb_fname(talloc_tos(),
1271 dname,
1272 NULL,
1273 &smb_dname_full->st,
1274 smb_dname->twrp,
1275 smb_dname->flags);
1276 if (direntry_fname == NULL) {
1277 status = NT_STATUS_NO_MEMORY;
1278 goto err_break;
1279 }
1280 } else {
1281 status = synthetic_pathref(talloc_tos(),
1282 dirfsp,
1283 dname,
1284 NULL,
1285 &smb_dname_full->st,
1286 smb_dname->twrp,
1287 smb_dname->flags,
1288 &direntry_fname);
1289 if (!NT_STATUS_IS_OK(status)) {
1290 goto err_break;
1291 }
1292
1293 if (!is_visible_fsp(direntry_fname->fsp)) {
1294 TALLOC_FREE(fullname);
1295 TALLOC_FREE(smb_dname_full);
1296 TALLOC_FREE(talloced);
1297 TALLOC_FREE(direntry_fname);
1298 continue;
1299 }
1300 }
1301
1302 unlink_flags = 0;
1303
1304 if (smb_dname_full->st.st_ex_mode & S_IFDIR) {
1305 status = recursive_rmdir(ctx, conn, smb_dname_full);
1306 if (!NT_STATUS_IS_OK(status)) {
1307 goto err_break;
1308 }
1309 unlink_flags = AT_REMOVEDIR;
1310 }
1311
1312 retval = SMB_VFS_UNLINKAT(conn,
1313 dirfsp,
1314 direntry_fname,
1315 unlink_flags);
1316 if (retval != 0) {
1317 status = map_nt_error_from_unix(errno);
1318 goto err_break;
1319 }
1320
1321 /* Successful iteration. */
1322 do_break = false;
1323
1324 err_break:
1325 TALLOC_FREE(fullname);
1326 TALLOC_FREE(smb_dname_full);
1327 TALLOC_FREE(talloced);
1328 TALLOC_FREE(direntry_fname);
1329 if (do_break) {
1330 break;
1331 }
1332 }
1333
1334 /* If we get here, we know NT_STATUS_IS_OK(status) */
1335 SMB_ASSERT(NT_STATUS_IS_OK(status));
1336
1337 /* Retry the rmdir */
1338 ret = SMB_VFS_UNLINKAT(conn,
1339 parent_fname->fsp,
1340 at_fname,
1341 AT_REMOVEDIR);
1342 if (ret != 0) {
1343 status = map_nt_error_from_unix(errno);
1344 }
1345
1346 err:
1347
1348 TALLOC_FREE(dir_hnd);
1349 TALLOC_FREE(parent_fname);
1350
1351 if (!NT_STATUS_IS_OK(status)) {
1352 DBG_NOTICE("couldn't remove directory %s : "
1353 "%s\n", smb_fname_str_dbg(smb_dname),
1354 nt_errstr(status));
1355 return status;
1356 }
1357
1358 notify_fname(conn, NOTIFY_ACTION_REMOVED,
1359 FILE_NOTIFY_CHANGE_DIR_NAME,
1360 smb_dname->base_name);
1361
1362 return status;
1363 }
1364
1365 /****************************************************************************
1366 Close a directory opened by an NT SMB call.
1367 ****************************************************************************/
1368
1369 static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp,
1370 enum file_close_type close_type)
1371 {
1372 struct share_mode_lock *lck = NULL;
1373 bool delete_dir = False;
1374 NTSTATUS status = NT_STATUS_OK;
1375 NTSTATUS status1 = NT_STATUS_OK;
1376 const struct security_token *del_nt_token = NULL;
1377 const struct security_unix_token *del_token = NULL;
1378 NTSTATUS notify_status;
1379
1380 SMB_ASSERT(fsp->fsp_flags.is_fsa);
1381
1382 if (fsp->conn->sconn->using_smb2) {
1383 notify_status = NT_STATUS_NOTIFY_CLEANUP;
1384 } else {
1385 notify_status = NT_STATUS_OK;
1386 }
1387
1388 assert_no_pending_aio(fsp, close_type);
1389
1390 /*
1391 * NT can set delete_on_close of the last open
1392 * reference to a directory also.
1393 */
1394
1395 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1396 if (lck == NULL) {
1397 DEBUG(0, ("close_directory: Could not get share mode lock for "
1398 "%s\n", fsp_str_dbg(fsp)));
1399 return NT_STATUS_INVALID_PARAMETER;
1400 }
1401
1402 if (fsp->fsp_flags.initial_delete_on_close) {
1403 /* Initial delete on close was set - for
1404 * directories we don't care if anyone else
1405 * wrote a real delete on close. */
1406
1407 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1408 fsp->fsp_name->base_name);
1409 set_delete_on_close_lck(fsp, lck,
1410 fsp->conn->session_info->security_token,
1411 fsp->conn->session_info->unix_token);
1412 fsp->fsp_flags.delete_on_close = true;
1413 }
1414
1415 delete_dir = get_delete_on_close_token(
1416 lck, fsp->name_hash, &del_nt_token, &del_token) &&
1417 !has_other_nonposix_opens(lck, fsp);
1418
1419 if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
1420 delete_dir) {
1421
1422 /* Become the user who requested the delete. */
1423
1424 if (!push_sec_ctx()) {
1425 smb_panic("close_directory: failed to push sec_ctx.\n");
1426 }
1427
1428 set_sec_ctx(del_token->uid,
1429 del_token->gid,
1430 del_token->ngroups,
1431 del_token->groups,
1432 del_nt_token);
1433
1434 if (!del_share_mode(lck, fsp)) {
1435 DEBUG(0, ("close_directory: Could not delete share entry for "
1436 "%s\n", fsp_str_dbg(fsp)));
1437 }
1438
1439 TALLOC_FREE(lck);
1440
1441 if ((fsp->conn->fs_capabilities & FILE_NAMED_STREAMS)
1442 && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
1443
1444 status = delete_all_streams(fsp->conn, fsp->fsp_name);
1445 if (!NT_STATUS_IS_OK(status)) {
1446 DEBUG(5, ("delete_all_streams failed: %s\n",
1447 nt_errstr(status)));
1448 /* unbecome user. */
1449 pop_sec_ctx();
1450 return status;
1451 }
1452 }
1453
1454 status = rmdir_internals(talloc_tos(), fsp);
1455
1456 DEBUG(5,("close_directory: %s. Delete on close was set - "
1457 "deleting directory returned %s.\n",
1458 fsp_str_dbg(fsp), nt_errstr(status)));
1459
1460 /* unbecome user. */
1461 pop_sec_ctx();
1462
1463 /*
1464 * Ensure we remove any change notify requests that would
1465 * now fail as the directory has been deleted.
1466 */
1467
1468 if (NT_STATUS_IS_OK(status)) {
1469 notify_status = NT_STATUS_DELETE_PENDING;
1470 }
1471 } else {
1472 if (!del_share_mode(lck, fsp)) {
1473 DEBUG(0, ("close_directory: Could not delete share entry for "
1474 "%s\n", fsp_str_dbg(fsp)));
1475 }
1476
1477 TALLOC_FREE(lck);
1478 }
1479
1480 remove_pending_change_notify_requests_by_fid(fsp, notify_status);
1481
1482 status1 = fd_close(fsp);
1483
1484 if (!NT_STATUS_IS_OK(status1)) {
1485 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
1486 fsp_str_dbg(fsp), fsp_get_pathref_fd(fsp), errno,
1487 strerror(errno)));
1488 }
1489
1490 if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(status1)) {
1491 status = status1;
1492 }
1493 return status;
1494 }
1495
1496 /****************************************************************************
1497 Rundown all SMB-related dependencies of a files struct
1498 ****************************************************************************/
1499
1500 NTSTATUS close_file_smb(struct smb_request *req,
1501 struct files_struct *fsp,
1502 enum file_close_type close_type)
1503 {
1504 NTSTATUS status;
1505
1506 /*
1507 * This fsp can never be an internal dirfsp. They must
1508 * be explicitly closed by TALLOC_FREE of the dir handle.
1509 */
1510 SMB_ASSERT(!fsp->fsp_flags.is_dirfsp);
1511
1512 /*
1513 * Never call directly on a base fsp
1514 */
1515 SMB_ASSERT(fsp->stream_fsp == NULL);
1516
1517 if (fsp->fake_file_handle != NULL) {
1518 status = close_fake_file(req, fsp);
1519 } else if (fsp->print_file != NULL) {
1520 /* FIXME: return spool errors */
1521 print_spool_end(fsp, close_type);
1522 fd_close(fsp);
1523 status = NT_STATUS_OK;
1524 } else if (!fsp->fsp_flags.is_fsa) {
1525 if (close_type == NORMAL_CLOSE) {
1526 DBG_ERR("unexpected NORMAL_CLOSE for [%s] "
1527 "is_fsa[%u] is_pathref[%u] is_directory[%u]\n",
1528 fsp_str_dbg(fsp),
1529 fsp->fsp_flags.is_fsa,
1530 fsp->fsp_flags.is_pathref,
1531 fsp->fsp_flags.is_directory);
1532 }
1533 SMB_ASSERT(close_type != NORMAL_CLOSE);
1534 fd_close(fsp);
1535 status = NT_STATUS_OK;
1536 } else if (fsp->fsp_flags.is_directory) {
1537 status = close_directory(req, fsp, close_type);
1538 } else {
1539 status = close_normal_file(req, fsp, close_type);
1540 }
1541
1542 if (fsp_is_alternate_stream(fsp)) {
1543 /*
1544 * fsp was a stream, its base_fsp can't be a stream
1545 * as well
1546 */
1547 SMB_ASSERT(!fsp_is_alternate_stream(fsp->base_fsp));
1548
1549 /*
1550 * There's a 1:1 relationship between fsp and a base_fsp
1551 */
1552 SMB_ASSERT(fsp->base_fsp->stream_fsp == fsp);
1553
1554 /*
1555 * Make base_fsp look standalone now
1556 */
1557 fsp->base_fsp->stream_fsp = NULL;
1558
1559 close_file_free(req, &fsp->base_fsp, close_type);
1560 }
1561
1562 fsp_unbind_smb(req, fsp);
1563
1564 return status;
1565 }
1566
1567 NTSTATUS close_file_free(struct smb_request *req,
1568 struct files_struct **_fsp,
1569 enum file_close_type close_type)
1570 {
1571 struct files_struct *fsp = *_fsp;
1572 NTSTATUS status;
1573
1574 status = close_file_smb(req, fsp, close_type);
1575
1576 file_free(req, fsp);
1577 *_fsp = NULL;
1578
1579 return status;
1580 }
1581
1582 /****************************************************************************
1583 Deal with an (authorized) message to close a file given the share mode
1584 entry.
1585 ****************************************************************************/
1586
1587 void msg_close_file(struct messaging_context *msg_ctx,
1588 void *private_data,
1589 uint32_t msg_type,
1590 struct server_id server_id,
1591 DATA_BLOB *data)
1592 {
1593 files_struct *fsp = NULL;
1594 struct file_id id;
1595 struct share_mode_entry e;
1596 struct smbd_server_connection *sconn =
1597 talloc_get_type_abort(private_data,
1598 struct smbd_server_connection);
1599
1600 message_to_share_mode_entry(&id, &e, (char *)data->data);
1601
1602 if(DEBUGLVL(10)) {
1603 char *sm_str = share_mode_str(NULL, 0, &id, &e);
1604 if (!sm_str) {
1605 smb_panic("talloc failed");
1606 }
1607 DEBUG(10,("msg_close_file: got request to close share mode "
1608 "entry %s\n", sm_str));
1609 TALLOC_FREE(sm_str);
1610 }
1611
1612 fsp = file_find_dif(sconn, id, e.share_file_id);
1613 if (!fsp) {
1614 DEBUG(10,("msg_close_file: failed to find file.\n"));
1615 return;
1616 }
1617 close_file_free(NULL, &fsp, NORMAL_CLOSE);
1618 }
Samba GIT mirror