Context Navigation

source: trunk/server/source3/smbd/close.c@ 750

Visit:

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

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

Download in other formats: