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