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