dir-win.cpp@ 9749

Last change on this file since 9749 was 8245, checked in by vboxsync, 16 years ago
rebranding: IPRT files again.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 15.2 KB

Line
1	/* $Id: dir-win.cpp 8245 2008-04-21 17:24:28Z vboxsync $ */
2	/** @file
3	* IPRT - Directory, win32.
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
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 (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*
26	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27	* Clara, CA 95054 USA or visit http://www.sun.com if you need
28	* additional information or have any questions.
29	*/
30
31
32	/*******************************************************************************
33	* Header Files *
34	*******************************************************************************/
35	#define LOG_GROUP RTLOGGROUP_DIR
36	#include <Windows.h>
37
38	#include <iprt/dir.h>
39	#include <iprt/path.h>
40	#include <iprt/alloc.h>
41	#include <iprt/string.h>
42	#include <iprt/assert.h>
43	#include <iprt/param.h>
44	#include <iprt/err.h>
45	#include <iprt/file.h>
46	#include <iprt/log.h>
47	#include "internal/fs.h"
48	#include "internal/path.h"
49	#include "internal/dir.h"
50
51
52
53	RTDECL(bool) RTDirExists(const char *pszPath)
54	{
55	bool fRc = false;
56
57	/*
58	* Convert to UTF-16.
59	*/
60	PRTUTF16 pwszString;
61	int rc = RTStrToUtf16(pszPath, &pwszString);
62	AssertRC(rc);
63	if (RT_SUCCESS(rc))
64	{
65	/*
66	* Query and check attributes.
67	*/
68	DWORD dwAttr = GetFileAttributesW((LPCWSTR)pwszString);
69	fRc = dwAttr != INVALID_FILE_ATTRIBUTES
70	&& (dwAttr & FILE_ATTRIBUTE_DIRECTORY);
71
72	RTUtf16Free(pwszString);
73	}
74
75	LogFlow(("RTDirExists(%p:{%s}): returns %RTbool\n", pszPath, pszPath, fRc));
76	return fRc;
77	}
78
79
80	RTDECL(int) RTDirCreate(const char *pszPath, RTFMODE fMode)
81	{
82	/*
83	* Validate the file mode.
84	*/
85	int rc;
86	fMode = rtFsModeNormalize(fMode, pszPath, 0);
87	if (rtFsModeIsValidPermissions(fMode))
88	{
89	/*
90	* Convert to UTF-16.
91	*/
92	PRTUTF16 pwszString;
93	rc = RTStrToUtf16(pszPath, &pwszString);
94	AssertRC(rc);
95	if (RT_SUCCESS(rc))
96	{
97	/*
98	* Create the directory.
99	*/
100	if (CreateDirectoryW((LPCWSTR)pwszString, NULL))
101	rc = VINF_SUCCESS;
102	else
103	rc = RTErrConvertFromWin32(GetLastError());
104
105	/*
106	* Turn off indexing of directory through Windows Indexing Service
107	*/
108	if (RT_SUCCESS(rc))
109	{
110	if (SetFileAttributesW((LPCWSTR)pwszString, FILE_ATTRIBUTE_NOT_CONTENT_INDEXED))
111	rc = VINF_SUCCESS;
112	else
113	rc = RTErrConvertFromWin32(GetLastError());
114	}
115
116	RTUtf16Free(pwszString);
117	}
118	}
119	else
120	{
121	AssertMsgFailed(("Invalid file mode! %RTfmode\n", fMode));
122	rc = VERR_INVALID_FMODE;
123	}
124
125	LogFlow(("RTDirCreate(%p:{%s}, %RTfmode): returns %Rrc\n", pszPath, pszPath, fMode, rc));
126	return rc;
127	}
128
129
130	RTDECL(int) RTDirRemove(const char *pszPath)
131	{
132	/*
133	* Convert to UTF-16.
134	*/
135	PRTUTF16 pwszString;
136	int rc = RTStrToUtf16(pszPath, &pwszString);
137	AssertRC(rc);
138	if (RT_SUCCESS(rc))
139	{
140	/*
141	* Remove the directory.
142	*/
143	if (RemoveDirectoryW((LPCWSTR)pwszString))
144	rc = VINF_SUCCESS;
145	else
146	rc = RTErrConvertFromWin32(GetLastError());
147
148	RTUtf16Free(pwszString);
149	}
150
151	LogFlow(("RTDirRemove(%p:{%s}): returns %Rrc\n", pszPath, pszPath, rc));
152	return rc;
153	}
154
155
156	int rtOpenDirNative(PRTDIR pDir, char *pszPathBuf)
157	{
158	/*
159	* Setup the search expression.
160	*
161	* pszPathBuf is pointing to the return 4K return buffer for the RTPathReal()
162	* call in rtDirOpenCommon(), so all we gota do is check that we don't overflow
163	* it when adding the wildcard expression.
164	*/
165	size_t cchExpr;
166	const char *pszExpr;
167	if (pDir->enmFilter == RTDIRFILTER_WINNT)
168	{
169	pszExpr = pDir->pszFilter;
170	cchExpr = pDir->cchFilter + 1;
171	}
172	else
173	{
174	pszExpr = "*";
175	cchExpr = sizeof("*");
176	}
177	if (pDir->cchPath + cchExpr > RTPATH_MAX)
178	return VERR_FILENAME_TOO_LONG;
179	memcpy(pszPathBuf + pDir->cchPath, pszExpr, cchExpr);
180
181
182	/*
183	* Attempt opening the search.
184	*/
185	int rc = VINF_SUCCESS;
186	#ifndef RT_DONT_CONVERT_FILENAMES
187	PRTUTF16 pwszName;
188	rc = RTStrToUtf16(pszPathBuf, &pwszName);
189	if (RT_SUCCESS(rc))
190	{
191	pDir->hDir = FindFirstFileW((LPCWSTR)pwszName, &pDir->Data);
192	#else
193	pDir->hDir = FindFirstFileA(pszPathBuf, &pDir->Data);
194	#endif
195	if (pDir->hDir != INVALID_HANDLE_VALUE)
196	pDir->fDataUnread = true;
197	/* theoretical case of an empty directory. */
198	else if (GetLastError() == ERROR_NO_MORE_FILES)
199	pDir->fDataUnread = false;
200	else
201	rc = RTErrConvertFromWin32(GetLastError());
202	#ifndef RT_DONT_CONVERT_FILENAMES
203	RTUtf16Free(pwszName);
204	}
205	#endif
206
207	return rc;
208	}
209
210
211	RTDECL(int) RTDirClose(PRTDIR pDir)
212	{
213	/*
214	* Validate input.
215	*/
216	if (!pDir)
217	return VERR_INVALID_PARAMETER;
218	if (pDir->u32Magic != RTDIR_MAGIC)
219	{
220	AssertMsgFailed(("Invalid pDir=%p\n", pDir));
221	return VERR_INVALID_PARAMETER;
222	}
223
224	/*
225	* Close the handle.
226	*/
227	pDir->u32Magic++;
228	if (pDir->hDir != INVALID_HANDLE_VALUE)
229	{
230	BOOL fRc = FindClose(pDir->hDir);
231	Assert(fRc);
232	pDir->hDir = INVALID_HANDLE_VALUE;
233	}
234	RTStrFree(pDir->pszName);
235	pDir->pszName = NULL;
236	RTMemFree(pDir);
237
238	return VINF_SUCCESS;
239	}
240
241
242	RTDECL(int) RTDirRead(PRTDIR pDir, PRTDIRENTRY pDirEntry, unsigned *pcbDirEntry)
243	{
244	/*
245	* Validate input.
246	*/
247	if (!pDir \|\| pDir->u32Magic != RTDIR_MAGIC)
248	{
249	AssertMsgFailed(("Invalid pDir=%p\n", pDir));
250	return VERR_INVALID_PARAMETER;
251	}
252	if (!pDirEntry)
253	{
254	AssertMsgFailed(("Invalid pDirEntry=%p\n", pDirEntry));
255	return VERR_INVALID_PARAMETER;
256	}
257	unsigned cbDirEntry = sizeof(*pDirEntry);
258	if (pcbDirEntry)
259	{
260	cbDirEntry = *pcbDirEntry;
261	if (cbDirEntry < (unsigned)RT_OFFSETOF(RTDIRENTRY, szName[2]))
262	{
263	AssertMsgFailed(("Invalid pcbDirEntry=%d (min %d)\n", pcbDirEntry, RT_OFFSETOF(RTDIRENTRY, szName[2])));
264	return VERR_INVALID_PARAMETER;
265	}
266	}
267
268	/*
269	* Fetch data?
270	*/
271	if (!pDir->fDataUnread)
272	{
273	#ifdef RT_DONT_CONVERT_FILENAMES
274	BOOL fRc = FindNextFileA(pDir->hDir, &pDir->Data);
275
276	#else
277	RTStrFree(pDir->pszName);
278	pDir->pszName = NULL;
279
280	BOOL fRc = FindNextFileW(pDir->hDir, &pDir->Data);
281	#endif
282	if (!fRc)
283	{
284	int iErr = GetLastError();
285	if (pDir->hDir == INVALID_HANDLE_VALUE \|\| iErr == ERROR_NO_MORE_FILES)
286	return VERR_NO_MORE_FILES;
287	return RTErrConvertFromWin32(iErr);
288	}
289	}
290
291	#ifndef RT_DONT_CONVERT_FILENAMES
292	/*
293	* Convert the filename to UTF-8.
294	*/
295	if (!pDir->pszName)
296	{
297	int rc = RTUtf16ToUtf8((PCRTUTF16)pDir->Data.cFileName, &pDir->pszName);
298	if (RT_FAILURE(rc))
299	{
300	pDir->pszName = NULL;
301	return rc;
302	}
303	pDir->cchName = strlen(pDir->pszName);
304	}
305	#endif
306
307	/*
308	* Check if we've got enough space to return the data.
309	*/
310	#ifdef RT_DONT_CONVERT_FILENAMES
311	const char *pszName = pDir->Data.cName;
312	const size_t cchName = strlen(pszName);
313	#else
314	const char *pszName = pDir->pszName;
315	const size_t cchName = pDir->cchName;
316	#endif
317	const size_t cbRequired = RT_OFFSETOF(RTDIRENTRY, szName[1]) + cchName;
318	if (pcbDirEntry)
319	*pcbDirEntry = cbRequired;
320	if (cbRequired > cbDirEntry)
321	return VERR_BUFFER_OVERFLOW;
322
323	/*
324	* Setup the returned data.
325	*/
326	pDir->fDataUnread = false;
327	pDirEntry->INodeId = 0;
328	pDirEntry->enmType = pDir->Data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY
329	? RTDIRENTRYTYPE_DIRECTORY : RTDIRENTRYTYPE_FILE;
330	pDirEntry->cbName = (uint16_t)cchName;
331	Assert(pDirEntry->cbName == cchName);
332	memcpy(pDirEntry->szName, pszName, cchName + 1);
333
334	return VINF_SUCCESS;
335	}
336
337
338	RTDECL(int) RTDirReadEx(PRTDIR pDir, PRTDIRENTRYEX pDirEntry, unsigned *pcbDirEntry, RTFSOBJATTRADD enmAdditionalAttribs)
339	{
340	/*
341	* Validate input.
342	*/
343	if (!pDir \|\| pDir->u32Magic != RTDIR_MAGIC)
344	{
345	AssertMsgFailed(("Invalid pDir=%p\n", pDir));
346	return VERR_INVALID_PARAMETER;
347	}
348	if (!pDirEntry)
349	{
350	AssertMsgFailed(("Invalid pDirEntry=%p\n", pDirEntry));
351	return VERR_INVALID_PARAMETER;
352	}
353	if ( enmAdditionalAttribs < RTFSOBJATTRADD_NOTHING
354	\|\| enmAdditionalAttribs > RTFSOBJATTRADD_LAST)
355	{
356	AssertMsgFailed(("Invalid enmAdditionalAttribs=%p\n", enmAdditionalAttribs));
357	return VERR_INVALID_PARAMETER;
358	}
359	unsigned cbDirEntry = sizeof(*pDirEntry);
360	if (pcbDirEntry)
361	{
362	cbDirEntry = *pcbDirEntry;
363	if (cbDirEntry < (unsigned)RT_OFFSETOF(RTDIRENTRYEX, szName[2]))
364	{
365	AssertMsgFailed(("Invalid pcbDirEntry=%d (min %d)\n", pcbDirEntry, RT_OFFSETOF(RTDIRENTRYEX, szName[2])));
366	return VERR_INVALID_PARAMETER;
367	}
368	}
369
370	/*
371	* Fetch data?
372	*/
373	if (!pDir->fDataUnread)
374	{
375	#ifdef RT_DONT_CONVERT_FILENAMES
376	BOOL fRc = FindNextFileA(pDir->hDir, &pDir->Data);
377
378	#else
379	RTStrFree(pDir->pszName);
380	pDir->pszName = NULL;
381
382	BOOL fRc = FindNextFileW(pDir->hDir, &pDir->Data);
383	#endif
384	if (!fRc)
385	{
386	int iErr = GetLastError();
387	if (pDir->hDir == INVALID_HANDLE_VALUE \|\| iErr == ERROR_NO_MORE_FILES)
388	return VERR_NO_MORE_FILES;
389	return RTErrConvertFromWin32(iErr);
390	}
391	}
392
393	#ifndef RT_DONT_CONVERT_FILENAMES
394	/*
395	* Convert the filename to UTF-8.
396	*/
397	if (!pDir->pszName)
398	{
399	int rc = RTUtf16ToUtf8((PCRTUTF16)pDir->Data.cFileName, &pDir->pszName);
400	if (RT_FAILURE(rc))
401	{
402	pDir->pszName = NULL;
403	return rc;
404	}
405	pDir->cchName = strlen(pDir->pszName);
406	}
407	#endif
408
409	/*
410	* Check if we've got enough space to return the data.
411	*/
412	#ifdef RT_DONT_CONVERT_FILENAMES
413	const char *pszName = pDir->Data.cName;
414	const size_t cchName = strlen(pszName);
415	#else
416	const char *pszName = pDir->pszName;
417	const size_t cchName = pDir->cchName;
418	#endif
419	const size_t cbRequired = RT_OFFSETOF(RTDIRENTRYEX, szName[1]) + cchName;
420	if (pcbDirEntry)
421	*pcbDirEntry = cbRequired;
422	if (cbRequired > cbDirEntry)
423	return VERR_BUFFER_OVERFLOW;
424
425	/*
426	* Setup the returned data.
427	*/
428	pDir->fDataUnread = false;
429	pDirEntry->cbName = (uint16_t)cchName;
430	Assert(pDirEntry->cbName == cchName);
431	memcpy(pDirEntry->szName, pszName, cchName + 1);
432	#ifndef RT_DONT_CONVERT_FILENAMES /* this ain't nice since the whole point of this define is not to drag in conversion... */
433	if (pDir->Data.cAlternateFileName[0])
434	{
435	/* copy and calc length */
436	PCRTUTF16 pwszSrc = (PCRTUTF16)pDir->Data.cAlternateFileName;
437	PRTUTF16 pwszDst = pDirEntry->wszShortName;
438	while (*pwszSrc)
439	pwszDst++ = pwszSrc++;
440	pDirEntry->cwcShortName = pwszDst - &pDirEntry->wszShortName[0];
441	/* zero the rest */
442	const PRTUTF16 pwszEnd = &pDirEntry->wszShortName[RT_ELEMENTS(pDirEntry->wszShortName)];
443	while (pwszDst < pwszEnd)
444	*pwszDst++ = '\0';
445	}
446	else
447	#endif
448	{
449	memset(pDirEntry->wszShortName, 0, sizeof(pDirEntry->wszShortName));
450	pDirEntry->cwcShortName = 0;
451	}
452
453	pDirEntry->Info.cbObject = ((uint64_t)pDir->Data.nFileSizeHigh << 32)
454	\| (uint64_t)pDir->Data.nFileSizeLow;
455	pDirEntry->Info.cbAllocated = pDirEntry->Info.cbObject;
456
457	Assert(sizeof(uint64_t) == sizeof(pDir->Data.ftCreationTime));
458	RTTimeSpecSetNtTime(&pDirEntry->Info.BirthTime, (uint64_t )&pDir->Data.ftCreationTime);
459	RTTimeSpecSetNtTime(&pDirEntry->Info.AccessTime, (uint64_t )&pDir->Data.ftLastAccessTime);
460	RTTimeSpecSetNtTime(&pDirEntry->Info.ModificationTime, (uint64_t )&pDir->Data.ftLastWriteTime);
461	pDirEntry->Info.ChangeTime = pDirEntry->Info.ModificationTime;
462
463	pDirEntry->Info.Attr.fMode = rtFsModeFromDos((pDir->Data.dwFileAttributes << RTFS_DOS_SHIFT) & RTFS_DOS_MASK_NT,
464	pszName, cchName);
465
466	/*
467	* Requested attributes (we cannot provide anything actually).
468	*/
469	switch (enmAdditionalAttribs)
470	{
471	case RTFSOBJATTRADD_EASIZE:
472	pDirEntry->Info.Attr.enmAdditional = RTFSOBJATTRADD_EASIZE;
473	pDirEntry->Info.Attr.u.EASize.cb = 0;
474	break;
475
476	case RTFSOBJATTRADD_UNIX:
477	pDirEntry->Info.Attr.enmAdditional = RTFSOBJATTRADD_UNIX;
478	pDirEntry->Info.Attr.u.Unix.uid = ~0U;
479	pDirEntry->Info.Attr.u.Unix.gid = ~0U;
480	pDirEntry->Info.Attr.u.Unix.cHardlinks = 1;
481	pDirEntry->Info.Attr.u.Unix.INodeIdDevice = 0;
482	pDirEntry->Info.Attr.u.Unix.INodeId = 0;
483	pDirEntry->Info.Attr.u.Unix.fFlags = 0;
484	pDirEntry->Info.Attr.u.Unix.GenerationId = 0;
485	pDirEntry->Info.Attr.u.Unix.Device = 0;
486	break;
487
488	case RTFSOBJATTRADD_NOTHING:
489	pDirEntry->Info.Attr.enmAdditional = RTFSOBJATTRADD_NOTHING;
490	break;
491
492	default:
493	AssertMsgFailed(("Impossible!\n"));
494	return VERR_INTERNAL_ERROR;
495	}
496
497	return VINF_SUCCESS;
498	}
499
500
501	RTDECL(int) RTDirRename(const char pszSrc, const char pszDst, unsigned fRename)
502	{
503	/*
504	* Validate input.
505	*/
506	AssertMsgReturn(VALID_PTR(pszSrc), ("%p\n", pszSrc), VERR_INVALID_POINTER);
507	AssertMsgReturn(VALID_PTR(pszDst), ("%p\n", pszDst), VERR_INVALID_POINTER);
508	AssertMsgReturn(*pszSrc, ("%p\n", pszSrc), VERR_INVALID_PARAMETER);
509	AssertMsgReturn(*pszDst, ("%p\n", pszDst), VERR_INVALID_PARAMETER);
510	AssertMsgReturn(!(fRename & ~RTPATHRENAME_FLAGS_REPLACE), ("%#x\n", fRename), VERR_INVALID_PARAMETER);
511
512	/*
513	* Call the worker.
514	*/
515	int rc = rtPathWin32MoveRename(pszSrc, pszDst,
516	fRename & RTPATHRENAME_FLAGS_REPLACE ? MOVEFILE_REPLACE_EXISTING : 0,
517	RTFS_TYPE_DIRECTORY);
518
519	LogFlow(("RTDirRename(%p:{%s}, %p:{%s}, %#x): returns %Rrc\n", pszSrc, pszSrc, pszDst, pszDst, fRename, rc));
520	return rc;
521	}
522

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

source: vbox/trunk/src/VBox/Runtime/r3/win/dir-win.cpp@ 9749

Download in other formats: