sal/osl/os2/file_url.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: file_url.cxx,v $
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include <ctype.h>
  32 #include "system.h"
  33
  34 #ifndef _LIMITS_H
  35 #include <limits.h>
  36 #endif
  37
  38 #ifndef _ERRNO_H
  39 #include <errno.h>
  40 #endif
  41
  42 #ifndef _STDLIB_H_
  43 #include <stdlib.h>
  44 #endif
  45
  46 #ifndef _STRINGS_H
  47 #include <strings.h>
  48 #endif
  49
  50 #ifndef _UNISTD_H
  51 #include <unistd.h>
  52 #endif
  53 #include <osl/file.h>
  54 #include <osl/security.h>
  55 #include <rtl/uri.h>
  56 #include <osl/diagnose.h>
  57 #include <rtl/ustring.hxx>
  58 #include <rtl/ustrbuf.h>
  59
  60 #ifndef _OSL_TREAD_H_
  61 #include <osl/thread.h>
  62 #endif
  63 #include <osl/file.hxx>
  64 #include <osl/mutex.h>
  65 #include <osl/process.h>
  66 #include "file_error_transl.h"
  67
  68 #ifndef _FILE_URL_H_
  69 #include "file_url.h"
  70 #endif
  71 #include "file_path_helper.hxx"
  72
  73 #ifndef _OSL_UUNXAPI_HXX_
  74 #include "uunxapi.hxx"
  75 #endif
  76
  77 #include <wchar.h>
  78 #include <wctype.h>
  79
  80 /***************************************************
  81
  82  General note
  83
  84  This file contains the part that handles File URLs.
  85
  86  File URLs as scheme specific notion of URIs
  87  (RFC2396) may be handled platform independend, but
  88  will not in osl which is considered wrong.
  89  Future version of osl should handle File URLs this
  90  way. In rtl/uri there is already an URI parser etc.
  91  so this code should be consolidated.
  92
  93  **************************************************/
  94
  95 oslMutex g_CurrentDirectoryMutex;
  96
  97
  98 /***************************************************
  99  * forward
 100  **************************************************/
 101
 102 void _osl_warnFile(const char*, rtl_uString*);
 103 rtl_uString*  oslMakeUStrFromPsz(const sal_Char* pszStr,rtl_uString** uStr);
 104
 105 extern "C" int UnicodeToText(char *, size_t, const sal_Unicode *, sal_Int32);
 106 extern "C" int TextToUnicode(const char* text, size_t text_buffer_size, sal_Unicode* unic_text, sal_Int32 unic_text_buffer_size);
 107
 108 /***************************************************
 109  * namespace directives
 110  **************************************************/
 111
 112 using namespace osl;
 113
 114 /******************************************************************************
 115  *
 116  *                  Exported Module Functions
 117  *
 118  *****************************************************************************/
 119
 120 /* a slightly modified version of Pchar in rtl/source/uri.c */
 121 const sal_Bool uriCharClass[128] =
 122 {
 123   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Pchar but without encoding slashes */
 124   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 125   0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* !"#$%&'()*+,-./  */
 126   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, /* 0123456789:;<=>? */
 127   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* @ABCDEFGHIJKLMNO */
 128   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* PQRSTUVWXYZ[\]^_ */
 129   0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* `abcdefghijklmno */
 130   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0  /* pqrstuvwxyz{|}~  */
 131 };
 132
 133
 134 /* check for top wrong usage strings */
 135 /*
 136 static sal_Bool findWrongUsage( const sal_Unicode *path, sal_Int32 len )
 137 {
 138     rtl_uString *pTmp = NULL;
 139     sal_Bool bRet;
 140
 141     rtl_uString_newFromStr_WithLength( &pTmp, path, len );
 142
 143     rtl_ustr_toAsciiLowerCase_WithLength( pTmp->buffer, pTmp->length );
 144
 145     bRet = ( 0 == rtl_ustr_ascii_shortenedCompare_WithLength( pTmp->buffer, pTmp->length, "ftp://", 6 ) ) ||
 146            ( 0 == rtl_ustr_ascii_shortenedCompare_WithLength( pTmp->buffer, pTmp->length, "http://", 7 ) ) ||
 147            ( 0 == rtl_ustr_ascii_shortenedCompare_WithLength( pTmp->buffer, pTmp->length, "vnd.sun.star", 12 ) ) ||
 148            ( 0 == rtl_ustr_ascii_shortenedCompare_WithLength( pTmp->buffer, pTmp->length, "private:", 8 ) ) ||
 149            ( 0 == rtl_ustr_ascii_shortenedCompare_WithLength( pTmp->buffer, pTmp->length, "slot:", 5) );
 150
 151     rtl_uString_release( pTmp );
 152     return bRet;
 153 }
 154 */
 155
 156
 157 /****************************************************************************/
 158 /*      osl_getFileURLFromSystemPath */
 159 /****************************************************************************/
 160
 161 BOOL WINAPI IsValidFilePathComponent(
 162     LPCTSTR lpComponent, LPCTSTR *lppComponentEnd, DWORD dwFlags)
 163 {
 164     LPCTSTR     lpComponentEnd = NULL;
 165     LPCTSTR     lpCurrent = lpComponent;
 166     BOOL        fValid = TRUE;  /* Assume success */
 167     TCHAR       cLast = 0;
 168
 169     /* Path component length must not exceed MAX_PATH */
 170
 171     while ( !lpComponentEnd && lpCurrent && lpCurrent - lpComponent < _MAX_PATH )
 172     {
 173         switch ( *lpCurrent )
 174         {
 175             /* Both backslash and slash determine the end of a path component */
 176         case '\0':
 177         case '/':
 178         case '\\':
 179             switch ( cLast )
 180             {
 181                 /* Component must not end with '.' or blank and can't be empty */
 182
 183             case '.':
 184                 if ( dwFlags & VALIDATEPATH_ALLOW_ELLIPSE )
 185                 {
 186                     if ( 1 == lpCurrent - lpComponent )
 187                     {
 188                         /* Current directory is O.K. */
 189                         lpComponentEnd = lpCurrent;
 190                         break;
 191                     }
 192                     else if ( 2 == lpCurrent - lpComponent && '.' == *lpComponent )
 193                     {
 194                         /* Parent directory is O.K. */
 195                         lpComponentEnd = lpCurrent;
 196                         break;
 197                     }
 198                 }
 199             case 0:
 200             case ' ':
 201                 lpComponentEnd = lpCurrent - 1;
 202                 fValid = FALSE;
 203                 break;
 204             default:
 205                 lpComponentEnd = lpCurrent;
 206                 break;
 207             }
 208             break;
 209             /* '?' and '*' are valid wildcards but not valid file name characters */
 210         case '?':
 211         case '*':
 212             if ( dwFlags & VALIDATEPATH_ALLOW_WILDCARDS )
 213                 break;
 214             /* The following characters are reserved */
 215         case '<':
 216         case '>':
 217         case '\"':
 218         case '|':
 219         case ':':
 220             lpComponentEnd = lpCurrent;
 221             fValid = FALSE;
 222             break;
 223         default:
 224             /* Characters below ASCII 32 are not allowed */
 225             if ( *lpCurrent < ' ' )
 226             {
 227                 lpComponentEnd = lpCurrent;
 228                 fValid = FALSE;
 229             }
 230             break;
 231         }
 232         cLast = *lpCurrent++;
 233     }
 234
 235     /*  If we don't reached the end of the component the length of the component was to long
 236         ( See condition of while loop ) */
 237     if ( !lpComponentEnd )
 238     {
 239         fValid = FALSE;
 240         lpComponentEnd = lpCurrent;
 241     }
 242
 243     /* Test wether the component specifies a device name what is not allowed */
 244
 245     // MT: PERFORMANCE:
 246     // This is very expensive. A lot of calls to _tcsicmp.
 247     // in SRC6870m71 67.000 calls of this method while empty office start result into more than 1.500.00 calls of _tcsicmp!
 248     // Possible optimizations
 249     // - Array should be const static
 250     // - Sorted array, use binary search
 251     // - More intelligent check for com1-9, lpt1-9
 252     // Maybe make szComponent upper case, don't search case intensitive
 253     // 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.
 254     /*
 255     if ( fValid )
 256     {
 257         LPCTSTR alpDeviceNames[] =
 258         {
 259             TEXT("CON"),
 260             TEXT("PRN"),
 261             TEXT("AUX"),
 262             TEXT("CLOCK$"),
 263             TEXT("NUL"),
 264             TEXT("LPT1"),
 265             TEXT("LPT2"),
 266             TEXT("LPT3"),
 267             TEXT("LPT4"),
 268             TEXT("LPT5"),
 269             TEXT("LPT6"),
 270             TEXT("LPT7"),
 271             TEXT("LPT8"),
 272             TEXT("LPT9"),
 273             TEXT("COM1"),
 274             TEXT("COM2"),
 275             TEXT("COM3"),
 276             TEXT("COM4"),
 277             TEXT("COM5"),
 278             TEXT("COM6"),
 279             TEXT("COM7"),
 280             TEXT("COM8"),
 281             TEXT("COM9")
 282         };
 283
 284         TCHAR   szComponent[MAX_PATH];
 285         int             nComponentLength;
 286         LPCTSTR lpDot;
 287         int             i;
 288
 289         // A device name with an extension is also invalid
 290         lpDot = _tcschr( lpComponent, '.' );
 291
 292         if ( !lpDot || lpDot > lpComponentEnd )
 293             nComponentLength = lpComponentEnd - lpComponent;
 294         else
 295             nComponentLength = lpDot - lpComponent;
 296
 297         _tcsncpy( szComponent, lpComponent, nComponentLength );
 298         szComponent[nComponentLength] = 0;
 299
 300         for ( i = 0; i < sizeof( alpDeviceNames ) / sizeof(LPCTSTR); i++ )
 301         {
 302             if ( 0 == _tcsicmp( szComponent, alpDeviceNames[i] ) )
 303             {
 304                 lpComponentEnd = lpComponent;
 305                 fValid = FALSE;
 306                 break;
 307             }
 308         }
 309     }
 310     */
 311
 312     if ( fValid )
 313     {
 314         // Empty components are not allowed
 315         if ( lpComponentEnd - lpComponent < 1 )
 316             fValid = FALSE;
 317
 318         // If we reached the end of the string NULL is returned
 319         else if ( !*lpComponentEnd )
 320             lpComponentEnd = NULL;
 321
 322     }
 323
 324     if ( lppComponentEnd )
 325         *lppComponentEnd = lpComponentEnd;
 326
 327     return fValid;
 328 }
 329
 330 //#####################################################
 331 DWORD WINAPI IsValidFilePath(LPCTSTR lpszPath, LPCTSTR *lppError, DWORD dwFlags)
 332 {
 333     LPCTSTR     lpComponent;
 334     BOOL        fValid = TRUE;
 335     DWORD       dwPathType = PATHTYPE_ERROR;
 336
 337     if ( dwFlags & VALIDATEPATH_ALLOW_RELATIVE )
 338         dwFlags |= VALIDATEPATH_ALLOW_ELLIPSE;
 339
 340     if ( !lpszPath )
 341     {
 342         fValid = FALSE;
 343         lpComponent = lpszPath;
 344     }
 345
 346     /* Test for UNC path notation */
 347     if ( 2 == _tcsspn( lpszPath, CHARSET_SEPARATOR ) )
 348     {
 349         /* Place the pointer behind the leading to backslashes */
 350
 351         lpComponent = lpszPath + 2;
 352
 353         fValid = IsValidFilePathComponent( lpComponent, &lpComponent, VALIDATEPATH_ALLOW_ELLIPSE );
 354
 355         /* So far we have a valid servername. Now let's see if we also have a network resource */
 356
 357         dwPathType = PATHTYPE_ABSOLUTE_UNC;
 358
 359         if ( fValid )
 360         {
 361             if ( lpComponent &&  !*++lpComponent )
 362                 lpComponent = NULL;
 363
 364             if ( !lpComponent )
 365             {
 366 #if 0
 367                 /* We only have a Server specification what is invalid */
 368
 369                 lpComponent = lpszPath;
 370                 fValid = FALSE;
 371 #else
 372                 dwPathType |= PATHTYPE_IS_SERVER;
 373 #endif
 374             }
 375             else
 376             {
 377                 /* Now test the network resource */
 378
 379                 fValid = IsValidFilePathComponent( lpComponent, &lpComponent, 0 );
 380
 381                 /* If we now reached the end of the path, everything is O.K. */
 382
 383
 384                 if ( fValid && (!lpComponent || lpComponent && !*++lpComponent ) )
 385                 {
 386                     lpComponent = NULL;
 387                     dwPathType |= PATHTYPE_IS_VOLUME;
 388                 }
 389             }
 390         }
 391     }
 392
 393     /* Local path verification. Must start with <drive>: */
 394     else if ( _istalpha( lpszPath[0] ) && ':' == lpszPath[1] )
 395     {
 396         /* Place pointer behind correct drive specification */
 397
 398         lpComponent = lpszPath + 2;
 399
 400         if ( 1 == _tcsspn( lpComponent, CHARSET_SEPARATOR ) )
 401             lpComponent++;
 402         else if ( *lpComponent )
 403             fValid = FALSE;
 404
 405         dwPathType = PATHTYPE_ABSOLUTE_LOCAL;
 406
 407         /* Now we are behind the backslash or it was a simple drive without backslash */
 408
 409         if ( fValid && !*lpComponent )
 410         {
 411             lpComponent = NULL;
 412             dwPathType |= PATHTYPE_IS_VOLUME;
 413         }
 414     }
 415
 416     /* Can be a relative path */
 417     else if ( dwFlags & VALIDATEPATH_ALLOW_RELATIVE )
 418     {
 419         lpComponent = lpszPath;
 420
 421         /* Relative path can start with a backslash */
 422
 423         if ( 1 == _tcsspn( lpComponent, CHARSET_SEPARATOR ) )
 424         {
 425             lpComponent++;
 426             if ( !*lpComponent )
 427                 lpComponent = NULL;
 428         }
 429
 430         dwPathType = PATHTYPE_RELATIVE;
 431     }
 432
 433     /* Anything else is an error */
 434     else
 435     {
 436         fValid = FALSE;
 437         lpComponent = lpszPath;
 438     }
 439
 440     /* Now validate each component of the path */
 441     while ( fValid && lpComponent )
 442     {
 443         fValid = IsValidFilePathComponent( lpComponent, &lpComponent, dwFlags );
 444
 445         if ( fValid && lpComponent )
 446         {
 447             lpComponent++;
 448
 449             /* If the string behind the backslash is empty, we've done */
 450
 451             if ( !*lpComponent )
 452                 lpComponent = NULL;
 453         }
 454     }
 455
 456     if ( fValid && _tcslen( lpszPath ) >= _MAX_PATH )
 457     {
 458         fValid = FALSE;
 459         lpComponent = lpszPath + _MAX_PATH;
 460     }
 461
 462     if ( lppError )
 463         *lppError = lpComponent;
 464
 465     return fValid ? dwPathType : PATHTYPE_ERROR;
 466 }
 467
 468 sal_Bool _osl_decodeURL( rtl_String* strUTF8, rtl_uString** pstrDecodedURL )
 469 {
 470     sal_Char            *pBuffer;
 471     const sal_Char      *pSrcEnd;
 472     const sal_Char      *pSrc;
 473     sal_Char            *pDest;
 474     sal_Int32           nSrcLen;
 475     sal_Bool            bValidEncoded = sal_True;       /* Assume success */
 476
 477     /* The resulting decoded string length is shorter or equal to the source length */
 478
 479     nSrcLen = rtl_string_getLength(strUTF8);
 480     pBuffer = reinterpret_cast<sal_Char*>(rtl_allocateMemory(nSrcLen + 1));
 481
 482     pDest = pBuffer;
 483     pSrc = rtl_string_getStr(strUTF8);
 484     pSrcEnd = pSrc + nSrcLen;
 485
 486     /* Now decode the URL what should result in an UTF8 string */
 487     while ( bValidEncoded && pSrc < pSrcEnd )
 488     {
 489         switch ( *pSrc )
 490         {
 491         case '%':
 492             {
 493                 sal_Char        aToken[3];
 494                 sal_Char        aChar;
 495
 496                 pSrc++;
 497                 aToken[0] = *pSrc++;
 498                 aToken[1] = *pSrc++;
 499                 aToken[2] = 0;
 500
 501                 aChar = (sal_Char)strtoul( aToken, NULL, 16 );
 502
 503                 /* The chars are path delimiters and must not be encoded */
 504
 505                 if ( 0 == aChar || '\\' == aChar || '/' == aChar || ':' == aChar )
 506                     bValidEncoded = sal_False;
 507                 else
 508                     *pDest++ = aChar;
 509             }
 510             break;
 511         default:
 512             *pDest++ = *pSrc++;
 513             break;
 514         }
 515     }
 516
 517     *pDest++ = 0;
 518
 519     if ( bValidEncoded ) {
 520         rtl_string2UString( pstrDecodedURL, pBuffer, rtl_str_getLength(pBuffer), RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS );
 521         OSL_ASSERT(*pstrDecodedURL != 0);
 522     }
 523
 524     rtl_freeMemory( pBuffer );
 525
 526     return bValidEncoded;
 527 }
 528
 529 //#############################################
 530 void _osl_encodeURL( rtl_uString *strURL, rtl_String **pstrEncodedURL )
 531 {
 532     /* Encode non ascii characters within the URL */
 533
 534     rtl_String          *strUTF8 = NULL;
 535     sal_Char            *pszEncodedURL;
 536     const sal_Char      *pURLScan;
 537     sal_Char            *pURLDest;
 538     sal_Int32           nURLScanLen;
 539     sal_Int32           nURLScanCount;
 540
 541     rtl_uString2String( &strUTF8, rtl_uString_getStr( strURL ), rtl_uString_getLength( strURL ), RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS );
 542
 543     pszEncodedURL = (sal_Char*) rtl_allocateMemory( (rtl_string_getLength( strUTF8 ) * 3 + 1)  * sizeof(sal_Char) );
 544
 545     pURLDest = pszEncodedURL;
 546     pURLScan = rtl_string_getStr( strUTF8 );
 547     nURLScanLen = rtl_string_getLength( strUTF8 );
 548     nURLScanCount = 0;
 549
 550     while ( nURLScanCount < nURLScanLen )
 551     {
 552         sal_Char        cCurrent = *pURLScan;
 553
 554         switch ( cCurrent )
 555         {
 556         default:
 557             if (!( ( cCurrent >= 'a' && cCurrent <= 'z' ) || ( cCurrent >= 'A' && cCurrent <= 'Z' ) || ( cCurrent >= '0' && cCurrent <= '9' ) ) )
 558             {
 559                 sprintf( pURLDest, "%%%02X", (unsigned char)cCurrent );
 560                 pURLDest += 3;
 561                 break;
 562             }
 563         case '!':
 564         case '\'':
 565         case '(':
 566         case ')':
 567         case '*':
 568         case '-':
 569         case '.':
 570         case '_':
 571         case '~':
 572         case '$':
 573         case '&':
 574         case '+':
 575         case ',':
 576         case '=':
 577         case '@':
 578         case ':':
 579         case '/':
 580         case '\\':
 581         case '|':
 582             *pURLDest++ = cCurrent;
 583             break;
 584         case 0:
 585             break;
 586         }
 587
 588         pURLScan++;
 589         nURLScanCount++;
 590     }
 591
 592
 593     *pURLDest = 0;
 594
 595     rtl_string_release( strUTF8 );
 596     rtl_string_newFromStr( pstrEncodedURL, pszEncodedURL );
 597     rtl_freeMemory( pszEncodedURL );
 598 }
 599
 600 //#############################################
 601 oslFileError SAL_CALL _osl_getFileURLFromSystemPath( rtl_uString* strPath, rtl_uString** pstrURL )
 602 {
 603     oslFileError nError = osl_File_E_INVAL; /* Assume failure */
 604     rtl_uString *strTempURL = NULL;
 605     DWORD dwPathType = PATHTYPE_ERROR;
 606
 607     if (strPath)
 608         dwPathType = IsValidFilePath(strPath->buffer, NULL, VALIDATEPATH_ALLOW_RELATIVE);
 609
 610     if (dwPathType)
 611     {
 612         rtl_uString     *strTempPath = NULL;
 613
 614         /* Replace backslashes */
 615
 616         rtl_uString_newReplace( &strTempPath, strPath, '\\', '/' );
 617
 618         switch ( dwPathType & PATHTYPE_MASK_TYPE )
 619         {
 620         case PATHTYPE_RELATIVE:
 621             rtl_uString_assign( &strTempURL, strTempPath );
 622             nError = osl_File_E_None;
 623             break;
 624         case PATHTYPE_ABSOLUTE_UNC:
 625             rtl_uString_newFromAscii( &strTempURL, "file:" );
 626             rtl_uString_newConcat( &strTempURL, strTempURL, strTempPath );
 627             nError = osl_File_E_None;
 628             break;
 629         case PATHTYPE_ABSOLUTE_LOCAL:
 630             rtl_uString_newFromAscii( &strTempURL, "file:///" );
 631             rtl_uString_newConcat( &strTempURL, strTempURL, strTempPath );
 632             nError = osl_File_E_None;
 633             break;
 634         default:
 635             break;
 636         }
 637
 638         /* Release temp path */
 639
 640         rtl_uString_release( strTempPath );
 641     }
 642
 643     if ( osl_File_E_None == nError )
 644     {
 645         rtl_String      *strEncodedURL = NULL;
 646
 647         /* Encode the URL */
 648
 649         _osl_encodeURL( strTempURL, &strEncodedURL );
 650
 651         /* Provide URL via unicode string */
 652
 653         rtl_string2UString( pstrURL, rtl_string_getStr(strEncodedURL), rtl_string_getLength(strEncodedURL), RTL_TEXTENCODING_ASCII_US, OUSTRING_TO_OSTRING_CVTFLAGS );
 654         OSL_ASSERT(*pstrURL != 0);
 655         rtl_string_release( strEncodedURL );
 656     }
 657
 658     /* Release temp URL */
 659
 660     if ( strTempURL )
 661         rtl_uString_release( strTempURL );
 662
 663     /*
 664     OSL_ENSURE_FILE( !nError, "osl_getFileURLFromSystemPath: \"%s\" is not a systemPath !!!", strPath );
 665     */
 666
 667     return nError;
 668 }
 669
 670 oslFileError SAL_CALL osl_getFileURLFromSystemPath( rtl_uString *ustrSystemPath, rtl_uString **pustrFileURL )
 671 {
 672     return _osl_getFileURLFromSystemPath( ustrSystemPath, pustrFileURL );
 673 #if 0
 674     static const sal_Unicode pDoubleSlash[2] = { '/', '/' };
 675
 676     rtl_uString *pTmp = NULL;
 677     sal_Int32 nIndex;
 678
 679     if( 0 == ustrSystemPath->length )
 680         return osl_File_E_INVAL;
 681
 682     /* YD convert '\' to '/' */
 683     rtl_ustr_replaceChar( ustrSystemPath->buffer, '\\', '/' );
 684
 685     /* temporary hack: if already file url, return ustrSystemPath */
 686     if( 0 == rtl_ustr_ascii_shortenedCompare_WithLength( ustrSystemPath->buffer, ustrSystemPath->length,"file:", 5 ) )
 687     {
 688     /*
 689         if( 0 == rtl_ustr_ascii_shortenedCompare_WithLength( ustrSystemPath->buffer, ustrSystemPath->length,"file://", 7 ) )
 690         {
 691             OSL_ENSURE( 0, "osl_getFileURLFromSystemPath: input is already file URL" );
 692             rtl_uString_assign( pustrFileURL, ustrSystemPath );
 693         }
 694         else
 695         {
 696             rtl_uString *pTmp2 = NULL;
 697
 698             OSL_ENSURE( 0, "osl_getFileURLFromSystemPath: input is wrong file URL" );
 699             rtl_uString_newFromStr_WithLength( pustrFileURL, ustrSystemPath->buffer + 5, ustrSystemPath->length - 5 );
 700             rtl_uString_newFromAscii( &pTmp2, "file://" );
 701             rtl_uString_newConcat( pustrFileURL, *pustrFileURL, pTmp2 );
 702             rtl_uString_release( pTmp2 );
 703         }
 704         return osl_File_E_None;
 705         */
 706         return osl_File_E_INVAL;
 707     }
 708
 709
 710     /* check if system path starts with ~ or ~user and replace it with the appropriate home dir */
 711     if( (sal_Unicode) '~' == ustrSystemPath->buffer[0] )
 712     {
 713         /* check if another user is specified */
 714         if( ( 1 == ustrSystemPath->length ) || ( (sal_Unicode)'/' == ustrSystemPath->buffer[1] ) )
 715         {
 716             /* osl_getHomeDir returns file URL */
 717             osl_getHomeDir( osl_getCurrentSecurity(), &pTmp );
 718
 719             /* remove "file://" prefix */
 720             rtl_uString_newFromStr_WithLength( &pTmp, pTmp->buffer + 7, pTmp->length - 7 );
 721
 722             /* replace '~' in original string */
 723             rtl_uString_newReplaceStrAt( &pTmp, ustrSystemPath, 0, 1, pTmp );
 724         }
 725
 726         else
 727         {
 728             /* FIXME: replace ~user with users home directory */
 729             return osl_File_E_INVAL;
 730         }
 731     }
 732
 733     /* check if initial string contains double instances of '/' */
 734     nIndex = rtl_ustr_indexOfStr_WithLength( ustrSystemPath->buffer, ustrSystemPath->length, pDoubleSlash, 2 );
 735     if( -1 != nIndex )
 736     {
 737         sal_Int32 nSrcIndex;
 738         sal_Int32 nDeleted = 0;
 739
 740         /* if pTmp is not already allocated, copy ustrSystemPath for modification */
 741         if( NULL == pTmp )
 742             rtl_uString_newFromString( &pTmp, ustrSystemPath );
 743
 744         /* adapt index to pTmp */
 745         nIndex += pTmp->length - ustrSystemPath->length;
 746
 747         /* remove all occurances of '//' */
 748         for( nSrcIndex = nIndex + 1; nSrcIndex < pTmp->length; nSrcIndex++ )
 749         {
 750             if( ((sal_Unicode) '/' == pTmp->buffer[nSrcIndex]) && ((sal_Unicode) '/' == pTmp->buffer[nIndex]) )
 751                 nDeleted++;
 752             else
 753                 pTmp->buffer[++nIndex] = pTmp->buffer[nSrcIndex];
 754         }
 755
 756         /* adjust length member */
 757         pTmp->length -= nDeleted;
 758     }
 759
 760     if( NULL == pTmp )
 761         rtl_uString_assign( &pTmp, ustrSystemPath );
 762
 763     /* temporary check for top 5 wrong usage strings (which are valid but unlikly filenames) */
 764     /*
 765     OSL_ASSERT( !findWrongUsage( pTmp->buffer, pTmp->length ) );
 766     */
 767
 768     /* file URLs must be URI encoded */
 769     rtl_uriEncode( pTmp, uriCharClass, rtl_UriEncodeIgnoreEscapes, RTL_TEXTENCODING_UTF8, pustrFileURL );
 770
 771     rtl_uString_release( pTmp );
 772
 773     /* absolute urls should start with 'file://' */
 774     if( (sal_Unicode)'/' == (*pustrFileURL)->buffer[0] )
 775     {
 776         rtl_uString *pProtocol = NULL;
 777
 778         rtl_uString_newFromAscii( &pProtocol, "file://" );
 779         rtl_uString_newConcat( pustrFileURL, pProtocol, *pustrFileURL );
 780         rtl_uString_release( pProtocol );
 781     }
 782
 783     return osl_File_E_None;
 784 #endif
 785 }
 786
 787 //#############################################
 788 oslFileError SAL_CALL _osl_getSystemPathFromFileURL( rtl_uString *strURL, rtl_uString **pustrPath, sal_Bool bAllowRelative )
 789 {
 790     rtl_String                  *strUTF8 = NULL;
 791     rtl_uString                 *strDecodedURL = NULL;
 792     rtl_uString                 *strTempPath = NULL;
 793     const sal_Unicode   *pDecodedURL;
 794     sal_uInt32                  nDecodedLen;
 795     sal_Bool                    bValidEncoded;
 796     oslFileError                nError = osl_File_E_INVAL;      /* Assume failure */
 797
 798     /*  If someone hasn't encoded the complete URL we convert it to UTF8 now to prevent from
 799         having a mixed encoded URL later */
 800
 801     rtl_uString2String( &strUTF8, rtl_uString_getStr( strURL ), rtl_uString_getLength( strURL ), RTL_TEXTENCODING_UTF8, OUSTRING_TO_OSTRING_CVTFLAGS );
 802
 803     /* If the length of strUTF8 and strURL differs it indicates that the URL was not correct encoded */
 804
 805     OSL_ENSURE_FILE(
 806         strUTF8->length == strURL->length ||
 807         0 != rtl_ustr_ascii_shortenedCompare_WithLength( strURL->buffer, strURL->length, "file:\\\\", 7 )
 808         ,"osl_getSystemPathFromFileURL: \"%s\" is not encoded !!!", strURL );
 809
 810     bValidEncoded = _osl_decodeURL( strUTF8, &strDecodedURL );
 811
 812     /* Release the encoded UTF8 string */
 813
 814     rtl_string_release( strUTF8 );
 815
 816
 817     if ( bValidEncoded )
 818     {
 819         /* Replace backslashes and pipes */
 820
 821         rtl_uString_newReplace( &strDecodedURL, strDecodedURL, '/', '\\' );
 822         rtl_uString_newReplace( &strDecodedURL, strDecodedURL, '|', ':' );
 823
 824         pDecodedURL = rtl_uString_getStr( strDecodedURL );
 825         nDecodedLen = rtl_uString_getLength( strDecodedURL );
 826
 827         /* Must start with "file://" */
 828
 829         if ( 0 == rtl_ustr_ascii_shortenedCompare_WithLength( pDecodedURL, nDecodedLen, "file:\\\\", 7 ) )
 830         {
 831             sal_uInt32  nSkip;
 832
 833             if ( 0 == rtl_ustr_ascii_shortenedCompare_WithLength( pDecodedURL, nDecodedLen, "file:\\\\\\", 8 ) )
 834                 nSkip = 8;
 835             else if (
 836                 0 == rtl_ustr_ascii_shortenedCompare_WithLength( pDecodedURL, nDecodedLen, "file:\\\\localhost\\", 17 ) ||
 837                 0 == rtl_ustr_ascii_shortenedCompare_WithLength( pDecodedURL, nDecodedLen, "file:\\\\127.0.0.1\\", 17 )
 838             )
 839                 nSkip = 17;
 840             else
 841                 nSkip = 5;
 842
 843             /* Indicates local root */
 844             if ( nDecodedLen == nSkip )
 845                 rtl_uString_newFromStr_WithLength( &strTempPath, (const sal_Unicode*)WSTR_SYSTEM_ROOT_PATH, ELEMENTS_OF_ARRAY(WSTR_SYSTEM_ROOT_PATH) - 1 );
 846             else
 847                 rtl_uString_newFromStr_WithLength( &strTempPath, pDecodedURL + nSkip, nDecodedLen - nSkip );
 848
 849             if ( IsValidFilePath( strTempPath->buffer, NULL, VALIDATEPATH_ALLOW_ELLIPSE ) )
 850                 nError = osl_File_E_None;
 851         }
 852         else if ( bAllowRelative )      /* This maybe a relative file URL */
 853         {
 854             rtl_uString_assign( &strTempPath, strDecodedURL );
 855
 856             if ( IsValidFilePath( strTempPath->buffer, NULL, VALIDATEPATH_ALLOW_RELATIVE | VALIDATEPATH_ALLOW_ELLIPSE ) )
 857                 nError = osl_File_E_None;
 858         }
 859     /*
 860         else
 861             OSL_ENSURE_FILE( !nError, "osl_getSystemPathFromFileURL: \"%s\" is not an absolute FileURL !!!", strURL );
 862      */
 863
 864     }
 865
 866     if ( strDecodedURL )
 867         rtl_uString_release( strDecodedURL );
 868
 869     if ( osl_File_E_None == nError )
 870         rtl_uString_assign( pustrPath, strTempPath );
 871
 872     if ( strTempPath )
 873         rtl_uString_release( strTempPath );
 874
 875     /*
 876     OSL_ENSURE_FILE( !nError, "osl_getSystemPathFromFileURL: \"%s\" is not a FileURL !!!", strURL );
 877     */
 878
 879     return nError;
 880 }
 881
 882 /****************************************************************************/
 883 /*      osl_getSystemPathFromFileURL */
 884 /****************************************************************************/
 885
 886 oslFileError SAL_CALL osl_getSystemPathFromFileURL( rtl_uString *ustrFileURL, rtl_uString **pustrSystemPath )
 887 {
 888     return _osl_getSystemPathFromFileURL( ustrFileURL, pustrSystemPath, sal_True );
 889 #if 0
 890     sal_Int32 nIndex = 0;
 891     rtl_uString * pTmp = NULL;
 892
 893     sal_Unicode encodedSlash[3] = { '%', '2', 'F' };
 894
 895     /* temporary hack: if already system path, return ustrFileURL */
 896     /*
 897     if( (sal_Unicode) '/' == ustrFileURL->buffer[0] )
 898     {
 899         OSL_ENSURE( 0, "osl_getSystemPathFromFileURL: input is already system path" );
 900         rtl_uString_assign( pustrSystemPath, ustrFileURL );
 901         return osl_File_E_None;
 902     }
 903     */
 904
 905     /* a valid file url may not start with '/' */
 906     if( ( 0 == ustrFileURL->length ) || ( (sal_Unicode) '/' == ustrFileURL->buffer[0] ) )
 907     {
 908         return osl_File_E_INVAL;
 909     }
 910
 911     /* search for encoded slashes (%2F) and decode every single token if we find one */
 912     if( -1 != rtl_ustr_indexOfStr_WithLength( ustrFileURL->buffer, ustrFileURL->length, encodedSlash, 3 ) )
 913     {
 914         rtl_uString * ustrPathToken = NULL;
 915         sal_Int32 nOffset = 7;
 916
 917         do
 918         {
 919             nOffset += nIndex;
 920
 921             /* break url down in '/' devided tokens tokens */
 922             nIndex = rtl_ustr_indexOfChar_WithLength( ustrFileURL->buffer + nOffset, ustrFileURL->length - nOffset, (sal_Unicode) '/' );
 923
 924             /* copy token to new string */
 925             rtl_uString_newFromStr_WithLength( &ustrPathToken, ustrFileURL->buffer + nOffset,
 926                 -1 == nIndex ? ustrFileURL->length - nOffset : nIndex++ );
 927
 928             /* decode token */
 929             rtl_uriDecode( ustrPathToken, rtl_UriDecodeWithCharset, RTL_TEXTENCODING_UTF8, &pTmp );
 930
 931             /* the result should not contain any '/' */
 932             if( -1 != rtl_ustr_indexOfChar_WithLength( pTmp->buffer, pTmp->length, (sal_Unicode) '/' ) )
 933             {
 934                 rtl_uString_release( pTmp );
 935                 rtl_uString_release( ustrPathToken );
 936
 937                 return osl_File_E_INVAL;
 938             }
 939
 940         } while( -1 != nIndex );
 941
 942         /* release temporary string and restore index variable */
 943         rtl_uString_release( ustrPathToken );
 944         nIndex = 0;
 945     }
 946
 947     /* protocol and server should not be encoded, so decode the whole string */
 948     rtl_uriDecode( ustrFileURL, rtl_UriDecodeWithCharset, RTL_TEXTENCODING_UTF8, &pTmp );
 949
 950     /* check if file protocol specified */
 951     /* FIXME: use rtl_ustr_ascii_shortenedCompareIgnoreCase_WithLength when available */
 952     if( 7 <= pTmp->length )
 953     {
 954         rtl_uString * pProtocol = NULL;
 955         rtl_uString_newFromStr_WithLength( &pProtocol, pTmp->buffer, 7 );
 956
 957         /* protocol is case insensitive */
 958         rtl_ustr_toAsciiLowerCase_WithLength( pProtocol->buffer, pProtocol->length );
 959
 960         if( 0 == rtl_ustr_ascii_shortenedCompare_WithLength( pProtocol->buffer, pProtocol->length,"file://", 7 ) )
 961             nIndex = 7;
 962
 963         rtl_uString_release( pProtocol );
 964     }
 965
 966     /* skip "localhost" or "127.0.0.1" if "file://" is specified */
 967     /* FIXME: use rtl_ustr_ascii_shortenedCompareIgnoreCase_WithLength when available */
 968     if( nIndex && ( 10 <= pTmp->length - nIndex ) )
 969     {
 970         rtl_uString * pServer = NULL;
 971         rtl_uString_newFromStr_WithLength( &pServer, pTmp->buffer + nIndex, 10 );
 972
 973         /* server is case insensitive */
 974         rtl_ustr_toAsciiLowerCase_WithLength( pServer->buffer, pServer->length );
 975
 976         if( ( 0 == rtl_ustr_ascii_shortenedCompare_WithLength( pServer->buffer, pServer->length,"localhost/", 10 ) ) ||
 977             ( 0 == rtl_ustr_ascii_shortenedCompare_WithLength( pServer->buffer, pServer->length,"127.0.0.1/", 10 ) ) )
 978         {
 979             /* don't exclude the '/' */
 980             nIndex += 9;
 981         }
 982
 983         rtl_uString_release( pServer );
 984     }
 985
 986     if( nIndex )
 987         rtl_uString_newFromStr_WithLength( &pTmp, pTmp->buffer + nIndex, pTmp->length - nIndex );
 988
 989     /* check if system path starts with ~ or ~user and replace it with the appropriate home dir */
 990     if( (sal_Unicode) '~' == pTmp->buffer[0] )
 991     {
 992         /* check if another user is specified */
 993         if( ( 1 == pTmp->length ) || ( (sal_Unicode)'/' == pTmp->buffer[1] ) )
 994         {
 995             rtl_uString *pTmp2 = NULL;
 996
 997             /* osl_getHomeDir returns file URL */
 998             osl_getHomeDir( osl_getCurrentSecurity(), &pTmp2 );
 999
1000             /* remove "file://" prefix */
1001             rtl_uString_newFromStr_WithLength( &pTmp2, pTmp2->buffer + 7, pTmp2->length - 7 );
1002
1003             /* replace '~' in original string */
1004             rtl_uString_newReplaceStrAt( &pTmp, pTmp, 0, 1, pTmp2 );
1005             rtl_uString_release( pTmp2 );
1006         }
1007
1008         else
1009         {
1010             /* FIXME: replace ~user with users home directory */
1011             return osl_File_E_INVAL;
1012         }
1013     }
1014
1015     /* temporary check for top 5 wrong usage strings (which are valid but unlikly filenames) */
1016     /*
1017     OSL_ASSERT( !findWrongUsage( pTmp->buffer, pTmp->length ) );
1018     */
1019
1020     *pustrSystemPath = pTmp;
1021     return osl_File_E_None;
1022 #endif // 0
1023 }
1024
1025
1026 /****************************************************************************
1027  * osl_getSystemPathFromFileURL_Ex - helper function
1028  * clients may specify if they want to accept relative
1029  * URLs or not
1030  ****************************************************************************/
1031
1032 oslFileError osl_getSystemPathFromFileURL_Ex(
1033     rtl_uString *ustrFileURL, rtl_uString **pustrSystemPath, sal_Bool bAllowRelative)
1034 {
1035     return _osl_getSystemPathFromFileURL( ustrFileURL, pustrSystemPath, bAllowRelative);
1036 #if 0
1037     rtl_uString* temp = 0;
1038     oslFileError osl_error = osl_getSystemPathFromFileURL(ustrFileURL, &temp);
1039
1040     if (osl_File_E_None == osl_error)
1041     {
1042         if (bAllowRelative
1043             || (UNICHAR_SLASH == temp->buffer[0])
1044             || (UNICHAR_COLON == temp->buffer[1] && UNICHAR_SLASH == temp->buffer[2]))
1045         {
1046             *pustrSystemPath = temp;
1047         }
1048         else
1049         {
1050             rtl_uString_release(temp);
1051             osl_error = osl_File_E_INVAL;
1052         }
1053     }
1054
1055     return osl_error;
1056 #endif
1057 }
1058
1059 namespace /* private */
1060 {
1061
1062 #if 0 // YD
1063
1064     /******************************************************
1065      * Helper function, return a pinter to the final '\0'
1066      * of a string
1067      ******************************************************/
1068
1069     sal_Unicode* ustrtoend(sal_Unicode* pStr)
1070     {
1071         return (pStr + rtl_ustr_getLength(pStr));
1072     }
1073
1074     /*********************************************
1075
1076      ********************************************/
1077     sal_Unicode* ustrcpy(const sal_Unicode* s, sal_Unicode* d)
1078     {
1079         const sal_Unicode* sc = s;
1080         sal_Unicode*       dc = d;
1081
1082         while ((*dc++ = *sc++))
1083             /**/;
1084
1085         return d;
1086     }
1087
1088     /*********************************************
1089
1090      ********************************************/
1091
1092     sal_Unicode* ustrncpy(const sal_Unicode* s, sal_Unicode* d, unsigned int n)
1093     {
1094         const sal_Unicode* sc = s;
1095         sal_Unicode*       dc = d;
1096         unsigned int       i  = n;
1097
1098         while (i--)
1099             *dc++ = *sc++;
1100
1101         if (n)
1102             *dc = 0;
1103
1104         return d;
1105     }
1106
1107     /*********************************************
1108
1109      ********************************************/
1110
1111     sal_Unicode* ustrchrcat(const sal_Unicode chr, sal_Unicode* d)
1112     {
1113         sal_Unicode* p = ustrtoend(d);
1114         *p++ = chr;
1115         *p   = 0;
1116         return d;
1117     }
1118
1119     /*********************************************
1120
1121      ********************************************/
1122
1123     sal_Unicode* ustrcat(const sal_Unicode* s, sal_Unicode* d)
1124     {
1125         sal_Unicode* dc = ustrtoend(d);
1126         ustrcpy(s, dc);
1127         return d;
1128     }
1129
1130     /******************************************************
1131      *
1132      ******************************************************/
1133
1134     bool _islastchr(sal_Unicode* pStr, sal_Unicode Chr)
1135     {
1136            sal_Unicode* p = ustrtoend(pStr);
1137            if (p > pStr)
1138                p--;
1139            return (*p == Chr);
1140     }
1141
1142     /******************************************************
1143      * Ensure that the given string has the specified last
1144      * character if necessary append it
1145      ******************************************************/
1146
1147     sal_Unicode* _strensurelast(sal_Unicode* pStr, sal_Unicode Chr)
1148     {
1149         if (!_islastchr(pStr, Chr))
1150             ustrchrcat(Chr, pStr);
1151         return pStr;
1152     }
1153
1154     /******************************************************
1155      * Remove the last part of a path, a path that has
1156      * only a '/' or no '/' at all will be returned
1157      * unmodified
1158      ******************************************************/
1159
1160     sal_Unicode* _rmlastpathtoken(sal_Unicode* aPath)
1161     {
1162         /*      we always may skip -2 because we
1163                may at least stand on a '/' but
1164                either there is no other character
1165                before this '/' or it's another
1166                character than the '/'
1167         */
1168         sal_Unicode* p = ustrtoend(aPath) - 2;
1169
1170         // move back to the next path separator
1171         // or to the start of the string
1172         while ((p > aPath) && (*p != UNICHAR_SLASH))
1173             p--;
1174
1175         if (p >= aPath)
1176         {
1177             if (UNICHAR_SLASH == *p)
1178             {
1179                 p++;
1180                *p = '\0';
1181             }
1182             else
1183             {
1184                    *p = '\0';
1185             }
1186         }
1187
1188         return aPath;
1189     }
1190
1191     /******************************************************
1192      *
1193      ******************************************************/
1194
1195     oslFileError _osl_resolvepath(
1196         /*inout*/ sal_Unicode* path,
1197         /*inout*/ sal_Unicode* current_pos,
1198         /*in   */ sal_Unicode* sentinel,
1199         /*inout*/ bool* failed)
1200     {
1201         oslFileError ferr = osl_File_E_None;
1202
1203         if (!*failed)
1204         {
1205             char unresolved_path[PATH_MAX];
1206             if (!UnicodeToText(unresolved_path, sizeof(unresolved_path), path, rtl_ustr_getLength(path)))
1207                 return oslTranslateFileError(OSL_FET_ERROR, ENAMETOOLONG);
1208
1209             char resolved_path[PATH_MAX];
1210             if (realpath(unresolved_path, resolved_path))
1211             {
1212                 if (!TextToUnicode(resolved_path, strlen(resolved_path), path, PATH_MAX))
1213                     return oslTranslateFileError(OSL_FET_ERROR, ENAMETOOLONG);
1214
1215                 current_pos = ustrtoend(path) - 1;
1216             }
1217             else
1218             {
1219                 if (EACCES == errno || ENOTDIR == errno || ENOENT == errno)
1220                     *failed = true;
1221                 else
1222                     ferr = oslTranslateFileError(OSL_FET_ERROR, errno);
1223             }
1224         }
1225
1226         return ferr;
1227     }
1228
1229     /******************************************************
1230      * Works even with non existing paths. The resulting
1231      * path must not exceed PATH_MAX else
1232      * osl_File_E_NAMETOOLONG is the result
1233      ******************************************************/
1234
1235     oslFileError osl_getAbsoluteFileURL_impl_(const rtl::OUString& unresolved_path, rtl::OUString& resolved_path)
1236     {
1237         // the given unresolved path must not exceed PATH_MAX
1238         if (unresolved_path.getLength() >= (PATH_MAX - 2))
1239             return oslTranslateFileError(OSL_FET_ERROR, ENAMETOOLONG);
1240
1241         sal_Unicode        path_resolved_so_far[PATH_MAX];
1242         const sal_Unicode* punresolved = unresolved_path.getStr();
1243         sal_Unicode*       presolvedsf = path_resolved_so_far;
1244
1245         // reserve space for leading '/' and trailing '\0'
1246         // do not exceed this limit
1247         sal_Unicode* sentinel = path_resolved_so_far + PATH_MAX - 2;
1248
1249         // if realpath fails with error ENOTDIR, EACCES or ENOENT
1250         // we will not call it again, because _osl_realpath should also
1251         // work with non existing directories etc.
1252         bool realpath_failed = false;
1253         oslFileError ferr;
1254
1255         path_resolved_so_far[0] = '\0';
1256
1257         while (*punresolved != '\0')
1258         {
1259             // ignore '/.' , skip one part back when '/..'
1260
1261             if ((UNICHAR_DOT == *punresolved) && (UNICHAR_SLASH == *presolvedsf))
1262             {
1263                 if ('\0' == *(punresolved + 1))
1264                 {
1265                     punresolved++;
1266                     continue;
1267                 }
1268                 else if (UNICHAR_SLASH == *(punresolved + 1))
1269                 {
1270                     punresolved += 2;
1271                     continue;
1272                 }
1273                 else if ((UNICHAR_DOT == *(punresolved + 1)) && ('\0' == *(punresolved + 2) || (UNICHAR_SLASH == *(punresolved + 2))))
1274                 {
1275                     _rmlastpathtoken(path_resolved_so_far);
1276
1277                     presolvedsf = ustrtoend(path_resolved_so_far) - 1;
1278
1279                     if (UNICHAR_SLASH == *(punresolved + 2))
1280                         punresolved += 3;
1281                     else
1282                         punresolved += 2;
1283
1284                     continue;
1285                 }
1286                 else // a file or directory name may start with '.'
1287                 {
1288                     if ((presolvedsf = ustrtoend(path_resolved_so_far)) > sentinel)
1289                         return oslTranslateFileError(OSL_FET_ERROR, ENAMETOOLONG);
1290
1291                     ustrchrcat(*punresolved++, path_resolved_so_far);
1292
1293                     if ('\0' == *punresolved && !realpath_failed)
1294                     {
1295                         ferr = _osl_resolvepath(
1296                             path_resolved_so_far,
1297                             presolvedsf,
1298                             sentinel,
1299                             &realpath_failed);
1300
1301                         if (osl_File_E_None != ferr)
1302                             return ferr;
1303                     }
1304                 }
1305             }
1306             else if (UNICHAR_SLASH == *punresolved)
1307             {
1308                 if ((presolvedsf = ustrtoend(path_resolved_so_far)) > sentinel)
1309                     return oslTranslateFileError(OSL_FET_ERROR, ENAMETOOLONG);
1310
1311                 ustrchrcat(*punresolved++, path_resolved_so_far);
1312
1313                 if (!realpath_failed)
1314                 {
1315                     ferr = _osl_resolvepath(
1316                         path_resolved_so_far,
1317                         presolvedsf,
1318                         sentinel,
1319                         &realpath_failed);
1320
1321                     if (osl_File_E_None != ferr)
1322                         return ferr;
1323
1324                     if (!_islastchr(path_resolved_so_far, UNICHAR_SLASH))
1325                     {
1326                         if ((presolvedsf = ustrtoend(path_resolved_so_far)) > sentinel)
1327                             return oslTranslateFileError(OSL_FET_ERROR, ENAMETOOLONG);
1328
1329                         ustrchrcat(UNICHAR_SLASH, path_resolved_so_far);
1330                     }
1331                 }
1332             }
1333             else // any other character
1334             {
1335                 if ((presolvedsf = ustrtoend(path_resolved_so_far)) > sentinel)
1336                     return oslTranslateFileError(OSL_FET_ERROR, ENAMETOOLONG);
1337
1338                 ustrchrcat(*punresolved++, path_resolved_so_far);
1339
1340                 if ('\0' == *punresolved && !realpath_failed)
1341                 {
1342                     ferr = _osl_resolvepath(
1343                         path_resolved_so_far,
1344                         presolvedsf,
1345                         sentinel,
1346                         &realpath_failed);
1347
1348                     if (osl_File_E_None != ferr)
1349                         return ferr;
1350                 }
1351             }
1352         }
1353
1354         sal_Int32 len = rtl_ustr_getLength(path_resolved_so_far);
1355
1356         OSL_ASSERT(len < PATH_MAX);
1357
1358         resolved_path = rtl::OUString(path_resolved_so_far, len);
1359
1360         return osl_File_E_None;
1361     }
1362
1363 #endif // 0 // YD
1364
1365 } // end namespace private
1366
1367 #if OSL_DEBUG_LEVEL > 0
1368
1369     //#####################################################
1370     void _osl_warnFile( const char *message, rtl_uString *ustrFile )
1371     {
1372         char szBuffer[2048];
1373
1374         if (ustrFile)
1375         {
1376             rtl_String  *strFile = NULL;
1377
1378             rtl_uString2String( &strFile, rtl_uString_getStr( ustrFile ), rtl_uString_getLength( ustrFile ), osl_getThreadTextEncoding(), OUSTRING_TO_OSTRING_CVTFLAGS );
1379             snprintf( szBuffer, sizeof(szBuffer), message, strFile->buffer );
1380             rtl_string_release( strFile );
1381
1382             message = szBuffer;
1383         }
1384         OSL_ENSURE( 0, message );
1385     }
1386
1387 #endif // OSL_DEBUG_LEVEL > 0
1388
1389 /******************************************************
1390  * osl_getAbsoluteFileURL
1391  ******************************************************/
1392
1393 //oslFileError osl_getAbsoluteFileURL(rtl_uString*  ustrBaseDirURL, rtl_uString* ustrRelativeURL, rtl_uString** pustrAbsoluteURL)
1394 oslFileError SAL_CALL osl_getAbsoluteFileURL( rtl_uString* ustrBaseURL, rtl_uString* ustrRelativeURL, rtl_uString** pustrAbsoluteURL )
1395 {
1396     oslFileError        eError;
1397     rtl_uString         *ustrRelSysPath = NULL;
1398     rtl_uString         *ustrBaseSysPath = NULL;
1399
1400     if ( ustrBaseURL && ustrBaseURL->length )
1401     {
1402         eError = _osl_getSystemPathFromFileURL( ustrBaseURL, &ustrBaseSysPath, sal_False );
1403         OSL_ENSURE( osl_File_E_None == eError, "osl_getAbsoluteFileURL called with relative or invalid base URL" );
1404
1405         eError = _osl_getSystemPathFromFileURL( ustrRelativeURL, &ustrRelSysPath, sal_True );
1406     }
1407     else
1408     {
1409         eError = _osl_getSystemPathFromFileURL( ustrRelativeURL, &ustrRelSysPath, sal_False );
1410         OSL_ENSURE( osl_File_E_None == eError, "osl_getAbsoluteFileURL called with empty base URL and/or invalid relative URL" );
1411     }
1412
1413     if ( !eError )
1414     {
1415         CHAR    szBuffer[_MAX_PATH];
1416         CHAR    szRelSysPath[_MAX_PATH];
1417         CHAR    szCurrentDir[_MAX_PATH];
1418         int             result;
1419         char*   cwd;
1420         int             rc;
1421
1422 /*@@@ToDo
1423   Bad, bad hack, this only works if the base path
1424   really exists which is not necessary according
1425   to RFC2396
1426   The whole FileURL implementation should be merged
1427   with the rtl/uri class.
1428 */
1429         if ( ustrBaseSysPath )
1430         {
1431             CHAR        szBaseSysPath[_MAX_PATH];
1432
1433             if (!g_CurrentDirectoryMutex)
1434                 g_CurrentDirectoryMutex = osl_createMutex();
1435
1436             osl_acquireMutex( g_CurrentDirectoryMutex );
1437
1438             cwd = getcwd( szCurrentDir, sizeof(szCurrentDir) );
1439             UnicodeToText( szBaseSysPath, sizeof(szBaseSysPath), ustrBaseSysPath->buffer, ustrBaseSysPath->length);
1440             rc = chdir( szBaseSysPath);
1441         }
1442
1443         UnicodeToText( szRelSysPath, sizeof(szRelSysPath), ustrRelSysPath->buffer, ustrRelSysPath->length);
1444         result = !_abspath( szBuffer, szRelSysPath, sizeof(szBuffer));
1445
1446         if ( ustrBaseSysPath )
1447         {
1448             rc = chdir( szCurrentDir );
1449
1450             osl_releaseMutex( g_CurrentDirectoryMutex );
1451         }
1452
1453         if ( result )
1454         {
1455                 rtl_uString     *ustrAbsSysPath = NULL;
1456
1457                 oslMakeUStrFromPsz( szBuffer, &ustrAbsSysPath);
1458
1459                 eError = osl_getFileURLFromSystemPath( ustrAbsSysPath, pustrAbsoluteURL );
1460
1461                 if ( ustrAbsSysPath )
1462                     rtl_uString_release( ustrAbsSysPath );
1463         }
1464         else
1465             eError = osl_File_E_INVAL;
1466     }
1467
1468     if ( ustrBaseSysPath )
1469         rtl_uString_release( ustrBaseSysPath );
1470
1471     if ( ustrRelSysPath )
1472         rtl_uString_release( ustrRelSysPath );
1473
1474     return      eError;
1475 #if 0
1476     FileBase::RC  rc;
1477     rtl::OUString unresolved_path;
1478
1479     rc = FileBase::getSystemPathFromFileURL(rtl::OUString(ustrRelativeURL), unresolved_path);
1480
1481     if(FileBase::E_None != rc)
1482         return oslFileError(rc);
1483
1484     if (systemPathIsRelativePath(unresolved_path))
1485     {
1486         rtl::OUString base_path;
1487         rc = (FileBase::RC) osl_getSystemPathFromFileURL_Ex(ustrBaseDirURL, &base_path.pData, sal_False);
1488
1489         if (FileBase::E_None != rc)
1490             return oslFileError(rc);
1491
1492         rtl::OUString abs_path;
1493         systemPathMakeAbsolutePath(base_path, unresolved_path, abs_path);
1494
1495         unresolved_path = abs_path;
1496     }
1497
1498     rtl::OUString resolved_path;
1499     rc = (FileBase::RC) osl_getAbsoluteFileURL_impl_(unresolved_path, resolved_path);
1500
1501     if (FileBase::E_None == rc)
1502     {
1503         rc = (FileBase::RC) osl_getFileURLFromSystemPath(resolved_path.pData, pustrAbsoluteURL);
1504         OSL_ASSERT(FileBase::E_None == rc);
1505     }
1506
1507     return oslFileError(rc);
1508 #endif // 0
1509 }
1510
1511
1512 namespace /* private */
1513 {
1514
1515     /*********************************************
1516      No separate error code if unicode to text
1517      conversion or getenv fails because for the
1518      caller there is no difference why a file
1519      could not be found in $PATH
1520      ********************************************/
1521
1522     bool find_in_PATH(const rtl::OUString& file_path, rtl::OUString& result)
1523     {
1524         bool          bfound = false;
1525         rtl::OUString path   = rtl::OUString::createFromAscii("PATH");
1526         rtl::OUString env_path;
1527
1528         if (osl_Process_E_None == osl_getEnvironment(path.pData, &env_path.pData))
1529             bfound = osl::searchPath(file_path, env_path, result);
1530
1531         return bfound;
1532     }
1533
1534     /*********************************************
1535      No separate error code if unicode to text
1536      conversion or getcwd fails because for the
1537      caller there is no difference why a file
1538      could not be found in CDW
1539      ********************************************/
1540
1541     bool find_in_CWD(const rtl::OUString& file_path, rtl::OUString& result)
1542     {
1543         bool bfound = false;
1544         rtl::OUString cwd_url;
1545
1546         if (osl_Process_E_None == osl_getProcessWorkingDir(&cwd_url.pData))
1547         {
1548             rtl::OUString cwd;
1549             FileBase::getSystemPathFromFileURL(cwd_url, cwd);
1550             bfound = osl::searchPath(file_path, cwd, result);
1551         }
1552         return bfound;
1553     }
1554
1555     /*********************************************
1556
1557      ********************************************/
1558
1559     bool find_in_searchPath(const rtl::OUString& file_path, rtl_uString* search_path, rtl::OUString& result)
1560     {
1561         return (search_path && osl::searchPath(file_path, rtl::OUString(search_path), result));
1562     }
1563
1564 } // end namespace private
1565
1566
1567 /****************************************************************************
1568  *      osl_searchFileURL
1569  ***************************************************************************/
1570
1571 oslFileError osl_searchFileURL(rtl_uString* ustrFilePath, rtl_uString* ustrSearchPath, rtl_uString** pustrURL)
1572 {
1573     OSL_PRECOND(ustrFilePath && pustrURL, "osl_searchFileURL: invalid parameter");
1574
1575     FileBase::RC  rc;
1576     rtl::OUString file_path;
1577
1578     // try to interpret search path as file url else assume it's a system path list
1579     rc = FileBase::getSystemPathFromFileURL(rtl::OUString(ustrFilePath), file_path);
1580     if ((FileBase::E_None != rc) && (FileBase::E_INVAL == rc))
1581         file_path = ustrFilePath;
1582     else if (FileBase::E_None != rc)
1583         return oslFileError(rc);
1584
1585     bool          bfound = false;
1586     rtl::OUString result;
1587
1588     if (find_in_searchPath(file_path, ustrSearchPath, result) ||
1589         find_in_PATH(file_path, result) ||
1590         find_in_CWD(file_path, result))
1591     {
1592         rtl::OUString resolved;
1593
1594         if (osl::realpath(result, resolved))
1595         {
1596 #if OSL_DEBUG_LEVEL > 0
1597             oslFileError osl_error =
1598 #endif
1599                 osl_getFileURLFromSystemPath(resolved.pData, pustrURL);
1600             OSL_ASSERT(osl_File_E_None == osl_error);
1601             bfound = true;
1602         }
1603     }
1604     return bfound ? osl_File_E_None : osl_File_E_NOENT;
1605 }
1606
1607
1608 /****************************************************************************
1609  * FileURLToPath
1610  ***************************************************************************/
1611
1612 oslFileError FileURLToPath(char * buffer, size_t bufLen, rtl_uString* ustrFileURL)
1613 {
1614     rtl_uString* ustrSystemPath = NULL;
1615     oslFileError osl_error              = osl_getSystemPathFromFileURL(ustrFileURL, &ustrSystemPath);
1616
1617     if(osl_File_E_None != osl_error)
1618         return osl_error;
1619
1620     osl_systemPathRemoveSeparator(ustrSystemPath);
1621
1622     /* convert unicode path to text */
1623     if(!UnicodeToText( buffer, bufLen, ustrSystemPath->buffer, ustrSystemPath->length))
1624         osl_error = oslTranslateFileError(OSL_FET_ERROR, errno);
1625
1626     rtl_uString_release(ustrSystemPath);
1627
1628     return osl_error;
1629 }