store/source/lockbyte.cxx

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