path-win32.cpp@ 937

Last change on this file since 937 was 937, checked in by vboxsync, 18 years ago
RTPathExists.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 16.3 KB

Line
1	/* $Id: path-win32.cpp 937 2007-02-15 20:59:20Z vboxsync $ */
2	/** @file
3	* InnoTek Portable Runtime - Path 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_PATH
27	#include <Windows.h>
28
29	#include <iprt/path.h>
30	#include <iprt/assert.h>
31	#include <iprt/string.h>
32	#include <iprt/time.h>
33	#include <iprt/param.h>
34	#include <iprt/log.h>
35	#include <iprt/err.h>
36	#include "internal/path.h"
37	#include "internal/fs.h"
38
39
40	/**
41	* Get the real (no symlinks, no . or .. components) path, must exist.
42	*
43	* @returns iprt status code.
44	* @param pszPath The path to resolve.
45	* @param pszRealPath Where to store the real path.
46	* @param cchRealPath Size of the buffer.
47	*/
48	RTDECL(int) RTPathReal(const char pszPath, char pszRealPath, unsigned cchRealPath)
49	{
50	/*
51	* Convert to UCS2, call Win32 APIs, convert back.
52	*/
53	PRTUTF16 pwszPath;
54	int rc = RTStrUtf8ToUcs2(&pwszPath, pszPath);
55	if (!RT_SUCCESS(rc))
56	return (rc);
57
58	LPWSTR lpFile;
59	WCHAR wsz[RTPATH_MAX];
60	rc = GetFullPathNameW((LPCWSTR)pwszPath, ELEMENTS(wsz), &wsz[0], &lpFile);
61	if (rc > 0 && rc < ELEMENTS(wsz))
62	{
63	/* Check that it exists. (Use RTPathAbs() to just resolve the name.) */
64	DWORD dwAttr = GetFileAttributesW(wsz);
65	if (dwAttr != INVALID_FILE_ATTRIBUTES)
66	rc = RTStrUcs2ToUtf8Ex(&pszRealPath, cchRealPath, (PRTUTF16)&wsz[0]);
67	else
68	rc = RTErrConvertFromWin32(GetLastError());
69	}
70	else if (rc <= 0)
71	rc = RTErrConvertFromWin32(GetLastError());
72	else
73	rc = VERR_FILENAME_TOO_LONG;
74
75	RTStrUcs2Free(pwszPath);
76
77	return rc;
78	}
79
80
81	/**
82	* Get the absolute path (no symlinks, no . or .. components), doesn't have to exit.
83	*
84	* @returns iprt status code.
85	* @param pszPath The path to resolve.
86	* @param pszAbsPath Where to store the absolute path.
87	* @param cchAbsPath Size of the buffer.
88	*/
89	RTDECL(int) RTPathAbs(const char pszPath, char pszAbsPath, unsigned cchAbsPath)
90	{
91	/*
92	* Convert to UCS2, call Win32 API, convert back.
93	*/
94	LPWSTR lpwPath;
95	int rc = RTStrUtf8ToUcs2(&lpwPath, pszPath);
96	if (!RT_SUCCESS(rc))
97	return (rc);
98
99	LPWSTR lpFile;
100	RTUCS2 ucsz[RTPATH_MAX];
101	rc = GetFullPathNameW(lpwPath, ELEMENTS(ucsz), &ucsz[0], &lpFile);
102	if (rc > 0 && rc < ELEMENTS(ucsz))
103	rc = RTStrUcs2ToUtf8Ex(&pszAbsPath, cchAbsPath, &ucsz[0]);
104	else if (rc <= 0)
105	rc = RTErrConvertFromWin32(GetLastError());
106	else
107	rc = VERR_FILENAME_TOO_LONG;
108
109	RTStrUcs2Free(lpwPath);
110
111	return rc;
112	}
113
114
115	/**
116	* Gets the program path.
117	*
118	* @returns iprt status code.
119	* @param pszPath Buffer where to store the path.
120	* @param cchPath Buffer size in bytes.
121	*/
122	RTDECL(int) RTPathProgram(char *pszPath, unsigned cchPath)
123	{
124	/*
125	* First time only.
126	*/
127	if (!g_szrtProgramPath[0])
128	{
129	HMODULE hExe = GetModuleHandle(NULL);
130	if (!GetModuleFileName(hExe, &g_szrtProgramPath[0], sizeof(g_szrtProgramPath)))
131	{
132	AssertMsgFailed(("Couldn't get exe module name. lasterr=%d\n", GetLastError()));
133	return RTErrConvertFromWin32(GetLastError());
134	}
135	RTPathStripFilename(g_szrtProgramPath);
136	}
137
138	/*
139	* Calc the length and check if there is space before copying.
140	*/
141	unsigned cch = strlen(g_szrtProgramPath) + 1;
142	if (cch <= cchPath)
143	{
144	memcpy(pszPath, g_szrtProgramPath, cch + 1);
145	return VINF_SUCCESS;
146	}
147
148	AssertMsgFailed(("Buffer too small (%d < %d)\n", cchPath, cch));
149	return VERR_BUFFER_OVERFLOW;
150	}
151
152
153	/**
154	* Gets the user home directory.
155	*
156	* @returns iprt status code.
157	* @param pszPath Buffer where to store the path.
158	* @param cchPath Buffer size in bytes.
159	*/
160	RTDECL(int) RTPathUserHome(char *pszPath, unsigned cchPath)
161	{
162	RTUCS2 ucszPath[RTPATH_MAX];
163	DWORD dwAttr;
164
165	/*
166	* There are multiple definitions for what WE think of as user home...
167	*/
168	if ( !GetEnvironmentVariableW(L"HOME", &ucszPath[0], RTPATH_MAX)
169	\|\| (dwAttr = GetFileAttributesW(&ucszPath[0])) == INVALID_FILE_ATTRIBUTES
170	\|\| !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
171	{
172	if ( !GetEnvironmentVariableW(L"USERPROFILE", &ucszPath[0], RTPATH_MAX)
173	\|\| (dwAttr = GetFileAttributesW(&ucszPath[0])) == INVALID_FILE_ATTRIBUTES
174	\|\| !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
175	{
176	if (!GetEnvironmentVariableW(L"HOMEDRIVE", &ucszPath[0], RTPATH_MAX))
177	return VERR_PATH_NOT_FOUND;
178	PRTUCS2 pucsz = &ucszPath[RTStrUcs2Len(&ucszPath[0])];
179	if ( !GetEnvironmentVariableW(L"HOMEPATH", &ucszPath[0], RTPATH_MAX)
180	\|\| (dwAttr = GetFileAttributesW(&ucszPath[0])) == INVALID_FILE_ATTRIBUTES
181	\|\| !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
182	return VERR_PATH_NOT_FOUND;
183	}
184	}
185
186	/*
187	* Convert and return.
188	*/
189	return RTStrUcs2ToUtf8Ex(&pszPath, cchPath, &ucszPath[0]);
190	}
191
192
193	RTR3DECL(int) RTPathQueryInfo(const char *pszPath, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAdditionalAttribs)
194	{
195	/*
196	* Validate input.
197	*/
198	if (!pszPath)
199	{
200	AssertMsgFailed(("Invalid pszPath=%p\n", pszPath));
201	return VERR_INVALID_PARAMETER;
202	}
203	if (!pObjInfo)
204	{
205	AssertMsgFailed(("Invalid pObjInfo=%p\n", pObjInfo));
206	return VERR_INVALID_PARAMETER;
207	}
208	if ( enmAdditionalAttribs < RTFSOBJATTRADD_NOTHING
209	\|\| enmAdditionalAttribs > RTFSOBJATTRADD_LAST)
210	{
211	AssertMsgFailed(("Invalid enmAdditionalAttribs=%p\n", enmAdditionalAttribs));
212	return VERR_INVALID_PARAMETER;
213	}
214
215	/*
216	* Query file info.
217	*/
218	WIN32_FILE_ATTRIBUTE_DATA Data;
219	#ifndef RT_DONT_CONVERT_FILENAMES
220	PRTUCS2 puszPath;
221	int rc = RTStrUtf8ToUcs2(&puszPath, pszPath);
222	if (RT_FAILURE(rc))
223	return rc;
224	if (!GetFileAttributesExW(puszPath, GetFileExInfoStandard, &Data))
225	{
226	rc = RTErrConvertFromWin32(GetLastError());
227	RTStrUcs2Free(puszPath);
228	return rc;
229	}
230	#else
231	if (!GetFileAttributesExA(pszPath, GetFileExInfoStandard, &Data))
232	return RTErrConvertFromWin32(GetLastError());
233	#endif
234
235	/*
236	* Setup the returned data.
237	*/
238	pObjInfo->cbObject = ((uint64_t)Data.nFileSizeHigh << 32)
239	\| (uint64_t)Data.nFileSizeLow;
240	pObjInfo->cbAllocated = pObjInfo->cbObject;
241
242	Assert(sizeof(uint64_t) == sizeof(Data.ftCreationTime));
243	RTTimeSpecSetNtTime(&pObjInfo->BirthTime, (uint64_t )&Data.ftCreationTime);
244	RTTimeSpecSetNtTime(&pObjInfo->AccessTime, (uint64_t )&Data.ftLastAccessTime);
245	RTTimeSpecSetNtTime(&pObjInfo->ModificationTime, (uint64_t )&Data.ftLastWriteTime);
246	pObjInfo->ChangeTime = pObjInfo->ModificationTime;
247
248	pObjInfo->Attr.fMode = rtFsModeFromDos((Data.dwFileAttributes << RTFS_DOS_SHIFT) & RTFS_DOS_MASK_NT,
249	pszPath, strlen(pszPath));
250
251	/*
252	* Requested attributes (we cannot provide anything actually).
253	*/
254	switch (enmAdditionalAttribs)
255	{
256	case RTFSOBJATTRADD_EASIZE:
257	pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_EASIZE;
258	pObjInfo->Attr.u.EASize.cb = 0;
259	break;
260
261	case RTFSOBJATTRADD_UNIX:
262	pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_UNIX;
263	pObjInfo->Attr.u.Unix.uid = ~0U;
264	pObjInfo->Attr.u.Unix.gid = ~0U;
265	pObjInfo->Attr.u.Unix.cHardlinks = 1;
266	pObjInfo->Attr.u.Unix.INodeIdDevice = 0;
267	pObjInfo->Attr.u.Unix.INodeId = 0;
268	pObjInfo->Attr.u.Unix.fFlags = 0;
269	pObjInfo->Attr.u.Unix.GenerationId = 0;
270	pObjInfo->Attr.u.Unix.Device = 0;
271	break;
272
273	case RTFSOBJATTRADD_NOTHING:
274	pObjInfo->Attr.enmAdditional = RTFSOBJATTRADD_NOTHING;
275	break;
276
277	default:
278	AssertMsgFailed(("Impossible!\n"));
279	return VERR_INTERNAL_ERROR;
280	}
281
282	return VINF_SUCCESS;
283	}
284
285
286	RTR3DECL(int) RTPathSetTimes(const char *pszPath, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime,
287	PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime)
288	{
289	/*
290	* Validate input.
291	*/
292	AssertMsgReturn(VALID_PTR(pszPath), ("%p\n", pszPath), VERR_INVALID_POINTER);
293	AssertMsgReturn(*pszPath, ("%p\n", pszPath), VERR_INVALID_PARAMETER);
294	AssertMsgReturn(!pAccessTime \|\| VALID_PTR(pAccessTime), ("%p\n", pAccessTime), VERR_INVALID_POINTER);
295	AssertMsgReturn(!pModificationTime \|\| VALID_PTR(pModificationTime), ("%p\n", pModificationTime), VERR_INVALID_POINTER);
296	AssertMsgReturn(!pChangeTime \|\| VALID_PTR(pChangeTime), ("%p\n", pChangeTime), VERR_INVALID_POINTER);
297	AssertMsgReturn(!pBirthTime \|\| VALID_PTR(pBirthTime), ("%p\n", pBirthTime), VERR_INVALID_POINTER);
298
299	/*
300	* Convert the path.
301	*/
302	PRTUTF16 pwszPath;
303	int rc = RTStrToUtf16(pszPath, &pwszPath);
304	if (RT_SUCCESS(rc))
305	{
306	HANDLE hFile = CreateFileW(pwszPath,
307	FILE_WRITE_ATTRIBUTES, /* dwDesiredAccess */
308	FILE_SHARE_WRITE \| FILE_SHARE_READ \| FILE_SHARE_DELETE, /* dwShareMode */
309	NULL, /* security attribs */
310	OPEN_EXISTING, /* dwCreationDisposition */
311	FILE_FLAG_BACKUP_SEMANTICS \| FILE_ATTRIBUTE_NORMAL,
312	NULL);
313	if (hFile != INVALID_HANDLE_VALUE)
314	{
315	/*
316	* Check if it's a no-op.
317	*/
318	if (!pAccessTime && !pModificationTime && !pBirthTime)
319	rc = VINF_SUCCESS; /* NOP */
320	else
321	{
322	/*
323	* Convert the input and call the API.
324	*/
325	FILETIME CreationTimeFT;
326	PFILETIME pCreationTimeFT = NULL;
327	if (pBirthTime)
328	pCreationTimeFT = RTTimeSpecGetNtFileTime(pBirthTime, &CreationTimeFT);
329
330	FILETIME LastAccessTimeFT;
331	PFILETIME pLastAccessTimeFT = NULL;
332	if (pAccessTime)
333	pLastAccessTimeFT = RTTimeSpecGetNtFileTime(pAccessTime, &LastAccessTimeFT);
334
335	FILETIME LastWriteTimeFT;
336	PFILETIME pLastWriteTimeFT = NULL;
337	if (pModificationTime)
338	pLastWriteTimeFT = RTTimeSpecGetNtFileTime(pModificationTime, &LastWriteTimeFT);
339
340	if (SetFileTime(hFile, pCreationTimeFT, pLastAccessTimeFT, pLastWriteTimeFT))
341	rc = VINF_SUCCESS;
342	else
343	{
344	DWORD Err = GetLastError();
345	rc = RTErrConvertFromWin32(Err);
346	Log(("RTPathSetTimes('%s', %p, %p, %p, %p): SetFileTime failed with lasterr %d (%Vrc)\n",
347	pszPath, pAccessTime, pModificationTime, pChangeTime, pBirthTime, Err, rc));
348	}
349	}
350	BOOL fRc = CloseHandle(hFile); Assert(fRc); NOREF(fRc);
351	}
352	else
353	{
354	DWORD Err = GetLastError();
355	rc = RTErrConvertFromWin32(Err);
356	Log(("RTPathSetTimes('%s',,,,): failed with %Rrc and lasterr=%u\n", pszPath, rc, Err));
357	}
358
359	RTUtf16Free(pwszPath);
360	}
361
362	LogFlow(("RTPathSetTimes(%p:{%s}, %p:{%RDtimespec}, %p:{%RDtimespec}, %p:{%RDtimespec}, %p:{%RDtimespec}): return %Rrc\n",
363	pszPath, pszPath, pAccessTime, pAccessTime, pModificationTime, pModificationTime,
364	pChangeTime, pChangeTime, pBirthTime, pBirthTime));
365	return rc;
366	}
367
368
369
370
371	/**
372	* Internal worker for RTFileRename and RTFileMove.
373	*
374	* @returns iprt status code.
375	* @param pszSrc The source filename.
376	* @param pszDst The destination filename.
377	* @param fFlags The windows MoveFileEx flags.
378	* @param fFileType The filetype. We use the RTFMODE filetypes here. If it's 0,
379	* anything goes. If it's RTFS_TYPE_DIRECTORY we'll check that the
380	* source is a directory. If Its RTFS_TYPE_FILE we'll check that it's
381	* not a directory (we are NOT checking whether it's a file).
382	*/
383	int rtPathWin32MoveRename(const char pszSrc, const char pszDst, uint32_t fFlags, RTFMODE fFileType)
384	{
385	/*
386	* Convert the strings.
387	*/
388	PRTUTF16 pwszSrc;
389	int rc = RTStrToUtf16(pszSrc, &pwszSrc);
390	if (RT_SUCCESS(rc))
391	{
392	PRTUTF16 pwszDst;
393	rc = RTStrToUtf16(pszDst, &pwszDst);
394	if (RT_SUCCESS(rc))
395	{
396	/*
397	* Check object type if requested.
398	* This is open to race conditions.
399	*/
400	if (fFileType)
401	{
402	DWORD dwAttr = GetFileAttributesW(pwszSrc);
403	if (dwAttr == INVALID_FILE_ATTRIBUTES)
404	rc = RTErrConvertFromWin32(GetLastError());
405	else if (RTFS_IS_DIRECTORY(fFileType))
406	rc = dwAttr & FILE_ATTRIBUTE_DIRECTORY ? VINF_SUCCESS : VERR_NOT_A_DIRECTORY;
407	else
408	rc = dwAttr & FILE_ATTRIBUTE_DIRECTORY ? VERR_IS_A_DIRECTORY : VINF_SUCCESS;
409	}
410	if (RT_SUCCESS(rc))
411	{
412	if (MoveFileExW(pwszSrc, pwszDst, fFlags))
413	rc = VINF_SUCCESS;
414	else
415	{
416	DWORD Err = GetLastError();
417	rc = RTErrConvertFromWin32(Err);
418	Log(("MoveFileExW('%s', '%s', %#x, %RTfmode): fails with rc=%Rrc & lasterr=%d\n",
419	pszSrc, pszDst, fFlags, fFileType, rc, Err));
420	}
421	}
422	RTUtf16Free(pwszDst);
423	}
424	RTUtf16Free(pwszSrc);
425	}
426	return rc;
427	}
428
429
430	RTR3DECL(int) RTPathRename(const char pszSrc, const char pszDst, unsigned fRename)
431	{
432	/*
433	* Validate input.
434	*/
435	AssertMsgReturn(VALID_PTR(pszSrc), ("%p\n", pszSrc), VERR_INVALID_POINTER);
436	AssertMsgReturn(VALID_PTR(pszDst), ("%p\n", pszDst), VERR_INVALID_POINTER);
437	AssertMsgReturn(*pszSrc, ("%p\n", pszSrc), VERR_INVALID_PARAMETER);
438	AssertMsgReturn(*pszDst, ("%p\n", pszDst), VERR_INVALID_PARAMETER);
439	AssertMsgReturn(!(fRename & ~RTPATHRENAME_FLAGS_REPLACE), ("%#x\n", fRename), VERR_INVALID_PARAMETER);
440
441	/*
442	* Call the worker.
443	*/
444	int rc = rtPathWin32MoveRename(pszSrc, pszDst, fRename & RTPATHRENAME_FLAGS_REPLACE ? MOVEFILE_REPLACE_EXISTING : 0, 0);
445
446	LogFlow(("RTPathRename(%p:{%s}, %p:{%s}, %#x): returns %Rrc\n", pszSrc, pszSrc, pszDst, pszDst, fRename, rc));
447	return rc;
448	}
449
450
451	/**
452	* Checks if the path exists.
453	*
454	* Symbolic links will all be attempted resolved.
455	*
456	* @returns true if it exists and false if it doesn't
457	* @param pszPath The path to check.
458	*/
459	RTDECL(bool) RTPathExists(const char *pszPath)
460	{
461	/*
462	* Validate input.
463	*/
464	AssertPtrReturn(pszPath, false);
465	AssertReturn(*pszPath, false);
466
467	/*
468	* Try query file info.
469	*/
470	#ifndef RT_DONT_CONVERT_FILENAMES
471	PRTUCS2 puszPath;
472	int rc = RTStrUtf8ToUcs2(&puszPath, pszPath);
473	if (RT_SUCCESS(rc))
474	{
475	if (GetFileAttributesW(puszPath) == INVALID_FILE_ATTRIBUTES)
476	rc = VERR_GENERAL_FAILURE;
477	RTStrUcs2Free(puszPath);
478	}
479	#else
480	int rc = VINF_SUCCESS;
481	if (GetFileAttributesExA(pszPath) == INVALID_FILE_ATTRIBUTES)
482	rc = VERR_GENERAL_FAILURE;
483	#endif
484
485	return RT_SUCCESS(rc);
486	}
487

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

source: vbox/trunk/src/VBox/Runtime/r3/win32/path-win32.cpp@ 937

Download in other formats: