Context Navigation

source: branches/samba-3.3.x/source/smbd/close.c@ 850

Visit:

Last change on this file since 850 was 222, checked in by Herwig Bauernfeind, 16 years ago
Update Samba 3.3 branch to 3.3.2
File size: 20.3 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: