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