sal/osl/w32/profile.c

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