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