unotools/source/config/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
  20 #include <sal/config.h>
  21
  22 #include <string_view>
  23
  24 #include <config_folders.h>
  25
  26 #include <unotools/bootstrap.hxx>
  27
  28 #include <rtl/ustring.hxx>
  29 #include <rtl/ustrbuf.hxx>
  30 #include <sal/log.hxx>
  31 #include <osl/file.hxx>
  32 #include <osl/diagnose.h>
  33
  34 #include <rtl/bootstrap.hxx>
  35 #include <osl/process.h>
  36
  37 // #define this to true, if remembering defaults is not supported properly
  38 #define RTL_BOOTSTRAP_DEFAULTS_BROKEN true
  39
  40 constexpr OUString BOOTSTRAP_ITEM_PRODUCT_KEY = u"ProductKey"_ustr;
  41 constexpr OUStringLiteral BOOTSTRAP_ITEM_VERSIONFILE = u"Location";
  42 constexpr OUStringLiteral BOOTSTRAP_ITEM_BUILDID = u"buildid";
  43
  44 constexpr OUStringLiteral BOOTSTRAP_ITEM_BASEINSTALLATION = u"BRAND_BASE_DIR";
  45 constexpr OUStringLiteral BOOTSTRAP_ITEM_USERINSTALLATION = u"UserInstallation";
  46
  47 constexpr OUString BOOTSTRAP_ITEM_USERDIR = u"UserDataDir"_ustr;
  48
  49 constexpr OUStringLiteral BOOTSTRAP_DEFAULT_BASEINSTALL = u"$SYSBINDIR/..";
  50
  51 constexpr OUString BOOTSTRAP_DIRNAME_USERDIR = u"user"_ustr;
  52
  53 typedef char const * AsciiString;
  54
  55 namespace utl
  56 {
  57
  58 // Implementation class: Bootstrap::Impl
  59
  60 static OUString makeImplName()
  61 {
  62     OUString uri;
  63     rtl::Bootstrap::get( u"BRAND_BASE_DIR"_ustr, uri);
  64     return uri + "/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("bootstrap");
  65 }
  66
  67 class Bootstrap::Impl
  68 {
  69     const OUString m_aImplName;
  70 public: // struct to cache the result of a path lookup
  71     struct PathData
  72     {
  73         OUString     path;
  74         PathStatus   status;
  75
  76         PathData()
  77         : status(DATA_UNKNOWN)
  78         {}
  79     };
  80 public: // data members
  81     // base install data
  82     PathData aBaseInstall_;
  83
  84     // user install data
  85     PathData aUserInstall_;
  86
  87     // INI files
  88     PathData aBootstrapINI_;
  89     PathData aVersionINI_;
  90
  91     // overall status
  92     Status status_;
  93
  94 public: // construction and initialization
  95     Impl() : m_aImplName(makeImplName())
  96     {
  97         initialize();
  98     }
  99
 100     void initialize();
 101
 102     // access helper
 103     OUString getBootstrapValue(OUString const& _sName, OUString const& _sDefault) const;
 104
 105     const OUString& getImplName() const { return m_aImplName; }
 106
 107 private: // implementation
 108     bool initBaseInstallationData(rtl::Bootstrap const & _rData);
 109     bool initUserInstallationData(rtl::Bootstrap const & _rData);
 110 };
 111
 112 namespace
 113 {
 114     Bootstrap::Impl& theImpl()
 115     {
 116         static Bootstrap::Impl SINGLETON;
 117         return SINGLETON;
 118     }
 119 }
 120
 121 const Bootstrap::Impl& Bootstrap::data()
 122 {
 123     return theImpl();
 124 }
 125
 126 bool Bootstrap::getProcessWorkingDir(OUString &rUrl)
 127 {
 128     rUrl.clear();
 129     OUString s(u"$OOO_CWD"_ustr);
 130     rtl::Bootstrap::expandMacros(s);
 131     if (s.isEmpty())
 132     {
 133         if (osl_getProcessWorkingDir(&rUrl.pData) == osl_Process_E_None)
 134             return true;
 135     }
 136     else if (s[0] == '1')
 137     {
 138         rUrl = s.copy(1);
 139         return true;
 140     }
 141     else if (s[0] == '2' &&
 142                (osl::FileBase::getFileURLFromSystemPath(s.copy(1), rUrl) ==
 143                 osl::FileBase::E_None))
 144     {
 145         return true;
 146     }
 147     return false;
 148 }
 149
 150 void Bootstrap::reloadData()
 151 {
 152     theImpl().initialize();
 153 }
 154
 155 // helper
 156
 157 typedef Bootstrap::PathStatus PathStatus;
 158
 159 sal_Unicode const cURLSeparator = '/';
 160
 161 // path status utility function
 162 static PathStatus implCheckStatusOfURL(OUString const& _sURL, osl::DirectoryItem& aDirItem)
 163 {
 164     using namespace osl;
 165
 166     PathStatus eStatus = Bootstrap::DATA_UNKNOWN;
 167
 168     if (!_sURL.isEmpty())
 169     {
 170         switch( DirectoryItem::get(_sURL, aDirItem) )
 171         {
 172         case DirectoryItem::E_None:         // Success
 173             eStatus = Bootstrap::PATH_EXISTS;
 174             break;
 175
 176         case DirectoryItem::E_NOENT:        // No such file or directory
 177             eStatus = Bootstrap::PATH_VALID;
 178             break;
 179
 180         case DirectoryItem::E_INVAL:        // the format of the parameters was not valid
 181         case DirectoryItem::E_NAMETOOLONG:  // File name too long
 182         case DirectoryItem::E_NOTDIR:       // A component of the path prefix of path is not a directory
 183             eStatus = Bootstrap::DATA_INVALID;
 184             break;
 185
 186         // how to handle these ?
 187         case DirectoryItem::E_LOOP:         // Too many symbolic links encountered
 188         case DirectoryItem::E_ACCES:        // permission denied
 189         // any other error - what to do ?
 190         default:
 191             eStatus = Bootstrap::DATA_UNKNOWN;
 192             break;
 193         }
 194     }
 195     else
 196     {
 197         eStatus = Bootstrap::DATA_MISSING;
 198     }
 199
 200     return eStatus;
 201 }
 202
 203 static bool implNormalizeURL(OUString & _sURL, osl::DirectoryItem& aDirItem)
 204 {
 205     using namespace osl;
 206
 207     OSL_PRECOND(aDirItem.is(), "Opened DirItem required");
 208
 209     static const sal_uInt32 cosl_FileStatus_Mask = osl_FileStatus_Mask_FileURL;
 210
 211     FileStatus aFileStatus(cosl_FileStatus_Mask);
 212
 213     if (aDirItem.getFileStatus(aFileStatus) != DirectoryItem::E_None)
 214         return false;
 215
 216     OUString aNormalizedURL = aFileStatus.getFileURL();
 217
 218     if (aNormalizedURL.isEmpty())
 219         return false;
 220
 221     // #109863# sal/osl returns final slash for file URLs contradicting
 222     // the URL/URI RFCs.
 223     if ( !aNormalizedURL.endsWith(OUStringChar(cURLSeparator)) )
 224         _sURL = aNormalizedURL;
 225     else
 226         _sURL = aNormalizedURL.copy( 0, aNormalizedURL.getLength()-1 );
 227
 228     return true;
 229 }
 230
 231 static bool implEnsureAbsolute(OUString & _rsURL) // also strips embedded dots !!
 232 {
 233     using osl::File;
 234
 235     OUString sBasePath;
 236     OSL_VERIFY(Bootstrap::getProcessWorkingDir(sBasePath));
 237
 238     OUString sAbsolute;
 239     if ( File::E_None == File::getAbsoluteFileURL(sBasePath, _rsURL, sAbsolute))
 240     {
 241         _rsURL = sAbsolute;
 242         return true;
 243     }
 244     else
 245     {
 246         OSL_FAIL("Could not get absolute file URL for URL");
 247         return false;
 248     }
 249 }
 250
 251 static bool implMakeAbsoluteURL(OUString & _rsPathOrURL)
 252 {
 253     using namespace osl;
 254
 255     bool bURL;
 256
 257     OUString sOther;
 258     // check if it already was normalized
 259     if ( File::E_None == File::getSystemPathFromFileURL(_rsPathOrURL, sOther) )
 260     {
 261         bURL = true;
 262     }
 263
 264     else if ( File::E_None == File::getFileURLFromSystemPath(_rsPathOrURL, sOther) )
 265     {
 266         _rsPathOrURL = sOther;
 267         bURL = true;
 268     }
 269     else
 270         bURL = false;
 271
 272     return bURL && implEnsureAbsolute(_rsPathOrURL);
 273 }
 274
 275 static PathStatus dbgCheckStatusOfURL(OUString const& _sURL)
 276 {
 277     using namespace osl;
 278
 279     DirectoryItem aDirItem;
 280
 281     return implCheckStatusOfURL(_sURL,aDirItem);
 282 }
 283
 284 static PathStatus checkStatusAndNormalizeURL(OUString & _sURL)
 285 {
 286     using namespace osl;
 287
 288     PathStatus eStatus = Bootstrap::DATA_UNKNOWN;
 289
 290     if (_sURL.isEmpty())
 291         eStatus = Bootstrap::DATA_MISSING;
 292
 293     else if ( !implMakeAbsoluteURL(_sURL) )
 294         eStatus = Bootstrap::DATA_INVALID;
 295
 296     else
 297     {
 298         DirectoryItem aDirItem;
 299
 300         eStatus = implCheckStatusOfURL(_sURL,aDirItem);
 301
 302         if (eStatus == Bootstrap::PATH_EXISTS && !implNormalizeURL(_sURL,aDirItem))
 303             OSL_FAIL("Unexpected failure getting actual URL for existing object");
 304     }
 305     return eStatus;
 306 }
 307
 308 // helpers to build and check a nested URL
 309 static PathStatus getDerivedPath(
 310               OUString& _rURL,
 311               OUString const& _aBaseURL, PathStatus _aBaseStatus,
 312               std::u16string_view _sRelativeURL,
 313               rtl::Bootstrap const & _rData, OUString const& _sBootstrapParameter
 314           )
 315 {
 316     OUString sDerivedURL;
 317     OSL_PRECOND(!_rData.getFrom(_sBootstrapParameter,sDerivedURL),"Setting for derived path is already defined");
 318     OSL_PRECOND(!_sRelativeURL.empty() && _sRelativeURL[0] != cURLSeparator,"Invalid Relative URL");
 319
 320     PathStatus aStatus = _aBaseStatus;
 321
 322     // do we have a base path ?
 323     if (!_aBaseURL.isEmpty())
 324     {
 325         OSL_PRECOND(!_aBaseURL.endsWith(OUStringChar(cURLSeparator)), "Unexpected: base URL ends in slash");
 326
 327         sDerivedURL = _aBaseURL + OUStringChar(cURLSeparator) + _sRelativeURL;
 328
 329         // a derived (nested) URL can only exist or have a lesser status, if the parent exists
 330         if (aStatus == Bootstrap::PATH_EXISTS)
 331             aStatus = checkStatusAndNormalizeURL(sDerivedURL);
 332
 333         else // the relative appendix must be valid
 334             OSL_ASSERT(aStatus != Bootstrap::PATH_VALID || dbgCheckStatusOfURL(sDerivedURL) == Bootstrap::PATH_VALID);
 335
 336         _rData.getFrom(_sBootstrapParameter, _rURL, sDerivedURL);
 337
 338         OSL_ENSURE(sDerivedURL == _rURL,"Could not set derived URL via Bootstrap default parameter");
 339         SAL_WARN_IF( !(RTL_BOOTSTRAP_DEFAULTS_BROKEN || (_rData.getFrom(_sBootstrapParameter,sDerivedURL) && sDerivedURL==_rURL)),
 340             "unotools.config",
 341             "Use of default did not affect bootstrap value");
 342     }
 343     else
 344     {
 345         // clear the result
 346         _rURL = _aBaseURL;
 347
 348         // if we have no data it can't be a valid path
 349         OSL_ASSERT( aStatus > Bootstrap::PATH_VALID );
 350     }
 351
 352     return aStatus;
 353 }
 354
 355 static PathStatus getDerivedPath(
 356                       OUString& _rURL,
 357                       Bootstrap::Impl::PathData const& _aBaseData,
 358                       std::u16string_view _sRelativeURL,
 359                       rtl::Bootstrap const & _rData, OUString const& _sBootstrapParameter
 360               )
 361 {
 362     return getDerivedPath(_rURL,_aBaseData.path,_aBaseData.status,_sRelativeURL,_rData,_sBootstrapParameter);
 363 }
 364
 365 static OUString getExecutableBaseName()
 366 {
 367     OUString sExecutable;
 368
 369     if (osl_Process_E_None == osl_getExecutableFile(&sExecutable.pData))
 370     {
 371         // split the executable name
 372         sal_Int32 nSepIndex = sExecutable.lastIndexOf(cURLSeparator);
 373
 374         sExecutable = sExecutable.copy(nSepIndex + 1);
 375
 376         // ... and get the basename (strip the extension)
 377         sal_Unicode const cExtensionSep = '.';
 378
 379         sal_Int32 const nExtIndex =     sExecutable.lastIndexOf(cExtensionSep);
 380         sal_Int32 const nExtLength =    sExecutable.getLength() - nExtIndex - 1;
 381         if (0 < nExtIndex && nExtLength < 4)
 382            sExecutable  = sExecutable.copy(0,nExtIndex);
 383     }
 384     else
 385         SAL_WARN("unotools.config", "Cannot get executable name: osl_getExecutableFile failed");
 386
 387     return sExecutable;
 388 }
 389
 390 static Bootstrap::PathStatus updateStatus(Bootstrap::Impl::PathData & _rResult)
 391 {
 392     _rResult.status = checkStatusAndNormalizeURL(_rResult.path);
 393     return _rResult.status;
 394 }
 395
 396 static Bootstrap::PathStatus implGetBootstrapFile(rtl::Bootstrap const & _rData, Bootstrap::Impl::PathData & _rBootstrapFile)
 397 {
 398     _rData.getIniName(_rBootstrapFile.path);
 399
 400     return updateStatus(_rBootstrapFile);
 401 }
 402
 403 static Bootstrap::PathStatus implGetVersionFile(rtl::Bootstrap const & _rData, Bootstrap::Impl::PathData & _rVersionFile)
 404 {
 405     _rData.getFrom(BOOTSTRAP_ITEM_VERSIONFILE, _rVersionFile.path);
 406
 407     return updateStatus(_rVersionFile);
 408 }
 409
 410 // Error reporting
 411
 412 char const IS_MISSING[] = "is missing";
 413 char const IS_INVALID[] = "is corrupt";
 414 char const PERIOD[] = ". ";
 415
 416 static void addFileError(OUStringBuffer& _rBuf, std::u16string_view _aPath, AsciiString _sWhat)
 417 {
 418     const std::string_view::size_type nLastSep = _aPath.rfind(cURLSeparator);
 419     const auto nAfterSep = (nLastSep != std::string_view::npos) ? (nLastSep + 1) : 0;
 420     std::u16string_view sSimpleFileName = _aPath.substr(nAfterSep);
 421
 422     _rBuf.append("The configuration file");
 423     _rBuf.append(OUString::Concat(" '") + sSimpleFileName + "' ");
 424     _rBuf.appendAscii(_sWhat).append(PERIOD);
 425 }
 426
 427 static void addMissingDirectoryError(OUStringBuffer& _rBuf, std::u16string_view _aPath)
 428 {
 429     _rBuf.append(OUString::Concat("The configuration directory '") + _aPath + "' " +
 430         IS_MISSING + PERIOD);
 431 }
 432
 433 static void addUnexpectedError(OUStringBuffer& _rBuf, AsciiString _sExtraInfo = nullptr)
 434 {
 435     if (nullptr == _sExtraInfo)
 436         _sExtraInfo = "An internal failure occurred";
 437
 438     _rBuf.appendAscii(_sExtraInfo).append(PERIOD);
 439 }
 440
 441 static Bootstrap::FailureCode describeError(OUStringBuffer& _rBuf, Bootstrap::Impl const& _rData)
 442 {
 443     Bootstrap::FailureCode eErrCode = Bootstrap::INVALID_BOOTSTRAP_DATA;
 444
 445     _rBuf.append("The program cannot be started. ");
 446
 447     switch (_rData.aUserInstall_.status)
 448     {
 449     case Bootstrap::PATH_EXISTS:
 450         switch (_rData.aBaseInstall_.status)
 451         {
 452         case Bootstrap::PATH_VALID:
 453             addMissingDirectoryError(_rBuf, _rData.aBaseInstall_.path);
 454             eErrCode = Bootstrap::MISSING_INSTALL_DIRECTORY;
 455             break;
 456
 457         case Bootstrap::DATA_INVALID:
 458             addUnexpectedError(_rBuf,"The installation path is invalid");
 459             break;
 460
 461         case Bootstrap::DATA_MISSING:
 462             addUnexpectedError(_rBuf,"The installation path is not available");
 463             break;
 464
 465         case Bootstrap::PATH_EXISTS: // seems to be all fine (?)
 466             addUnexpectedError(_rBuf,"");
 467             break;
 468
 469         default: OSL_ASSERT(false);
 470             addUnexpectedError(_rBuf);
 471             break;
 472         }
 473         break;
 474
 475     case Bootstrap::PATH_VALID:
 476         addMissingDirectoryError(_rBuf, _rData.aUserInstall_.path);
 477         eErrCode = Bootstrap::MISSING_USER_DIRECTORY;
 478         break;
 479
 480         // else fall through
 481     case Bootstrap::DATA_INVALID:
 482         if (_rData.aVersionINI_.status == Bootstrap::PATH_EXISTS)
 483         {
 484             addFileError(_rBuf, _rData.aVersionINI_.path, IS_INVALID);
 485             eErrCode = Bootstrap::INVALID_VERSION_FILE_ENTRY;
 486             break;
 487         }
 488         [[fallthrough]];
 489
 490     case Bootstrap::DATA_MISSING:
 491         switch (_rData.aVersionINI_.status)
 492         {
 493         case Bootstrap::PATH_EXISTS:
 494             addFileError(_rBuf, _rData.aVersionINI_.path, "does not support the current version");
 495             eErrCode = Bootstrap::MISSING_VERSION_FILE_ENTRY;
 496             break;
 497
 498         case Bootstrap::PATH_VALID:
 499             addFileError(_rBuf, _rData.aVersionINI_.path, IS_MISSING);
 500             eErrCode = Bootstrap::MISSING_VERSION_FILE;
 501             break;
 502
 503         default:
 504             switch (_rData.aBootstrapINI_.status)
 505             {
 506             case Bootstrap::PATH_EXISTS:
 507                 addFileError(_rBuf, _rData.aBootstrapINI_.path, IS_INVALID);
 508
 509                 if (_rData.aVersionINI_.status == Bootstrap::DATA_MISSING)
 510                     eErrCode = Bootstrap::MISSING_BOOTSTRAP_FILE_ENTRY;
 511                 else
 512                     eErrCode = Bootstrap::INVALID_BOOTSTRAP_FILE_ENTRY;
 513                 break;
 514
 515             case Bootstrap::DATA_INVALID: OSL_ASSERT(false); [[fallthrough]];
 516             case Bootstrap::PATH_VALID:
 517                 addFileError(_rBuf, _rData.aBootstrapINI_.path, IS_MISSING);
 518                 eErrCode = Bootstrap::MISSING_BOOTSTRAP_FILE;
 519                 break;
 520
 521             default:
 522                 addUnexpectedError(_rBuf);
 523                 break;
 524             }
 525             break;
 526         }
 527         break;
 528
 529     default: OSL_ASSERT(false);
 530         addUnexpectedError(_rBuf);
 531         break;
 532     }
 533
 534     return eErrCode;
 535 }
 536
 537
 538 OUString Bootstrap::getProductKey()
 539 {
 540     OUString const sDefaultProductKey = getExecutableBaseName();
 541
 542     return data().getBootstrapValue( BOOTSTRAP_ITEM_PRODUCT_KEY, sDefaultProductKey );
 543 }
 544
 545 OUString Bootstrap::getProductKey(OUString const& _sDefault)
 546 {
 547     return data().getBootstrapValue( BOOTSTRAP_ITEM_PRODUCT_KEY, _sDefault );
 548 }
 549
 550 OUString Bootstrap::getBuildIdData(OUString const& _sDefault)
 551 {
 552     // try to open version.ini (versionrc)
 553     OUString uri;
 554     rtl::Bootstrap::get( u"BRAND_BASE_DIR"_ustr, uri);
 555     rtl::Bootstrap aData( uri + "/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("version") );
 556     if ( aData.getHandle() == nullptr )
 557         // version.ini (versionrc) doesn't exist
 558         return _sDefault;
 559
 560     // read value
 561     OUString sBuildId;
 562     aData.getFrom(BOOTSTRAP_ITEM_BUILDID,sBuildId,_sDefault);
 563     return sBuildId;
 564 }
 565
 566 Bootstrap::PathStatus Bootstrap::locateBaseInstallation(OUString& _rURL)
 567 {
 568     Impl::PathData const& aPathData = data().aBaseInstall_;
 569
 570     _rURL = aPathData.path;
 571     return aPathData.status;
 572 }
 573
 574 Bootstrap::PathStatus Bootstrap::locateUserInstallation(OUString& _rURL)
 575 {
 576     Impl::PathData const& aPathData = data().aUserInstall_;
 577
 578     _rURL = aPathData.path;
 579     return aPathData.status;
 580 }
 581
 582 Bootstrap::PathStatus Bootstrap::locateUserData(OUString& _rURL)
 583 {
 584     OUString const csUserDirItem(BOOTSTRAP_ITEM_USERDIR);
 585
 586     rtl::Bootstrap aData( data().getImplName() );
 587
 588     if ( aData.getFrom(csUserDirItem, _rURL) )
 589     {
 590         return checkStatusAndNormalizeURL(_rURL);
 591     }
 592     else
 593     {
 594         return getDerivedPath(_rURL, data().aUserInstall_ ,BOOTSTRAP_DIRNAME_USERDIR, aData, csUserDirItem);
 595     }
 596 }
 597
 598 Bootstrap::PathStatus Bootstrap::locateBootstrapFile(OUString& _rURL)
 599 {
 600     Impl::PathData const& aPathData = data().aBootstrapINI_;
 601
 602     _rURL = aPathData.path;
 603     return aPathData.status;
 604 }
 605
 606 Bootstrap::PathStatus Bootstrap::locateVersionFile(OUString& _rURL)
 607 {
 608     Impl::PathData const& aPathData = data().aVersionINI_;
 609
 610     _rURL = aPathData.path;
 611     return aPathData.status;
 612 }
 613
 614 Bootstrap::Status Bootstrap::checkBootstrapStatus(OUString& _rDiagnosticMessage, FailureCode& _rErrCode)
 615 {
 616     Impl const& aData = data();
 617
 618     Status result = aData.status_;
 619
 620     // maybe do further checks here
 621
 622     OUStringBuffer sErrorBuffer;
 623     if (result != DATA_OK)
 624         _rErrCode = describeError(sErrorBuffer,aData);
 625
 626     else
 627         _rErrCode = NO_FAILURE;
 628
 629     _rDiagnosticMessage = sErrorBuffer.makeStringAndClear();
 630
 631     return result;
 632 }
 633
 634
 635 bool Bootstrap::Impl::initBaseInstallationData(rtl::Bootstrap const & _rData)
 636 {
 637     _rData.getFrom(BOOTSTRAP_ITEM_BASEINSTALLATION, aBaseInstall_.path, BOOTSTRAP_DEFAULT_BASEINSTALL);
 638
 639     bool bResult = (PATH_EXISTS == updateStatus(aBaseInstall_));
 640
 641     implGetBootstrapFile(_rData, aBootstrapINI_);
 642
 643     return bResult;
 644 }
 645
 646 bool Bootstrap::Impl::initUserInstallationData(rtl::Bootstrap const & _rData)
 647 {
 648     if (_rData.getFrom(BOOTSTRAP_ITEM_USERINSTALLATION, aUserInstall_.path))
 649     {
 650         updateStatus(aUserInstall_);
 651     }
 652     else
 653     {
 654         // should we do just this
 655         aUserInstall_.status = DATA_MISSING;
 656
 657         // ... or this - look for a single-user user directory ?
 658         OUString const csUserDirItem(BOOTSTRAP_ITEM_USERDIR);
 659         OUString sDummy;
 660         // look for $BASEINSTALLATION/user only if default UserDir setting is used
 661         if (! _rData.getFrom(csUserDirItem, sDummy))
 662         {
 663             if ( PATH_EXISTS == getDerivedPath(sDummy, aBaseInstall_, BOOTSTRAP_DIRNAME_USERDIR, _rData, csUserDirItem) )
 664                 aUserInstall_ = aBaseInstall_;
 665         }
 666     }
 667
 668     bool bResult = (PATH_EXISTS == aUserInstall_.status);
 669
 670     implGetVersionFile(_rData, aVersionINI_);
 671
 672     return bResult;
 673 }
 674
 675 void Bootstrap::Impl::initialize()
 676 {
 677     rtl::Bootstrap aData( m_aImplName );
 678
 679     if (!initBaseInstallationData(aData))
 680     {
 681         status_ = INVALID_BASE_INSTALL;
 682     }
 683     else if (!initUserInstallationData(aData))
 684     {
 685         status_ = INVALID_USER_INSTALL;
 686
 687         if (aUserInstall_.status >= DATA_MISSING)
 688         {
 689             switch (aVersionINI_.status)
 690             {
 691             case PATH_EXISTS:
 692             case PATH_VALID:
 693                 status_ = MISSING_USER_INSTALL;
 694                 break;
 695
 696             case DATA_INVALID:
 697             case DATA_MISSING:
 698                 status_ = INVALID_BASE_INSTALL;
 699                 break;
 700             default:
 701                 break;
 702             }
 703         }
 704     }
 705     else
 706     {
 707         status_ = DATA_OK;
 708     }
 709 }
 710
 711 OUString Bootstrap::Impl::getBootstrapValue(OUString const& _sName, OUString const& _sDefault) const
 712 {
 713     rtl::Bootstrap aData( m_aImplName );
 714
 715     OUString sResult;
 716     aData.getFrom(_sName,sResult,_sDefault);
 717     return sResult;
 718 }
 719
 720 } // namespace utl
 721
 722 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */