store/source/store.cxx

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