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