sal/rtl/bootstrap.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 #include <config_features.h>
  20 #include <config_folders.h>
  21
  22 #include <rtl/bootstrap.h>
  23 #include <rtl/bootstrap.hxx>
  24 #include <osl/diagnose.h>
  25 #include <osl/module.h>
  26 #include <osl/process.h>
  27 #include <osl/file.hxx>
  28 #include <osl/mutex.hxx>
  29 #include <osl/profile.hxx>
  30 #include <osl/security.hxx>
  31 #include <rtl/alloc.h>
  32 #include <rtl/string.hxx>
  33 #include <rtl/ustrbuf.hxx>
  34 #include <rtl/ustring.hxx>
  35 #include <rtl/byteseq.hxx>
  36 #include <rtl/instance.hxx>
  37 #include <rtl/malformeduriexception.hxx>
  38 #include <rtl/uri.hxx>
  39 #include <sal/log.hxx>
  40 #include <o3tl/lru_map.hxx>
  41
  42 #include <vector>
  43 #include <algorithm>
  44 #include <unordered_map>
  45
  46 #ifdef ANDROID
  47 #include <osl/detail/android-bootstrap.h>
  48 #endif
  49
  50 #ifdef IOS
  51 #include <premac.h>
  52 #import <Foundation/Foundation.h>
  53 #include <postmac.h>
  54 #endif
  55
  56 using osl::DirectoryItem;
  57 using osl::FileStatus;
  58
  59 namespace
  60 {
  61
  62 struct Bootstrap_Impl;
  63
  64 char const VND_SUN_STAR_PATHNAME[] = "vnd.sun.star.pathname:";
  65
  66 bool isPathnameUrl(OUString const & url)
  67 {
  68     return url.matchIgnoreAsciiCase(VND_SUN_STAR_PATHNAME);
  69 }
  70
  71 bool resolvePathnameUrl(OUString * url)
  72 {
  73     OSL_ASSERT(url);
  74     if (!isPathnameUrl(*url) ||
  75         (osl::FileBase::getFileURLFromSystemPath(
  76             url->copy(RTL_CONSTASCII_LENGTH(VND_SUN_STAR_PATHNAME)), *url) ==
  77          osl::FileBase::E_None))
  78     {
  79         return true;
  80     }
  81     *url = OUString();
  82     return false;
  83 }
  84
  85 enum LookupMode {
  86     LOOKUP_MODE_NORMAL, LOOKUP_MODE_URE_BOOTSTRAP,
  87     LOOKUP_MODE_URE_BOOTSTRAP_EXPANSION };
  88
  89 struct ExpandRequestLink {
  90     ExpandRequestLink const * next;
  91     Bootstrap_Impl const * file;
  92     OUString key;
  93 };
  94
  95 OUString expandMacros(
  96     Bootstrap_Impl const * file, OUString const & text, LookupMode mode,
  97     ExpandRequestLink const * requestStack);
  98
  99 OUString recursivelyExpandMacros(
 100     Bootstrap_Impl const * file, OUString const & text, LookupMode mode,
 101     Bootstrap_Impl const * requestFile, OUString const & requestKey,
 102     ExpandRequestLink const * requestStack)
 103 {
 104     for (; requestStack; requestStack = requestStack->next) {
 105         if (requestStack->file == requestFile &&
 106             requestStack->key == requestKey)
 107         {
 108             return "***RECURSION DETECTED***";
 109         }
 110     }
 111     ExpandRequestLink link = { requestStack, requestFile, requestKey };
 112     return expandMacros(file, text, mode, &link);
 113 }
 114
 115 struct rtl_bootstrap_NameValue
 116 {
 117     OUString sName;
 118     OUString sValue;
 119
 120     rtl_bootstrap_NameValue()
 121         {}
 122     rtl_bootstrap_NameValue(OUString const & name, OUString const & value )
 123         : sName( name ),
 124           sValue( value )
 125         {}
 126 };
 127
 128 } // end namespace
 129
 130 typedef std::vector<rtl_bootstrap_NameValue> NameValueVector;
 131
 132 static bool find(
 133     NameValueVector const & vector, OUString const & key,
 134     OUString * value)
 135 {
 136     OSL_ASSERT(value);
 137     auto i = std::find_if(vector.begin(), vector.end(),
 138         [&key](const rtl_bootstrap_NameValue& rNameValue) { return rNameValue.sName == key; });
 139     if (i != vector.end())
 140     {
 141         *value = i->sValue;
 142         return true;
 143     }
 144     return false;
 145 }
 146
 147 namespace
 148 {
 149     NameValueVector rtl_bootstrap_set_vector;
 150 }
 151
 152 static bool getFromCommandLineArgs(
 153     OUString const & key, OUString * value )
 154 {
 155     OSL_ASSERT(value);
 156
 157     static NameValueVector nameValueVector = [&]()
 158     {
 159         NameValueVector tmp;
 160
 161         sal_Int32 nArgCount = osl_getCommandArgCount();
 162         for(sal_Int32 i = 0; i < nArgCount; ++ i)
 163         {
 164             OUString pArg;
 165             osl_getCommandArg( i, &pArg.pData );
 166             if( (pArg.startsWith("-") || pArg.startsWith("/") ) &&
 167                 pArg.match("env:", 1) )
 168             {
 169                 sal_Int32 nIndex = pArg.indexOf( '=' );
 170
 171                 if( nIndex >= 0 )
 172                 {
 173                     rtl_bootstrap_NameValue nameValue;
 174                     nameValue.sName = pArg.copy( 5, nIndex - 5  );
 175                     nameValue.sValue = pArg.copy( nIndex+1 );
 176
 177                     if( i == nArgCount-1 &&
 178                         nameValue.sValue.getLength() &&
 179                         nameValue.sValue[nameValue.sValue.getLength()-1] == 13 )
 180                     {
 181                         // avoid the 13 linefeed for the last argument,
 182                         // when the executable is started from a script,
 183                         // that was edited on windows
 184                         nameValue.sValue = nameValue.sValue.copy(0,nameValue.sValue.getLength()-1);
 185                     }
 186
 187                     tmp.push_back( nameValue );
 188                 }
 189             }
 190         };
 191         return tmp;
 192     }();
 193
 194     return find(nameValueVector, key, value);
 195 }
 196
 197 static void getExecutableDirectory_Impl(rtl_uString ** ppDirURL)
 198 {
 199     OUString fileName;
 200     osl_getExecutableFile(&(fileName.pData));
 201
 202     sal_Int32 nDirEnd = fileName.lastIndexOf('/');
 203     OSL_ENSURE(nDirEnd >= 0, "Cannot locate executable directory");
 204
 205     rtl_uString_newFromStr_WithLength(ppDirURL,fileName.getStr(),nDirEnd);
 206 }
 207
 208 static OUString & getIniFileName_Impl()
 209 {
 210     static OUString aStaticName = []() {
 211         OUString fileName;
 212
 213 #if defined IOS
 214         // On iOS hardcode the inifile as "rc" in the .app
 215         // directory. Apps are self-contained anyway, there is no
 216         // possibility to have several "applications" in the same
 217         // installation location with different inifiles.
 218         const char *inifile = [[@"vnd.sun.star.pathname:" stringByAppendingString: [[[NSBundle mainBundle] bundlePath] stringByAppendingPathComponent: @"rc"]] UTF8String];
 219         fileName = OUString(inifile, strlen(inifile), RTL_TEXTENCODING_UTF8);
 220         resolvePathnameUrl(&fileName);
 221 #elif defined ANDROID
 222         // Apps are self-contained on Android, too, can as well hardcode
 223         // it as "rc" in the "/assets" directory, i.e.  inside the app's
 224         // .apk (zip) archive as the /assets/rc file.
 225         fileName = OUString("vnd.sun.star.pathname:/assets/rc");
 226         resolvePathnameUrl(&fileName);
 227 #else
 228         if (getFromCommandLineArgs("INIFILENAME", &fileName))
 229         {
 230             resolvePathnameUrl(&fileName);
 231         }
 232         else
 233         {
 234             osl_getExecutableFile(&(fileName.pData));
 235
 236             // get rid of a potential executable extension
 237             OUString progExt = ".bin";
 238             if (fileName.getLength() > progExt.getLength()
 239                 && fileName.copy(fileName.getLength() - progExt.getLength()).equalsIgnoreAsciiCase(progExt))
 240             {
 241                 fileName = fileName.copy(0, fileName.getLength() - progExt.getLength());
 242             }
 243
 244             progExt = ".exe";
 245             if (fileName.getLength() > progExt.getLength()
 246                 && fileName.copy(fileName.getLength() - progExt.getLength()).equalsIgnoreAsciiCase(progExt))
 247             {
 248                 fileName = fileName.copy(0, fileName.getLength() - progExt.getLength());
 249             }
 250
 251             // append config file suffix
 252             fileName += SAL_CONFIGFILE("");
 253
 254 #ifdef MACOSX
 255             // We keep only executables in the MacOS folder, and all
 256             // rc files in LIBO_ETC_FOLDER (typically "Resources").
 257             sal_Int32 off = fileName.lastIndexOf( "/MacOS/" );
 258             if (off != -1)
 259                 fileName = fileName.replaceAt(off + 1, strlen("MacOS"), LIBO_ETC_FOLDER);
 260 #endif
 261         }
 262 #endif
 263
 264         return fileName;
 265     }();
 266
 267     return aStaticName;
 268 }
 269
 270 // ensure the given file url has no final slash
 271
 272 static void EnsureNoFinalSlash (OUString & url)
 273 {
 274     sal_Int32 i = url.getLength();
 275
 276     if (i > 0 && url[i - 1] == '/')
 277         url = url.copy(0, i - 1);
 278 }
 279
 280 namespace {
 281
 282 struct Bootstrap_Impl
 283 {
 284     sal_Int32 _nRefCount;
 285     Bootstrap_Impl * _base_ini;
 286
 287     NameValueVector _nameValueVector;
 288     OUString      _iniName;
 289
 290     explicit Bootstrap_Impl (OUString const & rIniName);
 291     ~Bootstrap_Impl();
 292
 293     static void * operator new (std::size_t n)
 294         { return malloc (sal_uInt32(n)); }
 295     static void operator delete (void * p , std::size_t)
 296         { free (p); }
 297
 298     bool getValue(
 299         OUString const & key, rtl_uString ** value,
 300         rtl_uString * defaultValue, LookupMode mode, bool override,
 301         ExpandRequestLink const * requestStack) const;
 302     bool getDirectValue(
 303         OUString const & key, rtl_uString ** value, LookupMode mode,
 304         ExpandRequestLink const * requestStack) const;
 305     bool getAmbienceValue(
 306         OUString const & key, rtl_uString ** value, LookupMode mode,
 307         ExpandRequestLink const * requestStack) const;
 308     void expandValue(
 309         rtl_uString ** value, OUString const & text, LookupMode mode,
 310         Bootstrap_Impl const * requestFile, OUString const & requestKey,
 311         ExpandRequestLink const * requestStack) const;
 312 };
 313
 314 }
 315
 316 Bootstrap_Impl::Bootstrap_Impl( OUString const & rIniName )
 317     : _nRefCount( 0 ),
 318       _base_ini( nullptr ),
 319       _iniName (rIniName)
 320 {
 321     OUString base_ini(getIniFileName_Impl());
 322     // normalize path
 323     FileStatus status( osl_FileStatus_Mask_FileURL );
 324     DirectoryItem dirItem;
 325     if (DirectoryItem::get(base_ini, dirItem) == DirectoryItem::E_None &&
 326         dirItem.getFileStatus(status) == DirectoryItem::E_None)
 327     {
 328         base_ini = status.getFileURL();
 329         if (rIniName != base_ini)
 330         {
 331             _base_ini = static_cast< Bootstrap_Impl * >(
 332                 rtl_bootstrap_args_open(base_ini.pData));
 333         }
 334     }
 335     SAL_INFO("sal.bootstrap", "Bootstrap_Impl(): sFile=" << _iniName);
 336     oslFileHandle handle;
 337     if (!_iniName.isEmpty() &&
 338         osl_openFile(_iniName.pData, &handle, osl_File_OpenFlag_Read) == osl_File_E_None)
 339     {
 340         rtl::ByteSequence seq;
 341
 342         while (osl_readLine(handle , reinterpret_cast<sal_Sequence **>(&seq)) == osl_File_E_None)
 343         {
 344             OString line(reinterpret_cast<const char *>(seq.getConstArray()), seq.getLength());
 345             sal_Int32 nIndex = line.indexOf('=');
 346             if (nIndex >= 1)
 347             {
 348                 struct rtl_bootstrap_NameValue nameValue;
 349                 nameValue.sName = OStringToOUString(line.copy(0,nIndex).trim(), RTL_TEXTENCODING_ASCII_US);
 350                 nameValue.sValue = OStringToOUString(line.copy(nIndex+1).trim(), RTL_TEXTENCODING_UTF8);
 351
 352                 SAL_INFO("sal.bootstrap", "pushing: name=" << nameValue.sName << " value=" << nameValue.sValue);
 353
 354                 _nameValueVector.push_back(nameValue);
 355             }
 356         }
 357         osl_closeFile(handle);
 358     }
 359     else
 360     {
 361         SAL_INFO( "sal.bootstrap", "couldn't open file: " <<  _iniName );
 362     }
 363 }
 364
 365 Bootstrap_Impl::~Bootstrap_Impl()
 366 {
 367     if (_base_ini)
 368         rtl_bootstrap_args_close( _base_ini );
 369 }
 370
 371 namespace {
 372
 373 Bootstrap_Impl * get_static_bootstrap_handle()
 374 {
 375     static Bootstrap_Impl* s_handle = []() {
 376         OUString iniName(getIniFileName_Impl());
 377         Bootstrap_Impl* that = static_cast<Bootstrap_Impl*>(rtl_bootstrap_args_open(iniName.pData));
 378         if (!that)
 379         {
 380             that = new Bootstrap_Impl(iniName);
 381             ++that->_nRefCount;
 382         }
 383         return that;
 384     }();
 385
 386     return s_handle;
 387 }
 388
 389 struct FundamentalIniData
 390 {
 391     rtlBootstrapHandle ini;
 392
 393     FundamentalIniData()
 394     {
 395         OUString uri;
 396         ini =
 397             (get_static_bootstrap_handle()->getValue(
 398                 "URE_BOOTSTRAP", &uri.pData, nullptr, LOOKUP_MODE_NORMAL, false,
 399                 nullptr)
 400              && resolvePathnameUrl(&uri))
 401             ? rtl_bootstrap_args_open(uri.pData) : nullptr;
 402     }
 403
 404     ~FundamentalIniData() { rtl_bootstrap_args_close(ini); }
 405
 406     FundamentalIniData(const FundamentalIniData&) = delete;
 407     FundamentalIniData& operator=(const FundamentalIniData&) = delete;
 408 };
 409
 410 struct FundamentalIni: public rtl::Static< FundamentalIniData, FundamentalIni >
 411 {};
 412
 413 }
 414
 415 bool Bootstrap_Impl::getValue(
 416     OUString const & key, rtl_uString ** value, rtl_uString * defaultValue,
 417     LookupMode mode, bool override, ExpandRequestLink const * requestStack)
 418     const
 419 {
 420     if (mode == LOOKUP_MODE_NORMAL && key == "URE_BOOTSTRAP")
 421         mode = LOOKUP_MODE_URE_BOOTSTRAP;
 422
 423     if (override && getDirectValue(key, value, mode, requestStack))
 424         return true;
 425
 426     if (key == "_OS")
 427     {
 428         rtl_uString_assign(
 429             value, OUString(RTL_OS).pData);
 430         return true;
 431     }
 432
 433     if (key == "_ARCH")
 434     {
 435         rtl_uString_assign(
 436             value, OUString(RTL_ARCH).pData);
 437         return true;
 438     }
 439
 440     if (key == "_CPPU_ENV")
 441     {
 442         rtl_uString_assign(
 443             value,
 444             (OUString(
 445                 SAL_STRINGIFY(CPPU_ENV)).
 446              pData));
 447         return true;
 448     }
 449
 450 #ifdef ANDROID
 451     if (key == "APP_DATA_DIR")
 452     {
 453         const char *app_data_dir = lo_get_app_data_dir();
 454         rtl_uString_assign(
 455             value, OUString(app_data_dir, strlen(app_data_dir), RTL_TEXTENCODING_UTF8).pData);
 456         return true;
 457     }
 458 #endif
 459
 460 #ifdef IOS
 461     if (key == "APP_DATA_DIR")
 462     {
 463         const char *app_data_dir = [[[[NSBundle mainBundle] bundlePath] stringByAddingPercentEncodingWithAllowedCharacters: [NSCharacterSet URLPathAllowedCharacterSet]] UTF8String];
 464         rtl_uString_assign(
 465             value, OUString(app_data_dir, strlen(app_data_dir), RTL_TEXTENCODING_UTF8).pData);
 466         return true;
 467     }
 468 #endif
 469
 470     if (key == "ORIGIN")
 471     {
 472         rtl_uString_assign(
 473             value,
 474             _iniName.copy(
 475                 0, std::max<sal_Int32>(0, _iniName.lastIndexOf('/'))).pData);
 476         return true;
 477     }
 478
 479     if (getAmbienceValue(key, value, mode, requestStack))
 480         return true;
 481
 482     if (key == "SYSUSERCONFIG")
 483     {
 484         OUString v;
 485         bool b = osl::Security().getConfigDir(v);
 486         EnsureNoFinalSlash(v);
 487         rtl_uString_assign(value, v.pData);
 488         return b;
 489     }
 490
 491     if (key == "SYSUSERHOME")
 492     {
 493         OUString v;
 494         bool b = osl::Security().getHomeDir(v);
 495         EnsureNoFinalSlash(v);
 496         rtl_uString_assign(value, v.pData);
 497         return b;
 498     }
 499
 500     if (key == "SYSBINDIR")
 501     {
 502         getExecutableDirectory_Impl(value);
 503         return true;
 504     }
 505
 506     if (_base_ini != nullptr && _base_ini->getDirectValue(key, value, mode, requestStack))
 507         return true;
 508
 509     if (!override && getDirectValue(key, value, mode, requestStack))
 510         return true;
 511
 512     if (mode == LOOKUP_MODE_NORMAL)
 513     {
 514         FundamentalIniData const & d = FundamentalIni::get();
 515         Bootstrap_Impl const * b = static_cast<Bootstrap_Impl const *>(d.ini);
 516         if (b != nullptr && b != this && b->getDirectValue(key, value, mode, requestStack))
 517             return true;
 518     }
 519
 520     if (defaultValue != nullptr)
 521     {
 522         rtl_uString_assign(value, defaultValue);
 523         return true;
 524     }
 525
 526     rtl_uString_new(value);
 527     return false;
 528 }
 529
 530 bool Bootstrap_Impl::getDirectValue(
 531     OUString const & key, rtl_uString ** value, LookupMode mode,
 532     ExpandRequestLink const * requestStack) const
 533 {
 534     OUString v;
 535     if (find(_nameValueVector, key, &v))
 536     {
 537         expandValue(value, v, mode, this, key, requestStack);
 538         return true;
 539     }
 540
 541     return false;
 542 }
 543
 544 bool Bootstrap_Impl::getAmbienceValue(
 545     OUString const & key, rtl_uString ** value, LookupMode mode,
 546     ExpandRequestLink const * requestStack) const
 547 {
 548     OUString v;
 549     bool f;
 550
 551     {
 552         osl::MutexGuard g(osl::Mutex::getGlobalMutex());
 553         f = find(rtl_bootstrap_set_vector, key, &v);
 554     }
 555
 556     if (f || getFromCommandLineArgs(key, &v) ||
 557         osl_getEnvironment(key.pData, &v.pData) == osl_Process_E_None)
 558     {
 559         expandValue(value, v, mode, nullptr, key, requestStack);
 560         return true;
 561     }
 562
 563     return false;
 564 }
 565
 566 void Bootstrap_Impl::expandValue(
 567     rtl_uString ** value, OUString const & text, LookupMode mode,
 568     Bootstrap_Impl const * requestFile, OUString const & requestKey,
 569     ExpandRequestLink const * requestStack) const
 570 {
 571     rtl_uString_assign(
 572         value,
 573         (mode == LOOKUP_MODE_URE_BOOTSTRAP && isPathnameUrl(text) ?
 574          text :
 575          recursivelyExpandMacros(
 576              this, text,
 577              (mode == LOOKUP_MODE_URE_BOOTSTRAP ?
 578               LOOKUP_MODE_URE_BOOTSTRAP_EXPANSION : mode),
 579              requestFile, requestKey, requestStack)).pData);
 580 }
 581
 582 namespace {
 583
 584 typedef std::unordered_map< OUString, Bootstrap_Impl * > bootstrap_map_t;
 585 bootstrap_map_t bootstrap_map;
 586
 587 }
 588
 589 rtlBootstrapHandle SAL_CALL rtl_bootstrap_args_open(rtl_uString * pIniName)
 590 {
 591     static o3tl::lru_map<OUString,OUString> fileUrlLookupCache(16);
 592
 593     OUString originalIniName( pIniName );
 594     OUString iniName;
 595
 596     osl::ResettableMutexGuard guard(osl::Mutex::getGlobalMutex());
 597     auto cacheIt = fileUrlLookupCache.find(originalIniName);
 598     bool foundInCache = cacheIt != fileUrlLookupCache.end();
 599     if (foundInCache)
 600         iniName = cacheIt->second;
 601     guard.clear();
 602
 603     // normalize path
 604     if (!foundInCache)
 605     {
 606         FileStatus status(osl_FileStatus_Mask_FileURL);
 607         DirectoryItem dirItem;
 608         if (DirectoryItem::get(originalIniName, dirItem) != DirectoryItem::E_None ||
 609             dirItem.getFileStatus(status) != DirectoryItem::E_None)
 610         {
 611             return nullptr;
 612         }
 613         iniName = status.getFileURL();
 614     }
 615
 616     guard.reset();
 617     if (!foundInCache)
 618         fileUrlLookupCache.insert({originalIniName, iniName});
 619     Bootstrap_Impl * that;
 620     auto iFind(bootstrap_map.find(iniName));
 621     if (iFind == bootstrap_map.end())
 622     {
 623         guard.clear();
 624         that = new Bootstrap_Impl(iniName);
 625         guard.reset();
 626         iFind = bootstrap_map.find(iniName);
 627         if (iFind == bootstrap_map.end())
 628         {
 629             ++that->_nRefCount;
 630             ::std::pair< bootstrap_map_t::iterator, bool > insertion(
 631                 bootstrap_map.emplace(iniName, that));
 632             OSL_ASSERT(insertion.second);
 633         }
 634         else
 635         {
 636             Bootstrap_Impl * obsolete = that;
 637             that = iFind->second;
 638             ++that->_nRefCount;
 639             guard.clear();
 640             delete obsolete;
 641         }
 642     }
 643     else
 644     {
 645         that = iFind->second;
 646         ++that->_nRefCount;
 647     }
 648     return static_cast< rtlBootstrapHandle >( that );
 649 }
 650
 651 void SAL_CALL rtl_bootstrap_args_close(rtlBootstrapHandle handle) SAL_THROW_EXTERN_C()
 652 {
 653     if (!handle)
 654         return;
 655
 656     Bootstrap_Impl * that = static_cast< Bootstrap_Impl * >( handle );
 657
 658     osl::MutexGuard guard(osl::Mutex::getGlobalMutex());
 659     OSL_ASSERT(bootstrap_map.find(that->_iniName)->second == that);
 660     --that->_nRefCount;
 661
 662     if (that->_nRefCount != 0)
 663         return;
 664
 665     std::size_t const nLeaking = 8; // only hold up to 8 files statically
 666     if (bootstrap_map.size() > nLeaking)
 667     {
 668         ::std::size_t erased = bootstrap_map.erase( that->_iniName );
 669         if (erased != 1) {
 670             OSL_ASSERT( false );
 671         }
 672         delete that;
 673     }
 674 }
 675
 676 sal_Bool SAL_CALL rtl_bootstrap_get_from_handle(
 677     rtlBootstrapHandle handle,
 678     rtl_uString      * pName,
 679     rtl_uString     ** ppValue,
 680     rtl_uString      * pDefault
 681 )
 682 {
 683     osl::MutexGuard guard(osl::Mutex::getGlobalMutex());
 684
 685     bool found = false;
 686     if(ppValue && pName)
 687     {
 688         if (!handle)
 689             handle = get_static_bootstrap_handle();
 690
 691         found = static_cast< Bootstrap_Impl * >(handle)->getValue(
 692             pName, ppValue, pDefault, LOOKUP_MODE_NORMAL, false, nullptr );
 693     }
 694
 695     return found;
 696 }
 697
 698 void SAL_CALL rtl_bootstrap_get_iniName_from_handle (
 699     rtlBootstrapHandle handle,
 700     rtl_uString     ** ppIniName
 701 )
 702 {
 703     if(!ppIniName)
 704         return;
 705
 706     if(handle)
 707     {
 708         Bootstrap_Impl * pImpl = static_cast<Bootstrap_Impl*>(handle);
 709         rtl_uString_assign(ppIniName, pImpl->_iniName.pData);
 710     }
 711     else
 712     {
 713         const OUString & iniName = getIniFileName_Impl();
 714         rtl_uString_assign(ppIniName, iniName.pData);
 715     }
 716 }
 717
 718 void SAL_CALL rtl_bootstrap_setIniFileName (
 719     rtl_uString * pName
 720 )
 721 {
 722     osl::MutexGuard guard(osl::Mutex::getGlobalMutex());
 723     OUString & file = getIniFileName_Impl();
 724     file = pName;
 725 }
 726
 727 sal_Bool SAL_CALL rtl_bootstrap_get (
 728     rtl_uString  * pName,
 729     rtl_uString ** ppValue,
 730     rtl_uString  * pDefault
 731 )
 732 {
 733     return rtl_bootstrap_get_from_handle(nullptr, pName, ppValue, pDefault);
 734 }
 735
 736 void SAL_CALL rtl_bootstrap_set (
 737     rtl_uString * pName,
 738     rtl_uString * pValue
 739 )
 740 {
 741     const OUString name(pName);
 742     const OUString value(pValue);
 743
 744     osl::MutexGuard guard(osl::Mutex::getGlobalMutex());
 745
 746     for (auto & item : rtl_bootstrap_set_vector)
 747     {
 748         if (item.sName == name)
 749         {
 750             item.sValue = value;
 751             return;
 752         }
 753     }
 754
 755     SAL_INFO("sal.bootstrap", "explicitly getting: name=" << name << " value=" <<value);
 756
 757     rtl_bootstrap_set_vector.emplace_back(name, value);
 758 }
 759
 760 void SAL_CALL rtl_bootstrap_expandMacros_from_handle(
 761     rtlBootstrapHandle handle,
 762     rtl_uString     ** macro)
 763 {
 764     if (!handle)
 765         handle = get_static_bootstrap_handle();
 766
 767     OUString expanded(expandMacros(static_cast< Bootstrap_Impl * >(handle),
 768                                    OUString::unacquired(macro),
 769                                    LOOKUP_MODE_NORMAL, nullptr));
 770     rtl_uString_assign(macro, expanded.pData);
 771 }
 772
 773 void SAL_CALL rtl_bootstrap_expandMacros(rtl_uString ** macro)
 774 {
 775     rtl_bootstrap_expandMacros_from_handle(nullptr, macro);
 776 }
 777
 778 void rtl_bootstrap_encode(rtl_uString const * value, rtl_uString ** encoded)
 779 {
 780     OSL_ASSERT(value);
 781     OUStringBuffer b(value->length+5);
 782     for (sal_Int32 i = 0; i < value->length; ++i)
 783     {
 784         sal_Unicode c = value->buffer[i];
 785         if (c == '$' || c == '\\')
 786             b.append('\\');
 787
 788         b.append(c);
 789     }
 790
 791     rtl_uString_assign(encoded, b.makeStringAndClear().pData);
 792 }
 793
 794 namespace {
 795
 796 int hex(sal_Unicode c)
 797 {
 798     return
 799         c >= '0' && c <= '9' ? c - '0' :
 800         c >= 'A' && c <= 'F' ? c - 'A' + 10 :
 801         c >= 'a' && c <= 'f' ? c - 'a' + 10 : -1;
 802 }
 803
 804 sal_Unicode read(OUString const & text, sal_Int32 * pos, bool * escaped)
 805 {
 806     OSL_ASSERT(pos && *pos >= 0 && *pos < text.getLength() && escaped);
 807     sal_Unicode c = text[(*pos)++];
 808     if (c == '\\')
 809     {
 810         int n1, n2, n3, n4;
 811         if (*pos < text.getLength() - 4 && text[*pos] == 'u' &&
 812             ((n1 = hex(text[*pos + 1])) >= 0) &&
 813             ((n2 = hex(text[*pos + 2])) >= 0) &&
 814             ((n3 = hex(text[*pos + 3])) >= 0) &&
 815             ((n4 = hex(text[*pos + 4])) >= 0))
 816         {
 817             *pos += 5;
 818             *escaped = true;
 819             return static_cast< sal_Unicode >(
 820                 (n1 << 12) | (n2 << 8) | (n3 << 4) | n4);
 821         }
 822
 823         if (*pos < text.getLength())
 824         {
 825             *escaped = true;
 826             return text[(*pos)++];
 827         }
 828     }
 829
 830     *escaped = false;
 831     return c;
 832 }
 833
 834 OUString lookup(
 835     Bootstrap_Impl const * file, LookupMode mode, bool override,
 836     OUString const & key, ExpandRequestLink const * requestStack)
 837 {
 838     OUString v;
 839     (file == nullptr ? get_static_bootstrap_handle() : file)->getValue(
 840         key, &v.pData, nullptr, mode, override, requestStack);
 841     return v;
 842 }
 843
 844 OUString expandMacros(
 845     Bootstrap_Impl const * file, OUString const & text, LookupMode mode,
 846     ExpandRequestLink const * requestStack)
 847 {
 848     SAL_INFO("sal.bootstrap", "expandMacros called with: " << text);
 849     OUStringBuffer buf(2048);
 850
 851     for (sal_Int32 i = 0; i < text.getLength();)
 852     {
 853         bool escaped;
 854         sal_Unicode c = read(text, &i, &escaped);
 855         if (escaped || c != '$')
 856         {
 857             buf.append(c);
 858         }
 859         else
 860         {
 861             if (i < text.getLength() && text[i] == '{')
 862             {
 863                 ++i;
 864                 sal_Int32 p = i;
 865                 sal_Int32 nesting = 0;
 866                 OUString seg[3];
 867                 int n = 0;
 868
 869                 while (i < text.getLength())
 870                 {
 871                     sal_Int32 j = i;
 872                     c = read(text, &i, &escaped);
 873
 874                     if (!escaped)
 875                     {
 876                         switch (c)
 877                         {
 878                             case '{':
 879                                 ++nesting;
 880                                 break;
 881                             case '}':
 882                                 if (nesting == 0)
 883                                 {
 884                                     seg[n++] = text.copy(p, j - p);
 885                                     goto done;
 886                                 }
 887                                 else
 888                                 {
 889                                     --nesting;
 890                                 }
 891                                 break;
 892                             case ':':
 893                                 if (nesting == 0 && n < 2)
 894                                 {
 895                                     seg[n++] = text.copy(p, j - p);
 896                                     p = i;
 897                                 }
 898                                 break;
 899                         }
 900                     }
 901                 }
 902             done:
 903                 for (int j = 0; j < n; ++j)
 904                 {
 905                     seg[j] = expandMacros(file, seg[j], mode, requestStack);
 906                 }
 907
 908                 if (n == 1)
 909                 {
 910                     buf.append(lookup(file, mode, false, seg[0], requestStack));
 911                 }
 912                 else if (n == 3 && seg[0] == ".override")
 913                 {
 914                     rtl::Bootstrap b(seg[1]);
 915                     Bootstrap_Impl * f = static_cast< Bootstrap_Impl * >(b.getHandle());
 916                     buf.append(lookup(f, mode, f != nullptr, seg[2], requestStack));
 917                 }
 918                 else
 919                 {
 920                     if (n == 3 && seg[1].isEmpty())
 921                     {
 922                         // For backward compatibility, treat ${file::key} the
 923                         // same as just ${file:key}:
 924                         seg[1] = seg[2];
 925                         n = 2;
 926                     }
 927
 928                     if (n == 2)
 929                     {
 930                         buf.append(
 931                             lookup(
 932                                 static_cast< Bootstrap_Impl * >(
 933                                     rtl::Bootstrap(seg[0]).getHandle()),
 934                                 mode, false, seg[1], requestStack));
 935                     }
 936                     else
 937                     {
 938                         // Going through osl::Profile, this code erroneously
 939                         // does not recursively expand macros in the resulting
 940                         // replacement text (and if it did, it would fail to
 941                         // detect cycles that pass through here):
 942                         buf.append(
 943                             OStringToOUString(
 944                                 osl::Profile(seg[0]).readString(
 945                                     OUStringToOString(
 946                                         seg[1], RTL_TEXTENCODING_UTF8),
 947                                     OUStringToOString(
 948                                         seg[2], RTL_TEXTENCODING_UTF8),
 949                                     OString()),
 950                                 RTL_TEXTENCODING_UTF8));
 951                     }
 952                 }
 953             }
 954             else
 955             {
 956                 OUStringBuffer kbuf(text.getLength());
 957                 for (; i < text.getLength();)
 958                 {
 959                     sal_Int32 j = i;
 960                     c = read(text, &j, &escaped);
 961                     if (!escaped &&
 962                         (c == ' ' || c == '$' || c == '-' || c == '/' ||
 963                          c == ';' || c == '\\'))
 964                     {
 965                         break;
 966                     }
 967
 968                     kbuf.append(c);
 969                     i = j;
 970                 }
 971
 972                 buf.append(
 973                     lookup(
 974                         file, mode, false, kbuf.makeStringAndClear(),
 975                         requestStack));
 976             }
 977         }
 978     }
 979
 980     OUString result(buf.makeStringAndClear());
 981     SAL_INFO("sal.bootstrap", "expandMacros result: " << result);
 982
 983     return result;
 984 }
 985
 986 }
 987
 988 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */