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