store/source/lockbyte.cxx

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