tools/source/generic/config.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 <cstddef>
  21 #include <cstdlib>
  22 #include <limits>
  23 #include <new>
  24 #include <string.h>
  25
  26 #ifdef WNT
  27 #include "stdlib.h"
  28 #endif
  29
  30 #include <osl/file.hxx>
  31 #include <tools/stream.hxx>
  32 #include <tools/config.hxx>
  33 #include <osl/security.h>
  34 #include <rtl/strbuf.hxx>
  35 #include <sal/log.hxx>
  36
  37 struct ImplKeyData
  38 {
  39     ImplKeyData*    mpNext;
  40     OString         maKey;
  41     OString         maValue;
  42     bool            mbIsComment;
  43 };
  44
  45 struct ImplGroupData
  46 {
  47     ImplGroupData*  mpNext;
  48     ImplKeyData*    mpFirstKey;
  49     OString         maGroupName;
  50     sal_uInt16      mnEmptyLines;
  51 };
  52
  53 struct ImplConfigData
  54 {
  55     ImplGroupData*  mpFirstGroup;
  56     OUString        maFileName;
  57     sal_uIntPtr     mnDataUpdateId;
  58     sal_uIntPtr     mnTimeStamp;
  59     LineEnd         meLineEnd;
  60     sal_uInt16      mnRefCount;
  61     bool            mbModified;
  62     bool            mbRead;
  63     bool            mbIsUTF8BOM;
  64 };
  65
  66 static OUString toUncPath( const OUString& rPath )
  67 {
  68     OUString aFileURL;
  69
  70     // check if rFileName is already a URL; if not make it so
  71     if( rPath.startsWith( "file://"))
  72     {
  73         aFileURL = rPath;
  74     }
  75     else if( ::osl::FileBase::getFileURLFromSystemPath( rPath, aFileURL ) != ::osl::FileBase::E_None )
  76     {
  77         aFileURL = rPath;
  78     }
  79     return aFileURL;
  80 }
  81
  82 static sal_uIntPtr ImplSysGetConfigTimeStamp( const OUString& rFileName )
  83 {
  84     sal_uIntPtr nTimeStamp = 0;
  85     ::osl::DirectoryItem aItem;
  86     ::osl::FileStatus aStatus( osl_FileStatus_Mask_ModifyTime );
  87
  88     if( ::osl::DirectoryItem::get( rFileName, aItem ) == ::osl::FileBase::E_None &&
  89         aItem.getFileStatus( aStatus ) == ::osl::FileBase::E_None )
  90     {
  91         nTimeStamp = aStatus.getModifyTime().Seconds;
  92     }
  93
  94     return nTimeStamp;
  95 }
  96
  97 static sal_uInt8* ImplSysReadConfig( const OUString& rFileName,
  98                                 sal_uInt64& rRead, bool& rbRead, bool& rbIsUTF8BOM, sal_uIntPtr& rTimeStamp )
  99 {
 100     sal_uInt8*          pBuf = NULL;
 101     ::osl::File aFile( rFileName );
 102
 103     if( aFile.open( osl_File_OpenFlag_Read ) == ::osl::FileBase::E_None )
 104     {
 105         sal_uInt64 nPos = 0;
 106         if( aFile.getSize( nPos ) == ::osl::FileBase::E_None )
 107         {
 108             if (nPos > SAL_MAX_SIZE) {
 109                 aFile.close();
 110                 return 0;
 111             }
 112             pBuf = new sal_uInt8[static_cast< std::size_t >(nPos)];
 113             sal_uInt64 nRead = 0;
 114             if( aFile.read( pBuf, nPos, nRead ) == ::osl::FileBase::E_None && nRead == nPos )
 115             {
 116                 //skip the byte-order-mark 0xEF 0xBB 0xBF, if it was UTF8 files
 117                 unsigned char BOM[3] = {0xEF, 0xBB, 0xBF};
 118                 if (nRead > 2 && memcmp(pBuf, BOM, 3) == 0)
 119                 {
 120                     nRead -= 3;
 121                     memmove(pBuf, pBuf + 3, sal::static_int_cast<sal_Size>(nRead * sizeof(sal_uInt8)) );
 122                     rbIsUTF8BOM = true;
 123                 }
 124
 125                 rTimeStamp = ImplSysGetConfigTimeStamp( rFileName );
 126                 rbRead = true;
 127                 rRead = nRead;
 128             }
 129             else
 130             {
 131                 delete[] pBuf;
 132                 pBuf = NULL;
 133             }
 134         }
 135         aFile.close();
 136     }
 137
 138     return pBuf;
 139 }
 140
 141 static bool ImplSysWriteConfig( const OUString& rFileName,
 142                                 const sal_uInt8* pBuf, sal_uIntPtr nBufLen, bool rbIsUTF8BOM, sal_uIntPtr& rTimeStamp )
 143 {
 144     bool bSuccess = false;
 145     bool bUTF8BOMSuccess = false;
 146
 147     ::osl::File aFile( rFileName );
 148     ::osl::FileBase::RC eError = aFile.open( osl_File_OpenFlag_Write | osl_File_OpenFlag_Create );
 149     if( eError != ::osl::FileBase::E_None )
 150         eError = aFile.open( osl_File_OpenFlag_Write );
 151     if( eError == ::osl::FileBase::E_None )
 152     {
 153         // truncate
 154         aFile.setSize( 0 );
 155         sal_uInt64 nWritten;
 156
 157         //write the byte-order-mark 0xEF 0xBB 0xBF first , if it was UTF8 files
 158         if ( rbIsUTF8BOM )
 159         {
 160             unsigned char BOM[3] = {0xEF, 0xBB, 0xBF};
 161             sal_uInt64 nUTF8BOMWritten;
 162             if( aFile.write( BOM, 3, nUTF8BOMWritten ) == ::osl::FileBase::E_None && 3 == nUTF8BOMWritten )
 163             {
 164                 bUTF8BOMSuccess = true;
 165             }
 166         }
 167
 168         if( aFile.write( pBuf, nBufLen, nWritten ) == ::osl::FileBase::E_None && nWritten == nBufLen )
 169         {
 170             bSuccess = true;
 171         }
 172         if ( rbIsUTF8BOM ? bSuccess && bUTF8BOMSuccess : bSuccess )
 173         {
 174             rTimeStamp = ImplSysGetConfigTimeStamp( rFileName );
 175         }
 176     }
 177
 178     return rbIsUTF8BOM ? bSuccess && bUTF8BOMSuccess : bSuccess;
 179 }
 180
 181 namespace {
 182 OString makeOString(const sal_uInt8* p, sal_uInt64 n)
 183 {
 184     if (n > SAL_MAX_INT32)
 185     {
 186         #ifdef WNT
 187         abort();
 188         #else
 189         ::std::abort(); //TODO: handle this gracefully
 190         #endif
 191     }
 192     return OString(
 193         reinterpret_cast< char const * >(p),
 194         sal::static_int_cast< sal_Int32 >(n));
 195 }
 196 }
 197
 198 static void ImplMakeConfigList( ImplConfigData* pData,
 199                                 const sal_uInt8* pBuf, sal_uInt64 nLen )
 200 {
 201     if ( !nLen )
 202         return;
 203
 204     // Parse buffer and build config list
 205     sal_uInt64 nStart;
 206     sal_uInt64 nLineLen;
 207     sal_uInt64 nNameLen;
 208     sal_uInt64 nKeyLen;
 209     sal_uInt64 i;
 210     const sal_uInt8*    pLine;
 211     ImplKeyData*    pPrevKey = NULL;
 212     ImplKeyData*    pKey;
 213     ImplGroupData*  pPrevGroup = NULL;
 214     ImplGroupData*  pGroup = NULL;
 215     i = 0;
 216     while ( i < nLen )
 217     {
 218         // Ctrl+Z
 219         if ( pBuf[i] == 0x1A )
 220             break;
 221
 222         // Remove spaces and tabs
 223         while ( (pBuf[i] == ' ') || (pBuf[i] == '\t') )
 224             i++;
 225
 226         // remember line-starts
 227         nStart = i;
 228         pLine = pBuf+i;
 229
 230         // search line-endings
 231         while (  (i < nLen) && pBuf[i] && (pBuf[i] != '\r') && (pBuf[i] != '\n') &&
 232                 (pBuf[i] != 0x1A) )
 233             i++;
 234
 235         nLineLen = i-nStart;
 236
 237         // if Line-ending is found, continue once
 238         if ( (i+1 < nLen) &&
 239              (pBuf[i] != pBuf[i+1]) &&
 240              ((pBuf[i+1] == '\r') || (pBuf[i+1] == '\n')) )
 241             i++;
 242         i++;
 243
 244         // evaluate line
 245         if ( *pLine == '[' )
 246         {
 247             pGroup               = new ImplGroupData;
 248             pGroup->mpNext       = NULL;
 249             pGroup->mpFirstKey   = NULL;
 250             pGroup->mnEmptyLines = 0;
 251             if ( pPrevGroup )
 252                 pPrevGroup->mpNext = pGroup;
 253             else
 254                 pData->mpFirstGroup = pGroup;
 255             pPrevGroup  = pGroup;
 256             pPrevKey    = NULL;
 257             pKey        = NULL;
 258
 259             // filter group names
 260             pLine++;
 261             nLineLen--;
 262             // remove spaces and tabs
 263             while ( (*pLine == ' ') || (*pLine == '\t') )
 264             {
 265                 nLineLen--;
 266                 pLine++;
 267             }
 268             nNameLen = 0;
 269             while ( (nNameLen < nLineLen) && (pLine[nNameLen] != ']') )
 270                 nNameLen++;
 271             if ( nNameLen )
 272             {
 273                 while ( (pLine[nNameLen-1] == ' ') || (pLine[nNameLen-1] == '\t') )
 274                     nNameLen--;
 275             }
 276             pGroup->maGroupName = makeOString(pLine, nNameLen);
 277         }
 278         else
 279         {
 280             if ( nLineLen )
 281             {
 282                 // If no group exists yet, add to default
 283                 if ( !pGroup )
 284                 {
 285                     pGroup              = new ImplGroupData;
 286                     pGroup->mpNext      = NULL;
 287                     pGroup->mpFirstKey  = NULL;
 288                     pGroup->mnEmptyLines = 0;
 289                     pData->mpFirstGroup = pGroup;
 290                     pPrevGroup  = pGroup;
 291                     pPrevKey    = NULL;
 292                 }
 293
 294                 // if empty line, append it
 295                 if ( pPrevKey )
 296                 {
 297                     while ( pGroup->mnEmptyLines )
 298                     {
 299                         pKey                = new ImplKeyData;
 300                         pKey->mbIsComment   = true;
 301                         pPrevKey->mpNext    = pKey;
 302                         pPrevKey            = pKey;
 303                         pGroup->mnEmptyLines--;
 304                     }
 305                 }
 306
 307                 // Generate new key
 308                 pKey        = new ImplKeyData;
 309                 pKey->mpNext = NULL;
 310                 if ( pPrevKey )
 311                     pPrevKey->mpNext = pKey;
 312                 else
 313                     pGroup->mpFirstKey = pKey;
 314                 pPrevKey = pKey;
 315                 if ( pLine[0] == ';' )
 316                 {
 317                     pKey->maValue = makeOString(pLine, nLineLen);
 318                     pKey->mbIsComment = true;
 319                 }
 320                 else
 321                 {
 322                     pKey->mbIsComment = false;
 323                     nNameLen = 0;
 324                     while ( (nNameLen < nLineLen) && (pLine[nNameLen] != '=') )
 325                         nNameLen++;
 326                     nKeyLen = nNameLen;
 327                     // Remove spaces and tabs
 328                     if ( nNameLen )
 329                     {
 330                         while ( (pLine[nNameLen-1] == ' ') || (pLine[nNameLen-1] == '\t') )
 331                             nNameLen--;
 332                     }
 333                     pKey->maKey = makeOString(pLine, nNameLen);
 334                     nKeyLen++;
 335                     if ( nKeyLen < nLineLen )
 336                     {
 337                         pLine += nKeyLen;
 338                         nLineLen -= nKeyLen;
 339                         // Remove spaces and tabs
 340                         while ( (*pLine == ' ') || (*pLine == '\t') )
 341                         {
 342                             nLineLen--;
 343                             pLine++;
 344                         }
 345                         if ( nLineLen )
 346                         {
 347                             while ( (pLine[nLineLen-1] == ' ') || (pLine[nLineLen-1] == '\t') )
 348                                 nLineLen--;
 349                             pKey->maValue = makeOString(pLine, nLineLen);
 350                         }
 351                     }
 352                 }
 353             }
 354             else
 355             {
 356                 // Spaces are counted and appended only after key generation,
 357                 // as we want to store spaces even after adding new keys
 358                 if ( pGroup )
 359                     pGroup->mnEmptyLines++;
 360             }
 361         }
 362     }
 363 }
 364
 365 static sal_uInt8* ImplGetConfigBuffer( const ImplConfigData* pData, sal_uIntPtr& rLen )
 366 {
 367     sal_uInt8*      pWriteBuf;
 368     sal_uInt8*      pBuf;
 369     sal_uInt8       aLineEndBuf[2] = {0, 0};
 370     ImplKeyData*    pKey;
 371     ImplGroupData*  pGroup;
 372     unsigned int    nBufLen;
 373     sal_uInt32      nValueLen;
 374     sal_uInt32      nKeyLen;
 375     sal_uInt32      nLineEndLen;
 376
 377     if ( pData->meLineEnd == LINEEND_CR )
 378     {
 379         aLineEndBuf[0] = '\r';
 380         nLineEndLen = 1;
 381     }
 382     else if ( pData->meLineEnd == LINEEND_LF )
 383     {
 384         aLineEndBuf[0] = '\n';
 385         nLineEndLen = 1;
 386     }
 387     else
 388     {
 389         aLineEndBuf[0] = '\r';
 390         aLineEndBuf[1] = '\n';
 391         nLineEndLen = 2;
 392     }
 393
 394     nBufLen = 0;
 395     pGroup = pData->mpFirstGroup;
 396     while ( pGroup )
 397     {
 398         // Don't write empty groups
 399         if ( pGroup->mpFirstKey )
 400         {
 401             nBufLen += pGroup->maGroupName.getLength() + nLineEndLen + 2;
 402             pKey = pGroup->mpFirstKey;
 403             while ( pKey )
 404             {
 405                 nValueLen = pKey->maValue.getLength();
 406                 if ( pKey->mbIsComment )
 407                     nBufLen += nValueLen + nLineEndLen;
 408                 else
 409                     nBufLen += pKey->maKey.getLength() + nValueLen + nLineEndLen + 1;
 410
 411                 pKey = pKey->mpNext;
 412             }
 413
 414             // Write empty lines after each group
 415             if ( !pGroup->mnEmptyLines )
 416                 pGroup->mnEmptyLines = 1;
 417             nBufLen += nLineEndLen * pGroup->mnEmptyLines;
 418         }
 419
 420         pGroup = pGroup->mpNext;
 421     }
 422
 423     // Output buffer length
 424     rLen = nBufLen;
 425     if ( !nBufLen )
 426     {
 427         pWriteBuf = new sal_uInt8[nLineEndLen];
 428         if ( pWriteBuf )
 429         {
 430             pWriteBuf[0] = aLineEndBuf[0];
 431             if ( nLineEndLen == 2 )
 432                 pWriteBuf[1] = aLineEndBuf[1];
 433             return pWriteBuf;
 434         }
 435         else
 436             return 0;
 437     }
 438
 439     // Allocate new write buffer (caller frees it)
 440     pWriteBuf = new sal_uInt8[nBufLen];
 441     if ( !pWriteBuf )
 442         return 0;
 443
 444     // fill buffer
 445     pBuf = pWriteBuf;
 446     pGroup = pData->mpFirstGroup;
 447     while ( pGroup )
 448     {
 449         // Don't write empty groups
 450         if ( pGroup->mpFirstKey )
 451         {
 452             *pBuf = '[';    pBuf++;
 453             memcpy( pBuf, pGroup->maGroupName.getStr(), pGroup->maGroupName.getLength() );
 454             pBuf += pGroup->maGroupName.getLength();
 455             *pBuf = ']';    pBuf++;
 456             *pBuf = aLineEndBuf[0]; pBuf++;
 457             if ( nLineEndLen == 2 )
 458             {
 459                 *pBuf = aLineEndBuf[1]; pBuf++;
 460             }
 461             pKey = pGroup->mpFirstKey;
 462             while ( pKey )
 463             {
 464                 nValueLen = pKey->maValue.getLength();
 465                 if ( pKey->mbIsComment )
 466                 {
 467                     if ( nValueLen )
 468                     {
 469                         memcpy( pBuf, pKey->maValue.getStr(), nValueLen );
 470                         pBuf += nValueLen;
 471                     }
 472                     *pBuf = aLineEndBuf[0]; pBuf++;
 473                     if ( nLineEndLen == 2 )
 474                     {
 475                         *pBuf = aLineEndBuf[1]; pBuf++;
 476                     }
 477                 }
 478                 else
 479                 {
 480                     nKeyLen = pKey->maKey.getLength();
 481                     memcpy( pBuf, pKey->maKey.getStr(), nKeyLen );
 482                     pBuf += nKeyLen;
 483                     *pBuf = '=';    pBuf++;
 484                     memcpy( pBuf, pKey->maValue.getStr(), nValueLen );
 485                     pBuf += nValueLen;
 486                     *pBuf = aLineEndBuf[0]; pBuf++;
 487                     if ( nLineEndLen == 2 )
 488                     {
 489                         *pBuf = aLineEndBuf[1]; pBuf++;
 490                     }
 491                 }
 492
 493                 pKey = pKey->mpNext;
 494             }
 495
 496             // Store empty line after each group
 497             sal_uInt16 nEmptyLines = pGroup->mnEmptyLines;
 498             while ( nEmptyLines )
 499             {
 500                 *pBuf = aLineEndBuf[0]; pBuf++;
 501                 if ( nLineEndLen == 2 )
 502                 {
 503                     *pBuf = aLineEndBuf[1]; pBuf++;
 504                 }
 505                 nEmptyLines--;
 506             }
 507         }
 508
 509         pGroup = pGroup->mpNext;
 510     }
 511
 512     return pWriteBuf;
 513 }
 514
 515 static void ImplReadConfig( ImplConfigData* pData )
 516 {
 517     sal_uIntPtr nTimeStamp = 0;
 518     sal_uInt64  nRead = 0;
 519     bool    bRead = false;
 520     bool    bIsUTF8BOM = false;
 521     sal_uInt8*  pBuf = ImplSysReadConfig( pData->maFileName, nRead, bRead, bIsUTF8BOM, nTimeStamp );
 522
 523     // Read config list from buffer
 524     if ( pBuf )
 525     {
 526         ImplMakeConfigList( pData, pBuf, nRead );
 527         delete[] pBuf;
 528     }
 529     pData->mnTimeStamp = nTimeStamp;
 530     pData->mbModified  = false;
 531     if ( bRead )
 532         pData->mbRead = true;
 533     if ( bIsUTF8BOM )
 534         pData->mbIsUTF8BOM = true;
 535 }
 536
 537 static void ImplWriteConfig( ImplConfigData* pData )
 538 {
 539     SAL_WARN_IF( pData->mnTimeStamp != ImplSysGetConfigTimeStamp( pData->maFileName ),
 540         "tools.generic", "Config overwrites modified configfile: " << pData->maFileName );
 541
 542     // Read config list from buffer
 543     sal_uIntPtr nBufLen;
 544     sal_uInt8*  pBuf = ImplGetConfigBuffer( pData, nBufLen );
 545     if ( pBuf )
 546     {
 547         if ( ImplSysWriteConfig( pData->maFileName, pBuf, nBufLen, pData->mbIsUTF8BOM, pData->mnTimeStamp ) )
 548             pData->mbModified = false;
 549         delete[] pBuf;
 550     }
 551     else
 552         pData->mbModified = false;
 553 }
 554
 555 static void ImplDeleteConfigData( ImplConfigData* pData )
 556 {
 557     ImplKeyData*    pTempKey;
 558     ImplKeyData*    pKey;
 559     ImplGroupData*  pTempGroup;
 560     ImplGroupData*  pGroup = pData->mpFirstGroup;
 561     while ( pGroup )
 562     {
 563         pTempGroup = pGroup->mpNext;
 564
 565         // remove all keys
 566         pKey = pGroup->mpFirstKey;
 567         while ( pKey )
 568         {
 569             pTempKey = pKey->mpNext;
 570             delete pKey;
 571             pKey = pTempKey;
 572         }
 573
 574         // remove group and continue
 575         delete pGroup;
 576         pGroup = pTempGroup;
 577     }
 578
 579     pData->mpFirstGroup = NULL;
 580 }
 581
 582 static ImplConfigData* ImplGetConfigData( const OUString& rFileName )
 583 {
 584     ImplConfigData* pData;
 585
 586     pData                   = new ImplConfigData;
 587     pData->maFileName       = rFileName;
 588     pData->mpFirstGroup     = NULL;
 589     pData->mnDataUpdateId   = 0;
 590     pData->meLineEnd        = LINEEND_CRLF;
 591     pData->mnRefCount       = 0;
 592     pData->mbRead           = false;
 593     pData->mbIsUTF8BOM      = false;
 594     ImplReadConfig( pData );
 595
 596     return pData;
 597 }
 598
 599 static void ImplFreeConfigData( ImplConfigData* pDelData )
 600 {
 601     ImplDeleteConfigData( pDelData );
 602     delete pDelData;
 603 }
 604
 605 bool Config::ImplUpdateConfig() const
 606 {
 607     // Re-read file if timestamp differs
 608     if ( mpData->mnTimeStamp != ImplSysGetConfigTimeStamp( maFileName ) )
 609     {
 610         ImplDeleteConfigData( mpData );
 611         ImplReadConfig( mpData );
 612         mpData->mnDataUpdateId++;
 613         return true;
 614     }
 615     else
 616         return false;
 617 }
 618
 619 ImplGroupData* Config::ImplGetGroup() const
 620 {
 621     if ( !mpActGroup || (mnDataUpdateId != mpData->mnDataUpdateId) )
 622     {
 623         ImplGroupData* pPrevGroup = NULL;
 624         ImplGroupData* pGroup = mpData->mpFirstGroup;
 625         while ( pGroup )
 626         {
 627             if ( pGroup->maGroupName.equalsIgnoreAsciiCase(maGroupName) )
 628                 break;
 629
 630             pPrevGroup = pGroup;
 631             pGroup = pGroup->mpNext;
 632         }
 633
 634         // Add group if not exists
 635         if ( !pGroup )
 636         {
 637             pGroup               = new ImplGroupData;
 638             pGroup->mpNext       = NULL;
 639             pGroup->mpFirstKey   = NULL;
 640             pGroup->mnEmptyLines = 1;
 641             if ( pPrevGroup )
 642                 pPrevGroup->mpNext = pGroup;
 643             else
 644                 mpData->mpFirstGroup = pGroup;
 645         }
 646
 647         // Always inherit group names and upate cache members
 648         pGroup->maGroupName             = maGroupName;
 649         const_cast<Config*>(this)->mnDataUpdateId = mpData->mnDataUpdateId;
 650         const_cast<Config*>(this)->mpActGroup     = pGroup;
 651     }
 652
 653     return mpActGroup;
 654 }
 655
 656 Config::Config( const OUString& rFileName )
 657 {
 658     // Initialize config data
 659     maFileName      = toUncPath( rFileName );
 660     mpData          = ImplGetConfigData( maFileName );
 661     mpActGroup      = NULL;
 662     mnDataUpdateId  = 0;
 663     mnLockCount     = 1;
 664     mbPersistence   = true;
 665
 666 #ifdef DBG_UTIL
 667     OStringBuffer aTraceStr("Config::Config( ");
 668     aTraceStr.append(OUStringToOString(maFileName, RTL_TEXTENCODING_UTF8));
 669     aTraceStr.append(" )");
 670     OSL_TRACE("%s", aTraceStr.getStr());
 671 #endif
 672 }
 673
 674 Config::~Config()
 675 {
 676 #ifdef DBG_UTIL
 677     OSL_TRACE( "Config::~Config()" );
 678 #endif
 679
 680     Flush();
 681     ImplFreeConfigData( mpData );
 682 }
 683
 684 void Config::SetGroup(const OString& rGroup)
 685 {
 686     // If group is to be reset, it needs to be updated on next call
 687     if ( maGroupName != rGroup )
 688     {
 689         maGroupName     = rGroup;
 690         mnDataUpdateId  = mpData->mnDataUpdateId-1;
 691     }
 692 }
 693
 694 void Config::DeleteGroup(const OString& rGroup)
 695 {
 696     // Update config data if necessary
 697     if ( !mnLockCount || !mpData->mbRead )
 698     {
 699         ImplUpdateConfig();
 700         mpData->mbRead = true;
 701     }
 702
 703     ImplGroupData* pPrevGroup = NULL;
 704     ImplGroupData* pGroup = mpData->mpFirstGroup;
 705     while ( pGroup )
 706     {
 707         if ( pGroup->maGroupName.equalsIgnoreAsciiCase(rGroup) )
 708             break;
 709
 710         pPrevGroup = pGroup;
 711         pGroup = pGroup->mpNext;
 712     }
 713
 714     if ( pGroup )
 715     {
 716         // Remove all keys
 717         ImplKeyData* pTempKey;
 718         ImplKeyData* pKey = pGroup->mpFirstKey;
 719         while ( pKey )
 720         {
 721             pTempKey = pKey->mpNext;
 722             delete pKey;
 723             pKey = pTempKey;
 724         }
 725
 726         // Rewire pointers and remove group
 727         if ( pPrevGroup )
 728             pPrevGroup->mpNext = pGroup->mpNext;
 729         else
 730             mpData->mpFirstGroup = pGroup->mpNext;
 731         delete pGroup;
 732
 733         // Rewrite config data
 734         if ( !mnLockCount && mbPersistence )
 735             ImplWriteConfig( mpData );
 736         else
 737         {
 738             mpData->mbModified = true;
 739         }
 740
 741         mnDataUpdateId = mpData->mnDataUpdateId;
 742         mpData->mnDataUpdateId++;
 743     }
 744 }
 745
 746 OString Config::GetGroupName(sal_uInt16 nGroup) const
 747 {
 748     // Update config data if necessary
 749     if ( !mnLockCount )
 750         ImplUpdateConfig();
 751
 752     ImplGroupData*  pGroup = mpData->mpFirstGroup;
 753     sal_uInt16          nGroupCount = 0;
 754     OString aGroupName;
 755     while ( pGroup )
 756     {
 757         if ( nGroup == nGroupCount )
 758         {
 759             aGroupName = pGroup->maGroupName;
 760             break;
 761         }
 762
 763         nGroupCount++;
 764         pGroup = pGroup->mpNext;
 765     }
 766
 767     return aGroupName;
 768 }
 769
 770 sal_uInt16 Config::GetGroupCount() const
 771 {
 772     // Update config data if necessary
 773     if ( !mnLockCount )
 774         ImplUpdateConfig();
 775
 776     ImplGroupData*  pGroup = mpData->mpFirstGroup;
 777     sal_uInt16          nGroupCount = 0;
 778     while ( pGroup )
 779     {
 780         nGroupCount++;
 781         pGroup = pGroup->mpNext;
 782     }
 783
 784     return nGroupCount;
 785 }
 786
 787 bool Config::HasGroup(const OString& rGroup) const
 788 {
 789     // Update config data if necessary
 790     if ( !mnLockCount )
 791         ImplUpdateConfig();
 792
 793     ImplGroupData*  pGroup = mpData->mpFirstGroup;
 794     bool            bRet = false;
 795
 796     while( pGroup )
 797     {
 798         if( pGroup->maGroupName.equalsIgnoreAsciiCase(rGroup) )
 799         {
 800             bRet = true;
 801             break;
 802         }
 803
 804         pGroup = pGroup->mpNext;
 805     }
 806
 807     return bRet;
 808 }
 809
 810 OString Config::ReadKey(const OString& rKey) const
 811 {
 812     return ReadKey(rKey, OString());
 813 }
 814
 815 OString Config::ReadKey(const OString& rKey, const OString& rDefault) const
 816 {
 817 #ifdef DBG_UTIL
 818     OStringBuffer aTraceStr("Config::ReadKey( ");
 819     aTraceStr.append(rKey);
 820     aTraceStr.append(" ) from ");
 821     aTraceStr.append(GetGroup());
 822     aTraceStr.append(" in ");
 823     aTraceStr.append(OUStringToOString(maFileName, RTL_TEXTENCODING_UTF8));
 824     OSL_TRACE("%s", aTraceStr.getStr());
 825 #endif
 826
 827     // Update config data if necessary
 828     if ( !mnLockCount )
 829         ImplUpdateConfig();
 830
 831     // Search key, return value if found
 832     ImplGroupData* pGroup = ImplGetGroup();
 833     if ( pGroup )
 834     {
 835         ImplKeyData* pKey = pGroup->mpFirstKey;
 836         while ( pKey )
 837         {
 838             if ( !pKey->mbIsComment && pKey->maKey.equalsIgnoreAsciiCase(rKey) )
 839                 return pKey->maValue;
 840
 841             pKey = pKey->mpNext;
 842         }
 843     }
 844
 845     return rDefault;
 846 }
 847
 848 void Config::WriteKey(const OString& rKey, const OString& rStr)
 849 {
 850 #ifdef DBG_UTIL
 851     OStringBuffer aTraceStr("Config::WriteKey( ");
 852     aTraceStr.append(rKey);
 853     aTraceStr.append(", ");
 854     aTraceStr.append(rStr);
 855     aTraceStr.append(" ) to ");
 856     aTraceStr.append(GetGroup());
 857     aTraceStr.append(" in ");
 858     aTraceStr.append(OUStringToOString(maFileName, RTL_TEXTENCODING_UTF8));
 859     OSL_TRACE("%s", aTraceStr.getStr());
 860 #endif
 861
 862     // Update config data if necessary
 863     if ( !mnLockCount || !mpData->mbRead )
 864     {
 865         ImplUpdateConfig();
 866         mpData->mbRead = true;
 867     }
 868
 869     // Search key and update value if found
 870     ImplGroupData* pGroup = ImplGetGroup();
 871     if ( pGroup )
 872     {
 873         ImplKeyData* pPrevKey = NULL;
 874         ImplKeyData* pKey = pGroup->mpFirstKey;
 875         while ( pKey )
 876         {
 877             if ( !pKey->mbIsComment && pKey->maKey.equalsIgnoreAsciiCase(rKey) )
 878                 break;
 879
 880             pPrevKey = pKey;
 881             pKey = pKey->mpNext;
 882         }
 883
 884         bool bNewValue;
 885         if ( !pKey )
 886         {
 887             pKey              = new ImplKeyData;
 888             pKey->mpNext      = NULL;
 889             pKey->maKey       = rKey;
 890             pKey->mbIsComment = false;
 891             if ( pPrevKey )
 892                 pPrevKey->mpNext = pKey;
 893             else
 894                 pGroup->mpFirstKey = pKey;
 895             bNewValue = true;
 896         }
 897         else
 898             bNewValue = pKey->maValue != rStr;
 899
 900         if ( bNewValue )
 901         {
 902             pKey->maValue = rStr;
 903
 904             if ( !mnLockCount && mbPersistence )
 905                 ImplWriteConfig( mpData );
 906             else
 907             {
 908                 mpData->mbModified = true;
 909             }
 910         }
 911     }
 912 }
 913
 914 void Config::DeleteKey(const OString& rKey)
 915 {
 916     // Update config data if necessary
 917     if ( !mnLockCount || !mpData->mbRead )
 918     {
 919         ImplUpdateConfig();
 920         mpData->mbRead = true;
 921     }
 922
 923     // Search key and update value
 924     ImplGroupData* pGroup = ImplGetGroup();
 925     if ( pGroup )
 926     {
 927         ImplKeyData* pPrevKey = NULL;
 928         ImplKeyData* pKey = pGroup->mpFirstKey;
 929         while ( pKey )
 930         {
 931             if ( !pKey->mbIsComment && pKey->maKey.equalsIgnoreAsciiCase(rKey) )
 932                 break;
 933
 934             pPrevKey = pKey;
 935             pKey = pKey->mpNext;
 936         }
 937
 938         if ( pKey )
 939         {
 940             // Rewire group pointers and delete
 941             if ( pPrevKey )
 942                 pPrevKey->mpNext = pKey->mpNext;
 943             else
 944                 pGroup->mpFirstKey = pKey->mpNext;
 945             delete pKey;
 946
 947             // Rewrite config file
 948             if ( !mnLockCount && mbPersistence )
 949                 ImplWriteConfig( mpData );
 950             else
 951             {
 952                 mpData->mbModified = true;
 953             }
 954         }
 955     }
 956 }
 957
 958 sal_uInt16 Config::GetKeyCount() const
 959 {
 960 #ifdef DBG_UTIL
 961     OStringBuffer aTraceStr("Config::GetKeyCount()");
 962     aTraceStr.append(" from ");
 963     aTraceStr.append(GetGroup());
 964     aTraceStr.append(" in ");
 965     aTraceStr.append(OUStringToOString(maFileName, RTL_TEXTENCODING_UTF8));
 966     OSL_TRACE("%s", aTraceStr.getStr());
 967 #endif
 968
 969     // Update config data if necessary
 970     if ( !mnLockCount )
 971         ImplUpdateConfig();
 972
 973     // Search key and update value
 974     sal_uInt16 nCount = 0;
 975     ImplGroupData* pGroup = ImplGetGroup();
 976     if ( pGroup )
 977     {
 978         ImplKeyData* pKey = pGroup->mpFirstKey;
 979         while ( pKey )
 980         {
 981             if ( !pKey->mbIsComment )
 982                 nCount++;
 983
 984             pKey = pKey->mpNext;
 985         }
 986     }
 987
 988     return nCount;
 989 }
 990
 991 OString Config::GetKeyName(sal_uInt16 nKey) const
 992 {
 993 #ifdef DBG_UTIL
 994     OStringBuffer aTraceStr("Config::GetKeyName( ");
 995     aTraceStr.append(static_cast<sal_Int32>(nKey));
 996     aTraceStr.append(" ) from ");
 997     aTraceStr.append(GetGroup());
 998     aTraceStr.append(" in ");
 999     aTraceStr.append(OUStringToOString(
1000         maFileName, RTL_TEXTENCODING_UTF8));
1001     OSL_TRACE("%s", aTraceStr.getStr());
1002 #endif
1003
1004     // search key and return name if found
1005     ImplGroupData* pGroup = ImplGetGroup();
1006     if ( pGroup )
1007     {
1008         ImplKeyData* pKey = pGroup->mpFirstKey;
1009         while ( pKey )
1010         {
1011             if ( !pKey->mbIsComment )
1012             {
1013                 if ( !nKey )
1014                     return pKey->maKey;
1015                 nKey--;
1016             }
1017
1018             pKey = pKey->mpNext;
1019         }
1020     }
1021
1022     return OString();
1023 }
1024
1025 OString Config::ReadKey(sal_uInt16 nKey) const
1026 {
1027 #ifdef DBG_UTIL
1028     OStringBuffer aTraceStr("Config::ReadKey( ");
1029     aTraceStr.append(static_cast<sal_Int32>(nKey));
1030     aTraceStr.append(" ) from ");
1031     aTraceStr.append(GetGroup());
1032     aTraceStr.append(" in ");
1033     aTraceStr.append(OUStringToOString(maFileName,
1034         RTL_TEXTENCODING_UTF8));
1035     OSL_TRACE("%s", aTraceStr.getStr());
1036 #endif
1037
1038     // Search key and return value if found
1039     ImplGroupData* pGroup = ImplGetGroup();
1040     if ( pGroup )
1041     {
1042         ImplKeyData* pKey = pGroup->mpFirstKey;
1043         while ( pKey )
1044         {
1045             if ( !pKey->mbIsComment )
1046             {
1047                 if ( !nKey )
1048                     return pKey->maValue;
1049                 nKey--;
1050             }
1051
1052             pKey = pKey->mpNext;
1053         }
1054     }
1055
1056     return OString();
1057 }
1058
1059 void Config::Flush()
1060 {
1061     if ( mpData->mbModified && mbPersistence )
1062         ImplWriteConfig( mpData );
1063 }
1064
1065 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */