store/source/lockbyte.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: lockbyte.cxx,v $
   6  *
   7  *  $Revision: 1.1.2.4 $
   8  *
   9  *  last change: $Author: mhu $ $Date: 2008/11/25 15:44:56 $
  10  *
  11  *  The Contents of this file are made available subject to
  12  *  the terms of GNU Lesser General Public License Version 2.1.
  13  *
  14  *
  15  *    GNU Lesser General Public License Version 2.1
  16  *    =============================================
  17  *    Copyright 2005 by Sun Microsystems, Inc.
  18  *    901 San Antonio Road, Palo Alto, CA 94303, USA
  19  *
  20  *    This library is free software; you can redistribute it and/or
  21  *    modify it under the terms of the GNU Lesser General Public
  22  *    License version 2.1, as published by the Free Software Foundation.
  23  *
  24  *    This library is distributed in the hope that it will be useful,
  25  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27  *    Lesser General Public License for more details.
  28  *
  29  *    You should have received a copy of the GNU Lesser General Public
  30  *    License along with this library; if not, write to the Free Software
  31  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  32  *    MA  02111-1307  USA
  33  *
  34  ************************************************************************/
  35
  36 // MARKER(update_precomp.py): autogen include statement, do not remove
  37 #include "precompiled_store.hxx"
  38
  39 #include "lockbyte.hxx"
  40
  41 #include "sal/types.h"
  42 #include "osl/diagnose.h"
  43 #include "osl/file.h"
  44 #include "osl/process.h"
  45 #include "rtl/alloc.h"
  46 #include "rtl/ustring.hxx"
  47
  48 #include "object.hxx"
  49 #include "storbase.hxx"
  50
  51 #ifndef INCLUDED_STRING_H
  52 #include <string.h>
  53 #define INCLUDED_STRING_H
  54 #endif
  55
  56 using namespace store;
  57
  58 /*========================================================================
  59  *
  60  * ILockBytes (non-virtual interface) implementation.
  61  *
  62  *======================================================================*/
  63
  64 storeError ILockBytes::initialize (rtl::Reference< PageData::Allocator > & rxAllocator, sal_uInt16 nPageSize)
  65 {
  66     OSL_PRECOND((STORE_MINIMUM_PAGESIZE <= nPageSize) && (nPageSize <= STORE_MAXIMUM_PAGESIZE), "invalid PageSize");
  67     return initialize_Impl (rxAllocator, nPageSize);
  68 }
  69
  70 storeError ILockBytes::readPageAt (PageHolder & rPage, sal_uInt32 nOffset)
  71 {
  72     OSL_PRECOND(!(nOffset == STORE_PAGE_NULL), "store::ILockBytes::readPageAt(): invalid Offset");
  73     if (nOffset == STORE_PAGE_NULL)
  74         return store_E_CantSeek;
  75
  76     return readPageAt_Impl (rPage, nOffset);
  77 }
  78
  79 storeError ILockBytes::writePageAt (PageHolder const & rPage, sal_uInt32 nOffset)
  80 {
  81     // [SECURITY:ValInput]
  82     PageData const * pagedata = rPage.get();
  83     OSL_PRECOND(!(pagedata == 0), "store::ILockBytes::writePageAt(): invalid Page");
  84     if (pagedata == 0)
  85         return store_E_InvalidParameter;
  86
  87     sal_uInt32 const offset = pagedata->location();
  88     OSL_PRECOND(!(nOffset != offset), "store::ILockBytes::writePageAt(): inconsistent Offset");
  89     if (nOffset != offset)
  90         return store_E_InvalidParameter;
  91
  92     OSL_PRECOND(!(nOffset == STORE_PAGE_NULL), "store::ILockBytes::writePageAt(): invalid Offset");
  93     if (nOffset == STORE_PAGE_NULL)
  94         return store_E_CantSeek;
  95
  96     return writePageAt_Impl (rPage, nOffset);
  97 }
  98
  99 storeError ILockBytes::readAt (sal_uInt32 nOffset, void * pBuffer, sal_uInt32 nBytes)
 100 {
 101     // [SECURITY:ValInput]
 102     sal_uInt8 * dst_lo = static_cast<sal_uInt8*>(pBuffer);
 103     if (!(dst_lo != 0))
 104         return store_E_InvalidParameter;
 105
 106     sal_uInt8 * dst_hi = dst_lo + nBytes;
 107     if (!(dst_lo < dst_hi))
 108         return (dst_lo > dst_hi) ? store_E_InvalidParameter : store_E_None;
 109
 110     OSL_PRECOND(!(nOffset == STORE_PAGE_NULL), "store::ILockBytes::readAt(): invalid Offset");
 111     if (nOffset == STORE_PAGE_NULL)
 112         return store_E_CantSeek;
 113
 114     sal_uInt64 const src_size = nOffset + nBytes;
 115     if (src_size > SAL_MAX_UINT32)
 116         return store_E_CantSeek;
 117
 118     return readAt_Impl (nOffset, dst_lo, (dst_hi - dst_lo));
 119 }
 120
 121 storeError ILockBytes::writeAt (sal_uInt32 nOffset, void const * pBuffer, sal_uInt32 nBytes)
 122 {
 123     // [SECURITY:ValInput]
 124     sal_uInt8 const * src_lo = static_cast<sal_uInt8 const*>(pBuffer);
 125     if (!(src_lo != 0))
 126         return store_E_InvalidParameter;
 127
 128     sal_uInt8 const * src_hi = src_lo + nBytes;
 129     if (!(src_lo < src_hi))
 130         return (src_lo > src_hi) ? store_E_InvalidParameter : store_E_None;
 131
 132     OSL_PRECOND(!(nOffset == STORE_PAGE_NULL), "store::ILockBytes::writeAt(): invalid Offset");
 133     if (nOffset == STORE_PAGE_NULL)
 134         return store_E_CantSeek;
 135
 136     sal_uInt64 const dst_size = nOffset + nBytes;
 137     if (dst_size > SAL_MAX_UINT32)
 138         return store_E_CantSeek;
 139
 140     return writeAt_Impl (nOffset, src_lo, (src_hi - src_lo));
 141 }
 142
 143 storeError ILockBytes::getSize (sal_uInt32 & rnSize)
 144 {
 145     rnSize = 0;
 146     return getSize_Impl (rnSize);
 147 }
 148
 149 storeError ILockBytes::setSize (sal_uInt32 nSize)
 150 {
 151     return setSize_Impl (nSize);
 152 }
 153
 154 storeError ILockBytes::flush()
 155 {
 156     return flush_Impl();
 157 }
 158
 159 storeError ILockBytes::lockRange (sal_uInt32 nOffset, sal_uInt32 nBytes)
 160 {
 161     OSL_PRECOND(!(nOffset == STORE_PAGE_NULL), "store::ILockBytes::lockRange(): invalid Offset");
 162     if (nOffset == STORE_PAGE_NULL)
 163         return store_E_CantSeek;
 164
 165     sal_uInt64 size = nOffset + nBytes;
 166     if (size > SAL_MAX_UINT32)
 167         return store_E_CantSeek;
 168
 169 #ifdef STORE_FEATURE_LOCKING
 170     return lockRange_Impl (nOffset, nBytes);
 171 #else
 172     return store_E_None; // E_Unsupported
 173 #endif /* STORE_FEATURE_LOCKING */
 174 }
 175
 176 storeError ILockBytes::unlockRange (sal_uInt32 nOffset, sal_uInt32 nBytes)
 177 {
 178     OSL_PRECOND(!(nOffset == STORE_PAGE_NULL), "store::ILockBytes::unlockRange(): invalid Offset");
 179     if (nOffset == STORE_PAGE_NULL)
 180         return store_E_CantSeek;
 181
 182     sal_uInt64 size = nOffset + nBytes;
 183     if (size > SAL_MAX_UINT32)
 184         return store_E_CantSeek;
 185
 186 #ifdef STORE_FEATURE_LOCKING
 187     return unlockRange_Impl (nOffset, nBytes);
 188 #else
 189     return store_E_None; // E_Unsupported
 190 #endif /* STORE_FEATURE_LOCKING */
 191 }
 192
 193 /*========================================================================
 194  *
 195  * FileLockBytes implementation.
 196  *
 197  *======================================================================*/
 198 namespace store
 199 {
 200
 201 struct FileHandle
 202 {
 203     oslFileHandle m_handle;
 204
 205     FileHandle() : m_handle(0) {}
 206
 207     bool operator != (FileHandle const & rhs)
 208     {
 209         return (m_handle != rhs.m_handle);
 210     }
 211
 212     static storeError errorFromNative (oslFileError eErrno)
 213     {
 214         switch (eErrno)
 215         {
 216         case osl_File_E_None:
 217             return store_E_None;
 218
 219         case osl_File_E_NOENT:
 220             return store_E_NotExists;
 221
 222         case osl_File_E_ACCES:
 223         case osl_File_E_PERM:
 224             return store_E_AccessViolation;
 225
 226         case osl_File_E_AGAIN:
 227         case osl_File_E_DEADLK:
 228             return store_E_LockingViolation;
 229
 230         case osl_File_E_BADF:
 231             return store_E_InvalidHandle;
 232
 233         case osl_File_E_INVAL:
 234             return store_E_InvalidParameter;
 235
 236         case osl_File_E_NOMEM:
 237             return store_E_OutOfMemory;
 238
 239         case osl_File_E_NOSPC:
 240             return store_E_OutOfSpace;
 241
 242         case osl_File_E_OVERFLOW:
 243             return store_E_CantSeek;
 244
 245         default:
 246             return store_E_Unknown;
 247         }
 248     }
 249
 250     static sal_uInt32 modeToNative (storeAccessMode eAccessMode)
 251     {
 252         sal_uInt32 nFlags = 0;
 253         switch (eAccessMode)
 254         {
 255         case store_AccessCreate:
 256         case store_AccessReadCreate:
 257             nFlags |= osl_File_OpenFlag_Create;
 258             // fall through
 259         case store_AccessReadWrite:
 260             nFlags |= osl_File_OpenFlag_Write;
 261             // fall through
 262         case store_AccessReadOnly:
 263             nFlags |= osl_File_OpenFlag_Read;
 264             break;
 265         default:
 266             OSL_PRECOND(0, "store::FileHandle: unknown storeAccessMode");
 267         }
 268         return nFlags;
 269     }
 270
 271     storeError initialize (rtl_uString * pFilename, storeAccessMode eAccessMode)
 272     {
 273         // Verify arguments.
 274         sal_uInt32 nFlags = modeToNative (eAccessMode);
 275         if (!pFilename || !nFlags)
 276             return store_E_InvalidParameter;
 277
 278         // Convert into FileUrl.
 279         rtl::OUString aFileUrl;
 280         if (osl_getFileURLFromSystemPath (pFilename, &(aFileUrl.pData)) != osl_File_E_None)
 281         {
 282             // Not system path. Assume file url.
 283             rtl_uString_assign (&(aFileUrl.pData), pFilename);
 284         }
 285         if (aFileUrl.compareToAscii("file://", 7) != 0)
 286         {
 287             // Not file url. Assume relative path.
 288             rtl::OUString aCwdUrl;
 289             (void) osl_getProcessWorkingDir (&(aCwdUrl.pData));
 290
 291             // Absolute file url.
 292             (void) osl_getAbsoluteFileURL (aCwdUrl.pData, aFileUrl.pData, &(aFileUrl.pData));
 293         }
 294
 295         // Acquire handle.
 296         oslFileError result = osl_openFile (aFileUrl.pData, &m_handle, nFlags);
 297         if (result == osl_File_E_EXIST)
 298         {
 299             // Already existing (O_CREAT | O_EXCL).
 300             result = osl_openFile (aFileUrl.pData, &m_handle, osl_File_OpenFlag_Read | osl_File_OpenFlag_Write);
 301             if ((result == osl_File_E_None) && (eAccessMode == store_AccessCreate))
 302             {
 303                 // Truncate existing file.
 304                 result = osl_setFileSize (m_handle, 0);
 305             }
 306         }
 307         if (result != osl_File_E_None)
 308             return errorFromNative(result);
 309         return store_E_None;
 310     }
 311
 312     /** @see FileLockBytes destructor
 313      */
 314     static void closeFile (oslFileHandle hFile)
 315     {
 316         (void) osl_closeFile (hFile);
 317     }
 318
 319     /** @see ResourceHolder<T>::destructor_type
 320      */
 321     struct CloseFile
 322     {
 323         void operator()(FileHandle & rFile) const
 324         {
 325             // Release handle.
 326             closeFile (rFile.m_handle);
 327             rFile.m_handle = 0;
 328         }
 329     };
 330     typedef CloseFile destructor_type;
 331 };
 332
 333 class FileLockBytes :
 334     public store::OStoreObject,
 335     public store::ILockBytes
 336 {
 337     /** Representation.
 338      */
 339     oslFileHandle                         m_hFile;
 340     sal_uInt32                            m_nSize;
 341     rtl::Reference< PageData::Allocator > m_xAllocator;
 342
 343     storeError initSize_Impl (sal_uInt32 & rnSize);
 344
 345     /** ILockBytes implementation.
 346      */
 347     virtual storeError initialize_Impl (rtl::Reference< PageData::Allocator > & rxAllocator, sal_uInt16 nPageSize);
 348
 349     virtual storeError readPageAt_Impl (PageHolder & rPage, sal_uInt32 nOffset);
 350     virtual storeError writePageAt_Impl (PageHolder const & rPage, sal_uInt32 nOffset);
 351
 352     virtual storeError readAt_Impl (sal_uInt32 nOffset, void * pBuffer, sal_uInt32 nBytes);
 353     virtual storeError writeAt_Impl (sal_uInt32 nOffset, void const * pBuffer, sal_uInt32 nBytes);
 354
 355     virtual storeError getSize_Impl (sal_uInt32 & rnSize);
 356     virtual storeError setSize_Impl (sal_uInt32 nSize);
 357
 358     virtual storeError flush_Impl();
 359
 360     /** Not implemented.
 361      */
 362     FileLockBytes (FileLockBytes const &);
 363     FileLockBytes & operator= (FileLockBytes const &);
 364
 365 public:
 366     /** Construction.
 367      */
 368     explicit FileLockBytes (FileHandle & rFile);
 369
 370     /** Delegate multiple inherited IReference.
 371      */
 372     virtual oslInterlockedCount SAL_CALL acquire();
 373     virtual oslInterlockedCount SAL_CALL release();
 374
 375 protected:
 376     /** Destruction.
 377      */
 378     virtual ~FileLockBytes();
 379 };
 380
 381 } // namespace store
 382
 383 FileLockBytes::FileLockBytes (FileHandle & rFile)
 384     : m_hFile (rFile.m_handle), m_nSize (SAL_MAX_UINT32), m_xAllocator()
 385 {
 386 }
 387
 388 FileLockBytes::~FileLockBytes()
 389 {
 390     FileHandle::closeFile (m_hFile);
 391 }
 392
 393 oslInterlockedCount SAL_CALL FileLockBytes::acquire()
 394 {
 395     return OStoreObject::acquire();
 396 }
 397
 398 oslInterlockedCount SAL_CALL FileLockBytes::release()
 399 {
 400     return OStoreObject::release();
 401 }
 402
 403 storeError FileLockBytes::initSize_Impl (sal_uInt32 & rnSize)
 404 {
 405     /* osl_getFileSize() uses slow 'fstat(h, &size)',
 406      * instead of fast 'size = lseek(h, 0, SEEK_END)'.
 407      * so, init size here, and track changes.
 408      */
 409     sal_uInt64 uSize = 0;
 410     oslFileError result = osl_getFileSize (m_hFile, &uSize);
 411     if (result != osl_File_E_None)
 412         return FileHandle::errorFromNative(result);
 413     if (uSize > SAL_MAX_UINT32)
 414         return store_E_CantSeek;
 415
 416     rnSize = sal::static_int_cast<sal_uInt32>(uSize);
 417     return store_E_None;
 418 }
 419
 420 storeError FileLockBytes::initialize_Impl (rtl::Reference< PageData::Allocator > & rxAllocator, sal_uInt16 nPageSize)
 421 {
 422     storeError result = initSize_Impl (m_nSize);
 423     if (result != store_E_None)
 424         return (result);
 425
 426     result = PageData::Allocator::createInstance (rxAllocator, nPageSize);
 427     if (result != store_E_None)
 428         return (result);
 429
 430     // @see readPageAt_Impl().
 431     m_xAllocator = rxAllocator;
 432     return store_E_None;
 433 }
 434
 435 storeError FileLockBytes::readPageAt_Impl (PageHolder & rPage, sal_uInt32 nOffset)
 436 {
 437     if (m_xAllocator.is())
 438     {
 439         PageHolder page (m_xAllocator->construct<PageData>(), m_xAllocator);
 440         page.swap (rPage);
 441     }
 442
 443     if (!m_xAllocator.is())
 444         return store_E_InvalidAccess;
 445     if (!rPage.get())
 446         return store_E_OutOfMemory;
 447
 448     PageData * pagedata = rPage.get();
 449     return readAt_Impl (nOffset, pagedata, pagedata->size());
 450 }
 451
 452 storeError FileLockBytes::writePageAt_Impl (PageHolder const & rPage, sal_uInt32 nOffset)
 453 {
 454     PageData const * pagedata = rPage.get();
 455     OSL_PRECOND(pagedata != 0, "contract violation");
 456     return writeAt_Impl (nOffset, pagedata, pagedata->size());
 457 }
 458
 459 storeError FileLockBytes::readAt_Impl (sal_uInt32 nOffset, void * pBuffer, sal_uInt32 nBytes)
 460 {
 461     sal_uInt64 nDone = 0;
 462     oslFileError result = osl_readFileAt (m_hFile, nOffset, pBuffer, nBytes, &nDone);
 463     if (result != osl_File_E_None)
 464         return FileHandle::errorFromNative(result);
 465     if (nDone != nBytes)
 466         return (nDone != 0) ? store_E_CantRead : store_E_NotExists;
 467     return store_E_None;
 468 }
 469
 470 storeError FileLockBytes::writeAt_Impl (sal_uInt32 nOffset, void const * pBuffer, sal_uInt32 nBytes)
 471 {
 472     sal_uInt64 nDone = 0;
 473     oslFileError result = osl_writeFileAt (m_hFile, nOffset, pBuffer, nBytes, &nDone);
 474     if (result != osl_File_E_None)
 475         return FileHandle::errorFromNative(result);
 476     if (nDone != nBytes)
 477         return store_E_CantWrite;
 478
 479     sal_uInt64 const uSize = nOffset + nBytes;
 480     OSL_PRECOND(uSize < SAL_MAX_UINT32, "store::ILockBytes::writeAt() contract violation");
 481     if (uSize > m_nSize)
 482         m_nSize = sal::static_int_cast<sal_uInt32>(uSize);
 483     return store_E_None;
 484 }
 485
 486 storeError FileLockBytes::getSize_Impl (sal_uInt32 & rnSize)
 487 {
 488     rnSize = m_nSize;
 489     return store_E_None;
 490 }
 491
 492 storeError FileLockBytes::setSize_Impl (sal_uInt32 nSize)
 493 {
 494     oslFileError result = osl_setFileSize (m_hFile, nSize);
 495     if (result != osl_File_E_None)
 496         return FileHandle::errorFromNative(result);
 497
 498     m_nSize = nSize;
 499     return store_E_None;
 500 }
 501
 502 storeError FileLockBytes::flush_Impl()
 503 {
 504     oslFileError result = osl_syncFile (m_hFile);
 505     if (result != osl_File_E_None)
 506         return FileHandle::errorFromNative(result);
 507     return store_E_None;
 508 }
 509
 510 /*========================================================================
 511  *
 512  * MappedLockBytes implementation.
 513  *
 514  *======================================================================*/
 515 namespace store
 516 {
 517
 518 struct FileMapping
 519 {
 520     sal_uInt8 * m_pAddr;
 521     sal_uInt32  m_nSize;
 522
 523     FileMapping() : m_pAddr(0), m_nSize(0) {}
 524
 525     bool operator != (FileMapping const & rhs) const
 526     {
 527         return ((m_pAddr != rhs.m_pAddr) || (m_nSize != rhs.m_nSize));
 528     }
 529
 530     oslFileError initialize (oslFileHandle hFile)
 531     {
 532         // Determine mapping size.
 533         sal_uInt64   uSize  = 0;
 534         oslFileError result = osl_getFileSize (hFile, &uSize);
 535         if (result != osl_File_E_None)
 536             return result;
 537
 538         // [SECURITY:IntOver]
 539         if (uSize > SAL_MAX_UINT32)
 540             return osl_File_E_OVERFLOW;
 541         m_nSize = sal::static_int_cast<sal_uInt32>(uSize);
 542
 543         // Acquire mapping.
 544         return osl_mapFile (hFile, reinterpret_cast<void**>(&m_pAddr), m_nSize, 0, osl_File_MapFlag_RandomAccess);
 545     }
 546
 547     /** @see MappedLockBytes::destructor.
 548      */
 549     static void unmapFile (sal_uInt8 * pAddr, sal_uInt32 nSize)
 550     {
 551         (void) osl_unmapFile (pAddr, nSize);
 552     }
 553
 554     /** @see ResourceHolder<T>::destructor_type
 555      */
 556     struct UnmapFile
 557     {
 558         void operator ()(FileMapping & rMapping) const
 559         {
 560             // Release mapping.
 561             unmapFile (rMapping.m_pAddr, rMapping.m_nSize);
 562             rMapping.m_pAddr = 0, rMapping.m_nSize = 0;
 563         }
 564     };
 565     typedef UnmapFile destructor_type;
 566 };
 567
 568 class MappedLockBytes :
 569     public store::OStoreObject,
 570     public store::PageData::Allocator,
 571     public store::ILockBytes
 572 {
 573     /** Representation.
 574      */
 575     sal_uInt8 * m_pData;
 576     sal_uInt32  m_nSize;
 577     sal_uInt16  m_nPageSize;
 578
 579     /** PageData::Allocator implementation.
 580      */
 581     virtual void allocate_Impl (void ** ppPage, sal_uInt16 * pnSize);
 582     virtual void deallocate_Impl (void * pPage);
 583
 584     /** ILockBytes implementation.
 585      */
 586     virtual storeError initialize_Impl (rtl::Reference< PageData::Allocator > & rxAllocator, sal_uInt16 nPageSize);
 587
 588     virtual storeError readPageAt_Impl (PageHolder & rPage, sal_uInt32 nOffset);
 589     virtual storeError writePageAt_Impl (PageHolder const & rPage, sal_uInt32 nOffset);
 590
 591     virtual storeError readAt_Impl  (sal_uInt32 nOffset, void * pBuffer, sal_uInt32 nBytes);
 592     virtual storeError writeAt_Impl (sal_uInt32 nOffset, const void * pBuffer, sal_uInt32 nBytes);
 593
 594     virtual storeError getSize_Impl (sal_uInt32 & rnSize);
 595     virtual storeError setSize_Impl (sal_uInt32 nSize);
 596
 597     virtual storeError flush_Impl();
 598
 599     /** Not implemented.
 600      */
 601     MappedLockBytes (MappedLockBytes const &);
 602     MappedLockBytes & operator= (MappedLockBytes const &);
 603
 604 public:
 605     /** Construction.
 606      */
 607     explicit MappedLockBytes (FileMapping & rMapping);
 608
 609     /** Delegate multiple inherited IReference.
 610      */
 611     virtual oslInterlockedCount SAL_CALL acquire();
 612     virtual oslInterlockedCount SAL_CALL release();
 613
 614 protected:
 615     /* Destruction.
 616      */
 617     virtual ~MappedLockBytes();
 618 };
 619
 620 } // namespace store
 621
 622 MappedLockBytes::MappedLockBytes (FileMapping & rMapping)
 623     : m_pData (rMapping.m_pAddr), m_nSize (rMapping.m_nSize), m_nPageSize(0)
 624 {
 625 }
 626
 627 MappedLockBytes::~MappedLockBytes()
 628 {
 629     FileMapping::unmapFile (m_pData, m_nSize);
 630 }
 631
 632 oslInterlockedCount SAL_CALL MappedLockBytes::acquire()
 633 {
 634     return OStoreObject::acquire();
 635 }
 636
 637 oslInterlockedCount SAL_CALL MappedLockBytes::release()
 638 {
 639     return OStoreObject::release();
 640 }
 641
 642 void MappedLockBytes::allocate_Impl (void ** ppPage, sal_uInt16 * pnSize)
 643 {
 644     OSL_PRECOND((ppPage != 0) && (pnSize != 0), "contract violation");
 645     *ppPage = 0, *pnSize = m_nPageSize;
 646 }
 647
 648 void MappedLockBytes::deallocate_Impl (void * pPage)
 649 {
 650     OSL_PRECOND((m_pData <= pPage) && (pPage < m_pData + m_nSize), "contract violation");
 651     (void)pPage; // UNUSED
 652 }
 653
 654 storeError MappedLockBytes::initialize_Impl (rtl::Reference< PageData::Allocator > & rxAllocator, sal_uInt16 nPageSize)
 655 {
 656     rxAllocator = this;
 657     m_nPageSize = nPageSize;
 658     return store_E_None;
 659 }
 660
 661 storeError MappedLockBytes::readPageAt_Impl (PageHolder & rPage, sal_uInt32 nOffset)
 662 {
 663     sal_uInt8 * src_lo = m_pData + nOffset;
 664     if ((m_pData > src_lo) || (src_lo >= m_pData + m_nSize))
 665         return store_E_NotExists;
 666
 667     sal_uInt8 * src_hi = src_lo + m_nPageSize;
 668     if ((m_pData > src_hi) || (src_hi > m_pData + m_nSize))
 669         return store_E_CantRead;
 670
 671     PageHolder page (reinterpret_cast< PageData* >(src_lo), static_cast< PageData::Allocator* >(this));
 672     page.swap (rPage);
 673
 674     return store_E_None;
 675 }
 676
 677 storeError MappedLockBytes::writePageAt_Impl (PageHolder const & /*rPage*/, sal_uInt32 /*nOffset*/)
 678 {
 679     return store_E_AccessViolation;
 680 }
 681
 682 storeError MappedLockBytes::readAt_Impl (sal_uInt32 nOffset, void * pBuffer, sal_uInt32 nBytes)
 683 {
 684     sal_uInt8 const * src_lo = m_pData + nOffset;
 685     if ((m_pData > src_lo) || (src_lo >= m_pData + m_nSize))
 686         return store_E_NotExists;
 687
 688     sal_uInt8 const * src_hi = src_lo + nBytes;
 689     if ((m_pData > src_hi) || (src_hi > m_pData + m_nSize))
 690         return store_E_CantRead;
 691
 692     memcpy (pBuffer, src_lo, (src_hi - src_lo));
 693     return store_E_None;
 694 }
 695
 696 storeError MappedLockBytes::writeAt_Impl (sal_uInt32 /*nOffset*/, void const * /*pBuffer*/, sal_uInt32 /*nBytes*/)
 697 {
 698     return store_E_AccessViolation;
 699 }
 700
 701 storeError MappedLockBytes::getSize_Impl (sal_uInt32 & rnSize)
 702 {
 703     rnSize = m_nSize;
 704     return store_E_None;
 705 }
 706
 707 storeError MappedLockBytes::setSize_Impl (sal_uInt32 /*nSize*/)
 708 {
 709     return store_E_AccessViolation;
 710 }
 711
 712 storeError MappedLockBytes::flush_Impl()
 713 {
 714     return store_E_None;
 715 }
 716
 717 /*========================================================================
 718  *
 719  * MemoryLockBytes implementation.
 720  *
 721  *======================================================================*/
 722 namespace store
 723 {
 724
 725 class MemoryLockBytes :
 726     public store::OStoreObject,
 727     public store::ILockBytes
 728 {
 729     /** Representation.
 730      */
 731     sal_uInt8 * m_pData;
 732     sal_uInt32  m_nSize;
 733     rtl::Reference< PageData::Allocator > m_xAllocator;
 734
 735     /** ILockBytes implementation.
 736      */
 737     virtual storeError initialize_Impl (rtl::Reference< PageData::Allocator > & rxAllocator, sal_uInt16 nPageSize);
 738
 739     virtual storeError readPageAt_Impl (PageHolder & rPage, sal_uInt32 nOffset);
 740     virtual storeError writePageAt_Impl (PageHolder const & rPage, sal_uInt32 nOffset);
 741
 742     virtual storeError readAt_Impl  (sal_uInt32 nOffset, void * pBuffer, sal_uInt32 nBytes);
 743     virtual storeError writeAt_Impl (sal_uInt32 nOffset, const void * pBuffer, sal_uInt32 nBytes);
 744
 745     virtual storeError getSize_Impl (sal_uInt32 & rnSize);
 746     virtual storeError setSize_Impl (sal_uInt32 nSize);
 747
 748     virtual storeError flush_Impl();
 749
 750     /** Not implemented.
 751      */
 752     MemoryLockBytes (MemoryLockBytes const &);
 753     MemoryLockBytes& operator= (MemoryLockBytes const &);
 754
 755 public:
 756     /** Construction.
 757      */
 758     MemoryLockBytes();
 759
 760     /** Delegate multiple inherited IReference.
 761      */
 762     virtual oslInterlockedCount SAL_CALL acquire();
 763     virtual oslInterlockedCount SAL_CALL release();
 764
 765 protected:
 766     /** Destruction.
 767      */
 768     virtual ~MemoryLockBytes();
 769 };
 770
 771 } // namespace store
 772
 773 MemoryLockBytes::MemoryLockBytes()
 774     : m_pData (0), m_nSize (0), m_xAllocator()
 775 {}
 776
 777 MemoryLockBytes::~MemoryLockBytes()
 778 {
 779     rtl_freeMemory (m_pData);
 780 }
 781
 782 oslInterlockedCount SAL_CALL MemoryLockBytes::acquire (void)
 783 {
 784     return OStoreObject::acquire();
 785 }
 786
 787 oslInterlockedCount SAL_CALL MemoryLockBytes::release (void)
 788 {
 789     return OStoreObject::release();
 790 }
 791
 792 storeError MemoryLockBytes::initialize_Impl (rtl::Reference< PageData::Allocator > & rxAllocator, sal_uInt16 nPageSize)
 793 {
 794     storeError result = PageData::Allocator::createInstance (rxAllocator, nPageSize);
 795     if (result == store_E_None)
 796     {
 797         // @see readPageAt_Impl().
 798         m_xAllocator = rxAllocator;
 799     }
 800     return result;
 801 }
 802
 803 storeError MemoryLockBytes::readPageAt_Impl (PageHolder & rPage, sal_uInt32 nOffset)
 804 {
 805     if (m_xAllocator.is())
 806     {
 807         PageHolder page (m_xAllocator->construct<PageData>(), m_xAllocator);
 808         page.swap (rPage);
 809     }
 810
 811     if (!m_xAllocator.is())
 812         return store_E_InvalidAccess;
 813     if (!rPage.get())
 814         return store_E_OutOfMemory;
 815
 816     PageData * pagedata = rPage.get();
 817     return readAt_Impl (nOffset, pagedata, pagedata->size());
 818 }
 819
 820 storeError MemoryLockBytes::writePageAt_Impl (PageHolder const & rPage, sal_uInt32 nOffset)
 821 {
 822     PageData const * pagedata = rPage.get();
 823     OSL_PRECOND(!(pagedata == 0), "contract violation");
 824     return writeAt_Impl (nOffset, pagedata, pagedata->size());
 825 }
 826
 827 storeError MemoryLockBytes::readAt_Impl (sal_uInt32 nOffset, void * pBuffer, sal_uInt32 nBytes)
 828 {
 829     sal_uInt8 const * src_lo = m_pData + nOffset;
 830     if ((m_pData > src_lo) || (src_lo >= m_pData + m_nSize))
 831         return store_E_NotExists;
 832
 833     sal_uInt8 const * src_hi = src_lo + nBytes;
 834     if ((m_pData > src_hi) || (src_hi > m_pData + m_nSize))
 835         return store_E_CantRead;
 836
 837     memcpy (pBuffer, src_lo, (src_hi - src_lo));
 838     return store_E_None;
 839 }
 840
 841 storeError MemoryLockBytes::writeAt_Impl (sal_uInt32 nOffset, const void * pBuffer, sal_uInt32 nBytes)
 842 {
 843     sal_uInt64 const dst_size = nOffset + nBytes;
 844     OSL_PRECOND(dst_size < SAL_MAX_UINT32, "store::ILockBytes::writeAt() contract violation");
 845     if (dst_size > m_nSize)
 846     {
 847         storeError eErrCode = setSize_Impl (sal::static_int_cast<sal_uInt32>(dst_size));
 848         if (eErrCode != store_E_None)
 849             return eErrCode;
 850     }
 851     OSL_POSTCOND(dst_size <= m_nSize, "store::MemoryLockBytes::setSize_Impl() contract violation");
 852
 853     sal_uInt8 * dst_lo = m_pData + nOffset;
 854     if (dst_lo >= m_pData + m_nSize)
 855         return store_E_CantSeek;
 856
 857     sal_uInt8 * dst_hi = dst_lo + nBytes;
 858     if (dst_hi > m_pData + m_nSize)
 859         return store_E_CantWrite;
 860
 861     memcpy (dst_lo, pBuffer, (dst_hi - dst_lo));
 862     return store_E_None;
 863 }
 864
 865 storeError MemoryLockBytes::getSize_Impl (sal_uInt32 & rnSize)
 866 {
 867     rnSize = m_nSize;
 868     return store_E_None;
 869 }
 870
 871 storeError MemoryLockBytes::setSize_Impl (sal_uInt32 nSize)
 872 {
 873     if (nSize != m_nSize)
 874     {
 875         sal_uInt8 * pData = reinterpret_cast<sal_uInt8*>(rtl_reallocateMemory (m_pData, nSize));
 876         if (pData != 0)
 877         {
 878             if (nSize > m_nSize)
 879                 memset (pData + m_nSize, 0, sal::static_int_cast<size_t>(nSize - m_nSize));
 880         }
 881         else
 882         {
 883             if (nSize != 0)
 884                 return store_E_OutOfMemory;
 885         }
 886         m_pData = pData, m_nSize = nSize;
 887     }
 888     return store_E_None;
 889 }
 890
 891 storeError MemoryLockBytes::flush_Impl()
 892 {
 893     return store_E_None;
 894 }
 895
 896 /*========================================================================
 897  *
 898  * ILockBytes factory implementations.
 899  *
 900  *======================================================================*/
 901 namespace store
 902 {
 903
 904 template< class T > struct ResourceHolder
 905 {
 906     typedef typename T::destructor_type destructor_type;
 907
 908     T m_value;
 909
 910     explicit ResourceHolder (T const & value = T()) : m_value (value) {}
 911     ~ResourceHolder() { reset(); }
 912
 913     T & get() { return m_value; }
 914     T const & get() const { return m_value; }
 915
 916     void set (T const & value) { m_value = value; }
 917     void reset (T const & value = T())
 918     {
 919         T tmp (m_value);
 920         if (tmp != value)
 921             destructor_type()(tmp);
 922         set (value);
 923     }
 924     T release()
 925     {
 926         T tmp (m_value);
 927         set (T());
 928         return tmp;
 929     }
 930
 931     ResourceHolder (ResourceHolder & rhs)
 932     {
 933         set (rhs.release());
 934     }
 935     ResourceHolder & operator= (ResourceHolder & rhs)
 936     {
 937         reset (rhs.release());
 938         return *this;
 939     }
 940 };
 941
 942 storeError
 943 FileLockBytes_createInstance (
 944     rtl::Reference< ILockBytes > & rxLockBytes,
 945     rtl_uString *                  pFilename,
 946     storeAccessMode                eAccessMode
 947 )
 948 {
 949     // Acquire file handle.
 950     ResourceHolder<FileHandle> xFile;
 951     storeError result = xFile.get().initialize (pFilename, eAccessMode);
 952     if (result != store_E_None)
 953         return (result);
 954
 955     if (eAccessMode == store_AccessReadOnly)
 956     {
 957         ResourceHolder<FileMapping> xMapping;
 958         if (xMapping.get().initialize (xFile.get().m_handle) == osl_File_E_None)
 959         {
 960             rxLockBytes = new MappedLockBytes (xMapping.get());
 961             if (!rxLockBytes.is())
 962                 return store_E_OutOfMemory;
 963             (void) xMapping.release();
 964         }
 965     }
 966     if (!rxLockBytes.is())
 967     {
 968         rxLockBytes = new FileLockBytes (xFile.get());
 969         if (!rxLockBytes.is())
 970             return store_E_OutOfMemory;
 971         (void) xFile.release();
 972     }
 973
 974     return store_E_None;
 975 }
 976
 977 storeError
 978 MemoryLockBytes_createInstance (
 979     rtl::Reference< ILockBytes > & rxLockBytes
 980 )
 981 {
 982     rxLockBytes = new MemoryLockBytes();
 983     if (!rxLockBytes.is())
 984         return store_E_OutOfMemory;
 985
 986     return store_E_None;
 987 }
 988
 989 } // namespace store