Third part of fix for bug #8837 - smbd crashes when deleting directory and veto files...
[amitay/samba.git] / source3 / smbd / close.c
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(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(SNUM(conn)),p)) {
66                 status = NT_STATUS_OK;
67                 goto out;
68         }
69
70         if (*lp_magicoutput(SNUM(conn))) {
71                 magic_output = lp_magicoutput(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,(SMB_OFF_T)st.st_ex_size) == (SMB_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         uint32_t i, num_deferred;
174         struct share_mode_entry *deferred;
175
176         if (!should_notify_deferred_opens()) {
177                 return;
178         }
179
180         num_deferred = 0;
181         for (i=0; i<lck->data->num_share_modes; i++) {
182                 if (is_deferred_open_entry(&lck->data->share_modes[i])) {
183                         num_deferred += 1;
184                 }
185         }
186         if (num_deferred == 0) {
187                 return;
188         }
189
190         deferred = talloc_array(talloc_tos(), struct share_mode_entry,
191                                 num_deferred);
192         if (deferred == NULL) {
193                 return;
194         }
195
196         num_deferred = 0;
197         for (i=0; i<lck->data->num_share_modes; i++) {
198                 struct share_mode_entry *e = &lck->data->share_modes[i];
199                 if (is_deferred_open_entry(e)) {
200                         deferred[num_deferred] = *e;
201                         num_deferred += 1;
202                 }
203         }
204
205         /*
206          * We need to sort the notifications by initial request time. Imagine
207          * two opens come in asyncronously, both conflicting with the open we
208          * just close here. If we don't sort the notifications, the one that
209          * came in last might get the response before the one that came in
210          * first. This is demonstrated with the smbtorture4 raw.mux test.
211          *
212          * As long as we had the UNUSED_SHARE_MODE_ENTRY, we happened to
213          * survive this particular test. Without UNUSED_SHARE_MODE_ENTRY, we
214          * shuffle the share mode entries around a bit, so that we do not
215          * survive raw.mux anymore.
216          *
217          * We could have kept the ordering in del_share_mode, but as the
218          * ordering was never formalized I think it is better to do it here
219          * where it is necessary.
220          */
221
222         qsort(deferred, num_deferred, sizeof(struct share_mode_entry),
223               compare_share_mode_times);
224
225         for (i=0; i<num_deferred; i++) {
226                 struct share_mode_entry *e = &deferred[i];
227
228                 if (procid_is_me(&e->pid)) {
229                         /*
230                          * We need to notify ourself to retry the open.  Do
231                          * this by finding the queued SMB record, moving it to
232                          * the head of the queue and changing the wait time to
233                          * zero.
234                          */
235                         schedule_deferred_open_message_smb(sconn, e->op_mid);
236                 } else {
237                         char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
238
239                         share_mode_entry_to_message(msg, e);
240
241                         messaging_send_buf(sconn->msg_ctx, e->pid,
242                                            MSG_SMB_OPEN_RETRY,
243                                            (uint8 *)msg,
244                                            MSG_SMB_SHARE_MODE_ENTRY_SIZE);
245                 }
246         }
247         TALLOC_FREE(deferred);
248 }
249
250 /****************************************************************************
251  Delete all streams
252 ****************************************************************************/
253
254 NTSTATUS delete_all_streams(connection_struct *conn, const char *fname)
255 {
256         struct stream_struct *stream_info = NULL;
257         int i;
258         unsigned int num_streams = 0;
259         TALLOC_CTX *frame = talloc_stackframe();
260         NTSTATUS status;
261
262         status = vfs_streaminfo(conn, NULL, fname, talloc_tos(),
263                                 &num_streams, &stream_info);
264
265         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
266                 DEBUG(10, ("no streams around\n"));
267                 TALLOC_FREE(frame);
268                 return NT_STATUS_OK;
269         }
270
271         if (!NT_STATUS_IS_OK(status)) {
272                 DEBUG(10, ("vfs_streaminfo failed: %s\n",
273                            nt_errstr(status)));
274                 goto fail;
275         }
276
277         DEBUG(10, ("delete_all_streams found %d streams\n",
278                    num_streams));
279
280         if (num_streams == 0) {
281                 TALLOC_FREE(frame);
282                 return NT_STATUS_OK;
283         }
284
285         for (i=0; i<num_streams; i++) {
286                 int res;
287                 struct smb_filename *smb_fname_stream = NULL;
288
289                 if (strequal(stream_info[i].name, "::$DATA")) {
290                         continue;
291                 }
292
293                 status = create_synthetic_smb_fname(talloc_tos(), fname,
294                                                     stream_info[i].name, NULL,
295                                                     &smb_fname_stream);
296
297                 if (!NT_STATUS_IS_OK(status)) {
298                         DEBUG(0, ("talloc_aprintf failed\n"));
299                         goto fail;
300                 }
301
302                 res = SMB_VFS_UNLINK(conn, smb_fname_stream);
303
304                 if (res == -1) {
305                         status = map_nt_error_from_unix(errno);
306                         DEBUG(10, ("Could not delete stream %s: %s\n",
307                                    smb_fname_str_dbg(smb_fname_stream),
308                                    strerror(errno)));
309                         TALLOC_FREE(smb_fname_stream);
310                         break;
311                 }
312                 TALLOC_FREE(smb_fname_stream);
313         }
314
315  fail:
316         TALLOC_FREE(frame);
317         return status;
318 }
319
320 /****************************************************************************
321  Deal with removing a share mode on last close.
322 ****************************************************************************/
323
324 static NTSTATUS close_remove_share_mode(files_struct *fsp,
325                                         enum file_close_type close_type)
326 {
327         connection_struct *conn = fsp->conn;
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
338         /* Ensure any pending write time updates are done. */
339         if (fsp->update_write_time_event) {
340                 update_write_time_handler(fsp->conn->sconn->ev_ctx,
341                                         fsp->update_write_time_event,
342                                         timeval_current(),
343                                         (void *)fsp);
344         }
345
346         /*
347          * Lock the share entries, and determine if we should delete
348          * on close. If so delete whilst the lock is still in effect.
349          * This prevents race conditions with the file being created. JRA.
350          */
351
352         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
353         if (lck == NULL) {
354                 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
355                           "lock for file %s\n", fsp_str_dbg(fsp)));
356                 status = NT_STATUS_INVALID_PARAMETER;
357                 goto done;
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 (!del_share_mode(lck, fsp)) {
383                 DEBUG(0, ("close_remove_share_mode: Could not delete share "
384                           "entry for file %s\n",
385                           fsp_str_dbg(fsp)));
386         }
387
388         if (fsp->initial_delete_on_close &&
389                         !is_delete_on_close_set(lck, fsp->name_hash)) {
390                 bool became_user = False;
391
392                 /* Initial delete on close was set and no one else
393                  * wrote a real delete on close. */
394
395                 if (get_current_vuid(conn) != fsp->vuid) {
396                         become_user(conn, fsp->vuid);
397                         became_user = True;
398                 }
399                 fsp->delete_on_close = true;
400                 set_delete_on_close_lck(fsp, lck, True,
401                                 get_current_nttok(conn),
402                                 get_current_utok(conn));
403                 if (became_user) {
404                         unbecome_user();
405                 }
406         }
407
408         delete_file = is_delete_on_close_set(lck, fsp->name_hash);
409
410         if (delete_file) {
411                 int i;
412                 /* See if others still have the file open via this pathname.
413                    If this is the case, then don't delete. If all opens are
414                    POSIX delete now. */
415                 for (i=0; i<lck->data->num_share_modes; i++) {
416                         struct share_mode_entry *e = &lck->data->share_modes[i];
417                         if (is_valid_share_mode_entry(e) &&
418                                         e->name_hash == fsp->name_hash) {
419                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
420                                         continue;
421                                 }
422                                 delete_file = False;
423                                 break;
424                         }
425                 }
426         }
427
428         /* Notify any deferred opens waiting on this close. */
429         notify_deferred_opens(conn->sconn, lck);
430         reply_to_oplock_break_requests(fsp);
431
432         /*
433          * NT can set delete_on_close of the last open
434          * reference to a file.
435          */
436
437         if (!(close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) ||
438                         !delete_file) {
439                 TALLOC_FREE(lck);
440                 return NT_STATUS_OK;
441         }
442
443         /*
444          * Ok, we have to delete the file
445          */
446
447         DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
448                  "- deleting file.\n", fsp_str_dbg(fsp)));
449
450         /*
451          * Don't try to update the write time when we delete the file
452          */
453         fsp->update_write_time_on_close = false;
454
455         got_tokens = get_delete_on_close_token(lck, fsp->name_hash,
456                                         &del_nt_token, &del_token);
457         SMB_ASSERT(got_tokens);
458
459         if (!unix_token_equal(del_token, get_current_utok(conn))) {
460                 /* Become the user who requested the delete. */
461
462                 DEBUG(5,("close_remove_share_mode: file %s. "
463                         "Change user to uid %u\n",
464                         fsp_str_dbg(fsp),
465                         (unsigned int)del_token->uid));
466
467                 if (!push_sec_ctx()) {
468                         smb_panic("close_remove_share_mode: file %s. failed to push "
469                                   "sec_ctx.\n");
470                 }
471
472                 set_sec_ctx(del_token->uid,
473                             del_token->gid,
474                             del_token->ngroups,
475                             del_token->groups,
476                             del_nt_token);
477
478                 changed_user = true;
479         }
480
481         /* We can only delete the file if the name we have is still valid and
482            hasn't been renamed. */
483
484         tmp_status = vfs_stat_fsp(fsp);
485         if (!NT_STATUS_IS_OK(tmp_status)) {
486                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
487                          "was set and stat failed with error %s\n",
488                          fsp_str_dbg(fsp), nt_errstr(tmp_status)));
489                 /*
490                  * Don't save the errno here, we ignore this error
491                  */
492                 goto done;
493         }
494
495         id = vfs_file_id_from_sbuf(conn, &fsp->fsp_name->st);
496
497         if (!file_id_equal(&fsp->file_id, &id)) {
498                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
499                          "was set and dev and/or inode does not match\n",
500                          fsp_str_dbg(fsp)));
501                 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
502                          "stat file_id %s\n",
503                          fsp_str_dbg(fsp),
504                          file_id_string_tos(&fsp->file_id),
505                          file_id_string_tos(&id)));
506                 /*
507                  * Don't save the errno here, we ignore this error
508                  */
509                 goto done;
510         }
511
512         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
513             && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
514
515                 status = delete_all_streams(conn, fsp->fsp_name->base_name);
516
517                 if (!NT_STATUS_IS_OK(status)) {
518                         DEBUG(5, ("delete_all_streams failed: %s\n",
519                                   nt_errstr(status)));
520                         goto done;
521                 }
522         }
523
524
525         if (SMB_VFS_UNLINK(conn, fsp->fsp_name) != 0) {
526                 /*
527                  * This call can potentially fail as another smbd may
528                  * have had the file open with delete on close set and
529                  * deleted it when its last reference to this file
530                  * went away. Hence we log this but not at debug level
531                  * zero.
532                  */
533
534                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
535                          "was set and unlink failed with error %s\n",
536                          fsp_str_dbg(fsp), strerror(errno)));
537
538                 status = map_nt_error_from_unix(errno);
539         }
540
541         /* As we now have POSIX opens which can unlink
542          * with other open files we may have taken
543          * this code path with more than one share mode
544          * entry - ensure we only delete once by resetting
545          * the delete on close flag. JRA.
546          */
547
548         fsp->delete_on_close = false;
549         set_delete_on_close_lck(fsp, lck, false, NULL, NULL);
550
551  done:
552
553         if (changed_user) {
554                 /* unbecome user. */
555                 pop_sec_ctx();
556         }
557
558         TALLOC_FREE(lck);
559
560         if (delete_file) {
561                 /*
562                  * Do the notification after we released the share
563                  * mode lock. Inside notify_fname we take out another
564                  * tdb lock. With ctdb also accessing our databases,
565                  * this can lead to deadlocks. Putting this notify
566                  * after the TALLOC_FREE(lck) above we avoid locking
567                  * two records simultaneously. Notifies are async and
568                  * informational only, so calling the notify_fname
569                  * without holding the share mode lock should not do
570                  * any harm.
571                  */
572                 notify_fname(conn, NOTIFY_ACTION_REMOVED,
573                              FILE_NOTIFY_CHANGE_FILE_NAME,
574                              fsp->fsp_name->base_name);
575         }
576
577         return status;
578 }
579
580 void set_close_write_time(struct files_struct *fsp, struct timespec ts)
581 {
582         DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts))));
583
584         if (null_timespec(ts)) {
585                 return;
586         }
587         fsp->write_time_forced = false;
588         fsp->update_write_time_on_close = true;
589         fsp->close_write_time = ts;
590 }
591
592 static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
593 {
594         struct smb_file_time ft;
595         NTSTATUS status;
596         struct share_mode_lock *lck = NULL;
597
598         ZERO_STRUCT(ft);
599
600         if (!fsp->update_write_time_on_close) {
601                 return NT_STATUS_OK;
602         }
603
604         if (null_timespec(fsp->close_write_time)) {
605                 fsp->close_write_time = timespec_current();
606         }
607
608         /* Ensure we have a valid stat struct for the source. */
609         status = vfs_stat_fsp(fsp);
610         if (!NT_STATUS_IS_OK(status)) {
611                 return status;
612         }
613
614         if (!VALID_STAT(fsp->fsp_name->st)) {
615                 /* if it doesn't seem to be a real file */
616                 return NT_STATUS_OK;
617         }
618
619         /* On close if we're changing the real file time we
620          * must update it in the open file db too. */
621         (void)set_write_time(fsp->file_id, fsp->close_write_time);
622
623         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
624         if (lck) {
625                 /* Close write times overwrite sticky write times
626                    so we must replace any sticky write time here. */
627                 if (!null_timespec(lck->data->changed_write_time)) {
628                         (void)set_sticky_write_time(fsp->file_id, fsp->close_write_time);
629                 }
630                 TALLOC_FREE(lck);
631         }
632
633         ft.mtime = fsp->close_write_time;
634         /* As this is a close based update, we are not directly changing the
635            file attributes from a client call, but indirectly from a write. */
636         status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name, &ft, false);
637         if (!NT_STATUS_IS_OK(status)) {
638                 DEBUG(10,("update_write_time_on_close: smb_set_file_time "
639                         "on file %s returned %s\n",
640                         fsp_str_dbg(fsp),
641                         nt_errstr(status)));
642                 return status;
643         }
644
645         return status;
646 }
647
648 static NTSTATUS ntstatus_keeperror(NTSTATUS s1, NTSTATUS s2)
649 {
650         if (!NT_STATUS_IS_OK(s1)) {
651                 return s1;
652         }
653         return s2;
654 }
655
656 /****************************************************************************
657  Close a file.
658
659  close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
660  printing and magic scripts are only run on normal close.
661  delete on close is done on normal and shutdown close.
662 ****************************************************************************/
663
664 static NTSTATUS close_normal_file(struct smb_request *req, files_struct *fsp,
665                                   enum file_close_type close_type)
666 {
667         NTSTATUS status = NT_STATUS_OK;
668         NTSTATUS tmp;
669         connection_struct *conn = fsp->conn;
670
671         if (close_type == ERROR_CLOSE) {
672                 cancel_aio_by_fsp(fsp);
673         } else {
674                 /*
675                  * If we're finishing async io on a close we can get a write
676                  * error here, we must remember this.
677                  */
678                 int ret = wait_for_aio_completion(fsp);
679                 if (ret) {
680                         status = ntstatus_keeperror(
681                                 status, map_nt_error_from_unix(ret));
682                 }
683         }
684
685         /*
686          * If we're flushing on a close we can get a write
687          * error here, we must remember this.
688          */
689
690         tmp = close_filestruct(fsp);
691         status = ntstatus_keeperror(status, tmp);
692
693         if (fsp->print_file) {
694                 /* FIXME: return spool errors */
695                 print_spool_end(fsp, close_type);
696                 file_free(req, fsp);
697                 return NT_STATUS_OK;
698         }
699
700         /* Remove the oplock before potentially deleting the file. */
701         if(fsp->oplock_type) {
702                 release_file_oplock(fsp);
703         }
704
705         /* If this is an old DOS or FCB open and we have multiple opens on
706            the same handle we only have one share mode. Ensure we only remove
707            the share mode on the last close. */
708
709         if (fsp->fh->ref_count == 1) {
710                 /* Should we return on error here... ? */
711                 tmp = close_remove_share_mode(fsp, close_type);
712                 status = ntstatus_keeperror(status, tmp);
713         }
714
715         locking_close_file(conn->sconn->msg_ctx, fsp, close_type);
716
717         tmp = fd_close(fsp);
718         status = ntstatus_keeperror(status, tmp);
719
720         /* check for magic scripts */
721         if (close_type == NORMAL_CLOSE) {
722                 tmp = check_magic(fsp);
723                 status = ntstatus_keeperror(status, tmp);
724         }
725
726         /*
727          * Ensure pending modtime is set after close.
728          */
729
730         tmp = update_write_time_on_close(fsp);
731         if (NT_STATUS_EQUAL(tmp, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
732                 /* Someone renamed the file or a parent directory containing
733                  * this file. We can't do anything about this, we don't have
734                  * an "update timestamp by fd" call in POSIX. Eat the error. */
735
736                 tmp = NT_STATUS_OK;
737         }
738
739         status = ntstatus_keeperror(status, tmp);
740
741         DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
742                 conn->session_info->unix_info->unix_name, fsp_str_dbg(fsp),
743                 conn->num_files_open - 1,
744                 nt_errstr(status) ));
745
746         file_free(req, fsp);
747         return status;
748 }
749 /****************************************************************************
750  Static function used by reply_rmdir to delete an entire directory
751  tree recursively. Return True on ok, False on fail.
752 ****************************************************************************/
753
754 static bool recursive_rmdir(TALLOC_CTX *ctx,
755                         connection_struct *conn,
756                         struct smb_filename *smb_dname)
757 {
758         const char *dname = NULL;
759         char *talloced = NULL;
760         bool ret = True;
761         long offset = 0;
762         SMB_STRUCT_STAT st;
763         struct smb_Dir *dir_hnd;
764
765         SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
766
767         dir_hnd = OpenDir(talloc_tos(), conn, smb_dname->base_name, NULL, 0);
768         if(dir_hnd == NULL)
769                 return False;
770
771         while((dname = ReadDirName(dir_hnd, &offset, &st, &talloced))) {
772                 struct smb_filename *smb_dname_full = NULL;
773                 char *fullname = NULL;
774                 bool do_break = true;
775                 NTSTATUS status;
776
777                 if (ISDOT(dname) || ISDOTDOT(dname)) {
778                         TALLOC_FREE(talloced);
779                         continue;
780                 }
781
782                 if (!is_visible_file(conn, smb_dname->base_name, dname, &st,
783                                      false)) {
784                         TALLOC_FREE(talloced);
785                         continue;
786                 }
787
788                 /* Construct the full name. */
789                 fullname = talloc_asprintf(ctx,
790                                 "%s/%s",
791                                 smb_dname->base_name,
792                                 dname);
793                 if (!fullname) {
794                         errno = ENOMEM;
795                         goto err_break;
796                 }
797
798                 status = create_synthetic_smb_fname(talloc_tos(), fullname,
799                                                     NULL, NULL,
800                                                     &smb_dname_full);
801                 if (!NT_STATUS_IS_OK(status)) {
802                         goto err_break;
803                 }
804
805                 if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
806                         goto err_break;
807                 }
808
809                 if(smb_dname_full->st.st_ex_mode & S_IFDIR) {
810                         if(!recursive_rmdir(ctx, conn, smb_dname_full)) {
811                                 goto err_break;
812                         }
813                         if(SMB_VFS_RMDIR(conn,
814                                          smb_dname_full->base_name) != 0) {
815                                 goto err_break;
816                         }
817                 } else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) {
818                         goto err_break;
819                 }
820
821                 /* Successful iteration. */
822                 do_break = false;
823
824          err_break:
825                 TALLOC_FREE(smb_dname_full);
826                 TALLOC_FREE(fullname);
827                 TALLOC_FREE(talloced);
828                 if (do_break) {
829                         ret = false;
830                         break;
831                 }
832         }
833         TALLOC_FREE(dir_hnd);
834         return ret;
835 }
836
837 /****************************************************************************
838  The internals of the rmdir code - called elsewhere.
839 ****************************************************************************/
840
841 static NTSTATUS rmdir_internals(TALLOC_CTX *ctx, files_struct *fsp)
842 {
843         connection_struct *conn = fsp->conn;
844         struct smb_filename *smb_dname = fsp->fsp_name;
845         int ret;
846
847         SMB_ASSERT(!is_ntfs_stream_smb_fname(smb_dname));
848
849         /* Might be a symlink. */
850         if(SMB_VFS_LSTAT(conn, smb_dname) != 0) {
851                 return map_nt_error_from_unix(errno);
852         }
853
854         if (S_ISLNK(smb_dname->st.st_ex_mode)) {
855                 /* Is what it points to a directory ? */
856                 if(SMB_VFS_STAT(conn, smb_dname) != 0) {
857                         return map_nt_error_from_unix(errno);
858                 }
859                 if (!(S_ISDIR(smb_dname->st.st_ex_mode))) {
860                         return NT_STATUS_NOT_A_DIRECTORY;
861                 }
862                 ret = SMB_VFS_UNLINK(conn, smb_dname);
863         } else {
864                 ret = SMB_VFS_RMDIR(conn, smb_dname->base_name);
865         }
866         if (ret == 0) {
867                 notify_fname(conn, NOTIFY_ACTION_REMOVED,
868                              FILE_NOTIFY_CHANGE_DIR_NAME,
869                              smb_dname->base_name);
870                 return NT_STATUS_OK;
871         }
872
873         if(((errno == ENOTEMPTY)||(errno == EEXIST)) && *lp_veto_files(SNUM(conn))) {
874                 /*
875                  * Check to see if the only thing in this directory are
876                  * vetoed files/directories. If so then delete them and
877                  * retry. If we fail to delete any of them (and we *don't*
878                  * do a recursive delete) then fail the rmdir.
879                  */
880                 SMB_STRUCT_STAT st;
881                 const char *dname = NULL;
882                 char *talloced = NULL;
883                 long dirpos = 0;
884                 struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn,
885                                                   smb_dname->base_name, NULL,
886                                                   0);
887
888                 if(dir_hnd == NULL) {
889                         errno = ENOTEMPTY;
890                         goto err;
891                 }
892
893                 while ((dname = ReadDirName(dir_hnd, &dirpos, &st,
894                                             &talloced)) != NULL) {
895                         if((strcmp(dname, ".") == 0) || (strcmp(dname, "..")==0)) {
896                                 TALLOC_FREE(talloced);
897                                 continue;
898                         }
899                         if (!is_visible_file(conn, smb_dname->base_name, dname,
900                                              &st, false)) {
901                                 TALLOC_FREE(talloced);
902                                 continue;
903                         }
904                         if(!IS_VETO_PATH(conn, dname)) {
905                                 TALLOC_FREE(dir_hnd);
906                                 TALLOC_FREE(talloced);
907                                 errno = ENOTEMPTY;
908                                 goto err;
909                         }
910                         TALLOC_FREE(talloced);
911                 }
912
913                 /* We only have veto files/directories.
914                  * Are we allowed to delete them ? */
915
916                 if(!lp_recursive_veto_delete(SNUM(conn))) {
917                         TALLOC_FREE(dir_hnd);
918                         errno = ENOTEMPTY;
919                         goto err;
920                 }
921
922                 /* Do a recursive delete. */
923                 RewindDir(dir_hnd,&dirpos);
924                 while ((dname = ReadDirName(dir_hnd, &dirpos, &st,
925                                             &talloced)) != NULL) {
926                         struct smb_filename *smb_dname_full = NULL;
927                         char *fullname = NULL;
928                         bool do_break = true;
929                         NTSTATUS status;
930
931                         if (ISDOT(dname) || ISDOTDOT(dname)) {
932                                 TALLOC_FREE(talloced);
933                                 continue;
934                         }
935                         if (!is_visible_file(conn, smb_dname->base_name, dname,
936                                              &st, false)) {
937                                 TALLOC_FREE(talloced);
938                                 continue;
939                         }
940
941                         fullname = talloc_asprintf(ctx,
942                                         "%s/%s",
943                                         smb_dname->base_name,
944                                         dname);
945
946                         if(!fullname) {
947                                 errno = ENOMEM;
948                                 goto err_break;
949                         }
950
951                         status = create_synthetic_smb_fname(talloc_tos(),
952                                                             fullname, NULL,
953                                                             NULL,
954                                                             &smb_dname_full);
955                         if (!NT_STATUS_IS_OK(status)) {
956                                 errno = map_errno_from_nt_status(status);
957                                 goto err_break;
958                         }
959
960                         if(SMB_VFS_LSTAT(conn, smb_dname_full) != 0) {
961                                 goto err_break;
962                         }
963                         if(smb_dname_full->st.st_ex_mode & S_IFDIR) {
964                                 if(!recursive_rmdir(ctx, conn,
965                                                     smb_dname_full)) {
966                                         goto err_break;
967                                 }
968                                 if(SMB_VFS_RMDIR(conn,
969                                         smb_dname_full->base_name) != 0) {
970                                         goto err_break;
971                                 }
972                         } else if(SMB_VFS_UNLINK(conn, smb_dname_full) != 0) {
973                                 goto err_break;
974                         }
975
976                         /* Successful iteration. */
977                         do_break = false;
978
979                  err_break:
980                         TALLOC_FREE(fullname);
981                         TALLOC_FREE(smb_dname_full);
982                         TALLOC_FREE(talloced);
983                         if (do_break)
984                                 break;
985                 }
986                 TALLOC_FREE(dir_hnd);
987                 /* Retry the rmdir */
988                 ret = SMB_VFS_RMDIR(conn, smb_dname->base_name);
989         }
990
991   err:
992
993         if (ret != 0) {
994                 DEBUG(3,("rmdir_internals: couldn't remove directory %s : "
995                          "%s\n", smb_fname_str_dbg(smb_dname),
996                          strerror(errno)));
997                 return map_nt_error_from_unix(errno);
998         }
999
1000         notify_fname(conn, NOTIFY_ACTION_REMOVED,
1001                      FILE_NOTIFY_CHANGE_DIR_NAME,
1002                      smb_dname->base_name);
1003
1004         return NT_STATUS_OK;
1005 }
1006
1007 /****************************************************************************
1008  Close a directory opened by an NT SMB call. 
1009 ****************************************************************************/
1010   
1011 static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp,
1012                                 enum file_close_type close_type)
1013 {
1014         struct share_mode_lock *lck = NULL;
1015         bool delete_dir = False;
1016         NTSTATUS status = NT_STATUS_OK;
1017         NTSTATUS status1 = NT_STATUS_OK;
1018         const struct security_token *del_nt_token = NULL;
1019         const struct security_unix_token *del_token = NULL;
1020
1021         /*
1022          * NT can set delete_on_close of the last open
1023          * reference to a directory also.
1024          */
1025
1026         lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1027         if (lck == NULL) {
1028                 DEBUG(0, ("close_directory: Could not get share mode lock for "
1029                           "%s\n", fsp_str_dbg(fsp)));
1030                 status = NT_STATUS_INVALID_PARAMETER;
1031                 goto out;
1032         }
1033
1034         if (!del_share_mode(lck, fsp)) {
1035                 DEBUG(0, ("close_directory: Could not delete share entry for "
1036                           "%s\n", fsp_str_dbg(fsp)));
1037         }
1038
1039         if (fsp->initial_delete_on_close) {
1040                 bool became_user = False;
1041
1042                 /* Initial delete on close was set - for
1043                  * directories we don't care if anyone else
1044                  * wrote a real delete on close. */
1045
1046                 if (get_current_vuid(fsp->conn) != fsp->vuid) {
1047                         become_user(fsp->conn, fsp->vuid);
1048                         became_user = True;
1049                 }
1050                 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1051                                                fsp->fsp_name->base_name);
1052                 set_delete_on_close_lck(fsp, lck, true,
1053                                 get_current_nttok(fsp->conn),
1054                                 get_current_utok(fsp->conn));
1055                 fsp->delete_on_close = true;
1056                 if (became_user) {
1057                         unbecome_user();
1058                 }
1059         }
1060
1061         delete_dir = get_delete_on_close_token(lck, fsp->name_hash,
1062                                         &del_nt_token, &del_token);
1063
1064         if (delete_dir) {
1065                 int i;
1066                 /* See if others still have the dir open. If this is the
1067                  * case, then don't delete. If all opens are POSIX delete now. */
1068                 for (i=0; i<lck->data->num_share_modes; i++) {
1069                         struct share_mode_entry *e = &lck->data->share_modes[i];
1070                         if (is_valid_share_mode_entry(e) &&
1071                                         e->name_hash == fsp->name_hash) {
1072                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
1073                                         continue;
1074                                 }
1075                                 delete_dir = False;
1076                                 break;
1077                         }
1078                 }
1079         }
1080
1081         if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
1082                                 delete_dir) {
1083         
1084                 /* Become the user who requested the delete. */
1085
1086                 if (!push_sec_ctx()) {
1087                         smb_panic("close_directory: failed to push sec_ctx.\n");
1088                 }
1089
1090                 set_sec_ctx(del_token->uid,
1091                                 del_token->gid,
1092                                 del_token->ngroups,
1093                                 del_token->groups,
1094                                 del_nt_token);
1095
1096                 TALLOC_FREE(lck);
1097
1098                 if ((fsp->conn->fs_capabilities & FILE_NAMED_STREAMS)
1099                     && !is_ntfs_stream_smb_fname(fsp->fsp_name)) {
1100
1101                         status = delete_all_streams(fsp->conn, fsp->fsp_name->base_name);
1102                         if (!NT_STATUS_IS_OK(status)) {
1103                                 DEBUG(5, ("delete_all_streams failed: %s\n",
1104                                           nt_errstr(status)));
1105                                 goto out;
1106                         }
1107                 }
1108
1109                 status = rmdir_internals(talloc_tos(), fsp);
1110
1111                 DEBUG(5,("close_directory: %s. Delete on close was set - "
1112                          "deleting directory returned %s.\n",
1113                          fsp_str_dbg(fsp), nt_errstr(status)));
1114
1115                 /* unbecome user. */
1116                 pop_sec_ctx();
1117
1118                 /*
1119                  * Ensure we remove any change notify requests that would
1120                  * now fail as the directory has been deleted.
1121                  */
1122
1123                 if(NT_STATUS_IS_OK(status)) {
1124                         remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING);
1125                 }
1126         } else {
1127                 TALLOC_FREE(lck);
1128                 remove_pending_change_notify_requests_by_fid(
1129                         fsp, NT_STATUS_OK);
1130         }
1131
1132         status1 = fd_close(fsp);
1133
1134         if (!NT_STATUS_IS_OK(status1)) {
1135                 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
1136                           fsp_str_dbg(fsp), fsp->fh->fd, errno,
1137                           strerror(errno)));
1138         }
1139
1140         /*
1141          * Do the code common to files and directories.
1142          */
1143         close_filestruct(fsp);
1144         file_free(req, fsp);
1145
1146  out:
1147         TALLOC_FREE(lck);
1148         if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(status1)) {
1149                 status = status1;
1150         }
1151         return status;
1152 }
1153
1154 /****************************************************************************
1155  Close a files_struct.
1156 ****************************************************************************/
1157   
1158 NTSTATUS close_file(struct smb_request *req, files_struct *fsp,
1159                     enum file_close_type close_type)
1160 {
1161         NTSTATUS status;
1162         struct files_struct *base_fsp = fsp->base_fsp;
1163
1164         if(fsp->is_directory) {
1165                 status = close_directory(req, fsp, close_type);
1166         } else if (fsp->fake_file_handle != NULL) {
1167                 status = close_fake_file(req, fsp);
1168         } else {
1169                 status = close_normal_file(req, fsp, close_type);
1170         }
1171
1172         if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) {
1173
1174                 /*
1175                  * fsp was a stream, the base fsp can't be a stream as well
1176                  *
1177                  * For SHUTDOWN_CLOSE this is not possible here, because
1178                  * SHUTDOWN_CLOSE only happens from files.c which walks the
1179                  * complete list of files. If we mess with more than one fsp
1180                  * those loops will become confused.
1181                  */
1182
1183                 SMB_ASSERT(base_fsp->base_fsp == NULL);
1184                 close_file(req, base_fsp, close_type);
1185         }
1186
1187         return status;
1188 }
1189
1190 /****************************************************************************
1191  Deal with an (authorized) message to close a file given the share mode
1192  entry.
1193 ****************************************************************************/
1194
1195 void msg_close_file(struct messaging_context *msg_ctx,
1196                         void *private_data,
1197                         uint32_t msg_type,
1198                         struct server_id server_id,
1199                         DATA_BLOB *data)
1200 {
1201         files_struct *fsp = NULL;
1202         struct share_mode_entry e;
1203         struct smbd_server_connection *sconn =
1204                 talloc_get_type_abort(private_data,
1205                 struct smbd_server_connection);
1206
1207         message_to_share_mode_entry(&e, (char *)data->data);
1208
1209         if(DEBUGLVL(10)) {
1210                 char *sm_str = share_mode_str(NULL, 0, &e);
1211                 if (!sm_str) {
1212                         smb_panic("talloc failed");
1213                 }
1214                 DEBUG(10,("msg_close_file: got request to close share mode "
1215                         "entry %s\n", sm_str));
1216                 TALLOC_FREE(sm_str);
1217         }
1218
1219         fsp = file_find_dif(sconn, e.id, e.share_file_id);
1220         if (!fsp) {
1221                 DEBUG(10,("msg_close_file: failed to find file.\n"));
1222                 return;
1223         }
1224         close_file(NULL, fsp, NORMAL_CLOSE);
1225 }