| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the 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; |
| } |
