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