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