Added: openoffice/branches/olcProfileNano/sal/osl/w32/file_url.h
URL:
http://svn.apache.org/viewvc/openoffice/branches/olcProfileNano/sal/osl/w32/file_url.h?rev=1734003&view=auto
==============================================================================
--- openoffice/branches/olcProfileNano/sal/osl/w32/file_url.h (added)
+++ openoffice/branches/olcProfileNano/sal/osl/w32/file_url.h Mon Mar 7
23:34:03 2016
@@ -0,0 +1,92 @@
+/**************************************************************
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ *************************************************************/
+
+
+
+#ifndef INCLUDED_OSL_FILE_URL_H
+#define INCLUDED_OSL_FILE_URL_H
+
+#include "sal/types.h"
+#include "rtl/ustring.h"
+#include "osl/file.h"
+
+#ifdef _MSC_VER
+#pragma warning(push,1)
+#endif
+
+#define WINDOWS_LEAN_AND_MEAN
+#include <windows.h>
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define PATHTYPE_ERROR 0
+#define PATHTYPE_RELATIVE 1
+#define PATHTYPE_ABSOLUTE_UNC 2
+#define PATHTYPE_ABSOLUTE_LOCAL 3
+#define PATHTYPE_MASK_TYPE 0xFF
+#define PATHTYPE_IS_VOLUME 0x0100
+#define PATHTYPE_IS_SERVER 0x0200
+#define PATHTYPE_IS_LONGPATH 0x0400
+
+#define VALIDATEPATH_NORMAL 0x0000
+#define VALIDATEPATH_ALLOW_WILDCARDS 0x0001
+#define VALIDATEPATH_ALLOW_ELLIPSE 0x0002
+#define VALIDATEPATH_ALLOW_RELATIVE 0x0004
+#define VALIDATEPATH_ALLOW_UNC 0x0008
+
+#define MAX_LONG_PATH 32767
+
+DWORD IsValidFilePath (
+ rtl_uString * path,
+ LPCTSTR * lppError,
+ DWORD dwFlags,
+ rtl_uString ** corrected
+);
+
+DWORD GetCaseCorrectPathName (
+ LPCTSTR lpszShortPath, // file name
+ LPTSTR lpszLongPath, // path buffer
+ DWORD cchBuffer, // size of path buffer
+ BOOL bCheckExistence
+);
+
+oslFileError _osl_getSystemPathFromFileURL (
+ rtl_uString * strURL,
+ rtl_uString ** pustrPath,
+ sal_Bool bAllowRelative
+);
+
+oslFileError _osl_getFileURLFromSystemPath (
+ rtl_uString * strPath,
+ rtl_uString ** pstrURL
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* INCLUDED_OSL_FILE_URL_H */
Propchange: openoffice/branches/olcProfileNano/sal/osl/w32/file_url.h
------------------------------------------------------------------------------
svn:eol-style = native
Added: openoffice/branches/olcProfileNano/sal/osl/w32/path_helper.hxx
URL:
http://svn.apache.org/viewvc/openoffice/branches/olcProfileNano/sal/osl/w32/path_helper.hxx?rev=1734003&view=auto
==============================================================================
--- openoffice/branches/olcProfileNano/sal/osl/w32/path_helper.hxx (added)
+++ openoffice/branches/olcProfileNano/sal/osl/w32/path_helper.hxx Mon Mar 7
23:34:03 2016
@@ -0,0 +1,114 @@
+/**************************************************************
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ *************************************************************/
+
+
+
+#ifdef _MSC_VER
+#pragma warning (disable : 4800)
+#endif
+
+#ifndef _PATH_HELPER_HXX_
+#define _PATH_HELPER_HXX_
+
+#include "path_helper.h"
+#include <rtl/ustring.hxx>
+#include <rtl/alloc.h>
+
+namespace osl
+{
+
+/*******************************************************************
+ osl_systemPathEnsureSeparator
+ Adds a trailing path separator to the given system path if not
+ already there and if the path is not the root path or a logical
+ drive alone
+ ******************************************************************/
+
+inline void systemPathEnsureSeparator(/*inout*/ rtl::OUString& Path)
+{
+ osl_systemPathEnsureSeparator(&Path.pData);
+}
+
+/*******************************************************************
+ osl_systemPathRemoveSeparator
+ Removes the last separator from the given system path if any and
+ if the path is not the root path '\'
+ ******************************************************************/
+
+inline void systemPathRemoveSeparator(/*inout*/ rtl::OUString& Path)
+{
+ osl_systemPathRemoveSeparator(&Path.pData);
+}
+
+/*******************************************************************
+ osl_systemPathIsLogicalDrivePattern
+ ******************************************************************/
+
+inline bool systemPathIsLogicalDrivePattern(/*in*/ const rtl::OUString& path)
+{
+ return osl_systemPathIsLogicalDrivePattern(path.pData);
+}
+
+/*******************************************************************
+ LongPathBuffer
+ ******************************************************************/
+template< class T >
+class LongPathBuffer
+{
+ T* m_pBuffer;
+ sal_uInt32 m_nCharNum;
+
+ LongPathBuffer();
+ LongPathBuffer( const LongPathBuffer& );
+ LongPathBuffer& operator=( const LongPathBuffer& );
+
+public:
+ LongPathBuffer( sal_uInt32 nCharNum )
+ : m_pBuffer( reinterpret_cast<T*>( rtl_allocateMemory( nCharNum * sizeof(
T ) ) ) )
+ , m_nCharNum( nCharNum )
+ {
+ OSL_ENSURE( m_pBuffer, "Can not allocate the buffer!" );
+ }
+
+ ~LongPathBuffer()
+ {
+ if ( m_pBuffer )
+ rtl_freeMemory( m_pBuffer );
+ m_pBuffer = 0;
+ }
+
+ sal_uInt32 getBufSizeInSymbols()
+ {
+ return m_nCharNum;
+ }
+
+ operator T* ()
+ {
+ return m_pBuffer;
+ }
+
+};
+
+ template< class U, class T > U mingw_reinterpret_cast(LongPathBuffer<T>&
a) { return reinterpret_cast<U>(static_cast<T*>(a)); }
+
+} // end namespace osl
+
+#endif
Added: openoffice/branches/olcProfileNano/sal/osl/w32/profile.cxx
URL:
http://svn.apache.org/viewvc/openoffice/branches/olcProfileNano/sal/osl/w32/profile.cxx?rev=1734003&view=auto
==============================================================================
--- openoffice/branches/olcProfileNano/sal/osl/w32/profile.cxx (added)
+++ openoffice/branches/olcProfileNano/sal/osl/w32/profile.cxx Mon Mar 7
23:34:03 2016
@@ -0,0 +1,2700 @@
+/**************************************************************
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ *************************************************************/
+
+
+
+#include "system.h"
+
+#include "file_url.h"
+#include "path_helper.hxx"
+
+#include <osl/diagnose.h>
+#include <osl/profile.h>
+#include <osl/process.h>
+#include <osl/file.h>
+#include <osl/util.h>
+#include <rtl/alloc.h>
+#include <algorithm>
+using std::min;
+static inline void copy_ustr_n( void *dest, const void *source, size_t length
) { rtl_copyMemory(dest, source, length*sizeof(sal_Unicode)); }
+
+#define LINES_INI 32
+#define LINES_ADD 10
+#define SECTIONS_INI 5
+#define SECTIONS_ADD 3
+#define ENTRIES_INI 5
+#define ENTRIES_ADD 3
+
+
+#define STR_INI_EXTENSION L".ini"
+#define STR_INI_METAHOME "?~"
+#define STR_INI_METASYS "?$"
+#define STR_INI_METACFG "?^"
+#define STR_INI_METAINS "?#"
+
+#define STR_INI_BOOLYES "yes"
+#define STR_INI_BOOLON "on"
+#define STR_INI_BOOLONE "1"
+#define STR_INI_BOOLNO "no"
+#define STR_INI_BOOLOFF "off"
+#define STR_INI_BOOLZERO "0"
+
+#define FLG_USER 0x00FF
+#define FLG_AUTOOPEN 0x0100
+#define FLG_MODIFIED 0x0200
+
+#define SVERSION_LOCATION STR_INI_METACFG
+#define SVERSION_FALLBACK STR_INI_METASYS
+#define SVERSION_NAME "sversion"
+#define SVERSION_SECTION "Versions"
+#define SVERSION_SOFFICE "StarOffice"
+#define SVERSION_PROFILE "soffice.ini"
+#define SVERSION_OPTION "userid:"
+#define SVERSION_DIRS { "bin", "program" }
+#define SVERSION_USER "user"
+
+#define DEFAULT_PMODE (_S_IREAD | _S_IWRITE)
+
+#define _BUILD_STR_(n) # n
+#define BUILD_STR(n) _BUILD_STR_(n)
+
+
+/*#define DEBUG_OSL_PROFILE 1*/
+/*#define TRACE_OSL_PROFILE 1*/
+
+
+/*****************************************************************************/
+/* Data Type Definition */
+/*****************************************************************************/
+
+typedef FILETIME osl_TStamp;
+
+typedef enum _osl_TLockMode
+{
+ un_lock, read_lock, write_lock
+} osl_TLockMode;
+
+typedef struct _osl_TFile
+{
+ HANDLE m_Handle;
+ sal_Char* m_pReadPtr;
+ sal_Char m_ReadBuf[512];
+/* sal_Char* m_pWritePtr; */
+/* sal_Char m_WriteBuf[512]; */
+ sal_Char* m_pWriteBuf;
+ sal_uInt32 m_nWriteBufLen;
+ sal_uInt32 m_nWriteBufFree;
+} osl_TFile;
+
+typedef struct _osl_TProfileEntry
+{
+ sal_uInt32 m_Line;
+ sal_uInt32 m_Offset;
+ sal_uInt32 m_Len;
+} osl_TProfileEntry;
+
+typedef struct _osl_TProfileSection
+{
+ sal_uInt32 m_Line;
+ sal_uInt32 m_Offset;
+ sal_uInt32 m_Len;
+ sal_uInt32 m_NoEntries;
+ sal_uInt32 m_MaxEntries;
+ osl_TProfileEntry* m_Entries;
+} osl_TProfileSection;
+
+
+/*
+ Profile-data structure hidden behind oslProfile:
+*/
+typedef struct _osl_TProfileImpl
+{
+ sal_uInt32 m_Flags;
+ osl_TFile* m_pFile;
+ osl_TStamp m_Stamp;
+ sal_uInt32 m_NoLines;
+ sal_uInt32 m_MaxLines;
+ sal_uInt32 m_NoSections;
+ sal_uInt32 m_MaxSections;
+ sal_Char** m_Lines;
+ rtl_uString *m_strFileName;
+ osl_TProfileSection* m_Sections;
+} osl_TProfileImpl;
+
+
+/*****************************************************************************/
+/* Static Module Function Declarations */
+/*****************************************************************************/
+
+static osl_TFile* openFileImpl(rtl_uString * strFileName,
oslProfileOption ProfileFlags );
+static osl_TStamp closeFileImpl(osl_TFile* pFile);
+static sal_Bool lockFile(const osl_TFile* pFile, osl_TLockMode
eMode);
+static sal_Bool rewindFile(osl_TFile* pFile, sal_Bool bTruncate);
+static osl_TStamp getFileStamp(osl_TFile* pFile);
+
+static sal_Bool getLine(osl_TFile* pFile, const sal_Char *pszLine,
int MaxLen);
+static sal_Bool putLine(osl_TFile* pFile, const sal_Char *pszLine);
+static const sal_Char* stripBlanks(const sal_Char* String, sal_uInt32*
pLen);
+static const sal_Char* addLine(osl_TProfileImpl* pProfile, const
sal_Char* Line);
+static const sal_Char* insertLine(osl_TProfileImpl* pProfile, const
sal_Char* Line, sal_uInt32 LineNo);
+static void removeLine(osl_TProfileImpl* pProfile, sal_uInt32
LineNo);
+static void setEntry(osl_TProfileImpl* pProfile,
osl_TProfileSection* pSection,
+ sal_uInt32 NoEntry, sal_uInt32 Line,
+ const sal_Char* Entry, sal_uInt32 Len);
+static sal_Bool addEntry(osl_TProfileImpl* pProfile,
osl_TProfileSection *pSection,
+ int Line, const sal_Char* Entry,
sal_uInt32 Len);
+static void removeEntry(osl_TProfileSection *pSection,
sal_uInt32 NoEntry);
+static sal_Bool addSection(osl_TProfileImpl* pProfile, int Line,
const sal_Char* Section, sal_uInt32 Len);
+static void removeSection(osl_TProfileImpl* pProfile,
osl_TProfileSection *pSection);
+static osl_TProfileSection* findEntry(osl_TProfileImpl* pProfile, const
sal_Char* Section,
+ const sal_Char* Entry, sal_uInt32
*pNoEntry);
+static sal_Bool loadProfile(osl_TFile* pFile, osl_TProfileImpl*
pProfile);
+static sal_Bool storeProfile(osl_TProfileImpl* pProfile, sal_Bool
bCleanup);
+static osl_TProfileImpl* acquireProfile(oslProfile Profile, sal_Bool
bWriteable);
+static sal_Bool releaseProfile(osl_TProfileImpl* pProfile);
+static sal_Bool lookupProfile(const sal_Unicode *strPath, const
sal_Unicode *strFile, sal_Unicode *strProfile);
+
+static sal_Bool writeProfileImpl (osl_TFile* pFile);
+static osl_TFile* osl_openTmpProfileImpl(osl_TProfileImpl*);
+static sal_Bool osl_ProfileSwapProfileNames(osl_TProfileImpl*);
+static rtl_uString* osl_ProfileGenerateExtension(rtl_uString* ustrFileName,
rtl_uString* ustrExtension);
+
+static sal_Bool SAL_CALL osl_getProfileName(rtl_uString* strPath, rtl_uString*
strName, rtl_uString** strProfileName);
+
+/*****************************************************************************/
+/* Exported Module Functions */
+/*****************************************************************************/
+
+oslProfile SAL_CALL osl_openProfile(rtl_uString *strProfileName, sal_uInt32
Flags)
+{
+ osl_TFile* pFile = NULL;
+ osl_TProfileImpl* pProfile;
+ rtl_uString *FileName=NULL;
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("In osl_openProfile\n");
+#endif
+ OSL_VERIFY(strProfileName);
+
+ if (rtl_uString_getLength(strProfileName) == 0 )
+ {
+ OSL_VERIFY(osl_getProfileName(NULL, NULL, &FileName));
+ }
+ else
+ {
+ rtl_uString_assign(&FileName, strProfileName);
+ }
+
+
+ osl_getSystemPathFromFileURL(FileName, &FileName);
+
+
+#ifdef DEBUG_OSL_PROFILE
+ Flags=osl_Profile_FLUSHWRITE;
+
+ // OSL_TRACE("opening '%s'\n",FileName);
+ if ( Flags == osl_Profile_DEFAULT )
+ {
+ OSL_TRACE("with osl_Profile_DEFAULT \n");
+ }
+ if ( Flags & osl_Profile_SYSTEM )
+ {
+ OSL_TRACE("with osl_Profile_SYSTEM \n");
+ }
+ if ( Flags & osl_Profile_READLOCK )
+ {
+ OSL_TRACE("with osl_Profile_READLOCK \n");
+ }
+ if ( Flags & osl_Profile_WRITELOCK )
+ {
+ OSL_TRACE("with osl_Profile_WRITELOCK \n");
+ }
+/* if ( Flags & osl_Profile_READWRITE ) */
+/* { */
+/* OSL_TRACE("with osl_Profile_READWRITE \n"); */
+/* } */
+ if ( Flags & osl_Profile_FLUSHWRITE )
+ {
+ OSL_TRACE("with osl_Profile_FLUSHWRITE \n");
+ }
+#endif
+
+ if ( (! (Flags & osl_Profile_SYSTEM)) && ( (pFile = openFileImpl(FileName,
Flags) ) == NULL ) )
+ {
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_openProfile [not opened]\n");
+#endif
+ if( FileName)
+ rtl_uString_release( FileName);
+
+ return (NULL);
+ }
+
+
+ pProfile = (osl_TProfileImpl*)calloc(1, sizeof(osl_TProfileImpl));
+
+
+ pProfile->m_Flags = Flags & FLG_USER;
+ osl_getSystemPathFromFileURL(strProfileName, &pProfile->m_strFileName);
+// rtl_uString_assign(&pProfile->m_strFileName, strProfileName);
+
+ if (Flags & (osl_Profile_READLOCK | osl_Profile_WRITELOCK |
osl_Profile_FLUSHWRITE ))
+ pProfile->m_pFile = pFile;
+
+ pProfile->m_Stamp = getFileStamp(pFile);
+
+ loadProfile(pFile, pProfile);
+
+ if (pProfile->m_pFile == NULL)
+ closeFileImpl(pFile);
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_openProfile [ok]\n");
+#endif
+ if( FileName)
+ rtl_uString_release( FileName);
+
+ return (pProfile);
+}
+
+sal_Bool SAL_CALL osl_closeProfile(oslProfile Profile)
+{
+ osl_TProfileImpl* pProfile = (osl_TProfileImpl*)Profile;
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("In osl_closeProfile\n");
+#endif
+
+ if ( Profile == 0 )
+ {
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_closeProfile [profile==0]\n");
+#endif
+ return sal_False;
+ }
+
+ if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
+ {
+ pProfile = acquireProfile(Profile,sal_True);
+
+ if ( pProfile != 0 )
+ {
+ if ( !( pProfile->m_Flags & osl_Profile_READLOCK ) &&
( pProfile->m_Flags & FLG_MODIFIED ) )
+ {
+/* if (pProfile->m_pFile == NULL) */
+/* pProfile->m_pFile =
openFileImpl(pProfile->m_Filename, sal_True); */
+
+ storeProfile(pProfile, sal_False);
+ }
+ }
+ else
+ {
+ pProfile = acquireProfile(Profile,sal_False);
+ }
+
+ if ( pProfile == 0 )
+ {
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_closeProfile [pProfile==0]\n");
+#endif
+ return sal_False;
+ }
+
+ if (pProfile->m_pFile != NULL)
+ closeFileImpl(pProfile->m_pFile);
+ }
+
+ pProfile->m_pFile = NULL;
+ rtl_uString_release(pProfile->m_strFileName);
+ pProfile->m_strFileName = NULL;
+
+ /* release whole profile data types memory */
+ if ( pProfile->m_NoLines > 0)
+ {
+ unsigned int index=0;
+ if ( pProfile->m_Lines != 0 )
+ {
+ for ( index = 0 ; index < pProfile->m_NoLines ; ++index)
+ {
+ if ( pProfile->m_Lines[index] != 0 )
+ {
+ free(pProfile->m_Lines[index]);
+ }
+ }
+ free(pProfile->m_Lines);
+ }
+ if ( pProfile->m_Sections != 0 )
+ {
+ /*osl_TProfileSection* pSections=pProfile->m_Sections;*/
+ for ( index = 0 ; index < pProfile->m_NoSections ;
++index )
+ {
+ if ( pProfile->m_Sections[index].m_Entries != 0
)
+ {
+
free(pProfile->m_Sections[index].m_Entries);
+ }
+ }
+ free(pProfile->m_Sections);
+ }
+
+ }
+ free(pProfile);
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_closeProfile [ok]\n");
+#endif
+ return (sal_True);
+}
+
+
+sal_Bool SAL_CALL osl_flushProfile(oslProfile Profile)
+{
+ osl_TProfileImpl* pProfile = (osl_TProfileImpl*) Profile;
+ osl_TFile* pFile;
+ sal_Bool bRet = sal_False;
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("In osl_flushProfile()\n");
+#endif
+
+ if ( pProfile == 0 )
+ {
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_flushProfile() [pProfile == 0]\n");
+#endif
+ return sal_False;
+ }
+
+ pFile = pProfile->m_pFile;
+ if ( !( pFile != 0 && pFile->m_Handle >= 0 ) )
+ {
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_flushProfile() [invalid file]\n");
+#endif
+ return sal_False;
+ }
+
+ if ( pProfile->m_Flags & FLG_MODIFIED )
+ {
+#ifdef DEBUG_OSL_PROFILE
+ OSL_TRACE("swapping to storeprofile\n");
+#endif
+ bRet = storeProfile(pProfile,sal_False);
+ }
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_flushProfile() [ok]\n");
+#endif
+ return bRet;
+}
+
+static sal_Bool writeProfileImpl(osl_TFile* pFile)
+{
+ DWORD BytesWritten=0;
+ BOOL bRet;
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("In osl_writeProfileImpl()\n");
+#endif
+
+ if ( !( pFile != 0 && pFile->m_Handle != INVALID_HANDLE_VALUE ) || (
pFile->m_pWriteBuf == 0 ) )
+ {
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_writeProfileImpl() [invalid args]\n");
+#endif
+ return sal_False;
+ }
+
+#ifdef DEBUG_OSL_PROFILE
+/* OSL_TRACE("File Buffer in writeProfileImpl '%s' size == '%i' '%i'(%i)\n",
+
pFile->m_pWriteBuf,pFile->m_nWriteBufLen,strlen(pFile->m_pWriteBuf),pFile->m_nWriteBufLen
- pFile->m_nWriteBufFree);*/
+#endif
+
+ bRet=WriteFile(pFile->m_Handle, pFile->m_pWriteBuf, pFile->m_nWriteBufLen
- pFile->m_nWriteBufFree,&BytesWritten,NULL);
+
+ if ( bRet == 0 || BytesWritten <= 0 )
+ {
+ OSL_ENSURE(bRet,"WriteFile failed!!!");
+
+ OSL_TRACE("write failed '%s'\n",strerror(errno));
+
+/* OSL_TRACE("Out osl_writeProfileImpl() [write
'%s']\n",strerror(errno));*/
+ return (sal_False);
+ }
+
+ free(pFile->m_pWriteBuf);
+ pFile->m_pWriteBuf=0;
+ pFile->m_nWriteBufLen=0;
+ pFile->m_nWriteBufFree=0;
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_writeProfileImpl() [ok]\n");
+#endif
+ return sal_True;
+}
+
+
+sal_Bool SAL_CALL osl_readProfileString(oslProfile Profile,
+ const sal_Char*
pszSection, const sal_Char* pszEntry,
+ sal_Char* pszString,
sal_uInt32 MaxLen,
+ const sal_Char*
pszDefault)
+{
+ sal_uInt32 NoEntry;
+ const sal_Char* pStr = 0;
+ osl_TProfileSection* pSec;
+ osl_TProfileImpl* pProfile = 0;
+
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("In osl_readProfileString\n");
+#endif
+
+ pProfile = acquireProfile(Profile, sal_False);
+
+ if (pProfile == NULL)
+ {
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_readProfileString [pProfile==0]\n");
+#endif
+
+
+ return (sal_False);
+ }
+
+
+ if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
+ {
+ if (((pSec = findEntry(pProfile, pszSection, pszEntry,
&NoEntry)) != NULL) &&
+ (NoEntry < pSec->m_NoEntries) &&
+ ((pStr =
strchr(pProfile->m_Lines[pSec->m_Entries[NoEntry].m_Line],
+ '=')) != NULL))
+ pStr++;
+ else
+ pStr = pszDefault;
+
+ if ( pStr != 0 )
+ {
+ pStr = stripBlanks(pStr, NULL);
+ MaxLen = (MaxLen - 1 < strlen(pStr)) ? (MaxLen - 1) :
strlen(pStr);
+ pStr = stripBlanks(pStr, &MaxLen);
+ strncpy(pszString, pStr, MaxLen);
+ pszString[MaxLen] = '\0';
+ }
+ }
+ else
+ {
+ ::osl::LongPathBuffer< sal_Char > aFileName( MAX_LONG_PATH );
+
+ WideCharToMultiByte(CP_ACP,0,
reinterpret_cast<LPCWSTR>(pProfile->m_strFileName->buffer), -1, aFileName,
aFileName.getBufSizeInSymbols(), NULL, NULL);
+ GetPrivateProfileString(pszSection, pszEntry, pszDefault,
pszString, MaxLen, aFileName);
+ }
+
+ releaseProfile(pProfile);
+
+ if ( pStr == 0 )
+ {
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_readProfileString [pStr==0]\n");
+#endif
+
+
+ return (sal_False);
+ }
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_readProfileString [ok]\n");
+#endif
+
+
+
+
+ return (sal_True);
+}
+
+
+sal_Bool SAL_CALL osl_readProfileBool(oslProfile Profile,
+ const sal_Char*
pszSection, const sal_Char* pszEntry,
+ sal_Bool Default)
+{
+ sal_Char Line[32];
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("In osl_readProfileBool\n");
+#endif
+
+ if (osl_readProfileString(Profile, pszSection, pszEntry, Line,
sizeof(Line), ""))
+ {
+ if ((stricmp(Line, STR_INI_BOOLYES) == 0) ||
+ (stricmp(Line, STR_INI_BOOLON) == 0) ||
+ (stricmp(Line, STR_INI_BOOLONE) == 0))
+ Default = sal_True;
+ else
+ if ((stricmp(Line, STR_INI_BOOLNO) == 0) ||
+ (stricmp(Line, STR_INI_BOOLOFF) == 0) ||
+ (stricmp(Line, STR_INI_BOOLZERO) == 0))
+ Default = sal_False;
+ }
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_readProfileBool [ok]\n");
+#endif
+
+ return (Default);
+}
+
+
+sal_uInt32 SAL_CALL osl_readProfileIdent(oslProfile Profile,
+ const sal_Char*
pszSection, const sal_Char* pszEntry,
+ sal_uInt32 FirstId,
const sal_Char* Strings[],
+ sal_uInt32 Default)
+{
+ sal_uInt32 i;
+ sal_Char Line[256];
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("In osl_readProfileIdent\n");
+#endif
+
+ if (osl_readProfileString(Profile, pszSection, pszEntry, Line,
sizeof(Line), ""))
+ {
+ i = 0;
+ while (Strings[i] != NULL)
+ {
+ if (stricmp(Line, Strings[i]) == 0)
+ {
+ Default = i + FirstId;
+ break;
+ }
+ i++;
+ }
+ }
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_readProfileIdent [ok]\n");
+#endif
+ return (Default);
+}
+
+sal_Bool SAL_CALL osl_writeProfileString(oslProfile Profile,
+ const sal_Char*
pszSection, const sal_Char* pszEntry,
+ const sal_Char*
pszString)
+{
+ sal_uInt32 i;
+ sal_Bool bRet = sal_False;
+ sal_uInt32 NoEntry;
+ const sal_Char* pStr;
+ sal_Char Line[4096];
+ osl_TProfileSection* pSec;
+ osl_TProfileImpl* pProfile = 0;
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("In osl_writeProfileString\n");
+#endif
+
+ pProfile = acquireProfile(Profile, sal_True);
+
+ if (pProfile == NULL)
+ {
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_writeProfileString [pProfile==0]\n");
+#endif
+ return (sal_False);
+ }
+
+
+ if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
+ {
+ if ((pSec = findEntry(pProfile, pszSection, pszEntry,
&NoEntry)) == NULL)
+ {
+ Line[0] = '\0';
+ addLine(pProfile, Line);
+
+ Line[0] = '[';
+ strcpy(&Line[1], pszSection);
+ Line[1 + strlen(pszSection)] = ']';
+ Line[2 + strlen(pszSection)] = '\0';
+
+ if (((pStr = addLine(pProfile, Line)) == NULL) ||
+ (! addSection(pProfile, pProfile->m_NoLines -
1, &pStr[1], strlen(pszSection))))
+ {
+ releaseProfile(pProfile);
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_writeProfileString [not added]\n");
+#endif
+ return (sal_False);
+ }
+
+ pSec = &pProfile->m_Sections[pProfile->m_NoSections -
1];
+ NoEntry = pSec->m_NoEntries;
+ }
+
+ Line[0] = '\0';
+ strcpy(&Line[0], pszEntry);
+ Line[0 + strlen(pszEntry)] = '=';
+ strcpy(&Line[1 + strlen(pszEntry)], pszString);
+
+ if (NoEntry >= pSec->m_NoEntries)
+ {
+ if (pSec->m_NoEntries > 0)
+ i = pSec->m_Entries[pSec->m_NoEntries -
1].m_Line + 1;
+ else
+ i = pSec->m_Line + 1;
+
+ if (((pStr = insertLine(pProfile, Line, i)) == NULL) ||
+ (! addEntry(pProfile, pSec, i, pStr,
strlen(pszEntry))))
+ {
+ releaseProfile(pProfile);
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_writeProfileString [not inserted]\n");
+#endif
+ return (sal_False);
+ }
+
+ pProfile->m_Flags |= FLG_MODIFIED;
+ }
+ else
+ {
+ i = pSec->m_Entries[NoEntry].m_Line;
+ free(pProfile->m_Lines[i]);
+ pProfile->m_Lines[i] = strdup(Line);
+ setEntry(pProfile, pSec, NoEntry, i,
pProfile->m_Lines[i], strlen(pszEntry));
+
+ pProfile->m_Flags |= FLG_MODIFIED;
+ }
+ }
+ else
+ {
+ ::osl::LongPathBuffer< sal_Char > aFileName( MAX_LONG_PATH );
+
+ WideCharToMultiByte(CP_ACP,0,
reinterpret_cast<LPCWSTR>(pProfile->m_strFileName->buffer), -1, aFileName,
aFileName.getBufSizeInSymbols(), NULL, NULL);
+ WritePrivateProfileString(pszSection, pszEntry, pszString,
aFileName);
+ }
+
+ bRet = releaseProfile(pProfile);
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_writeProfileString [ok]\n");
+#endif
+ return bRet;
+}
+
+
+sal_Bool SAL_CALL osl_writeProfileBool(oslProfile Profile,
+ const sal_Char*
pszSection, const sal_Char* pszEntry,
+ sal_Bool Value)
+{
+ sal_Bool bRet = sal_False;
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("In osl_writeProfileBool\n");
+#endif
+
+ if (Value)
+ bRet=osl_writeProfileString(Profile, pszSection, pszEntry,
STR_INI_BOOLONE);
+ else
+ bRet=osl_writeProfileString(Profile, pszSection, pszEntry,
STR_INI_BOOLZERO);
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_writeProfileBool [ok]\n");
+#endif
+
+ return bRet;
+}
+
+
+sal_Bool SAL_CALL osl_writeProfileIdent(oslProfile Profile,
+ const sal_Char*
pszSection, const sal_Char* pszEntry,
+ sal_uInt32 FirstId,
const sal_Char* Strings[],
+ sal_uInt32 Value)
+{
+ int i, n;
+ sal_Bool bRet = sal_False;
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("In osl_writeProfileIdent\n");
+#endif
+
+ for (n = 0; Strings[n] != NULL; n++);
+
+ if ((i = Value - FirstId) >= n)
+ bRet=sal_False;
+ else
+ bRet=osl_writeProfileString(Profile, pszSection, pszEntry,
Strings[i]);
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_writeProfileIdent\n");
+#endif
+ return bRet;
+}
+
+
+sal_Bool SAL_CALL osl_removeProfileEntry(oslProfile Profile,
+ const sal_Char
*pszSection, const sal_Char *pszEntry)
+{
+ sal_uInt32 NoEntry;
+ osl_TProfileSection* pSec;
+ osl_TProfileImpl* pProfile = 0;
+ sal_Bool bRet = sal_False;
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("In osl_removeProfileEntry\n");
+#endif
+
+ pProfile = acquireProfile(Profile, sal_True);
+
+ if (pProfile == NULL)
+ {
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_removeProfileEntry [pProfile==0]\n");
+#endif
+
+
+ return (sal_False);
+ }
+
+
+ if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
+ {
+ if (((pSec = findEntry(pProfile, pszSection, pszEntry,
&NoEntry)) != NULL) &&
+ (NoEntry < pSec->m_NoEntries))
+ {
+ removeLine(pProfile, pSec->m_Entries[NoEntry].m_Line);
+ removeEntry(pSec, NoEntry);
+ if (pSec->m_NoEntries == 0)
+ {
+ removeLine(pProfile, pSec->m_Line);
+
+ /* remove any empty separation line */
+ if ((pSec->m_Line > 0) &&
(pProfile->m_Lines[pSec->m_Line - 1][0] == '\0'))
+ removeLine(pProfile, pSec->m_Line - 1);
+
+ removeSection(pProfile, pSec);
+ }
+
+ pProfile->m_Flags |= FLG_MODIFIED;
+ }
+ }
+ else
+ {
+ ::osl::LongPathBuffer< sal_Char > aFileName( MAX_LONG_PATH );
+
+ WideCharToMultiByte(CP_ACP,0,
reinterpret_cast<LPCWSTR>(pProfile->m_strFileName->buffer), -1, aFileName,
aFileName.getBufSizeInSymbols(), NULL, NULL);
+ WritePrivateProfileString(pszSection, pszEntry, NULL,
aFileName);
+ }
+
+ bRet = releaseProfile(pProfile);
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_removeProfileEntry [ok]\n");
+#endif
+ return bRet;
+}
+
+
+sal_uInt32 SAL_CALL osl_getProfileSectionEntries(oslProfile Profile, const
sal_Char *pszSection,
+ sal_Char*
pszBuffer, sal_uInt32 MaxLen)
+{
+ sal_uInt32 i, n = 0;
+ sal_uInt32 NoEntry;
+ osl_TProfileSection* pSec;
+ osl_TProfileImpl* pProfile = 0;
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("In osl_getProfileSectionEntries\n");
+#endif
+
+ pProfile = acquireProfile(Profile, sal_False);
+
+ if (pProfile == NULL)
+ {
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_getProfileSectionEntries [pProfile=0]\n");
+#endif
+
+
+ return (0);
+ }
+
+
+ if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
+ {
+ if ((pSec = findEntry(pProfile, pszSection, "", &NoEntry)) !=
NULL)
+ {
+ if (MaxLen != 0)
+ {
+ for (i = 0; i < pSec->m_NoEntries; i++)
+ {
+ if ((n + pSec->m_Entries[i].m_Len + 1)
< MaxLen)
+ {
+ strncpy(&pszBuffer[n],
&pProfile->m_Lines[pSec->m_Entries[i].m_Line]
+
[pSec->m_Entries[i].m_Offset], pSec->m_Entries[i].m_Len);
+ n += pSec->m_Entries[i].m_Len;
+ pszBuffer[n++] = '\0';
+ }
+ else
+ break;
+
+ }
+
+ pszBuffer[n++] = '\0';
+ }
+ else
+ {
+ for (i = 0; i < pSec->m_NoEntries; i++)
+ n += pSec->m_Entries[i].m_Len + 1;
+
+ n += 1;
+ }
+ }
+ else
+ n = 0;
+ }
+ else
+ {
+ ::osl::LongPathBuffer< sal_Char > aFileName( MAX_LONG_PATH );
+
+ WideCharToMultiByte(CP_ACP,0,
reinterpret_cast<LPCWSTR>(pProfile->m_strFileName->buffer), -1, aFileName,
aFileName.getBufSizeInSymbols(), NULL, NULL);
+ n = GetPrivateProfileString(pszSection, NULL, NULL, pszBuffer,
MaxLen, aFileName);
+ }
+
+ releaseProfile(pProfile);
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out osl_getProfileSectionEntries [ok]\n");
+#endif
+
+ return (n);
+}
+
+
+sal_Bool SAL_CALL osl_getProfileName(rtl_uString* strPath, rtl_uString*
strName, rtl_uString** strProfileName)
+{
+ sal_Bool bFailed;
+ ::osl::LongPathBuffer< sal_Unicode > aFile( MAX_LONG_PATH );
+ ::osl::LongPathBuffer< sal_Unicode > aPath( MAX_LONG_PATH );
+ sal_uInt32 nFileLen = 0;
+ sal_uInt32 nPathLen = 0;
+
+ rtl_uString * strTmp = NULL;
+ oslFileError nError;
+
+ /* build file name */
+ if (strName && strName->length)
+ {
+ if( ::sal::static_int_cast< sal_uInt32 >( strName->length ) >=
aFile.getBufSizeInSymbols() )
+ return sal_False;
+
+ copy_ustr_n( aFile, strName->buffer, strName->length+1);
+ nFileLen = strName->length;
+
+ if (rtl_ustr_indexOfChar( aFile, L'.' ) == -1)
+ {
+ if (nFileLen + wcslen(STR_INI_EXTENSION) >=
aFile.getBufSizeInSymbols())
+ return sal_False;
+
+ /* add default extension */
+ copy_ustr_n( aFile + nFileLen, STR_INI_EXTENSION,
wcslen(STR_INI_EXTENSION)+1 );
+ nFileLen += wcslen(STR_INI_EXTENSION);
+ }
+ }
+ else
+ {
+ rtl_uString *strProgName = NULL;
+ sal_Unicode *pProgName;
+ sal_Int32 nOffset = 0;
+ sal_Int32 nLen;
+ sal_Int32 nPos;
+
+ if (osl_getExecutableFile(&strProgName) != osl_Process_E_None)
+ return sal_False;
+
+ /* remove path and extension from filename */
+ pProgName = strProgName->buffer;
+ nLen = strProgName->length ;
+
+ if ((nPos = rtl_ustr_lastIndexOfChar( pProgName, L'/' )) != -1)
+ nOffset = nPos + 1;
+ else if ((nPos = rtl_ustr_lastIndexOfChar( pProgName, L':' ))
!= -1)
+ nOffset = nPos + 1;
+
+ if ((nPos = rtl_ustr_lastIndexOfChar( pProgName, L'.' )) != -1 )
+ nLen -= 4;
+
+ if ((nFileLen = nLen - nOffset) >= aFile.getBufSizeInSymbols())
+ return sal_False;
+
+ copy_ustr_n(aFile, pProgName + nOffset, nFileLen);
+
+ if (nFileLen + wcslen(STR_INI_EXTENSION) >=
aFile.getBufSizeInSymbols())
+ return sal_False;
+
+ /* add default extension */
+ copy_ustr_n(aFile + nFileLen, STR_INI_EXTENSION,
wcslen(STR_INI_EXTENSION)+1);
+ nFileLen += wcslen(STR_INI_EXTENSION);
+
+ rtl_uString_release( strProgName );
+ }
+
+ if (aFile[0] == 0)
+ return sal_False;
+
+ /* build directory path */
+ if (strPath && strPath->length)
+ {
+ sal_Unicode *pPath = rtl_uString_getStr(strPath);
+ sal_Int32 nLen = rtl_uString_getLength(strPath);
+
+ if ((rtl_ustr_ascii_compare_WithLength(pPath,
RTL_CONSTASCII_LENGTH(STR_INI_METAHOME) , STR_INI_METAHOME) == 0) &&
+ ((nLen == RTL_CONSTASCII_LENGTH(STR_INI_METAHOME)) ||
(pPath[RTL_CONSTASCII_LENGTH(STR_INI_METAHOME)] == '/')))
+ {
+ rtl_uString * strHome = NULL;
+ oslSecurity security = osl_getCurrentSecurity();
+
+ bFailed = ! osl_getHomeDir(security, &strHome);
+ osl_freeSecurityHandle(security);
+
+ if (bFailed) return (sal_False);
+
+ if ( ::sal::static_int_cast< sal_uInt32 >(
strHome->length ) >= aPath.getBufSizeInSymbols())
+ return sal_False;
+
+ copy_ustr_n( aPath, strHome->buffer, strHome->length+1);
+ nPathLen = strHome->length;
+
+ if (nLen > RTL_CONSTASCII_LENGTH(STR_INI_METAHOME))
+ {
+ pPath +=
RTL_CONSTASCII_LENGTH(STR_INI_METAHOME);
+ nLen -= RTL_CONSTASCII_LENGTH(STR_INI_METAHOME);
+
+ if (nLen + nPathLen >=
aPath.getBufSizeInSymbols())
+ return sal_False;
+
+ copy_ustr_n(aPath + nPathLen, pPath, nLen+1);
+ nPathLen += nLen;
+ }
+
+ rtl_uString_release(strHome);
+ }
+
+ else if ((rtl_ustr_ascii_compare_WithLength(pPath,
RTL_CONSTASCII_LENGTH(STR_INI_METACFG), STR_INI_METACFG) == 0) &&
+ ((nLen == RTL_CONSTASCII_LENGTH(STR_INI_METACFG)) ||
(pPath[RTL_CONSTASCII_LENGTH(STR_INI_METACFG)] == '/')))
+ {
+ rtl_uString * strConfig = NULL;
+ oslSecurity security = osl_getCurrentSecurity();
+
+ bFailed = ! osl_getConfigDir(security, &strConfig);
+ osl_freeSecurityHandle(security);
+
+ if (bFailed) return (sal_False);
+
+ if ( ::sal::static_int_cast< sal_uInt32 >(
strConfig->length ) >= aPath.getBufSizeInSymbols())
+ return sal_False;
+
+ copy_ustr_n( aPath, strConfig->buffer,
strConfig->length+1 );
+ nPathLen = strConfig->length;
+
+ if (nLen > RTL_CONSTASCII_LENGTH(STR_INI_METACFG))
+ {
+ pPath += RTL_CONSTASCII_LENGTH(STR_INI_METACFG);
+ nLen -= RTL_CONSTASCII_LENGTH(STR_INI_METACFG);
+
+ if (nLen + nPathLen >=
aPath.getBufSizeInSymbols())
+ return sal_False;
+
+ copy_ustr_n(aPath + nPathLen, pPath, nLen+1);
+ nPathLen += nLen;
+ }
+
+ rtl_uString_release(strConfig);
+ }
+
+ else if ((rtl_ustr_ascii_compare_WithLength(pPath,
RTL_CONSTASCII_LENGTH(STR_INI_METASYS), STR_INI_METASYS) == 0) &&
+ ((nLen == RTL_CONSTASCII_LENGTH(STR_INI_METASYS)) ||
(pPath[RTL_CONSTASCII_LENGTH(STR_INI_METASYS)] == '/')))
+ {
+ if (((nPathLen =
GetWindowsDirectoryW(::osl::mingw_reinterpret_cast<LPWSTR>(aPath),
aPath.getBufSizeInSymbols())) == 0) || (nPathLen >=
aPath.getBufSizeInSymbols()))
+ return (sal_False);
+
+ if (nLen > RTL_CONSTASCII_LENGTH(STR_INI_METASYS))
+ {
+ pPath += RTL_CONSTASCII_LENGTH(STR_INI_METASYS);
+ nLen -= RTL_CONSTASCII_LENGTH(STR_INI_METASYS);
+
+ if (nLen + nPathLen >=
aPath.getBufSizeInSymbols())
+ return sal_False;
+
+ copy_ustr_n(aPath + nPathLen, pPath, nLen+1);
+ nPathLen += nLen;
+ }
+ }
+
+ else if ((rtl_ustr_ascii_compare_WithLength(pPath,
RTL_CONSTASCII_LENGTH(STR_INI_METAINS), STR_INI_METAINS) == 0) &&
+ ((nLen == RTL_CONSTASCII_LENGTH(STR_INI_METAINS)) ||
(pPath[RTL_CONSTASCII_LENGTH(STR_INI_METAINS)] == '/') ||
+ (pPath[RTL_CONSTASCII_LENGTH(STR_INI_METAINS)] == '"') ) )
+ {
+ if (! lookupProfile(pPath +
RTL_CONSTASCII_LENGTH(STR_INI_METAINS), aFile, aPath))
+ return (sal_False);
+
+ nPathLen = rtl_ustr_getLength(aPath);
+ }
+
+ else if( ::sal::static_int_cast< sal_uInt32 >( nLen ) <
aPath.getBufSizeInSymbols())
+ {
+ copy_ustr_n(aPath, pPath, nLen+1);
+ nPathLen = rtl_ustr_getLength(aPath);
+ }
+ else
+ return sal_False;
+ }
+ else
+ {
+ rtl_uString * strConfigDir = NULL;
+ oslSecurity security = osl_getCurrentSecurity();
+
+ bFailed = ! osl_getConfigDir(security, &strConfigDir);
+ osl_freeSecurityHandle(security);
+
+ if (bFailed) return (sal_False);
+ if ( ::sal::static_int_cast< sal_uInt32 >( strConfigDir->length
) >= aPath.getBufSizeInSymbols() )
+ return sal_False;
+
+ copy_ustr_n(aPath, strConfigDir->buffer,
strConfigDir->length+1);
+ nPathLen = strConfigDir->length;
+ }
+
+ if (nPathLen && (aPath[nPathLen - 1] != L'/') && (aPath[nPathLen - 1]
!= L'\\'))
+ {
+ aPath[nPathLen++] = L'\\';
+ aPath[nPathLen] = 0;
+ }
+
+ if (nPathLen + nFileLen >= aPath.getBufSizeInSymbols())
+ return sal_False;
+
+ /* append file name */
+ copy_ustr_n(aPath + nPathLen, aFile, nFileLen+1);
+ nPathLen += nFileLen;
+
+ /* copy filename */
+ rtl_uString_newFromStr_WithLength(&strTmp, aPath, nPathLen);
+ nError = osl_getFileURLFromSystemPath(strTmp, strProfileName);
+ rtl_uString_release(strTmp);
+
+ return (sal_Bool) (nError == osl_File_E_None);
+}
+
+
+sal_uInt32 SAL_CALL osl_getProfileSections(oslProfile Profile, sal_Char*
pszBuffer, sal_uInt32 MaxLen)
+{
+ sal_uInt32 i, n = 0;
+ osl_TProfileSection* pSec;
+ osl_TProfileImpl* pProfile = acquireProfile(Profile, sal_False);
+
+ if (pProfile == NULL)
+ return (0);
+
+ if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
+ {
+ if (MaxLen != 0)
+ {
+ for (i = 0; i < pProfile->m_NoSections; i++)
+ {
+ pSec = &pProfile->m_Sections[i];
+
+ if ((n + pSec->m_Len + 1) < MaxLen)
+ {
+ strncpy(&pszBuffer[n],
&pProfile->m_Lines[pSec->m_Line][pSec->m_Offset],
+ pSec->m_Len);
+ n += pSec->m_Len;
+ pszBuffer[n++] = '\0';
+ }
+ else
+ break;
+ }
+
+ pszBuffer[n++] = '\0';
+ }
+ else
+ {
+ for (i = 0; i < pProfile->m_NoSections; i++)
+ n += pProfile->m_Sections[i].m_Len + 1;
+
+ n += 1;
+ }
+ }
+ else
+ {
+ ::osl::LongPathBuffer< sal_Char > aFileName( MAX_LONG_PATH );
+
+ WideCharToMultiByte(CP_ACP,0,
reinterpret_cast<LPCWSTR>(pProfile->m_strFileName->buffer), -1, aFileName,
aFileName.getBufSizeInSymbols(), NULL, NULL);
+ n = GetPrivateProfileSectionNames(pszBuffer, MaxLen, aFileName);
+ }
+
+ releaseProfile(pProfile);
+
+ return (n);
+}
+
+
+
+
+/*****************************************************************************/
+/* Static Module Functions */
+/*****************************************************************************/
+
+static osl_TStamp getFileStamp(osl_TFile* pFile)
+{
+ FILETIME FileTime;
+
+ if ((pFile->m_Handle == INVALID_HANDLE_VALUE) ||
+ (! GetFileTime(pFile->m_Handle, NULL, NULL, &FileTime)))
+ memset(&FileTime, 0, sizeof(FileTime));
+
+ return (FileTime);
+}
+
+
+
+static sal_Bool lockFile(const osl_TFile* pFile, osl_TLockMode eMode)
+{
+ sal_Bool status = sal_False;
+ OVERLAPPED Overlapped;
+
+ if (pFile->m_Handle == INVALID_HANDLE_VALUE)
+ return (sal_False);
+
+ memset(&Overlapped, 0, sizeof(Overlapped));
+
+ switch (eMode)
+ {
+ case un_lock:
+ status = (sal_Bool) UnlockFileEx(
+ pFile->m_Handle, 0, 0xFFFFFFFF, 0, &Overlapped);
+ break;
+
+ case read_lock:
+ status = (sal_Bool) LockFileEx(
+ pFile->m_Handle, 0, 0, 0xFFFFFFFF, 0, &Overlapped);
+ break;
+
+ case write_lock:
+ status = (sal_Bool) LockFileEx(
+ pFile->m_Handle, LOCKFILE_EXCLUSIVE_LOCK, 0, 0xFFFFFFFF, 0,
+ &Overlapped);
+ break;
+ }
+
+ return (status);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+static osl_TFile* openFileImpl(rtl_uString * strFileName, oslProfileOption
ProfileFlags )
+{
+ osl_TFile* pFile = reinterpret_cast< osl_TFile*>( calloc( 1,
sizeof(osl_TFile) ) );
+ sal_Bool bWriteable = sal_False;
+
+/* if ( ProfileFlags & ( osl_Profile_WRITELOCK | osl_Profile_FLUSHWRITE |
osl_Profile_READWRITE ) )*/
+ if ( ProfileFlags & ( osl_Profile_WRITELOCK | osl_Profile_FLUSHWRITE ) )
+ {
+#ifdef DEBUG_OSL_PROFILE
+ OSL_TRACE("setting bWriteable to TRUE\n");
+#endif
+ bWriteable=sal_True;
+ }
+
+ if (! bWriteable)
+ {
+#if 0
+//#ifdef DEBUG_OSL_PROFILE
+ OSL_TRACE("opening '%s' read only\n",pszFilename);
+#endif
+
+ pFile->m_Handle = CreateFileW(
reinterpret_cast<LPCWSTR>(rtl_uString_getStr( strFileName )), GENERIC_READ,
+
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+
+ /* mfe: argghh!!! do not check if the file could be openend */
+ /* default mode expects it that way!!! */
+ }
+ else
+ {
+#ifdef DEBUG_OSL_PROFILE
+ OSL_TRACE("opening '%s' read/write\n",pszFilename);
+#endif
+
+ if ((pFile->m_Handle = CreateFileW(
reinterpret_cast<LPCWSTR>(rtl_uString_getStr( strFileName )), GENERIC_READ |
GENERIC_WRITE,
+
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
+
OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL))
+ == INVALID_HANDLE_VALUE)
+ {
+ free(pFile);
+ return (NULL);
+ }
+ }
+
+ pFile->m_pWriteBuf=0;
+ pFile->m_nWriteBufFree=0;
+ pFile->m_nWriteBufLen=0;
+
+ if ( ProfileFlags & (osl_Profile_WRITELOCK | osl_Profile_READLOCK ) )
+ {
+#ifdef DEBUG_OSL_PROFILE
+ OSL_TRACE("locking '%s' file\n",pszFilename);
+#endif
+
+ lockFile(pFile, bWriteable ? write_lock : read_lock);
+ }
+
+ /* mfe: new WriteBuf obsolete */
+/* pFile->m_pWritePtr = pFile->m_Buf;*/
+/* pFile->m_pReadPtr = pFile->m_ReadBuf + sizeof(pFile->m_ReadBuf);*/
+
+ return (pFile);
+}
+
+
+
+
+
+
+
+
+
+static osl_TStamp closeFileImpl(osl_TFile* pFile)
+{
+ osl_TStamp stamp = {0, 0};
+
+ if ( pFile == 0 )
+ {
+ return stamp;
+ }
+
+ if (pFile->m_Handle != INVALID_HANDLE_VALUE)
+ {
+ /* mfe: new WriteBuf obsolete */
+ /* we just closing the file here, DO NOT write, it has to be handled
in higher levels */
+/* if (pFile->m_pWritePtr > pFile->m_Buf)*/
+/* {*/
+/* DWORD Bytes;*/
+
+/* WriteFile(pFile->m_Handle, pFile->m_WriteBuf,*/
+/* pFile->m_pWritePtr -
pFile->m_WriteBuf,*/
+/* &Bytes, NULL);*/
+/* }*/
+
+ stamp = getFileStamp(pFile);
+
+ lockFile(pFile, un_lock);
+
+ CloseHandle(pFile->m_Handle);
+ pFile->m_Handle = INVALID_HANDLE_VALUE;
+ }
+
+ if ( pFile->m_pWriteBuf != 0 )
+ {
+ free(pFile->m_pWriteBuf);
+ }
+
+ free(pFile);
+
+ return(stamp);
+}
+
+
+
+
+
+
+
+
+static sal_Bool rewindFile(osl_TFile* pFile, sal_Bool bTruncate)
+{
+ if (pFile->m_Handle != INVALID_HANDLE_VALUE)
+ {
+ /* mfe: new WriteBuf obsolete */
+ /* we just closing the file here, DO NOT write, it has to be handled
in higher levels */
+/* if (pFile->m_pWritePtr > pFile->m_WriteBuf)*/
+/* {*/
+/* DWORD Bytes;*/
+
+/* WriteFile(pFile->m_Handle, pFile->m_WriteBuf,*/
+/* pFile->m_pWritePtr -
pFile->m_WriteBuf,*/
+/* &Bytes, NULL);*/
+
+/* pFile->m_pWritePtr = pFile->m_WriteBuf;*/
+/* }*/
+
+ pFile->m_pReadPtr = pFile->m_ReadBuf + sizeof(pFile->m_ReadBuf);
+
+ SetFilePointer(pFile->m_Handle, 0, NULL, FILE_BEGIN);
+
+ if (bTruncate)
+ SetEndOfFile(pFile->m_Handle);
+ }
+
+ return (sal_True);
+}
+
+
+
+
+
+
+
+
+
+
+static sal_Bool getLine(osl_TFile* pFile, const sal_Char *pszLine, int MaxLen)
+{
+ DWORD Max;
+ size_t Free, Bytes;
+ sal_Char* pChr;
+ sal_Char* pLine = (sal_Char *)pszLine;
+
+ if (pFile->m_Handle == INVALID_HANDLE_VALUE)
+ return (sal_False);
+
+ MaxLen -= 1;
+
+ do
+ {
+ Bytes = sizeof(pFile->m_ReadBuf) - (pFile->m_pReadPtr -
pFile->m_ReadBuf);
+
+ if (Bytes <= 1)
+ {
+ /* refill buffer */
+ memcpy(pFile->m_ReadBuf, pFile->m_pReadPtr, Bytes);
+ pFile->m_pReadPtr = pFile->m_ReadBuf;
+
+ Free = sizeof(pFile->m_ReadBuf) - Bytes;
+
+ if (! ReadFile(pFile->m_Handle,
&pFile->m_ReadBuf[Bytes], Free, &Max, NULL))
+ {
+ *pLine = '\0';
+ return (sal_False);
+ }
+
+ if (Max < Free)
+ {
+ if ((Max == 0) && (pLine == pszLine))
+ {
+ *pLine = '\0';
+ return (sal_False);
+ }
+
+ pFile->m_ReadBuf[Bytes + Max] = '\0';
+ }
+ }
+
+ for (pChr = pFile->m_pReadPtr;
+ (*pChr != '\n') && (*pChr != '\r') && (*pChr != '\0')
&&
+ (pChr < (pFile->m_ReadBuf + sizeof(pFile->m_ReadBuf) -
1));
+ pChr++);
+
+ Max = min(pChr - pFile->m_pReadPtr, MaxLen);
+ memcpy(pLine, pFile->m_pReadPtr, Max);
+ MaxLen -= Max;
+ pLine += Max;
+
+ if (pChr < (pFile->m_ReadBuf + sizeof(pFile->m_ReadBuf) - 1))
+ {
+ if (*pChr != '\0')
+ {
+ if ((pChr[0] == '\r') && (pChr[1] == '\n'))
+ pChr += 2;
+ else
+ pChr += 1;
+ }
+
+ if ((pChr < (pFile->m_ReadBuf +
sizeof(pFile->m_ReadBuf))) &&
+ (*pChr == '\0'))
+ pChr = pFile->m_ReadBuf +
sizeof(pFile->m_ReadBuf);
+
+ *pLine = '\0';
+
+ /* setting MaxLen to -1 indicates terminating read loop
*/
+ MaxLen = -1;
+ }
+
+ pFile->m_pReadPtr = pChr;
+ }
+ while (MaxLen > 0);
+
+ return (sal_True);
+}
+
+
+
+
+
+
+
+
+
+
+static sal_Bool putLine(osl_TFile* pFile, const sal_Char *pszLine)
+{
+ unsigned int Len = strlen(pszLine);
+
+#ifdef DEBUG_OSL_PROFILE
+ int strLen=0;
+#endif
+
+ if ( pFile == 0 || pFile->m_Handle < 0 )
+ {
+ return (sal_False);
+ }
+
+ if ( pFile->m_pWriteBuf == 0 )
+ {
+ pFile->m_pWriteBuf = (sal_Char*) malloc(Len+3);
+ pFile->m_nWriteBufLen = Len+3;
+ pFile->m_nWriteBufFree = Len+3;
+ }
+ else
+ {
+ if ( pFile->m_nWriteBufFree <= Len + 3 )
+ {
+ sal_Char* pTmp;
+
+ pTmp=(sal_Char*) realloc(pFile->m_pWriteBuf,( (
pFile->m_nWriteBufLen + Len ) * 2) );
+ if ( pTmp == 0 )
+ {
+ return sal_False;
+ }
+ pFile->m_pWriteBuf = pTmp;
+ pFile->m_nWriteBufFree = pFile->m_nWriteBufFree +
pFile->m_nWriteBufLen + ( 2 * Len );
+ pFile->m_nWriteBufLen = ( pFile->m_nWriteBufLen + Len ) * 2;
+ memset( (pFile->m_pWriteBuf) + ( pFile->m_nWriteBufLen -
pFile->m_nWriteBufFree ), 0, pFile->m_nWriteBufFree);
+ }
+ }
+
+
+
+ memcpy(pFile->m_pWriteBuf + ( pFile->m_nWriteBufLen -
pFile->m_nWriteBufFree ),pszLine,Len+1);
+#ifdef DEBUG_OSL_PROFILE
+ strLen = strlen(pFile->m_pWriteBuf);
+#endif
+ pFile->m_pWriteBuf[pFile->m_nWriteBufLen - pFile->m_nWriteBufFree +
Len]='\r';
+ pFile->m_pWriteBuf[pFile->m_nWriteBufLen - pFile->m_nWriteBufFree + Len +
1]='\n';
+ pFile->m_pWriteBuf[pFile->m_nWriteBufLen - pFile->m_nWriteBufFree + Len +
2]='\0';
+
+ pFile->m_nWriteBufFree-=Len+2;
+
+#ifdef DEBUG_OSL_PROFILE
+/* OSL_TRACE("File Buffer in _putLine '%s'
'%i'(%i)\n",pFile->m_pWriteBuf,strlen(pFile->m_pWriteBuf),pFile->m_nWriteBufLen
- pFile->m_nWriteBufFree);*/
+#endif
+
+ return (sal_True);
+}
+
+/* platform specific end */
+
+
+static const sal_Char* stripBlanks(const sal_Char* String, sal_uInt32* pLen)
+{
+ if ( (pLen != NULL) && ( *pLen != 0 ) )
+ {
+ while ((String[*pLen - 1] == ' ') || (String[*pLen - 1] ==
'\t'))
+ (*pLen)--;
+
+ while ((*String == ' ') || (*String == '\t'))
+ {
+ String++;
+ (*pLen)--;
+ }
+ }
+ else
+ while ((*String == ' ') || (*String == '\t'))
+ String++;
+
+ return (String);
+}
+
+static const sal_Char* addLine(osl_TProfileImpl* pProfile, const sal_Char*
Line)
+{
+ if (pProfile->m_NoLines >= pProfile->m_MaxLines)
+ {
+ if (pProfile->m_Lines == NULL)
+ {
+ pProfile->m_MaxLines = LINES_INI;
+ pProfile->m_Lines = (sal_Char
**)calloc(pProfile->m_MaxLines, sizeof(sal_Char *));
+ }
+ else
+ {
+ unsigned int index=0;
+ unsigned int oldmax=pProfile->m_MaxLines;
+
+ pProfile->m_MaxLines += LINES_ADD;
+ pProfile->m_Lines = (sal_Char
**)realloc(pProfile->m_Lines, pProfile->m_MaxLines * sizeof(sal_Char *));
+
+ for ( index = oldmax ; index < pProfile->m_MaxLines ;
++index )
+ {
+ pProfile->m_Lines[index]=0;
+ }
+ }
+
+ if (pProfile->m_Lines == NULL)
+ {
+ pProfile->m_NoLines = 0;
+ pProfile->m_MaxLines = 0;
+ return (NULL);
+ }
+
+ }
+
+ if ( pProfile->m_Lines != 0 && pProfile->m_Lines[pProfile->m_NoLines]
!= 0 )
+ {
+ free(pProfile->m_Lines[pProfile->m_NoLines]);
+ }
+ pProfile->m_Lines[pProfile->m_NoLines++] = strdup(Line);
+
+ return (pProfile->m_Lines[pProfile->m_NoLines - 1]);
+}
+
+static const sal_Char* insertLine(osl_TProfileImpl* pProfile, const sal_Char*
Line, sal_uInt32 LineNo)
+{
+ if (pProfile->m_NoLines >= pProfile->m_MaxLines)
+ {
+ if (pProfile->m_Lines == NULL)
+ {
+ pProfile->m_MaxLines = LINES_INI;
+ pProfile->m_Lines = (sal_Char
**)calloc(pProfile->m_MaxLines, sizeof(sal_Char *));
+ }
+ else
+ {
+ pProfile->m_MaxLines += LINES_ADD;
+ pProfile->m_Lines = (sal_Char
**)realloc(pProfile->m_Lines,
+
pProfile->m_MaxLines * sizeof(sal_Char *));
+
+ memset(&pProfile->m_Lines[pProfile->m_NoLines],
+ 0,
+ (pProfile->m_MaxLines - pProfile->m_NoLines -
1) * sizeof(sal_Char*));
+ }
+
+ if (pProfile->m_Lines == NULL)
+ {
+ pProfile->m_NoLines = 0;
+ pProfile->m_MaxLines = 0;
+ return (NULL);
+ }
+ }
+
+ LineNo = LineNo > pProfile->m_NoLines ? pProfile->m_NoLines : LineNo;
+
+ if (LineNo < pProfile->m_NoLines)
+ {
+ sal_uInt32 i, n;
+ osl_TProfileSection* pSec;
+
+ memmove(&pProfile->m_Lines[LineNo + 1],
&pProfile->m_Lines[LineNo],
+ (pProfile->m_NoLines - LineNo) *
sizeof(sal_Char *));
+
+
+ /* adjust line references */
+ for (i = 0; i < pProfile->m_NoSections; i++)
+ {
+ pSec = &pProfile->m_Sections[i];
+
+ if (pSec->m_Line >= LineNo)
+ pSec->m_Line++;
+
+ for (n = 0; n < pSec->m_NoEntries; n++)
+ if (pSec->m_Entries[n].m_Line >= LineNo)
+ pSec->m_Entries[n].m_Line++;
+ }
+ }
+
+ pProfile->m_NoLines++;
+
+ pProfile->m_Lines[LineNo] = strdup(Line);
+
+ return (pProfile->m_Lines[LineNo]);
+}
+
+static void removeLine(osl_TProfileImpl* pProfile, sal_uInt32 LineNo)
+{
+ if (LineNo < pProfile->m_NoLines)
+ {
+ free(pProfile->m_Lines[LineNo]);
+ pProfile->m_Lines[LineNo]=0;
+ if (pProfile->m_NoLines - LineNo > 1)
+ {
+ sal_uInt32 i, n;
+ osl_TProfileSection* pSec;
+
+ memmove(&pProfile->m_Lines[LineNo],
&pProfile->m_Lines[LineNo + 1],
+ (pProfile->m_NoLines - LineNo - 1) *
sizeof(sal_Char *));
+
+ memset(&pProfile->m_Lines[pProfile->m_NoLines - 1],
+ 0,
+ (pProfile->m_MaxLines - pProfile->m_NoLines) *
sizeof(sal_Char*));
+
+ /* adjust line references */
+ for (i = 0; i < pProfile->m_NoSections; i++)
+ {
+ pSec = &pProfile->m_Sections[i];
+
+ if (pSec->m_Line > LineNo)
+ pSec->m_Line--;
+
+ for (n = 0; n < pSec->m_NoEntries; n++)
+ if (pSec->m_Entries[n].m_Line > LineNo)
+ pSec->m_Entries[n].m_Line--;
+ }
+ }
+ else
+ {
+ pProfile->m_Lines[LineNo] = 0;
+ }
+
+ pProfile->m_NoLines--;
+ }
+
+ return;
+}
+
+static void setEntry(osl_TProfileImpl* pProfile, osl_TProfileSection* pSection,
+ sal_uInt32 NoEntry, sal_uInt32 Line,
+ const sal_Char* Entry, sal_uInt32 Len)
+{
+ Entry = stripBlanks(Entry, &Len);
+ pSection->m_Entries[NoEntry].m_Line = Line;
+ pSection->m_Entries[NoEntry].m_Offset = Entry - pProfile->m_Lines[Line];
+ pSection->m_Entries[NoEntry].m_Len = Len;
+
+ return;
+}
+
+static sal_Bool addEntry(osl_TProfileImpl* pProfile, osl_TProfileSection
*pSection,
+ int Line, const sal_Char*
Entry, sal_uInt32 Len)
+{
+ if (pSection != NULL)
+ {
+ if (pSection->m_NoEntries >= pSection->m_MaxEntries)
+ {
+ if (pSection->m_Entries == NULL)
+ {
+ pSection->m_MaxEntries = ENTRIES_INI;
+ pSection->m_Entries = (osl_TProfileEntry
*)malloc(
+
pSection->m_MaxEntries * sizeof(osl_TProfileEntry));
+ }
+ else
+ {
+ pSection->m_MaxEntries += ENTRIES_ADD;
+ pSection->m_Entries = (osl_TProfileEntry
*)realloc(pSection->m_Entries,
+
pSection->m_MaxEntries * sizeof(osl_TProfileEntry));
+ }
+
+ if (pSection->m_Entries == NULL)
+ {
+ pSection->m_NoEntries = 0;
+ pSection->m_MaxEntries = 0;
+ return (sal_False);
+ }
+ }
+
+ pSection->m_NoEntries++;
+
+ Entry = stripBlanks(Entry, &Len);
+ setEntry(pProfile, pSection, pSection->m_NoEntries - 1, Line,
+ Entry, Len);
+
+ return (sal_True);
+ }
+
+ return (sal_False);
+}
+
+static void removeEntry(osl_TProfileSection *pSection, sal_uInt32 NoEntry)
+{
+ if (NoEntry < pSection->m_NoEntries)
+ {
+ if (pSection->m_NoEntries - NoEntry > 1)
+ {
+ memmove(&pSection->m_Entries[NoEntry],
+ &pSection->m_Entries[NoEntry + 1],
+ (pSection->m_NoEntries - NoEntry - 1) *
sizeof(osl_TProfileEntry));
+ pSection->m_Entries[pSection->m_NoEntries - 1].m_Line=0;
+ pSection->m_Entries[pSection->m_NoEntries -
1].m_Offset=0;
+ pSection->m_Entries[pSection->m_NoEntries - 1].m_Len=0;
+ }
+
+ pSection->m_NoEntries--;
+ }
+
+ return;
+}
+
+static sal_Bool addSection(osl_TProfileImpl* pProfile, int Line, const
sal_Char* Section, sal_uInt32 Len)
+{
+ if (pProfile->m_NoSections >= pProfile->m_MaxSections)
+ {
+ if (pProfile->m_Sections == NULL)
+ {
+ pProfile->m_MaxSections = SECTIONS_INI;
+ pProfile->m_Sections = (osl_TProfileSection
*)calloc(pProfile->m_MaxSections, sizeof(osl_TProfileSection));
+ }
+ else
+ {
+ unsigned int index=0;
+ unsigned int oldmax=pProfile->m_MaxSections;
+
+ pProfile->m_MaxSections += SECTIONS_ADD;
+ pProfile->m_Sections = (osl_TProfileSection
*)realloc(pProfile->m_Sections,
+
pProfile->m_MaxSections * sizeof(osl_TProfileSection));
+ for ( index = oldmax ; index < pProfile->m_MaxSections
; ++index )
+ {
+ pProfile->m_Sections[index].m_Entries=0;
+ }
+ }
+
+ if (pProfile->m_Sections == NULL)
+ {
+ pProfile->m_NoSections = 0;
+ pProfile->m_MaxSections = 0;
+ return (sal_False);
+ }
+ }
+
+ pProfile->m_NoSections++;
+
+ if ( pProfile->m_Sections[(pProfile->m_NoSections) - 1].m_Entries != 0 )
+ {
+ free(pProfile->m_Sections[(pProfile->m_NoSections) -
1].m_Entries);
+ }
+ pProfile->m_Sections[pProfile->m_NoSections - 1].m_Entries = NULL;
+ pProfile->m_Sections[pProfile->m_NoSections - 1].m_NoEntries = 0;
+ pProfile->m_Sections[pProfile->m_NoSections - 1].m_MaxEntries = 0;
+
+ Section = (sal_Char *)stripBlanks(Section, &Len);
+ pProfile->m_Sections[pProfile->m_NoSections - 1].m_Line = Line;
+ pProfile->m_Sections[pProfile->m_NoSections - 1].m_Offset = Section -
pProfile->m_Lines[Line];
+ pProfile->m_Sections[pProfile->m_NoSections - 1].m_Len = Len;
+
+ return (sal_True);
+}
+
+static void removeSection(osl_TProfileImpl* pProfile, osl_TProfileSection
*pSection)
+{
+ sal_uInt32 Section;
+
+ if ((Section = pSection - pProfile->m_Sections) <
pProfile->m_NoSections)
+ {
+ free (pSection->m_Entries);
+ pSection->m_Entries=0;
+ if (pProfile->m_NoSections - Section > 1)
+ {
+ memmove(&pProfile->m_Sections[Section],
&pProfile->m_Sections[Section + 1],
+ (pProfile->m_NoSections - Section - 1)
* sizeof(osl_TProfileSection));
+
+ memset(&pProfile->m_Sections[pProfile->m_NoSections -
1],
+ 0,
+ (pProfile->m_MaxSections -
pProfile->m_NoSections) * sizeof(osl_TProfileSection));
+ pProfile->m_Sections[pProfile->m_NoSections -
1].m_Entries = 0;
+ }
+ else
+ {
+ pSection->m_Entries = 0;
+ }
+
+ pProfile->m_NoSections--;
+ }
+
+ return;
+}
+
+static osl_TProfileSection* findEntry(osl_TProfileImpl* pProfile, const
sal_Char* Section,
+ const sal_Char* Entry, sal_uInt32
*pNoEntry)
+{
+static sal_uInt32 Sect = 0;
+ sal_uInt32 i, n;
+ sal_uInt32 Len;
+ const sal_Char* pStr;
+ osl_TProfileSection* pSec = NULL;
+
+ Len = strlen(Section);
+ Section = (sal_Char *)stripBlanks(Section, &Len);
+
+ n = Sect;
+
+ for (i = 0; i < pProfile->m_NoSections; i++)
+ {
+ n %= pProfile->m_NoSections;
+ pSec = &pProfile->m_Sections[n];
+ if ((Len == pSec->m_Len) &&
+ (strnicmp(Section,
&pProfile->m_Lines[pSec->m_Line][pSec->m_Offset], pSec->m_Len)
+ == 0))
+ break;
+ n++;
+ }
+
+ Sect = n;
+
+ if (i < pProfile->m_NoSections)
+ {
+ Len = strlen(Entry);
+ Entry = stripBlanks(Entry, &Len);
+
+ *pNoEntry = pSec->m_NoEntries;
+
+ for (i = 0; i < pSec->m_NoEntries; i++)
+ {
+ pStr = &pProfile->m_Lines[pSec->m_Entries[i].m_Line]
+
[pSec->m_Entries[i].m_Offset];
+ if ((Len == pSec->m_Entries[i].m_Len) &&
+ (strnicmp(Entry, pStr, pSec->m_Entries[i].m_Len)
+ == 0))
+ {
+ *pNoEntry = i;
+ break;
+ }
+ }
+ }
+ else
+ pSec = NULL;
+
+ return (pSec);
+}
+
+static sal_Bool loadProfile(osl_TFile* pFile, osl_TProfileImpl* pProfile)
+{
+ sal_uInt32 i;
+ sal_Char* pStr;
+ sal_Char* pChar;
+ sal_Char Line[4096];
+
+ pProfile->m_NoLines = 0;
+ pProfile->m_NoSections = 0;
+
+ OSL_VERIFY(rewindFile(pFile, sal_False));
+
+ while (getLine(pFile, Line, sizeof(Line)))
+ {
+ if (! addLine(pProfile, Line))
+ return (sal_False);
+ }
+
+ for (i = 0; i < pProfile->m_NoLines; i++)
+ {
+ pStr = (sal_Char *)stripBlanks(pProfile->m_Lines[i], NULL);
+
+ if ((*pStr == '\0') || (*pStr == ';'))
+ continue;
+
+ if ((*pStr != '[') || ((pChar = strrchr(pStr, ']')) == NULL) ||
+ ((pChar - pStr) <= 2))
+ {
+ /* insert entry */
+
+ if (pProfile->m_NoSections < 1)
+ continue;
+
+ if ((pChar = strchr(pStr, '=')) == NULL)
+ pChar = pStr + strlen(pStr);
+
+ if (! addEntry(pProfile,
&pProfile->m_Sections[pProfile->m_NoSections - 1],
+ i, pStr, pChar - pStr))
+ return (sal_False);
+ }
+ else
+ {
+ /* new section */
+
+ if (! addSection(pProfile, i, pStr + 1, pChar - pStr -
1))
+ return (sal_False);
+ }
+ }
+
+ return (sal_True);
+}
+
+
+
+
+
+static sal_Bool storeProfile(osl_TProfileImpl* pProfile, sal_Bool bCleanup)
+{
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("In storeProfile\n");
+#endif
+
+ if (pProfile->m_Lines != NULL)
+ {
+ if (pProfile->m_Flags & FLG_MODIFIED)
+ {
+ sal_uInt32 i;
+
+ osl_TFile* pTmpFile = osl_openTmpProfileImpl(pProfile);
+
+ if ( pTmpFile == 0 )
+ {
+ return sal_False;
+ }
+
+ OSL_VERIFY(rewindFile(pTmpFile, sal_True));
+
+ for (i = 0; i < pProfile->m_NoLines; i++)
+ {
+ OSL_VERIFY(putLine(pTmpFile,
pProfile->m_Lines[i]));
+ }
+
+ if ( ! writeProfileImpl(pTmpFile) )
+ {
+ if ( pTmpFile->m_pWriteBuf != 0 )
+ {
+ free(pTmpFile->m_pWriteBuf);
+ }
+
+ pTmpFile->m_pWriteBuf=0;
+ pTmpFile->m_nWriteBufLen=0;
+ pTmpFile->m_nWriteBufFree=0;
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out storeProfile [not flushed]\n");
+#endif
+ closeFileImpl(pTmpFile);
+
+ return sal_False;
+ }
+
+ pProfile->m_Flags &= ~FLG_MODIFIED;
+
+ closeFileImpl(pProfile->m_pFile);
+ closeFileImpl(pTmpFile);
+
+ osl_ProfileSwapProfileNames(pProfile);
+
+/* free(pProfile->m_pFile);*/
+/* free(pTmpFile);*/
+
+ pProfile->m_pFile =
openFileImpl(pProfile->m_strFileName,pProfile->m_Flags);
+
+ }
+
+ if (bCleanup)
+ {
+ while (pProfile->m_NoLines > 0)
+ removeLine(pProfile, pProfile->m_NoLines - 1);
+
+ free(pProfile->m_Lines);
+ pProfile->m_Lines = NULL;
+ pProfile->m_MaxLines = 0;
+
+ while (pProfile->m_NoSections > 0)
+ removeSection(pProfile,
&pProfile->m_Sections[pProfile->m_NoSections - 1]);
+
+ free(pProfile->m_Sections);
+ pProfile->m_Sections = NULL;
+ pProfile->m_MaxSections = 0;
+ }
+ }
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out storeProfile [ok]\n");
+#endif
+ return (sal_True);
+}
+
+
+static osl_TFile* osl_openTmpProfileImpl(osl_TProfileImpl* pProfile)
+{
+ osl_TFile* pFile=0;
+ rtl_uString* ustrExtension=0;
+ rtl_uString* ustrTmpName=0;
+ oslProfileOption PFlags=0;
+
+ rtl_uString_newFromAscii(&ustrExtension,"tmp");
+
+
+ /* generate tmp profilename */
+
ustrTmpName=osl_ProfileGenerateExtension(pProfile->m_strFileName,ustrExtension);
+ rtl_uString_release(ustrExtension);
+
+ if ( ustrTmpName == 0 )
+ {
+ return 0;
+ }
+
+
+ if ( ! ( pProfile->m_Flags & osl_Profile_READLOCK ) )
+ {
+ PFlags |= osl_Profile_WRITELOCK;
+ }
+
+ /* open this file */
+ pFile = openFileImpl(ustrTmpName,pProfile->m_Flags | PFlags);
+
+
+ /* return new pFile */
+ return pFile;
+}
+
+
+static sal_Bool osl_ProfileSwapProfileNames(osl_TProfileImpl* pProfile)
+{
+ sal_Bool bRet = sal_False;
+
+ rtl_uString* ustrBakFile=0;
+ rtl_uString* ustrTmpFile=0;
+ rtl_uString* ustrIniFile=0;
+ rtl_uString* ustrExtension=0;
+
+
+ rtl_uString_newFromAscii(&ustrExtension,"bak");
+
+
ustrBakFile=osl_ProfileGenerateExtension(pProfile->m_strFileName,ustrExtension);
+ rtl_uString_release(ustrExtension);
+ ustrExtension=0;
+
+
+ rtl_uString_newFromAscii(&ustrExtension,"ini");
+
+
ustrIniFile=osl_ProfileGenerateExtension(pProfile->m_strFileName,ustrExtension);
+ rtl_uString_release(ustrExtension);
+ ustrExtension=0;
+
+
+ rtl_uString_newFromAscii(&ustrExtension,"tmp");
+
+
ustrTmpFile=osl_ProfileGenerateExtension(pProfile->m_strFileName,ustrExtension);
+ rtl_uString_release(ustrExtension);
+ ustrExtension=0;
+
+
+ /* unlink bak */
+ DeleteFileW( reinterpret_cast<LPCWSTR>(rtl_uString_getStr( ustrBakFile
)) );
+
+ /* rename ini bak */
+ MoveFileExW( reinterpret_cast<LPCWSTR>(rtl_uString_getStr( ustrIniFile
)), reinterpret_cast<LPCWSTR>(rtl_uString_getStr( ustrBakFile )),
MOVEFILE_COPY_ALLOWED | MOVEFILE_WRITE_THROUGH );
+
+ /* rename tmp ini */
+ MoveFileExW( reinterpret_cast<LPCWSTR>(rtl_uString_getStr( ustrTmpFile
)), reinterpret_cast<LPCWSTR>(rtl_uString_getStr( ustrIniFile )),
MOVEFILE_COPY_ALLOWED | MOVEFILE_WRITE_THROUGH );
+
+ return bRet;
+}
+
+
+static rtl_uString* osl_ProfileGenerateExtension(rtl_uString* ustrFileName,
rtl_uString* ustrExtension)
+{
+ rtl_uString* ustrNewFileName=0;
+ rtl_uString* ustrOldExtension = 0;
+ sal_Unicode* pExtensionBuf = 0;
+ sal_Unicode* pFileNameBuf = 0;
+ sal_Int32 nIndex = -1;
+
+ pFileNameBuf = rtl_uString_getStr(ustrFileName);
+
+ rtl_uString_newFromAscii(&ustrOldExtension,".");
+
+ pExtensionBuf = rtl_uString_getStr(ustrOldExtension);
+
+ nIndex = rtl_ustr_lastIndexOfChar(pFileNameBuf,*pExtensionBuf);
+
+ rtl_uString_newReplaceStrAt(&ustrNewFileName,
+ ustrFileName,
+ nIndex+1,
+ 3,
+ ustrExtension);
+
+ return ustrNewFileName;
+}
+
+
+static osl_TProfileImpl* acquireProfile(oslProfile Profile, sal_Bool
bWriteable)
+{
+ osl_TProfileImpl* pProfile = (osl_TProfileImpl*)Profile;
+ oslProfileOption PFlags=0;
+
+
+ if ( bWriteable )
+ {
+/* PFlags = osl_Profile_DEFAULT | osl_Profile_READWRITE; */
+ PFlags = osl_Profile_DEFAULT | osl_Profile_WRITELOCK;
+ }
+ else
+ {
+ PFlags = osl_Profile_DEFAULT;
+ }
+
+
+ if (pProfile == NULL)
+ {
+#ifdef DEBUG_OSL_PROFILE
+ OSL_TRACE("AUTOOPEN MODE\n");
+#endif
+
+
+
+ if ( ( pProfile = (osl_TProfileImpl*)osl_openProfile( NULL,
PFlags ) ) != NULL )
+ {
+ pProfile->m_Flags |= FLG_AUTOOPEN;
+ }
+ }
+ else
+ {
+#ifdef DEBUG_OSL_PROFILE
+ OSL_TRACE("try to acquire\n");
+#endif
+
+
+
+ if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
+ {
+ if (! (pProfile->m_Flags & (osl_Profile_READLOCK |
+ osl_Profile_WRITELOCK |
osl_Profile_FLUSHWRITE)))
+ {
+ osl_TStamp Stamp;
+#ifdef DEBUG_OSL_PROFILE
+ OSL_TRACE("DEFAULT MODE\n");
+#endif
+ pProfile->m_pFile = openFileImpl(
+ pProfile->m_strFileName, pProfile->m_Flags | PFlags);
+ if (!pProfile->m_pFile)
+ return NULL;
+
+ Stamp = getFileStamp(pProfile->m_pFile);
+
+ if (memcmp(&Stamp, &(pProfile->m_Stamp),
sizeof(osl_TStamp)))
+ {
+ pProfile->m_Stamp = Stamp;
+
+ loadProfile(pProfile->m_pFile,
pProfile);
+ }
+ }
+ else
+ {
+#ifdef DEBUG_OSL_PROFILE
+ OSL_TRACE("READ/WRITELOCK MODE\n");
+#endif
+
+
+ /* A readlock file could not be written */
+ if ((pProfile->m_Flags & osl_Profile_READLOCK) && bWriteable)
+ {
+ return (NULL);
+ }
+ }
+ }
+ }
+
+ return (pProfile);
+}
+
+static sal_Bool releaseProfile(osl_TProfileImpl* pProfile)
+{
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("In releaseProfile\n");
+#endif
+
+ if ( pProfile == 0 )
+ {
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out releaseProfile [profile==0]\n");
+#endif
+ return sal_False;
+ }
+
+ if (! (pProfile->m_Flags & osl_Profile_SYSTEM))
+ {
+ if (pProfile->m_Flags & FLG_AUTOOPEN)
+ {
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out releaseProfile [AUTOOPEN]\n");
+#endif
+ return (osl_closeProfile((oslProfile)pProfile));
+ }
+ else
+ {
+#ifdef DEBUG_OSL_PROFILE
+ OSL_TRACE("DEFAULT MODE\n");
+#endif
+ if (! (pProfile->m_Flags & (osl_Profile_READLOCK |
+ osl_Profile_WRITELOCK |
osl_Profile_FLUSHWRITE)))
+ {
+ if (pProfile->m_Flags & FLG_MODIFIED)
+ storeProfile(pProfile, sal_False);
+
+ closeFileImpl(pProfile->m_pFile);
+ pProfile->m_pFile = NULL;
+ }
+ }
+ }
+
+#ifdef TRACE_OSL_PROFILE
+ OSL_TRACE("Out releaseProfile [ok]\n");
+#endif
+ return (sal_True);
+}
+
+static sal_Bool lookupProfile(const sal_Unicode *strPath, const sal_Unicode
*strFile, sal_Unicode *strProfile)
+{
+ sal_Char *pChr, *pStr;
+ sal_Char Buffer[4096] = "";
+ sal_Char Product[132] = "";
+
+ ::osl::LongPathBuffer< sal_Unicode > aPath( MAX_LONG_PATH );
+ aPath[0] = 0;
+ DWORD dwPathLen = 0;
+
+ if (*strPath == L'"')
+ {
+ int i = 0;
+
+ strPath++;
+
+ while ((strPath[i] != L'"') && (strPath[i] != L'\0'))
+ i++;
+
+ WideCharToMultiByte(CP_ACP,0,
reinterpret_cast<LPCWSTR>(strPath), i, Product, sizeof(Product), NULL, NULL);
+ Product[i] = '\0';
+ strPath += i;
+
+ if (*strPath == L'"')
+ strPath++;
+
+ if ( (*strPath == L'/') || (*strPath == L'\\') )
+ {
+ strPath++;
+ }
+ }
+
+ else
+ {
+ /* if we have not product identfication, do a special handling
for soffice.ini */
+ if (rtl_ustr_ascii_compare(strFile, SVERSION_PROFILE) == 0)
+ {
+ rtl_uString * strSVProfile = NULL;
+ rtl_uString * strSVFallback = NULL;
+ rtl_uString * strSVLocation = NULL;
+ rtl_uString * strSVName = NULL;
+ ::osl::LongPathBuffer< sal_Char > aDir( MAX_LONG_PATH );
+ oslProfile hProfile;
+
+ rtl_uString_newFromAscii(&strSVFallback,
SVERSION_FALLBACK);
+ rtl_uString_newFromAscii(&strSVLocation,
SVERSION_LOCATION);
+ rtl_uString_newFromAscii(&strSVName, SVERSION_NAME);
+
+ /* open sversion.ini in the system directory, and try
to locate the entry
+ with the highest version for StarOffice */
+ if (osl_getProfileName( strSVFallback, strSVName,
&strSVProfile))
+ {
+ hProfile = osl_openProfile(strSVProfile,
osl_Profile_READLOCK);
+ if (hProfile)
+ {
+ osl_getProfileSectionEntries(
+ hProfile, SVERSION_SECTION, Buffer, sizeof(Buffer));
+
+ for (pChr = Buffer; *pChr != '\0'; pChr += strlen(pChr) +
1)
+ {
+ if ((strnicmp(
+ pChr, SVERSION_SOFFICE,
+ sizeof(SVERSION_SOFFICE) - 1)
+ == 0)
+ && (stricmp(Product, pChr) < 0))
+ {
+ osl_readProfileString(
+ hProfile, SVERSION_SECTION, pChr, aDir,
+ aDir.getBufSizeInSymbols(), "");
+
+ /* check for existence of path */
+ if (access(aDir, 0) >= 0)
+ strcpy(Product, pChr);
+ }
+ }
+
+ osl_closeProfile(hProfile);
+ }
+ rtl_uString_release(strSVProfile);
+ strSVProfile = NULL;
+ }
+
+ /* open sversion.ini in the users directory, and try to
locate the entry
+ with the highest version for StarOffice */
+ if ((strcmp(SVERSION_LOCATION, SVERSION_FALLBACK) != 0)
&&
+ (osl_getProfileName(strSVLocation, strSVName,
&strSVProfile)))
+ {
+ hProfile = osl_openProfile(strSVProfile,
osl_Profile_READLOCK);
+ if (hProfile)
+ {
+ osl_getProfileSectionEntries(
+ hProfile, SVERSION_SECTION, Buffer, sizeof(Buffer));
+
+ for (pChr = Buffer; *pChr != '\0'; pChr += strlen(pChr) +
1)
+ {
+ if ((strnicmp(
+ pChr, SVERSION_SOFFICE,
+ sizeof(SVERSION_SOFFICE) - 1)
+ == 0)
+ && (stricmp(Product, pChr) < 0))
+ {
+ osl_readProfileString(
+ hProfile, SVERSION_SECTION, pChr, aDir,
+ aDir.getBufSizeInSymbols(), "");
+
+ /* check for existence of path */
+ if (access(aDir, 0) >= 0)
+ strcpy(Product, pChr);
+ }
+ }
+
+ osl_closeProfile(hProfile);
+ }
+ rtl_uString_release(strSVProfile);
+ }
+
+ rtl_uString_release(strSVFallback);
+ rtl_uString_release(strSVLocation);
+ rtl_uString_release(strSVName);
+
+ /* remove any trailing build number */
+ if ((pChr = strrchr(Product, '/')) != NULL)
+ *pChr = '\0';
+ }
+ }
+
+ /* if we have an userid option eg.
"-userid:rh[/usr/home/rh/staroffice]",
+ this will supercede all other locations */
+ {
+ sal_uInt32 n, nArgs = osl_getCommandArgCount();
+
+ for (n = 0; n < nArgs; n++)
+ {
+ rtl_uString * strCommandArg = NULL;
+
+ if ((osl_getCommandArg( n, &strCommandArg ) ==
osl_Process_E_None) &&
+ ((strCommandArg->buffer[0] == L'-') ||
(strCommandArg->buffer[0] == L'+')) &&
+
(rtl_ustr_ascii_compare_WithLength(strCommandArg->buffer,
RTL_CONSTASCII_LENGTH(SVERSION_OPTION), SVERSION_OPTION)))
+ {
+ sal_Unicode *pCommandArg =
strCommandArg->buffer + RTL_CONSTASCII_LENGTH(SVERSION_OPTION);
+ sal_Int32 nStart, nEnd;
+
+ if (((nStart =
rtl_ustr_indexOfChar(pCommandArg, L'[')) != -1) &&
+ ((nEnd =
rtl_ustr_indexOfChar(pCommandArg + nStart + 1, L']')) != -1))
+ {
+ dwPathLen = nEnd;
+ copy_ustr_n(aPath, pCommandArg + nStart +
1, dwPathLen);
+ aPath[dwPathLen] = 0;
+
+ /* build full path */
+ if ((aPath[dwPathLen - 1] != L'/') &&
(aPath[dwPathLen - 1] != L'\\'))
+ {
+ copy_ustr_n(aPath +
dwPathLen++, L"/", 2);
+ }
+
+ if (*strPath)
+ {
+ copy_ustr_n(aPath + dwPathLen,
strPath, rtl_ustr_getLength(strPath)+1);
+ dwPathLen +=
rtl_ustr_getLength(strPath);
+ }
+ else
+ {
+ ::osl::LongPathBuffer< sal_Char > aTmpPath(
MAX_LONG_PATH );
+ int n;
+
+ if ((n =
WideCharToMultiByte(CP_ACP,0, ::osl::mingw_reinterpret_cast<LPCWSTR>(aPath),
-1, aTmpPath, aTmpPath.getBufSizeInSymbols(), NULL, NULL)) > 0)
+ {
+ strcpy(aTmpPath + n,
SVERSION_USER);
+ if (access(aTmpPath, 0)
>= 0)
+ {
+ dwPathLen +=
MultiByteToWideChar( CP_ACP, 0, SVERSION_USER, -1,
reinterpret_cast<LPWSTR>(aPath + dwPathLen), aPath.getBufSizeInSymbols() -
dwPathLen );
+ }
+ }
+ }
+
+ break;
+ }
+ }
+ }
+ }
+
+
+ if (dwPathLen == 0)
+ {
+ rtl_uString * strExecutable = NULL;
+ rtl_uString * strTmp = NULL;
+ sal_Int32 nPos;
+
+ /* try to find the file in the directory of the executbale */
+ if (osl_getExecutableFile(&strTmp) != osl_Process_E_None)
+ return (sal_False);
+
+ /* convert to native path */
+ if (osl_getSystemPathFromFileURL(strTmp, &strExecutable) !=
osl_File_E_None)
+ {
+ rtl_uString_release(strTmp);
+ return sal_False;
+ }
+
+ rtl_uString_release(strTmp);
+
+ /* separate path from filename */
+ if ((nPos = rtl_ustr_lastIndexOfChar(strExecutable->buffer,
L'\\')) == -1)
+ {
+ if ((nPos =
rtl_ustr_lastIndexOfChar(strExecutable->buffer, L':')) == -1)
+ {
+ return sal_False;
+ }
+ else
+ {
+ copy_ustr_n(aPath, strExecutable->buffer, nPos);
+ aPath[nPos] = 0;
+ dwPathLen = nPos;
+ }
+ }
+ else
+ {
+ copy_ustr_n(aPath, strExecutable->buffer, nPos);
+ dwPathLen = nPos;
+ aPath[dwPathLen] = 0;
+ }
+
+ /* if we have no product identification use the executable file
name */
+ if (*Product == 0)
+ {
+ WideCharToMultiByte(CP_ACP,0,
reinterpret_cast<LPCWSTR>(strExecutable->buffer + nPos + 1), -1, Product,
sizeof(Product), NULL, NULL);
+
+ /* remove extension */
+ if ((pChr = strrchr(Product, '.')) != NULL)
+ *pChr = '\0';
+ }
+
+ rtl_uString_release(strExecutable);
+
+ /* remember last subdir */
+ nPos = rtl_ustr_lastIndexOfChar(aPath, L'\\');
+
+ copy_ustr_n(aPath + dwPathLen++, L"\\", 2);
+
+ if (*strPath)
+ {
+ copy_ustr_n(aPath + dwPathLen, strPath,
rtl_ustr_getLength(strPath)+1);
+ dwPathLen += rtl_ustr_getLength(strPath);
+ }
+
+ {
+ ::osl::LongPathBuffer< sal_Char > aTmpPath( MAX_LONG_PATH );
+
+ WideCharToMultiByte(CP_ACP,0,
::osl::mingw_reinterpret_cast<LPCWSTR>(aPath), -1, aTmpPath,
aTmpPath.getBufSizeInSymbols(), NULL, NULL);
+
+ /* if file not exists, remove any specified
subdirectories
+ like "bin" or "program" */
+
+ if (((access(aTmpPath, 0) < 0) && (nPos != -1)) ||
(*strPath == 0))
+ {
+ static sal_Char *SubDirs[] = SVERSION_DIRS;
+
+ int i = 0;
+ pStr = aTmpPath + nPos;
+
+ for (i = 0; i < (sizeof(SubDirs) /
sizeof(SubDirs[0])); i++)
+ if (strnicmp(pStr + 1, SubDirs[i],
strlen(SubDirs[i])) == 0)
+ {
+ if ( *strPath == 0)
+ {
+ strcpy(pStr +
1,SVERSION_USER);
+ if ( access(aTmpPath,
0) < 0 )
+ {
+ *(pStr+1)='\0';
+ }
+ else
+ {
+ dwPathLen = nPos + MultiByteToWideChar(
CP_ACP, 0, SVERSION_USER, -1, reinterpret_cast<LPWSTR>(aPath + nPos + 1),
aPath.getBufSizeInSymbols() - (nPos + 1) );
+ }
+ }
+ else
+ {
+ copy_ustr_n(aPath +
nPos + 1, strPath, rtl_ustr_getLength(strPath)+1);
+ dwPathLen = nPos + 1 +
rtl_ustr_getLength(strPath);
+ }
+
+ break;
+ }
+ }
+ }
+
+ if ((aPath[dwPathLen - 1] != L'/') && (aPath[dwPathLen - 1] !=
L'\\'))
+ {
+ aPath[dwPathLen++] = L'\\';
+ aPath[dwPathLen] = 0;
+ }
+
+ copy_ustr_n(aPath + dwPathLen, strFile,
rtl_ustr_getLength(strFile)+1);
+
+ {
+ ::osl::LongPathBuffer< sal_Char > aTmpPath( MAX_LONG_PATH );
+
+ WideCharToMultiByte(CP_ACP,0,
::osl::mingw_reinterpret_cast<LPCWSTR>(aPath), -1, aTmpPath,
aTmpPath.getBufSizeInSymbols(), NULL, NULL);
+
+ if ((access(aTmpPath, 0) < 0) && (strlen(Product) > 0))
+ {
+ rtl_uString * strSVFallback = NULL;
+ rtl_uString * strSVProfile = NULL;
+ rtl_uString * strSVLocation = NULL;
+ rtl_uString * strSVName = NULL;
+ oslProfile hProfile;
+
+ rtl_uString_newFromAscii(&strSVFallback,
SVERSION_FALLBACK);
+ rtl_uString_newFromAscii(&strSVLocation,
SVERSION_LOCATION);
+ rtl_uString_newFromAscii(&strSVName,
SVERSION_NAME);
+
+ /* open sversion.ini in the system directory,
and try to locate the entry
+ with the highest version for StarOffice */
+ if (osl_getProfileName(strSVLocation,
strSVName, &strSVProfile))
+ {
+ hProfile = osl_openProfile(
+ strSVProfile, osl_Profile_READLOCK);
+ if (hProfile)
+ {
+ osl_readProfileString(
+ hProfile, SVERSION_SECTION, Product, Buffer,
+ sizeof(Buffer), "");
+ osl_closeProfile(hProfile);
+
+ /* if not found, try the fallback */
+ if ((strlen(Buffer) <= 0)
+ && (strcmp(SVERSION_LOCATION, SVERSION_FALLBACK)
+ != 0))
+ {
+ if (osl_getProfileName(
+ strSVFallback, strSVName, &strSVProfile))
+ {
+ hProfile = osl_openProfile(
+ strSVProfile, osl_Profile_READLOCK);
+ if (hProfile)
+ {
+ osl_readProfileString(
+ hProfile, SVERSION_SECTION, Product,
+ Buffer, sizeof(Buffer), "");
+ }
+ }
+
+ osl_closeProfile(hProfile);
+ }
+
+ if (strlen(Buffer) > 0)
+ {
+ dwPathLen = MultiByteToWideChar(
+ CP_ACP, 0, Buffer, -1,
::osl::mingw_reinterpret_cast<LPWSTR>(aPath), aPath.getBufSizeInSymbols() );
+ dwPathLen -=1;
+
+ /* build full path */
+ if ((aPath[dwPathLen - 1] != L'/')
+ && (aPath[dwPathLen - 1] != L'\\'))
+ {
+ copy_ustr_n(aPath + dwPathLen++, L"\\", 2);
+ }
+
+ if (*strPath)
+ {
+ copy_ustr_n(aPath + dwPathLen, strPath,
rtl_ustr_getLength(strPath)+1);
+ dwPathLen += rtl_ustr_getLength(strPath);
+ }
+ else
+ {
+ ::osl::LongPathBuffer< sal_Char > aTmpPath(
MAX_LONG_PATH );
+ int n;
+
+ if ((n = WideCharToMultiByte(
+ CP_ACP,0,
::osl::mingw_reinterpret_cast<LPCWSTR>(aPath), -1, aTmpPath,
+ aTmpPath.getBufSizeInSymbols(), NULL,
NULL))
+ > 0)
+ {
+ strcpy(aTmpPath + n, SVERSION_USER);
+ if (access(aTmpPath, 0) >= 0)
+ {
+ dwPathLen += MultiByteToWideChar(
+ CP_ACP, 0, SVERSION_USER, -1,
+ reinterpret_cast<LPWSTR>(aPath +
dwPathLen),
+ aPath.getBufSizeInSymbols() -
dwPathLen );
+ }
+ }
+ }
+ }
+ }
+
+ rtl_uString_release(strSVProfile);
+ }
+
+ rtl_uString_release(strSVFallback);
+ rtl_uString_release(strSVLocation);
+ rtl_uString_release(strSVName);
+ }
+ }
+
+ aPath[dwPathLen] = 0;
+ }
+
+ /* copy filename */
+ copy_ustr_n(strProfile, aPath, dwPathLen+1);
+
+ return sal_True;
+}
+
+
Added: openoffice/branches/olcProfileNano/sal/osl/w32/system.h
URL:
http://svn.apache.org/viewvc/openoffice/branches/olcProfileNano/sal/osl/w32/system.h?rev=1734003&view=auto
==============================================================================
--- openoffice/branches/olcProfileNano/sal/osl/w32/system.h (added)
+++ openoffice/branches/olcProfileNano/sal/osl/w32/system.h Mon Mar 7 23:34:03
2016
@@ -0,0 +1,122 @@
+/**************************************************************
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+ *************************************************************/
+
+
+
+#if OSL_DEBUG_LEVEL == 0
+# define NO_DEBUG_CRT
+#endif
+
+#ifndef _WIN32_WINNT
+# define _WIN32_WINNT 0x0400
+# define _CTYPE_DISABLE_MACROS /* wg. dynamischer C-Runtime MH */
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <ctype.h>
+#include <malloc.h>
+#include <limits.h>
+#include <process.h>
+#include <time.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <io.h>
+#include <share.h>
+#include <direct.h>
+
+/* Must define this else build breaks because Winsock2.h
+ includes Windows.h and without WIN32_LEAN_AND_MEAN
+ also includes mswsock.h which needs a forward typedef
+ of SOCKET ...
+*/
+#define WIN32_LEAN_AND_MEAN
+
+#ifdef GCC
+ // windows.h includes winsock2.h
+ // if _WIN32_WINNT > 0x0400
+ // so someone cannot include winsock.h
+ // at the same time without patching
+ // windows.h
+ #include <windows.h>
+#ifdef __MINGW32__
+ #include <winsock2.h>
+ #include <ws2tcpip.h>
+#endif
+ #include <shlobj.h>
+ #ifndef NO_DEBUG_CRT
+ #include <crtdbg.h>
+ #endif
+#else
+ // winsock2.h includes windows.h
+ #pragma warning(push,1) /* disable warnings within system headers */
+ #pragma warning(disable:4917)
+ #include <winsock2.h>
+ #include <wsipx.h>
+ #include <shlobj.h>
+ #ifndef NO_DEBUG_CRT
+ #include <crtdbg.h>
+ #endif
+ #pragma warning(pop)
+#endif
+
+#define _MAX_CMD 4096 /* maximum length of commandline */
+/* #define _MAX_ENV 4096 maximum length of environment var (isn't used
anywhere) */
+
+#ifdef GCC
+ # ifndef SA_FAMILY_DECL
+ # define SA_FAMILY_DECL short sa_family
+ # endif
+
+ typedef struct sockaddr_ipx {
+ SA_FAMILY_DECL;
+ char sa_netnum[4];
+ char sa_nodenum[6];
+ unsigned short sa_socket;
+ } SOCKADDR_IPX;
+
+ # define NSPROTO_IPX 1000
+ # define NSPROTO_SPX 1256
+ # define NSPROTO_SPXII 1257
+#endif // #ifdef GCC
+
+#ifdef _DLL_
+
+#ifdef __cplusplus
+ extern "C" DWORD g_dwPlatformId;
+#else
+ extern DWORD g_dwPlatformId;
+#endif // #ifdef __cplusplus
+
+ #define IS_NT (g_dwPlatformId == VER_PLATFORM_WIN32_NT)
+#else
+
+#ifdef __cplusplus
+ extern "C" DWORD GetPlatformId(void);
+#else
+ extern DWORD GetPlatformId(void);
+#endif // #ifdef __cplusplus
+
+ #define IS_NT (GetPlatformId() == VER_PLATFORM_WIN32_NT)
+#endif // #ifdef _DLL_
+
Propchange: openoffice/branches/olcProfileNano/sal/osl/w32/system.h
------------------------------------------------------------------------------
svn:eol-style = native
