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