Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 665 insertions, 0 deletions

diff --git a/connectivity/source/manager/mdrivermanager.cxx b/connectivity/source/manager/mdrivermanager.cxx
new file mode 100644
index 000000000..e7e0adf5e
--- /dev/null
+++ b/connectivity/source/manager/mdrivermanager.cxx
@@ -0,0 +1,665 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <config_fuzzers.h>
+
+#include "mdrivermanager.hxx"
+#include <com/sun/star/configuration/theDefaultProvider.hpp>
+#include <com/sun/star/sdbc/XDriver.hpp>
+#include <com/sun/star/container/XContentEnumerationAccess.hpp>
+#include <com/sun/star/container/ElementExistException.hpp>
+#include <com/sun/star/beans/NamedValue.hpp>
+#include <com/sun/star/logging/LogLevel.hpp>
+
+#include <tools/diagnose_ex.h>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <cppuhelper/weak.hxx>
+#include <osl/diagnose.h>
+
+#include <algorithm>
+#include <iterator>
+#include <vector>
+
+namespace drivermanager
+{
+
+using namespace ::com::sun::star::uno;
+using namespace ::com::sun::star::lang;
+using namespace ::com::sun::star::sdbc;
+using namespace ::com::sun::star::beans;
+using namespace ::com::sun::star::container;
+using namespace ::com::sun::star::logging;
+using namespace ::osl;
+
+constexpr OUStringLiteral SERVICE_SDBC_DRIVER = u"com.sun.star.sdbc.Driver";
+
+/// @throws NoSuchElementException
+static void throwNoSuchElementException()
+{
+    throw NoSuchElementException();
+}
+
+class ODriverEnumeration : public ::cppu::WeakImplHelper< XEnumeration >
+{
+    friend class OSDBCDriverManager;
+
+    typedef std::vector< Reference< XDriver > > DriverArray;
+    DriverArray                 m_aDrivers;
+    DriverArray::const_iterator m_aPos;
+    // order matters!
+
+protected:
+    virtual ~ODriverEnumeration() override;
+public:
+    explicit ODriverEnumeration(DriverArray&& _rDriverSequence);
+
+// XEnumeration
+    virtual sal_Bool SAL_CALL hasMoreElements( ) override;
+    virtual Any SAL_CALL nextElement( ) override;
+};
+
+
+ODriverEnumeration::ODriverEnumeration(DriverArray&& _rDriverSequence)
+    :m_aDrivers( std::move(_rDriverSequence) )
+    ,m_aPos( m_aDrivers.begin() )
+{
+}
+
+
+ODriverEnumeration::~ODriverEnumeration()
+{
+}
+
+
+sal_Bool SAL_CALL ODriverEnumeration::hasMoreElements(  )
+{
+    return m_aPos != m_aDrivers.end();
+}
+
+
+Any SAL_CALL ODriverEnumeration::nextElement(  )
+{
+    if ( !hasMoreElements() )
+        throwNoSuchElementException();
+
+    return Any( *m_aPos++ );
+}
+
+namespace
+{
+    /// an STL functor which ensures that a SdbcDriver described by a DriverAccess is loaded
+    struct EnsureDriver
+    {
+        explicit EnsureDriver( const Reference< XComponentContext > &rxContext )
+            : mxContext( rxContext ) {}
+
+        const DriverAccess& operator()( const DriverAccess& _rDescriptor ) const
+        {
+            // we did not load this driver, yet
+            if (_rDescriptor.xDriver.is())
+                return _rDescriptor;
+
+            // we have a factory for it
+            if (_rDescriptor.xComponentFactory.is())
+            {
+                DriverAccess& rDesc = const_cast<DriverAccess&>(_rDescriptor);
+                try
+                {
+                    //load driver
+                    rDesc.xDriver.set(
+                        rDesc.xComponentFactory->createInstanceWithContext(mxContext), css::uno::UNO_QUERY);
+                }
+                catch (const Exception&)
+                {
+                    //failure, abandon driver
+                    rDesc.xComponentFactory.clear();
+                }
+            }
+            return _rDescriptor;
+        }
+
+    private:
+        Reference< XComponentContext > mxContext;
+    };
+
+    /// an STL functor which extracts a SdbcDriver from a DriverAccess
+    struct ExtractDriverFromAccess
+    {
+        const Reference<XDriver>& operator()( const DriverAccess& _rAccess ) const
+        {
+            return _rAccess.xDriver;
+        }
+    };
+
+    struct ExtractDriverFromCollectionElement
+    {
+        const Reference<XDriver>& operator()( const DriverCollection::value_type& _rElement ) const
+        {
+            return _rElement.second;
+        }
+    };
+
+    // predicate for checking whether or not a driver accepts a given URL
+    class AcceptsURL
+    {
+    protected:
+        const OUString& m_rURL;
+
+    public:
+        // ctor
+        explicit AcceptsURL( const OUString& _rURL ) : m_rURL( _rURL ) { }
+
+
+        bool operator()( const Reference<XDriver>& _rDriver ) const
+        {
+            // ask the driver
+            return _rDriver.is() && _rDriver->acceptsURL( m_rURL );
+        }
+    };
+
+#if !ENABLE_FUZZERS
+    sal_Int32 lcl_getDriverPrecedence( const Reference<XComponentContext>& _rContext, Sequence< OUString >& _rPrecedence )
+    {
+        _rPrecedence.realloc( 0 );
+        try
+        {
+            // create a configuration provider
+            Reference< XMultiServiceFactory > xConfigurationProvider(
+                css::configuration::theDefaultProvider::get( _rContext ) );
+
+            // one argument for creating the node access: the path to the configuration node
+            Sequence< Any > aCreationArgs{ Any(NamedValue(
+                "nodepath", Any( OUString("org.openoffice.Office.DataAccess/DriverManager") ) )) };
+
+            // create the node access
+            Reference< XNameAccess > xDriverManagerNode(
+                xConfigurationProvider->createInstanceWithArguments("com.sun.star.configuration.ConfigurationAccess", aCreationArgs),
+                UNO_QUERY);
+
+            OSL_ENSURE(xDriverManagerNode.is(), "lcl_getDriverPrecedence: could not open my configuration node!");
+            if (xDriverManagerNode.is())
+            {
+                // obtain the preference list
+                Any aPreferences = xDriverManagerNode->getByName("DriverPrecedence");
+                bool bSuccess = aPreferences >>= _rPrecedence;
+                OSL_ENSURE(bSuccess || !aPreferences.hasValue(), "lcl_getDriverPrecedence: invalid value for the preferences node (no string sequence but not NULL)!");
+            }
+        }
+        catch( const Exception& )
+        {
+            DBG_UNHANDLED_EXCEPTION("connectivity.manager");
+        }
+
+        return _rPrecedence.getLength();
+    }
+#endif
+
+    /// an STL algorithm compatible predicate comparing two DriverAccess instances by their implementation names
+    struct CompareDriverAccessByName
+    {
+
+        bool operator()( const DriverAccess& lhs, const DriverAccess& rhs )
+        {
+            return lhs.sImplementationName < rhs.sImplementationName;
+        }
+    };
+
+    /// and an STL algorithm compatible predicate comparing the impl name of a DriverAccess to a string
+    struct EqualDriverAccessToName
+    {
+        OUString m_sImplName;
+        explicit EqualDriverAccessToName(const OUString& _sImplName) : m_sImplName(_sImplName){}
+
+        bool operator()( const DriverAccess& lhs)
+        {
+            return lhs.sImplementationName == m_sImplName;
+        }
+    };
+}
+
+OSDBCDriverManager::OSDBCDriverManager( const Reference< XComponentContext >& _rxContext )
+    :OSDBCDriverManager_Base(m_aMutex)
+    ,m_xContext( _rxContext )
+    ,m_aEventLogger( _rxContext, "org.openoffice.logging.sdbc.DriverManager" )
+    ,m_aDriverConfig(m_xContext)
+    ,m_nLoginTimeout(0)
+{
+    // bootstrap all objects supporting the .sdb.Driver service
+    bootstrapDrivers();
+
+    // initialize the drivers order
+    initializeDriverPrecedence();
+}
+
+
+OSDBCDriverManager::~OSDBCDriverManager()
+{
+}
+
+void OSDBCDriverManager::bootstrapDrivers()
+{
+    Reference< XContentEnumerationAccess > xEnumAccess( m_xContext->getServiceManager(), UNO_QUERY );
+    Reference< XEnumeration > xEnumDrivers;
+    if (xEnumAccess.is())
+        xEnumDrivers = xEnumAccess->createContentEnumeration(SERVICE_SDBC_DRIVER);
+
+    OSL_ENSURE( xEnumDrivers.is(), "OSDBCDriverManager::bootstrapDrivers: no enumeration for the drivers available!" );
+    if (!xEnumDrivers.is())
+        return;
+
+    Reference< XSingleComponentFactory > xFactory;
+    Reference< XServiceInfo > xSI;
+    while (xEnumDrivers->hasMoreElements())
+    {
+        xFactory.set(xEnumDrivers->nextElement(), css::uno::UNO_QUERY);
+        OSL_ENSURE( xFactory.is(), "OSDBCDriverManager::bootstrapDrivers: no factory extracted" );
+
+        if ( xFactory.is() )
+        {
+            // we got a factory for the driver
+            DriverAccess aDriverDescriptor;
+            bool bValidDescriptor = false;
+
+            // can it tell us something about the implementation name?
+            xSI.set(xFactory, css::uno::UNO_QUERY);
+            if ( xSI.is() )
+            {   // yes -> no need to load the driver immediately (load it later when needed)
+                aDriverDescriptor.sImplementationName = xSI->getImplementationName();
+                aDriverDescriptor.xComponentFactory = xFactory;
+                bValidDescriptor = true;
+
+                m_aEventLogger.log( LogLevel::CONFIG,
+                    "found SDBC driver $1$, no need to load it",
+                    aDriverDescriptor.sImplementationName
+                );
+            }
+            else
+            {
+                // no -> create the driver
+                Reference< XDriver > xDriver( xFactory->createInstanceWithContext( m_xContext ), UNO_QUERY );
+                OSL_ENSURE( xDriver.is(), "OSDBCDriverManager::bootstrapDrivers: a driver which is no driver?!" );
+
+                if ( xDriver.is() )
+                {
+                    aDriverDescriptor.xDriver = xDriver;
+                    // and obtain its implementation name
+                    xSI.set(xDriver, css::uno::UNO_QUERY);
+                    OSL_ENSURE( xSI.is(), "OSDBCDriverManager::bootstrapDrivers: a driver without service info?" );
+                    if ( xSI.is() )
+                    {
+                        aDriverDescriptor.sImplementationName = xSI->getImplementationName();
+                        bValidDescriptor = true;
+
+                        m_aEventLogger.log( LogLevel::CONFIG,
+                            "found SDBC driver $1$, needed to load it",
+                            aDriverDescriptor.sImplementationName
+                        );
+                    }
+                }
+            }
+
+            if ( bValidDescriptor )
+            {
+                m_aDriversBS.push_back( aDriverDescriptor );
+            }
+        }
+    }
+}
+
+
+void OSDBCDriverManager::initializeDriverPrecedence()
+{
+#if !ENABLE_FUZZERS
+    if ( m_aDriversBS.empty() )
+        // nothing to do
+        return;
+
+    try
+    {
+        // get the precedence of the drivers from the configuration
+        Sequence< OUString > aDriverOrder;
+        if ( 0 == lcl_getDriverPrecedence( m_xContext, aDriverOrder ) )
+            // nothing to do
+            return;
+
+        // aDriverOrder now is the list of driver implementation names in the order they should be used
+
+        if ( m_aEventLogger.isLoggable( LogLevel::CONFIG ) )
+        {
+            sal_Int32 nOrderedCount = aDriverOrder.getLength();
+            for ( sal_Int32 i=0; i<nOrderedCount; ++i )
+            m_aEventLogger.log( LogLevel::CONFIG,
+                "configuration's driver order: driver $1$ of $2$: $3$",
+                static_cast<sal_Int32>(i + 1), nOrderedCount, aDriverOrder[i]
+            );
+        }
+
+        // sort our bootstrapped drivers
+        std::sort( m_aDriversBS.begin(), m_aDriversBS.end(), CompareDriverAccessByName() );
+
+        // the first driver for which there is no preference
+        DriverAccessArray::iterator aNoPrefDriversStart = m_aDriversBS.begin();
+            // at the moment this is the first of all drivers we know
+
+        // loop through the names in the precedence order
+        for ( const OUString& rDriverOrder : std::as_const(aDriverOrder) )
+        {
+            if (aNoPrefDriversStart == m_aDriversBS.end())
+                break;
+
+            DriverAccess driver_order;
+            driver_order.sImplementationName = rDriverOrder;
+
+            // look for the impl name in the DriverAccess array
+            std::pair< DriverAccessArray::iterator, DriverAccessArray::iterator > aPos =
+                std::equal_range( aNoPrefDriversStart, m_aDriversBS.end(), driver_order, CompareDriverAccessByName() );
+
+            if ( aPos.first != aPos.second )
+            {   // we have a DriverAccess with this impl name
+
+                OSL_ENSURE( std::distance( aPos.first, aPos.second ) == 1,
+                    "OSDBCDriverManager::initializeDriverPrecedence: more than one driver with this impl name? How this?" );
+                // move the DriverAccess pointed to by aPos.first to the position pointed to by aNoPrefDriversStart
+
+                if ( aPos.first != aNoPrefDriversStart )
+                {   // if this does not hold, the DriverAccess already has the correct position
+
+                    // rotate the range [aNoPrefDriversStart, aPos.second) right 1 element
+                    std::rotate( aNoPrefDriversStart, aPos.second - 1, aPos.second );
+                }
+
+                // next round we start searching and pos right
+                ++aNoPrefDriversStart;
+            }
+        }
+    }
+    catch (Exception&)
+    {
+        TOOLS_WARN_EXCEPTION( "connectivity.hsqldb", "OSDBCDriverManager::initializeDriverPrecedence: caught an exception while sorting the drivers!");
+    }
+#endif
+}
+
+
+Reference< XConnection > SAL_CALL OSDBCDriverManager::getConnection( const OUString& _rURL )
+{
+    MutexGuard aGuard(m_aMutex);
+
+    m_aEventLogger.log( LogLevel::INFO,
+        "connection requested for URL $1$",
+        _rURL
+    );
+
+    Reference< XConnection > xConnection;
+    Reference< XDriver > xDriver = implGetDriverForURL(_rURL);
+    if (xDriver.is())
+    {
+        // TODO : handle the login timeout
+        xConnection = xDriver->connect(_rURL, Sequence< PropertyValue >());
+        // may throw an exception
+        m_aEventLogger.log( LogLevel::INFO,
+            "connection retrieved for URL $1$",
+            _rURL
+        );
+    }
+
+    return xConnection;
+}
+
+
+Reference< XConnection > SAL_CALL OSDBCDriverManager::getConnectionWithInfo( const OUString& _rURL, const Sequence< PropertyValue >& _rInfo )
+{
+    MutexGuard aGuard(m_aMutex);
+
+    m_aEventLogger.log( LogLevel::INFO,
+        "connection with info requested for URL $1$",
+        _rURL
+    );
+
+    Reference< XConnection > xConnection;
+    Reference< XDriver > xDriver = implGetDriverForURL(_rURL);
+    if (xDriver.is())
+    {
+        // TODO : handle the login timeout
+        xConnection = xDriver->connect(_rURL, _rInfo);
+        // may throw an exception
+        m_aEventLogger.log( LogLevel::INFO,
+            "connection with info retrieved for URL $1$",
+            _rURL
+        );
+    }
+
+    return xConnection;
+}
+
+
+void SAL_CALL OSDBCDriverManager::setLoginTimeout( sal_Int32 seconds )
+{
+    MutexGuard aGuard(m_aMutex);
+    m_nLoginTimeout = seconds;
+}
+
+
+sal_Int32 SAL_CALL OSDBCDriverManager::getLoginTimeout(  )
+{
+    MutexGuard aGuard(m_aMutex);
+    return m_nLoginTimeout;
+}
+
+
+Reference< XEnumeration > SAL_CALL OSDBCDriverManager::createEnumeration(  )
+{
+    MutexGuard aGuard(m_aMutex);
+
+    ODriverEnumeration::DriverArray aDrivers;
+
+    // ensure that all our bootstrapped drivers are instantiated
+    std::for_each( m_aDriversBS.begin(), m_aDriversBS.end(), EnsureDriver( m_xContext ) );
+
+    // copy the bootstrapped drivers
+    std::transform(
+        m_aDriversBS.begin(),               // "copy from" start
+        m_aDriversBS.end(),                 // "copy from" end
+        std::back_inserter( aDrivers ),   // insert into
+        ExtractDriverFromAccess()           // transformation to apply (extract a driver from a driver access)
+    );
+
+    // append the runtime drivers
+    std::transform(
+        m_aDriversRT.begin(),                   // "copy from" start
+        m_aDriversRT.end(),                     // "copy from" end
+        std::back_inserter( aDrivers ),       // insert into
+        ExtractDriverFromCollectionElement()    // transformation to apply (extract a driver from a driver access)
+    );
+
+    return new ODriverEnumeration( std::move(aDrivers) );
+}
+
+
+css::uno::Type SAL_CALL OSDBCDriverManager::getElementType(  )
+{
+    return cppu::UnoType<XDriver>::get();
+}
+
+
+sal_Bool SAL_CALL OSDBCDriverManager::hasElements(  )
+{
+    MutexGuard aGuard(m_aMutex);
+    return !(m_aDriversBS.empty() && m_aDriversRT.empty());
+}
+
+
+OUString SAL_CALL OSDBCDriverManager::getImplementationName(  )
+{
+    return "com.sun.star.comp.sdbc.OSDBCDriverManager";
+}
+
+sal_Bool SAL_CALL OSDBCDriverManager::supportsService( const OUString& _rServiceName )
+{
+    return cppu::supportsService(this, _rServiceName);
+}
+
+
+Sequence< OUString > SAL_CALL OSDBCDriverManager::getSupportedServiceNames(  )
+{
+    return { "com.sun.star.sdbc.DriverManager" };
+}
+
+
+Reference< XInterface > SAL_CALL OSDBCDriverManager::getRegisteredObject( const OUString& _rName )
+{
+    MutexGuard aGuard(m_aMutex);
+    DriverCollection::const_iterator aSearch = m_aDriversRT.find(_rName);
+    if (aSearch == m_aDriversRT.end())
+        throwNoSuchElementException();
+
+    return aSearch->second;
+}
+
+
+void SAL_CALL OSDBCDriverManager::registerObject( const OUString& _rName, const Reference< XInterface >& _rxObject )
+{
+    MutexGuard aGuard(m_aMutex);
+
+    m_aEventLogger.log( LogLevel::INFO,
+        "attempt to register new driver for name $1$",
+        _rName
+    );
+
+    DriverCollection::const_iterator aSearch = m_aDriversRT.find(_rName);
+    if (aSearch != m_aDriversRT.end())
+        throw ElementExistException();
+    Reference< XDriver > xNewDriver(_rxObject, UNO_QUERY);
+    if (!xNewDriver.is())
+        throw IllegalArgumentException();
+
+    m_aDriversRT.emplace(_rName, xNewDriver);
+
+    m_aEventLogger.log( LogLevel::INFO,
+        "new driver registered for name $1$",
+        _rName
+    );
+}
+
+
+void SAL_CALL OSDBCDriverManager::revokeObject( const OUString& _rName )
+{
+    MutexGuard aGuard(m_aMutex);
+
+    m_aEventLogger.log( LogLevel::INFO,
+        "attempt to revoke driver for name $1$",
+        _rName
+    );
+
+    DriverCollection::iterator aSearch = m_aDriversRT.find(_rName);
+    if (aSearch == m_aDriversRT.end())
+        throwNoSuchElementException();
+
+    m_aDriversRT.erase(aSearch); // we already have the iterator so we could use it
+
+    m_aEventLogger.log( LogLevel::INFO,
+        "driver revoked for name $1$",
+        _rName
+    );
+}
+
+
+Reference< XDriver > SAL_CALL OSDBCDriverManager::getDriverByURL( const OUString& _rURL )
+{
+    m_aEventLogger.log( LogLevel::INFO,
+        "driver requested for URL $1$",
+        _rURL
+    );
+
+    Reference< XDriver > xDriver( implGetDriverForURL( _rURL ) );
+
+    if ( xDriver.is() )
+        m_aEventLogger.log( LogLevel::INFO,
+            "driver obtained for URL $1$",
+            _rURL
+        );
+
+    return xDriver;
+}
+
+
+Reference< XDriver > OSDBCDriverManager::implGetDriverForURL(const OUString& _rURL)
+{
+    Reference< XDriver > xReturn;
+
+    {
+        const OUString sDriverFactoryName = m_aDriverConfig.getDriverFactoryName(_rURL);
+
+        EqualDriverAccessToName aEqual(sDriverFactoryName);
+        DriverAccessArray::const_iterator aFind = std::find_if(m_aDriversBS.begin(),m_aDriversBS.end(),aEqual);
+        if ( aFind == m_aDriversBS.end() )
+        {
+            // search all bootstrapped drivers
+            aFind = std::find_if(
+                m_aDriversBS.begin(),       // begin of search range
+                m_aDriversBS.end(),         // end of search range
+                [&_rURL, this] (const DriverAccessArray::value_type& driverAccess) {
+                    // extract the driver from the access, then ask the resulting driver for acceptance
+                    const DriverAccess& ensuredAccess = EnsureDriver(m_xContext)(driverAccess);
+                    const Reference<XDriver> driver = ExtractDriverFromAccess()(ensuredAccess);
+                    return AcceptsURL(_rURL)(driver);
+                });
+        } // if ( m_aDriversBS.find(sDriverFactoryName ) == m_aDriversBS.end() )
+        else
+        {
+            EnsureDriver aEnsure( m_xContext );
+            aEnsure(*aFind);
+        }
+
+        // found something?
+        if ( m_aDriversBS.end() != aFind && aFind->xDriver.is() && aFind->xDriver->acceptsURL(_rURL) )
+            xReturn = aFind->xDriver;
+    }
+
+    if ( !xReturn.is() )
+    {
+        // no -> search the runtime drivers
+        DriverCollection::const_iterator aPos = std::find_if(
+            m_aDriversRT.begin(),       // begin of search range
+            m_aDriversRT.end(),         // end of search range
+            [&_rURL] (const DriverCollection::value_type& element) {
+                // extract the driver from the collection element, then ask the resulting driver for acceptance
+                const Reference<XDriver> driver = ExtractDriverFromCollectionElement()(element);
+                return AcceptsURL(_rURL)(driver);
+            });
+
+        if ( m_aDriversRT.end() != aPos )
+            xReturn = aPos->second;
+    }
+
+    return xReturn;
+}
+
+}   // namespace drivermanager
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
+connectivity_OSDBCDriverManager_get_implementation(
+    css::uno::XComponentContext* context , css::uno::Sequence<css::uno::Any> const&)
+{
+    return cppu::acquire(new drivermanager::OSDBCDriverManager(context));
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */