dir.cpp@ 239

Last change on this file since 239 was 1, checked in by vboxsync, 55 years ago
import
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 20.4 KB

Line
1	/* $Id: dir.cpp 1 1970-01-01 00:00:00Z vboxsync $ */
2	/** @file
3	* InnoTek Portable Runtime - Directory Manipulation.
4	*/
5
6	/*
7	* Copyright (C) 2006 InnoTek Systemberatung GmbH
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* If you received this file as part of a commercial VirtualBox
18	* distribution, then only the terms of your commercial VirtualBox
19	* license agreement apply instead of the previous paragraph.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#define LOG_GROUP RTLOGGROUP_DIR
27	#ifdef __WIN__
28	# include <Windows.h>
29	#else
30	# include <dirent.h>
31	#endif
32
33	#include <iprt/dir.h>
34	#include <iprt/path.h>
35	#include <iprt/alloc.h>
36	#include <iprt/log.h>
37	#include <iprt/param.h>
38	#include <iprt/string.h>
39	#include <iprt/err.h>
40	#include <iprt/assert.h>
41	#include <iprt/uni.h>
42	#include "internal/fs.h"
43	#include "internal/dir.h"
44
45
46	static DECLCALLBACK(bool) rtDirFilterWinNtMatch(PRTDIR pDir, const char *pszName);
47	static DECLCALLBACK(bool) rtDirFilterWinNtMatchNoWildcards(PRTDIR pDir, const char *pszName);
48	DECLINLINE(bool) rtDirFilterWinNtMatchEon(PCRTUNICP puszFilter);
49	static bool rtDirFilterWinNtMatchDosStar(unsigned iDepth, RTUNICP uc, const char *pszNext, PCRTUNICP puszFilter);
50	static bool rtDirFilterWinNtMatchStar(unsigned iDepth, RTUNICP uc, const char *pszNext, PCRTUNICP puszFilter);
51	static bool rtDirFilterWinNtMatchBase(unsigned iDepth, const char *pszName, PCRTUNICP puszFilter);
52
53
54
55	RTDECL(int) RTDirCreateFullPath(const char *pszPath, RTFMODE fMode)
56	{
57	/*
58	* Resolve the path.
59	*/
60	char szAbsPath[RTPATH_MAX];
61	int rc = RTPathAbs(pszPath, szAbsPath, sizeof(szAbsPath));
62	if (RT_FAILURE(rc))
63	return rc;
64
65	/*
66	* Iterate the path components making sure each of the exist.
67	*/
68	/* skip volume name */
69	char *psz = &szAbsPath[rtPathVolumeSpecLen(szAbsPath)];
70
71	/* skip the root slash if any */
72	if ( psz[0] == '/'
73	#if defined(__WIN__) \|\| defined(__OS2__)
74	\|\| psz[0] == '\\'
75	#endif
76	)
77	psz++;
78
79	/* iterate over path components. */
80	do
81	{
82	/* the next component is NULL, stop iterating */
83	if (!*psz)
84	break;
85	#if defined(__WIN__) \|\| defined(__OS2__)
86	psz = strpbrk(psz, "\\/");
87	#else
88	psz = strchr(psz, '/');
89	#endif
90	if (psz)
91	*psz = '\0';
92	/*
93	* ASSUME that RTDirCreate will return VERR_ALREADY_EXISTS and not VERR_ACCESS_DENIED in those cases
94	* where the directory exists but we don't have write access to the parent directory.
95	*/
96	rc = RTDirCreate(szAbsPath, fMode);
97	if (rc == VERR_ALREADY_EXISTS)
98	rc = VINF_SUCCESS;
99	if (!psz)
100	break;
101	*psz++ = RTPATH_DELIMITER;
102	} while (RT_SUCCESS(rc));
103
104	return rc;
105	}
106
107
108	/**
109	* Filter a the filename in the against a filter.
110	*
111	* @returns true if the name matches the filter.
112	* @returns false if the name doesn't match filter.
113	* @param pDir The directory handle.
114	* @param pszName The path to match to the filter.
115	*/
116	static DECLCALLBACK(bool) rtDirFilterWinNtMatchNoWildcards(PRTDIR pDir, const char *pszName)
117	{
118	/*
119	* Walk the string and compare.
120	*/
121	PCRTUNICP pucFilter = pDir->puszFilter;
122	const char *psz = pszName;
123	RTUNICP uc;
124	do
125	{
126	int rc = RTStrGetCpEx(&psz, &uc);
127	AssertRCReturn(rc, false);
128	RTUNICP ucFilter = *pucFilter++;
129	if ( uc != ucFilter
130	&& RTUniCpToUpper(uc) != ucFilter)
131	return false;
132	} while (uc);
133	return true;
134	}
135
136
137	/**
138	* Matches end of name.
139	*/
140	DECLINLINE(bool) rtDirFilterWinNtMatchEon(PCRTUNICP puszFilter)
141	{
142	RTUNICP ucFilter;
143	while ( (ucFilter = *puszFilter) == '>'
144	\|\| ucFilter == '<'
145	\|\| ucFilter == '*'
146	\|\| ucFilter == '"')
147	puszFilter++;
148	return !ucFilter;
149	}
150
151
152	/**
153	* Recursive star matching.
154	* Practically the same as normal star, except that the dos star stops
155	* when hitting the last dot.
156	*
157	* @returns true on match.
158	* @returns false on miss.
159	*/
160	static bool rtDirFilterWinNtMatchDosStar(unsigned iDepth, RTUNICP uc, const char *pszNext, PCRTUNICP puszFilter)
161	{
162	AssertReturn(iDepth++ < 256, false);
163
164	/*
165	* If there is no dos star, we should work just like the NT star.
166	* Since that's generally faster algorithms, we jump down to there if we can.
167	*/
168	const char *pszDosDot = strrchr(pszNext, '.');
169	if (!pszDosDot && uc == '.')
170	pszDosDot = pszNext - 1;
171	if (!pszDosDot)
172	return rtDirFilterWinNtMatchStar(iDepth, uc, pszNext, puszFilter);
173
174	/*
175	* Inspect the next filter char(s) until we find something to work on.
176	*/
177	RTUNICP ucFilter = *puszFilter++;
178	switch (ucFilter)
179	{
180	/*
181	* The star expression is the last in the pattern.
182	* We're fine if the name ends with a dot.
183	*/
184	case '\0':
185	return !pszDosDot[1];
186
187	/*
188	* Simplified by brute force.
189	*/
190	case '>': /* dos question mark */
191	case '?':
192	case '*':
193	case '<': /* dos star */
194	case '"': /* dos dot */
195	{
196	puszFilter--;
197	const char *pszStart = pszNext;
198	do
199	{
200	if (rtDirFilterWinNtMatchBase(iDepth, pszNext, puszFilter))
201	return true;
202	int rc = RTStrGetCpEx(&pszNext, &uc); AssertRCReturn(rc, false);
203	} while ((intptr_t)pszDosDot - (intptr_t)pszNext >= -1);
204
205	/* backtrack and do the current char. */
206	pszNext = RTStrPrevCp(NULL, pszStart); AssertReturn(pszNext, false);
207	return rtDirFilterWinNtMatchBase(iDepth, pszNext, puszFilter);
208	}
209
210	/*
211	* Ok, we've got zero or more characters.
212	* We'll try match starting at each occurence of this character.
213	*/
214	default:
215	{
216	if ( RTUniCpToUpper(uc) == ucFilter
217	&& rtDirFilterWinNtMatchBase(iDepth, pszNext, puszFilter))
218	return true;
219	do
220	{
221	int rc = RTStrGetCpEx(&pszNext, &uc); AssertRCReturn(rc, false);
222	if ( RTUniCpToUpper(uc) == ucFilter
223	&& rtDirFilterWinNtMatchBase(iDepth, pszNext, puszFilter))
224	return true;
225	} while ((intptr_t)pszDosDot - (intptr_t)pszNext >= -1);
226	return false;
227	}
228	}
229	/* won't ever get here! */
230	}
231
232
233	/**
234	* Recursive star matching.
235	*
236	* @returns true on match.
237	* @returns false on miss.
238	*/
239	static bool rtDirFilterWinNtMatchStar(unsigned iDepth, RTUNICP uc, const char *pszNext, PCRTUNICP puszFilter)
240	{
241	AssertReturn(iDepth++ < 256, false);
242
243	/*
244	* Inspect the next filter char(s) until we find something to work on.
245	*/
246	for (;;)
247	{
248	RTUNICP ucFilter = *puszFilter++;
249	switch (ucFilter)
250	{
251	/*
252	* The star expression is the last in the pattern.
253	* Cool, that means we're done!
254	*/
255	case '\0':
256	return true;
257
258	/*
259	* Just in case (doubt we ever get here), just merge it with the current one.
260	*/
261	case '*':
262	break;
263
264	/*
265	* Skip a fixed number of chars.
266	* Figure out how many by walking the filter ignoring '*'s.
267	*/
268	case '?':
269	{
270	unsigned cQms = 1;
271	while ((ucFilter = puszFilter) == '' \|\| ucFilter == '?')
272	{
273	cQms += ucFilter == '?';
274	puszFilter++;
275	}
276	do
277	{
278	if (!uc)
279	return false;
280	int rc = RTStrGetCpEx(&pszNext, &uc); AssertRCReturn(rc, false);
281	} while (--cQms > 0);
282	/* done? */
283	if (!ucFilter)
284	return true;
285	break;
286	}
287
288	/*
289	* The simple way is to try char by char and match the remaining
290	* expression. If it's trailing we're done.
291	*/
292	case '>': /* dos question mark */
293	{
294	if (rtDirFilterWinNtMatchEon(puszFilter))
295	return true;
296	const char *pszStart = pszNext;
297	do
298	{
299	if (rtDirFilterWinNtMatchBase(iDepth, pszNext, puszFilter))
300	return true;
301	int rc = RTStrGetCpEx(&pszNext, &uc); AssertRCReturn(rc, false);
302	} while (uc);
303
304	/* backtrack and do the current char. */
305	pszNext = RTStrPrevCp(NULL, pszStart); AssertReturn(pszNext, false);
306	return rtDirFilterWinNtMatchBase(iDepth, pszNext, puszFilter);
307	}
308
309	/*
310	* This bugger is interesting.
311	* Time for brute force. Iterate the name char by char.
312	*/
313	case '<':
314	{
315	do
316	{
317	if (rtDirFilterWinNtMatchDosStar(iDepth, uc, pszNext, puszFilter))
318	return true;
319	int rc = RTStrGetCpEx(&pszNext, &uc); AssertRCReturn(rc, false);
320	} while (uc);
321	return false;
322	}
323
324	/*
325	* This guy matches a '.' or the end of the name.
326	* It's very simple if the rest of the filter expression also matches eon.
327	*/
328	case '"':
329	if (rtDirFilterWinNtMatchEon(puszFilter))
330	return true;
331	ucFilter = '.';
332	/* fall thru */
333
334	/*
335	* Ok, we've got zero or more characters.
336	* We'll try match starting at each occurence of this character.
337	*/
338	default:
339	{
340	do
341	{
342	if ( RTUniCpToUpper(uc) == ucFilter
343	&& rtDirFilterWinNtMatchBase(iDepth, pszNext, puszFilter))
344	return true;
345	int rc = RTStrGetCpEx(&pszNext, &uc); AssertRCReturn(rc, false);
346	} while (uc);
347	return false;
348	}
349	}
350	} /* for (;;) */
351
352	/* won't ever get here! */
353	}
354
355
356	/**
357	* Filter a the filename in the against a filter.
358	*
359	* The rules are as follows:
360	* '?' Matches exactly one char.
361	* '*' Matches zero or more chars.
362	* '<' The dos star, matches zero or more chars except the DOS dot.
363	* '>' The dos question mark, matches one char, but dots and end-of-name eats them.
364	* '"' The dos dot, matches a dot or end-of-name.
365	*
366	* @returns true if the name matches the filter.
367	* @returns false if the name doesn't match filter.
368	* @param iDepth The recursion depth.
369	* @param pszName The path to match to the filter.
370	* @param puszFilter The filter string.
371	*/
372	static bool rtDirFilterWinNtMatchBase(unsigned iDepth, const char *pszName, PCRTUNICP puszFilter)
373	{
374	AssertReturn(iDepth++ < 256, false);
375
376	/*
377	* Walk the string and match it up char by char.
378	*/
379	RTUNICP uc;
380	do
381	{
382	RTUNICP ucFilter = *puszFilter++;
383	int rc = RTStrGetCpEx(&pszName, &uc); AssertRCReturn(rc, false);
384	switch (ucFilter)
385	{
386	/* Exactly one char. */
387	case '?':
388	if (!uc)
389	return false;
390	break;
391
392	/* One char, but the dos dot and end-of-name eats '>' and '<'. */
393	case '>': /* dos ? */
394	if (!uc)
395	return rtDirFilterWinNtMatchEon(puszFilter);
396	if (uc == '.')
397	{
398	while ((ucFilter = *puszFilter) == '>' \|\| ucFilter == '<')
399	puszFilter++;
400	if (ucFilter == '"' \|\| ucFilter == '.') /* not 100% sure about the last dot */
401	++puszFilter;
402	else /* the does question mark doesn't match '.'s, so backtrack. */
403	pszName = RTStrPrevCp(NULL, pszName);
404	}
405	break;
406
407	/* Match a dot or the end-of-name. */
408	case '"': /* dos '.' */
409	if (uc != '.')
410	{
411	if (uc)
412	return false;
413	return rtDirFilterWinNtMatchEon(puszFilter);
414	}
415	break;
416
417	/* zero or more */
418	case '*':
419	return rtDirFilterWinNtMatchStar(iDepth, uc, pszName, puszFilter);
420	case '<': /* dos '' /
421	return rtDirFilterWinNtMatchDosStar(iDepth, uc, pszName, puszFilter);
422
423
424	/* uppercased match */
425	default:
426	{
427	if (RTUniCpToUpper(uc) != ucFilter)
428	return false;
429	break;
430	}
431	}
432	} while (uc);
433
434	return true;
435	}
436
437
438	/**
439	* Filter a the filename in the against a filter.
440	*
441	* @returns true if the name matches the filter.
442	* @returns false if the name doesn't match filter.
443	* @param pDir The directory handle.
444	* @param pszName The path to match to the filter.
445	*/
446	static DECLCALLBACK(bool) rtDirFilterWinNtMatch(PRTDIR pDir, const char *pszName)
447	{
448	return rtDirFilterWinNtMatchBase(0, pszName, pDir->puszFilter);
449	}
450
451
452	/**
453	* Initializes a WinNt like wildcard filter.
454	*
455	* @returns Pointer to the filter function.
456	* @returns NULL if the filter doesn't filter out anything.
457	* @param pDir The directory handle (not yet opened).
458	*/
459	static PFNRTDIRFILTER rtDirFilterWinNtInit(PRTDIR pDir)
460	{
461	/*
462	* Check for the usual * and <"< (. in DOS language) patterns.
463	*/
464	if ( (pDir->cchFilter == 1 && pDir->pszFilter[0] == '*')
465	\|\| (pDir->cchFilter == 3 && !memcmp(pDir->pszFilter, "<\".>", 3))
466	)
467	return NULL;
468
469	/*
470	* Uppercase the expression, also do a little optimizations when possible.
471	*/
472	bool fHaveWildcards = false;
473	unsigned iRead = 0;
474	unsigned iWrite = 0;
475	while (iRead < pDir->cucFilter)
476	{
477	RTUNICP uc = pDir->puszFilter[iRead++];
478	if (uc == '*')
479	{
480	fHaveWildcards = true;
481	/* remove extra stars. */
482	RTUNICP uc2;
483	while ((uc2 = pDir->puszFilter[iRead + 1]) == '*')
484	iRead++;
485	}
486	else if (uc == '?' \|\| uc == '>' \|\| uc == '<' \|\| uc == '"')
487	fHaveWildcards = true;
488	else
489	uc = RTUniCpToUpper(uc);
490	pDir->puszFilter[iWrite++] = uc;
491	}
492	pDir->puszFilter[iWrite] = 0;
493	pDir->cucFilter = iWrite;
494
495	return fHaveWildcards
496	? rtDirFilterWinNtMatch
497	: rtDirFilterWinNtMatchNoWildcards;
498	}
499
500
501	/**
502	* Common worker for opening a directory.
503	*
504	* @returns IPRT status code.
505	* @param ppDir Where to store the directory handle.
506	* @param pszPath The specified path.
507	* @param pszFilter Pointer to where the filter start in the path. NULL if no filter.
508	* @param enmFilter The type of filter to apply.
509	*/
510	static int rtDirOpenCommon(PRTDIR ppDir, const char pszPath, const char *pszFilter, RTDIRFILTER enmFilter)
511	{
512	/*
513	* Expand the path.
514	*
515	* The purpose of this exercise to have the abs path around
516	* for querying extra information about the objects we list.
517	* As a sideeffect we also validate the path here.
518	*/
519	char szRealPath[RTPATH_MAX + 1];
520	int rc;
521	size_t cchFilter; /* includes '\0'. */
522	size_t cucFilter; /* includes U+0. */
523	if (!pszFilter)
524	{
525	cchFilter = cucFilter = 0;
526	rc = RTPathReal(pszPath, szRealPath, sizeof(szRealPath) - 1);
527	}
528	else
529	{
530	cchFilter = strlen(pszFilter) + 1;
531	cucFilter = RTStrUniLen(pszFilter) + 1;
532
533	if (pszFilter != pszPath)
534	{
535	/* yea, I'm lazy. sue me. */
536	char *pszTmp = RTStrDup(pszPath);
537	if (!pszTmp)
538	return VERR_NO_MEMORY;
539	pszTmp[pszFilter - pszPath] = '\0';
540	rc = RTPathReal(pszTmp, szRealPath, sizeof(szRealPath) - 1);
541	RTStrFree(pszTmp);
542	}
543	else
544	rc = RTPathReal(".", szRealPath, sizeof(szRealPath) - 1);
545	}
546	if (RT_FAILURE(rc))
547	return rc;
548
549	/* add trailing '/' if missing. */
550	size_t cchRealPath = strlen(szRealPath);
551	if (!RTPATH_IS_SEP(szRealPath[cchRealPath - 1]))
552	{
553	szRealPath[cchRealPath++] = RTPATH_SLASH;
554	szRealPath[cchRealPath] = '\0';
555	}
556
557	/*
558	* Allocate and initialize the directory handle.
559	*/
560	PRTDIR pDir = (PRTDIR)RTMemAlloc(sizeof(RTDIR) + cchRealPath + 1 + 4 + cchFilter + cucFilter * sizeof(RTUNICP));
561	if (!pDir)
562	return VERR_NO_MEMORY;
563
564	/* initialize it */
565	pDir->u32Magic = RTDIR_MAGIC;
566	if (cchFilter)
567	{
568	pDir->puszFilter = (PRTUNICP)(pDir + 1);
569	rc = RTStrToUniEx(pszFilter, RTSTR_MAX, &pDir->puszFilter, cucFilter, &pDir->cucFilter);
570	AssertRC(rc);
571	pDir->pszFilter = (char *)memcpy(pDir->puszFilter + cucFilter, pszFilter, cchFilter);
572	pDir->cchFilter = cchFilter - 1;
573	}
574	else
575	{
576	pDir->puszFilter = NULL;
577	pDir->cucFilter = 0;
578	pDir->pszFilter = NULL;
579	pDir->cchFilter = 0;
580	}
581	pDir->enmFilter = enmFilter;
582	switch (enmFilter)
583	{
584	default:
585	case RTDIRFILTER_NONE:
586	pDir->pfnFilter = NULL;
587	break;
588	case RTDIRFILTER_WINNT:
589	pDir->pfnFilter = rtDirFilterWinNtInit(pDir);
590	break;
591	case RTDIRFILTER_UNIX:
592	pDir->pfnFilter = NULL;
593	break;
594	case RTDIRFILTER_UNIX_UPCASED:
595	pDir->pfnFilter = NULL;
596	break;
597	}
598	pDir->cchPath = cchRealPath;
599	pDir->pszPath = (char )memcpy((char )(pDir + 1) + cucFilter * sizeof(RTUNICP) + cchFilter,
600	szRealPath, cchRealPath + 1);
601	pDir->fDataUnread = false;
602	#ifndef RT_DONT_CONVERT_FILENAMES
603	pDir->pszName = NULL;
604	pDir->cchName = 0;
605	#endif
606
607	/*
608	* Hand it over to the native part.
609	*/
610	rc = rtOpenDirNative(pDir, szRealPath);
611	if (RT_SUCCESS(rc))
612	*ppDir = pDir;
613	else
614	RTMemFree(pDir);
615
616	return rc;
617	}
618
619
620
621	RTDECL(int) RTDirOpen(PRTDIR ppDir, const char pszPath)
622	{
623	/*
624	* Validate input.
625	*/
626	AssertMsgReturn(VALID_PTR(ppDir), ("%p\n", ppDir), VERR_INVALID_POINTER);
627	AssertMsgReturn(VALID_PTR(pszPath), ("%p\n", pszPath), VERR_INVALID_POINTER);
628
629	/*
630	* Take common cause with RTDirOpenFiltered().
631	*/
632	int rc = rtDirOpenCommon(ppDir, pszPath, NULL, RTDIRFILTER_NONE);
633	LogFlow(("RTDirOpen(%p:{%p}, %p:{%s}): return %Rrc\n", ppDir, *ppDir, pszPath, pszPath, rc));
634	return rc;
635	}
636
637
638	RTDECL(int) RTDirOpenFiltered(PRTDIR ppDir, const char pszPath, RTDIRFILTER enmFilter)
639	{
640	/*
641	* Validate input.
642	*/
643	AssertMsgReturn(VALID_PTR(ppDir), ("%p\n", ppDir), VERR_INVALID_POINTER);
644	AssertMsgReturn(VALID_PTR(pszPath), ("%p\n", pszPath), VERR_INVALID_POINTER);
645	switch (enmFilter)
646	{
647	case RTDIRFILTER_UNIX:
648	case RTDIRFILTER_UNIX_UPCASED:
649	AssertMsgFailed(("%d is not implemented!\n", enmFilter));
650	return VERR_NOT_IMPLEMENTED;
651	case RTDIRFILTER_NONE:
652	case RTDIRFILTER_WINNT:
653	break;
654	default:
655	AssertMsgFailedReturn(("%d\n", enmFilter), VERR_INVALID_PARAMETER);
656	}
657
658	/*
659	* Find the last component, i.e. where the filter criteria starts and the dir name ends.
660	*/
661	const char *pszFilter = enmFilter != RTDIRFILTER_NONE
662	? RTPathFilename(pszPath)
663	: NULL;
664
665	/*
666	* Call worker common with RTDirOpen which will verify the path, allocate
667	* and initialize the handle, and finally call the backend.
668	*/
669	int rc = rtDirOpenCommon(ppDir, pszPath, pszFilter, enmFilter);
670
671	LogFlow(("RTDirOpenFiltered(%p:{%p}, %p:{%s}, %d): return %Rrc\n",
672	ppDir, *ppDir, pszPath, pszPath, enmFilter, rc));
673	return rc;
674	}
675

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

source: vbox/trunk/src/VBox/Runtime/dir.cpp@ 239

Download in other formats: