connectivity/source/drivers/firebird/Blob.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
   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
  10 #include "Blob.hxx"
  11 #include "Util.hxx"
  12
  13 #include <com/sun/star/io/BufferSizeExceededException.hpp>
  14 #include <com/sun/star/io/NotConnectedException.hpp>
  15 #include <com/sun/star/io/IOException.hpp>
  16 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  17 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  18 #include <com/sun/star/sdbc/SQLException.hpp>
  19 #include <connectivity/CommonTools.hxx>
  20 #include <connectivity/dbexception.hxx>
  21 #include <cppuhelper/exc_hlp.hxx>
  22 #include <comphelper/diagnose_ex.hxx>
  23
  24 using namespace ::connectivity::firebird;
  25
  26 using namespace ::cppu;
  27 using namespace ::osl;
  28
  29 using namespace ::com::sun::star;
  30 using namespace ::com::sun::star::io;
  31 using namespace ::com::sun::star::sdbc;
  32 using namespace ::com::sun::star::uno;
  33
  34 Blob::Blob(isc_db_handle* pDatabaseHandle,
  35            isc_tr_handle* pTransactionHandle,
  36            ISC_QUAD const & aBlobID):
  37     Blob_BASE(m_aMutex),
  38     m_pDatabaseHandle(pDatabaseHandle),
  39     m_pTransactionHandle(pTransactionHandle),
  40     m_blobID(aBlobID),
  41 #if SAL_TYPES_SIZEOFPOINTER == 8
  42     m_blobHandle(0),
  43 #else
  44     m_blobHandle(nullptr),
  45 #endif
  46     m_bBlobOpened(false),
  47     m_nBlobLength(0),
  48     m_nMaxSegmentSize(0),
  49     m_nBlobPosition(0)
  50 {
  51 }
  52
  53 void Blob::ensureBlobIsOpened()
  54 {
  55     MutexGuard aGuard(m_aMutex);
  56
  57     if (m_bBlobOpened)
  58         return;
  59
  60     ISC_STATUS aErr;
  61     aErr = isc_open_blob2(m_statusVector,
  62                           m_pDatabaseHandle,
  63                           m_pTransactionHandle,
  64                           &m_blobHandle,
  65                           &m_blobID,
  66                           0,
  67                           nullptr);
  68
  69     if (aErr)
  70         evaluateStatusVector(m_statusVector, u"isc_open_blob2", *this);
  71
  72     m_bBlobOpened = true;
  73     m_nBlobPosition = 0;
  74
  75     char aBlobItems[] = {
  76         isc_info_blob_total_length,
  77         isc_info_blob_max_segment
  78     };
  79
  80     // Assuming a data (e.g. length of blob) is maximum 64 bit.
  81     // That means we need 8 bytes for data + 2 for length of data + 1 for item
  82     // identifier for each item.
  83     char aResultBuffer[11 + 11];
  84
  85     aErr = isc_blob_info(m_statusVector,
  86                   &m_blobHandle,
  87                   sizeof(aBlobItems),
  88                   aBlobItems,
  89                   sizeof(aResultBuffer),
  90                   aResultBuffer);
  91
  92     if (aErr)
  93         evaluateStatusVector(m_statusVector, u"isc_blob_info", *this);
  94
  95     char* pIt = aResultBuffer;
  96     while( *pIt != isc_info_end ) // info is in clusters
  97     {
  98         char item = *pIt++;
  99         short aResultLength = static_cast<short>(isc_vax_integer(pIt, 2));
 100
 101         pIt += 2;
 102         switch(item)
 103         {
 104             case isc_info_blob_total_length:
 105                 m_nBlobLength = isc_vax_integer(pIt, aResultLength);
 106                 break;
 107             case isc_info_blob_max_segment:
 108                 m_nMaxSegmentSize = isc_vax_integer(pIt, aResultLength);
 109                 break;
 110             default:
 111                 assert(false);
 112                 break;
 113         }
 114         pIt += aResultLength;
 115     }
 116 }
 117
 118 sal_uInt16 Blob::getMaximumSegmentSize()
 119 {
 120     ensureBlobIsOpened();
 121
 122     return m_nMaxSegmentSize;
 123 }
 124
 125 bool Blob::readOneSegment(std::vector<char>& rDataOut)
 126 {
 127     checkDisposed(Blob_BASE::rBHelper.bDisposed);
 128     ensureBlobIsOpened();
 129
 130     sal_uInt16 nMaxSize = getMaximumSegmentSize();
 131
 132     if(rDataOut.size() < nMaxSize)
 133         rDataOut.resize(nMaxSize);
 134
 135     sal_uInt16 nActualSize = 0;
 136     ISC_STATUS aRet = isc_get_segment(m_statusVector,
 137             &m_blobHandle,
 138             &nActualSize,
 139             nMaxSize,
 140             rDataOut.data() );
 141
 142     if (aRet && aRet != isc_segstr_eof && IndicatesError(m_statusVector))
 143     {
 144         OUString sError(StatusVectorToString(m_statusVector, u"isc_get_segment"));
 145         throw IOException(sError, *this);
 146     }
 147
 148     if (rDataOut.size() > nActualSize)
 149         rDataOut.resize(nActualSize);
 150     m_nBlobPosition += nActualSize;
 151     return aRet == isc_segstr_eof;  // last segment read
 152 }
 153
 154
 155 void Blob::closeBlob()
 156 {
 157     MutexGuard aGuard(m_aMutex);
 158
 159     if (!m_bBlobOpened)
 160         return;
 161
 162     ISC_STATUS aErr;
 163     aErr = isc_close_blob(m_statusVector,
 164                           &m_blobHandle);
 165     if (aErr)
 166         evaluateStatusVector(m_statusVector, u"isc_close_blob", *this);
 167
 168     m_bBlobOpened = false;
 169 #if SAL_TYPES_SIZEOFPOINTER == 8
 170     m_blobHandle = 0;
 171 #else
 172     m_blobHandle = nullptr;
 173 #endif
 174 }
 175
 176 void SAL_CALL Blob::disposing()
 177 {
 178     try
 179     {
 180          closeBlob();
 181     }
 182     catch (const SQLException &)
 183     {
 184         // we cannot throw any exceptions here...
 185         TOOLS_WARN_EXCEPTION("connectivity.firebird", "isc_close_blob failed");
 186         assert(false);
 187     }
 188     Blob_BASE::disposing();
 189 }
 190
 191 sal_Int64 SAL_CALL Blob::length()
 192 {
 193     MutexGuard aGuard(m_aMutex);
 194     checkDisposed(Blob_BASE::rBHelper.bDisposed);
 195     ensureBlobIsOpened();
 196
 197     return m_nBlobLength;
 198 }
 199
 200 uno::Sequence< sal_Int8 > SAL_CALL  Blob::getBytes(sal_Int64 nPosition,
 201                                                    sal_Int32 nBytes)
 202 {
 203     MutexGuard aGuard(m_aMutex);
 204     checkDisposed(Blob_BASE::rBHelper.bDisposed);
 205     ensureBlobIsOpened();
 206
 207     if (nPosition > m_nBlobLength || nPosition < 1)
 208         throw lang::IllegalArgumentException(u"nPosition out of range"_ustr, *this, 0);
 209     // We only have to read as many bytes as are available, i.e. nPosition+nBytes
 210     // can legally be greater than the total length, hence we don't bother to check.
 211
 212     if (nPosition -1 < m_nBlobPosition)
 213     {
 214         // Resets to the beginning (we can't seek these blobs)
 215         closeBlob();
 216         ensureBlobIsOpened();
 217     }
 218
 219     // nPosition is indexed from 1.
 220     skipBytes(nPosition - m_nBlobPosition -1 );
 221
 222     // Don't bother preallocating: readBytes does the appropriate calculations
 223     // and reallocates for us.
 224     uno::Sequence< sal_Int8 > aBytes;
 225     readBytes(aBytes, nBytes);
 226     return aBytes;
 227 }
 228
 229 uno::Reference< XInputStream > SAL_CALL  Blob::getBinaryStream()
 230 {
 231     return this;
 232 }
 233
 234 sal_Int64 SAL_CALL  Blob::position(const uno::Sequence< sal_Int8 >& /*rPattern*/,
 235                                    sal_Int64 /*nStart*/)
 236 {
 237     ::dbtools::throwFeatureNotImplementedSQLException(u"Blob::position"_ustr, *this);
 238 }
 239
 240 sal_Int64 SAL_CALL  Blob::positionOfBlob(const uno::Reference< XBlob >& /*rPattern*/,
 241                                          sal_Int64 /*aStart*/)
 242 {
 243     ::dbtools::throwFeatureNotImplementedSQLException(u"Blob::positionOfBlob"_ustr, *this);
 244 }
 245
 246 // ---- XInputStream ----------------------------------------------------------
 247
 248 sal_Int32 SAL_CALL Blob::readBytes(uno::Sequence< sal_Int8 >& rDataOut,
 249                                    sal_Int32 nBytes)
 250 {
 251     MutexGuard aGuard(m_aMutex);
 252
 253     try
 254     {
 255         checkDisposed(Blob_BASE::rBHelper.bDisposed);
 256         ensureBlobIsOpened();
 257     }
 258     catch (const NotConnectedException&)
 259     {
 260         throw;
 261     }
 262     catch (const BufferSizeExceededException&)
 263     {
 264         throw;
 265     }
 266     catch (const IOException&)
 267     {
 268         throw;
 269     }
 270     catch (const RuntimeException&)
 271     {
 272         throw;
 273     }
 274     catch (const Exception& e)
 275     {
 276         css::uno::Any a(cppu::getCaughtException());
 277         throw css::lang::WrappedTargetRuntimeException(
 278             "wrapped Exception " + e.Message,
 279             css::uno::Reference<css::uno::XInterface>(), a);
 280     }
 281
 282     // Ensure we have enough space for the amount of data we can actually read.
 283     const sal_Int64 nBytesAvailable = m_nBlobLength - m_nBlobPosition;
 284     const sal_Int32 nBytesToRead = std::min<sal_Int64>(nBytes, nBytesAvailable);
 285
 286     if (rDataOut.getLength() < nBytesToRead)
 287         rDataOut.realloc(nBytesToRead);
 288
 289     sal_Int32 nTotalBytesRead = 0;
 290     ISC_STATUS aErr;
 291     while (nTotalBytesRead < nBytesToRead)
 292     {
 293         sal_uInt16 nBytesRead = 0;
 294         sal_uInt64 nDataRemaining = nBytesToRead - nTotalBytesRead;
 295         sal_uInt16 nReadSize = std::min<sal_uInt64>(nDataRemaining, SAL_MAX_UINT16);
 296         aErr = isc_get_segment(m_statusVector,
 297                                &m_blobHandle,
 298                                &nBytesRead,
 299                                nReadSize,
 300                                reinterpret_cast<char*>(rDataOut.getArray()) + nTotalBytesRead);
 301         if (aErr && IndicatesError(m_statusVector))
 302         {
 303             OUString sError(StatusVectorToString(m_statusVector, u"isc_get_segment"));
 304             throw IOException(sError, *this);
 305         }
 306         nTotalBytesRead += nBytesRead;
 307         m_nBlobPosition += nBytesRead;
 308     }
 309
 310     return nTotalBytesRead;
 311 }
 312
 313 sal_Int32 SAL_CALL Blob::readSomeBytes(uno::Sequence< sal_Int8 >& rDataOut,
 314                                 sal_Int32 nMaximumBytes)
 315 {
 316     // We don't have any way of verifying how many bytes are immediately available,
 317     // hence we just pass through direct to readBytes
 318     // (Spec: "reads the available number of bytes, at maximum nMaxBytesToRead.")
 319     return readBytes(rDataOut, nMaximumBytes);
 320 }
 321
 322 void SAL_CALL Blob::skipBytes(sal_Int32 nBytesToSkip)
 323 {
 324     // There is no way of directly skipping, hence we have to pretend to skip
 325     // by reading & discarding the data.
 326     uno::Sequence< sal_Int8 > aBytes;
 327     readBytes(aBytes, nBytesToSkip);
 328 }
 329
 330 sal_Int32 SAL_CALL Blob::available()
 331 {
 332     MutexGuard aGuard(m_aMutex);
 333
 334     try
 335     {
 336         checkDisposed(Blob_BASE::rBHelper.bDisposed);
 337         ensureBlobIsOpened();
 338     }
 339     catch (const NotConnectedException&)
 340     {
 341         throw;
 342     }
 343     catch (const IOException&)
 344     {
 345         throw;
 346     }
 347     catch (const RuntimeException&)
 348     {
 349         throw;
 350     }
 351     catch (const Exception& e)
 352     {
 353         css::uno::Any a(cppu::getCaughtException());
 354         throw css::lang::WrappedTargetRuntimeException(
 355             "wrapped Exception " + e.Message,
 356             css::uno::Reference<css::uno::XInterface>(), a);
 357     }
 358
 359     return m_nBlobLength - m_nBlobPosition;
 360 }
 361
 362 void SAL_CALL Blob::closeInput()
 363 {
 364     try
 365     {
 366         closeBlob();
 367     }
 368     catch (const NotConnectedException&)
 369     {
 370         throw;
 371     }
 372     catch (const IOException&)
 373     {
 374         throw;
 375     }
 376     catch (const RuntimeException&)
 377     {
 378         throw;
 379     }
 380     catch (const Exception& e)
 381     {
 382         css::uno::Any a(cppu::getCaughtException());
 383         throw css::lang::WrappedTargetRuntimeException(
 384             "wrapped Exception " + e.Message,
 385             css::uno::Reference<css::uno::XInterface>(), a);
 386     }
 387 }
 388
 389 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */