1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 // MARKER(update_precomp.py): autogen include statement, do not remove 29 #include "precompiled_store.hxx" 30 31 #include "store/store.h" 32 33 #include <sal/types.h> 34 #include <rtl/memory.h> 35 #include <rtl/string.hxx> 36 #include <rtl/ref.hxx> 37 38 #include "object.hxx" 39 #include "lockbyte.hxx" 40 41 #include "storbase.hxx" 42 #include "storpage.hxx" 43 #include "stordir.hxx" 44 #include "storlckb.hxx" 45 46 using rtl::Reference; 47 using rtl::OString; 48 49 namespace store 50 { 51 /** Template helper class as type safe Reference to store_handle_type. 52 */ 53 template<class store_handle_type> 54 class OStoreHandle : public rtl::Reference<store_handle_type> 55 { 56 public: 57 OStoreHandle (store_handle_type * pHandle) 58 : rtl::Reference<store_handle_type> (pHandle) 59 {} 60 61 static store_handle_type * SAL_CALL query (void * pHandle) 62 { 63 return store::query ( 64 static_cast<IStoreHandle*>(pHandle), 65 static_cast<store_handle_type*>(0)); 66 } 67 }; 68 } 69 70 71 using namespace store; 72 73 /*======================================================================== 74 * 75 * storeHandle implementation. 76 * 77 *======================================================================*/ 78 /* 79 * store_acquireHandle. 80 */ 81 storeError SAL_CALL store_acquireHandle ( 82 storeHandle Handle 83 ) SAL_THROW_EXTERN_C() 84 { 85 IStoreHandle *pHandle = static_cast<IStoreHandle*>(Handle); 86 if (!pHandle) 87 return store_E_InvalidHandle; 88 89 pHandle->acquire(); 90 return store_E_None; 91 } 92 93 /* 94 * store_releaseHandle. 95 */ 96 storeError SAL_CALL store_releaseHandle ( 97 storeHandle Handle 98 ) SAL_THROW_EXTERN_C() 99 { 100 IStoreHandle *pHandle = static_cast<IStoreHandle*>(Handle); 101 if (!pHandle) 102 return store_E_InvalidHandle; 103 104 pHandle->release(); 105 return store_E_None; 106 } 107 108 /*======================================================================== 109 * 110 * storeFileHandle implementation. 111 * 112 *======================================================================*/ 113 /* 114 * store_createMemoryFile. 115 */ 116 storeError SAL_CALL store_createMemoryFile ( 117 sal_uInt16 nPageSize, 118 storeFileHandle *phFile 119 ) SAL_THROW_EXTERN_C() 120 { 121 if (!phFile) 122 return store_E_InvalidParameter; 123 *phFile = NULL; 124 125 Reference<ILockBytes> xLockBytes; 126 127 storeError eErrCode = MemoryLockBytes_createInstance(xLockBytes); 128 if (eErrCode != store_E_None) 129 return eErrCode; 130 OSL_ASSERT(xLockBytes.is()); 131 132 Reference<OStorePageManager> xManager (new OStorePageManager()); 133 if (!xManager.is()) 134 return store_E_OutOfMemory; 135 136 eErrCode = xManager->initialize ( 137 &*xLockBytes, store_AccessCreate, nPageSize); 138 if (eErrCode != store_E_None) 139 return eErrCode; 140 141 xManager->acquire(); 142 143 *phFile = (storeFileHandle)&(*xManager); 144 return store_E_None; 145 } 146 147 /* 148 * store_openFile. 149 */ 150 storeError SAL_CALL store_openFile ( 151 rtl_uString *pFilename, 152 storeAccessMode eAccessMode, 153 sal_uInt16 nPageSize, 154 storeFileHandle *phFile 155 ) SAL_THROW_EXTERN_C() 156 { 157 if (phFile) 158 *phFile = NULL; 159 160 if (!(pFilename && phFile)) 161 return store_E_InvalidParameter; 162 163 Reference<ILockBytes> xLockBytes; 164 165 storeError eErrCode = FileLockBytes_createInstance (xLockBytes, pFilename, eAccessMode); 166 if (eErrCode != store_E_None) 167 return eErrCode; 168 OSL_ASSERT(xLockBytes.is()); 169 170 Reference<OStorePageManager> xManager (new OStorePageManager()); 171 if (!xManager.is()) 172 return store_E_OutOfMemory; 173 174 eErrCode = xManager->initialize ( 175 &*xLockBytes, eAccessMode, nPageSize); 176 if (eErrCode != store_E_None) 177 return eErrCode; 178 179 xManager->acquire(); 180 181 *phFile = (storeFileHandle)&(*xManager); 182 return store_E_None; 183 } 184 185 /* 186 * store_closeFile. 187 */ 188 storeError SAL_CALL store_closeFile ( 189 storeFileHandle Handle 190 ) SAL_THROW_EXTERN_C() 191 { 192 OStorePageManager *pManager = 193 OStoreHandle<OStorePageManager>::query (Handle); 194 if (!pManager) 195 return store_E_InvalidHandle; 196 197 storeError eErrCode = pManager->close(); 198 pManager->release(); 199 return eErrCode; 200 } 201 202 /* 203 * store_flushFile. 204 */ 205 storeError SAL_CALL store_flushFile ( 206 storeFileHandle Handle 207 ) SAL_THROW_EXTERN_C() 208 { 209 OStoreHandle<OStorePageManager> xManager ( 210 OStoreHandle<OStorePageManager>::query (Handle)); 211 if (!xManager.is()) 212 return store_E_InvalidHandle; 213 214 return xManager->flush(); 215 } 216 217 /* 218 * store_getFileRefererCount. 219 */ 220 storeError SAL_CALL store_getFileRefererCount ( 221 storeFileHandle Handle, 222 sal_uInt32 *pnRefCount 223 ) SAL_THROW_EXTERN_C() 224 { 225 OStoreHandle<OStorePageManager> xManager ( 226 OStoreHandle<OStorePageManager>::query (Handle)); 227 if (!xManager.is()) 228 return store_E_InvalidHandle; 229 230 if (!pnRefCount) 231 return store_E_InvalidParameter; 232 233 *pnRefCount = xManager->getRefererCount(); 234 return store_E_None; 235 } 236 237 /* 238 * store_getFileSize. 239 */ 240 storeError SAL_CALL store_getFileSize ( 241 storeFileHandle Handle, 242 sal_uInt32 *pnSize 243 ) SAL_THROW_EXTERN_C() 244 { 245 OStoreHandle<OStorePageManager> xManager ( 246 OStoreHandle<OStorePageManager>::query (Handle)); 247 if (!xManager.is()) 248 return store_E_InvalidHandle; 249 250 if (!pnSize) 251 return store_E_InvalidParameter; 252 253 return xManager->size (*pnSize); 254 } 255 256 /* 257 * store_rebuildFile. 258 */ 259 storeError SAL_CALL store_rebuildFile ( 260 rtl_uString *pSrcFilename, 261 rtl_uString *pDstFilename 262 ) SAL_THROW_EXTERN_C() 263 { 264 storeError eErrCode = store_E_None; 265 266 if (!(pSrcFilename && pDstFilename)) 267 return store_E_InvalidParameter; 268 269 Reference<OStorePageManager> xManager (new OStorePageManager()); 270 if (!xManager.is()) 271 return store_E_OutOfMemory; 272 273 Reference<ILockBytes> xSrcLB; 274 eErrCode = FileLockBytes_createInstance (xSrcLB, pSrcFilename, store_AccessReadOnly); 275 if (eErrCode != store_E_None) 276 return eErrCode; 277 OSL_ASSERT(xSrcLB.is()); 278 279 Reference<ILockBytes> xDstLB; 280 eErrCode = FileLockBytes_createInstance (xDstLB, pDstFilename, store_AccessCreate); 281 if (eErrCode != store_E_None) 282 return eErrCode; 283 OSL_ASSERT(xDstLB.is()); 284 285 return xManager->rebuild (&*xSrcLB, &*xDstLB); 286 } 287 288 /*======================================================================== 289 * 290 * storeDirectoryHandle implementation. 291 * 292 *======================================================================*/ 293 /* 294 * store_openDirectory. 295 */ 296 storeError SAL_CALL store_openDirectory ( 297 storeFileHandle hFile, 298 rtl_uString *pPath, 299 rtl_uString *pName, 300 storeAccessMode eAccessMode, 301 storeDirectoryHandle *phDirectory 302 ) SAL_THROW_EXTERN_C() 303 { 304 storeError eErrCode = store_E_None; 305 if (phDirectory) 306 *phDirectory = NULL; 307 308 OStoreHandle<OStorePageManager> xManager ( 309 OStoreHandle<OStorePageManager>::query (hFile)); 310 if (!xManager.is()) 311 return store_E_InvalidHandle; 312 313 if (!(pPath && pName && phDirectory)) 314 return store_E_InvalidParameter; 315 316 Reference<OStoreDirectory_Impl> xDirectory (new OStoreDirectory_Impl()); 317 if (!xDirectory.is()) 318 return store_E_OutOfMemory; 319 320 OString aPath (pPath->buffer, pPath->length, RTL_TEXTENCODING_UTF8); 321 OString aName (pName->buffer, pName->length, RTL_TEXTENCODING_UTF8); 322 323 eErrCode = xDirectory->create (&*xManager, aPath.pData, aName.pData, eAccessMode); 324 if (eErrCode != store_E_None) 325 return eErrCode; 326 327 xDirectory->acquire(); 328 329 *phDirectory = (storeDirectoryHandle)&(*xDirectory); 330 return store_E_None; 331 } 332 333 /* 334 * store_closeDirectory. 335 */ 336 storeError SAL_CALL store_closeDirectory ( 337 storeDirectoryHandle Handle 338 ) SAL_THROW_EXTERN_C() 339 { 340 OStoreDirectory_Impl *pDirectory = 341 OStoreHandle<OStoreDirectory_Impl>::query (Handle); 342 if (!pDirectory) 343 return store_E_InvalidHandle; 344 345 pDirectory->release(); 346 return store_E_None; 347 } 348 349 /* 350 * store_findFirst. 351 */ 352 storeError SAL_CALL store_findFirst ( 353 storeDirectoryHandle Handle, 354 storeFindData *pFindData 355 ) SAL_THROW_EXTERN_C() 356 { 357 OStoreHandle<OStoreDirectory_Impl> xDirectory ( 358 OStoreHandle<OStoreDirectory_Impl>::query (Handle)); 359 if (!xDirectory.is()) 360 return store_E_InvalidHandle; 361 362 if (!pFindData) 363 return store_E_InvalidParameter; 364 365 // Initialize FindData. 366 rtl_zeroMemory (pFindData, sizeof (storeFindData)); 367 368 // Find first. 369 pFindData->m_nReserved = (sal_uInt32)(~0); 370 return xDirectory->iterate (*pFindData); 371 } 372 373 /* 374 * store_findNext. 375 */ 376 storeError SAL_CALL store_findNext ( 377 storeDirectoryHandle Handle, 378 storeFindData *pFindData 379 ) SAL_THROW_EXTERN_C() 380 { 381 OStoreHandle<OStoreDirectory_Impl> xDirectory ( 382 OStoreHandle<OStoreDirectory_Impl>::query (Handle)); 383 if (!xDirectory.is()) 384 return store_E_InvalidHandle; 385 386 if (!pFindData) 387 return store_E_InvalidParameter; 388 389 // Check FindData. 390 if (!pFindData->m_nReserved) 391 return store_E_NoMoreFiles; 392 393 // Find next. 394 pFindData->m_nReserved -= 1; 395 return xDirectory->iterate (*pFindData); 396 } 397 398 /*======================================================================== 399 * 400 * storeStreamHandle implementation. 401 * 402 *======================================================================*/ 403 /* 404 * store_openStream 405 */ 406 storeError SAL_CALL store_openStream ( 407 storeFileHandle hFile, 408 rtl_uString *pPath, 409 rtl_uString *pName, 410 storeAccessMode eAccessMode, 411 storeStreamHandle *phStream 412 ) SAL_THROW_EXTERN_C() 413 { 414 storeError eErrCode = store_E_None; 415 if (phStream) 416 *phStream = NULL; 417 418 OStoreHandle<OStorePageManager> xManager ( 419 OStoreHandle<OStorePageManager>::query (hFile)); 420 if (!xManager.is()) 421 return store_E_InvalidHandle; 422 423 if (!(pPath && pName && phStream)) 424 return store_E_InvalidParameter; 425 426 Reference<OStoreLockBytes> xLockBytes (new OStoreLockBytes()); 427 if (!xLockBytes.is()) 428 return store_E_OutOfMemory; 429 430 OString aPath (pPath->buffer, pPath->length, RTL_TEXTENCODING_UTF8); 431 OString aName (pName->buffer, pName->length, RTL_TEXTENCODING_UTF8); 432 433 eErrCode = xLockBytes->create (&*xManager, aPath.pData, aName.pData, eAccessMode); 434 if (eErrCode != store_E_None) 435 return eErrCode; 436 437 xLockBytes->acquire(); 438 439 *phStream = (storeStreamHandle)&(*xLockBytes); 440 return store_E_None; 441 } 442 443 /* 444 * store_closeStream. 445 */ 446 storeError SAL_CALL store_closeStream ( 447 storeStreamHandle Handle 448 ) SAL_THROW_EXTERN_C() 449 { 450 OStoreLockBytes *pLockBytes = 451 OStoreHandle<OStoreLockBytes>::query (Handle); 452 if (!pLockBytes) 453 return store_E_InvalidHandle; 454 455 pLockBytes->release(); 456 return store_E_None; 457 } 458 459 /* 460 * store_readStream. 461 */ 462 storeError SAL_CALL store_readStream ( 463 storeStreamHandle Handle, 464 sal_uInt32 nOffset, 465 void *pBuffer, 466 sal_uInt32 nBytes, 467 sal_uInt32 *pnDone 468 ) SAL_THROW_EXTERN_C() 469 { 470 OStoreHandle<OStoreLockBytes> xLockBytes ( 471 OStoreHandle<OStoreLockBytes>::query (Handle)); 472 if (!xLockBytes.is()) 473 return store_E_InvalidHandle; 474 475 if (!(pBuffer && pnDone)) 476 return store_E_InvalidParameter; 477 478 return xLockBytes->readAt (nOffset, pBuffer, nBytes, *pnDone); 479 } 480 481 /* 482 * store_writeStream. 483 */ 484 storeError SAL_CALL store_writeStream ( 485 storeStreamHandle Handle, 486 sal_uInt32 nOffset, 487 const void *pBuffer, 488 sal_uInt32 nBytes, 489 sal_uInt32 *pnDone 490 ) SAL_THROW_EXTERN_C() 491 { 492 OStoreHandle<OStoreLockBytes> xLockBytes ( 493 OStoreHandle<OStoreLockBytes>::query (Handle)); 494 if (!xLockBytes.is()) 495 return store_E_InvalidHandle; 496 497 if (!(pBuffer && pnDone)) 498 return store_E_InvalidParameter; 499 500 return xLockBytes->writeAt (nOffset, pBuffer, nBytes, *pnDone); 501 } 502 503 /* 504 * store_flushStream. 505 */ 506 storeError SAL_CALL store_flushStream ( 507 storeStreamHandle Handle 508 ) SAL_THROW_EXTERN_C() 509 { 510 OStoreHandle<OStoreLockBytes> xLockBytes ( 511 OStoreHandle<OStoreLockBytes>::query (Handle)); 512 if (!xLockBytes.is()) 513 return store_E_InvalidHandle; 514 515 return xLockBytes->flush(); 516 } 517 518 /* 519 * store_getStreamSize. 520 */ 521 storeError SAL_CALL store_getStreamSize ( 522 storeStreamHandle Handle, 523 sal_uInt32 *pnSize 524 ) SAL_THROW_EXTERN_C() 525 { 526 OStoreHandle<OStoreLockBytes> xLockBytes ( 527 OStoreHandle<OStoreLockBytes>::query (Handle)); 528 if (!xLockBytes.is()) 529 return store_E_InvalidHandle; 530 531 if (!pnSize) 532 return store_E_InvalidParameter; 533 534 return xLockBytes->stat (*pnSize); 535 } 536 537 /* 538 * store_setStreamSize. 539 */ 540 storeError SAL_CALL store_setStreamSize ( 541 storeStreamHandle Handle, 542 sal_uInt32 nSize 543 ) SAL_THROW_EXTERN_C() 544 { 545 OStoreHandle<OStoreLockBytes> xLockBytes ( 546 OStoreHandle<OStoreLockBytes>::query (Handle)); 547 if (!xLockBytes.is()) 548 return store_E_InvalidHandle; 549 550 return xLockBytes->setSize (nSize); 551 } 552 553 /*======================================================================== 554 * 555 * Common storeDirectoryHandle and storeStreamHandle operations. 556 * 557 *======================================================================*/ 558 /* 559 * store_attrib. 560 */ 561 storeError SAL_CALL store_attrib ( 562 storeFileHandle Handle, 563 rtl_uString *pPath, 564 rtl_uString *pName, 565 sal_uInt32 nMask1, 566 sal_uInt32 nMask2, 567 sal_uInt32 *pnAttrib 568 ) SAL_THROW_EXTERN_C() 569 { 570 storeError eErrCode = store_E_None; 571 if (pnAttrib) 572 *pnAttrib = 0; 573 574 OStoreHandle<OStorePageManager> xManager ( 575 OStoreHandle<OStorePageManager>::query (Handle)); 576 if (!xManager.is()) 577 return store_E_InvalidHandle; 578 579 if (!(pPath && pName)) 580 return store_E_InvalidParameter; 581 582 // Setup page key. 583 OString aPath (pPath->buffer, pPath->length, RTL_TEXTENCODING_UTF8); 584 OString aName (pName->buffer, pName->length, RTL_TEXTENCODING_UTF8); 585 OStorePageKey aKey; 586 587 eErrCode = OStorePageManager::namei (aPath.pData, aName.pData, aKey); 588 if (eErrCode != store_E_None) 589 return eErrCode; 590 591 // Obtain or modify page attributes. 592 sal_uInt32 nAttrib = 0; 593 eErrCode = xManager->attrib (aKey, nMask1, nMask2, nAttrib); 594 if (pnAttrib) 595 *pnAttrib = nAttrib; 596 return eErrCode; 597 } 598 599 /* 600 * store_link. 601 */ 602 storeError SAL_CALL store_link ( 603 storeFileHandle Handle, 604 rtl_uString *pSrcPath, rtl_uString *pSrcName, 605 rtl_uString *pDstPath, rtl_uString *pDstName 606 ) SAL_THROW_EXTERN_C() 607 { 608 storeError eErrCode = store_E_None; 609 610 OStoreHandle<OStorePageManager> xManager ( 611 OStoreHandle<OStorePageManager>::query (Handle)); 612 if (!xManager.is()) 613 return store_E_InvalidHandle; 614 615 if (!(pSrcPath && pSrcName)) 616 return store_E_InvalidParameter; 617 618 if (!(pDstPath && pDstName)) 619 return store_E_InvalidParameter; 620 621 // Setup 'Source' page key. 622 OString aSrcPath ( 623 pSrcPath->buffer, pSrcPath->length, RTL_TEXTENCODING_UTF8); 624 OString aSrcName ( 625 pSrcName->buffer, pSrcName->length, RTL_TEXTENCODING_UTF8); 626 OStorePageKey aSrcKey; 627 628 eErrCode = OStorePageManager::namei ( 629 aSrcPath.pData, aSrcName.pData, aSrcKey); 630 if (eErrCode != store_E_None) 631 return eErrCode; 632 633 // Setup 'Destination' page key. 634 OString aDstPath ( 635 pDstPath->buffer, pDstPath->length, RTL_TEXTENCODING_UTF8); 636 OString aDstName ( 637 pDstName->buffer, pDstName->length, RTL_TEXTENCODING_UTF8); 638 OStorePageKey aDstKey; 639 640 eErrCode = OStorePageManager::namei ( 641 aDstPath.pData, aDstName.pData, aDstKey); 642 if (eErrCode != store_E_None) 643 return eErrCode; 644 645 // Link 'Source' hard to 'Destination'. 646 return xManager->link (aSrcKey, aDstKey); 647 } 648 649 /* 650 * store_symlink. 651 */ 652 storeError SAL_CALL store_symlink ( 653 storeFileHandle Handle, 654 rtl_uString *pSrcPath, rtl_uString *pSrcName, 655 rtl_uString *pDstPath, rtl_uString *pDstName 656 ) SAL_THROW_EXTERN_C() 657 { 658 storeError eErrCode = store_E_None; 659 660 OStoreHandle<OStorePageManager> xManager ( 661 OStoreHandle<OStorePageManager>::query (Handle)); 662 if (!xManager.is()) 663 return store_E_InvalidHandle; 664 665 if (!(pSrcPath && pSrcName)) 666 return store_E_InvalidParameter; 667 668 if (!(pDstPath && pDstName)) 669 return store_E_InvalidParameter; 670 671 // Setup 'Destination' page key. 672 OString aDstPath ( 673 pDstPath->buffer, pDstPath->length, RTL_TEXTENCODING_UTF8); 674 OString aDstName ( 675 pDstName->buffer, pDstName->length, RTL_TEXTENCODING_UTF8); 676 OStorePageKey aDstKey; 677 678 eErrCode = OStorePageManager::namei ( 679 aDstPath.pData, aDstName.pData, aDstKey); 680 if (eErrCode != store_E_None) 681 return eErrCode; 682 683 // Insert 'Source' as symlink to 'Destination'. 684 OString aSrcPath ( 685 pSrcPath->buffer, pSrcPath->length, RTL_TEXTENCODING_UTF8); 686 OString aSrcName ( 687 pSrcName->buffer, pSrcName->length, RTL_TEXTENCODING_UTF8); 688 689 return xManager->symlink (aSrcPath.pData, aSrcName.pData, aDstKey); 690 } 691 692 /* 693 * store_rename. 694 */ 695 storeError SAL_CALL store_rename ( 696 storeFileHandle Handle, 697 rtl_uString *pSrcPath, rtl_uString *pSrcName, 698 rtl_uString *pDstPath, rtl_uString *pDstName 699 ) SAL_THROW_EXTERN_C() 700 { 701 storeError eErrCode = store_E_None; 702 703 OStoreHandle<OStorePageManager> xManager ( 704 OStoreHandle<OStorePageManager>::query (Handle)); 705 if (!xManager.is()) 706 return store_E_InvalidHandle; 707 708 if (!(pSrcPath && pSrcName)) 709 return store_E_InvalidParameter; 710 711 if (!(pDstPath && pDstName)) 712 return store_E_InvalidParameter; 713 714 // Setup 'Source' page key. 715 OString aSrcPath ( 716 pSrcPath->buffer, pSrcPath->length, RTL_TEXTENCODING_UTF8); 717 OString aSrcName ( 718 pSrcName->buffer, pSrcName->length, RTL_TEXTENCODING_UTF8); 719 OStorePageKey aSrcKey; 720 721 eErrCode = OStorePageManager::namei ( 722 aSrcPath.pData, aSrcName.pData, aSrcKey); 723 if (eErrCode != store_E_None) 724 return eErrCode; 725 726 // Rename 'Source' into 'Destination'. 727 OString aDstPath ( 728 pDstPath->buffer, pDstPath->length, RTL_TEXTENCODING_UTF8); 729 OString aDstName ( 730 pDstName->buffer, pDstName->length, RTL_TEXTENCODING_UTF8); 731 732 return xManager->rename (aSrcKey, aDstPath.pData, aDstName.pData); 733 } 734 735 /* 736 * store_remove. 737 */ 738 storeError SAL_CALL store_remove ( 739 storeFileHandle Handle, 740 rtl_uString *pPath, 741 rtl_uString *pName 742 ) SAL_THROW_EXTERN_C() 743 { 744 storeError eErrCode = store_E_None; 745 746 OStoreHandle<OStorePageManager> xManager ( 747 OStoreHandle<OStorePageManager>::query (Handle)); 748 if (!xManager.is()) 749 return store_E_InvalidHandle; 750 751 if (!(pPath && pName)) 752 return store_E_InvalidParameter; 753 754 // Setup page key. 755 OString aPath (pPath->buffer, pPath->length, RTL_TEXTENCODING_UTF8); 756 OString aName (pName->buffer, pName->length, RTL_TEXTENCODING_UTF8); 757 OStorePageKey aKey; 758 759 eErrCode = OStorePageManager::namei (aPath.pData, aName.pData, aKey); 760 if (eErrCode != store_E_None) 761 return eErrCode; 762 763 // Remove. 764 return xManager->remove (aKey); 765 } 766