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