VirtualBox

source: vbox/trunk/src/VBox/Runtime/r3/win/path-win.cpp@ 13837

Last change on this file since 13837 was 13837, checked in by vboxsync, 16 years ago

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

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette