connectivity/source/drivers/firebird/Connection.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  * 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 "Blob.hxx"
  21 #include "Catalog.hxx"
  22 #include "Clob.hxx"
  23 #include "Connection.hxx"
  24 #include "DatabaseMetaData.hxx"
  25 #include "Driver.hxx"
  26 #include "PreparedStatement.hxx"
  27 #include "Statement.hxx"
  28 #include "Util.hxx"
  29
  30 #include <stdexcept>
  31
  32 #include <com/sun/star/document/XDocumentEventBroadcaster.hpp>
  33 #include <com/sun/star/embed/ElementModes.hpp>
  34 #include <com/sun/star/io/XStream.hpp>
  35 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  36 #include <com/sun/star/sdbc/SQLException.hpp>
  37 #include <com/sun/star/sdbc/XRow.hpp>
  38 #include <com/sun/star/sdbc/TransactionIsolation.hpp>
  39 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
  40 #include <com/sun/star/ucb/XSimpleFileAccess2.hpp>
  41
  42 #include <connectivity/dbexception.hxx>
  43 #include <strings.hrc>
  44 #include <resource/sharedresources.hxx>
  45
  46 #include <comphelper/processfactory.hxx>
  47 #include <comphelper/servicehelper.hxx>
  48 #include <comphelper/storagehelper.hxx>
  49 #include <cppuhelper/exc_hlp.hxx>
  50 #include <cppuhelper/typeprovider.hxx>
  51 #include <unotools/tempfile.hxx>
  52 #include <unotools/localfilehelper.hxx>
  53
  54 #include <osl/file.hxx>
  55 #include <rtl/strbuf.hxx>
  56 #include <sal/log.hxx>
  57
  58 using namespace connectivity::firebird;
  59 using namespace connectivity;
  60
  61 using namespace ::osl;
  62
  63 using namespace ::com::sun::star;
  64 using namespace ::com::sun::star::beans;
  65 using namespace ::com::sun::star::container;
  66 using namespace ::com::sun::star::document;
  67 using namespace ::com::sun::star::embed;
  68 using namespace ::com::sun::star::io;
  69 using namespace ::com::sun::star::lang;
  70 using namespace ::com::sun::star::sdbc;
  71 using namespace ::com::sun::star::sdbcx;
  72 using namespace ::com::sun::star::uno;
  73
  74 /**
  75  * Location within the .odb that an embedded .fdb will be stored.
  76  * Only relevant for embedded dbs.
  77  */
  78 constexpr OUStringLiteral our_sFDBLocation( u"firebird.fdb" );
  79 /**
  80  * Older version of LO may store the database in a .fdb file
  81  */
  82 constexpr OUStringLiteral our_sFBKLocation( u"firebird.fbk" );
  83
  84 Connection::Connection()
  85     : Connection_BASE(m_aMutex)
  86     , m_sConnectionURL()
  87     , m_sFirebirdURL()
  88     , m_bIsEmbedded(false)
  89     , m_bIsFile(false)
  90     , m_bIsAutoCommit(true)
  91     , m_bIsReadOnly(false)
  92     , m_aTransactionIsolation(TransactionIsolation::REPEATABLE_READ)
  93 #if SAL_TYPES_SIZEOFPOINTER == 8
  94     , m_aDBHandle(0)
  95     , m_aTransactionHandle(0)
  96 #else
  97     , m_aDBHandle(nullptr)
  98     , m_aTransactionHandle(nullptr)
  99 #endif
 100     , m_xCatalog(nullptr)
 101     , m_xMetaData(nullptr)
 102     , m_aStatements()
 103 {
 104 }
 105
 106 Connection::~Connection()
 107 {
 108     if(!isClosed())
 109         close();
 110 }
 111
 112 namespace {
 113
 114 struct ConnectionGuard
 115 {
 116     oslInterlockedCount& m_refCount;
 117     explicit ConnectionGuard(oslInterlockedCount& refCount)
 118         : m_refCount(refCount)
 119     {
 120         osl_atomic_increment(&m_refCount);
 121     }
 122     ~ConnectionGuard()
 123     {
 124         osl_atomic_decrement(&m_refCount);
 125     }
 126 };
 127
 128 }
 129
 130 void Connection::construct(const OUString& url, const Sequence< PropertyValue >& info)
 131 {
 132     ConnectionGuard aGuard(m_refCount);
 133
 134     try
 135     {
 136         m_sConnectionURL = url;
 137
 138         bool bIsNewDatabase = false;
 139         // the database may be stored as an
 140         // fdb file in older versions
 141         bool bIsFdbStored = false;
 142         if (url == "sdbc:embedded:firebird")
 143         {
 144             m_bIsEmbedded = true;
 145
 146             const PropertyValue* pIter = info.getConstArray();
 147             const PropertyValue* pEnd = pIter + info.getLength();
 148
 149             for (;pIter != pEnd; ++pIter)
 150             {
 151                 if ( pIter->Name == "Storage" )
 152                 {
 153                     m_xEmbeddedStorage.set(pIter->Value,UNO_QUERY);
 154                 }
 155                 else if ( pIter->Name == "Document" )
 156                 {
 157                     pIter->Value >>= m_xParentDocument;
 158                 }
 159             }
 160
 161             if ( !m_xEmbeddedStorage.is() )
 162             {
 163                 ::connectivity::SharedResources aResources;
 164                 const OUString sMessage = aResources.getResourceString(STR_NO_STORAGE);
 165                 ::dbtools::throwGenericSQLException(sMessage ,*this);
 166             }
 167
 168             bIsNewDatabase = !m_xEmbeddedStorage->hasElements();
 169
 170             m_pDatabaseFileDir.reset(new ::utl::TempFile(nullptr, true));
 171             m_pDatabaseFileDir->EnableKillingFile();
 172             m_sFirebirdURL = m_pDatabaseFileDir->GetFileName() + "/firebird.fdb";
 173             m_sFBKPath = m_pDatabaseFileDir->GetFileName() + "/firebird.fbk";
 174
 175             SAL_INFO("connectivity.firebird", "Temporary .fdb location:  " << m_sFirebirdURL);
 176
 177             if (!bIsNewDatabase)
 178             {
 179                 if (m_xEmbeddedStorage->hasByName(our_sFBKLocation) &&
 180                     m_xEmbeddedStorage->isStreamElement(our_sFBKLocation))
 181                 {
 182                     SAL_INFO("connectivity.firebird", "Extracting* .fbk from .odb" );
 183                     loadDatabaseFile(our_sFBKLocation, m_sFBKPath);
 184                 }
 185                 else if(m_xEmbeddedStorage->hasByName(our_sFDBLocation) &&
 186                         m_xEmbeddedStorage->isStreamElement(our_sFDBLocation))
 187                 {
 188                     SAL_INFO("connectivity.firebird", "Found .fdb instead of .fbk");
 189                     bIsFdbStored = true;
 190                     loadDatabaseFile(our_sFDBLocation, m_sFirebirdURL);
 191                 }
 192                 else
 193                 {
 194                     // There might be files which are not firebird databases.
 195                     // This is not a problem.
 196                     bIsNewDatabase = true;
 197                 }
 198             }
 199             // TODO: Get DB properties from XML
 200
 201         }
 202         // External file AND/OR remote connection
 203         else if (url.startsWith("sdbc:firebird:"))
 204         {
 205             m_sFirebirdURL = url.copy(OUString("sdbc:firebird:").getLength());
 206             if (m_sFirebirdURL.startsWith("file://"))
 207             {
 208                 m_bIsFile = true;
 209                 uno::Reference< ucb::XSimpleFileAccess > xFileAccess =
 210                     ucb::SimpleFileAccess::create(comphelper::getProcessComponentContext());
 211                 if (!xFileAccess->exists(m_sFirebirdURL))
 212                     bIsNewDatabase = true;
 213
 214                 osl::FileBase::getSystemPathFromFileURL(m_sFirebirdURL, m_sFirebirdURL);
 215             }
 216         }
 217
 218         std::string dpbBuffer;
 219         {
 220             char userName[256] = "";
 221             char userPassword[256] = "";
 222
 223             dpbBuffer.push_back(isc_dpb_version1);
 224             dpbBuffer.push_back(isc_dpb_sql_dialect);
 225             dpbBuffer.push_back(1); // 1 byte long
 226             dpbBuffer.push_back(FIREBIRD_SQL_DIALECT);
 227
 228             // set UTF8 as default character set of the database
 229             const char sCharset[] = "UTF8";
 230             dpbBuffer.push_back(isc_dpb_set_db_charset);
 231             dpbBuffer.push_back(sizeof(sCharset) - 1);
 232             dpbBuffer.append(sCharset);
 233             // set UTF8 as default character set of the connection
 234             dpbBuffer.push_back(isc_dpb_lc_ctype);
 235             dpbBuffer.push_back(sizeof(sCharset) - 1);
 236             dpbBuffer.append(sCharset);
 237
 238             // Do any more dpbBuffer additions here
 239
 240             if (m_bIsEmbedded || m_bIsFile)
 241             {
 242                 strcpy(userName,"sysdba");
 243                 strcpy(userPassword,"masterkey");
 244             }
 245             else
 246             {
 247                 // TODO: parse password from connection string as needed?
 248             }
 249
 250             if (strlen(userName))
 251             {
 252                 int nUsernameLength = strlen(userName);
 253                 dpbBuffer.push_back(isc_dpb_user_name);
 254                 dpbBuffer.push_back(nUsernameLength);
 255                 dpbBuffer.append(userName);
 256             }
 257
 258             if (strlen(userPassword))
 259             {
 260                 int nPasswordLength = strlen(userPassword);
 261                 dpbBuffer.push_back(isc_dpb_password);
 262                 dpbBuffer.push_back(nPasswordLength);
 263                 dpbBuffer.append(userPassword);
 264             }
 265         }
 266
 267         ISC_STATUS_ARRAY status;            /* status vector */
 268         ISC_STATUS aErr;
 269         const OString sFirebirdURL = OUStringToOString(m_sFirebirdURL, RTL_TEXTENCODING_UTF8);
 270         if (bIsNewDatabase)
 271         {
 272             aErr = isc_create_database(status,
 273                                        sFirebirdURL.getLength(),
 274                                        sFirebirdURL.getStr(),
 275                                        &m_aDBHandle,
 276                                        dpbBuffer.size(),
 277                                        dpbBuffer.c_str(),
 278                                        0);
 279             if (aErr)
 280             {
 281                 evaluateStatusVector(status, u"isc_create_database", *this);
 282             }
 283         }
 284         else
 285         {
 286             if (m_bIsEmbedded && !bIsFdbStored) // We need to restore the .fbk first
 287             {
 288                 runBackupService(isc_action_svc_restore);
 289             }
 290
 291             aErr = isc_attach_database(status,
 292                                        sFirebirdURL.getLength(),
 293                                        sFirebirdURL.getStr(),
 294                                        &m_aDBHandle,
 295                                        dpbBuffer.size(),
 296                                        dpbBuffer.c_str());
 297             if (aErr)
 298             {
 299                 evaluateStatusVector(status, u"isc_attach_database", *this);
 300             }
 301         }
 302
 303         if (m_bIsEmbedded) // Add DocumentEventListener to save the .fdb as needed
 304         {
 305             // We need to attach as a document listener in order to be able to store
 306             // the temporary db back into the .odb when saving
 307             uno::Reference<XDocumentEventBroadcaster> xBroadcaster(m_xParentDocument, UNO_QUERY);
 308
 309             if (xBroadcaster.is())
 310                 xBroadcaster->addDocumentEventListener(this);
 311             else
 312                 assert(false);
 313         }
 314     }
 315     catch (const Exception&)
 316     {
 317         throw;
 318     }
 319     catch (const std::exception&)
 320     {
 321         throw;
 322     }
 323     catch (...) // const Firebird::Exception& firebird throws this, but doesn't install the fb_exception.h that declares it
 324
 325     {
 326         throw std::runtime_error("Generic Firebird::Exception");
 327     }
 328 }
 329
 330 void Connection::notifyDatabaseModified()
 331 {
 332     if (m_xParentDocument.is()) // Only true in embedded mode
 333         m_xParentDocument->setModified(true);
 334 }
 335
 336 //----- XServiceInfo ---------------------------------------------------------
 337 IMPLEMENT_SERVICE_INFO(Connection, "com.sun.star.sdbc.drivers.firebird.Connection",
 338                                                     "com.sun.star.sdbc.Connection")
 339
 340 Reference< XBlob> Connection::createBlob(ISC_QUAD const * pBlobId)
 341 {
 342     MutexGuard aGuard(m_aMutex);
 343     checkDisposed(Connection_BASE::rBHelper.bDisposed);
 344
 345     Reference< XBlob > xReturn = new Blob(&m_aDBHandle,
 346                                           &m_aTransactionHandle,
 347                                           *pBlobId);
 348
 349     m_aStatements.push_back(WeakReferenceHelper(xReturn));
 350     return xReturn;
 351 }
 352
 353 Reference< XClob> Connection::createClob(ISC_QUAD const * pBlobId)
 354 {
 355     MutexGuard aGuard(m_aMutex);
 356     checkDisposed(Connection_BASE::rBHelper.bDisposed);
 357
 358     Reference< XClob > xReturn = new Clob(&m_aDBHandle,
 359                                           &m_aTransactionHandle,
 360                                           *pBlobId);
 361
 362     m_aStatements.push_back(WeakReferenceHelper(xReturn));
 363     return xReturn;
 364 }
 365
 366 //----- XUnoTunnel ----------------------------------------------------------
 367 // virtual
 368 sal_Int64 SAL_CALL Connection::getSomething(const css::uno::Sequence<sal_Int8>& rId)
 369 {
 370     return (isUnoTunnelId<Connection>(rId)) ? reinterpret_cast<sal_Int64>(this) : sal_Int64(0);
 371 }
 372
 373 // static
 374 css::uno::Sequence<sal_Int8> Connection::getUnoTunnelId()
 375 {
 376     static const cppu::OImplementationId implId;
 377     return implId.getImplementationId();
 378 }
 379
 380 //----- XConnection ----------------------------------------------------------
 381 Reference< XStatement > SAL_CALL Connection::createStatement( )
 382 {
 383     MutexGuard aGuard( m_aMutex );
 384     checkDisposed(Connection_BASE::rBHelper.bDisposed);
 385
 386     // the pre
 387     if(m_aTypeInfo.empty())
 388         buildTypeInfo();
 389
 390     // create a statement
 391     // the statement can only be executed once
 392     Reference< XStatement > xReturn = new OStatement(this);
 393     m_aStatements.push_back(WeakReferenceHelper(xReturn));
 394     return xReturn;
 395 }
 396
 397 Reference< XPreparedStatement > SAL_CALL Connection::prepareStatement(
 398             const OUString& _sSql)
 399 {
 400     SAL_INFO("connectivity.firebird", "prepareStatement() "
 401              "called with sql: " << _sSql);
 402     MutexGuard aGuard(m_aMutex);
 403     checkDisposed(Connection_BASE::rBHelper.bDisposed);
 404
 405     if(m_aTypeInfo.empty())
 406         buildTypeInfo();
 407
 408     Reference< XPreparedStatement > xReturn = new OPreparedStatement(this, _sSql);
 409     m_aStatements.push_back(WeakReferenceHelper(xReturn));
 410
 411     return xReturn;
 412 }
 413
 414 Reference< XPreparedStatement > SAL_CALL Connection::prepareCall(
 415                 const OUString& _sSql )
 416 {
 417     SAL_INFO("connectivity.firebird", "prepareCall(). "
 418              "_sSql: " << _sSql);
 419
 420     MutexGuard aGuard( m_aMutex );
 421     checkDisposed(Connection_BASE::rBHelper.bDisposed);
 422
 423     // OUString sSqlStatement (transformPreparedStatement( _sSql ));
 424
 425     // not implemented yet :-) a task to do
 426     return nullptr;
 427 }
 428
 429 OUString SAL_CALL Connection::nativeSQL( const OUString& _sSql )
 430 {
 431     MutexGuard aGuard( m_aMutex );
 432     // We do not need to adapt the SQL for Firebird atm.
 433     return _sSql;
 434 }
 435
 436 void SAL_CALL Connection::setAutoCommit( sal_Bool autoCommit )
 437 {
 438     MutexGuard aGuard( m_aMutex );
 439     checkDisposed(Connection_BASE::rBHelper.bDisposed);
 440
 441     m_bIsAutoCommit = autoCommit;
 442
 443     if (m_aTransactionHandle)
 444     {
 445         setupTransaction();
 446     }
 447 }
 448
 449 sal_Bool SAL_CALL Connection::getAutoCommit()
 450 {
 451     MutexGuard aGuard( m_aMutex );
 452     checkDisposed(Connection_BASE::rBHelper.bDisposed);
 453
 454     return m_bIsAutoCommit;
 455 }
 456
 457 void Connection::setupTransaction()
 458 {
 459     MutexGuard aGuard( m_aMutex );
 460     ISC_STATUS status_vector[20];
 461
 462     // TODO: is this sensible? If we have changed parameters then transaction
 463     // is lost...
 464     if (m_aTransactionHandle)
 465     {
 466         disposeStatements();
 467         isc_rollback_transaction(status_vector, &m_aTransactionHandle);
 468     }
 469
 470     char aTransactionIsolation = 0;
 471     switch (m_aTransactionIsolation)
 472     {
 473         // TODO: confirm that these are correct.
 474         case TransactionIsolation::READ_UNCOMMITTED:
 475             aTransactionIsolation = isc_tpb_concurrency;
 476             break;
 477         case TransactionIsolation::READ_COMMITTED:
 478             aTransactionIsolation = isc_tpb_read_committed;
 479             break;
 480         case TransactionIsolation::REPEATABLE_READ:
 481             aTransactionIsolation = isc_tpb_consistency;
 482             break;
 483         case TransactionIsolation::SERIALIZABLE:
 484             aTransactionIsolation = isc_tpb_consistency;
 485             break;
 486         default:
 487             assert( false ); // We must have a valid TransactionIsolation.
 488     }
 489
 490     // You cannot pass an empty tpb parameter so we have to do some pointer
 491     // arithmetic to avoid problems. (i.e. aTPB[x] = 0 is invalid)
 492     char aTPB[5];
 493     char* pTPB = aTPB;
 494
 495     *pTPB++ = isc_tpb_version3;
 496     if (m_bIsAutoCommit)
 497         *pTPB++ = isc_tpb_autocommit;
 498     *pTPB++ = (!m_bIsReadOnly ? isc_tpb_write : isc_tpb_read);
 499     *pTPB++ = aTransactionIsolation;
 500     *pTPB++ = isc_tpb_wait;
 501
 502     isc_start_transaction(status_vector,
 503                           &m_aTransactionHandle,
 504                           1,
 505                           &m_aDBHandle,
 506                           pTPB - aTPB, // bytes used in TPB
 507                           aTPB);
 508
 509     evaluateStatusVector(status_vector,
 510                          u"isc_start_transaction",
 511                          *this);
 512 }
 513
 514 isc_tr_handle& Connection::getTransaction()
 515 {
 516     MutexGuard aGuard( m_aMutex );
 517     if (!m_aTransactionHandle)
 518     {
 519         setupTransaction();
 520     }
 521     return m_aTransactionHandle;
 522 }
 523
 524 void SAL_CALL Connection::commit()
 525 {
 526     MutexGuard aGuard( m_aMutex );
 527     checkDisposed(Connection_BASE::rBHelper.bDisposed);
 528
 529     ISC_STATUS status_vector[20];
 530
 531     if (!m_bIsAutoCommit && m_aTransactionHandle)
 532     {
 533         disposeStatements();
 534         isc_commit_transaction(status_vector, &m_aTransactionHandle);
 535         evaluateStatusVector(status_vector,
 536                              u"isc_commit_transaction",
 537                              *this);
 538     }
 539 }
 540
 541 void Connection::loadDatabaseFile(const OUString& srcLocation, const OUString& tmpLocation)
 542 {
 543     Reference< XStream > xDBStream(m_xEmbeddedStorage->openStreamElement(srcLocation,
 544             ElementModes::READ));
 545
 546     uno::Reference< ucb::XSimpleFileAccess2 > xFileAccess =
 547         ucb::SimpleFileAccess::create( comphelper::getProcessComponentContext() );
 548     if ( !xFileAccess.is() )
 549     {
 550         ::connectivity::SharedResources aResources;
 551         // TODO FIXME: this does _not_ look like the right error message
 552         const OUString sMessage = aResources.getResourceString(STR_ERROR_NEW_VERSION);
 553         ::dbtools::throwGenericSQLException(sMessage ,*this);
 554     }
 555     xFileAccess->writeFile(tmpLocation,xDBStream->getInputStream());
 556 }
 557
 558 isc_svc_handle Connection::attachServiceManager()
 559 {
 560     ISC_STATUS_ARRAY aStatusVector;
 561 #if SAL_TYPES_SIZEOFPOINTER == 8
 562     isc_svc_handle aServiceHandle = 0;
 563 #else
 564     isc_svc_handle aServiceHandle = nullptr;
 565 #endif
 566
 567     char aSPBBuffer[256];
 568     char* pSPB = aSPBBuffer;
 569     *pSPB++ = isc_spb_version;
 570     *pSPB++ = isc_spb_current_version;
 571     *pSPB++ = isc_spb_user_name;
 572     OUString sUserName("SYSDBA");
 573     char aLength = static_cast<char>(sUserName.getLength());
 574     *pSPB++ = aLength;
 575     strncpy(pSPB,
 576             OUStringToOString(sUserName,
 577                               RTL_TEXTENCODING_UTF8).getStr(),
 578             aLength);
 579     pSPB += aLength;
 580     // TODO: do we need ", isc_dpb_trusted_auth, 1, 1" -- probably not but ...
 581     if (isc_service_attach(aStatusVector,
 582                             0, // Denotes null-terminated string next
 583                             "service_mgr",
 584                             &aServiceHandle,
 585                             pSPB - aSPBBuffer,
 586                             aSPBBuffer))
 587     {
 588         evaluateStatusVector(aStatusVector,
 589                              u"isc_service_attach",
 590                              *this);
 591     }
 592
 593     return aServiceHandle;
 594 }
 595
 596 void Connection::detachServiceManager(isc_svc_handle aServiceHandle)
 597 {
 598     ISC_STATUS_ARRAY aStatusVector;
 599     if (isc_service_detach(aStatusVector,
 600                             &aServiceHandle))
 601     {
 602         evaluateStatusVector(aStatusVector,
 603                              u"isc_service_detach",
 604                              *this);
 605     }
 606 }
 607
 608 void Connection::runBackupService(const short nAction)
 609 {
 610     assert(nAction == isc_action_svc_backup
 611            || nAction == isc_action_svc_restore);
 612
 613     ISC_STATUS_ARRAY aStatusVector;
 614
 615     // convert paths to 8-Bit strings
 616     OString sFDBPath = OUStringToOString(m_sFirebirdURL, RTL_TEXTENCODING_UTF8);
 617     OString sFBKPath = OUStringToOString(m_sFBKPath, RTL_TEXTENCODING_UTF8);
 618
 619
 620     OStringBuffer aRequest; // byte array
 621
 622
 623     aRequest.append(static_cast<char>(nAction));
 624
 625     aRequest.append(char(isc_spb_dbname)); // .fdb
 626     sal_uInt16 nFDBLength = sFDBPath.getLength();
 627     aRequest.append(static_cast<char>(nFDBLength & 0xFF)); // least significant byte first
 628     aRequest.append(static_cast<char>((nFDBLength >> 8) & 0xFF));
 629     aRequest.append(sFDBPath);
 630
 631     aRequest.append(char(isc_spb_bkp_file)); // .fbk
 632     sal_uInt16 nFBKLength = sFBKPath.getLength();
 633     aRequest.append(static_cast<char>(nFBKLength & 0xFF));
 634     aRequest.append(static_cast<char>((nFBKLength >> 8) & 0xFF));
 635     aRequest.append(sFBKPath);
 636
 637     if (nAction == isc_action_svc_restore)
 638     {
 639         aRequest.append(char(isc_spb_options)); // 4-Byte bitmask
 640         char sOptions[4];
 641         char * pOptions = sOptions;
 642 #ifdef _WIN32
 643 #pragma warning(push)
 644 #pragma warning(disable: 4310) // cast truncates data
 645 #endif
 646         ADD_SPB_NUMERIC(pOptions, isc_spb_res_create);
 647 #ifdef _WIN32
 648 #pragma warning(pop)
 649 #endif
 650         aRequest.append(sOptions, 4);
 651     }
 652
 653     isc_svc_handle aServiceHandle;
 654     aServiceHandle = attachServiceManager();
 655
 656     if (isc_service_start(aStatusVector,
 657                             &aServiceHandle,
 658                             nullptr,
 659                             aRequest.getLength(),
 660                             aRequest.getStr()))
 661     {
 662         evaluateStatusVector(aStatusVector, u"isc_service_start", *this);
 663     }
 664
 665     char aInfoSPB = isc_info_svc_line;
 666     char aResults[256];
 667
 668     // query blocks until success or error
 669     if(isc_service_query(aStatusVector,
 670                       &aServiceHandle,
 671                       nullptr, // Reserved null
 672                       0,nullptr, // "send" spb -- size and spb -- not needed?
 673                       1,
 674                       &aInfoSPB,
 675                       sizeof(aResults),
 676                       aResults))
 677     {
 678         evaluateStatusVector(aStatusVector, u"isc_service_query", *this);
 679     }
 680
 681     detachServiceManager(aServiceHandle);
 682 }
 683
 684
 685 void SAL_CALL Connection::rollback()
 686 {
 687     MutexGuard aGuard( m_aMutex );
 688     checkDisposed(Connection_BASE::rBHelper.bDisposed);
 689
 690     ISC_STATUS status_vector[20];
 691
 692     if (!m_bIsAutoCommit && m_aTransactionHandle)
 693     {
 694         isc_rollback_transaction(status_vector, &m_aTransactionHandle);
 695     }
 696 }
 697
 698 sal_Bool SAL_CALL Connection::isClosed(  )
 699 {
 700     MutexGuard aGuard( m_aMutex );
 701
 702     // just simple -> we are close when we are disposed that means someone called dispose(); (XComponent)
 703     return Connection_BASE::rBHelper.bDisposed;
 704 }
 705
 706 Reference< XDatabaseMetaData > SAL_CALL Connection::getMetaData(  )
 707 {
 708     MutexGuard aGuard( m_aMutex );
 709     checkDisposed(Connection_BASE::rBHelper.bDisposed);
 710
 711     // here we have to create the class with biggest interface
 712     // The answer is 42 :-)
 713     Reference< XDatabaseMetaData > xMetaData = m_xMetaData;
 714     if(!xMetaData.is())
 715     {
 716         xMetaData = new ODatabaseMetaData(this); // need the connection because it can return it
 717         m_xMetaData = xMetaData;
 718     }
 719
 720     return xMetaData;
 721 }
 722
 723 void SAL_CALL Connection::setReadOnly(sal_Bool readOnly)
 724 {
 725     MutexGuard aGuard( m_aMutex );
 726     checkDisposed(Connection_BASE::rBHelper.bDisposed);
 727
 728     m_bIsReadOnly = readOnly;
 729     setupTransaction();
 730 }
 731
 732 sal_Bool SAL_CALL Connection::isReadOnly()
 733 {
 734     MutexGuard aGuard( m_aMutex );
 735     checkDisposed(Connection_BASE::rBHelper.bDisposed);
 736
 737     return m_bIsReadOnly;
 738 }
 739
 740 void SAL_CALL Connection::setCatalog(const OUString& /*catalog*/)
 741 {
 742     ::dbtools::throwFunctionNotSupportedSQLException("setCatalog", *this);
 743 }
 744
 745 OUString SAL_CALL Connection::getCatalog()
 746 {
 747     ::dbtools::throwFunctionNotSupportedSQLException("getCatalog", *this);
 748     return OUString();
 749 }
 750
 751 void SAL_CALL Connection::setTransactionIsolation( sal_Int32 level )
 752 {
 753     MutexGuard aGuard( m_aMutex );
 754     checkDisposed(Connection_BASE::rBHelper.bDisposed);
 755
 756     m_aTransactionIsolation = level;
 757     setupTransaction();
 758 }
 759
 760 sal_Int32 SAL_CALL Connection::getTransactionIsolation(  )
 761 {
 762     MutexGuard aGuard( m_aMutex );
 763     checkDisposed(Connection_BASE::rBHelper.bDisposed);
 764
 765     return m_aTransactionIsolation;
 766 }
 767
 768 Reference< XNameAccess > SAL_CALL Connection::getTypeMap()
 769 {
 770     ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::getTypeMap", *this );
 771     return nullptr;
 772 }
 773
 774 void SAL_CALL Connection::setTypeMap(const Reference< XNameAccess >&)
 775 {
 776     ::dbtools::throwFeatureNotImplementedSQLException( "XConnection::setTypeMap", *this );
 777 }
 778
 779 //----- XCloseable -----------------------------------------------------------
 780 void SAL_CALL Connection::close(  )
 781 {
 782     // we just dispose us
 783     {
 784         MutexGuard aGuard( m_aMutex );
 785         checkDisposed(Connection_BASE::rBHelper.bDisposed);
 786
 787     }
 788     dispose();
 789 }
 790
 791 // XWarningsSupplier
 792 Any SAL_CALL Connection::getWarnings(  )
 793 {
 794     // when you collected some warnings -> return it
 795     return Any();
 796 }
 797
 798 void SAL_CALL Connection::clearWarnings(  )
 799 {
 800     // you should clear your collected warnings here
 801 }
 802
 803 // XDocumentEventListener
 804 void SAL_CALL Connection::documentEventOccured( const DocumentEvent& Event )
 805 {
 806     MutexGuard aGuard(m_aMutex);
 807
 808     if (!m_bIsEmbedded)
 809         return;
 810
 811     if (Event.EventName != "OnSave" && Event.EventName != "OnSaveAs")
 812         return;
 813
 814     commit(); // Commit and close transaction
 815     if ( !(m_bIsEmbedded && m_xEmbeddedStorage.is()) )
 816         return;
 817
 818     SAL_INFO("connectivity.firebird", "Writing .fbk from running db");
 819     try
 820     {
 821         runBackupService(isc_action_svc_backup);
 822     }
 823     catch (const SQLException& e)
 824     {
 825         auto a = cppu::getCaughtException();
 826         throw WrappedTargetRuntimeException(e.Message, e.Context, a);
 827     }
 828
 829
 830     Reference< XStream > xDBStream(m_xEmbeddedStorage->openStreamElement(our_sFBKLocation,
 831                                                     ElementModes::WRITE));
 832
 833     // TODO: verify the backup actually exists -- the backup service
 834     // can fail without giving any sane error messages / telling us
 835     // that it failed.
 836     using namespace ::comphelper;
 837     Reference< XComponentContext > xContext = comphelper::getProcessComponentContext();
 838     Reference< XInputStream > xInputStream;
 839     if (!xContext.is())
 840         return;
 841
 842     xInputStream =
 843             OStorageHelper::GetInputStreamFromURL(m_sFBKPath, xContext);
 844     if (xInputStream.is())
 845         OStorageHelper::CopyInputToOutput( xInputStream,
 846                                     xDBStream->getOutputStream());
 847
 848     // remove old fdb file if exists
 849     uno::Reference< ucb::XSimpleFileAccess > xFileAccess =
 850         ucb::SimpleFileAccess::create(xContext);
 851     if (xFileAccess->exists(m_sFirebirdURL))
 852         xFileAccess->kill(m_sFirebirdURL);
 853 }
 854 // XEventListener
 855 void SAL_CALL Connection::disposing(const EventObject& /*rSource*/)
 856 {
 857     MutexGuard aGuard( m_aMutex );
 858
 859     m_xEmbeddedStorage.clear();
 860 }
 861
 862 void Connection::buildTypeInfo()
 863 {
 864     MutexGuard aGuard( m_aMutex );
 865
 866     Reference< XResultSet> xRs = getMetaData ()->getTypeInfo ();
 867     Reference< XRow> xRow(xRs,UNO_QUERY);
 868     // Information for a single SQL type
 869
 870     // Loop on the result set until we reach end of file
 871
 872     while (xRs->next ())
 873     {
 874         OTypeInfo aInfo;
 875         aInfo.aTypeName         = xRow->getString   (1);
 876         aInfo.nType             = xRow->getShort    (2);
 877         aInfo.nPrecision        = xRow->getInt      (3);
 878         // aLiteralPrefix    = xRow->getString   (4);
 879         // aLiteralSuffix    = xRow->getString   (5);
 880         // aCreateParams     = xRow->getString   (6);
 881         // bNullable         = xRow->getBoolean  (7);
 882         // bCaseSensitive    = xRow->getBoolean  (8);
 883         // nSearchType       = xRow->getShort    (9);
 884         // bUnsigned         = xRow->getBoolean  (10);
 885         // bCurrency         = xRow->getBoolean  (11);
 886         // bAutoIncrement    = xRow->getBoolean  (12);
 887         aInfo.aLocalTypeName    = xRow->getString   (13);
 888         // nMinimumScale     = xRow->getShort    (14);
 889         aInfo.nMaximumScale     = xRow->getShort    (15);
 890         // nNumPrecRadix     = (sal_Int16)xRow->getInt(18);
 891
 892
 893         // Now that we have the type info, save it
 894         // in the Hashtable if we don't already have an
 895         // entry for this SQL type.
 896
 897         m_aTypeInfo.push_back(aInfo);
 898     }
 899
 900     SAL_INFO("connectivity.firebird", "buildTypeInfo(). "
 901              "Type info built.");
 902
 903     // Close the result set/statement.
 904
 905     Reference< XCloseable> xClose(xRs,UNO_QUERY);
 906     xClose->close();
 907
 908     SAL_INFO("connectivity.firebird", "buildTypeInfo(). "
 909              "Closed.");
 910 }
 911
 912 void Connection::disposing()
 913 {
 914     MutexGuard aGuard(m_aMutex);
 915
 916     disposeStatements();
 917
 918     m_xMetaData = css::uno::WeakReference< css::sdbc::XDatabaseMetaData>();
 919
 920     ISC_STATUS_ARRAY status;            /* status vector */
 921     if (m_aTransactionHandle)
 922     {
 923         // TODO: confirm whether we need to ask the user here.
 924         isc_rollback_transaction(status, &m_aTransactionHandle);
 925     }
 926
 927     if (m_aDBHandle)
 928     {
 929         if (isc_detach_database(status, &m_aDBHandle))
 930         {
 931             evaluateStatusVector(status, u"isc_detach_database", *this);
 932         }
 933     }
 934     // TODO: write to storage again?
 935
 936     cppu::WeakComponentImplHelperBase::disposing();
 937
 938     if (m_pDatabaseFileDir)
 939     {
 940         ::utl::removeTree(m_pDatabaseFileDir->GetURL());
 941         m_pDatabaseFileDir.reset();
 942     }
 943 }
 944
 945 void Connection::disposeStatements()
 946 {
 947     MutexGuard aGuard(m_aMutex);
 948     for (auto const& statement : m_aStatements)
 949     {
 950         Reference< XComponent > xComp(statement.get(), UNO_QUERY);
 951         if (xComp.is())
 952             xComp->dispose();
 953     }
 954     m_aStatements.clear();
 955 }
 956
 957 uno::Reference< XTablesSupplier > Connection::createCatalog()
 958 {
 959     MutexGuard aGuard(m_aMutex);
 960
 961     // m_xCatalog is a weak reference. Reuse it if it still exists.
 962     Reference< XTablesSupplier > xCatalog = m_xCatalog;
 963     if (xCatalog.is())
 964     {
 965         return xCatalog;
 966     }
 967     else
 968     {
 969         xCatalog = new Catalog(this);
 970         m_xCatalog = xCatalog;
 971         return m_xCatalog;
 972     }
 973
 974 }
 975
 976 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */