sal/osl/unx/file_url.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "file_url.hxx"
  21
  22 #include "system.hxx"
  23
  24 #include <cassert>
  25 #include <stdexcept>
  26 #include <limits.h>
  27 #include <errno.h>
  28 #include <strings.h>
  29 #include <unistd.h>
  30
  31 #include <osl/file.hxx>
  32 #include <osl/security.hxx>
  33 #include <osl/diagnose.h>
  34 #include <osl/thread.h>
  35 #include <osl/process.h>
  36
  37 #include <rtl/character.hxx>
  38 #include <rtl/uri.h>
  39 #include <rtl/uri.hxx>
  40 #include <rtl/ustring.hxx>
  41 #include <rtl/ustrbuf.h>
  42 #include <rtl/textcvt.h>
  43 #include <sal/log.hxx>
  44
  45 #include "file_error_transl.hxx"
  46 #include "file_path_helper.hxx"
  47
  48 #include "uunxapi.hxx"
  49
  50 /** @file
  51
  52  General note
  53
  54  This file contains the part that handles File URLs.
  55
  56  File URLs as scheme specific notion of URIs
  57  (RFC2396) may be handled platform independent, but
  58  will not in osl which is considered wrong.
  59  Future version of osl should handle File URLs this
  60  way. In rtl/uri there is already an URI parser etc.
  61  so this code should be consolidated.
  62
  63 */
  64
  65 using namespace osl;
  66
  67 namespace {
  68
  69 // A slightly modified version of Pchar in rtl/source/uri.c, but without
  70 // encoding slashes:
  71 const sal_Bool uriCharClass[128] = {
  72     false, false, false, false, false, false, false, false,
  73     false, false, false, false, false, false, false, false,
  74     false, false, false, false, false, false, false, false,
  75     false, false, false, false, false, false, false, false,
  76     false,  true, false, false,  true, false,  true,  true,  //  !"#$%&'
  77      true,  true,  true,  true,  true,  true,  true,  true,  // ()*+,-./
  78      true,  true,  true,  true,  true,  true,  true,  true,  // 01234567
  79      true,  true,  true, false, false,  true, false, false,  // 89:;<=>?
  80      true,  true,  true,  true,  true,  true,  true,  true,  // @ABCDEFG
  81      true,  true,  true,  true,  true,  true,  true,  true,  // HIJKLMNO
  82      true,  true,  true,  true,  true,  true,  true,  true,  // PQRSTUVW
  83      true,  true,  true, false, false, false, false,  true,  // XYZ[\]^_
  84     false,  true,  true,  true,  true,  true,  true,  true,  // `abcdefg
  85      true,  true,  true,  true,  true,  true,  true,  true,  // hijklmno
  86      true,  true,  true,  true,  true,  true,  true,  true,  // pqrstuvw
  87      true,  true,  true, false, false, false,  true, false}; // xyz{|}~
  88
  89 }
  90
  91 oslFileError SAL_CALL osl_getCanonicalName( rtl_uString* ustrFileURL, rtl_uString** pustrValidURL )
  92 {
  93     OSL_FAIL("osl_getCanonicalName not implemented");
  94
  95     rtl_uString_newFromString(pustrValidURL, ustrFileURL);
  96     return osl_File_E_None;
  97 }
  98
  99 namespace {
 100
 101 oslFileError getSystemPathFromFileUrl(
 102     OUString const & url, OUString * path, bool resolveHome)
 103 {
 104     assert(path != nullptr);
 105     // For compatibility with assumptions in other parts of the code base,
 106     // assume that anything starting with a slash is a system path instead of a
 107     // (relative) file URL (except if it starts with two slashes, in which case
 108     // it is a relative URL with an authority component):
 109     if (url.isEmpty()
 110         || (url[0] == '/' && (url.getLength() == 1 || url[1] != '/')))
 111     {
 112         return osl_File_E_INVAL;
 113     }
 114     // Check for non file scheme:
 115     sal_Int32 i = 0;
 116     if (rtl::isAsciiAlpha(url[0])) {
 117         for (sal_Int32 j = 1; j != url.getLength(); ++j) {
 118             auto c = url[j];
 119             if (c == ':') {
 120                 if (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
 121                         url.pData->buffer, j,
 122                         RTL_CONSTASCII_STRINGPARAM("file"))
 123                     != 0)
 124                 {
 125                     return osl_File_E_INVAL;
 126                 }
 127                 i = j + 1;
 128                 break;
 129             } if (!rtl::isAsciiAlphanumeric(c) && c != '+' && c != '-'
 130                        && c != '.')
 131             {
 132                 break;
 133             }
 134         }
 135     }
 136     // Handle query or fragment:
 137     if (url.indexOf('?', i) != -1 || url.indexOf('#', i) != -1)
 138         return osl_File_E_INVAL;
 139     // Handle authority:
 140     if (url.getLength() - i >= 2 && url[i] == '/' && url[i + 1] == '/')
 141     {
 142         i += 2;
 143         sal_Int32 j = url.indexOf('/', i);
 144         if (j == -1)
 145             j = url.getLength();
 146         if (j != i
 147             && (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
 148                     url.pData->buffer + i, j - i,
 149                     RTL_CONSTASCII_STRINGPARAM("localhost"))
 150                 != 0)
 151             && (rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
 152                     url.pData->buffer + i, j - i,
 153                     RTL_CONSTASCII_STRINGPARAM("127.0.0.1"))
 154                 != 0))
 155         {
 156             return osl_File_E_INVAL;
 157         }
 158         i = j;
 159     }
 160     // Handle empty path:
 161     if (i == url.getLength())
 162     {
 163         *path = "/";
 164         return osl_File_E_None;
 165     }
 166     // Path must not contain %2F:
 167     if (url.indexOf("%2F", i) != -1 || url.indexOf("%2f", i) != -1)
 168         return osl_File_E_INVAL;
 169
 170     *path = rtl::Uri::decode(
 171         url.copy(i), rtl_UriDecodeWithCharset, RTL_TEXTENCODING_UTF8);
 172     // Path must not contain %2F:
 173     if (path->indexOf('\0') != -1)
 174         return osl_File_E_INVAL;
 175
 176     // Handle ~ notation:
 177     if (resolveHome && path->getLength() >= 2 && (*path)[1] == '~')
 178     {
 179         sal_Int32 j = path->indexOf('/', 2);
 180         if (j == -1)
 181             j = path->getLength();
 182
 183         if (j == 2)
 184         {
 185             OUString home;
 186             if (!osl::Security().getHomeDir(home))
 187             {
 188                 SAL_WARN("sal.file", "osl::Security::getHomeDir failed");
 189                 return osl_File_E_INVAL;
 190             }
 191
 192             i = url.indexOf('/', i + 1);
 193
 194             if (i == -1)
 195                 i = url.getLength();
 196             else
 197                 ++i;
 198
 199             //TODO: cheesy way of ensuring home's path ends in slash:
 200             if (!home.isEmpty() && home[home.getLength() - 1] != '/')
 201                 home += "/";
 202             try
 203             {
 204                 home = rtl::Uri::convertRelToAbs(home, url.copy(i));
 205             }
 206             catch (rtl::MalformedUriException & e)
 207             {
 208                 SAL_WARN("sal.file", "rtl::MalformedUriException " << e.getMessage());
 209                 return osl_File_E_INVAL;
 210             }
 211             return getSystemPathFromFileUrl(home, path, false);
 212         }
 213         // FIXME: replace ~user with user's home directory
 214         return osl_File_E_INVAL;
 215     }
 216     return osl_File_E_None;
 217 }
 218
 219 }
 220
 221 oslFileError SAL_CALL osl_getSystemPathFromFileURL( rtl_uString *ustrFileURL, rtl_uString **pustrSystemPath )
 222 {
 223     OUString path;
 224     oslFileError e;
 225     try
 226     {
 227         e = getSystemPathFromFileUrl(
 228             OUString::unacquired(&ustrFileURL), &path, true);
 229     }
 230     catch (std::length_error &)
 231     {
 232         e = osl_File_E_RANGE;
 233     }
 234
 235     if (e == osl_File_E_None)
 236         rtl_uString_assign(pustrSystemPath, path.pData);
 237
 238     return e;
 239 }
 240
 241 oslFileError SAL_CALL osl_getFileURLFromSystemPath( rtl_uString *ustrSystemPath, rtl_uString **pustrFileURL )
 242 {
 243     static const sal_Unicode pDoubleSlash[2] = { '/', '/' };
 244
 245     rtl_uString *pTmp = nullptr;
 246     sal_Int32 nIndex;
 247
 248     if( ustrSystemPath->length == 0 )
 249         return osl_File_E_INVAL;
 250
 251     /* temporary hack: if already file url, return ustrSystemPath */
 252
 253     if( rtl_ustr_ascii_shortenedCompare_WithLength( ustrSystemPath->buffer, ustrSystemPath->length,"file:", 5 ) == 0 )
 254         return osl_File_E_INVAL;
 255
 256     /* check if system path starts with ~ or ~user and replace it with the appropriate home dir */
 257     if( ustrSystemPath->buffer[0] == '~' )
 258     {
 259         /* check if another user is specified */
 260         if( ( ustrSystemPath->length == 1 ) ||
 261             ( ustrSystemPath->buffer[1] == '/' ) )
 262         {
 263             /* osl_getHomeDir returns file URL */
 264             oslSecurity pSecurity = osl_getCurrentSecurity();
 265             osl_getHomeDir( pSecurity , &pTmp );
 266             osl_freeSecurityHandle( pSecurity );
 267
 268             if (!pTmp)
 269                 return osl_File_E_INVAL;
 270
 271             /* remove "file://" prefix */
 272             rtl_uString_newFromStr_WithLength( &pTmp, pTmp->buffer + 7, pTmp->length - 7 );
 273
 274             /* replace '~' in original string */
 275             rtl_uString_newReplaceStrAt( &pTmp, ustrSystemPath, 0, 1, pTmp );
 276         }
 277         else
 278         {
 279             /* FIXME: replace ~user with users home directory */
 280             return osl_File_E_INVAL;
 281         }
 282     }
 283
 284     /* check if initial string contains repeated '/' characters */
 285     nIndex = rtl_ustr_indexOfStr_WithLength( ustrSystemPath->buffer, ustrSystemPath->length, pDoubleSlash, 2 );
 286     if( nIndex != -1 )
 287     {
 288         sal_Int32 nSrcIndex;
 289         sal_Int32 nDeleted = 0;
 290
 291         /* if pTmp is not already allocated, copy ustrSystemPath for modification */
 292         if( pTmp == nullptr )
 293             rtl_uString_newFromString( &pTmp, ustrSystemPath );
 294
 295         /* adapt index to pTmp */
 296         nIndex += pTmp->length - ustrSystemPath->length;
 297
 298         /* replace repeated '/' characters with a single '/' */
 299         for( nSrcIndex = nIndex + 1; nSrcIndex < pTmp->length; nSrcIndex++ )
 300         {
 301             if( (pTmp->buffer[nSrcIndex] == '/') && (pTmp->buffer[nIndex] == '/') )
 302                 nDeleted++;
 303             else
 304                 pTmp->buffer[++nIndex] = pTmp->buffer[nSrcIndex];
 305         }
 306
 307         /* adjust length member */
 308         pTmp->length -= nDeleted;
 309     }
 310
 311     if( pTmp == nullptr )
 312         rtl_uString_assign( &pTmp, ustrSystemPath );
 313
 314     /* file URLs must be URI encoded */
 315     rtl_uriEncode( pTmp, uriCharClass, rtl_UriEncodeIgnoreEscapes, RTL_TEXTENCODING_UTF8, pustrFileURL );
 316
 317     rtl_uString_release( pTmp );
 318
 319     /* absolute urls should start with 'file://' */
 320     if( (*pustrFileURL)->buffer[0] == '/' )
 321     {
 322         rtl_uString *pProtocol = nullptr;
 323
 324         rtl_uString_newFromAscii( &pProtocol, "file://" );
 325         rtl_uString_newConcat( pustrFileURL, pProtocol, *pustrFileURL );
 326         rtl_uString_release( pProtocol );
 327     }
 328
 329     return osl_File_E_None;
 330 }
 331
 332 /*
 333  * relative URLs are not accepted
 334  */
 335 oslFileError osl_getSystemPathFromFileURL_Ex(
 336     rtl_uString *ustrFileURL, rtl_uString **pustrSystemPath)
 337 {
 338     rtl_uString* temp = nullptr;
 339     oslFileError osl_error = osl_getSystemPathFromFileURL(ustrFileURL, &temp);
 340
 341     if (osl_error == osl_File_E_None)
 342     {
 343         if (temp->buffer[0] == '/')
 344         {
 345             *pustrSystemPath = temp;
 346         }
 347         else
 348         {
 349             rtl_uString_release(temp);
 350             osl_error = osl_File_E_INVAL;
 351         }
 352     }
 353
 354     return osl_error;
 355 }
 356
 357 namespace
 358 {
 359
 360     /** Helper function, return a pinter to the final '\0'
 361         of a string
 362     */
 363
 364     sal_Unicode* ustrtoend(sal_Unicode* pStr)
 365     {
 366         return (pStr + rtl_ustr_getLength(pStr));
 367     }
 368
 369     sal_Unicode* ustrchrcat(const sal_Unicode chr, sal_Unicode* d)
 370     {
 371         sal_Unicode* p = ustrtoend(d);
 372         *p++ = chr;
 373         *p   = 0;
 374         return d;
 375     }
 376
 377     bool _islastchr(sal_Unicode* pStr, sal_Unicode Chr)
 378     {
 379            sal_Unicode* p = ustrtoend(pStr);
 380            if (p > pStr)
 381                p--;
 382            return (*p == Chr);
 383     }
 384
 385     /**
 386      Remove the last part of a path, a path that has
 387      only a '/' or no '/' at all will be returned
 388      unmodified
 389     */
 390
 391     sal_Unicode* _rmlastpathtoken(sal_Unicode* aPath)
 392     {
 393         /* we may always skip -2 because we
 394            may at least stand on a '/' but
 395            either there is no other character
 396            before this '/' or it's another
 397            character than the '/'
 398         */
 399         sal_Unicode* p = ustrtoend(aPath) - 2;
 400
 401         /* move back to the next path separator
 402            or to the start of the string */
 403         while ((p > aPath) && (*p != '/'))
 404             p--;
 405
 406         if (p >= aPath)
 407         {
 408             if (*p == '/')
 409             {
 410                 p++;
 411                *p = '\0';
 412             }
 413             else
 414             {
 415                 *p = '\0';
 416             }
 417         }
 418
 419         return aPath;
 420     }
 421
 422     oslFileError _osl_resolvepath(
 423         /*inout*/ sal_Unicode* path,
 424         /*inout*/ bool* failed)
 425     {
 426         oslFileError ferr = osl_File_E_None;
 427
 428         if (!*failed)
 429         {
 430             char unresolved_path[PATH_MAX];
 431             if (!UnicodeToText(unresolved_path, sizeof(unresolved_path), path, rtl_ustr_getLength(path)))
 432                 return oslTranslateFileError(ENAMETOOLONG);
 433
 434             char resolved_path[PATH_MAX];
 435             if (realpath(unresolved_path, resolved_path))
 436             {
 437                 if (!TextToUnicode(resolved_path, strlen(resolved_path), path, PATH_MAX))
 438                     return oslTranslateFileError(ENAMETOOLONG);
 439             }
 440             else
 441             {
 442                 if (EACCES == errno || ENOTDIR == errno || ENOENT == errno)
 443                     *failed = true;
 444                 else
 445                     ferr = oslTranslateFileError(errno);
 446             }
 447         }
 448
 449         return ferr;
 450     }
 451
 452     /**
 453        Works even with non existing paths. The resulting path must not exceed
 454        PATH_MAX else osl_File_E_NAMETOOLONG is the result
 455     */
 456
 457     oslFileError osl_getAbsoluteFileURL_impl_(const OUString& unresolved_path, OUString& resolved_path)
 458     {
 459         /* the given unresolved path must not exceed PATH_MAX */
 460         if (unresolved_path.getLength() >= (PATH_MAX - 2))
 461             return oslTranslateFileError(ENAMETOOLONG);
 462
 463         sal_Unicode        path_resolved_so_far[PATH_MAX];
 464         const sal_Unicode* punresolved = unresolved_path.getStr();
 465         sal_Unicode*       presolvedsf = path_resolved_so_far;
 466
 467         /* reserve space for leading '/' and trailing '\0'
 468            do not exceed this limit */
 469         sal_Unicode* sentinel = path_resolved_so_far + PATH_MAX - 2;
 470
 471         /* if realpath fails with error ENOTDIR, EACCES or ENOENT
 472            we will not call it again, because _osl_realpath should also
 473            work with non existing directories etc. */
 474         bool realpath_failed = false;
 475         oslFileError ferr;
 476
 477         path_resolved_so_far[0] = '\0';
 478
 479         while (*punresolved != '\0')
 480         {
 481             /* ignore '/.' , skip one part back when '/..' */
 482             if ((*punresolved == '.') && (*presolvedsf == '/'))
 483             {
 484                 if (*(punresolved + 1) == '\0')
 485                 {
 486                     punresolved++;
 487                     continue;
 488                 }
 489                 if (*(punresolved + 1) == '/')
 490                 {
 491                     punresolved += 2;
 492                     continue;
 493                 }
 494                 if ((*(punresolved + 1) == '.') && (*(punresolved + 2) == '\0' || (*(punresolved + 2) == '/')))
 495                 {
 496                     _rmlastpathtoken(path_resolved_so_far);
 497
 498                     presolvedsf = ustrtoend(path_resolved_so_far) - 1;
 499
 500                     if (*(punresolved + 2) == '/')
 501                         punresolved += 3;
 502                     else
 503                         punresolved += 2;
 504
 505                     continue;
 506                 }
 507
 508                 /* a file or directory name may start with '.' */
 509                 if ((presolvedsf = ustrtoend(path_resolved_so_far)) > sentinel)
 510                     return oslTranslateFileError(ENAMETOOLONG);
 511
 512                 ustrchrcat(*punresolved++, path_resolved_so_far);
 513
 514                 if (*punresolved == '\0' && !realpath_failed)
 515                 {
 516                     ferr = _osl_resolvepath(
 517                         path_resolved_so_far,
 518                         &realpath_failed);
 519
 520                     if (ferr != osl_File_E_None)
 521                         return ferr;
 522                 }
 523             }
 524             else if (*punresolved == '/')
 525             {
 526                 if ((presolvedsf = ustrtoend(path_resolved_so_far)) > sentinel)
 527                     return oslTranslateFileError(ENAMETOOLONG);
 528
 529                 ustrchrcat(*punresolved++, path_resolved_so_far);
 530
 531                 if (!realpath_failed)
 532                 {
 533                     ferr = _osl_resolvepath(
 534                         path_resolved_so_far,
 535                         &realpath_failed);
 536
 537                     if (ferr != osl_File_E_None)
 538                         return ferr;
 539
 540                     if (!_islastchr(path_resolved_so_far, '/'))
 541                     {
 542                         if ((presolvedsf = ustrtoend(path_resolved_so_far)) > sentinel)
 543                             return oslTranslateFileError(ENAMETOOLONG);
 544
 545                         ustrchrcat('/', path_resolved_so_far);
 546                     }
 547                 }
 548             }
 549             else // any other character
 550             {
 551                 if ((presolvedsf = ustrtoend(path_resolved_so_far)) > sentinel)
 552                     return oslTranslateFileError(ENAMETOOLONG);
 553
 554                 ustrchrcat(*punresolved++, path_resolved_so_far);
 555
 556                 if (*punresolved == '\0' && !realpath_failed)
 557                 {
 558                     ferr = _osl_resolvepath(
 559                         path_resolved_so_far,
 560                         &realpath_failed);
 561
 562                     if (ferr != osl_File_E_None)
 563                         return ferr;
 564                 }
 565             }
 566         }
 567
 568         sal_Int32 len = rtl_ustr_getLength(path_resolved_so_far);
 569
 570         OSL_ASSERT(len < PATH_MAX);
 571
 572         resolved_path = OUString(path_resolved_so_far, len);
 573
 574         return osl_File_E_None;
 575     }
 576
 577 }
 578
 579 oslFileError osl_getAbsoluteFileURL(
 580         rtl_uString* ustrBaseDirURL,
 581         rtl_uString* ustrRelativeURL,
 582         rtl_uString** pustrAbsoluteURL)
 583 {
 584     /* Work around the below call to getSystemPathFromFileURL rejecting input
 585        that starts with "/" (for whatever reason it behaves that way; but
 586        changing that would start to break lots of tests at least) */
 587     OUString relUrl(ustrRelativeURL);
 588     if (relUrl.startsWith("//"))
 589         relUrl = "file:" + relUrl;
 590     else if (relUrl.startsWith("/"))
 591         relUrl = "file://" + relUrl;
 592
 593     OUString unresolved_path;
 594
 595     FileBase::RC frc = FileBase::getSystemPathFromFileURL(relUrl, unresolved_path);
 596     if (frc != FileBase::E_None)
 597         return oslFileError(frc);
 598
 599     if (systemPathIsRelativePath(unresolved_path))
 600     {
 601         OUString base_path;
 602         oslFileError rc = osl_getSystemPathFromFileURL_Ex(ustrBaseDirURL, &base_path.pData);
 603         if (rc != osl_File_E_None)
 604             return rc;
 605
 606         OUString abs_path;
 607         systemPathMakeAbsolutePath(base_path, unresolved_path, abs_path);
 608
 609         unresolved_path = abs_path;
 610     }
 611
 612     OUString resolved_path;
 613     oslFileError rc = osl_getAbsoluteFileURL_impl_(unresolved_path, resolved_path);
 614     if (rc == osl_File_E_None)
 615     {
 616         rc = osl_getFileURLFromSystemPath(resolved_path.pData, pustrAbsoluteURL);
 617         OSL_ASSERT(osl_File_E_None == rc);
 618     }
 619
 620     return rc;
 621 }
 622
 623 namespace osl {
 624 namespace detail {
 625
 626     /**
 627      No separate error code if unicode to text conversion or getenv fails because for the
 628      caller there is no difference why a file could not be found in $PATH
 629     */
 630     bool find_in_PATH(const OUString& file_path, OUString& result)
 631     {
 632         bool bfound = false;
 633         OUString path("PATH");
 634         OUString env_path;
 635
 636         if (osl_getEnvironment(path.pData, &env_path.pData) == osl_Process_E_None)
 637             bfound = osl::searchPath(file_path, env_path, result);
 638
 639         return bfound;
 640     }
 641 }
 642 }
 643
 644 namespace
 645 {
 646     /**
 647      No separate error code if unicode to text conversion or getcwd fails because for the
 648      caller there is no difference why a file could not be found in CDW
 649     */
 650     bool find_in_CWD(const OUString& file_path, OUString& result)
 651     {
 652         bool bfound = false;
 653         OUString cwd_url;
 654
 655         if (osl_getProcessWorkingDir(&cwd_url.pData) == osl_Process_E_None)
 656         {
 657             OUString cwd;
 658             FileBase::getSystemPathFromFileURL(cwd_url, cwd);
 659             bfound = osl::searchPath(file_path, cwd, result);
 660         }
 661         return bfound;
 662     }
 663
 664     bool find_in_searchPath(const OUString& file_path, rtl_uString* search_path, OUString& result)
 665     {
 666         return (search_path && osl::searchPath(file_path, OUString(search_path), result));
 667     }
 668
 669 }
 670
 671 oslFileError osl_searchFileURL(rtl_uString* ustrFilePath, rtl_uString* ustrSearchPath, rtl_uString** pustrURL)
 672 {
 673     OSL_PRECOND(ustrFilePath && pustrURL, "osl_searchFileURL: invalid parameter");
 674
 675     FileBase::RC  rc;
 676     OUString file_path;
 677
 678     // try to interpret search path as file url else assume it's a system path list
 679     rc = FileBase::getSystemPathFromFileURL(ustrFilePath, file_path);
 680     if (rc == FileBase::E_INVAL)
 681         file_path = ustrFilePath;
 682     else if (rc != FileBase::E_None)
 683         return oslFileError(rc);
 684
 685     bool          bfound = false;
 686     OUString result;
 687
 688     if (find_in_searchPath(file_path, ustrSearchPath, result) ||
 689         osl::detail::find_in_PATH(file_path, result) ||
 690         find_in_CWD(file_path, result))
 691     {
 692         OUString resolved;
 693
 694         if (osl::realpath(result, resolved))
 695         {
 696             oslFileError osl_error = osl_getFileURLFromSystemPath(resolved.pData, pustrURL);
 697             SAL_WARN_IF(osl_File_E_None != osl_error, "sal.file", "osl_getFileURLFromSystemPath failed");
 698             bfound = true;
 699         }
 700     }
 701     return bfound ? osl_File_E_None : osl_File_E_NOENT;
 702 }
 703
 704 oslFileError FileURLToPath(char * buffer, size_t bufLen, rtl_uString* ustrFileURL)
 705 {
 706     rtl_uString* ustrSystemPath = nullptr;
 707     oslFileError osl_error      = osl_getSystemPathFromFileURL(ustrFileURL, &ustrSystemPath);
 708
 709     if(osl_error != osl_File_E_None)
 710         return osl_error;
 711
 712     osl_systemPathRemoveSeparator(ustrSystemPath);
 713
 714     /* convert unicode path to text */
 715     if(!UnicodeToText( buffer, bufLen, ustrSystemPath->buffer, ustrSystemPath->length))
 716         osl_error = oslTranslateFileError(errno);
 717
 718     rtl_uString_release(ustrSystemPath);
 719
 720     return osl_error;
 721 }
 722
 723 namespace
 724 {
 725     class UnicodeToTextConverter_Impl
 726     {
 727         rtl_UnicodeToTextConverter const m_converter;
 728
 729         UnicodeToTextConverter_Impl()
 730             : m_converter (rtl_createUnicodeToTextConverter (osl_getThreadTextEncoding()))
 731         {}
 732
 733         ~UnicodeToTextConverter_Impl()
 734         {
 735             rtl_destroyUnicodeToTextConverter (m_converter);
 736         }
 737     public:
 738         static UnicodeToTextConverter_Impl & getInstance()
 739         {
 740             static UnicodeToTextConverter_Impl g_theConverter;
 741             return g_theConverter;
 742         }
 743
 744         sal_Size convert(
 745             sal_Unicode const * pSrcBuf, sal_Size nSrcChars, sal_Char * pDstBuf, sal_Size nDstBytes,
 746             sal_uInt32 nFlags, sal_uInt32 * pInfo, sal_Size * pSrcCvtChars)
 747         {
 748             OSL_ASSERT(m_converter != nullptr);
 749             return rtl_convertUnicodeToText (
 750                 m_converter, nullptr, pSrcBuf, nSrcChars, pDstBuf, nDstBytes, nFlags, pInfo, pSrcCvtChars);
 751         }
 752     };
 753 }
 754
 755 int UnicodeToText( char * buffer, size_t bufLen, const sal_Unicode * uniText, sal_Int32 uniTextLen )
 756 {
 757     sal_uInt32   nInfo = 0;
 758     sal_Size     nSrcChars = 0;
 759
 760     sal_Size nDestBytes = UnicodeToTextConverter_Impl::getInstance().convert (
 761         uniText, uniTextLen, buffer, bufLen,
 762         OUSTRING_TO_OSTRING_CVTFLAGS | RTL_UNICODETOTEXT_FLAGS_FLUSH, &nInfo, &nSrcChars);
 763
 764     if( nInfo & RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL )
 765     {
 766         errno = EOVERFLOW;
 767         return 0;
 768     }
 769
 770     /* ensure trailing '\0' */
 771     buffer[nDestBytes] = '\0';
 772     return nDestBytes;
 773 }
 774
 775 namespace
 776 {
 777     class TextToUnicodeConverter_Impl
 778     {
 779         rtl_TextToUnicodeConverter const m_converter;
 780
 781         TextToUnicodeConverter_Impl()
 782             : m_converter (rtl_createTextToUnicodeConverter (osl_getThreadTextEncoding()))
 783         {}
 784
 785         ~TextToUnicodeConverter_Impl()
 786         {
 787             rtl_destroyTextToUnicodeConverter (m_converter);
 788         }
 789
 790     public:
 791         static TextToUnicodeConverter_Impl & getInstance()
 792         {
 793             static TextToUnicodeConverter_Impl g_theConverter;
 794             return g_theConverter;
 795         }
 796
 797         sal_Size convert(
 798             sal_Char const * pSrcBuf, sal_Size nSrcBytes, sal_Unicode * pDstBuf, sal_Size nDstChars,
 799             sal_uInt32 nFlags, sal_uInt32 * pInfo, sal_Size * pSrcCvtBytes)
 800         {
 801             OSL_ASSERT(m_converter != nullptr);
 802             return rtl_convertTextToUnicode (
 803                 m_converter, nullptr, pSrcBuf, nSrcBytes, pDstBuf, nDstChars, nFlags, pInfo, pSrcCvtBytes);
 804         }
 805     };
 806 }
 807
 808 int TextToUnicode(
 809     const char*  text,
 810     size_t text_buffer_size,
 811     sal_Unicode* unic_text,
 812     sal_Int32 unic_text_buffer_size)
 813 {
 814     sal_uInt32 nInfo = 0;
 815     sal_Size nSrcChars = 0;
 816
 817     sal_Size nDestBytes = TextToUnicodeConverter_Impl::getInstance().convert(
 818         text, text_buffer_size, unic_text, unic_text_buffer_size,
 819         OSTRING_TO_OUSTRING_CVTFLAGS | RTL_TEXTTOUNICODE_FLAGS_FLUSH, &nInfo, &nSrcChars);
 820
 821     if (nInfo & RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOOSMALL)
 822     {
 823         errno = EOVERFLOW;
 824         return 0;
 825     }
 826
 827     /* ensure trailing '\0' */
 828     unic_text[nDestBytes] = '\0';
 829     return nDestBytes;
 830 }
 831
 832 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */