Fix more POSIX path lstat calls. Fix bug where close can return
[jra/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
24 extern struct current_user current_user;
25
26 /****************************************************************************
27  Run a file if it is a magic script.
28 ****************************************************************************/
29
30 static void check_magic(struct files_struct *fsp)
31 {
32         int ret;
33         const char *magic_output = NULL;
34         SMB_STRUCT_STAT st;
35         int tmp_fd, outfd;
36         TALLOC_CTX *ctx = NULL;
37         const char *p;
38         struct connection_struct *conn = fsp->conn;
39
40         if (!*lp_magicscript(SNUM(conn))) {
41                 return;
42         }
43
44         DEBUG(5,("checking magic for %s\n",fsp->fsp_name));
45
46         if (!(p = strrchr_m(fsp->fsp_name,'/'))) {
47                 p = fsp->fsp_name;
48         } else {
49                 p++;
50         }
51
52         if (!strequal(lp_magicscript(SNUM(conn)),p)) {
53                 return;
54         }
55
56         ctx = talloc_stackframe();
57
58         if (*lp_magicoutput(SNUM(conn))) {
59                 magic_output = lp_magicoutput(SNUM(conn));
60         } else {
61                 magic_output = talloc_asprintf(ctx,
62                                 "%s.out",
63                                 fsp->fsp_name);
64         }
65         if (!magic_output) {
66                 TALLOC_FREE(ctx);
67                 return;
68         }
69
70         /* Ensure we don't depend on user's PATH. */
71         p = talloc_asprintf(ctx, "./%s", fsp->fsp_name);
72         if (!p) {
73                 TALLOC_FREE(ctx);
74                 return;
75         }
76
77         if (chmod(fsp->fsp_name,0755) == -1) {
78                 TALLOC_FREE(ctx);
79                 return;
80         }
81         ret = smbrun(p,&tmp_fd);
82         DEBUG(3,("Invoking magic command %s gave %d\n",
83                 p,ret));
84
85         unlink(fsp->fsp_name);
86         if (ret != 0 || tmp_fd == -1) {
87                 if (tmp_fd != -1) {
88                         close(tmp_fd);
89                 }
90                 TALLOC_FREE(ctx);
91                 return;
92         }
93         outfd = open(magic_output, O_CREAT|O_EXCL|O_RDWR, 0600);
94         if (outfd == -1) {
95                 close(tmp_fd);
96                 TALLOC_FREE(ctx);
97                 return;
98         }
99
100         if (sys_fstat(tmp_fd,&st) == -1) {
101                 close(tmp_fd);
102                 close(outfd);
103                 return;
104         }
105
106         transfer_file(tmp_fd,outfd,(SMB_OFF_T)st.st_size);
107         close(tmp_fd);
108         close(outfd);
109         TALLOC_FREE(ctx);
110 }
111
112 /****************************************************************************
113   Common code to close a file or a directory.
114 ****************************************************************************/
115
116 static NTSTATUS close_filestruct(files_struct *fsp)
117 {
118         NTSTATUS status = NT_STATUS_OK;
119
120         if (fsp->fh->fd != -1) {
121                 if(flush_write_cache(fsp, CLOSE_FLUSH) == -1) {
122                         status = map_nt_error_from_unix(errno);
123                 }
124                 delete_write_cache(fsp);
125         }
126
127         return status;
128 }
129
130 /****************************************************************************
131  If any deferred opens are waiting on this close, notify them.
132 ****************************************************************************/
133
134 static void notify_deferred_opens(struct share_mode_lock *lck)
135 {
136         int i;
137
138         if (!should_notify_deferred_opens()) {
139                 return;
140         }
141  
142         for (i=0; i<lck->num_share_modes; i++) {
143                 struct share_mode_entry *e = &lck->share_modes[i];
144  
145                 if (!is_deferred_open_entry(e)) {
146                         continue;
147                 }
148  
149                 if (procid_is_me(&e->pid)) {
150                         /*
151                          * We need to notify ourself to retry the open.  Do
152                          * this by finding the queued SMB record, moving it to
153                          * the head of the queue and changing the wait time to
154                          * zero.
155                          */
156                         schedule_deferred_open_smb_message(e->op_mid);
157                 } else {
158                         char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
159
160                         share_mode_entry_to_message(msg, e);
161
162                         messaging_send_buf(smbd_messaging_context(),
163                                            e->pid, MSG_SMB_OPEN_RETRY,
164                                            (uint8 *)msg,
165                                            MSG_SMB_SHARE_MODE_ENTRY_SIZE);
166                 }
167         }
168 }
169
170 /****************************************************************************
171  Delete all streams
172 ****************************************************************************/
173
174 NTSTATUS delete_all_streams(connection_struct *conn, const char *fname)
175 {
176         struct stream_struct *stream_info;
177         int i;
178         unsigned int num_streams;
179         TALLOC_CTX *frame = talloc_stackframe();
180         NTSTATUS status;
181
182         status = SMB_VFS_STREAMINFO(conn, NULL, fname, talloc_tos(),
183                                     &num_streams, &stream_info);
184
185         if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
186                 DEBUG(10, ("no streams around\n"));
187                 TALLOC_FREE(frame);
188                 return NT_STATUS_OK;
189         }
190
191         if (!NT_STATUS_IS_OK(status)) {
192                 DEBUG(10, ("SMB_VFS_STREAMINFO failed: %s\n",
193                            nt_errstr(status)));
194                 goto fail;
195         }
196
197         DEBUG(10, ("delete_all_streams found %d streams\n",
198                    num_streams));
199
200         if (num_streams == 0) {
201                 TALLOC_FREE(frame);
202                 return NT_STATUS_OK;
203         }
204
205         for (i=0; i<num_streams; i++) {
206                 int res;
207                 char *streamname;
208
209                 if (strequal(stream_info[i].name, "::$DATA")) {
210                         continue;
211                 }
212
213                 streamname = talloc_asprintf(talloc_tos(), "%s%s", fname,
214                                              stream_info[i].name);
215
216                 if (streamname == NULL) {
217                         DEBUG(0, ("talloc_aprintf failed\n"));
218                         status = NT_STATUS_NO_MEMORY;
219                         goto fail;
220                 }
221
222                 res = SMB_VFS_UNLINK(conn, streamname);
223
224                 TALLOC_FREE(streamname);
225
226                 if (res == -1) {
227                         status = map_nt_error_from_unix(errno);
228                         DEBUG(10, ("Could not delete stream %s: %s\n",
229                                    streamname, strerror(errno)));
230                         break;
231                 }
232         }
233
234  fail:
235         TALLOC_FREE(frame);
236         return status;
237 }
238
239 /****************************************************************************
240  Deal with removing a share mode on last close.
241 ****************************************************************************/
242
243 static NTSTATUS close_remove_share_mode(files_struct *fsp,
244                                         enum file_close_type close_type)
245 {
246         connection_struct *conn = fsp->conn;
247         bool delete_file = false;
248         bool changed_user = false;
249         struct share_mode_lock *lck;
250         SMB_STRUCT_STAT sbuf;
251         NTSTATUS status = NT_STATUS_OK;
252         int ret;
253         struct file_id id;
254
255         /*
256          * Lock the share entries, and determine if we should delete
257          * on close. If so delete whilst the lock is still in effect.
258          * This prevents race conditions with the file being created. JRA.
259          */
260
261         lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
262                                   NULL);
263
264         if (lck == NULL) {
265                 DEBUG(0, ("close_remove_share_mode: Could not get share mode "
266                           "lock for file %s\n", fsp->fsp_name));
267                 return NT_STATUS_INVALID_PARAMETER;
268         }
269
270         if (fsp->write_time_forced) {
271                 set_close_write_time(fsp, lck->changed_write_time);
272         }
273
274         if (!del_share_mode(lck, fsp)) {
275                 DEBUG(0, ("close_remove_share_mode: Could not delete share "
276                           "entry for file %s\n", fsp->fsp_name));
277         }
278
279         if (fsp->initial_delete_on_close && (lck->delete_token == NULL)) {
280                 bool became_user = False;
281
282                 /* Initial delete on close was set and no one else
283                  * wrote a real delete on close. */
284
285                 if (current_user.vuid != fsp->vuid) {
286                         become_user(conn, fsp->vuid);
287                         became_user = True;
288                 }
289                 set_delete_on_close_lck(lck, True, &current_user.ut);
290                 if (became_user) {
291                         unbecome_user();
292                 }
293         }
294
295         delete_file = lck->delete_on_close;
296
297         if (delete_file) {
298                 int i;
299                 /* See if others still have the file open. If this is the
300                  * case, then don't delete. If all opens are POSIX delete now. */
301                 for (i=0; i<lck->num_share_modes; i++) {
302                         struct share_mode_entry *e = &lck->share_modes[i];
303                         if (is_valid_share_mode_entry(e)) {
304                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
305                                         continue;
306                                 }
307                                 delete_file = False;
308                                 break;
309                         }
310                 }
311         }
312
313         /* Notify any deferred opens waiting on this close. */
314         notify_deferred_opens(lck);
315         reply_to_oplock_break_requests(fsp);
316
317         /*
318          * NT can set delete_on_close of the last open
319          * reference to a file.
320          */
321
322         if (!(close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE)
323             || !delete_file
324             || (lck->delete_token == NULL)) {
325                 TALLOC_FREE(lck);
326                 return NT_STATUS_OK;
327         }
328
329         /*
330          * Ok, we have to delete the file
331          */
332
333         DEBUG(5,("close_remove_share_mode: file %s. Delete on close was set "
334                  "- deleting file.\n", fsp->fsp_name));
335
336         /*
337          * Don't try to update the write time when we delete the file
338          */
339         fsp->update_write_time_on_close = false;
340
341         if (!unix_token_equal(lck->delete_token, &current_user.ut)) {
342                 /* Become the user who requested the delete. */
343
344                 DEBUG(5,("close_remove_share_mode: file %s. "
345                         "Change user to uid %u\n",
346                         fsp->fsp_name,
347                         (unsigned int)lck->delete_token->uid));
348
349                 if (!push_sec_ctx()) {
350                         smb_panic("close_remove_share_mode: file %s. failed to push "
351                                   "sec_ctx.\n");
352                 }
353
354                 set_sec_ctx(lck->delete_token->uid,
355                             lck->delete_token->gid,
356                             lck->delete_token->ngroups,
357                             lck->delete_token->groups,
358                             NULL);
359
360                 changed_user = true;
361         }
362
363         /* We can only delete the file if the name we have is still valid and
364            hasn't been renamed. */
365
366         if (fsp->posix_open) {
367                 ret = SMB_VFS_LSTAT(conn,fsp->fsp_name,&sbuf);
368         } else {
369                 ret = SMB_VFS_STAT(conn,fsp->fsp_name,&sbuf);
370         }
371
372         if (ret != 0) {
373                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
374                          "was set and stat failed with error %s\n",
375                          fsp->fsp_name, strerror(errno) ));
376                 /*
377                  * Don't save the errno here, we ignore this error
378                  */
379                 goto done;
380         }
381
382         id = vfs_file_id_from_sbuf(conn, &sbuf);
383
384         if (!file_id_equal(&fsp->file_id, &id)) {
385                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
386                          "was set and dev and/or inode does not match\n",
387                          fsp->fsp_name ));
388                 DEBUG(5,("close_remove_share_mode: file %s. stored file_id %s, "
389                          "stat file_id %s\n",
390                          fsp->fsp_name,
391                          file_id_string_tos(&fsp->file_id),
392                          file_id_string_tos(&id)));
393                 /*
394                  * Don't save the errno here, we ignore this error
395                  */
396                 goto done;
397         }
398
399         if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
400             && !is_ntfs_stream_name(fsp->fsp_name)) {
401
402                 status = delete_all_streams(conn, fsp->fsp_name);
403
404                 if (!NT_STATUS_IS_OK(status)) {
405                         DEBUG(5, ("delete_all_streams failed: %s\n",
406                                   nt_errstr(status)));
407                         goto done;
408                 }
409         }
410
411
412         if (SMB_VFS_UNLINK(conn,fsp->fsp_name) != 0) {
413                 /*
414                  * This call can potentially fail as another smbd may
415                  * have had the file open with delete on close set and
416                  * deleted it when its last reference to this file
417                  * went away. Hence we log this but not at debug level
418                  * zero.
419                  */
420
421                 DEBUG(5,("close_remove_share_mode: file %s. Delete on close "
422                          "was set and unlink failed with error %s\n",
423                          fsp->fsp_name, strerror(errno) ));
424
425                 status = map_nt_error_from_unix(errno);
426         }
427
428         notify_fname(conn, NOTIFY_ACTION_REMOVED,
429                      FILE_NOTIFY_CHANGE_FILE_NAME,
430                      fsp->fsp_name);
431
432         /* As we now have POSIX opens which can unlink
433          * with other open files we may have taken
434          * this code path with more than one share mode
435          * entry - ensure we only delete once by resetting
436          * the delete on close flag. JRA.
437          */
438
439         set_delete_on_close_lck(lck, False, NULL);
440
441  done:
442
443         if (changed_user) {
444                 /* unbecome user. */
445                 pop_sec_ctx();
446         }
447
448         TALLOC_FREE(lck);
449         return status;
450 }
451
452 void set_close_write_time(struct files_struct *fsp, struct timespec ts)
453 {
454         DEBUG(6,("close_write_time: %s" , time_to_asc(convert_timespec_to_time_t(ts))));
455
456         if (null_timespec(ts)) {
457                 return;
458         }
459         /*
460          * if the write time on close is explict set, then don't
461          * need to fix it up to the value in the locking db
462          */
463         fsp->write_time_forced = false;
464
465         fsp->update_write_time_on_close = true;
466         fsp->close_write_time = ts;
467 }
468
469 static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
470 {
471         SMB_STRUCT_STAT sbuf;
472         struct smb_file_time ft;
473         NTSTATUS status;
474         int ret = -1;
475
476         ZERO_STRUCT(sbuf);
477         ZERO_STRUCT(ft);
478
479         if (!fsp->update_write_time_on_close) {
480                 return NT_STATUS_OK;
481         }
482
483         if (null_timespec(fsp->close_write_time)) {
484                 fsp->close_write_time = timespec_current();
485         }
486
487         /* Ensure we have a valid stat struct for the source. */
488         if (fsp->fh->fd != -1) {
489                 ret = SMB_VFS_FSTAT(fsp, &sbuf);
490         } else {
491                 if (fsp->posix_open) {
492                         ret = SMB_VFS_LSTAT(fsp->conn,fsp->fsp_name,&sbuf);
493                 } else {
494                         ret = SMB_VFS_STAT(fsp->conn,fsp->fsp_name,&sbuf);
495                 }
496         }
497
498         if (ret == -1) {
499                 return map_nt_error_from_unix(errno);
500         }
501
502         if (!VALID_STAT(sbuf)) {
503                 /* if it doesn't seem to be a real file */
504                 return NT_STATUS_OK;
505         }
506
507         ft.mtime = fsp->close_write_time;
508         status = smb_set_file_time(fsp->conn, fsp, fsp->fsp_name,
509                                    &sbuf, &ft, true);
510         if (!NT_STATUS_IS_OK(status)) {
511                 return status;
512         }
513
514         return NT_STATUS_OK;
515 }
516
517 /****************************************************************************
518  Close a file.
519
520  close_type can be NORMAL_CLOSE=0,SHUTDOWN_CLOSE,ERROR_CLOSE.
521  printing and magic scripts are only run on normal close.
522  delete on close is done on normal and shutdown close.
523 ****************************************************************************/
524
525 static NTSTATUS close_normal_file(struct smb_request *req, files_struct *fsp,
526                                   enum file_close_type close_type)
527 {
528         NTSTATUS status = NT_STATUS_OK;
529         NTSTATUS saved_status1 = NT_STATUS_OK;
530         NTSTATUS saved_status2 = NT_STATUS_OK;
531         NTSTATUS saved_status3 = NT_STATUS_OK;
532         NTSTATUS saved_status4 = NT_STATUS_OK;
533         connection_struct *conn = fsp->conn;
534
535         if (fsp->aio_write_behind) {
536                 /*
537                  * If we're finishing write behind on a close we can get a write
538                  * error here, we must remember this.
539                  */
540                 int ret = wait_for_aio_completion(fsp);
541                 if (ret) {
542                         saved_status1 = map_nt_error_from_unix(ret);
543                 }
544         } else {
545                 cancel_aio_by_fsp(fsp);
546         }
547  
548         /*
549          * If we're flushing on a close we can get a write
550          * error here, we must remember this.
551          */
552
553         saved_status2 = close_filestruct(fsp);
554
555         if (fsp->print_file) {
556                 print_fsp_end(fsp, close_type);
557                 file_free(req, fsp);
558                 return NT_STATUS_OK;
559         }
560
561         /* Remove the oplock before potentially deleting the file. */
562         if(fsp->oplock_type) {
563                 release_file_oplock(fsp);
564         }
565
566         /* If this is an old DOS or FCB open and we have multiple opens on
567            the same handle we only have one share mode. Ensure we only remove
568            the share mode on the last close. */
569
570         if (fsp->fh->ref_count == 1) {
571                 /* Should we return on error here... ? */
572                 saved_status3 = close_remove_share_mode(fsp, close_type);
573         }
574
575         locking_close_file(smbd_messaging_context(), fsp);
576
577         status = fd_close(fsp);
578
579         /* check for magic scripts */
580         if (close_type == NORMAL_CLOSE) {
581                 check_magic(fsp);
582         }
583
584         /*
585          * Ensure pending modtime is set after close.
586          */
587
588         saved_status4 = update_write_time_on_close(fsp);
589         if (NT_STATUS_EQUAL(saved_status4, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
590                 /* Someone renamed the file or a parent directory containing
591                  * this file. We can't do anything about this, we don't have
592                  * an "update timestamp by fd" call in POSIX. Eat the error. */
593
594                 saved_status4 = NT_STATUS_OK;
595         }
596
597         if (NT_STATUS_IS_OK(status)) {
598                 if (!NT_STATUS_IS_OK(saved_status1)) {
599                         status = saved_status1;
600                 } else if (!NT_STATUS_IS_OK(saved_status2)) {
601                         status = saved_status2;
602                 } else if (!NT_STATUS_IS_OK(saved_status3)) {
603                         status = saved_status3;
604                 } else if (!NT_STATUS_IS_OK(saved_status4)) {
605                         status = saved_status4;
606                 }
607         }
608
609         DEBUG(2,("%s closed file %s (numopen=%d) %s\n",
610                 conn->server_info->unix_name,fsp->fsp_name,
611                 conn->num_files_open - 1,
612                 nt_errstr(status) ));
613
614         file_free(req, fsp);
615         return status;
616 }
617
618 /****************************************************************************
619  Close a directory opened by an NT SMB call. 
620 ****************************************************************************/
621   
622 static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp,
623                                 enum file_close_type close_type)
624 {
625         struct share_mode_lock *lck = 0;
626         bool delete_dir = False;
627         NTSTATUS status = NT_STATUS_OK;
628
629         /*
630          * NT can set delete_on_close of the last open
631          * reference to a directory also.
632          */
633
634         lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
635                                   NULL);
636
637         if (lck == NULL) {
638                 DEBUG(0, ("close_directory: Could not get share mode lock for %s\n", fsp->fsp_name));
639                 return NT_STATUS_INVALID_PARAMETER;
640         }
641
642         if (!del_share_mode(lck, fsp)) {
643                 DEBUG(0, ("close_directory: Could not delete share entry for %s\n", fsp->fsp_name));
644         }
645
646         if (fsp->initial_delete_on_close) {
647                 bool became_user = False;
648
649                 /* Initial delete on close was set - for
650                  * directories we don't care if anyone else
651                  * wrote a real delete on close. */
652
653                 if (current_user.vuid != fsp->vuid) {
654                         become_user(fsp->conn, fsp->vuid);
655                         became_user = True;
656                 }
657                 send_stat_cache_delete_message(fsp->fsp_name);
658                 set_delete_on_close_lck(lck, True, &current_user.ut);
659                 if (became_user) {
660                         unbecome_user();
661                 }
662         }
663
664         delete_dir = lck->delete_on_close;
665
666         if (delete_dir) {
667                 int i;
668                 /* See if others still have the dir open. If this is the
669                  * case, then don't delete. If all opens are POSIX delete now. */
670                 for (i=0; i<lck->num_share_modes; i++) {
671                         struct share_mode_entry *e = &lck->share_modes[i];
672                         if (is_valid_share_mode_entry(e)) {
673                                 if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
674                                         continue;
675                                 }
676                                 delete_dir = False;
677                                 break;
678                         }
679                 }
680         }
681
682         if ((close_type == NORMAL_CLOSE || close_type == SHUTDOWN_CLOSE) &&
683                                 delete_dir &&
684                                 lck->delete_token) {
685         
686                 /* Become the user who requested the delete. */
687
688                 if (!push_sec_ctx()) {
689                         smb_panic("close_directory: failed to push sec_ctx.\n");
690                 }
691
692                 set_sec_ctx(lck->delete_token->uid,
693                                 lck->delete_token->gid,
694                                 lck->delete_token->ngroups,
695                                 lck->delete_token->groups,
696                                 NULL);
697
698                 TALLOC_FREE(lck);
699
700                 status = rmdir_internals(talloc_tos(),
701                                 fsp->conn, fsp->fsp_name);
702
703                 DEBUG(5,("close_directory: %s. Delete on close was set - "
704                          "deleting directory returned %s.\n",
705                          fsp->fsp_name, nt_errstr(status)));
706
707                 /* unbecome user. */
708                 pop_sec_ctx();
709
710                 /*
711                  * Ensure we remove any change notify requests that would
712                  * now fail as the directory has been deleted.
713                  */
714
715                 if(NT_STATUS_IS_OK(status)) {
716                         remove_pending_change_notify_requests_by_fid(fsp, NT_STATUS_DELETE_PENDING);
717                 }
718         } else {
719                 TALLOC_FREE(lck);
720                 remove_pending_change_notify_requests_by_fid(
721                         fsp, NT_STATUS_OK);
722         }
723
724         status = fd_close(fsp);
725
726         if (!NT_STATUS_IS_OK(status)) {
727                 DEBUG(0, ("Could not close dir! fname=%s, fd=%d, err=%d=%s\n",
728                           fsp->fsp_name, fsp->fh->fd, errno, strerror(errno)));
729         }
730
731         /*
732          * Do the code common to files and directories.
733          */
734         close_filestruct(fsp);
735         file_free(req, fsp);
736         return status;
737 }
738
739 /****************************************************************************
740  Close a files_struct.
741 ****************************************************************************/
742   
743 NTSTATUS close_file(struct smb_request *req, files_struct *fsp,
744                     enum file_close_type close_type)
745 {
746         NTSTATUS status;
747         struct files_struct *base_fsp = fsp->base_fsp;
748
749         if(fsp->is_directory) {
750                 status = close_directory(req, fsp, close_type);
751         } else if (fsp->fake_file_handle != NULL) {
752                 status = close_fake_file(req, fsp);
753         } else {
754                 status = close_normal_file(req, fsp, close_type);
755         }
756
757         if ((base_fsp != NULL) && (close_type != SHUTDOWN_CLOSE)) {
758
759                 /*
760                  * fsp was a stream, the base fsp can't be a stream as well
761                  *
762                  * For SHUTDOWN_CLOSE this is not possible here, because
763                  * SHUTDOWN_CLOSE only happens from files.c which walks the
764                  * complete list of files. If we mess with more than one fsp
765                  * those loops will become confused.
766                  */
767
768                 SMB_ASSERT(base_fsp->base_fsp == NULL);
769                 close_file(req, base_fsp, close_type);
770         }
771
772         return status;
773 }
774
775 /****************************************************************************
776  Deal with an (authorized) message to close a file given the share mode
777  entry.
778 ****************************************************************************/
779
780 void msg_close_file(struct messaging_context *msg_ctx,
781                         void *private_data,
782                         uint32_t msg_type,
783                         struct server_id server_id,
784                         DATA_BLOB *data)
785 {
786         files_struct *fsp = NULL;
787         struct share_mode_entry e;
788
789         message_to_share_mode_entry(&e, (char *)data->data);
790
791         if(DEBUGLVL(10)) {
792                 char *sm_str = share_mode_str(NULL, 0, &e);
793                 if (!sm_str) {
794                         smb_panic("talloc failed");
795                 }
796                 DEBUG(10,("msg_close_file: got request to close share mode "
797                         "entry %s\n", sm_str));
798                 TALLOC_FREE(sm_str);
799         }
800
801         fsp = file_find_dif(e.id, e.share_file_id);
802         if (!fsp) {
803                 DEBUG(10,("msg_close_file: failed to find file.\n"));
804                 return;
805         }
806         close_file(NULL, fsp, NORMAL_CLOSE);
807 }