unity/kconfig/kconfigbackend.cpp

   1 /*
   2   This file is part of the KDE libraries
   3   Copyright (c) 1999 Preston Brown <pbrown@kde.org>
   4   Copyright (c) 1997-1999 Matthias Kalle Dalheimer <kalle@kde.org>
   5
   6   This library is free software; you can redistribute it and/or
   7   modify it under the terms of the GNU Library General Public
   8   License as published by the Free Software Foundation; either
   9   version 2 of the License, or (at your option) any later version.
  10
  11   This library is distributed in the hope that it will be useful,
  12   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14   Library General Public License for more details.
  15
  16   You should have received a copy of the GNU Library General Public License
  17   along with this library; see the file COPYING.LIB.  If not, write to
  18   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19   Boston, MA 02111-1307, USA.
  20 */
  21
  22 #include <config.h>
  23
  24 #include <unistd.h>
  25 #include <ctype.h>
  26 #ifdef HAVE_SYS_MMAN_H
  27 #include <sys/mman.h>
  28 #endif
  29 #include <sys/types.h>
  30 #ifdef HAVE_SYS_STAT_H
  31 #include <sys/stat.h>
  32 #endif
  33 #include <fcntl.h>
  34 #include <signal.h>
  35
  36 #undef Unsorted
  37 #include <qdir.h>
  38 #include <qfileinfo.h>
  39 #include <qtextcodec.h>
  40 #include <qtextstream.h>
  41
  42 #include "kconfigbackend.h"
  43 #include "kconfigbase.h"
  44 #include <kglobal.h>
  45 #include <klocale.h>
  46 #include <kstandarddirs.h>
  47 #include <ksavefile.h>
  48 #include <kurl.h>
  49
  50 extern bool checkAccess(const QString& pathname, int mode);
  51 /* translate escaped escape sequences to their actual values. */
  52 static QCString printableToString(const char *str, int l)
  53 {
  54   // Strip leading white-space.
  55   while((l>0) &&
  56         ((*str == ' ') || (*str == '\t') || (*str == '\r')))
  57   {
  58      str++; l--;
  59   }
  60
  61   // Strip trailing white-space.
  62   while((l>0) &&
  63         ((str[l-1] == ' ') || (str[l-1] == '\t') || (str[l-1] == '\r')))
  64   {
  65      l--;
  66   }
  67
  68   QCString result(l + 1);
  69   char *r = result.data();
  70
  71   for(int i = 0; i < l;i++, str++)
  72   {
  73      if (*str == '\\')
  74      {
  75         i++, str++;
  76         if (i >= l) // End of line. (Line ends with single slash)
  77         {
  78            *r++ = '\\';
  79            break;
  80         }
  81         switch(*str)
  82         {
  83            case 's':
  84               *r++ = ' ';
  85               break;
  86            case 't':
  87               *r++ = '\t';
  88               break;
  89            case 'n':
  90               *r++ = '\n';
  91               break;
  92            case 'r':
  93               *r++ = '\r';
  94               break;
  95            case '\\':
  96               *r++ = '\\';
  97               break;
  98            default:
  99               *r++ = '\\';
 100               *r++ = *str;
 101         }
 102      }
 103      else
 104      {
 105         *r++ = *str;
 106      }
 107   }
 108   result.truncate(r-result.data());
 109   return result;
 110 }
 111
 112 static QCString stringToPrintable(const QCString& str){
 113   QCString result(str.length()*2); // Maximum 2x as long as source string
 114   register char *r = result.data();
 115   register char *s = str.data();
 116
 117   if (!s) return QCString("");
 118
 119   // Escape leading space
 120   if (*s == ' ')
 121   {
 122      *r++ = '\\'; *r++ = 's';
 123      s++;
 124   }
 125
 126   if (*s)
 127   {
 128    while(*s)
 129    {
 130     if (*s == '\n')
 131     {
 132       *r++ = '\\'; *r++ = 'n';
 133     }
 134     else if (*s == '\t')
 135     {
 136       *r++ = '\\'; *r++ = 't';
 137     }
 138     else if (*s == '\r')
 139     {
 140       *r++ = '\\'; *r++ = 'r';
 141     }
 142     else if (*s == '\\')
 143     {
 144       *r++ = '\\'; *r++ = '\\';
 145     }
 146     else
 147     {
 148       *r++ = *s;
 149     }
 150     s++;
 151    }
 152    // Escape trailing space
 153    if (*(r-1) == ' ')
 154    {
 155       *(r-1) = '\\'; *r++ = 's';
 156    }
 157   }
 158
 159   result.truncate(r - result.data());
 160   return result;
 161 }
 162
 163 void KConfigBackEnd::changeFileName(const QString &_fileName,
 164                                     const char * _resType,
 165                                     bool _useKDEGlobals)
 166 {
 167    mfileName = _fileName;
 168    resType = _resType;
 169    useKDEGlobals = _useKDEGlobals;
 170    if (mfileName.isEmpty())
 171       mLocalFileName = QString::null;
 172    else if (mfileName[0] == '/')
 173       mLocalFileName = mfileName;
 174    else
 175       mLocalFileName = KGlobal::dirs()->saveLocation(resType) + mfileName;
 176
 177    if (useKDEGlobals)
 178       mGlobalFileName = KGlobal::dirs()->saveLocation("config") +
 179               QString::fromLatin1("kdeglobals");
 180    else
 181       mGlobalFileName = QString::null;
 182 }
 183
 184 KConfigBackEnd::KConfigBackEnd(KConfigBase *_config,
 185                                const QString &_fileName,
 186                                const char * _resType,
 187                                bool _useKDEGlobals)
 188   : pConfig(_config), bFileImmutable(false), mConfigState(KConfigBase::NoAccess), mFileMode(-1)
 189 {
 190    changeFileName(_fileName, _resType, _useKDEGlobals);
 191 }
 192
 193 void KConfigBackEnd::setFileWriteMode(int mode)
 194 {
 195   mFileMode = mode;
 196 }
 197
 198 bool KConfigINIBackEnd::parseConfigFiles()
 199 {
 200   // Check if we can write to the local file.
 201   mConfigState = KConfigBase::ReadOnly;
 202   if (!mLocalFileName.isEmpty() && !pConfig->isReadOnly())
 203   {
 204      if (checkAccess(mLocalFileName, W_OK))
 205      {
 206         mConfigState = KConfigBase::ReadWrite;
 207      }
 208      else
 209      {
 210         // Create the containing dir, maybe it wasn't there
 211         KURL path;
 212         path.setPath(mLocalFileName);
 213         QString dir=path.directory();
 214         KStandardDirs::makeDir(dir);
 215
 216         if (checkAccess(mLocalFileName, W_OK))
 217         {
 218            mConfigState = KConfigBase::ReadWrite;
 219         }
 220      }
 221   }
 222
 223   // Parse all desired files from the least to the most specific.
 224   bFileImmutable = false;
 225
 226   // Parse the general config files
 227   if (useKDEGlobals) {
 228     QStringList kdercs = KGlobal::dirs()->
 229       findAllResources("config", QString::fromLatin1("kdeglobals"));
 230
 231     if (checkAccess(QString::fromLatin1("/etc/kderc"), R_OK))
 232       kdercs += QString::fromLatin1("/etc/kderc");
 233
 234     kdercs += KGlobal::dirs()->
 235       findAllResources("config", QString::fromLatin1("system.kdeglobals"));
 236
 237     QStringList::ConstIterator it;
 238
 239     for (it = kdercs.fromLast(); it != kdercs.end(); --it) {
 240
 241       QFile aConfigFile( *it );
 242       if (!aConfigFile.open( IO_ReadOnly ))
 243            continue;
 244       parseSingleConfigFile( aConfigFile, 0L, true, (*it != mGlobalFileName) );
 245       aConfigFile.close();
 246       if (bFileImmutable)
 247          break;
 248     }
 249   }
 250
 251   bool bReadFile = !mfileName.isEmpty();
 252   while(bReadFile) {
 253     bReadFile = false;
 254     QString bootLanguage;
 255     if (useKDEGlobals && localeString.isEmpty() && !KGlobal::_locale) {
 256        // Boot strap language
 257        bootLanguage = KLocale::_initLanguage(pConfig);
 258        setLocaleString(bootLanguage.utf8());
 259     }
 260
 261     bFileImmutable = false;
 262     QStringList list = KGlobal::dirs()->
 263       findAllResources(resType, mfileName);
 264
 265     QStringList::ConstIterator it;
 266
 267     for (it = list.fromLast(); it != list.end(); --it) {
 268
 269       QFile aConfigFile( *it );
 270       // we can already be sure that this file exists
 271       bool bIsLocal = (*it == mLocalFileName);
 272       if (aConfigFile.open( IO_ReadOnly )) {
 273          parseSingleConfigFile( aConfigFile, 0L, false, !bIsLocal );
 274          aConfigFile.close();
 275          if (bFileImmutable)
 276             break;
 277       }
 278     }
 279     if (KGlobal::dirs()->isRestrictedResource(resType, mfileName))
 280        bFileImmutable = true;
 281     QString currentLanguage;
 282     if (!bootLanguage.isEmpty())
 283     {
 284        currentLanguage = KLocale::_initLanguage(pConfig);
 285        // If the file changed the language, we need to read the file again
 286        // with the new language setting.
 287        if (bootLanguage != currentLanguage)
 288        {
 289           bReadFile = true;
 290           setLocaleString(currentLanguage.utf8());
 291        }
 292     }
 293   }
 294   if (bFileImmutable)
 295      mConfigState = KConfigBase::ReadOnly;
 296
 297   return true;
 298 }
 299
 300 #ifdef HAVE_MMAP
 301 #ifdef SIGBUS
 302 static const char **mmap_pEof;
 303
 304 static void mmap_sigbus_handler(int)
 305 {
 306    *mmap_pEof = 0;
 307    write(2, "SIGBUS\n", 7);
 308    signal(SIGBUS, mmap_sigbus_handler);
 309 }
 310 #endif
 311 #endif
 312
 313 void KConfigINIBackEnd::parseSingleConfigFile(QFile &rFile,
 314                                               KEntryMap *pWriteBackMap,
 315                                               bool bGlobal, bool bDefault)
 316 {
 317    void (*old_sighandler)(int) = 0;
 318
 319    if (!rFile.isOpen()) // come back, if you have real work for us ;->
 320       return;
 321
 322    //using kdDebug() here leads to an infinite loop
 323    //remove this for the release, aleXXX
 324    //qWarning("Parsing %s, global = %s default = %s",
 325    //           rFile.name().latin1(), bGlobal ? "true" : "false", bDefault ? "true" : "false");
 326
 327    QCString aCurrentGroup("<default>");
 328
 329    const char *s, *eof;
 330    QByteArray data;
 331
 332    unsigned int ll = localeString.length();
 333
 334 #ifdef HAVE_MMAP
 335    const char *map = ( const char* ) mmap(0, rFile.size(), PROT_READ, MAP_PRIVATE,
 336                                           rFile.handle(), 0);
 337
 338    if (map)
 339    {
 340       s = map;
 341       eof = s + rFile.size();
 342
 343 #ifdef SIGBUS
 344       mmap_pEof = &eof;
 345       old_sighandler = signal(SIGBUS, mmap_sigbus_handler);
 346 #endif
 347    }
 348    else
 349 #endif
 350    {
 351       rFile.at(0);
 352       data = rFile.readAll();
 353       s = data.data();
 354       eof = s + data.size();
 355    }
 356
 357    bool fileOptionImmutable = false;
 358    bool groupOptionImmutable = false;
 359    bool groupSkip = false;
 360
 361    int line = 0;
 362    for(; s < eof; s++)
 363    {
 364       line++;
 365
 366       while((s < eof) && isspace(*s) && (*s != '\n'))
 367          s++; //skip leading whitespace, shouldn't happen too often
 368
 369       //skip empty lines, lines starting with #
 370       if ((s < eof) && ((*s == '\n') || (*s == '#')))
 371       {
 372     sktoeol:    //skip till end-of-line
 373          while ((s < eof) && (*s != '\n'))
 374             s++;
 375          continue; // Empty or comment or no keyword
 376       }
 377       const char *startLine = s;
 378
 379       if (*s == '[')  //group
 380       {
 381          while ((s < eof) && (*s != '\n') && (*s != ']')) s++; // Search till end of group
 382          const char *e = s;
 383          while ((s < eof) && (*s != '\n')) s++; // Search till end of line / end of file
 384          if ((e >= eof) || (*e != ']'))
 385          {
 386             fprintf(stderr, "Invalid group header at %s:%d\n", rFile.name().latin1(), line);
 387             continue;
 388          }
 389          // group found; get the group name by taking everything in
 390          // between the brackets
 391          if ((e-startLine == 3) &&
 392              (startLine[1] == '$') &&
 393              (startLine[2] == 'i'))
 394          {
 395             fileOptionImmutable = true;
 396             continue;
 397          }
 398
 399          aCurrentGroup = QCString(startLine + 1, e - startLine);
 400          //cout<<"found group ["<<aCurrentGroup<<"]"<<endl;
 401
 402          // Backwards compatibility
 403          if (aCurrentGroup == "KDE Desktop Entry")
 404             aCurrentGroup = "Desktop Entry";
 405
 406          groupOptionImmutable = fileOptionImmutable;
 407
 408          e++;
 409          if ((e+2 < eof) && (*e++ == '[') && (*e++ == '$')) // Option follows
 410          {
 411             if (*e == 'i')
 412             {
 413                groupOptionImmutable = true;
 414             }
 415          }
 416
 417          KEntryKey groupKey(aCurrentGroup, 0);
 418          KEntry entry = pConfig->lookupData(groupKey);
 419          groupSkip = entry.bImmutable;
 420
 421          if (groupSkip)
 422             continue;
 423
 424          entry.bImmutable = groupOptionImmutable;
 425          pConfig->putData(groupKey, entry, false);
 426
 427          if (pWriteBackMap)
 428          {
 429             // add the special group key indicator
 430             (*pWriteBackMap)[groupKey] = entry;
 431          }
 432
 433          continue;
 434       }
 435       if (groupSkip)
 436         goto sktoeol; // Skip entry
 437
 438       bool optionImmutable = groupOptionImmutable;
 439       bool optionDeleted = false;
 440       bool optionExpand = false;
 441       const char *endOfKey = 0, *locale = 0, *elocale = 0;
 442       for (; (s < eof) && (*s != '\n'); s++)
 443       {
 444          if (*s == '=') //find the equal sign
 445          {
 446             if (!endOfKey)
 447                 endOfKey = s;
 448             goto haveeq;
 449          }
 450          if (*s == '[') //find the locale or options.
 451          {
 452             const char *option;
 453             const char *eoption;
 454             endOfKey = s;
 455             option = ++s;
 456             for (;; s++)
 457             {
 458                 if ((s >= eof) || (*s == '\n') || (*s == '=')) {
 459                     fprintf(stderr, "Invalid entry (missing ']') at %s:%d\n", rFile.name().latin1(), line);
 460                     goto sktoeol;
 461                 }
 462                 if (*s == ']')
 463                     break;
 464             }
 465             eoption = s;
 466             if (*option != '$')
 467             {
 468               // Locale
 469               if (locale) {
 470                 fprintf(stderr, "Invalid entry (second locale!?) at %s:%d\n", rFile.name().latin1(), line);
 471                 goto sktoeol;
 472               }
 473               locale = option;
 474               elocale = eoption;
 475             }
 476             else
 477             {
 478               // Option
 479               while (option < eoption)
 480               {
 481                  option++;
 482                  if (*option == 'i')
 483                     optionImmutable = true;
 484                  else if (*option == 'e')
 485                     optionExpand = true;
 486                  else if (*option == 'd')
 487                  {
 488                     optionDeleted = true;
 489                     goto haveeq;
 490                  }
 491                  else if (*option == ']')
 492                     break;
 493               }
 494             }
 495          }
 496       }
 497       fprintf(stderr, "Invalid entry (missing '=') at %s:%d\n", rFile.name().latin1(), line);
 498       continue;
 499
 500    haveeq:
 501       for (endOfKey--; ; endOfKey--)
 502       {
 503          if (endOfKey < startLine)
 504          {
 505            fprintf(stderr, "Invalid entry (empty key) at %s:%d\n", rFile.name().latin1(), line);
 506            goto sktoeol;
 507          }
 508          if (!isspace(*endOfKey))
 509             break;
 510       }
 511
 512       const char *st = ++s;
 513       while ((s < eof) && (*s != '\n')) s++; // Search till end of line / end of file
 514
 515       if (locale) {
 516           unsigned int cl = static_cast<unsigned int>(elocale - locale);
 517           if ((ll != cl) || memcmp(locale, localeString.data(), ll))
 518           {
 519               // backward compatibility. C == en_US
 520               if ( cl != 1 || ll != 5 || memcmp(locale, "C", 1) || memcmp(localeString.data(), "en_US", 5)) {
 521                   //cout<<"mismatched locale '"<<QCString(locale, elocale-locale +1)<<"'"<<endl;
 522                   // We can ignore this one
 523                   if (!pWriteBackMap)
 524                       continue; // We just ignore it
 525                   // We just store it as is to be able to write it back later.
 526                   endOfKey = elocale;
 527                   locale = 0;
 528               }
 529           }
 530       }
 531
 532       // insert the key/value line
 533       QCString key(startLine, endOfKey - startLine + 2);
 534       QCString val = printableToString(st, s - st);
 535       //qDebug("found key '%s' with value '%s'", key.data(), val.data());
 536
 537       KEntryKey aEntryKey(aCurrentGroup, key);
 538       aEntryKey.bLocal = (locale != 0);
 539       aEntryKey.bDefault = bDefault;
 540
 541       KEntry aEntry;
 542       aEntry.mValue = val;
 543       aEntry.bGlobal = bGlobal;
 544       aEntry.bImmutable = optionImmutable;
 545       aEntry.bDeleted = optionDeleted;
 546       aEntry.bExpand = optionExpand;
 547       aEntry.bNLS = (locale != 0);
 548
 549       if (pWriteBackMap) {
 550          // don't insert into the config object but into the temporary
 551          // scratchpad map
 552          pWriteBackMap->insert(aEntryKey, aEntry);
 553       } else {
 554          // directly insert value into config object
 555          // no need to specify localization; if the key we just
 556          // retrieved was localized already, no need to localize it again.
 557          pConfig->putData(aEntryKey, aEntry, false);
 558       }
 559    }
 560    if (fileOptionImmutable)
 561       bFileImmutable = true;
 562
 563 #ifdef HAVE_MMAP
 564    if (map)
 565    {
 566       munmap(( char* )map, rFile.size());
 567 #ifdef SIGBUS
 568       signal(SIGBUS, old_sighandler);
 569 #endif
 570    }
 571 #endif
 572 }
 573
 574
 575 void KConfigINIBackEnd::sync(bool bMerge)
 576 {
 577   // write-sync is only necessary if there are dirty entries
 578   if (!pConfig->isDirty())
 579     return;
 580
 581   bool bEntriesLeft = true;
 582
 583   // find out the file to write to (most specific writable file)
 584   // try local app-specific file first
 585
 586   if (!mfileName.isEmpty()) {
 587     // Create the containing dir if needed
 588     if ((resType!="config") && mLocalFileName[0]=='/')
 589     {
 590        KURL path;
 591        path.setPath(mLocalFileName);
 592        QString dir=path.directory();
 593        KStandardDirs::makeDir(dir);
 594     }
 595
 596     // Can we allow the write? We can, if the program
 597     // doesn't run SUID. But if it runs SUID, we must
 598     // check if the user would be allowed to write if
 599     // it wasn't SUID.
 600     if (checkAccess(mLocalFileName, W_OK)) {
 601       // is it writable?
 602       bEntriesLeft = writeConfigFile( mLocalFileName, false, bMerge );
 603     }
 604   }
 605
 606   // only write out entries to the kdeglobals file if there are any
 607   // entries marked global (indicated by bEntriesLeft) and
 608   // the useKDEGlobals flag is set.
 609   if (bEntriesLeft && useKDEGlobals) {
 610
 611
 612     // can we allow the write? (see above)
 613     if (checkAccess ( mGlobalFileName, W_OK )) {
 614       writeConfigFile( mGlobalFileName, true, bMerge );
 615     }
 616   }
 617
 618 }
 619
 620 static void writeEntries(FILE *pStream, const KEntryMap& entryMap, bool defaultGroup, bool &firstEntry, const QCString &localeString)
 621 {
 622   // now write out all other groups.
 623   QCString currentGroup;
 624   for (KEntryMapConstIterator aIt = entryMap.begin();
 625        aIt != entryMap.end(); ++aIt)
 626   {
 627      const KEntryKey &key = aIt.key();
 628
 629      // Either proces the default group or all others
 630      if ((key.mGroup != "<default>") == defaultGroup)
 631         continue; // Skip
 632
 633      // Skip default values and group headers.
 634      if ((key.bDefault) || key.mKey.isEmpty())
 635         continue; // Skip
 636
 637      const KEntry &currentEntry = *aIt;
 638
 639      KEntryMapConstIterator aTestIt = aIt;
 640      ++aTestIt;
 641      bool hasDefault = (aTestIt != entryMap.end());
 642      if (hasDefault)
 643      {
 644         const KEntryKey &defaultKey = aTestIt.key();
 645         if ((!defaultKey.bDefault) ||
 646             (defaultKey.mKey != key.mKey) ||
 647             (defaultKey.mGroup != key.mGroup) ||
 648             (defaultKey.bLocal != key.bLocal))
 649            hasDefault = false;
 650      }
 651
 652
 653      if (hasDefault)
 654      {
 655         // Entry had a default value
 656         if ((currentEntry.mValue == (*aTestIt).mValue) &&
 657             (currentEntry.bDeleted == (*aTestIt).bDeleted))
 658            continue; // Same as default, don't write.
 659      }
 660      else
 661      {
 662         // Entry had no default value.
 663         if (currentEntry.bDeleted)
 664            continue; // Don't write deleted entries if there is no default.
 665      }
 666
 667      if (!defaultGroup && (currentGroup != key.mGroup)) {
 668         if (!firstEntry)
 669             fprintf(pStream, "\n");
 670         currentGroup = key.mGroup;
 671         fprintf(pStream, "[%s]\n", currentGroup.data());
 672      }
 673
 674      firstEntry = false;
 675      // it is data for a group
 676      fputs(key.mKey.data(), pStream); // Key
 677
 678      if ( currentEntry.bNLS )
 679      {
 680         fputc('[', pStream);
 681         fputs(localeString.data(), pStream);
 682         fputc(']', pStream);
 683      }
 684
 685      if (currentEntry.bDeleted)
 686      {
 687         fputs("[$d]\n", pStream); // Deleted
 688      }
 689      else
 690      {
 691         if (currentEntry.bImmutable || currentEntry.bExpand)
 692         {
 693            fputc('[', pStream);
 694            fputc('$', pStream);
 695            if (currentEntry.bImmutable)
 696               fputc('i', pStream);
 697            if (currentEntry.bExpand)
 698               fputc('e', pStream);
 699
 700            fputc(']', pStream);
 701         }
 702         fputc('=', pStream);
 703         fputs(stringToPrintable(currentEntry.mValue).data(), pStream);
 704         fputc('\n', pStream);
 705      }
 706   } // for loop
 707 }
 708
 709 bool KConfigINIBackEnd::writeConfigFile(QString filename, bool bGlobal,
 710                                         bool bMerge)
 711 {
 712   KEntryMap aTempMap;
 713   bool bEntriesLeft = false;
 714
 715   // is the config object read-only?
 716   if (pConfig->isReadOnly())
 717     return true; // pretend we wrote it
 718
 719   bFileImmutable = false;
 720   if (bMerge)
 721   {
 722     // Read entries from disk
 723     QFile rConfigFile( filename );
 724     if (rConfigFile.open(IO_ReadOnly))
 725     {
 726        // fill the temporary structure with entries from the file
 727        parseSingleConfigFile( rConfigFile, &aTempMap, bGlobal, false );
 728        rConfigFile.close();
 729
 730        if (bFileImmutable) // File has become immutable on disk
 731           return true; // pretend we wrote it
 732     }
 733
 734     KEntryMap aMap = pConfig->internalEntryMap();
 735
 736     // augment this structure with the dirty entries from the config object
 737     for (KEntryMapIterator aIt = aMap.begin();
 738           aIt != aMap.end(); ++aIt)
 739     {
 740       const KEntry &currentEntry = *aIt;
 741       if(aIt.key().bDefault)
 742       {
 743          aTempMap.replace(aIt.key(), currentEntry);
 744          continue;
 745       }
 746
 747       if (!currentEntry.bDirty)
 748          continue;
 749
 750       // only write back entries that have the same
 751       // "globality" as the file
 752       if (currentEntry.bGlobal != bGlobal)
 753       {
 754         // wrong "globality" - might have to be saved later
 755         bEntriesLeft = true;
 756         continue;
 757       }
 758
 759       // put this entry from the config object into the
 760       // temporary map, possibly replacing an existing entry
 761       KEntryMapIterator aIt2 = aTempMap.find(aIt.key());
 762       if (aIt2 != aTempMap.end() && (*aIt2).bImmutable)
 763         continue; // Bail out if the on-disk entry is immutable
 764
 765       aTempMap.insert(aIt.key(), currentEntry, true);
 766     } // loop
 767   }
 768   else
 769   {
 770     // don't merge, just get the regular entry map and use that.
 771     aTempMap = pConfig->internalEntryMap();
 772     bEntriesLeft = true; // maybe not true, but we aren't sure
 773   }
 774
 775   // OK now the temporary map should be full of ALL entries.
 776   // write it out to disk.
 777
 778   // Check if file exists:
 779   int fileMode = -1;
 780   bool createNew = true;
 781
 782   struct stat buf;
 783   if (lstat(QFile::encodeName(filename), &buf) == 0)
 784   {
 785      if (S_ISLNK(buf.st_mode))
 786      {
 787         // File is a symlink:
 788         if (stat(QFile::encodeName(filename), &buf) == 0)
 789         {
 790            // Don't create new file but write to existing file instead.
 791            createNew = false;
 792         }
 793      }
 794      else if (buf.st_uid == getuid())
 795      {
 796         // Preserve file mode if file exists and is owned by user.
 797         fileMode = buf.st_mode & 0777;
 798      }
 799      else
 800      {
 801         // File is not owned by user:
 802         // Don't create new file but write to existing file instead.
 803         createNew = false;
 804      }
 805   }
 806
 807   KSaveFile *pConfigFile = 0;
 808   FILE *pStream = 0;
 809
 810   if (createNew)
 811   {
 812      pConfigFile = new KSaveFile( filename, 0600 );
 813
 814      if (pConfigFile->status() != 0)
 815      {
 816         delete pConfigFile;
 817         return bEntriesLeft;
 818      }
 819
 820      if (!bGlobal && (fileMode == -1))
 821         fileMode = mFileMode;
 822
 823      if (fileMode != -1)
 824      {
 825         fchmod(pConfigFile->handle(), fileMode);
 826      }
 827
 828      pStream = pConfigFile->fstream();
 829   }
 830   else
 831   {
 832      // Open existing file.
 833      // We use open() to ensure that we call without O_CREAT.
 834      int fd = open( QFile::encodeName(filename), O_WRONLY | O_TRUNC);
 835      if (fd < 0)
 836         return bEntriesLeft;
 837      pStream = fdopen( fd, "w");
 838      if (!pStream)
 839      {
 840         close(fd);
 841         return bEntriesLeft;
 842      }
 843   }
 844
 845   bool firstEntry = true;
 846
 847   // Write default group
 848   writeEntries(pStream, aTempMap, true, firstEntry, localeString);
 849
 850   // Write all other groups
 851   writeEntries(pStream, aTempMap, false, firstEntry, localeString);
 852
 853   if (pConfigFile)
 854   {
 855      pConfigFile->close();
 856      delete pConfigFile;
 857   }
 858   else
 859   {
 860      fclose(pStream);
 861   }
 862
 863   return bEntriesLeft;
 864 }
 865
 866
 867 void KConfigBackEnd::virtual_hook( int, void* )
 868 { /*BASE::virtual_hook( id, data );*/ }
 869
 870 void KConfigINIBackEnd::virtual_hook( int id, void* data )
 871 { KConfigBackEnd::virtual_hook( id, data ); }
 872