/* [<][>][^][v][top][bottom][index][help] */
DEFINITIONS
This source file includes following definitions.
- check_magic
- close_filestruct
- notify_deferred_opens
- delete_all_streams
- close_remove_share_mode
- set_close_write_time
- update_write_time_on_close
- close_normal_file
- close_directory
- close_file
- msg_close_file
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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, ¤t_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, ¤t_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)
/* [<][>][^][v][top][bottom][index][help] */
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)
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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, ¤t_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,
/* [<][>][^][v][top][bottom][index][help] */
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,
/* [<][>][^][v][top][bottom][index][help] */
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 }