LCOV - code coverage report
Current view: top level - libreoffice/sal/osl/unx - profile.c (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 118 760 15.5 %
Date: 2012-12-27 Functions: 12 38 31.6 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10