1143 lines
40 KiB
C++
1143 lines
40 KiB
C++
/*************************************************************************
|
|
*
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* Copyright 2000, 2010 Oracle and/or its affiliates.
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* This file is part of OpenOffice.org.
|
|
*
|
|
* OpenOffice.org is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License version 3
|
|
* only, as published by the Free Software Foundation.
|
|
*
|
|
* OpenOffice.org is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License version 3 for more details
|
|
* (a copy is included in the LICENSE file that accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* version 3 along with OpenOffice.org. If not, see
|
|
* <http://www.openoffice.org/license.html>
|
|
* for a copy of the LGPLv3 License.
|
|
*
|
|
************************************************************************/
|
|
|
|
#define UNICODE
|
|
#define _UNICODE
|
|
#define _WIN32_WINNT_0x0500
|
|
#include "systools/win32/uwinapi.h"
|
|
|
|
#include "file_url.h"
|
|
#include "file_error.h"
|
|
|
|
#include "rtl/alloc.h"
|
|
#include "osl/diagnose.h"
|
|
#include "osl/file.h"
|
|
#include "osl/mutex.h"
|
|
|
|
#include "path_helper.hxx"
|
|
|
|
#include <stdio.h>
|
|
#include <tchar.h>
|
|
|
|
#if OSL_DEBUG_LEVEL > 0
|
|
#define OSL_ENSURE_FILE( cond, msg, file ) ( (cond) ? (void)0 : _osl_warnFile( msg, file ) )
|
|
#else
|
|
#define OSL_ENSURE_FILE( cond, msg, file ) ((void)0)
|
|
#endif
|
|
|
|
#define ELEMENTS_OF_ARRAY(arr) (sizeof(arr)/(sizeof((arr)[0])))
|
|
|
|
#define WSTR_SYSTEM_ROOT_PATH L"\\\\.\\"
|
|
#define WSTR_LONG_PATH_PREFIX L"\\\\?\\"
|
|
#define WSTR_LONG_PATH_PREFIX_UNC L"\\\\?\\UNC\\"
|
|
|
|
|
|
//##################################################################
|
|
// FileURL functions
|
|
//##################################################################
|
|
|
|
extern "C" oslMutex g_CurrentDirectoryMutex; /* Initialized in dllentry.c */
|
|
oslMutex g_CurrentDirectoryMutex = 0;
|
|
|
|
//#####################################################
|
|
static BOOL IsValidFilePathComponent(
|
|
LPCTSTR lpComponent, LPCTSTR *lppComponentEnd, DWORD dwFlags)
|
|
{
|
|
LPCTSTR lpComponentEnd = NULL;
|
|
LPCTSTR lpCurrent = lpComponent;
|
|
BOOL fValid = TRUE; /* Assume success */
|
|
TCHAR cLast = 0;
|
|
|
|
/* Path component length must not exceed MAX_PATH even if long path with "\\?\" prefix is used */
|
|
|
|
while ( !lpComponentEnd && lpCurrent && lpCurrent - lpComponent < MAX_PATH )
|
|
{
|
|
switch ( *lpCurrent )
|
|
{
|
|
/* Both backslash and slash determine the end of a path component */
|
|
case '\0':
|
|
case '/':
|
|
case '\\':
|
|
switch ( cLast )
|
|
{
|
|
/* Component must not end with '.' or blank and can't be empty */
|
|
|
|
case '.':
|
|
if ( dwFlags & VALIDATEPATH_ALLOW_ELLIPSE )
|
|
{
|
|
if ( 1 == lpCurrent - lpComponent )
|
|
{
|
|
/* Current directory is O.K. */
|
|
lpComponentEnd = lpCurrent;
|
|
break;
|
|
}
|
|
else if ( 2 == lpCurrent - lpComponent && '.' == *lpComponent )
|
|
{
|
|
/* Parent directory is O.K. */
|
|
lpComponentEnd = lpCurrent;
|
|
break;
|
|
}
|
|
}
|
|
case 0:
|
|
case ' ':
|
|
lpComponentEnd = lpCurrent - 1;
|
|
fValid = FALSE;
|
|
break;
|
|
default:
|
|
lpComponentEnd = lpCurrent;
|
|
break;
|
|
}
|
|
break;
|
|
/* '?' and '*' are valid wildcards but not valid file name characters */
|
|
case '?':
|
|
case '*':
|
|
if ( dwFlags & VALIDATEPATH_ALLOW_WILDCARDS )
|
|
break;
|
|
/* The following characters are reserved */
|
|
case '<':
|
|
case '>':
|
|
case '\"':
|
|
case '|':
|
|
case ':':
|
|
lpComponentEnd = lpCurrent;
|
|
fValid = FALSE;
|
|
break;
|
|
default:
|
|
/* Characters below ASCII 32 are not allowed */
|
|
if ( *lpCurrent < ' ' )
|
|
{
|
|
lpComponentEnd = lpCurrent;
|
|
fValid = FALSE;
|
|
}
|
|
break;
|
|
}
|
|
cLast = *lpCurrent++;
|
|
}
|
|
|
|
/* If we don't reached the end of the component the length of the component was to long
|
|
( See condition of while loop ) */
|
|
if ( !lpComponentEnd )
|
|
{
|
|
fValid = FALSE;
|
|
lpComponentEnd = lpCurrent;
|
|
}
|
|
|
|
/* Test wether the component specifies a device name what is not allowed */
|
|
|
|
// MT: PERFORMANCE:
|
|
// This is very expensive. A lot of calls to _tcsicmp.
|
|
// in SRC6870m71 67.000 calls of this method while empty office start result into more than 1.500.00 calls of _tcsicmp!
|
|
// Possible optimizations
|
|
// - Array should be const static
|
|
// - Sorted array, use binary search
|
|
// - More intelligent check for com1-9, lpt1-9
|
|
// Maybe make szComponent upper case, don't search case intensitive
|
|
// Talked to HRO: Could be removed. Shouldn't be used in OOo, and if used for something like a filename, it will lead to an error anyway.
|
|
/*
|
|
if ( fValid )
|
|
{
|
|
LPCTSTR alpDeviceNames[] =
|
|
{
|
|
TEXT("CON"),
|
|
TEXT("PRN"),
|
|
TEXT("AUX"),
|
|
TEXT("CLOCK$"),
|
|
TEXT("NUL"),
|
|
TEXT("LPT1"),
|
|
TEXT("LPT2"),
|
|
TEXT("LPT3"),
|
|
TEXT("LPT4"),
|
|
TEXT("LPT5"),
|
|
TEXT("LPT6"),
|
|
TEXT("LPT7"),
|
|
TEXT("LPT8"),
|
|
TEXT("LPT9"),
|
|
TEXT("COM1"),
|
|
TEXT("COM2"),
|
|
TEXT("COM3"),
|
|
TEXT("COM4"),
|
|
TEXT("COM5"),
|
|
TEXT("COM6"),
|
|
TEXT("COM7"),
|
|
TEXT("COM8"),
|
|
TEXT("COM9")
|
|
};
|
|
|
|
TCHAR szComponent[MAX_PATH];
|
|
int nComponentLength;
|
|
LPCTSTR lpDot;
|
|
int i;
|
|
|
|
// A device name with an extension is also invalid
|
|
lpDot = _tcschr( lpComponent, '.' );
|
|
|
|
if ( !lpDot || lpDot > lpComponentEnd )
|
|
nComponentLength = lpComponentEnd - lpComponent;
|
|
else
|
|
nComponentLength = lpDot - lpComponent;
|
|
|
|
_tcsncpy( szComponent, lpComponent, nComponentLength );
|
|
szComponent[nComponentLength] = 0;
|
|
|
|
for ( i = 0; i < sizeof( alpDeviceNames ) / sizeof(LPCTSTR); i++ )
|
|
{
|
|
if ( 0 == _tcsicmp( szComponent, alpDeviceNames[i] ) )
|
|
{
|
|
lpComponentEnd = lpComponent;
|
|
fValid = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
if ( fValid )
|
|
{
|
|
// Empty components are not allowed
|
|
if ( lpComponentEnd - lpComponent < 1 )
|
|
fValid = FALSE;
|
|
|
|
// If we reached the end of the string NULL is returned
|
|
else if ( !*lpComponentEnd )
|
|
lpComponentEnd = NULL;
|
|
|
|
}
|
|
|
|
if ( lppComponentEnd )
|
|
*lppComponentEnd = lpComponentEnd;
|
|
|
|
return fValid;
|
|
}
|
|
|
|
//#####################################################
|
|
#define CHARSET_SEPARATOR TEXT("\\/")
|
|
|
|
DWORD IsValidFilePath(rtl_uString *path, LPCTSTR *lppError, DWORD dwFlags, rtl_uString **corrected)
|
|
{
|
|
LPCTSTR lpszPath = reinterpret_cast< LPCTSTR >(path->buffer);
|
|
LPCTSTR lpComponent = lpszPath;
|
|
BOOL fValid = TRUE;
|
|
DWORD dwPathType = PATHTYPE_ERROR;
|
|
sal_Int32 nLength = rtl_uString_getLength( path );
|
|
|
|
if ( dwFlags & VALIDATEPATH_ALLOW_RELATIVE )
|
|
dwFlags |= VALIDATEPATH_ALLOW_ELLIPSE;
|
|
|
|
if ( !lpszPath )
|
|
fValid = FALSE;
|
|
|
|
DWORD dwCandidatPathType = PATHTYPE_ERROR;
|
|
|
|
if ( 0 == rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( path->buffer, nLength, reinterpret_cast<const sal_Unicode *>(WSTR_LONG_PATH_PREFIX_UNC), ELEMENTS_OF_ARRAY(WSTR_LONG_PATH_PREFIX_UNC) - 1, ELEMENTS_OF_ARRAY(WSTR_LONG_PATH_PREFIX_UNC) - 1 ) )
|
|
{
|
|
/* This is long path in UNC notation */
|
|
lpComponent = lpszPath + ELEMENTS_OF_ARRAY(WSTR_LONG_PATH_PREFIX_UNC) - 1;
|
|
dwCandidatPathType = PATHTYPE_ABSOLUTE_UNC | PATHTYPE_IS_LONGPATH;
|
|
}
|
|
else if ( 0 == rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( path->buffer, nLength, reinterpret_cast<const sal_Unicode *>(WSTR_LONG_PATH_PREFIX), ELEMENTS_OF_ARRAY(WSTR_LONG_PATH_PREFIX) - 1, ELEMENTS_OF_ARRAY(WSTR_LONG_PATH_PREFIX) - 1 ) )
|
|
{
|
|
/* This is long path */
|
|
lpComponent = lpszPath + ELEMENTS_OF_ARRAY(WSTR_LONG_PATH_PREFIX) - 1;
|
|
|
|
if ( _istalpha( lpComponent[0] ) && ':' == lpComponent[1] )
|
|
{
|
|
lpComponent += 2;
|
|
dwCandidatPathType = PATHTYPE_ABSOLUTE_LOCAL | PATHTYPE_IS_LONGPATH;
|
|
}
|
|
}
|
|
else if ( 2 == _tcsspn( lpszPath, CHARSET_SEPARATOR ) )
|
|
{
|
|
/* The UNC path notation */
|
|
lpComponent = lpszPath + 2;
|
|
dwCandidatPathType = PATHTYPE_ABSOLUTE_UNC;
|
|
}
|
|
else if ( _istalpha( lpszPath[0] ) && ':' == lpszPath[1] )
|
|
{
|
|
/* Local path verification. Must start with <drive>: */
|
|
lpComponent = lpszPath + 2;
|
|
dwCandidatPathType = PATHTYPE_ABSOLUTE_LOCAL;
|
|
}
|
|
|
|
if ( ( dwCandidatPathType & PATHTYPE_MASK_TYPE ) == PATHTYPE_ABSOLUTE_UNC )
|
|
{
|
|
fValid = IsValidFilePathComponent( lpComponent, &lpComponent, VALIDATEPATH_ALLOW_ELLIPSE );
|
|
|
|
/* So far we have a valid servername. Now let's see if we also have a network resource */
|
|
|
|
dwPathType = dwCandidatPathType;
|
|
|
|
if ( fValid )
|
|
{
|
|
if ( lpComponent && !*++lpComponent )
|
|
lpComponent = NULL;
|
|
|
|
if ( !lpComponent )
|
|
{
|
|
#if 0
|
|
/* We only have a Server specification what is invalid */
|
|
|
|
lpComponent = lpszPath;
|
|
fValid = FALSE;
|
|
#else
|
|
dwPathType |= PATHTYPE_IS_SERVER;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
/* Now test the network resource */
|
|
|
|
fValid = IsValidFilePathComponent( lpComponent, &lpComponent, 0 );
|
|
|
|
/* If we now reached the end of the path, everything is O.K. */
|
|
|
|
|
|
if ( fValid && (!lpComponent || lpComponent && !*++lpComponent ) )
|
|
{
|
|
lpComponent = NULL;
|
|
dwPathType |= PATHTYPE_IS_VOLUME;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ( ( dwCandidatPathType & PATHTYPE_MASK_TYPE ) == PATHTYPE_ABSOLUTE_LOCAL )
|
|
{
|
|
if ( 1 == _tcsspn( lpComponent, CHARSET_SEPARATOR ) )
|
|
lpComponent++;
|
|
else if ( *lpComponent )
|
|
fValid = FALSE;
|
|
|
|
dwPathType = dwCandidatPathType;
|
|
|
|
/* Now we are behind the backslash or it was a simple drive without backslash */
|
|
|
|
if ( fValid && !*lpComponent )
|
|
{
|
|
lpComponent = NULL;
|
|
dwPathType |= PATHTYPE_IS_VOLUME;
|
|
}
|
|
}
|
|
else if ( dwFlags & VALIDATEPATH_ALLOW_RELATIVE )
|
|
{
|
|
/* Can be a relative path */
|
|
lpComponent = lpszPath;
|
|
|
|
/* Relative path can start with a backslash */
|
|
|
|
if ( 1 == _tcsspn( lpComponent, CHARSET_SEPARATOR ) )
|
|
{
|
|
lpComponent++;
|
|
if ( !*lpComponent )
|
|
lpComponent = NULL;
|
|
}
|
|
|
|
dwPathType = PATHTYPE_RELATIVE;
|
|
}
|
|
else
|
|
{
|
|
/* Anything else is an error */
|
|
fValid = FALSE;
|
|
lpComponent = lpszPath;
|
|
}
|
|
|
|
/* Now validate each component of the path */
|
|
while ( fValid && lpComponent )
|
|
{
|
|
// Correct path by merging consecutive slashes:
|
|
if (*lpComponent == '\\' && corrected != NULL) {
|
|
sal_Int32 i = lpComponent - lpszPath;
|
|
rtl_uString_newReplaceStrAt(corrected, path, i, 1, NULL);
|
|
//TODO: handle out-of-memory
|
|
lpszPath = reinterpret_cast< LPCTSTR >((*corrected)->buffer);
|
|
lpComponent = lpszPath + i;
|
|
}
|
|
|
|
fValid = IsValidFilePathComponent( lpComponent, &lpComponent, dwFlags );
|
|
|
|
if ( fValid && lpComponent )
|
|
{
|
|
lpComponent++;
|
|
|
|
/* If the string behind the backslash is empty, we've done */
|
|
|
|
if ( !*lpComponent )
|
|
lpComponent = NULL;
|
|
}
|
|
}
|
|
|
|
/* The path can be longer than MAX_PATH only in case it has the longpath prefix */
|
|
if ( fValid && !( dwPathType & PATHTYPE_IS_LONGPATH ) && _tcslen( lpszPath ) >= MAX_PATH )
|
|
{
|
|
fValid = FALSE;
|
|
lpComponent = lpszPath + MAX_PATH;
|
|
}
|
|
|
|
if ( lppError )
|
|
*lppError = lpComponent;
|
|
|
|
return fValid ? dwPathType : PATHTYPE_ERROR;
|
|
}
|
|
|
|
//#####################################################
|
|
static sal_Int32 PathRemoveFileSpec(LPTSTR lpPath, LPTSTR lpFileName, sal_Int32 nFileBufLen )
|
|
{
|
|
sal_Int32 nRemoved = 0;
|
|
|
|
if ( nFileBufLen )
|
|
{
|
|
lpFileName[0] = 0;
|
|
LPTSTR lpLastBkSlash = _tcsrchr( lpPath, '\\' );
|
|
LPTSTR lpLastSlash = _tcsrchr( lpPath, '/' );
|
|
LPTSTR lpLastDelimiter = lpLastSlash > lpLastBkSlash ? lpLastSlash : lpLastBkSlash;
|
|
|
|
if ( lpLastDelimiter )
|
|
{
|
|
sal_Int32 nDelLen = _tcslen( lpLastDelimiter );
|
|
if ( 1 == nDelLen )
|
|
{
|
|
if ( lpLastDelimiter > lpPath && *(lpLastDelimiter - 1) != ':' )
|
|
{
|
|
*lpLastDelimiter = 0;
|
|
*lpFileName = 0;
|
|
nRemoved = nDelLen;
|
|
}
|
|
}
|
|
else if ( nDelLen && nDelLen - 1 < nFileBufLen )
|
|
{
|
|
_tcscpy( lpFileName, lpLastDelimiter + 1 );
|
|
*(++lpLastDelimiter) = 0;
|
|
nRemoved = nDelLen - 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return nRemoved;
|
|
}
|
|
|
|
//#####################################################
|
|
// Undocumented in SHELL32.DLL ordinal 32
|
|
static LPTSTR PathAddBackslash(LPTSTR lpPath, sal_Int32 nBufLen)
|
|
{
|
|
LPTSTR lpEndPath = NULL;
|
|
|
|
if ( lpPath )
|
|
{
|
|
int nLen = _tcslen(lpPath);
|
|
|
|
if ( !nLen || lpPath[nLen-1] != '\\' && lpPath[nLen-1] != '/' && nLen < nBufLen - 1 )
|
|
{
|
|
lpEndPath = lpPath + nLen;
|
|
*lpEndPath++ = '\\';
|
|
*lpEndPath = 0;
|
|
}
|
|
}
|
|
return lpEndPath;
|
|
}
|
|
|
|
//#####################################################
|
|
// Same as GetLongPathName but also 95/NT4
|
|
static DWORD GetCaseCorrectPathNameEx(
|
|
LPTSTR lpszPath, // path buffer to convert
|
|
DWORD cchBuffer, // size of path buffer
|
|
DWORD nSkipLevels,
|
|
BOOL bCheckExistence )
|
|
{
|
|
::osl::LongPathBuffer< WCHAR > szFile( MAX_PATH + 1 );
|
|
sal_Int32 nRemoved = PathRemoveFileSpec( lpszPath, szFile, MAX_PATH + 1 );
|
|
sal_Int32 nLastStepRemoved = nRemoved;
|
|
while ( nLastStepRemoved && szFile[0] == 0 )
|
|
{
|
|
// remove separators
|
|
nLastStepRemoved = PathRemoveFileSpec( lpszPath, szFile, MAX_PATH + 1 );
|
|
nRemoved += nLastStepRemoved;
|
|
}
|
|
|
|
if ( nRemoved )
|
|
{
|
|
BOOL bSkipThis = FALSE;
|
|
|
|
if ( 0 == _tcscmp( szFile, TEXT("..") ) )
|
|
{
|
|
bSkipThis = TRUE;
|
|
nSkipLevels += 1;
|
|
}
|
|
else if ( 0 == _tcscmp( szFile, TEXT(".") ) )
|
|
{
|
|
bSkipThis = TRUE;
|
|
}
|
|
else if ( nSkipLevels )
|
|
{
|
|
bSkipThis = TRUE;
|
|
nSkipLevels--;
|
|
}
|
|
else
|
|
bSkipThis = FALSE;
|
|
|
|
GetCaseCorrectPathNameEx( lpszPath, cchBuffer, nSkipLevels, bCheckExistence );
|
|
|
|
PathAddBackslash( lpszPath, cchBuffer );
|
|
|
|
/* Analyze parent if not only a trailing backslash was cutted but a real file spec */
|
|
if ( !bSkipThis )
|
|
{
|
|
if ( bCheckExistence )
|
|
{
|
|
::osl::LongPathBuffer< WCHAR > aShortPath( MAX_LONG_PATH );
|
|
_tcscpy( aShortPath, lpszPath );
|
|
_tcscat( aShortPath, szFile );
|
|
|
|
WIN32_FIND_DATA aFindFileData;
|
|
HANDLE hFind = FindFirstFile( aShortPath, &aFindFileData );
|
|
|
|
if ( IsValidHandle(hFind) )
|
|
{
|
|
_tcscat( lpszPath, aFindFileData.cFileName[0] ? aFindFileData.cFileName : aFindFileData.cAlternateFileName );
|
|
|
|
FindClose( hFind );
|
|
}
|
|
else
|
|
lpszPath[0] = 0;
|
|
}
|
|
else
|
|
{
|
|
/* add the segment name back */
|
|
_tcscat( lpszPath, szFile );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* File specification can't be removed therefore the short path is either a drive
|
|
or a network share. If still levels to skip are left, the path specification
|
|
tries to travel below the file system root */
|
|
if ( nSkipLevels )
|
|
lpszPath[0] = 0;
|
|
else
|
|
_tcsupr( lpszPath );
|
|
}
|
|
|
|
return _tcslen( lpszPath );
|
|
}
|
|
|
|
//#####################################################
|
|
#define WSTR_SYSTEM_ROOT_PATH L"\\\\.\\"
|
|
|
|
DWORD GetCaseCorrectPathName(
|
|
LPCTSTR lpszShortPath, // file name
|
|
LPTSTR lpszLongPath, // path buffer
|
|
DWORD cchBuffer, // size of path buffer
|
|
BOOL bCheckExistence
|
|
)
|
|
{
|
|
/* Special handling for "\\.\" as system root */
|
|
if ( lpszShortPath && 0 == wcscmp( lpszShortPath, WSTR_SYSTEM_ROOT_PATH ) )
|
|
{
|
|
if ( cchBuffer >= ELEMENTS_OF_ARRAY(WSTR_SYSTEM_ROOT_PATH) )
|
|
{
|
|
wcscpy( lpszLongPath, WSTR_SYSTEM_ROOT_PATH );
|
|
return ELEMENTS_OF_ARRAY(WSTR_SYSTEM_ROOT_PATH) - 1;
|
|
}
|
|
else
|
|
{
|
|
return ELEMENTS_OF_ARRAY(WSTR_SYSTEM_ROOT_PATH) - 1;
|
|
}
|
|
}
|
|
else if ( lpszShortPath )
|
|
{
|
|
if ( _tcslen( lpszShortPath ) <= cchBuffer )
|
|
{
|
|
_tcscpy( lpszLongPath, lpszShortPath );
|
|
return GetCaseCorrectPathNameEx( lpszLongPath, cchBuffer, 0, bCheckExistence );
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
//#############################################
|
|
static sal_Bool _osl_decodeURL( rtl_String* strUTF8, rtl_uString** pstrDecodedURL )
|
|
{
|
|
sal_Char *pBuffer;
|
|
const sal_Char *pSrcEnd;
|
|
const sal_Char *pSrc;
|
|
sal_Char *pDest;
|
|
sal_Int32 nSrcLen;
|
|
sal_Bool bValidEncoded = sal_True; /* Assume success */
|
|
|
|
/* The resulting decoded string length is shorter or equal to the source length */
|
|
|
|
nSrcLen = rtl_string_getLength(strUTF8);
|
|
pBuffer = reinterpret_cast<sal_Char*>(rtl_allocateMemory(nSrcLen + 1));
|
|
|
|
pDest = pBuffer;
|
|
pSrc = rtl_string_getStr(strUTF8);
|
|
pSrcEnd = pSrc + nSrcLen;
|
|
|
|
/* Now decode the URL what should result in an UTF8 string */
|
|
while ( bValidEncoded && pSrc < pSrcEnd )
|
|
{
|
|
switch ( *pSrc )
|
|
{
|
|
case '%':
|
|
{
|
|
sal_Char aToken[3];
|
|
sal_Char aChar;
|
|
|
|
pSrc++;
|
|
aToken[0] = *pSrc++;
|
|
aToken[1] = *pSrc++;
|
|
aToken[2] = 0;
|
|
|
|
aChar = (sal_Char)strtoul( aToken, NULL, 16 );
|
|
|
|
/* The chars are path delimiters and must not be encoded */
|
|
|
|
if ( 0 == aChar || '\\' == aChar || '/' == aChar || ':' == aChar )
|
|
bValidEncoded = sal_False;
|
|
else
|
|
*pDest++ = aChar;
|
|
}
|
|
break;
|
|
default:
|
|
*pDest++ = *pSrc++;
|
|
break;
|
|
}
|
|
}
|
|
|
|
*pDest++ = 0;
|
|
|
|
if ( bValidEncoded )
|
|
{
|
|
rtl_string2UString( pstrDecodedURL, pBuffer, rtl_str_getLength(pBuffer), RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS );
|
|
OSL_ASSERT(*pstrDecodedURL != 0);
|
|
}
|
|
|
|
rtl_freeMemory( pBuffer );
|
|
|
|
return bValidEncoded;
|
|
}
|
|
|
|
//#############################################
|
|
static void _osl_encodeURL( rtl_uString *strURL, rtl_String **pstrEncodedURL )
|
|
{
|
|
/* Encode non ascii characters within the URL */
|
|
|
|
rtl_String *strUTF8 = NULL;
|
|
sal_Char *pszEncodedURL;
|
|
const sal_Char *pURLScan;
|
|
sal_Char *pURLDest;
|
|
sal_Int32 nURLScanLen;
|
|
sal_Int32 nURLScanCount;
|
|
|
|
rtl_uString2String( &strUTF8, rtl_uString_getStr( strURL ), rtl_uString_getLength( strURL ), RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS );
|
|
|
|
pszEncodedURL = (sal_Char*) rtl_allocateMemory( (rtl_string_getLength( strUTF8 ) * 3 + 1) * sizeof(sal_Char) );
|
|
|
|
pURLDest = pszEncodedURL;
|
|
pURLScan = rtl_string_getStr( strUTF8 );
|
|
nURLScanLen = rtl_string_getLength( strUTF8 );
|
|
nURLScanCount = 0;
|
|
|
|
while ( nURLScanCount < nURLScanLen )
|
|
{
|
|
sal_Char cCurrent = *pURLScan;
|
|
switch ( cCurrent )
|
|
{
|
|
default:
|
|
if (!( ( cCurrent >= 'a' && cCurrent <= 'z' ) || ( cCurrent >= 'A' && cCurrent <= 'Z' ) || ( cCurrent >= '0' && cCurrent <= '9' ) ) )
|
|
{
|
|
sprintf( pURLDest, "%%%02X", (unsigned char)cCurrent );
|
|
pURLDest += 3;
|
|
break;
|
|
}
|
|
case '!':
|
|
case '\'':
|
|
case '(':
|
|
case ')':
|
|
case '*':
|
|
case '-':
|
|
case '.':
|
|
case '_':
|
|
case '~':
|
|
case '$':
|
|
case '&':
|
|
case '+':
|
|
case ',':
|
|
case '=':
|
|
case '@':
|
|
case ':':
|
|
case '/':
|
|
case '\\':
|
|
case '|':
|
|
*pURLDest++ = cCurrent;
|
|
break;
|
|
case 0:
|
|
break;
|
|
}
|
|
|
|
pURLScan++;
|
|
nURLScanCount++;
|
|
}
|
|
|
|
*pURLDest = 0;
|
|
|
|
rtl_string_release( strUTF8 );
|
|
rtl_string_newFromStr( pstrEncodedURL, pszEncodedURL );
|
|
rtl_freeMemory( pszEncodedURL );
|
|
}
|
|
|
|
//#############################################
|
|
|
|
oslFileError _osl_getSystemPathFromFileURL( rtl_uString *strURL, rtl_uString **pustrPath, sal_Bool bAllowRelative )
|
|
{
|
|
rtl_String *strUTF8 = NULL;
|
|
rtl_uString *strDecodedURL = NULL;
|
|
rtl_uString *strTempPath = NULL;
|
|
const sal_Unicode *pDecodedURL;
|
|
sal_uInt32 nDecodedLen;
|
|
sal_Bool bValidEncoded;
|
|
oslFileError nError = osl_File_E_INVAL; /* Assume failure */
|
|
|
|
/* If someone hasn't encoded the complete URL we convert it to UTF8 now to prevent from
|
|
having a mixed encoded URL later */
|
|
|
|
rtl_uString2String( &strUTF8, rtl_uString_getStr( strURL ), rtl_uString_getLength( strURL ), RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS );
|
|
|
|
/* If the length of strUTF8 and strURL differs it indicates that the URL was not correct encoded */
|
|
|
|
OSL_ENSURE_FILE(
|
|
strUTF8->length == strURL->length ||
|
|
0 != rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( strURL->buffer, strURL->length, "file:\\\\", 7 )
|
|
,"osl_getSystemPathFromFileURL: \"%s\" is not encoded !!!", strURL );
|
|
|
|
bValidEncoded = _osl_decodeURL( strUTF8, &strDecodedURL );
|
|
|
|
/* Release the encoded UTF8 string */
|
|
rtl_string_release( strUTF8 );
|
|
|
|
if ( bValidEncoded )
|
|
{
|
|
/* Replace backslashes and pipes */
|
|
|
|
rtl_uString_newReplace( &strDecodedURL, strDecodedURL, '/', '\\' );
|
|
rtl_uString_newReplace( &strDecodedURL, strDecodedURL, '|', ':' );
|
|
|
|
pDecodedURL = rtl_uString_getStr( strDecodedURL );
|
|
nDecodedLen = rtl_uString_getLength( strDecodedURL );
|
|
|
|
/* Must start with "file://" */
|
|
if ( 0 == rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( pDecodedURL, nDecodedLen, "file:\\\\", 7 ) )
|
|
{
|
|
sal_uInt32 nSkip;
|
|
|
|
if ( 0 == rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( pDecodedURL, nDecodedLen, "file:\\\\\\", 8 ) )
|
|
nSkip = 8;
|
|
else if (
|
|
0 == rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( pDecodedURL, nDecodedLen, "file:\\\\localhost\\", 17 ) ||
|
|
0 == rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( pDecodedURL, nDecodedLen, "file:\\\\127.0.0.1\\", 17 )
|
|
)
|
|
nSkip = 17;
|
|
else
|
|
nSkip = 5;
|
|
|
|
/* Indicates local root */
|
|
if ( nDecodedLen == nSkip )
|
|
rtl_uString_newFromStr_WithLength( &strTempPath, reinterpret_cast<const sal_Unicode*>(WSTR_SYSTEM_ROOT_PATH), ELEMENTS_OF_ARRAY(WSTR_SYSTEM_ROOT_PATH) - 1 );
|
|
else
|
|
{
|
|
/* do not separate the directory and file case, so the maximal path lengs without prefix is MAX_PATH-12 */
|
|
if ( nDecodedLen - nSkip <= MAX_PATH - 12 )
|
|
{
|
|
rtl_uString_newFromStr_WithLength( &strTempPath, pDecodedURL + nSkip, nDecodedLen - nSkip );
|
|
}
|
|
else
|
|
{
|
|
::osl::LongPathBuffer< sal_Unicode > aBuf( MAX_LONG_PATH );
|
|
sal_uInt32 nNewLen = GetCaseCorrectPathName( reinterpret_cast<LPCTSTR>(pDecodedURL + nSkip),
|
|
::osl::mingw_reinterpret_cast<LPTSTR>(aBuf),
|
|
aBuf.getBufSizeInSymbols(),
|
|
sal_False );
|
|
|
|
if ( nNewLen <= MAX_PATH - 12
|
|
|| 0 == rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( pDecodedURL + nSkip, nDecodedLen - nSkip, reinterpret_cast<const sal_Unicode*>(WSTR_SYSTEM_ROOT_PATH), ELEMENTS_OF_ARRAY(WSTR_SYSTEM_ROOT_PATH) - 1, ELEMENTS_OF_ARRAY(WSTR_SYSTEM_ROOT_PATH) - 1 )
|
|
|| 0 == rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( pDecodedURL + nSkip, nDecodedLen - nSkip, reinterpret_cast<const sal_Unicode*>(WSTR_LONG_PATH_PREFIX), ELEMENTS_OF_ARRAY(WSTR_LONG_PATH_PREFIX) - 1, ELEMENTS_OF_ARRAY(WSTR_LONG_PATH_PREFIX) - 1 ) )
|
|
{
|
|
rtl_uString_newFromStr_WithLength( &strTempPath, aBuf, nNewLen );
|
|
}
|
|
else if ( pDecodedURL[nSkip] == (sal_Unicode)'\\' && pDecodedURL[nSkip+1] == (sal_Unicode)'\\' )
|
|
{
|
|
/* it should be an UNC path, use the according prefix */
|
|
rtl_uString *strSuffix = NULL;
|
|
rtl_uString *strPrefix = NULL;
|
|
rtl_uString_newFromStr_WithLength( &strPrefix, reinterpret_cast<const sal_Unicode*>(WSTR_LONG_PATH_PREFIX_UNC), ELEMENTS_OF_ARRAY( WSTR_LONG_PATH_PREFIX_UNC ) - 1 );
|
|
rtl_uString_newFromStr_WithLength( &strSuffix, aBuf + 2, nNewLen - 2 );
|
|
|
|
rtl_uString_newConcat( &strTempPath, strPrefix, strSuffix );
|
|
|
|
rtl_uString_release( strPrefix );
|
|
rtl_uString_release( strSuffix );
|
|
}
|
|
else
|
|
{
|
|
rtl_uString *strSuffix = NULL;
|
|
rtl_uString *strPrefix = NULL;
|
|
rtl_uString_newFromStr_WithLength( &strPrefix, reinterpret_cast<const sal_Unicode*>(WSTR_LONG_PATH_PREFIX), ELEMENTS_OF_ARRAY( WSTR_LONG_PATH_PREFIX ) - 1 );
|
|
rtl_uString_newFromStr_WithLength( &strSuffix, aBuf, nNewLen );
|
|
|
|
rtl_uString_newConcat( &strTempPath, strPrefix, strSuffix );
|
|
|
|
rtl_uString_release( strPrefix );
|
|
rtl_uString_release( strSuffix );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( IsValidFilePath( strTempPath, NULL, VALIDATEPATH_ALLOW_ELLIPSE, &strTempPath ) )
|
|
nError = osl_File_E_None;
|
|
}
|
|
else if ( bAllowRelative ) /* This maybe a relative file URL */
|
|
{
|
|
/* In future the relative path could be converted to absolute if it is too long */
|
|
rtl_uString_assign( &strTempPath, strDecodedURL );
|
|
|
|
if ( IsValidFilePath( strTempPath, NULL, VALIDATEPATH_ALLOW_RELATIVE | VALIDATEPATH_ALLOW_ELLIPSE, &strTempPath ) )
|
|
nError = osl_File_E_None;
|
|
}
|
|
/*
|
|
else
|
|
OSL_ENSURE_FILE( !nError, "osl_getSystemPathFromFileURL: \"%s\" is not an absolute FileURL !!!", strURL );
|
|
*/
|
|
|
|
}
|
|
|
|
if ( strDecodedURL )
|
|
rtl_uString_release( strDecodedURL );
|
|
|
|
if ( osl_File_E_None == nError )
|
|
rtl_uString_assign( pustrPath, strTempPath );
|
|
|
|
if ( strTempPath )
|
|
rtl_uString_release( strTempPath );
|
|
|
|
/*
|
|
OSL_ENSURE_FILE( !nError, "osl_getSystemPathFromFileURL: \"%s\" is not a FileURL !!!", strURL );
|
|
*/
|
|
|
|
return nError;
|
|
}
|
|
|
|
//#############################################
|
|
oslFileError _osl_getFileURLFromSystemPath( rtl_uString* strPath, rtl_uString** pstrURL )
|
|
{
|
|
oslFileError nError = osl_File_E_INVAL; /* Assume failure */
|
|
rtl_uString *strTempURL = NULL;
|
|
DWORD dwPathType = PATHTYPE_ERROR;
|
|
|
|
if (strPath)
|
|
dwPathType = IsValidFilePath(strPath, NULL, VALIDATEPATH_ALLOW_RELATIVE, NULL);
|
|
|
|
if (dwPathType)
|
|
{
|
|
rtl_uString *strTempPath = NULL;
|
|
|
|
if ( dwPathType & PATHTYPE_IS_LONGPATH )
|
|
{
|
|
rtl_uString *strBuffer = NULL;
|
|
sal_uInt32 nIgnore = 0;
|
|
sal_uInt32 nLength = 0;
|
|
|
|
/* the path has the longpath prefix, lets remove it */
|
|
switch ( dwPathType & PATHTYPE_MASK_TYPE )
|
|
{
|
|
case PATHTYPE_ABSOLUTE_UNC:
|
|
nIgnore = ELEMENTS_OF_ARRAY( WSTR_LONG_PATH_PREFIX_UNC ) - 1;
|
|
OSL_ENSURE( nIgnore == 8, "Unexpected long path UNC prefix!" );
|
|
|
|
/* generate the normal UNC path */
|
|
nLength = rtl_uString_getLength( strPath );
|
|
rtl_uString_newFromStr_WithLength( &strBuffer, strPath->buffer + nIgnore - 2, nLength - nIgnore + 2 );
|
|
strBuffer->buffer[0] = '\\';
|
|
|
|
rtl_uString_newReplace( &strTempPath, strBuffer, '\\', '/' );
|
|
rtl_uString_release( strBuffer );
|
|
break;
|
|
|
|
case PATHTYPE_ABSOLUTE_LOCAL:
|
|
nIgnore = ELEMENTS_OF_ARRAY( WSTR_LONG_PATH_PREFIX ) - 1;
|
|
OSL_ENSURE( nIgnore == 4, "Unexpected long path prefix!" );
|
|
|
|
/* generate the normal path */
|
|
nLength = rtl_uString_getLength( strPath );
|
|
rtl_uString_newFromStr_WithLength( &strBuffer, strPath->buffer + nIgnore, nLength - nIgnore );
|
|
|
|
rtl_uString_newReplace( &strTempPath, strBuffer, '\\', '/' );
|
|
rtl_uString_release( strBuffer );
|
|
break;
|
|
|
|
default:
|
|
OSL_ASSERT( "Unexpected long path format!" );
|
|
rtl_uString_newReplace( &strTempPath, strPath, '\\', '/' );
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Replace backslashes */
|
|
rtl_uString_newReplace( &strTempPath, strPath, '\\', '/' );
|
|
}
|
|
|
|
switch ( dwPathType & PATHTYPE_MASK_TYPE )
|
|
{
|
|
case PATHTYPE_RELATIVE:
|
|
rtl_uString_assign( &strTempURL, strTempPath );
|
|
nError = osl_File_E_None;
|
|
break;
|
|
case PATHTYPE_ABSOLUTE_UNC:
|
|
rtl_uString_newFromAscii( &strTempURL, "file:" );
|
|
rtl_uString_newConcat( &strTempURL, strTempURL, strTempPath );
|
|
nError = osl_File_E_None;
|
|
break;
|
|
case PATHTYPE_ABSOLUTE_LOCAL:
|
|
rtl_uString_newFromAscii( &strTempURL, "file:///" );
|
|
rtl_uString_newConcat( &strTempURL, strTempURL, strTempPath );
|
|
nError = osl_File_E_None;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/* Release temp path */
|
|
rtl_uString_release( strTempPath );
|
|
}
|
|
|
|
if ( osl_File_E_None == nError )
|
|
{
|
|
rtl_String *strEncodedURL = NULL;
|
|
|
|
/* Encode the URL */
|
|
_osl_encodeURL( strTempURL, &strEncodedURL );
|
|
|
|
/* Provide URL via unicode string */
|
|
rtl_string2UString( pstrURL, rtl_string_getStr(strEncodedURL), rtl_string_getLength(strEncodedURL), RTL_TEXTENCODING_ASCII_US, OUSTRING_TO_OSTRING_CVTFLAGS );
|
|
OSL_ASSERT(*pstrURL != 0);
|
|
rtl_string_release( strEncodedURL );
|
|
}
|
|
|
|
/* Release temp URL */
|
|
if ( strTempURL )
|
|
rtl_uString_release( strTempURL );
|
|
|
|
/*
|
|
OSL_ENSURE_FILE( !nError, "osl_getFileURLFromSystemPath: \"%s\" is not a systemPath !!!", strPath );
|
|
*/
|
|
return nError;
|
|
}
|
|
|
|
//#####################################################
|
|
oslFileError SAL_CALL osl_getFileURLFromSystemPath(
|
|
rtl_uString* ustrPath, rtl_uString** pustrURL )
|
|
{
|
|
return _osl_getFileURLFromSystemPath( ustrPath, pustrURL );
|
|
}
|
|
|
|
//#####################################################
|
|
oslFileError SAL_CALL osl_getSystemPathFromFileURL(
|
|
rtl_uString *ustrURL, rtl_uString **pustrPath)
|
|
{
|
|
return _osl_getSystemPathFromFileURL( ustrURL, pustrPath, sal_True );
|
|
}
|
|
|
|
//#####################################################
|
|
oslFileError SAL_CALL osl_searchFileURL(
|
|
rtl_uString *ustrFileName,
|
|
rtl_uString *ustrSystemSearchPath,
|
|
rtl_uString **pustrPath)
|
|
{
|
|
rtl_uString *ustrUNCPath = NULL;
|
|
rtl_uString *ustrSysPath = NULL;
|
|
oslFileError error;
|
|
|
|
/* First try to interpret the file name as an URL even a relative one */
|
|
error = _osl_getSystemPathFromFileURL( ustrFileName, &ustrUNCPath, sal_True );
|
|
|
|
/* So far we either have an UNC path or something invalid
|
|
Now create a system path */
|
|
if ( osl_File_E_None == error )
|
|
error = _osl_getSystemPathFromFileURL( ustrUNCPath, &ustrSysPath, sal_True );
|
|
|
|
if ( osl_File_E_None == error )
|
|
{
|
|
DWORD nBufferLength;
|
|
DWORD dwResult;
|
|
LPTSTR lpBuffer = NULL;
|
|
LPTSTR lpszFilePart;
|
|
|
|
/* Repeat calling SearchPath ...
|
|
Start with MAX_PATH for the buffer. In most cases this
|
|
will be enough and does not force the loop to runtwice */
|
|
dwResult = MAX_PATH;
|
|
|
|
do
|
|
{
|
|
/* If search path is empty use a NULL pointer instead according to MSDN documentation of SearchPath */
|
|
LPCTSTR lpszSearchPath = ustrSystemSearchPath && ustrSystemSearchPath->length ? reinterpret_cast<LPCTSTR>(ustrSystemSearchPath->buffer) : NULL;
|
|
LPCTSTR lpszSearchFile = reinterpret_cast<LPCTSTR>(ustrSysPath->buffer);
|
|
|
|
/* Allocate space for buffer according to previous returned count of required chars */
|
|
/* +1 is not neccessary if we follow MSDN documentation but for robustness we do so */
|
|
nBufferLength = dwResult + 1;
|
|
lpBuffer = lpBuffer ?
|
|
reinterpret_cast<LPTSTR>(rtl_reallocateMemory(lpBuffer, nBufferLength * sizeof(TCHAR))) :
|
|
reinterpret_cast<LPTSTR>(rtl_allocateMemory(nBufferLength * sizeof(TCHAR)));
|
|
|
|
dwResult = SearchPath( lpszSearchPath, lpszSearchFile, NULL, nBufferLength, lpBuffer, &lpszFilePart );
|
|
} while ( dwResult && dwResult >= nBufferLength );
|
|
|
|
/* ... until an error occures or buffer is large enough.
|
|
dwResult == nBufferLength can not happen according to documentation but lets be robust ;-) */
|
|
|
|
if ( dwResult )
|
|
{
|
|
rtl_uString_newFromStr( &ustrSysPath, reinterpret_cast<const sal_Unicode*>(lpBuffer) );
|
|
error = osl_getFileURLFromSystemPath( ustrSysPath, pustrPath );
|
|
}
|
|
else
|
|
{
|
|
WIN32_FIND_DATA aFindFileData;
|
|
HANDLE hFind;
|
|
|
|
/* Somthing went wrong, perhaps the path was absolute */
|
|
error = oslTranslateFileError( GetLastError() );
|
|
|
|
hFind = FindFirstFile( reinterpret_cast<LPCTSTR>(ustrSysPath->buffer), &aFindFileData );
|
|
|
|
if ( IsValidHandle(hFind) )
|
|
{
|
|
error = osl_getFileURLFromSystemPath( ustrSysPath, pustrPath );
|
|
FindClose( hFind );
|
|
}
|
|
}
|
|
|
|
rtl_freeMemory( lpBuffer );
|
|
}
|
|
|
|
if ( ustrSysPath )
|
|
rtl_uString_release( ustrSysPath );
|
|
|
|
if ( ustrUNCPath )
|
|
rtl_uString_release( ustrUNCPath );
|
|
|
|
return error;
|
|
}
|
|
|
|
//#####################################################
|
|
|
|
oslFileError SAL_CALL osl_getAbsoluteFileURL( rtl_uString* ustrBaseURL, rtl_uString* ustrRelativeURL, rtl_uString** pustrAbsoluteURL )
|
|
{
|
|
oslFileError eError;
|
|
rtl_uString *ustrRelSysPath = NULL;
|
|
rtl_uString *ustrBaseSysPath = NULL;
|
|
|
|
if ( ustrBaseURL && ustrBaseURL->length )
|
|
{
|
|
eError = _osl_getSystemPathFromFileURL( ustrBaseURL, &ustrBaseSysPath, sal_False );
|
|
OSL_ENSURE( osl_File_E_None == eError, "osl_getAbsoluteFileURL called with relative or invalid base URL" );
|
|
|
|
eError = _osl_getSystemPathFromFileURL( ustrRelativeURL, &ustrRelSysPath, sal_True );
|
|
}
|
|
else
|
|
{
|
|
eError = _osl_getSystemPathFromFileURL( ustrRelativeURL, &ustrRelSysPath, sal_False );
|
|
OSL_ENSURE( osl_File_E_None == eError, "osl_getAbsoluteFileURL called with empty base URL and/or invalid relative URL" );
|
|
}
|
|
|
|
if ( !eError )
|
|
{
|
|
::osl::LongPathBuffer< sal_Unicode > aBuffer( MAX_LONG_PATH );
|
|
::osl::LongPathBuffer< sal_Unicode > aCurrentDir( MAX_LONG_PATH );
|
|
LPTSTR lpFilePart = NULL;
|
|
DWORD dwResult;
|
|
|
|
/*@@@ToDo
|
|
Bad, bad hack, this only works if the base path
|
|
really exists which is not necessary according
|
|
to RFC2396
|
|
The whole FileURL implementation should be merged
|
|
with the rtl/uri class.
|
|
*/
|
|
if ( ustrBaseSysPath )
|
|
{
|
|
osl_acquireMutex( g_CurrentDirectoryMutex );
|
|
|
|
GetCurrentDirectoryW( aCurrentDir.getBufSizeInSymbols(), ::osl::mingw_reinterpret_cast<LPWSTR>(aCurrentDir) );
|
|
SetCurrentDirectoryW( reinterpret_cast<LPCWSTR>(ustrBaseSysPath->buffer) );
|
|
}
|
|
|
|
dwResult = GetFullPathNameW( reinterpret_cast<LPCWSTR>(ustrRelSysPath->buffer), aBuffer.getBufSizeInSymbols(), ::osl::mingw_reinterpret_cast<LPWSTR>(aBuffer), &lpFilePart );
|
|
|
|
if ( ustrBaseSysPath )
|
|
{
|
|
SetCurrentDirectoryW( ::osl::mingw_reinterpret_cast<LPCWSTR>(aCurrentDir) );
|
|
|
|
osl_releaseMutex( g_CurrentDirectoryMutex );
|
|
}
|
|
|
|
if ( dwResult )
|
|
{
|
|
if ( dwResult >= aBuffer.getBufSizeInSymbols() )
|
|
eError = osl_File_E_INVAL;
|
|
else
|
|
{
|
|
rtl_uString *ustrAbsSysPath = NULL;
|
|
|
|
rtl_uString_newFromStr( &ustrAbsSysPath, aBuffer );
|
|
|
|
eError = osl_getFileURLFromSystemPath( ustrAbsSysPath, pustrAbsoluteURL );
|
|
|
|
if ( ustrAbsSysPath )
|
|
rtl_uString_release( ustrAbsSysPath );
|
|
}
|
|
}
|
|
else
|
|
eError = oslTranslateFileError( GetLastError() );
|
|
}
|
|
|
|
if ( ustrBaseSysPath )
|
|
rtl_uString_release( ustrBaseSysPath );
|
|
|
|
if ( ustrRelSysPath )
|
|
rtl_uString_release( ustrRelSysPath );
|
|
|
|
return eError;
|
|
}
|
|
|
|
//#####################################################
|
|
oslFileError SAL_CALL osl_getCanonicalName( rtl_uString *strRequested, rtl_uString **strValid )
|
|
{
|
|
rtl_uString_newFromString(strValid, strRequested);
|
|
return osl_File_E_None;
|
|
}
|