sal/osl/w32/profile.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 "system.h"
  21
  22 #include "file_url.hxx"
  23 #include "path_helper.hxx"
  24
  25 #include <string.h>
  26 #include <osl/diagnose.h>
  27 #include <osl/profile.h>
  28 #include <osl/process.h>
  29 #include <osl/thread.h>
  30 #include <osl/file.h>
  31 #include <rtl/alloc.h>
  32 #include <sal/macros.h>
  33 #include <sal/log.hxx>
  34 #include <o3tl/char16_t2wchar_t.hxx>
  35 #include <algorithm>
  36 #include <vector>
  37 using std::min;
  38 static void copy_ustr_n( void *dest, const void *source, size_t length ) { memcpy(dest, source, length*sizeof(sal_Unicode)); }
  39
  40 #define LINES_INI       32
  41 #define LINES_ADD       10
  42 #define SECTIONS_INI    5
  43 #define SECTIONS_ADD    3
  44 #define ENTRIES_INI     5
  45 #define ENTRIES_ADD     3
  46
  47 #define STR_INI_EXTENSION   L".ini"
  48 #define STR_INI_METAHOME    "?~"
  49 #define STR_INI_METASYS     "?$"
  50 #define STR_INI_METACFG     "?^"
  51 #define STR_INI_METAINS     "?#"
  52
  53 #define STR_INI_BOOLYES     "yes"
  54 #define STR_INI_BOOLON      "on"
  55 #define STR_INI_BOOLONE     "1"
  56 #define STR_INI_BOOLNO      "no"
  57 #define STR_INI_BOOLOFF     "off"
  58 #define STR_INI_BOOLZERO    "0"
  59
  60 #define FLG_USER            0x00FF
  61 #define FLG_AUTOOPEN        0x0100
  62 #define FLG_MODIFIED        0x0200
  63
  64 #define SVERSION_LOCATION   STR_INI_METACFG
  65 #define SVERSION_FALLBACK   STR_INI_METASYS
  66 #define SVERSION_NAME       "sversion"
  67 #define SVERSION_SECTION    "Versions"
  68 #define SVERSION_SOFFICE    "StarOffice"
  69 #define SVERSION_PROFILE    "soffice.ini"
  70 #define SVERSION_DIRS       { "bin", "program" }
  71 #define SVERSION_USER       "user"
  72
  73 /*#define DEBUG_OSL_PROFILE 1*/
  74
  75 typedef FILETIME osl_TStamp;
  76
  77 namespace {
  78
  79 enum osl_TLockMode
  80 {
  81     un_lock, read_lock, write_lock
  82 };
  83
  84 struct osl_TFile
  85 {
  86     HANDLE  m_Handle;
  87     char*       m_pReadPtr;
  88     char        m_ReadBuf[512];
  89     char*       m_pWriteBuf;
  90     sal_uInt32  m_nWriteBufLen;
  91     sal_uInt32  m_nWriteBufFree;
  92 };
  93
  94 struct osl_TProfileEntry
  95 {
  96     sal_uInt32      m_Line;
  97     sal_uInt32      m_Offset;
  98     sal_uInt32      m_Len;
  99 };
 100
 101 struct osl_TProfileSection
 102 {
 103     sal_uInt32          m_Line;
 104     sal_uInt32          m_Offset;
 105     sal_uInt32          m_Len;
 106     sal_uInt32          m_NoEntries;
 107     sal_uInt32          m_MaxEntries;
 108     osl_TProfileEntry*  m_Entries;
 109 };
 110
 111 /*
 112     Profile-data structure hidden behind oslProfile:
 113 */
 114 struct osl_TProfileImpl
 115 {
 116     sal_uInt32  m_Flags;
 117     osl_TFile*  m_pFile;
 118     osl_TStamp  m_Stamp;
 119     sal_uInt32  m_NoLines;
 120     sal_uInt32  m_MaxLines;
 121     sal_uInt32  m_NoSections;
 122     sal_uInt32  m_MaxSections;
 123     char**      m_Lines;
 124     rtl_uString *m_strFileName;
 125     osl_TProfileSection* m_Sections;
 126 };
 127
 128 }
 129
 130 static osl_TFile*           openFileImpl(rtl_uString * strFileName, oslProfileOption ProfileFlags  );
 131 static osl_TStamp           closeFileImpl(osl_TFile* pFile);
 132 static bool                 lockFile(const osl_TFile* pFile, osl_TLockMode eMode);
 133 static bool                 rewindFile(osl_TFile* pFile, bool bTruncate);
 134 static osl_TStamp           getFileStamp(osl_TFile* pFile);
 135
 136 static bool                 getLine(osl_TFile* pFile, char *pszLine, int MaxLen);
 137 static bool                 putLine(osl_TFile* pFile, const char *pszLine);
 138 static const char*          stripBlanks(const char* String, sal_uInt32* pLen);
 139 static const char*          addLine(osl_TProfileImpl* pProfile, const char* Line);
 140 static const char*          insertLine(osl_TProfileImpl* pProfile, const char* Line, sal_uInt32 LineNo);
 141 static void                 removeLine(osl_TProfileImpl* pProfile, sal_uInt32 LineNo);
 142 static void                 setEntry(osl_TProfileImpl* pProfile, osl_TProfileSection* pSection,
 143                                      sal_uInt32 NoEntry, sal_uInt32 Line,
 144                                      const char* Entry, sal_uInt32 Len);
 145 static bool                 addEntry(osl_TProfileImpl* pProfile, osl_TProfileSection *pSection,
 146                                      int Line, const char* Entry, sal_uInt32 Len);
 147 static void                 removeEntry(osl_TProfileSection *pSection, sal_uInt32 NoEntry);
 148 static bool                 addSection(osl_TProfileImpl* pProfile, int Line, const char* Section, sal_uInt32 Len);
 149 static void                 removeSection(osl_TProfileImpl* pProfile, osl_TProfileSection *pSection);
 150 static osl_TProfileSection* findEntry(osl_TProfileImpl* pProfile, const char* Section,
 151                                       const char* Entry, sal_uInt32 *pNoEntry);
 152 static bool                 loadProfile(osl_TFile* pFile, osl_TProfileImpl* pProfile);
 153 static bool                 storeProfile(osl_TProfileImpl* pProfile, bool bCleanup);
 154 static osl_TProfileImpl*    acquireProfile(oslProfile Profile, bool bWriteable);
 155 static bool                 releaseProfile(osl_TProfileImpl* pProfile);
 156 static bool                 lookupProfile(const sal_Unicode *strPath, const sal_Unicode *strFile, sal_Unicode *strProfile);
 157
 158 static bool writeProfileImpl (osl_TFile* pFile);
 159 static osl_TFile* osl_openTmpProfileImpl(osl_TProfileImpl*);
 160 static bool osl_ProfileSwapProfileNames(osl_TProfileImpl*);
 161 static rtl_uString* osl_ProfileGenerateExtension(rtl_uString* ustrFileName, rtl_uString* ustrExtension);
 162
 163 static bool osl_getProfileName(rtl_uString* strPath, rtl_uString* strName, rtl_uString** strProfileName);
 164
 165 oslProfile SAL_CALL osl_openProfile(rtl_uString *strProfileName, oslProfileOption Flags)
 166 {
 167     osl_TFile*        pFile = nullptr;
 168     osl_TProfileImpl* pProfile;
 169     rtl_uString       *FileName=nullptr;
 170
 171     OSL_VERIFY(strProfileName);
 172
 173     if (rtl_uString_getLength(strProfileName) == 0 )
 174     {
 175         OSL_VERIFY(osl_getProfileName(nullptr, nullptr, &FileName));
 176     }
 177     else
 178     {
 179         rtl_uString_assign(&FileName, strProfileName);
 180     }
 181
 182     osl_getSystemPathFromFileURL(FileName, &FileName);
 183
 184 #ifdef DEBUG_OSL_PROFILE
 185     Flags=osl_Profile_FLUSHWRITE;
 186
 187     if ( Flags == osl_Profile_DEFAULT )
 188     {
 189         SAL_INFO("sal.osl", "with osl_Profile_DEFAULT");
 190     }
 191     if ( Flags & osl_Profile_SYSTEM )
 192     {
 193         SAL_INFO("sal.osl", "with osl_Profile_SYSTEM");
 194     }
 195     if ( Flags & osl_Profile_READLOCK )
 196     {
 197         SAL_INFO("sal.osl", "with osl_Profile_READLOCK");
 198     }
 199     if ( Flags & osl_Profile_WRITELOCK )
 200     {
 201         SAL_INFO("sal.osl", "with osl_Profile_WRITELOCK");
 202     }
 203     if ( Flags & osl_Profile_FLUSHWRITE )
 204     {
 205         SAL_INFO("sal.osl", "with osl_Profile_FLUSHWRITE");
 206     }
 207 #endif
 208
 209     if ( (! (Flags & osl_Profile_SYSTEM)) && ( (pFile = openFileImpl(FileName, Flags) ) == nullptr ) )
 210     {
 211         if( FileName)
 212             rtl_uString_release( FileName);
 213
 214         return nullptr;
 215     }
 216
 217     pProfile = static_cast<osl_TProfileImpl*>(calloc(1, sizeof(osl_TProfileImpl)));
 218     if (!pProfile)
 219         return nullptr;
 220
 221     pProfile->m_Flags = Flags & FLG_USER;
 222     osl_getSystemPathFromFileURL(strProfileName, &pProfile->m_strFileName);
 223
 224     if (Flags & (osl_Profile_READLOCK | osl_Profile_WRITELOCK | osl_Profile_FLUSHWRITE ))
 225         pProfile->m_pFile = pFile;
 226
 227     pProfile->m_Stamp = getFileStamp(pFile);
 228
 229     loadProfile(pFile, pProfile);
 230
 231     if (pProfile->m_pFile == nullptr)
 232         closeFileImpl(pFile);
 233
 234     if( FileName)
 235         rtl_uString_release( FileName);
 236
 237     return pProfile;
 238 }
 239
 240 sal_Bool SAL_CALL osl_closeProfile(oslProfile Profile)
 241 {
 242     osl_TProfileImpl* pProfile = static_cast<osl_TProfileImpl*>(Profile);
 243
 244
 245     if ( Profile == nullptr )
 246     {
 247         return false;
 248     }
 249
 250     if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
 251     {
 252         pProfile = acquireProfile(Profile,true);
 253
 254         if ( pProfile != nullptr )
 255         {
 256             if ( !( pProfile->m_Flags & osl_Profile_READLOCK )  && ( pProfile->m_Flags & FLG_MODIFIED ) )
 257             {
 258                 storeProfile(pProfile, false);
 259             }
 260         }
 261         else
 262         {
 263             pProfile = acquireProfile(Profile,false);
 264         }
 265
 266         if ( pProfile == nullptr )
 267         {
 268             return false;
 269         }
 270
 271         if (pProfile->m_pFile != nullptr)
 272             closeFileImpl(pProfile->m_pFile);
 273     }
 274
 275     pProfile->m_pFile = nullptr;
 276     rtl_uString_release(pProfile->m_strFileName);
 277     pProfile->m_strFileName = nullptr;
 278
 279     /* release whole profile data types memory */
 280     if ( pProfile->m_NoLines > 0)
 281     {
 282         unsigned int index=0;
 283         if ( pProfile->m_Lines != nullptr )
 284         {
 285             for ( index = 0 ; index < pProfile->m_NoLines ; ++index)
 286             {
 287                 if ( pProfile->m_Lines[index] != nullptr )
 288                 {
 289                     free(pProfile->m_Lines[index]);
 290                 }
 291             }
 292             free(pProfile->m_Lines);
 293         }
 294         if ( pProfile->m_Sections != nullptr )
 295         {
 296             for ( index = 0 ; index < pProfile->m_NoSections ; ++index )
 297             {
 298                 if ( pProfile->m_Sections[index].m_Entries != nullptr )
 299                     free(pProfile->m_Sections[index].m_Entries);
 300             }
 301             free(pProfile->m_Sections);
 302         }
 303
 304     }
 305     free(pProfile);
 306
 307     return true;
 308 }
 309
 310 sal_Bool SAL_CALL osl_flushProfile(oslProfile Profile)
 311 {
 312     osl_TProfileImpl* pProfile = static_cast<osl_TProfileImpl*>(Profile);
 313     osl_TFile* pFile;
 314     bool bRet = false;
 315
 316
 317     if ( pProfile == nullptr )
 318     {
 319         return false;
 320     }
 321
 322     pFile = pProfile->m_pFile;
 323     if ( pFile == nullptr || pFile->m_Handle == INVALID_HANDLE_VALUE )
 324     {
 325         return false;
 326     }
 327
 328     if ( pProfile->m_Flags & FLG_MODIFIED )
 329     {
 330 #ifdef DEBUG_OSL_PROFILE
 331         SAL_INFO("sal.osl", "swapping to storeprofile");
 332 #endif
 333         bRet = storeProfile(pProfile,false);
 334     }
 335
 336     return bRet;
 337 }
 338
 339 static bool writeProfileImpl(osl_TFile* pFile)
 340 {
 341     DWORD BytesWritten=0;
 342     bool bRet;
 343
 344     if ( pFile == nullptr || pFile->m_Handle == INVALID_HANDLE_VALUE || ( pFile->m_pWriteBuf == nullptr ) )
 345     {
 346         return false;
 347     }
 348
 349     bRet=WriteFile(pFile->m_Handle, pFile->m_pWriteBuf, pFile->m_nWriteBufLen - pFile->m_nWriteBufFree,&BytesWritten,nullptr);
 350
 351     if ( !bRet || BytesWritten == 0 )
 352     {
 353         OSL_ENSURE(bRet,"WriteFile failed!!!");
 354         SAL_WARN("sal.osl", "write failed " << strerror(errno));
 355
 356         return false;
 357     }
 358
 359     free(pFile->m_pWriteBuf);
 360     pFile->m_pWriteBuf=nullptr;
 361     pFile->m_nWriteBufLen=0;
 362     pFile->m_nWriteBufFree=0;
 363
 364     return true;
 365 }
 366
 367 namespace {
 368 // Use Unicode version of GetPrivateProfileString, to work with Multi-language paths
 369 DWORD GetPrivateProfileStringWrapper(const osl_TProfileImpl* pProfile,
 370     const char* pszSection, const char* pszEntry,
 371     char* pszString, sal_uInt32 MaxLen,
 372     const char* pszDefault)
 373 {
 374     OSL_ASSERT(pProfile && (!MaxLen || pszString));
 375
 376     rtl_uString *pSection = nullptr, *pEntry = nullptr, *pDefault = nullptr;
 377     if (pszSection)
 378     {
 379         rtl_string2UString(&pSection, pszSection, strlen(pszSection), osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS);
 380         OSL_ASSERT(pSection);
 381     }
 382     if (pszEntry)
 383     {
 384         rtl_string2UString(&pEntry, pszEntry, strlen(pszEntry), osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS);
 385         OSL_ASSERT(pEntry);
 386     }
 387     if (pszDefault)
 388     {
 389         rtl_string2UString(&pDefault, pszDefault, strlen(pszDefault), osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS);
 390         OSL_ASSERT(pDefault);
 391     }
 392
 393     LPCWSTR pWSection = (pSection ? o3tl::toW(rtl_uString_getStr(pSection)) : nullptr),
 394             pWEntry   = (pEntry   ? o3tl::toW(rtl_uString_getStr(pEntry))   : nullptr),
 395             pWDefault = (pDefault ? o3tl::toW(rtl_uString_getStr(pDefault)) : nullptr);
 396
 397     std::vector<wchar_t> aBuf(MaxLen + 1);
 398     GetPrivateProfileStringW(pWSection, pWEntry, pWDefault, aBuf.data(), MaxLen, o3tl::toW(rtl_uString_getStr(pProfile->m_strFileName)));
 399
 400     if (pDefault)
 401         rtl_uString_release(pDefault);
 402     if (pEntry)
 403         rtl_uString_release(pEntry);
 404     if (pSection)
 405         rtl_uString_release(pSection);
 406
 407     return WideCharToMultiByte(CP_ACP, 0, aBuf.data(), -1, pszString, MaxLen, nullptr, nullptr);
 408 }
 409
 410 // Use Unicode version of WritePrivateProfileString, to work with Multi-language paths
 411 bool WritePrivateProfileStringWrapper(const osl_TProfileImpl* pProfile,
 412     const char* pszSection, const char* pszEntry,
 413     const char* pszString)
 414 {
 415     OSL_ASSERT(pProfile && pszSection);
 416     rtl_uString *pSection, *pEntry = nullptr, *pString = nullptr;
 417     rtl_string2UString(&pSection, pszSection, strlen(pszSection), osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS);
 418     OSL_ASSERT(pSection);
 419     if (pszEntry)
 420     {
 421         rtl_string2UString(&pEntry, pszEntry, strlen(pszEntry), osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS);
 422         OSL_ASSERT(pEntry);
 423     }
 424     if (pszString)
 425     {
 426         rtl_string2UString(&pString, pszString, strlen(pszString), osl_getThreadTextEncoding(), OSTRING_TO_OUSTRING_CVTFLAGS);
 427         OSL_ASSERT(pString);
 428     }
 429
 430     LPCWSTR pWSection = o3tl::toW(pSection->buffer),
 431             pWEntry   = (pEntry   ? o3tl::toW(rtl_uString_getStr(pEntry))   : nullptr),
 432             pWString  = (pString  ? o3tl::toW(rtl_uString_getStr(pString))  : nullptr);
 433
 434     bool bResult = WritePrivateProfileStringW(pWSection, pWEntry, pWString, o3tl::toW(rtl_uString_getStr(pProfile->m_strFileName)));
 435
 436     if (pString)
 437         rtl_uString_release(pString);
 438     if (pEntry)
 439         rtl_uString_release(pEntry);
 440     rtl_uString_release(pSection);
 441
 442     return bResult;
 443 }
 444 }
 445
 446 sal_Bool SAL_CALL osl_readProfileString(oslProfile Profile,
 447                               const char* pszSection, const char* pszEntry,
 448                               char* pszString, sal_uInt32 MaxLen,
 449                               const char* pszDefault)
 450 {
 451     sal_uInt32    NoEntry;
 452     const char* pStr = nullptr;
 453     osl_TProfileImpl*    pProfile = nullptr;
 454
 455     pProfile = acquireProfile(Profile, false);
 456
 457     if (pProfile == nullptr)
 458     {
 459         return false;
 460     }
 461
 462     if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
 463     {
 464         osl_TProfileSection* pSec;
 465         if (((pSec = findEntry(pProfile, pszSection, pszEntry, &NoEntry)) != nullptr) &&
 466             (NoEntry < pSec->m_NoEntries) &&
 467             ((pStr = strchr(pProfile->m_Lines[pSec->m_Entries[NoEntry].m_Line],
 468                             '=')) != nullptr))
 469             pStr++;
 470         else
 471             pStr = pszDefault;
 472
 473         if ( pStr != nullptr )
 474         {
 475             pStr = stripBlanks(pStr, nullptr);
 476             MaxLen = (MaxLen - 1 < strlen(pStr)) ? (MaxLen - 1) : strlen(pStr);
 477             pStr = stripBlanks(pStr, &MaxLen);
 478             strncpy(pszString, pStr, MaxLen);
 479             pszString[MaxLen] = '\0';
 480         }
 481     }
 482     else
 483     {
 484         if (GetPrivateProfileStringWrapper(pProfile, pszSection, pszEntry, pszString, MaxLen, pszDefault) > 0)
 485             pStr = pszString; // required to return true below
 486     }
 487
 488     releaseProfile(pProfile);
 489
 490     if ( pStr == nullptr )
 491     {
 492         return false;
 493     }
 494
 495     return true;
 496 }
 497
 498 sal_Bool SAL_CALL osl_readProfileBool(oslProfile Profile,
 499                             const char* pszSection, const char* pszEntry,
 500                             sal_Bool Default)
 501 {
 502     char Line[32];
 503
 504     if (osl_readProfileString(Profile, pszSection, pszEntry, Line, sizeof(Line), ""))
 505     {
 506         if ((stricmp(Line, STR_INI_BOOLYES) == 0) ||
 507             (stricmp(Line, STR_INI_BOOLON)  == 0) ||
 508             (stricmp(Line, STR_INI_BOOLONE) == 0))
 509             Default = true;
 510         else
 511             if ((stricmp(Line, STR_INI_BOOLNO)   == 0) ||
 512                 (stricmp(Line, STR_INI_BOOLOFF)  == 0) ||
 513                 (stricmp(Line, STR_INI_BOOLZERO) == 0))
 514                 Default = false;
 515     }
 516
 517     return Default;
 518 }
 519
 520 sal_uInt32 SAL_CALL osl_readProfileIdent(oslProfile Profile,
 521                               const char* pszSection, const char* pszEntry,
 522                               sal_uInt32 FirstId, const char* Strings[],
 523                               sal_uInt32 Default)
 524 {
 525     sal_uInt32    i;
 526     char        Line[256];
 527
 528     if (osl_readProfileString(Profile, pszSection, pszEntry, Line, sizeof(Line), ""))
 529     {
 530         i = 0;
 531         while (Strings[i] != nullptr)
 532         {
 533             if (stricmp(Line, Strings[i]) == 0)
 534             {
 535                 Default = i + FirstId;
 536                 break;
 537             }
 538             i++;
 539         }
 540     }
 541
 542     return Default;
 543 }
 544
 545 sal_Bool SAL_CALL osl_writeProfileString(oslProfile Profile,
 546                                const char* pszSection, const char* pszEntry,
 547                                const char* pszString)
 548 {
 549     sal_uInt32    i;
 550     bool bRet = false;
 551     sal_uInt32    NoEntry;
 552     const char* pStr;
 553     char        Line[4096];
 554     osl_TProfileSection* pSec;
 555     osl_TProfileImpl*    pProfile = nullptr;
 556
 557     pProfile = acquireProfile(Profile, true);
 558
 559     if (pProfile == nullptr)
 560     {
 561         return false;
 562     }
 563
 564     if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
 565     {
 566         if ((pSec = findEntry(pProfile, pszSection, pszEntry, &NoEntry)) == nullptr)
 567         {
 568             Line[0] = '\0';
 569             addLine(pProfile, Line);
 570
 571             Line[0] = '[';
 572             strcpy(&Line[1], pszSection);
 573             Line[1 + strlen(pszSection)] = ']';
 574             Line[2 + strlen(pszSection)] = '\0';
 575
 576             if (((pStr = addLine(pProfile, Line)) == nullptr) ||
 577                 (! addSection(pProfile, pProfile->m_NoLines - 1, &pStr[1], strlen(pszSection))))
 578             {
 579                 releaseProfile(pProfile);
 580                 return false;
 581             }
 582
 583             pSec = &pProfile->m_Sections[pProfile->m_NoSections - 1];
 584             NoEntry = pSec->m_NoEntries;
 585         }
 586
 587         Line[0] = '\0';
 588         strcpy(&Line[0], pszEntry);
 589         Line[0 + strlen(pszEntry)] = '=';
 590         strcpy(&Line[1 + strlen(pszEntry)], pszString);
 591
 592         if (NoEntry >= pSec->m_NoEntries)
 593         {
 594             if (pSec->m_NoEntries > 0)
 595                 i = pSec->m_Entries[pSec->m_NoEntries - 1].m_Line + 1;
 596             else
 597                 i = pSec->m_Line + 1;
 598
 599             if (((pStr = insertLine(pProfile, Line, i)) == nullptr) ||
 600                 (! addEntry(pProfile, pSec, i, pStr, strlen(pszEntry))))
 601             {
 602                 releaseProfile(pProfile);
 603                 return false;
 604             }
 605
 606             pProfile->m_Flags |= FLG_MODIFIED;
 607         }
 608         else
 609         {
 610             i = pSec->m_Entries[NoEntry].m_Line;
 611             free(pProfile->m_Lines[i]);
 612             pProfile->m_Lines[i] = strdup(Line);
 613             setEntry(pProfile, pSec, NoEntry, i, pProfile->m_Lines[i], strlen(pszEntry));
 614
 615             pProfile->m_Flags |= FLG_MODIFIED;
 616         }
 617     }
 618     else
 619     {
 620         WritePrivateProfileStringWrapper(pProfile, pszSection, pszEntry, pszString);
 621     }
 622
 623     bRet = releaseProfile(pProfile);
 624     return bRet;
 625 }
 626
 627 sal_Bool SAL_CALL osl_writeProfileBool(oslProfile Profile,
 628                              const char* pszSection, const char* pszEntry,
 629                              sal_Bool Value)
 630 {
 631     bool bRet = false;
 632
 633     if (Value)
 634         bRet=osl_writeProfileString(Profile, pszSection, pszEntry, STR_INI_BOOLONE);
 635     else
 636         bRet=osl_writeProfileString(Profile, pszSection, pszEntry, STR_INI_BOOLZERO);
 637
 638     return bRet;
 639 }
 640
 641 sal_Bool SAL_CALL osl_writeProfileIdent(oslProfile Profile,
 642                               const char* pszSection, const char* pszEntry,
 643                               sal_uInt32 FirstId, const char* Strings[],
 644                               sal_uInt32 Value)
 645 {
 646     int i, n;
 647     bool bRet = false;
 648
 649     for (n = 0; Strings[n] != nullptr; n++);
 650
 651     if ((i = Value - FirstId) >= n)
 652         bRet=false;
 653     else
 654         bRet=osl_writeProfileString(Profile, pszSection, pszEntry, Strings[i]);
 655
 656     return bRet;
 657 }
 658
 659 sal_Bool SAL_CALL osl_removeProfileEntry(oslProfile Profile,
 660                                const char *pszSection, const char *pszEntry)
 661 {
 662     sal_uInt32    NoEntry;
 663     osl_TProfileImpl*    pProfile = nullptr;
 664     bool bRet = false;
 665
 666     pProfile = acquireProfile(Profile, true);
 667
 668     if (pProfile == nullptr)
 669         return false;
 670
 671     if (!(pProfile->m_Flags & osl_Profile_SYSTEM))
 672     {
 673         osl_TProfileSection* pSec;
 674         if (((pSec = findEntry(pProfile, pszSection, pszEntry, &NoEntry)) != nullptr) &&
 675             (NoEntry < pSec->m_NoEntries))
 676         {
 677             removeLine(pProfile, pSec->m_Entries[NoEntry].m_Line);
 678             removeEntry(pSec, NoEntry);
 679             if (pSec->m_NoEntries == 0)
 680             {
 681                 removeLine(pProfile, pSec->m_Line);
 682
 683                 /* remove any empty separation line */
 684                 if ((pSec->m_Line > 0) && (pProfile->m_Lines[pSec->m_Line - 1][0] == '\0'))
 685                     removeLine(pProfile, pSec->m_Line - 1);
 686
 687                 removeSection(pProfile, pSec);
 688             }
 689
 690             pProfile->m_Flags |= FLG_MODIFIED;
 691         }
 692     }
 693     else
 694     {
 695         WritePrivateProfileStringWrapper(pProfile, pszSection, pszEntry, nullptr);
 696     }
 697
 698     bRet = releaseProfile(pProfile);
 699     return bRet;
 700 }
 701
 702 sal_uInt32 SAL_CALL osl_getProfileSectionEntries(oslProfile Profile, const char *pszSection,
 703                                        char* pszBuffer, sal_uInt32 MaxLen)
 704 {
 705     sal_uInt32 i, n = 0;
 706     sal_uInt32 NoEntry;
 707     osl_TProfileImpl* pProfile = nullptr;
 708
 709     pProfile = acquireProfile(Profile, false);
 710
 711     if (pProfile == nullptr)
 712         return 0;
 713
 714     if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
 715     {
 716         osl_TProfileSection* pSec;
 717         if ((pSec = findEntry(pProfile, pszSection, "", &NoEntry)) != nullptr)
 718         {
 719             if (MaxLen != 0)
 720             {
 721                 for (i = 0; i < pSec->m_NoEntries; i++)
 722                 {
 723                     if ((n + pSec->m_Entries[i].m_Len + 1) < MaxLen)
 724                     {
 725                         strncpy(&pszBuffer[n], &pProfile->m_Lines[pSec->m_Entries[i].m_Line]
 726                                 [pSec->m_Entries[i].m_Offset], pSec->m_Entries[i].m_Len);
 727                         n += pSec->m_Entries[i].m_Len;
 728                         pszBuffer[n++] = '\0';
 729                     }
 730                     else
 731                     {
 732                         break;
 733                     }
 734
 735                 }
 736
 737                 pszBuffer[n++] = '\0';
 738             }
 739             else
 740             {
 741                 for (i = 0; i < pSec->m_NoEntries; i++)
 742                 {
 743                     n += pSec->m_Entries[i].m_Len + 1;
 744                 }
 745
 746                 n += 1;
 747             }
 748         }
 749         else
 750         {
 751             n = 0;
 752         }
 753     }
 754     else
 755     {
 756         n = GetPrivateProfileStringWrapper(pProfile, pszSection, nullptr, pszBuffer, MaxLen, nullptr);
 757     }
 758
 759     releaseProfile(pProfile);
 760
 761     return n;
 762 }
 763
 764 bool osl_getProfileName(rtl_uString* strPath, rtl_uString* strName, rtl_uString** strProfileName)
 765 {
 766     bool bFailed;
 767     ::osl::LongPathBuffer< sal_Unicode > aFile( MAX_LONG_PATH );
 768     ::osl::LongPathBuffer< sal_Unicode > aPath( MAX_LONG_PATH );
 769     sal_uInt32  nFileLen = 0;
 770     sal_uInt32  nPathLen = 0;
 771
 772     rtl_uString * strTmp = nullptr;
 773     oslFileError nError;
 774
 775     /* build file name */
 776     if (strName && strName->length)
 777     {
 778         if( ::sal::static_int_cast< sal_uInt32 >( strName->length ) >= aFile.getBufSizeInSymbols() )
 779             return false;
 780
 781         copy_ustr_n( aFile, strName->buffer, strName->length+1);
 782         nFileLen = strName->length;
 783
 784         if (rtl_ustr_indexOfChar( aFile, L'.' ) == -1)
 785         {
 786             if (nFileLen + wcslen(STR_INI_EXTENSION) >= aFile.getBufSizeInSymbols())
 787                 return false;
 788
 789             /* add default extension */
 790             copy_ustr_n( aFile + nFileLen, STR_INI_EXTENSION, wcslen(STR_INI_EXTENSION)+1 );
 791             nFileLen += wcslen(STR_INI_EXTENSION);
 792         }
 793     }
 794     else
 795     {
 796         rtl_uString *strProgName = nullptr;
 797         sal_Unicode *pProgName;
 798         sal_Int32 nOffset = 0;
 799         sal_Int32 nLen;
 800         sal_Int32 nPos;
 801
 802         if (osl_getExecutableFile(&strProgName) != osl_Process_E_None)
 803             return false;
 804
 805         /* remove path and extension from filename */
 806         pProgName = strProgName->buffer;
 807         nLen = strProgName->length ;
 808
 809         if ((nPos = rtl_ustr_lastIndexOfChar( pProgName, L'/' )) != -1)
 810             nOffset = nPos + 1;
 811         else if ((nPos = rtl_ustr_lastIndexOfChar( pProgName, L':' )) != -1)
 812             nOffset = nPos + 1;
 813
 814         if ((nPos = rtl_ustr_lastIndexOfChar( pProgName, L'.' )) != -1 )
 815             nLen -= 4;
 816
 817         if ((nFileLen = nLen - nOffset) >= aFile.getBufSizeInSymbols())
 818             return false;
 819
 820         copy_ustr_n(aFile, pProgName + nOffset, nFileLen);
 821
 822         if (nFileLen + wcslen(STR_INI_EXTENSION) >= aFile.getBufSizeInSymbols())
 823             return false;
 824
 825         /* add default extension */
 826         copy_ustr_n(aFile + nFileLen, STR_INI_EXTENSION, wcslen(STR_INI_EXTENSION)+1);
 827         nFileLen += wcslen(STR_INI_EXTENSION);
 828
 829         rtl_uString_release( strProgName );
 830     }
 831
 832     if (aFile[0] == 0)
 833         return false;
 834
 835     /* build directory path */
 836     if (strPath && strPath->length)
 837     {
 838         sal_Unicode *pPath = rtl_uString_getStr(strPath);
 839         sal_Int32 nLen = rtl_uString_getLength(strPath);
 840
 841         if ((rtl_ustr_ascii_compare_WithLength(pPath, RTL_CONSTASCII_LENGTH(STR_INI_METAHOME) , STR_INI_METAHOME) == 0) &&
 842             ((nLen == RTL_CONSTASCII_LENGTH(STR_INI_METAHOME)) || (pPath[RTL_CONSTASCII_LENGTH(STR_INI_METAHOME)] == '/')))
 843         {
 844             rtl_uString * strHome = nullptr;
 845             oslSecurity security = osl_getCurrentSecurity();
 846
 847             bFailed = ! osl_getHomeDir(security, &strHome);
 848             osl_freeSecurityHandle(security);
 849
 850             if (bFailed) return false;
 851
 852             if ( ::sal::static_int_cast< sal_uInt32 >( strHome->length ) >= aPath.getBufSizeInSymbols())
 853                 return false;
 854
 855             copy_ustr_n( aPath, strHome->buffer, strHome->length+1);
 856             nPathLen = strHome->length;
 857
 858             if (nLen > RTL_CONSTASCII_LENGTH(STR_INI_METAHOME))
 859             {
 860                 pPath += RTL_CONSTASCII_LENGTH(STR_INI_METAHOME);
 861                 nLen -= RTL_CONSTASCII_LENGTH(STR_INI_METAHOME);
 862
 863                 if (nLen + nPathLen >= aPath.getBufSizeInSymbols())
 864                     return false;
 865
 866                 copy_ustr_n(aPath + nPathLen, pPath, nLen+1);
 867                 nPathLen += nLen;
 868             }
 869
 870             rtl_uString_release(strHome);
 871         }
 872
 873         else if ((rtl_ustr_ascii_compare_WithLength(pPath, RTL_CONSTASCII_LENGTH(STR_INI_METACFG), STR_INI_METACFG) == 0) &&
 874             ((nLen == RTL_CONSTASCII_LENGTH(STR_INI_METACFG)) || (pPath[RTL_CONSTASCII_LENGTH(STR_INI_METACFG)] == '/')))
 875         {
 876             rtl_uString * strConfig = nullptr;
 877             oslSecurity security = osl_getCurrentSecurity();
 878
 879             bFailed = ! osl_getConfigDir(security, &strConfig);
 880             osl_freeSecurityHandle(security);
 881
 882             if (bFailed) return false;
 883
 884             if ( ::sal::static_int_cast< sal_uInt32 >( strConfig->length ) >= aPath.getBufSizeInSymbols())
 885                 return false;
 886
 887             copy_ustr_n( aPath, strConfig->buffer, strConfig->length+1 );
 888             nPathLen = strConfig->length;
 889
 890             if (nLen > RTL_CONSTASCII_LENGTH(STR_INI_METACFG))
 891             {
 892                 pPath += RTL_CONSTASCII_LENGTH(STR_INI_METACFG);
 893                 nLen -= RTL_CONSTASCII_LENGTH(STR_INI_METACFG);
 894
 895                 if (nLen + nPathLen >= aPath.getBufSizeInSymbols())
 896                     return false;
 897
 898                 copy_ustr_n(aPath + nPathLen, pPath, nLen+1);
 899                 nPathLen += nLen;
 900             }
 901
 902             rtl_uString_release(strConfig);
 903         }
 904
 905         else if ((rtl_ustr_ascii_compare_WithLength(pPath, RTL_CONSTASCII_LENGTH(STR_INI_METASYS), STR_INI_METASYS) == 0) &&
 906             ((nLen == RTL_CONSTASCII_LENGTH(STR_INI_METASYS)) || (pPath[RTL_CONSTASCII_LENGTH(STR_INI_METASYS)] == '/')))
 907         {
 908             if (((nPathLen = GetWindowsDirectoryW(o3tl::toW(aPath), aPath.getBufSizeInSymbols())) == 0) || (nPathLen >= aPath.getBufSizeInSymbols()))
 909                 return false;
 910
 911             if (nLen > RTL_CONSTASCII_LENGTH(STR_INI_METASYS))
 912             {
 913                 pPath += RTL_CONSTASCII_LENGTH(STR_INI_METASYS);
 914                 nLen -= RTL_CONSTASCII_LENGTH(STR_INI_METASYS);
 915
 916                 if (nLen + nPathLen >= aPath.getBufSizeInSymbols())
 917                     return false;
 918
 919                 copy_ustr_n(aPath + nPathLen, pPath, nLen+1);
 920                 nPathLen += nLen;
 921             }
 922         }
 923
 924         else if ((rtl_ustr_ascii_compare_WithLength(pPath, RTL_CONSTASCII_LENGTH(STR_INI_METAINS), STR_INI_METAINS) == 0) &&
 925             ((nLen == RTL_CONSTASCII_LENGTH(STR_INI_METAINS)) || (pPath[RTL_CONSTASCII_LENGTH(STR_INI_METAINS)] == '/') ||
 926                 (pPath[RTL_CONSTASCII_LENGTH(STR_INI_METAINS)] == '"') ) )
 927         {
 928             if (! lookupProfile(pPath + RTL_CONSTASCII_LENGTH(STR_INI_METAINS), aFile, aPath))
 929                 return false;
 930
 931             nPathLen = rtl_ustr_getLength(aPath);
 932         }
 933
 934         else if( ::sal::static_int_cast< sal_uInt32 >( nLen ) < aPath.getBufSizeInSymbols())
 935         {
 936             copy_ustr_n(aPath, pPath, nLen+1);
 937             nPathLen = rtl_ustr_getLength(aPath);
 938         }
 939         else
 940             return false;
 941     }
 942     else
 943     {
 944         rtl_uString * strConfigDir = nullptr;
 945         oslSecurity security = osl_getCurrentSecurity();
 946
 947         bFailed = ! osl_getConfigDir(security, &strConfigDir);
 948         osl_freeSecurityHandle(security);
 949
 950         if (bFailed) return false;
 951         if ( ::sal::static_int_cast< sal_uInt32 >( strConfigDir->length ) >= aPath.getBufSizeInSymbols() )
 952             return false;
 953
 954         copy_ustr_n(aPath, strConfigDir->buffer, strConfigDir->length+1);
 955         nPathLen = strConfigDir->length;
 956     }
 957
 958     if (nPathLen && (aPath[nPathLen - 1] != L'/') && (aPath[nPathLen - 1] != L'\\'))
 959     {
 960         aPath[nPathLen++] = L'\\';
 961         aPath[nPathLen] = 0;
 962     }
 963
 964     if (nPathLen + nFileLen >= aPath.getBufSizeInSymbols())
 965         return false;
 966
 967     /* append file name */
 968     copy_ustr_n(aPath + nPathLen, aFile, nFileLen+1);
 969     nPathLen += nFileLen;
 970
 971     /* copy filename */
 972     rtl_uString_newFromStr_WithLength(&strTmp, aPath, nPathLen);
 973     nError = osl_getFileURLFromSystemPath(strTmp, strProfileName);
 974     rtl_uString_release(strTmp);
 975
 976     return nError == osl_File_E_None;
 977 }
 978
 979 sal_uInt32 SAL_CALL osl_getProfileSections(oslProfile Profile, char* pszBuffer, sal_uInt32 MaxLen)
 980 {
 981     sal_uInt32    i, n = 0;
 982     osl_TProfileImpl*    pProfile = acquireProfile(Profile, false);
 983
 984     if (pProfile == nullptr)
 985         return 0;
 986
 987     if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
 988     {
 989         if (MaxLen != 0)
 990         {
 991             for (i = 0; i < pProfile->m_NoSections; i++)
 992             {
 993                 osl_TProfileSection* pSec = &pProfile->m_Sections[i];
 994
 995                 if ((n + pSec->m_Len + 1) < MaxLen)
 996                 {
 997                     strncpy(&pszBuffer[n], &pProfile->m_Lines[pSec->m_Line][pSec->m_Offset],
 998                             pSec->m_Len);
 999                     n += pSec->m_Len;
1000                     pszBuffer[n++] = '\0';
1001                 }
1002                 else
1003                     break;
1004             }
1005
1006             pszBuffer[n++] = '\0';
1007         }
1008         else
1009         {
1010             for (i = 0; i < pProfile->m_NoSections; i++)
1011                 n += pProfile->m_Sections[i].m_Len + 1;
1012
1013             n += 1;
1014         }
1015     }
1016     else
1017     {
1018         std::vector<wchar_t> aBuf(MaxLen + 1);
1019         GetPrivateProfileSectionNamesW(aBuf.data(), MaxLen, o3tl::toW(rtl_uString_getStr(pProfile->m_strFileName)));
1020
1021         n = WideCharToMultiByte(CP_ACP, 0, aBuf.data(), -1, pszBuffer, MaxLen, nullptr, nullptr);
1022     }
1023
1024     releaseProfile(pProfile);
1025
1026     return n;
1027 }
1028
1029 static osl_TStamp getFileStamp(osl_TFile* pFile)
1030 {
1031     FILETIME FileTime;
1032
1033     if ((pFile->m_Handle == INVALID_HANDLE_VALUE) ||
1034         (! GetFileTime(pFile->m_Handle, nullptr, nullptr, &FileTime)))
1035         memset(&FileTime, 0, sizeof(FileTime));
1036
1037     return FileTime;
1038 }
1039
1040 static bool lockFile(const osl_TFile* pFile, osl_TLockMode eMode)
1041 {
1042     bool     status = false;
1043     OVERLAPPED  Overlapped = {};
1044
1045     if (pFile->m_Handle == INVALID_HANDLE_VALUE)
1046         return false;
1047
1048     switch (eMode)
1049     {
1050         case un_lock:
1051             status = UnlockFileEx(
1052                 pFile->m_Handle, 0, 0xFFFFFFFF, 0, &Overlapped);
1053             break;
1054
1055         case read_lock:
1056             status = LockFileEx(
1057                 pFile->m_Handle, 0, 0, 0xFFFFFFFF, 0, &Overlapped);
1058             break;
1059
1060         case write_lock:
1061             status = LockFileEx(
1062                 pFile->m_Handle, LOCKFILE_EXCLUSIVE_LOCK, 0, 0xFFFFFFFF, 0,
1063                 &Overlapped);
1064             break;
1065     }
1066
1067     return status;
1068 }
1069
1070 static osl_TFile* openFileImpl(rtl_uString * strFileName, oslProfileOption ProfileFlags )
1071 {
1072     osl_TFile* pFile = static_cast< osl_TFile*>( calloc( 1, sizeof(osl_TFile) ) );
1073     if (!pFile)
1074         return nullptr;
1075     bool bWriteable = false;
1076
1077     if ( ProfileFlags & ( osl_Profile_WRITELOCK | osl_Profile_FLUSHWRITE ) )
1078     {
1079 #ifdef DEBUG_OSL_PROFILE
1080         SAL_INFO("sal.osl", "setting bWriteable to TRUE");
1081 #endif
1082         bWriteable=true;
1083     }
1084
1085     if (! bWriteable)
1086     {
1087         pFile->m_Handle = CreateFileW( o3tl::toW(rtl_uString_getStr( strFileName )), GENERIC_READ,
1088                                           FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
1089                                           OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
1090
1091         /* mfe: argghh!!! do not check if the file could be opened */
1092         /*      default mode expects it that way!!!                */
1093     }
1094     else
1095     {
1096 #ifdef DEBUG_OSL_PROFILE
1097         SAL_INFO("sal.osl", "opening read/write " << pszFilename);
1098 #endif
1099
1100         if ((pFile->m_Handle = CreateFileW( o3tl::toW(rtl_uString_getStr( strFileName )), GENERIC_READ | GENERIC_WRITE,
1101                                                FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
1102                                                OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr))
1103             == INVALID_HANDLE_VALUE)
1104         {
1105             free(pFile);
1106             return nullptr;
1107         }
1108     }
1109
1110     pFile->m_pWriteBuf=nullptr;
1111     pFile->m_nWriteBufFree=0;
1112     pFile->m_nWriteBufLen=0;
1113
1114     if ( ProfileFlags & (osl_Profile_WRITELOCK | osl_Profile_READLOCK ) )
1115     {
1116 #ifdef DEBUG_OSL_PROFILE
1117         SAL_INFO("sal.osl", "locking file " << pszFilename);
1118 #endif
1119
1120         lockFile(pFile, bWriteable ? write_lock : read_lock);
1121     }
1122
1123     return pFile;
1124 }
1125
1126 static osl_TStamp closeFileImpl(osl_TFile* pFile)
1127 {
1128     osl_TStamp stamp = {0, 0};
1129
1130     if ( pFile == nullptr )
1131     {
1132         return stamp;
1133     }
1134
1135     if (pFile->m_Handle != INVALID_HANDLE_VALUE)
1136     {
1137         stamp = getFileStamp(pFile);
1138
1139         lockFile(pFile, un_lock);
1140
1141         CloseHandle(pFile->m_Handle);
1142         pFile->m_Handle = INVALID_HANDLE_VALUE;
1143     }
1144
1145     if ( pFile->m_pWriteBuf != nullptr )
1146     {
1147         free(pFile->m_pWriteBuf);
1148     }
1149
1150     free(pFile);
1151
1152     return stamp;
1153 }
1154
1155 static bool rewindFile(osl_TFile* pFile, bool bTruncate)
1156 {
1157     if (pFile->m_Handle != INVALID_HANDLE_VALUE)
1158     {
1159         pFile->m_pReadPtr = pFile->m_ReadBuf + sizeof(pFile->m_ReadBuf);
1160
1161         SetFilePointer(pFile->m_Handle, 0, nullptr, FILE_BEGIN);
1162
1163         if (bTruncate)
1164             SetEndOfFile(pFile->m_Handle);
1165     }
1166
1167     return true;
1168 }
1169
1170 static bool getLine(osl_TFile* pFile, char *pszLine, int MaxLen)
1171 {
1172     DWORD Max;
1173     size_t Free;
1174     char* pChr;
1175     char* pLine = pszLine;
1176
1177     if (pFile->m_Handle == INVALID_HANDLE_VALUE)
1178         return false;
1179
1180     MaxLen -= 1;
1181
1182     do
1183     {
1184         size_t Bytes = sizeof(pFile->m_ReadBuf) - (pFile->m_pReadPtr - pFile->m_ReadBuf);
1185
1186         if (Bytes <= 1)
1187         {
1188             /* refill buffer */
1189             memcpy(pFile->m_ReadBuf, pFile->m_pReadPtr, Bytes);
1190             pFile->m_pReadPtr = pFile->m_ReadBuf;
1191
1192             Free = sizeof(pFile->m_ReadBuf) - Bytes;
1193
1194             if (! ReadFile(pFile->m_Handle, &pFile->m_ReadBuf[Bytes], Free, &Max, nullptr))
1195             {
1196                 *pLine = '\0';
1197                 return false;
1198             }
1199
1200             if (Max < Free)
1201             {
1202                 if ((Max == 0) && (pLine == pszLine))
1203                 {
1204                     *pLine = '\0';
1205                     return false;
1206                 }
1207
1208                 pFile->m_ReadBuf[Bytes + Max] = '\0';
1209             }
1210         }
1211
1212         for (pChr = pFile->m_pReadPtr;
1213              (*pChr != '\n') && (*pChr != '\r') && (*pChr != '\0') &&
1214              (pChr < (pFile->m_ReadBuf + sizeof(pFile->m_ReadBuf) - 1));
1215              pChr++);
1216
1217         Max = min(static_cast<int>(pChr - pFile->m_pReadPtr), MaxLen);
1218         memcpy(pLine, pFile->m_pReadPtr, Max);
1219         MaxLen -= Max;
1220         pLine  += Max;
1221
1222         if (pChr < (pFile->m_ReadBuf + sizeof(pFile->m_ReadBuf) - 1))
1223         {
1224             if (*pChr != '\0')
1225             {
1226                 if ((pChr[0] == '\r') && (pChr[1] == '\n'))
1227                     pChr += 2;
1228                 else
1229                     pChr += 1;
1230             }
1231
1232             if ((pChr < (pFile->m_ReadBuf + sizeof(pFile->m_ReadBuf))) &&
1233                 (*pChr == '\0'))
1234                 pChr = pFile->m_ReadBuf + sizeof(pFile->m_ReadBuf);
1235
1236             *pLine = '\0';
1237
1238             /* setting MaxLen to -1 indicates terminating read loop */
1239             MaxLen = -1;
1240         }
1241
1242         pFile->m_pReadPtr = pChr;
1243     }
1244     while (MaxLen > 0);
1245
1246     return true;
1247 }
1248
1249 static bool putLine(osl_TFile* pFile, const char *pszLine)
1250 {
1251     unsigned int Len = strlen(pszLine);
1252
1253     if ( pFile == nullptr || pFile->m_Handle == INVALID_HANDLE_VALUE )
1254     {
1255         return false;
1256     }
1257
1258     if ( pFile->m_pWriteBuf == nullptr )
1259     {
1260         pFile->m_pWriteBuf = static_cast<char*>(malloc(Len+3));
1261         pFile->m_nWriteBufLen = Len+3;
1262         pFile->m_nWriteBufFree = Len+3;
1263     }
1264     else
1265     {
1266         if ( pFile->m_nWriteBufFree <= Len + 3 )
1267         {
1268             char* pTmp;
1269
1270             pTmp=static_cast<char*>(realloc(pFile->m_pWriteBuf,( ( pFile->m_nWriteBufLen + Len ) * 2) ));
1271             if ( pTmp == nullptr )
1272             {
1273                 return false;
1274             }
1275             pFile->m_pWriteBuf = pTmp;
1276             pFile->m_nWriteBufFree = pFile->m_nWriteBufFree + pFile->m_nWriteBufLen + ( 2 * Len );
1277             pFile->m_nWriteBufLen = ( pFile->m_nWriteBufLen + Len ) * 2;
1278             memset( (pFile->m_pWriteBuf) + ( pFile->m_nWriteBufLen - pFile->m_nWriteBufFree ), 0, pFile->m_nWriteBufFree);
1279         }
1280     }
1281
1282     memcpy(pFile->m_pWriteBuf + ( pFile->m_nWriteBufLen - pFile->m_nWriteBufFree ),pszLine,Len+1);
1283
1284     pFile->m_pWriteBuf[pFile->m_nWriteBufLen - pFile->m_nWriteBufFree + Len]='\r';
1285     pFile->m_pWriteBuf[pFile->m_nWriteBufLen - pFile->m_nWriteBufFree + Len + 1]='\n';
1286     pFile->m_pWriteBuf[pFile->m_nWriteBufLen - pFile->m_nWriteBufFree + Len + 2]='\0';
1287
1288     pFile->m_nWriteBufFree-=Len+2;
1289
1290     return true;
1291 }
1292
1293 /* platform specific end */
1294
1295 static const char* stripBlanks(const char* String, sal_uInt32* pLen)
1296 {
1297     if ( (pLen != nullptr) && ( *pLen != 0 ) )
1298     {
1299         while ((String[*pLen - 1] == ' ') || (String[*pLen - 1] == '\t'))
1300             (*pLen)--;
1301
1302         while ((*String == ' ') || (*String == '\t'))
1303         {
1304             String++;
1305             (*pLen)--;
1306         }
1307     }
1308     else
1309         while ((*String == ' ') || (*String == '\t'))
1310             String++;
1311
1312     return String;
1313 }
1314
1315 static const char* addLine(osl_TProfileImpl* pProfile, const char* Line)
1316 {
1317     if (pProfile->m_NoLines >= pProfile->m_MaxLines)
1318     {
1319         if (pProfile->m_Lines == nullptr)
1320         {
1321             pProfile->m_MaxLines = LINES_INI;
1322             pProfile->m_Lines = static_cast<char **>(calloc(pProfile->m_MaxLines, sizeof(char *)));
1323         }
1324         else
1325         {
1326             unsigned int index=0;
1327             unsigned int oldmax=pProfile->m_MaxLines;
1328
1329             pProfile->m_MaxLines += LINES_ADD;
1330             if (auto p = static_cast<char **>(realloc(pProfile->m_Lines, pProfile->m_MaxLines * sizeof(char *))))
1331             {
1332                 pProfile->m_Lines = p;
1333
1334                 for ( index = oldmax ; index < pProfile->m_MaxLines ; ++index )
1335                 {
1336                     pProfile->m_Lines[index]=nullptr;
1337                 }
1338             }
1339             else
1340             {
1341                 free(pProfile->m_Lines);
1342                 pProfile->m_Lines = nullptr;
1343             }
1344         }
1345
1346         if (pProfile->m_Lines == nullptr)
1347         {
1348             pProfile->m_NoLines  = 0;
1349             pProfile->m_MaxLines = 0;
1350             return nullptr;
1351         }
1352
1353     }
1354
1355     if ( pProfile->m_Lines != nullptr && pProfile->m_Lines[pProfile->m_NoLines] != nullptr )
1356     {
1357             free(pProfile->m_Lines[pProfile->m_NoLines]);
1358     }
1359     pProfile->m_Lines[pProfile->m_NoLines++] = strdup(Line);
1360
1361     return pProfile->m_Lines[pProfile->m_NoLines - 1];
1362 }
1363
1364 static const char* insertLine(osl_TProfileImpl* pProfile, const char* Line, sal_uInt32 LineNo)
1365 {
1366     if (pProfile->m_NoLines >= pProfile->m_MaxLines)
1367     {
1368         if (pProfile->m_Lines == nullptr)
1369         {
1370             pProfile->m_MaxLines = LINES_INI;
1371             pProfile->m_Lines = static_cast<char **>(calloc(pProfile->m_MaxLines, sizeof(char *)));
1372         }
1373         else
1374         {
1375             pProfile->m_MaxLines += LINES_ADD;
1376             if (auto p = static_cast<char**>(
1377                     realloc(pProfile->m_Lines, pProfile->m_MaxLines * sizeof(char*))))
1378             {
1379                 pProfile->m_Lines = p;
1380
1381                 memset(&pProfile->m_Lines[pProfile->m_NoLines], 0,
1382                        (pProfile->m_MaxLines - pProfile->m_NoLines - 1) * sizeof(char*));
1383             }
1384             else
1385             {
1386                 free(pProfile->m_Lines);
1387                 pProfile->m_Lines = nullptr;
1388             }
1389         }
1390
1391         if (pProfile->m_Lines == nullptr)
1392         {
1393             pProfile->m_NoLines  = 0;
1394             pProfile->m_MaxLines = 0;
1395             return nullptr;
1396         }
1397     }
1398
1399     LineNo = std::min(LineNo, pProfile->m_NoLines);
1400
1401     if (LineNo < pProfile->m_NoLines)
1402     {
1403         sal_uInt32 i, n;
1404
1405         memmove(&pProfile->m_Lines[LineNo + 1], &pProfile->m_Lines[LineNo],
1406                 (pProfile->m_NoLines - LineNo) * sizeof(char *));
1407
1408         /* adjust line references */
1409         for (i = 0; i < pProfile->m_NoSections; i++)
1410         {
1411             osl_TProfileSection* pSec = &pProfile->m_Sections[i];
1412
1413             if (pSec->m_Line >= LineNo)
1414                 pSec->m_Line++;
1415
1416             for (n = 0; n < pSec->m_NoEntries; n++)
1417                 if (pSec->m_Entries[n].m_Line >= LineNo)
1418                     pSec->m_Entries[n].m_Line++;
1419         }
1420     }
1421
1422     pProfile->m_NoLines++;
1423
1424     pProfile->m_Lines[LineNo] = strdup(Line);
1425
1426     return pProfile->m_Lines[LineNo];
1427 }
1428
1429 static void removeLine(osl_TProfileImpl* pProfile, sal_uInt32 LineNo)
1430 {
1431     if (LineNo < pProfile->m_NoLines)
1432     {
1433         free(pProfile->m_Lines[LineNo]);
1434         pProfile->m_Lines[LineNo]=nullptr;
1435         if (pProfile->m_NoLines - LineNo > 1)
1436         {
1437             sal_uInt32 i, n;
1438
1439             memmove(&pProfile->m_Lines[LineNo], &pProfile->m_Lines[LineNo + 1],
1440                     (pProfile->m_NoLines - LineNo - 1) * sizeof(char *));
1441
1442             memset(&pProfile->m_Lines[pProfile->m_NoLines - 1],
1443                 0,
1444                 (pProfile->m_MaxLines - pProfile->m_NoLines) * sizeof(char*));
1445
1446             /* adjust line references */
1447             for (i = 0; i < pProfile->m_NoSections; i++)
1448             {
1449                 osl_TProfileSection* pSec = &pProfile->m_Sections[i];
1450
1451                 if (pSec->m_Line > LineNo)
1452                     pSec->m_Line--;
1453
1454                 for (n = 0; n < pSec->m_NoEntries; n++)
1455                     if (pSec->m_Entries[n].m_Line > LineNo)
1456                         pSec->m_Entries[n].m_Line--;
1457             }
1458         }
1459         else
1460         {
1461             pProfile->m_Lines[LineNo] = nullptr;
1462         }
1463
1464         pProfile->m_NoLines--;
1465     }
1466
1467     return;
1468 }
1469
1470 static void setEntry(osl_TProfileImpl* pProfile, osl_TProfileSection* pSection,
1471                      sal_uInt32 NoEntry, sal_uInt32 Line,
1472                      const char* Entry, sal_uInt32 Len)
1473 {
1474     Entry = stripBlanks(Entry, &Len);
1475     pSection->m_Entries[NoEntry].m_Line   = Line;
1476     pSection->m_Entries[NoEntry].m_Offset = Entry - pProfile->m_Lines[Line];
1477     pSection->m_Entries[NoEntry].m_Len    = Len;
1478
1479     return;
1480 }
1481
1482 static bool addEntry(osl_TProfileImpl* pProfile, osl_TProfileSection *pSection,
1483                         int Line, const char* Entry, sal_uInt32 Len)
1484 {
1485     if (pSection != nullptr)
1486     {
1487         if (pSection->m_NoEntries >= pSection->m_MaxEntries)
1488         {
1489             if (pSection->m_Entries == nullptr)
1490             {
1491                 pSection->m_MaxEntries = ENTRIES_INI;
1492                 pSection->m_Entries = static_cast<osl_TProfileEntry *>(malloc(
1493                                 pSection->m_MaxEntries * sizeof(osl_TProfileEntry)));
1494             }
1495             else
1496             {
1497                 pSection->m_MaxEntries += ENTRIES_ADD;
1498                 if (auto p = static_cast<osl_TProfileEntry*>(realloc(
1499                         pSection->m_Entries, pSection->m_MaxEntries * sizeof(osl_TProfileEntry))))
1500                     pSection->m_Entries = p;
1501                 else
1502                 {
1503                     free(pSection->m_Entries);
1504                     pSection->m_Entries = nullptr;
1505                 }
1506             }
1507
1508             if (pSection->m_Entries == nullptr)
1509             {
1510                 pSection->m_NoEntries  = 0;
1511                 pSection->m_MaxEntries = 0;
1512                 return false;
1513             }
1514         }
1515
1516         pSection->m_NoEntries++;
1517
1518         Entry = stripBlanks(Entry, &Len);
1519         setEntry(pProfile, pSection, pSection->m_NoEntries - 1, Line,
1520                  Entry, Len);
1521
1522         return true;
1523     }
1524
1525     return false;
1526 }
1527
1528 static void removeEntry(osl_TProfileSection *pSection, sal_uInt32 NoEntry)
1529 {
1530     if (NoEntry < pSection->m_NoEntries)
1531     {
1532         if (pSection->m_NoEntries - NoEntry > 1)
1533         {
1534             memmove(&pSection->m_Entries[NoEntry],
1535                     &pSection->m_Entries[NoEntry + 1],
1536                     (pSection->m_NoEntries - NoEntry - 1) * sizeof(osl_TProfileEntry));
1537             pSection->m_Entries[pSection->m_NoEntries - 1].m_Line=0;
1538             pSection->m_Entries[pSection->m_NoEntries - 1].m_Offset=0;
1539             pSection->m_Entries[pSection->m_NoEntries - 1].m_Len=0;
1540         }
1541
1542         pSection->m_NoEntries--;
1543     }
1544
1545     return;
1546 }
1547
1548 static bool addSection(osl_TProfileImpl* pProfile, int Line, const char* Section, sal_uInt32 Len)
1549 {
1550     if (pProfile->m_NoSections >= pProfile->m_MaxSections)
1551     {
1552         if (pProfile->m_Sections == nullptr)
1553         {
1554             pProfile->m_MaxSections = SECTIONS_INI;
1555             pProfile->m_Sections = static_cast<osl_TProfileSection*>(calloc(pProfile->m_MaxSections, sizeof(osl_TProfileSection)));
1556         }
1557         else
1558         {
1559             unsigned int index=0;
1560             unsigned int oldmax=pProfile->m_MaxSections;
1561
1562             pProfile->m_MaxSections += SECTIONS_ADD;
1563             if (auto p = static_cast<osl_TProfileSection*>(realloc(
1564                     pProfile->m_Sections, pProfile->m_MaxSections * sizeof(osl_TProfileSection))))
1565             {
1566                 pProfile->m_Sections = p;
1567                 for ( index = oldmax ; index < pProfile->m_MaxSections ; ++index )
1568                 {
1569                     pProfile->m_Sections[index].m_Entries=nullptr;
1570                 }
1571             }
1572             else
1573             {
1574                 free(pProfile->m_Sections);
1575                 pProfile->m_Sections = nullptr;
1576             }
1577         }
1578
1579         if (pProfile->m_Sections == nullptr)
1580         {
1581             pProfile->m_NoSections = 0;
1582             pProfile->m_MaxSections = 0;
1583             return false;
1584         }
1585     }
1586
1587     pProfile->m_NoSections++;
1588
1589     if ( pProfile->m_Sections[(pProfile->m_NoSections) - 1].m_Entries != nullptr )
1590     {
1591         free(pProfile->m_Sections[(pProfile->m_NoSections) - 1].m_Entries);
1592     }
1593     pProfile->m_Sections[pProfile->m_NoSections - 1].m_Entries    = nullptr;
1594     pProfile->m_Sections[pProfile->m_NoSections - 1].m_NoEntries  = 0;
1595     pProfile->m_Sections[pProfile->m_NoSections - 1].m_MaxEntries = 0;
1596
1597     Section = stripBlanks(Section, &Len);
1598     pProfile->m_Sections[pProfile->m_NoSections - 1].m_Line = Line;
1599     pProfile->m_Sections[pProfile->m_NoSections - 1].m_Offset = Section - pProfile->m_Lines[Line];
1600     pProfile->m_Sections[pProfile->m_NoSections - 1].m_Len = Len;
1601
1602     return true;
1603 }
1604
1605 static void removeSection(osl_TProfileImpl* pProfile, osl_TProfileSection *pSection)
1606 {
1607     sal_uInt32 Section;
1608
1609     if ((Section = pSection - pProfile->m_Sections) < pProfile->m_NoSections)
1610     {
1611         free (pSection->m_Entries);
1612         pSection->m_Entries=nullptr;
1613         if (pProfile->m_NoSections - Section > 1)
1614         {
1615             memmove(&pProfile->m_Sections[Section], &pProfile->m_Sections[Section + 1],
1616                     (pProfile->m_NoSections - Section - 1) * sizeof(osl_TProfileSection));
1617
1618             memset(&pProfile->m_Sections[pProfile->m_NoSections - 1],
1619                 0,
1620                 (pProfile->m_MaxSections - pProfile->m_NoSections) * sizeof(osl_TProfileSection));
1621             pProfile->m_Sections[pProfile->m_NoSections - 1].m_Entries = nullptr;
1622         }
1623         else
1624         {
1625             pSection->m_Entries = nullptr;
1626         }
1627
1628         pProfile->m_NoSections--;
1629     }
1630
1631     return;
1632 }
1633
1634 static osl_TProfileSection* findEntry(osl_TProfileImpl* pProfile, const char* Section,
1635                                       const char* Entry, sal_uInt32 *pNoEntry)
1636 {
1637     static  sal_uInt32    Sect = 0;
1638     sal_uInt32    i, n;
1639     sal_uInt32    Len;
1640     osl_TProfileSection* pSec = nullptr;
1641
1642     Len = strlen(Section);
1643     Section = stripBlanks(Section, &Len);
1644
1645     n = Sect;
1646
1647     for (i = 0; i < pProfile->m_NoSections; i++)
1648     {
1649         n %= pProfile->m_NoSections;
1650         pSec = &pProfile->m_Sections[n];
1651         if ((Len == pSec->m_Len) &&
1652             (strnicmp(Section, &pProfile->m_Lines[pSec->m_Line][pSec->m_Offset], pSec->m_Len)
1653              == 0))
1654             break;
1655         n++;
1656     }
1657
1658     Sect = n;
1659
1660     if (i < pProfile->m_NoSections)
1661     {
1662         Len = strlen(Entry);
1663         Entry = stripBlanks(Entry, &Len);
1664
1665         *pNoEntry = pSec->m_NoEntries;
1666
1667         for (i = 0; i < pSec->m_NoEntries; i++)
1668         {
1669             const char* pStr = &pProfile->m_Lines[pSec->m_Entries[i].m_Line]
1670                                      [pSec->m_Entries[i].m_Offset];
1671             if ((Len == pSec->m_Entries[i].m_Len) &&
1672                 (strnicmp(Entry, pStr, pSec->m_Entries[i].m_Len)
1673                  == 0))
1674             {
1675                 *pNoEntry = i;
1676                 break;
1677             }
1678         }
1679     }
1680     else
1681         pSec = nullptr;
1682
1683     return pSec;
1684 }
1685
1686 static bool loadProfile(osl_TFile* pFile, osl_TProfileImpl* pProfile)
1687 {
1688     sal_uInt32    i;
1689     char const * pStr;
1690     char const * pChar;
1691     char        Line[4096];
1692
1693     pProfile->m_NoLines    = 0;
1694     pProfile->m_NoSections = 0;
1695
1696     OSL_VERIFY(rewindFile(pFile, false));
1697
1698     while (getLine(pFile, Line, sizeof(Line)))
1699     {
1700         if (! addLine(pProfile, Line))
1701             return false;
1702     }
1703
1704     for (i = 0; i < pProfile->m_NoLines; i++)
1705     {
1706         pStr = stripBlanks(pProfile->m_Lines[i], nullptr);
1707
1708         if ((*pStr == '\0') || (*pStr == ';'))
1709             continue;
1710
1711         if ((*pStr != '[') || ((pChar = strrchr(pStr, ']')) == nullptr) ||
1712             ((pChar - pStr) <= 2))
1713         {
1714             /* insert entry */
1715
1716             if (pProfile->m_NoSections < 1)
1717                 continue;
1718
1719             if ((pChar = strchr(pStr, '=')) == nullptr)
1720                 pChar = pStr + strlen(pStr);
1721
1722             if (! addEntry(pProfile, &pProfile->m_Sections[pProfile->m_NoSections - 1],
1723                            i, pStr, pChar - pStr))
1724                 return false;
1725         }
1726         else
1727         {
1728             /* new section */
1729             if (! addSection(pProfile, i, pStr + 1, pChar - pStr - 1))
1730                 return false;
1731         }
1732     }
1733
1734     return true;
1735 }
1736
1737 static bool storeProfile(osl_TProfileImpl* pProfile, bool bCleanup)
1738 {
1739     if (pProfile->m_Lines != nullptr)
1740     {
1741         if (pProfile->m_Flags & FLG_MODIFIED)
1742         {
1743             sal_uInt32 i;
1744
1745             osl_TFile* pTmpFile = osl_openTmpProfileImpl(pProfile);
1746
1747             if ( pTmpFile == nullptr )
1748             {
1749                 return false;
1750             }
1751
1752             OSL_VERIFY(rewindFile(pTmpFile, true));
1753
1754             for (i = 0; i < pProfile->m_NoLines; i++)
1755             {
1756                 OSL_VERIFY(putLine(pTmpFile, pProfile->m_Lines[i]));
1757             }
1758
1759             if ( ! writeProfileImpl(pTmpFile) )
1760             {
1761                 if ( pTmpFile->m_pWriteBuf != nullptr )
1762                 {
1763                     free(pTmpFile->m_pWriteBuf);
1764                 }
1765
1766                 pTmpFile->m_pWriteBuf=nullptr;
1767                 pTmpFile->m_nWriteBufLen=0;
1768                 pTmpFile->m_nWriteBufFree=0;
1769
1770                 closeFileImpl(pTmpFile);
1771
1772                 return false;
1773             }
1774
1775             pProfile->m_Flags &= ~FLG_MODIFIED;
1776
1777             closeFileImpl(pProfile->m_pFile);
1778             closeFileImpl(pTmpFile);
1779
1780             osl_ProfileSwapProfileNames(pProfile);
1781
1782             pProfile->m_pFile = openFileImpl(pProfile->m_strFileName,pProfile->m_Flags);
1783
1784         }
1785
1786         if (bCleanup)
1787         {
1788             while (pProfile->m_NoLines > 0)
1789                 removeLine(pProfile, pProfile->m_NoLines - 1);
1790
1791             free(pProfile->m_Lines);
1792             pProfile->m_Lines = nullptr;
1793             pProfile->m_MaxLines = 0;
1794
1795             while (pProfile->m_NoSections > 0)
1796                 removeSection(pProfile, &pProfile->m_Sections[pProfile->m_NoSections - 1]);
1797
1798             free(pProfile->m_Sections);
1799             pProfile->m_Sections = nullptr;
1800             pProfile->m_MaxSections = 0;
1801         }
1802     }
1803
1804     return true;
1805 }
1806
1807 static osl_TFile* osl_openTmpProfileImpl(osl_TProfileImpl* pProfile)
1808 {
1809     osl_TFile* pFile=nullptr;
1810     rtl_uString* ustrExtension=nullptr;
1811     rtl_uString* ustrTmpName=nullptr;
1812     oslProfileOption PFlags=0;
1813
1814     rtl_uString_newFromAscii(&ustrExtension,"tmp");
1815
1816     /* generate tmp profilename */
1817     ustrTmpName=osl_ProfileGenerateExtension(pProfile->m_strFileName,ustrExtension);
1818     rtl_uString_release(ustrExtension);
1819
1820     if (ustrTmpName == nullptr)
1821         return nullptr;
1822
1823     if (!(pProfile->m_Flags & osl_Profile_READLOCK))
1824         PFlags |= osl_Profile_WRITELOCK;
1825
1826     /* open this file */
1827     pFile = openFileImpl(ustrTmpName,pProfile->m_Flags | PFlags);
1828
1829     /* return new pFile */
1830     return pFile;
1831 }
1832
1833 static bool osl_ProfileSwapProfileNames(osl_TProfileImpl* pProfile)
1834 {
1835     rtl_uString* ustrBakFile=nullptr;
1836     rtl_uString* ustrTmpFile=nullptr;
1837     rtl_uString* ustrIniFile=nullptr;
1838     rtl_uString* ustrExtension=nullptr;
1839
1840     rtl_uString_newFromAscii(&ustrExtension,"bak");
1841
1842     ustrBakFile=osl_ProfileGenerateExtension(pProfile->m_strFileName,ustrExtension);
1843     rtl_uString_release(ustrExtension);
1844     ustrExtension=nullptr;
1845
1846     rtl_uString_newFromAscii(&ustrExtension,"ini");
1847
1848     ustrIniFile=osl_ProfileGenerateExtension(pProfile->m_strFileName,ustrExtension);
1849     rtl_uString_release(ustrExtension);
1850     ustrExtension=nullptr;
1851
1852     rtl_uString_newFromAscii(&ustrExtension,"tmp");
1853
1854     ustrTmpFile=osl_ProfileGenerateExtension(pProfile->m_strFileName,ustrExtension);
1855     rtl_uString_release(ustrExtension);
1856     ustrExtension=nullptr;
1857
1858     /* unlink bak */
1859     DeleteFileW( o3tl::toW(rtl_uString_getStr( ustrBakFile )) );
1860
1861     /* rename ini bak */
1862     MoveFileExW( o3tl::toW(rtl_uString_getStr( ustrIniFile )), o3tl::toW(rtl_uString_getStr( ustrBakFile )), MOVEFILE_COPY_ALLOWED | MOVEFILE_WRITE_THROUGH );
1863
1864     /* rename tmp ini */
1865     MoveFileExW( o3tl::toW(rtl_uString_getStr( ustrTmpFile )), o3tl::toW(rtl_uString_getStr( ustrIniFile )), MOVEFILE_COPY_ALLOWED | MOVEFILE_WRITE_THROUGH );
1866
1867     return false;
1868 }
1869
1870 static rtl_uString* osl_ProfileGenerateExtension(rtl_uString* ustrFileName, rtl_uString* ustrExtension)
1871 {
1872     rtl_uString* ustrNewFileName = nullptr;
1873     rtl_uString* ustrOldExtension = nullptr;
1874
1875     sal_Unicode* pFileNameBuf = rtl_uString_getStr(ustrFileName);
1876
1877     rtl_uString_newFromAscii(&ustrOldExtension, ".");
1878
1879     sal_Unicode* pExtensionBuf = rtl_uString_getStr(ustrOldExtension);
1880
1881     sal_Int32 nIndex = rtl_ustr_lastIndexOfChar(pFileNameBuf, *pExtensionBuf);
1882
1883     rtl_uString_newReplaceStrAt(&ustrNewFileName,
1884                                 ustrFileName,
1885                                 nIndex+1,
1886                                 3,
1887                                 ustrExtension);
1888
1889     return ustrNewFileName;
1890 }
1891
1892 static osl_TProfileImpl* acquireProfile(oslProfile Profile, bool bWriteable)
1893 {
1894     osl_TProfileImpl* pProfile = static_cast<osl_TProfileImpl*>(Profile);
1895     oslProfileOption PFlags=0;
1896
1897     if ( bWriteable )
1898     {
1899         PFlags = osl_Profile_DEFAULT | osl_Profile_WRITELOCK;
1900     }
1901     else
1902     {
1903         PFlags = osl_Profile_DEFAULT;
1904     }
1905
1906     if (pProfile == nullptr)
1907     {
1908 #ifdef DEBUG_OSL_PROFILE
1909         SAL_INFO("sal.osl", "AUTOOPEN MODE");
1910 #endif
1911
1912         if ( ( pProfile = static_cast<osl_TProfileImpl*>(osl_openProfile( nullptr, PFlags )) ) != nullptr )
1913         {
1914             pProfile->m_Flags |= FLG_AUTOOPEN;
1915         }
1916     }
1917     else
1918     {
1919 #ifdef DEBUG_OSL_PROFILE
1920         SAL_INFO("sal.osl", "try to acquire");
1921 #endif
1922
1923         if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
1924         {
1925             if (! (pProfile->m_Flags & (osl_Profile_READLOCK |
1926                                         osl_Profile_WRITELOCK | osl_Profile_FLUSHWRITE)))
1927             {
1928                 osl_TStamp Stamp;
1929 #ifdef DEBUG_OSL_PROFILE
1930                 SAL_INFO("sal.osl", "DEFAULT MODE");
1931 #endif
1932                 pProfile->m_pFile = openFileImpl(
1933                     pProfile->m_strFileName, pProfile->m_Flags | PFlags);
1934                 if (!pProfile->m_pFile)
1935                     return nullptr;
1936
1937                 Stamp = getFileStamp(pProfile->m_pFile);
1938
1939                 if (memcmp(&Stamp, &(pProfile->m_Stamp), sizeof(osl_TStamp)))
1940                 {
1941                     pProfile->m_Stamp = Stamp;
1942
1943                     loadProfile(pProfile->m_pFile, pProfile);
1944                 }
1945             }
1946             else
1947             {
1948 #ifdef DEBUG_OSL_PROFILE
1949                 SAL_INFO("sal.osl", "READ/WRITELOCK MODE");
1950 #endif
1951
1952                 /* A readlock file could not be written */
1953                 if ((pProfile->m_Flags & osl_Profile_READLOCK) && bWriteable)
1954                 {
1955                     return nullptr;
1956                 }
1957             }
1958         }
1959     }
1960
1961     return pProfile;
1962 }
1963
1964 static bool releaseProfile(osl_TProfileImpl* pProfile)
1965 {
1966     if ( pProfile == nullptr )
1967     {
1968         return false;
1969     }
1970
1971     if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
1972     {
1973         if (pProfile->m_Flags & FLG_AUTOOPEN)
1974         {
1975             return osl_closeProfile(static_cast<oslProfile>(pProfile));
1976         }
1977         else
1978         {
1979 #ifdef DEBUG_OSL_PROFILE
1980             SAL_INFO("sal.osl", "DEFAULT MODE");
1981 #endif
1982             if (! (pProfile->m_Flags & (osl_Profile_READLOCK |
1983                                         osl_Profile_WRITELOCK | osl_Profile_FLUSHWRITE)))
1984             {
1985                 if (pProfile->m_Flags & FLG_MODIFIED)
1986                     storeProfile(pProfile, false);
1987
1988                 closeFileImpl(pProfile->m_pFile);
1989                 pProfile->m_pFile = nullptr;
1990             }
1991         }
1992     }
1993
1994     return true;
1995 }
1996
1997 static bool lookupProfile(const sal_Unicode *strPath, const sal_Unicode *strFile, sal_Unicode *strProfile)
1998 {
1999     char *pChr;
2000     char Buffer[4096] = "";
2001     char Product[132] = "";
2002
2003     ::osl::LongPathBuffer< sal_Unicode > aPath( MAX_LONG_PATH );
2004     aPath[0] = 0;
2005
2006     if (*strPath == L'"')
2007     {
2008         int i = 0;
2009
2010         strPath++;
2011
2012         while ((strPath[i] != L'"') && (strPath[i] != L'\0'))
2013             i++;
2014
2015         WideCharToMultiByte(CP_ACP,0, o3tl::toW(strPath), i, Product, sizeof(Product), nullptr, nullptr);
2016         Product[i] = '\0';
2017         strPath += i;
2018
2019         if (*strPath == L'"')
2020             strPath++;
2021
2022         if ( (*strPath == L'/') || (*strPath == L'\\') )
2023         {
2024             strPath++;
2025         }
2026     }
2027
2028     else
2029     {
2030         /* if we have not product identification, do a special handling for soffice.ini */
2031         if (rtl_ustr_ascii_compare(strFile, SVERSION_PROFILE) == 0)
2032         {
2033             rtl_uString * strSVProfile  = nullptr;
2034             rtl_uString * strSVFallback = nullptr;
2035             rtl_uString * strSVLocation = nullptr;
2036             rtl_uString * strSVName     = nullptr;
2037             ::osl::LongPathBuffer< char > aDir( MAX_LONG_PATH );
2038             oslProfile hProfile;
2039
2040             rtl_uString_newFromAscii(&strSVFallback, SVERSION_FALLBACK);
2041             rtl_uString_newFromAscii(&strSVLocation, SVERSION_LOCATION);
2042             rtl_uString_newFromAscii(&strSVName, SVERSION_NAME);
2043
2044             /* open sversion.ini in the system directory, and try to locate the entry
2045                with the highest version for StarOffice */
2046             if (osl_getProfileName( strSVFallback, strSVName, &strSVProfile))
2047             {
2048                 hProfile = osl_openProfile(strSVProfile, osl_Profile_READLOCK);
2049                 if (hProfile)
2050                 {
2051                     osl_getProfileSectionEntries(
2052                         hProfile, SVERSION_SECTION, Buffer, sizeof(Buffer));
2053
2054                     for (pChr = Buffer; *pChr != '\0'; pChr += strlen(pChr) + 1)
2055                     {
2056                         if ((strnicmp(
2057                                  pChr, SVERSION_SOFFICE,
2058                                  sizeof(SVERSION_SOFFICE) - 1)
2059                              == 0)
2060                             && (stricmp(Product, pChr) < 0))
2061                         {
2062                             osl_readProfileString(
2063                                 hProfile, SVERSION_SECTION, pChr, aDir,
2064                                 aDir.getBufSizeInSymbols(), "");
2065
2066                             /* check for existence of path */
2067                             if (access(aDir, 0) >= 0)
2068                                 strcpy(Product, pChr);
2069                         }
2070                     }
2071
2072                     osl_closeProfile(hProfile);
2073                 }
2074                 rtl_uString_release(strSVProfile);
2075                 strSVProfile = nullptr;
2076             }
2077
2078             /* open sversion.ini in the users directory, and try to locate the entry
2079                with the highest version for StarOffice */
2080             if ( osl_getProfileName(strSVLocation, strSVName, &strSVProfile) )
2081             {
2082                 hProfile = osl_openProfile(strSVProfile, osl_Profile_READLOCK);
2083                 if (hProfile)
2084                 {
2085                     osl_getProfileSectionEntries(
2086                         hProfile, SVERSION_SECTION, Buffer, sizeof(Buffer));
2087
2088                     for (pChr = Buffer; *pChr != '\0'; pChr += strlen(pChr) + 1)
2089                     {
2090                         if ((strnicmp(
2091                                  pChr, SVERSION_SOFFICE,
2092                                  sizeof(SVERSION_SOFFICE) - 1)
2093                              == 0)
2094                             && (stricmp(Product, pChr) < 0))
2095                         {
2096                             osl_readProfileString(
2097                                 hProfile, SVERSION_SECTION, pChr, aDir,
2098                                 aDir.getBufSizeInSymbols(), "");
2099
2100                             /* check for existence of path */
2101                             if (access(aDir, 0) >= 0)
2102                                 strcpy(Product, pChr);
2103                         }
2104                     }
2105
2106                     osl_closeProfile(hProfile);
2107                 }
2108                 rtl_uString_release(strSVProfile);
2109             }
2110
2111             rtl_uString_release(strSVFallback);
2112             rtl_uString_release(strSVLocation);
2113             rtl_uString_release(strSVName);
2114
2115             /* remove any trailing build number */
2116             if ((pChr = strrchr(Product, '/')) != nullptr)
2117                 *pChr = '\0';
2118         }
2119     }
2120
2121     rtl_uString * strExecutable = nullptr;
2122     rtl_uString * strTmp = nullptr;
2123     sal_Int32 nPos;
2124
2125     /* try to find the file in the directory of the executable */
2126     if (osl_getExecutableFile(&strTmp) != osl_Process_E_None)
2127         return false;
2128
2129     /* convert to native path */
2130     if (osl_getSystemPathFromFileURL(strTmp, &strExecutable) != osl_File_E_None)
2131     {
2132         rtl_uString_release(strTmp);
2133         return false;
2134     }
2135
2136     rtl_uString_release(strTmp);
2137
2138     DWORD dwPathLen = 0;
2139
2140     /* separate path from filename */
2141     if ((nPos = rtl_ustr_lastIndexOfChar(strExecutable->buffer, L'\\')) == -1)
2142     {
2143         if ((nPos = rtl_ustr_lastIndexOfChar(strExecutable->buffer, L':')) == -1)
2144         {
2145             rtl_uString_release(strExecutable);
2146             return false;
2147         }
2148         else
2149         {
2150             copy_ustr_n(aPath, strExecutable->buffer, nPos);
2151             aPath[nPos] = 0;
2152             dwPathLen = nPos;
2153         }
2154     }
2155     else
2156     {
2157         copy_ustr_n(aPath, strExecutable->buffer, nPos);
2158         dwPathLen = nPos;
2159         aPath[dwPathLen] = 0;
2160     }
2161
2162     /* if we have no product identification use the executable file name */
2163     if (*Product == 0)
2164     {
2165         WideCharToMultiByte(CP_ACP,0, o3tl::toW(strExecutable->buffer + nPos + 1), -1, Product, sizeof(Product), nullptr, nullptr);
2166
2167         /* remove extension */
2168         if ((pChr = strrchr(Product, '.')) != nullptr)
2169             *pChr = '\0';
2170     }
2171
2172     rtl_uString_release(strExecutable);
2173
2174     /* remember last subdir */
2175     nPos = rtl_ustr_lastIndexOfChar(aPath, L'\\');
2176
2177     copy_ustr_n(aPath + dwPathLen++, L"\\", 2);
2178
2179     if (*strPath)
2180     {
2181         copy_ustr_n(aPath + dwPathLen, strPath, rtl_ustr_getLength(strPath)+1);
2182         dwPathLen += rtl_ustr_getLength(strPath);
2183     }
2184
2185     {
2186         ::osl::LongPathBuffer< char > aTmpPath( MAX_LONG_PATH );
2187
2188         WideCharToMultiByte(CP_ACP,0, o3tl::toW(aPath), -1, aTmpPath, aTmpPath.getBufSizeInSymbols(), nullptr, nullptr);
2189
2190         /* if file not exists, remove any specified subdirectories
2191            like "bin" or "program" */
2192
2193         if (((access(aTmpPath, 0) < 0) && (nPos != -1)) || (*strPath == 0))
2194         {
2195             static const char *SubDirs[] = SVERSION_DIRS;
2196
2197             unsigned i = 0;
2198             char *pStr = aTmpPath + nPos;
2199
2200             for (i = 0; i < SAL_N_ELEMENTS(SubDirs); i++)
2201                 if (strnicmp(pStr + 1, SubDirs[i], strlen(SubDirs[i])) == 0)
2202                 {
2203                     if ( *strPath == 0)
2204                     {
2205                         strcpy(pStr + 1,SVERSION_USER);
2206                         if ( access(aTmpPath, 0) < 0 )
2207                         {
2208                             *(pStr+1)='\0';
2209                         }
2210                         else
2211                         {
2212                             dwPathLen = nPos + MultiByteToWideChar( CP_ACP, 0, SVERSION_USER, -1, o3tl::toW(aPath + nPos + 1), aPath.getBufSizeInSymbols() - (nPos + 1) );
2213                         }
2214                     }
2215                     else
2216                     {
2217                         copy_ustr_n(aPath + nPos + 1, strPath, rtl_ustr_getLength(strPath)+1);
2218                         dwPathLen = nPos + 1 + rtl_ustr_getLength(strPath);
2219                     }
2220
2221                     break;
2222                 }
2223         }
2224     }
2225
2226     if ((aPath[dwPathLen - 1] != L'/') && (aPath[dwPathLen - 1] != L'\\'))
2227     {
2228         aPath[dwPathLen++] = L'\\';
2229         aPath[dwPathLen] = 0;
2230     }
2231
2232     copy_ustr_n(aPath + dwPathLen, strFile, rtl_ustr_getLength(strFile)+1);
2233
2234     {
2235         ::osl::LongPathBuffer< char > aTmpPath( MAX_LONG_PATH );
2236
2237         WideCharToMultiByte(CP_ACP,0, o3tl::toW(aPath), -1, aTmpPath, aTmpPath.getBufSizeInSymbols(), nullptr, nullptr);
2238
2239         if ((access(aTmpPath, 0) < 0) && (Product[0] != '\0'))
2240         {
2241             rtl_uString * strSVFallback = nullptr;
2242             rtl_uString * strSVProfile  = nullptr;
2243             rtl_uString * strSVLocation = nullptr;
2244             rtl_uString * strSVName     = nullptr;
2245             oslProfile hProfile;
2246
2247             rtl_uString_newFromAscii(&strSVFallback, SVERSION_FALLBACK);
2248             rtl_uString_newFromAscii(&strSVLocation, SVERSION_LOCATION);
2249             rtl_uString_newFromAscii(&strSVName, SVERSION_NAME);
2250
2251             /* open sversion.ini in the system directory, and try to locate the entry
2252                with the highest version for StarOffice */
2253             if (osl_getProfileName(strSVLocation, strSVName, &strSVProfile))
2254             {
2255                 hProfile = osl_openProfile(
2256                     strSVProfile, osl_Profile_READLOCK);
2257                 if (hProfile)
2258                 {
2259                     osl_readProfileString(
2260                         hProfile, SVERSION_SECTION, Product, Buffer,
2261                         sizeof(Buffer), "");
2262                     osl_closeProfile(hProfile);
2263
2264                     /* if not found, try the fallback */
2265                     if (Buffer[0] == '\0')
2266                     {
2267                         if (osl_getProfileName(
2268                                 strSVFallback, strSVName, &strSVProfile))
2269                         {
2270                             hProfile = osl_openProfile(
2271                                 strSVProfile, osl_Profile_READLOCK);
2272                             if (hProfile)
2273                             {
2274                                 osl_readProfileString(
2275                                     hProfile, SVERSION_SECTION, Product,
2276                                     Buffer, sizeof(Buffer), "");
2277                             }
2278                         }
2279
2280                         osl_closeProfile(hProfile);
2281                     }
2282
2283                     if (Buffer[0] != '\0')
2284                     {
2285                         dwPathLen = MultiByteToWideChar(
2286                             CP_ACP, 0, Buffer, -1, o3tl::toW(aPath), aPath.getBufSizeInSymbols() );
2287                         dwPathLen -=1;
2288
2289                         /* build full path */
2290                         if ((aPath[dwPathLen - 1] != L'/')
2291                             && (aPath[dwPathLen - 1] != L'\\'))
2292                         {
2293                             copy_ustr_n(aPath + dwPathLen++, L"\\", 2);
2294                         }
2295
2296                         if (*strPath)
2297                         {
2298                             copy_ustr_n(aPath + dwPathLen, strPath, rtl_ustr_getLength(strPath)+1);
2299                             dwPathLen += rtl_ustr_getLength(strPath);
2300                         }
2301                         else
2302                         {
2303                             ::osl::LongPathBuffer< char > aTmpPath2( MAX_LONG_PATH );
2304                             int n;
2305
2306                             if ((n = WideCharToMultiByte(
2307                                      CP_ACP,0, o3tl::toW(aPath), -1, aTmpPath2,
2308                                      aTmpPath2.getBufSizeInSymbols(), nullptr, nullptr))
2309                                 > 0)
2310                             {
2311                                 strcpy(aTmpPath2 + n, SVERSION_USER);
2312                                 if (access(aTmpPath2, 0) >= 0)
2313                                 {
2314                                     dwPathLen += MultiByteToWideChar(
2315                                         CP_ACP, 0, SVERSION_USER, -1,
2316                                         o3tl::toW(aPath + dwPathLen),
2317                                         aPath.getBufSizeInSymbols() - dwPathLen );
2318                                 }
2319                             }
2320                         }
2321                     }
2322                 }
2323
2324                 rtl_uString_release(strSVProfile);
2325             }
2326
2327             rtl_uString_release(strSVFallback);
2328             rtl_uString_release(strSVLocation);
2329             rtl_uString_release(strSVName);
2330         }
2331     }
2332
2333     aPath[dwPathLen] = 0;
2334
2335     /* copy filename */
2336     copy_ustr_n(strProfile, aPath, dwPathLen+1);
2337
2338     return true;
2339 }
2340
2341 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */