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