Context Navigation

source: trunk/server/source3/smbd/dir.c@ 745

Visit:

Last change on this file since 745 was 745, checked in by Silvan Scherrer, 13 years ago
Samba Server: updated trunk to 3.6.0
File size: 44.6 KB

Line
1	/*
2	Unix SMB/CIFS implementation.
3	Directory handling routines
4	Copyright (C) Andrew Tridgell 1992-1998
5	Copyright (C) Jeremy Allison 2007
6
7	This program is free software; you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 3 of the License, or
10	(at your option) any later version.
11
12	This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.
16
17	You should have received a copy of the GNU General Public License
18	along with this program. If not, see <http://www.gnu.org/licenses/>.
19	*/
20
21	#include "includes.h"
22	#include "system/filesys.h"
23	#include "smbd/smbd.h"
24	#include "smbd/globals.h"
25	#include "libcli/security/security.h"
26
27	/*
28	This module implements directory related functions for Samba.
29	*/
30
31	/* "Special" directory offsets. */
32	#define END_OF_DIRECTORY_OFFSET ((long)-1)
33	#define START_OF_DIRECTORY_OFFSET ((long)0)
34	#define DOT_DOT_DIRECTORY_OFFSET ((long)0x80000000)
35
36	/* Make directory handle internals available. */
37
38	struct name_cache_entry {
39	char *name;
40	long offset;
41	};
42
43	struct smb_Dir {
44	connection_struct *conn;
45	SMB_STRUCT_DIR *dir;
46	long offset;
47	char *dir_path;
48	size_t name_cache_size;
49	struct name_cache_entry *name_cache;
50	unsigned int name_cache_index;
51	unsigned int file_number;
52	};
53
54	struct dptr_struct {
55	struct dptr_struct next, prev;
56	int dnum;
57	uint16 spid;
58	struct connection_struct *conn;
59	struct smb_Dir *dir_hnd;
60	bool expect_close;
61	char *wcard;
62	uint32 attr;
63	char *path;
64	bool has_wild; /* Set to true if the wcard entry has MS wildcard characters in it. */
65	bool did_stat; /* Optimisation for non-wcard searches. */
66	};
67
68	static struct smb_Dir OpenDir_fsp(TALLOC_CTX mem_ctx, connection_struct *conn,
69	files_struct *fsp,
70	const char *mask,
71	uint32 attr);
72
73	#define INVALID_DPTR_KEY (-3)
74
75	/****************************************************************************
76	Make a dir struct.
77	****************************************************************************/
78
79	bool make_dir_struct(TALLOC_CTX *ctx,
80	char *buf,
81	const char *mask,
82	const char *fname,
83	SMB_OFF_T size,
84	uint32 mode,
85	time_t date,
86	bool uc)
87	{
88	char *p;
89	char *mask2 = talloc_strdup(ctx, mask);
90
91	if (!mask2) {
92	return False;
93	}
94
95	if ((mode & FILE_ATTRIBUTE_DIRECTORY) != 0) {
96	size = 0;
97	}
98
99	memset(buf+1,' ',11);
100	if ((p = strchr_m(mask2,'.')) != NULL) {
101	*p = 0;
102	push_ascii(buf+1,mask2,8, 0);
103	push_ascii(buf+9,p+1,3, 0);
104	*p = '.';
105	} else {
106	push_ascii(buf+1,mask2,11, 0);
107	}
108
109	memset(buf+21,'\0',DIR_STRUCT_SIZE-21);
110	SCVAL(buf,21,mode);
111	srv_put_dos_date(buf,22,date);
112	SSVAL(buf,26,size & 0xFFFF);
113	SSVAL(buf,28,(size >> 16)&0xFFFF);
114	/* We only uppercase if FLAGS2_LONG_PATH_COMPONENTS is zero in the input buf.
115	Strange, but verified on W2K3. Needed for OS/2. JRA. */
116	push_ascii(buf+30,fname,12, uc ? STR_UPPER : 0);
117	DEBUG(8,("put name [%s] from [%s] into dir struct\n",buf+30, fname));
118	return True;
119	}
120
121	/****************************************************************************
122	Initialise the dir bitmap.
123	****************************************************************************/
124
125	bool init_dptrs(struct smbd_server_connection *sconn)
126	{
127	if (sconn->searches.dptr_bmap) {
128	return true;
129	}
130
131	sconn->searches.dptr_bmap = bitmap_talloc(
132	sconn, MAX_DIRECTORY_HANDLES);
133
134	if (sconn->searches.dptr_bmap == NULL) {
135	return false;
136	}
137
138	return true;
139	}
140
141	/****************************************************************************
142	Idle a dptr - the directory is closed but the control info is kept.
143	****************************************************************************/
144
145	static void dptr_idle(struct dptr_struct *dptr)
146	{
147	if (dptr->dir_hnd) {
148	DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
149	TALLOC_FREE(dptr->dir_hnd);
150	}
151	}
152
153	/****************************************************************************
154	Idle the oldest dptr.
155	****************************************************************************/
156
157	static void dptr_idleoldest(struct smbd_server_connection *sconn)
158	{
159	struct dptr_struct *dptr;
160
161	/*
162	* Go to the end of the list.
163	*/
164	dptr = DLIST_TAIL(sconn->searches.dirptrs);
165
166	if(!dptr) {
167	DEBUG(0,("No dptrs available to idle ?\n"));
168	return;
169	}
170
171	/*
172	* Idle the oldest pointer.
173	*/
174
175	for(; dptr; dptr = DLIST_PREV(dptr)) {
176	if (dptr->dir_hnd) {
177	dptr_idle(dptr);
178	return;
179	}
180	}
181	}
182
183	/****************************************************************************
184	Get the struct dptr_struct for a dir index.
185	****************************************************************************/
186
187	static struct dptr_struct dptr_get(struct smbd_server_connection sconn,
188	int key, bool forclose)
189	{
190	struct dptr_struct *dptr;
191
192	for(dptr = sconn->searches.dirptrs; dptr; dptr = dptr->next) {
193	if(dptr->dnum == key) {
194	if (!forclose && !dptr->dir_hnd) {
195	if (sconn->searches.dirhandles_open >= MAX_OPEN_DIRECTORIES)
196	dptr_idleoldest(sconn);
197	DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
198	if (!(dptr->dir_hnd = OpenDir(
199	NULL, dptr->conn, dptr->path,
200	dptr->wcard, dptr->attr))) {
201	DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
202	strerror(errno)));
203	return False;
204	}
205	}
206	DLIST_PROMOTE(sconn->searches.dirptrs,dptr);
207	return dptr;
208	}
209	}
210	return(NULL);
211	}
212
213	/****************************************************************************
214	Get the dir path for a dir index.
215	****************************************************************************/
216
217	char dptr_path(struct smbd_server_connection sconn, int key)
218	{
219	struct dptr_struct *dptr = dptr_get(sconn, key, false);
220	if (dptr)
221	return(dptr->path);
222	return(NULL);
223	}
224
225	/****************************************************************************
226	Get the dir wcard for a dir index.
227	****************************************************************************/
228
229	char dptr_wcard(struct smbd_server_connection sconn, int key)
230	{
231	struct dptr_struct *dptr = dptr_get(sconn, key, false);
232	if (dptr)
233	return(dptr->wcard);
234	return(NULL);
235	}
236
237	/****************************************************************************
238	Get the dir attrib for a dir index.
239	****************************************************************************/
240
241	uint16 dptr_attr(struct smbd_server_connection *sconn, int key)
242	{
243	struct dptr_struct *dptr = dptr_get(sconn, key, false);
244	if (dptr)
245	return(dptr->attr);
246	return(0);
247	}
248
249	/****************************************************************************
250	Close a dptr (internal func).
251	****************************************************************************/
252
253	static void dptr_close_internal(struct dptr_struct *dptr)
254	{
255	struct smbd_server_connection *sconn = dptr->conn->sconn;
256
257	DEBUG(4,("closing dptr key %d\n",dptr->dnum));
258
259	if (sconn == NULL) {
260	goto done;
261	}
262
263	DLIST_REMOVE(sconn->searches.dirptrs, dptr);
264
265	/*
266	* Free the dnum in the bitmap. Remember the dnum value is always
267	* biased by one with respect to the bitmap.
268	*/
269
270	if (!bitmap_query(sconn->searches.dptr_bmap, dptr->dnum - 1)) {
271	DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
272	dptr->dnum ));
273	}
274
275	bitmap_clear(sconn->searches.dptr_bmap, dptr->dnum - 1);
276
277	done:
278	TALLOC_FREE(dptr->dir_hnd);
279
280	/* Lanman 2 specific code */
281	SAFE_FREE(dptr->wcard);
282	string_set(&dptr->path,"");
283	SAFE_FREE(dptr);
284	}
285
286	/****************************************************************************
287	Close a dptr given a key.
288	****************************************************************************/
289
290	void dptr_close(struct smbd_server_connection sconn, int key)
291	{
292	struct dptr_struct *dptr;
293
294	if(*key == INVALID_DPTR_KEY)
295	return;
296
297	/* OS/2 seems to use -1 to indicate "close all directories" */
298	if (*key == -1) {
299	struct dptr_struct *next;
300	for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
301	next = dptr->next;
302	dptr_close_internal(dptr);
303	}
304	*key = INVALID_DPTR_KEY;
305	return;
306	}
307
308	dptr = dptr_get(sconn, *key, true);
309
310	if (!dptr) {
311	DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
312	return;
313	}
314
315	dptr_close_internal(dptr);
316
317	*key = INVALID_DPTR_KEY;
318	}
319
320	/****************************************************************************
321	Close all dptrs for a cnum.
322	****************************************************************************/
323
324	void dptr_closecnum(connection_struct *conn)
325	{
326	struct dptr_struct dptr, next;
327	struct smbd_server_connection *sconn = conn->sconn;
328
329	if (sconn == NULL) {
330	return;
331	}
332
333	for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
334	next = dptr->next;
335	if (dptr->conn == conn) {
336	dptr_close_internal(dptr);
337	}
338	}
339	}
340
341	/****************************************************************************
342	Idle all dptrs for a cnum.
343	****************************************************************************/
344
345	void dptr_idlecnum(connection_struct *conn)
346	{
347	struct dptr_struct *dptr;
348	struct smbd_server_connection *sconn = conn->sconn;
349
350	if (sconn == NULL) {
351	return;
352	}
353
354	for(dptr = sconn->searches.dirptrs; dptr; dptr = dptr->next) {
355	if (dptr->conn == conn && dptr->dir_hnd) {
356	dptr_idle(dptr);
357	}
358	}
359	}
360
361	/****************************************************************************
362	Close a dptr that matches a given path, only if it matches the spid also.
363	****************************************************************************/
364
365	void dptr_closepath(struct smbd_server_connection *sconn,
366	char *path,uint16 spid)
367	{
368	struct dptr_struct dptr, next;
369	for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
370	next = dptr->next;
371	if (spid == dptr->spid && strequal(dptr->path,path))
372	dptr_close_internal(dptr);
373	}
374	}
375
376	/****************************************************************************
377	Try and close the oldest handle not marked for
378	expect close in the hope that the client has
379	finished with that one.
380	****************************************************************************/
381
382	static void dptr_close_oldest(struct smbd_server_connection *sconn,
383	bool old)
384	{
385	struct dptr_struct *dptr;
386
387	/*
388	* Go to the end of the list.
389	*/
390	for(dptr = sconn->searches.dirptrs; dptr && dptr->next; dptr = dptr->next)
391	;
392
393	if(!dptr) {
394	DEBUG(0,("No old dptrs available to close oldest ?\n"));
395	return;
396	}
397
398	/*
399	* If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
400	* does not have expect_close set. If 'old' is false, close
401	* one of the new dnum handles.
402	*/
403
404	for(; dptr; dptr = DLIST_PREV(dptr)) {
405	if ((old && (dptr->dnum < 256) && !dptr->expect_close) \|\|
406	(!old && (dptr->dnum > 255))) {
407	dptr_close_internal(dptr);
408	return;
409	}
410	}
411	}
412
413	/****************************************************************************
414	Create a new dir ptr. If the flag old_handle is true then we must allocate
415	from the bitmap range 0 - 255 as old SMBsearch directory handles are only
416	one byte long. If old_handle is false we allocate from the range
417	256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
418	a directory handle is never zero.
419	wcard must not be zero.
420	****************************************************************************/
421
422	NTSTATUS dptr_create(connection_struct conn, files_struct fsp,
423	const char *path, bool old_handle, bool expect_close,uint16 spid,
424	const char wcard, bool wcard_has_wild, uint32 attr, struct dptr_struct *dptr_ret)
425	{
426	struct smbd_server_connection *sconn = conn->sconn;
427	struct dptr_struct *dptr = NULL;
428	struct smb_Dir *dir_hnd;
429	NTSTATUS status;
430
431	if (fsp && fsp->is_directory && fsp->fh->fd != -1) {
432	path = fsp->fsp_name->base_name;
433	}
434
435	DEBUG(5,("dptr_create dir=%s\n", path));
436
437	if (sconn == NULL) {
438	DEBUG(0,("dptr_create: called with fake connection_struct\n"));
439	return NT_STATUS_INTERNAL_ERROR;
440	}
441
442	if (!wcard) {
443	return NT_STATUS_INVALID_PARAMETER;
444	}
445
446	if (fsp) {
447	dir_hnd = OpenDir_fsp(NULL, conn, fsp, wcard, attr);
448	} else {
449	status = check_name(conn,path);
450	if (!NT_STATUS_IS_OK(status)) {
451	return status;
452	}
453	dir_hnd = OpenDir(NULL, conn, path, wcard, attr);
454	}
455
456	if (!dir_hnd) {
457	return map_nt_error_from_unix(errno);
458	}
459
460	if (sconn->searches.dirhandles_open >= MAX_OPEN_DIRECTORIES) {
461	dptr_idleoldest(sconn);
462	}
463
464	dptr = SMB_MALLOC_P(struct dptr_struct);
465	if(!dptr) {
466	DEBUG(0,("malloc fail in dptr_create.\n"));
467	TALLOC_FREE(dir_hnd);
468	return NT_STATUS_NO_MEMORY;
469	}
470
471	ZERO_STRUCTP(dptr);
472
473	if(old_handle) {
474
475	/*
476	* This is an old-style SMBsearch request. Ensure the
477	* value we return will fit in the range 1-255.
478	*/
479
480	dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 0);
481
482	if(dptr->dnum == -1 \|\| dptr->dnum > 254) {
483
484	/*
485	* Try and close the oldest handle not marked for
486	* expect close in the hope that the client has
487	* finished with that one.
488	*/
489
490	dptr_close_oldest(sconn, true);
491
492	/* Now try again... */
493	dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 0);
494	if(dptr->dnum == -1 \|\| dptr->dnum > 254) {
495	DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
496	SAFE_FREE(dptr);
497	TALLOC_FREE(dir_hnd);
498	return NT_STATUS_TOO_MANY_OPENED_FILES;
499	}
500	}
501	} else {
502
503	/*
504	* This is a new-style trans2 request. Allocate from
505	* a range that will return 256 - MAX_DIRECTORY_HANDLES.
506	*/
507
508	dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 255);
509
510	if(dptr->dnum == -1 \|\| dptr->dnum < 255) {
511
512	/*
513	* Try and close the oldest handle close in the hope that
514	* the client has finished with that one. This will only
515	* happen in the case of the Win98 client bug where it leaks
516	* directory handles.
517	*/
518
519	dptr_close_oldest(sconn, false);
520
521	/* Now try again... */
522	dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 255);
523
524	if(dptr->dnum == -1 \|\| dptr->dnum < 255) {
525	DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
526	SAFE_FREE(dptr);
527	TALLOC_FREE(dir_hnd);
528	return NT_STATUS_TOO_MANY_OPENED_FILES;
529	}
530	}
531	}
532
533	bitmap_set(sconn->searches.dptr_bmap, dptr->dnum);
534
535	dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
536
537	string_set(&dptr->path,path);
538	dptr->conn = conn;
539	dptr->dir_hnd = dir_hnd;
540	dptr->spid = spid;
541	dptr->expect_close = expect_close;
542	dptr->wcard = SMB_STRDUP(wcard);
543	if (!dptr->wcard) {
544	bitmap_clear(sconn->searches.dptr_bmap, dptr->dnum - 1);
545	SAFE_FREE(dptr);
546	TALLOC_FREE(dir_hnd);
547	return NT_STATUS_NO_MEMORY;
548	}
549	if (lp_posix_pathnames() \|\| (wcard[0] == '.' && wcard[1] == 0)) {
550	dptr->has_wild = True;
551	} else {
552	dptr->has_wild = wcard_has_wild;
553	}
554
555	dptr->attr = attr;
556
557	DLIST_ADD(sconn->searches.dirptrs, dptr);
558
559	DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
560	dptr->dnum,path,expect_close));
561
562	*dptr_ret = dptr;
563
564	return NT_STATUS_OK;
565	}
566
567
568	/****************************************************************************
569	Wrapper functions to access the lower level directory handles.
570	****************************************************************************/
571
572	void dptr_CloseDir(files_struct *fsp)
573	{
574	if (fsp->dptr) {
575	/*
576	* Ugly hack. We have defined fdopendir to return ENOSYS if dirfd also isn't
577	* present. I hate Solaris. JRA.
578	*/
579	#ifdef HAVE_DIRFD
580	if (fsp->fh->fd != -1 &&
581	fsp->dptr->dir_hnd &&
582	dirfd(fsp->dptr->dir_hnd->dir)) {
583	/* The call below closes the underlying fd. */
584	fsp->fh->fd = -1;
585	}
586	#endif
587	dptr_close_internal(fsp->dptr);
588	fsp->dptr = NULL;
589	}
590	}
591
592	void dptr_SeekDir(struct dptr_struct *dptr, long offset)
593	{
594	SeekDir(dptr->dir_hnd, offset);
595	}
596
597	long dptr_TellDir(struct dptr_struct *dptr)
598	{
599	return TellDir(dptr->dir_hnd);
600	}
601
602	bool dptr_has_wild(struct dptr_struct *dptr)
603	{
604	return dptr->has_wild;
605	}
606
607	int dptr_dnum(struct dptr_struct *dptr)
608	{
609	return dptr->dnum;
610	}
611
612	/****************************************************************************
613	Return the next visible file name, skipping veto'd and invisible files.
614	****************************************************************************/
615
616	static const char dptr_normal_ReadDirName(struct dptr_struct dptr,
617	long poffset, SMB_STRUCT_STAT pst,
618	char **ptalloced)
619	{
620	/* Normal search for the next file. */
621	const char *name;
622	char *talloced = NULL;
623
624	while ((name = ReadDirName(dptr->dir_hnd, poffset, pst, &talloced))
625	!= NULL) {
626	if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
627	*ptalloced = talloced;
628	return name;
629	}
630	TALLOC_FREE(talloced);
631	}
632	return NULL;
633	}
634
635	/****************************************************************************
636	Return the next visible file name, skipping veto'd and invisible files.
637	****************************************************************************/
638
639	char dptr_ReadDirName(TALLOC_CTX ctx,
640	struct dptr_struct *dptr,
641	long *poffset,
642	SMB_STRUCT_STAT *pst)
643	{
644	struct smb_filename smb_fname_base;
645	char *name = NULL;
646	const char *name_temp = NULL;
647	char *talloced = NULL;
648	char *pathreal = NULL;
649	char *found_name = NULL;
650	int ret;
651
652	SET_STAT_INVALID(*pst);
653
654	if (dptr->has_wild \|\| dptr->did_stat) {
655	name_temp = dptr_normal_ReadDirName(dptr, poffset, pst,
656	&talloced);
657	if (name_temp == NULL) {
658	return NULL;
659	}
660	if (talloced != NULL) {
661	return talloc_move(ctx, &talloced);
662	}
663	return talloc_strdup(ctx, name_temp);
664	}
665
666	/* If poffset is -1 then we know we returned this name before and we
667	* have no wildcards. We're at the end of the directory. */
668	if (*poffset == END_OF_DIRECTORY_OFFSET) {
669	return NULL;
670	}
671
672	/* We know the stored wcard contains no wildcard characters.
673	* See if we can match with a stat call. If we can't, then set
674	* did_stat to true to ensure we only do this once and keep
675	* searching. */
676
677	dptr->did_stat = true;
678
679	/* First check if it should be visible. */
680	if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard,
681	pst, true))
682	{
683	/* This only returns false if the file was found, but
684	is explicitly not visible. Set us to end of
685	directory, but return NULL as we know we can't ever
686	find it. */
687	goto ret;
688	}
689
690	if (VALID_STAT(*pst)) {
691	name = talloc_strdup(ctx, dptr->wcard);
692	goto ret;
693	}
694
695	pathreal = talloc_asprintf(ctx,
696	"%s/%s",
697	dptr->path,
698	dptr->wcard);
699	if (!pathreal)
700	return NULL;
701
702	/* Create an smb_filename with stream_name == NULL. */
703	ZERO_STRUCT(smb_fname_base);
704	smb_fname_base.base_name = pathreal;
705
706	if (SMB_VFS_STAT(dptr->conn, &smb_fname_base) == 0) {
707	*pst = smb_fname_base.st;
708	name = talloc_strdup(ctx, dptr->wcard);
709	goto clean;
710	} else {
711	/* If we get any other error than ENOENT or ENOTDIR
712	then the file exists we just can't stat it. */
713	if (errno != ENOENT && errno != ENOTDIR) {
714	name = talloc_strdup(ctx, dptr->wcard);
715	goto clean;
716	}
717	}
718
719	/* Stat failed. We know this is authoratiative if we are
720	* providing case sensitive semantics or the underlying
721	* filesystem is case sensitive.
722	*/
723	if (dptr->conn->case_sensitive \|\|
724	!(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH))
725	{
726	goto clean;
727	}
728
729	/*
730	* Try case-insensitive stat if the fs has the ability. This avoids
731	* scanning the whole directory.
732	*/
733	ret = SMB_VFS_GET_REAL_FILENAME(dptr->conn, dptr->path, dptr->wcard,
734	ctx, &found_name);
735	if (ret == 0) {
736	name = found_name;
737	goto clean;
738	} else if (errno == ENOENT) {
739	/* The case-insensitive lookup was authoritative. */
740	goto clean;
741	}
742
743	TALLOC_FREE(pathreal);
744
745	name_temp = dptr_normal_ReadDirName(dptr, poffset, pst, &talloced);
746	if (name_temp == NULL) {
747	return NULL;
748	}
749	if (talloced != NULL) {
750	return talloc_move(ctx, &talloced);
751	}
752	return talloc_strdup(ctx, name_temp);
753
754	clean:
755	TALLOC_FREE(pathreal);
756	ret:
757	/* We need to set the underlying dir_hnd offset to -1
758	* also as this function is usually called with the
759	* output from TellDir. */
760	dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
761	return name;
762	}
763
764	/****************************************************************************
765	Search for a file by name, skipping veto'ed and not visible files.
766	****************************************************************************/
767
768	bool dptr_SearchDir(struct dptr_struct dptr, const char name, long poffset, SMB_STRUCT_STAT pst)
769	{
770	SET_STAT_INVALID(*pst);
771
772	if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
773	/* This is a singleton directory and we're already at the end. */
774	*poffset = END_OF_DIRECTORY_OFFSET;
775	return False;
776	}
777
778	return SearchDir(dptr->dir_hnd, name, poffset);
779	}
780
781	/****************************************************************************
782	Add the name we're returning into the underlying cache.
783	****************************************************************************/
784
785	void dptr_DirCacheAdd(struct dptr_struct dptr, const char name, long offset)
786	{
787	DirCacheAdd(dptr->dir_hnd, name, offset);
788	}
789
790	/****************************************************************************
791	Initialize variables & state data at the beginning of all search SMB requests.
792	****************************************************************************/
793	void dptr_init_search_op(struct dptr_struct *dptr)
794	{
795	SMB_VFS_INIT_SEARCH_OP(dptr->conn, dptr->dir_hnd->dir);
796	}
797
798	/****************************************************************************
799	Fill the 5 byte server reserved dptr field.
800	****************************************************************************/
801
802	bool dptr_fill(struct smbd_server_connection *sconn,
803	char *buf1,unsigned int key)
804	{
805	unsigned char buf = (unsigned char )buf1;
806	struct dptr_struct *dptr = dptr_get(sconn, key, false);
807	uint32 offset;
808	if (!dptr) {
809	DEBUG(1,("filling null dirptr %d\n",key));
810	return(False);
811	}
812	offset = (uint32)TellDir(dptr->dir_hnd);
813	DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
814	(long)dptr->dir_hnd,(int)offset));
815	buf[0] = key;
816	SIVAL(buf,1,offset);
817	return(True);
818	}
819
820	/****************************************************************************
821	Fetch the dir ptr and seek it given the 5 byte server field.
822	****************************************************************************/
823
824	struct dptr_struct dptr_fetch(struct smbd_server_connection sconn,
825	char buf, int num)
826	{
827	unsigned int key = (unsigned char )buf;
828	struct dptr_struct *dptr = dptr_get(sconn, key, false);
829	uint32 offset;
830	long seekoff;
831
832	if (!dptr) {
833	DEBUG(3,("fetched null dirptr %d\n",key));
834	return(NULL);
835	}
836	*num = key;
837	offset = IVAL(buf,1);
838	if (offset == (uint32)-1) {
839	seekoff = END_OF_DIRECTORY_OFFSET;
840	} else {
841	seekoff = (long)offset;
842	}
843	SeekDir(dptr->dir_hnd,seekoff);
844	DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
845	key, dptr->path, (int)seekoff));
846	return(dptr);
847	}
848
849	/****************************************************************************
850	Fetch the dir ptr.
851	****************************************************************************/
852
853	struct dptr_struct dptr_fetch_lanman2(struct smbd_server_connection sconn,
854	int dptr_num)
855	{
856	struct dptr_struct *dptr = dptr_get(sconn, dptr_num, false);
857
858	if (!dptr) {
859	DEBUG(3,("fetched null dirptr %d\n",dptr_num));
860	return(NULL);
861	}
862	DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr->path));
863	return(dptr);
864	}
865
866	/****************************************************************************
867	Check that a file matches a particular file type.
868	****************************************************************************/
869
870	bool dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
871	{
872	uint32 mask;
873
874	/* Check the "may have" search bits. */
875	if (((mode & ~dirtype) & (FILE_ATTRIBUTE_HIDDEN \| FILE_ATTRIBUTE_SYSTEM \| FILE_ATTRIBUTE_DIRECTORY)) != 0)
876	return False;
877
878	/* Check the "must have" bits, which are the may have bits shifted eight */
879	/* If must have bit is set, the file/dir can not be returned in search unless the matching
880	file attribute is set */
881	mask = ((dirtype >> 8) & (FILE_ATTRIBUTE_DIRECTORY\|FILE_ATTRIBUTE_ARCHIVE\|FILE_ATTRIBUTE_READONLY\|FILE_ATTRIBUTE_HIDDEN\|FILE_ATTRIBUTE_SYSTEM)); /* & 0x37 */
882	if(mask) {
883	if((mask & (mode & (FILE_ATTRIBUTE_DIRECTORY\|FILE_ATTRIBUTE_ARCHIVE\|FILE_ATTRIBUTE_READONLY\|FILE_ATTRIBUTE_HIDDEN\|FILE_ATTRIBUTE_SYSTEM))) == mask) /* check if matching attribute present */
884	return True;
885	else
886	return False;
887	}
888
889	return True;
890	}
891
892	static bool mangle_mask_match(connection_struct *conn,
893	const char *filename,
894	const char *mask)
895	{
896	char mname[13];
897
898	if (!name_to_8_3(filename,mname,False,conn->params)) {
899	return False;
900	}
901	return mask_match_search(mname,mask,False);
902	}
903
904	bool smbd_dirptr_get_entry(TALLOC_CTX *ctx,
905	struct dptr_struct *dirptr,
906	const char *mask,
907	uint32_t dirtype,
908	bool dont_descend,
909	bool ask_sharemode,
910	bool (match_fn)(TALLOC_CTX ctx,
911	void *private_data,
912	const char *dname,
913	const char *mask,
914	char **_fname),
915	bool (mode_fn)(TALLOC_CTX ctx,
916	void *private_data,
917	struct smb_filename *smb_fname,
918	uint32_t *_mode),
919	void *private_data,
920	char **_fname,
921	struct smb_filename **_smb_fname,
922	uint32_t *_mode,
923	long *_prev_offset)
924	{
925	connection_struct *conn = dirptr->conn;
926	bool needslash;
927
928	*_smb_fname = NULL;
929	*_mode = 0;
930
931	needslash = ( dirptr->path[strlen(dirptr->path) -1] != '/');
932
933	while (true) {
934	long cur_offset;
935	long prev_offset;
936	SMB_STRUCT_STAT sbuf;
937	char *dname = NULL;
938	bool isdots;
939	char *fname = NULL;
940	char *pathreal = NULL;
941	struct smb_filename smb_fname;
942	uint32_t mode = 0;
943	bool ok;
944	NTSTATUS status;
945
946	cur_offset = dptr_TellDir(dirptr);
947	prev_offset = cur_offset;
948	dname = dptr_ReadDirName(ctx, dirptr, &cur_offset, &sbuf);
949
950	DEBUG(6,("smbd_dirptr_get_entry: dirptr 0x%lx now at offset %ld\n",
951	(long)dirptr, cur_offset));
952
953	if (dname == NULL) {
954	return false;
955	}
956
957	isdots = (ISDOT(dname) \|\| ISDOTDOT(dname));
958	if (dont_descend && !isdots) {
959	TALLOC_FREE(dname);
960	continue;
961	}
962
963	/*
964	* fname may get mangled, dname is never mangled.
965	* Whenever we're accessing the filesystem we use
966	* pathreal which is composed from dname.
967	*/
968
969	ok = match_fn(ctx, private_data, dname, mask, &fname);
970	if (!ok) {
971	TALLOC_FREE(dname);
972	continue;
973	}
974
975	pathreal = talloc_asprintf(ctx, "%s%s%s",
976	dirptr->path,
977	needslash?"/":"",
978	dname);
979	if (!pathreal) {
980	TALLOC_FREE(dname);
981	TALLOC_FREE(fname);
982	return false;
983	}
984
985	/* Create smb_fname with NULL stream_name. */
986	ZERO_STRUCT(smb_fname);
987	smb_fname.base_name = pathreal;
988	smb_fname.st = sbuf;
989
990	ok = mode_fn(ctx, private_data, &smb_fname, &mode);
991	if (!ok) {
992	TALLOC_FREE(dname);
993	TALLOC_FREE(fname);
994	TALLOC_FREE(pathreal);
995	continue;
996	}
997
998	if (!dir_check_ftype(conn, mode, dirtype)) {
999	DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",
1000	fname, (unsigned int)mode, (unsigned int)dirtype));
1001	TALLOC_FREE(dname);
1002	TALLOC_FREE(fname);
1003	TALLOC_FREE(pathreal);
1004	continue;
1005	}
1006
1007	if (ask_sharemode) {
1008	struct timespec write_time_ts;
1009	struct file_id fileid;
1010
1011	fileid = vfs_file_id_from_sbuf(conn,
1012	&smb_fname.st);
1013	get_file_infos(fileid, 0, NULL, &write_time_ts);
1014	if (!null_timespec(write_time_ts)) {
1015	update_stat_ex_mtime(&smb_fname.st,
1016	write_time_ts);
1017	}
1018	}
1019
1020	DEBUG(3,("smbd_dirptr_get_entry mask=[%s] found %s "
1021	"fname=%s (%s)\n",
1022	mask, smb_fname_str_dbg(&smb_fname),
1023	dname, fname));
1024
1025	DirCacheAdd(dirptr->dir_hnd, dname, cur_offset);
1026
1027	TALLOC_FREE(dname);
1028
1029	status = copy_smb_filename(ctx, &smb_fname, _smb_fname);
1030	TALLOC_FREE(pathreal);
1031	if (!NT_STATUS_IS_OK(status)) {
1032	return false;
1033	}
1034	*_fname = fname;
1035	*_mode = mode;
1036	*_prev_offset = prev_offset;
1037
1038	return true;
1039	}
1040
1041	return false;
1042	}
1043
1044	/****************************************************************************
1045	Get an 8.3 directory entry.
1046	****************************************************************************/
1047
1048	static bool smbd_dirptr_8_3_match_fn(TALLOC_CTX *ctx,
1049	void *private_data,
1050	const char *dname,
1051	const char *mask,
1052	char **_fname)
1053	{
1054	connection_struct conn = (connection_struct )private_data;
1055
1056	if ((strcmp(mask,".") == 0) \|\|
1057	mask_match_search(dname, mask, false) \|\|
1058	mangle_mask_match(conn, dname, mask)) {
1059	char mname[13];
1060	const char *fname;
1061
1062	if (!mangle_is_8_3(dname, false, conn->params)) {
1063	bool ok = name_to_8_3(dname, mname, false,
1064	conn->params);
1065	if (!ok) {
1066	return false;
1067	}
1068	fname = mname;
1069	} else {
1070	fname = dname;
1071	}
1072
1073	*_fname = talloc_strdup(ctx, fname);
1074	if (*_fname == NULL) {
1075	return false;
1076	}
1077
1078	return true;
1079	}
1080
1081	return false;
1082	}
1083
1084	static bool smbd_dirptr_8_3_mode_fn(TALLOC_CTX *ctx,
1085	void *private_data,
1086	struct smb_filename *smb_fname,
1087	uint32_t *_mode)
1088	{
1089	connection_struct conn = (connection_struct )private_data;
1090
1091	if (!VALID_STAT(smb_fname->st)) {
1092	if ((SMB_VFS_STAT(conn, smb_fname)) != 0) {
1093	DEBUG(5,("smbd_dirptr_8_3_mode_fn: "
1094	"Couldn't stat [%s]. Error "
1095	"= %s\n",
1096	smb_fname_str_dbg(smb_fname),
1097	strerror(errno)));
1098	return false;
1099	}
1100	}
1101
1102	*_mode = dos_mode(conn, smb_fname);
1103	return true;
1104	}
1105
1106	bool get_dir_entry(TALLOC_CTX *ctx,
1107	struct dptr_struct *dirptr,
1108	const char *mask,
1109	uint32_t dirtype,
1110	char **_fname,
1111	SMB_OFF_T *_size,
1112	uint32_t *_mode,
1113	struct timespec *_date,
1114	bool check_descend,
1115	bool ask_sharemode)
1116	{
1117	connection_struct *conn = dirptr->conn;
1118	char *fname = NULL;
1119	struct smb_filename *smb_fname = NULL;
1120	uint32_t mode = 0;
1121	long prev_offset;
1122	bool ok;
1123
1124	ok = smbd_dirptr_get_entry(ctx,
1125	dirptr,
1126	mask,
1127	dirtype,
1128	check_descend,
1129	ask_sharemode,
1130	smbd_dirptr_8_3_match_fn,
1131	smbd_dirptr_8_3_mode_fn,
1132	conn,
1133	&fname,
1134	&smb_fname,
1135	&mode,
1136	&prev_offset);
1137	if (!ok) {
1138	return false;
1139	}
1140
1141	*_fname = talloc_move(ctx, &fname);
1142	*_size = smb_fname->st.st_ex_size;
1143	*_mode = mode;
1144	*_date = smb_fname->st.st_ex_mtime;
1145	TALLOC_FREE(smb_fname);
1146	return true;
1147	}
1148
1149	/*******************************************************************
1150	Check to see if a user can read a file. This is only approximate,
1151	it is used as part of the "hide unreadable" option. Don't
1152	use it for anything security sensitive.
1153	********************************************************************/
1154
1155	static bool user_can_read_file(connection_struct *conn,
1156	struct smb_filename *smb_fname)
1157	{
1158	/*
1159	* Never hide files from the root user.
1160	* We use (uid_t)0 here not sec_initial_uid()
1161	* as make test uses a single user context.
1162	*/
1163
1164	if (get_current_uid(conn) == (uid_t)0) {
1165	return True;
1166	}
1167
1168	return can_access_file_acl(conn, smb_fname, FILE_READ_DATA);
1169	}
1170
1171	/*******************************************************************
1172	Check to see if a user can write a file (and only files, we do not
1173	check dirs on this one). This is only approximate,
1174	it is used as part of the "hide unwriteable" option. Don't
1175	use it for anything security sensitive.
1176	********************************************************************/
1177
1178	static bool user_can_write_file(connection_struct *conn,
1179	const struct smb_filename *smb_fname)
1180	{
1181	/*
1182	* Never hide files from the root user.
1183	* We use (uid_t)0 here not sec_initial_uid()
1184	* as make test uses a single user context.
1185	*/
1186
1187	if (get_current_uid(conn) == (uid_t)0) {
1188	return True;
1189	}
1190
1191	SMB_ASSERT(VALID_STAT(smb_fname->st));
1192
1193	/* Pseudo-open the file */
1194
1195	if(S_ISDIR(smb_fname->st.st_ex_mode)) {
1196	return True;
1197	}
1198
1199	return can_write_to_file(conn, smb_fname);
1200	}
1201
1202	/*******************************************************************
1203	Is a file a "special" type ?
1204	********************************************************************/
1205
1206	static bool file_is_special(connection_struct *conn,
1207	const struct smb_filename *smb_fname)
1208	{
1209	/*
1210	* Never hide files from the root user.
1211	* We use (uid_t)0 here not sec_initial_uid()
1212	* as make test uses a single user context.
1213	*/
1214
1215	if (get_current_uid(conn) == (uid_t)0) {
1216	return False;
1217	}
1218
1219	SMB_ASSERT(VALID_STAT(smb_fname->st));
1220
1221	if (S_ISREG(smb_fname->st.st_ex_mode) \|\|
1222	S_ISDIR(smb_fname->st.st_ex_mode) \|\|
1223	S_ISLNK(smb_fname->st.st_ex_mode))
1224	return False;
1225
1226	return True;
1227	}
1228
1229	/*******************************************************************
1230	Should the file be seen by the client?
1231	NOTE: A successful return is no guarantee of the file's existence.
1232	********************************************************************/
1233
1234	bool is_visible_file(connection_struct conn, const char dir_path,
1235	const char name, SMB_STRUCT_STAT pst, bool use_veto)
1236	{
1237	bool hide_unreadable = lp_hideunreadable(SNUM(conn));
1238	bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1239	bool hide_special = lp_hide_special_files(SNUM(conn));
1240	char *entry = NULL;
1241	struct smb_filename *smb_fname_base = NULL;
1242	NTSTATUS status;
1243	bool ret = false;
1244
1245	if ((strcmp(".",name) == 0) \|\| (strcmp("..",name) == 0)) {
1246	return True; /* . and .. are always visible. */
1247	}
1248
1249	/* If it's a vetoed file, pretend it doesn't even exist */
1250	if (use_veto && IS_VETO_PATH(conn, name)) {
1251	DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1252	return False;
1253	}
1254
1255	if (hide_unreadable \|\| hide_unwriteable \|\| hide_special) {
1256	entry = talloc_asprintf(talloc_tos(), "%s/%s", dir_path, name);
1257	if (!entry) {
1258	ret = false;
1259	goto out;
1260	}
1261
1262	/* Create an smb_filename with stream_name == NULL. */
1263	status = create_synthetic_smb_fname(talloc_tos(), entry, NULL,
1264	pst, &smb_fname_base);
1265	if (!NT_STATUS_IS_OK(status)) {
1266	ret = false;
1267	goto out;
1268	}
1269
1270	/* If the file name does not exist, there's no point checking
1271	* the configuration options. We succeed, on the basis that the
1272	* checks might have passed if the file was present.
1273	*/
1274	if (!VALID_STAT(*pst)) {
1275	if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
1276	ret = true;
1277	goto out;
1278	} else {
1279	*pst = smb_fname_base->st;
1280	}
1281	}
1282
1283	/* Honour _hide unreadable_ option */
1284	if (hide_unreadable &&
1285	!user_can_read_file(conn, smb_fname_base)) {
1286	DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1287	entry ));
1288	ret = false;
1289	goto out;
1290	}
1291	/* Honour _hide unwriteable_ option */
1292	if (hide_unwriteable && !user_can_write_file(conn,
1293	smb_fname_base)) {
1294	DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1295	entry ));
1296	ret = false;
1297	goto out;
1298	}
1299	/* Honour _hide_special_ option */
1300	if (hide_special && file_is_special(conn, smb_fname_base)) {
1301	DEBUG(10,("is_visible_file: file %s is special.\n",
1302	entry ));
1303	ret = false;
1304	goto out;
1305	}
1306	}
1307
1308	ret = true;
1309	out:
1310	TALLOC_FREE(smb_fname_base);
1311	TALLOC_FREE(entry);
1312	return ret;
1313	}
1314
1315	static int smb_Dir_destructor(struct smb_Dir *dirp)
1316	{
1317	if (dirp->dir) {
1318	#ifdef HAVE_DIRFD
1319	if (dirp->conn->sconn) {
1320	files_struct *fsp = file_find_fd(dirp->conn->sconn,
1321	dirfd(dirp->dir));
1322	if (fsp) {
1323	/* The call below closes the underlying fd. */
1324	fsp->fh->fd = -1;
1325	}
1326	}
1327	#endif
1328	SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1329	}
1330	if (dirp->conn->sconn) {
1331	dirp->conn->sconn->searches.dirhandles_open--;
1332	}
1333	return 0;
1334	}
1335
1336	/*******************************************************************
1337	Open a directory.
1338	********************************************************************/
1339
1340	struct smb_Dir OpenDir(TALLOC_CTX mem_ctx, connection_struct *conn,
1341	const char *name,
1342	const char *mask,
1343	uint32 attr)
1344	{
1345	struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
1346	struct smbd_server_connection *sconn = conn->sconn;
1347
1348	if (!dirp) {
1349	return NULL;
1350	}
1351
1352	dirp->conn = conn;
1353	dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1354
1355	dirp->dir_path = talloc_strdup(dirp, name);
1356	if (!dirp->dir_path) {
1357	errno = ENOMEM;
1358	goto fail;
1359	}
1360
1361	if (sconn) {
1362	sconn->searches.dirhandles_open++;
1363	}
1364	talloc_set_destructor(dirp, smb_Dir_destructor);
1365
1366	dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1367	if (!dirp->dir) {
1368	DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1369	strerror(errno) ));
1370	goto fail;
1371	}
1372
1373	return dirp;
1374
1375	fail:
1376	TALLOC_FREE(dirp);
1377	return NULL;
1378	}
1379
1380	/*******************************************************************
1381	Open a directory from an fsp.
1382	********************************************************************/
1383
1384	static struct smb_Dir OpenDir_fsp(TALLOC_CTX mem_ctx, connection_struct *conn,
1385	files_struct *fsp,
1386	const char *mask,
1387	uint32 attr)
1388	{
1389	struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
1390	struct smbd_server_connection *sconn = conn->sconn;
1391
1392	if (!dirp) {
1393	return NULL;
1394	}
1395
1396	dirp->conn = conn;
1397	dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1398
1399	dirp->dir_path = talloc_strdup(dirp, fsp->fsp_name->base_name);
1400	if (!dirp->dir_path) {
1401	errno = ENOMEM;
1402	goto fail;
1403	}
1404
1405	if (sconn) {
1406	sconn->searches.dirhandles_open++;
1407	}
1408	talloc_set_destructor(dirp, smb_Dir_destructor);
1409
1410	if (fsp->is_directory && fsp->fh->fd != -1) {
1411	dirp->dir = SMB_VFS_FDOPENDIR(fsp, mask, attr);
1412	if (dirp->dir == NULL) {
1413	DEBUG(10,("OpenDir_fsp: SMB_VFS_FDOPENDIR on %s returned "
1414	"NULL (%s)\n",
1415	dirp->dir_path,
1416	strerror(errno)));
1417	if (errno != ENOSYS) {
1418	return NULL;
1419	}
1420	}
1421	}
1422
1423	if (dirp->dir == NULL) {
1424	/* FDOPENDIR didn't work. Use OPENDIR instead. */
1425	dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1426	}
1427
1428	if (!dirp->dir) {
1429	DEBUG(5,("OpenDir_fsp: Can't open %s. %s\n", dirp->dir_path,
1430	strerror(errno) ));
1431	goto fail;
1432	}
1433
1434	return dirp;
1435
1436	fail:
1437	TALLOC_FREE(dirp);
1438	return NULL;
1439	}
1440
1441
1442	/*******************************************************************
1443	Read from a directory.
1444	Return directory entry, current offset, and optional stat information.
1445	Don't check for veto or invisible files.
1446	********************************************************************/
1447
1448	const char ReadDirName(struct smb_Dir dirp, long *poffset,
1449	SMB_STRUCT_STAT sbuf, char *ptalloced)
1450	{
1451	const char *n;
1452	char *talloced = NULL;
1453	connection_struct *conn = dirp->conn;
1454
1455	/* Cheat to allow . and .. to be the first entries returned. */
1456	if (((*poffset == START_OF_DIRECTORY_OFFSET) \|\|
1457	(*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2))
1458	{
1459	if (dirp->file_number == 0) {
1460	n = ".";
1461	*poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1462	} else {
1463	n = "..";
1464	*poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1465	}
1466	dirp->file_number++;
1467	*ptalloced = NULL;
1468	return n;
1469	} else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1470	*poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1471	return NULL;
1472	} else {
1473	/* A real offset, seek to it. */
1474	SeekDir(dirp, *poffset);
1475	}
1476
1477	while ((n = vfs_readdirname(conn, dirp->dir, sbuf, &talloced))) {
1478	/* Ignore . and .. - we've already returned them. */
1479	if (*n == '.') {
1480	if ((n[1] == '\0') \|\| (n[1] == '.' && n[2] == '\0')) {
1481	TALLOC_FREE(talloced);
1482	continue;
1483	}
1484	}
1485	*poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1486	*ptalloced = talloced;
1487	dirp->file_number++;
1488	return n;
1489	}
1490	*poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1491	*ptalloced = NULL;
1492	return NULL;
1493	}
1494
1495	/*******************************************************************
1496	Rewind to the start.
1497	********************************************************************/
1498
1499	void RewindDir(struct smb_Dir dirp, long poffset)
1500	{
1501	SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1502	dirp->file_number = 0;
1503	dirp->offset = START_OF_DIRECTORY_OFFSET;
1504	*poffset = START_OF_DIRECTORY_OFFSET;
1505	}
1506
1507	/*******************************************************************
1508	Seek a dir.
1509	********************************************************************/
1510
1511	void SeekDir(struct smb_Dir *dirp, long offset)
1512	{
1513	if (offset != dirp->offset) {
1514	if (offset == START_OF_DIRECTORY_OFFSET) {
1515	RewindDir(dirp, &offset);
1516	/*
1517	* Ok we should really set the file number here
1518	* to 1 to enable ".." to be returned next. Trouble
1519	* is I'm worried about callers using SeekDir(dirp,0)
1520	* as equivalent to RewindDir(). So leave this alone
1521	* for now.
1522	*/
1523	} else if (offset == DOT_DOT_DIRECTORY_OFFSET) {
1524	RewindDir(dirp, &offset);
1525	/*
1526	* Set the file number to 2 - we want to get the first
1527	* real file entry (the one we return after "..")
1528	* on the next ReadDir.
1529	*/
1530	dirp->file_number = 2;
1531	} else if (offset == END_OF_DIRECTORY_OFFSET) {
1532	; /* Don't seek in this case. */
1533	} else {
1534	SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1535	}
1536	dirp->offset = offset;
1537	}
1538	}
1539
1540	/*******************************************************************
1541	Tell a dir position.
1542	********************************************************************/
1543
1544	long TellDir(struct smb_Dir *dirp)
1545	{
1546	return(dirp->offset);
1547	}
1548
1549	/*******************************************************************
1550	Add an entry into the dcache.
1551	********************************************************************/
1552
1553	void DirCacheAdd(struct smb_Dir dirp, const char name, long offset)
1554	{
1555	struct name_cache_entry *e;
1556
1557	if (dirp->name_cache_size == 0) {
1558	return;
1559	}
1560
1561	if (dirp->name_cache == NULL) {
1562	dirp->name_cache = TALLOC_ZERO_ARRAY(
1563	dirp, struct name_cache_entry, dirp->name_cache_size);
1564
1565	if (dirp->name_cache == NULL) {
1566	return;
1567	}
1568	}
1569
1570	dirp->name_cache_index = (dirp->name_cache_index+1) %
1571	dirp->name_cache_size;
1572	e = &dirp->name_cache[dirp->name_cache_index];
1573	TALLOC_FREE(e->name);
1574	e->name = talloc_strdup(dirp, name);
1575	e->offset = offset;
1576	}
1577
1578	/*******************************************************************
1579	Find an entry by name. Leave us at the offset after it.
1580	Don't check for veto or invisible files.
1581	********************************************************************/
1582
1583	bool SearchDir(struct smb_Dir dirp, const char name, long *poffset)
1584	{
1585	int i;
1586	const char *entry = NULL;
1587	char *talloced = NULL;
1588	connection_struct *conn = dirp->conn;
1589
1590	/* Search back in the name cache. */
1591	if (dirp->name_cache_size && dirp->name_cache) {
1592	for (i = dirp->name_cache_index; i >= 0; i--) {
1593	struct name_cache_entry *e = &dirp->name_cache[i];
1594	if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1595	*poffset = e->offset;
1596	SeekDir(dirp, e->offset);
1597	return True;
1598	}
1599	}
1600	for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1601	struct name_cache_entry *e = &dirp->name_cache[i];
1602	if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1603	*poffset = e->offset;
1604	SeekDir(dirp, e->offset);
1605	return True;
1606	}
1607	}
1608	}
1609
1610	/* Not found in the name cache. Rewind directory and start from scratch. */
1611	SMB_VFS_REWINDDIR(conn, dirp->dir);
1612	dirp->file_number = 0;
1613	*poffset = START_OF_DIRECTORY_OFFSET;
1614	while ((entry = ReadDirName(dirp, poffset, NULL, &talloced))) {
1615	if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1616	TALLOC_FREE(talloced);
1617	return True;
1618	}
1619	TALLOC_FREE(talloced);
1620	}
1621	return False;
1622	}
1623
1624	/*****************************************************************
1625	Is this directory empty ?
1626	*****************************************************************/
1627
1628	NTSTATUS can_delete_directory(struct connection_struct *conn,
1629	const char *dirname)
1630	{
1631	NTSTATUS status = NT_STATUS_OK;
1632	long dirpos = 0;
1633	const char *dname = NULL;
1634	char *talloced = NULL;
1635	SMB_STRUCT_STAT st;
1636	struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn,
1637	dirname, NULL, 0);
1638
1639	if (!dir_hnd) {
1640	return map_nt_error_from_unix(errno);
1641	}
1642
1643	while ((dname = ReadDirName(dir_hnd, &dirpos, &st, &talloced))) {
1644	/* Quick check for "." and ".." */
1645	if (dname[0] == '.') {
1646	if (!dname[1] \|\| (dname[1] == '.' && !dname[2])) {
1647	TALLOC_FREE(talloced);
1648	continue;
1649	}
1650	}
1651
1652	if (!is_visible_file(conn, dirname, dname, &st, True)) {
1653	TALLOC_FREE(talloced);
1654	continue;
1655	}
1656
1657	DEBUG(10,("can_delete_directory: got name %s - can't delete\n",
1658	dname ));
1659	status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1660	break;
1661	}
1662	TALLOC_FREE(talloced);
1663	TALLOC_FREE(dir_hnd);
1664
1665	return status;
1666	}

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

Download in other formats: