/home/maarten/src/libreoffice/core/include/cppuhelper/weakref.hxx

Bug Summary

File:	home/maarten/src/libreoffice/core/include/cppuhelper/weakref.hxx
Warning:	line 173, column 49 Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ModelImpl.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D OOO_DLLIMPLEMENTATION_DBA -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/dbaccess/inc -I /home/maarten/src/libreoffice/core/dbaccess/source/inc -I /home/maarten/src/libreoffice/core/dbaccess/source/core/inc -I /home/maarten/src/libreoffice/core/dbaccess/source/filter/hsqldb -I /home/maarten/src/libreoffice/core/workdir/YaccTarget/connectivity/source/parse -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx

/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* 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 .
*/

20#include <databasecontext.hxx>
21#include "databasedocument.hxx"
22#include "datasource.hxx"
23#include <definitioncontainer.hxx>
24#include <ModelImpl.hxx>
25#include <sdbcoretools.hxx>

27#include <com/sun/star/beans/PropertyBag.hpp>
28#include <com/sun/star/container/XSet.hpp>
29#include <com/sun/star/document/MacroExecMode.hpp>
30#include <com/sun/star/embed/XTransactedObject.hpp>
31#include <com/sun/star/embed/XTransactionBroadcaster.hpp>
32#include <com/sun/star/embed/StorageFactory.hpp>
33#include <com/sun/star/frame/theGlobalEventBroadcaster.hpp>
34#include <com/sun/star/io/IOException.hpp>
35#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
36#include <com/sun/star/sdb/BooleanComparisonMode.hpp>
37#include <com/sun/star/script/DocumentScriptLibraryContainer.hpp>
38#include <com/sun/star/script/DocumentDialogLibraryContainer.hpp>
39#include <com/sun/star/util/NumberFormatsSupplier.hpp>
40#include <com/sun/star/security/DocumentDigitalSignatures.hpp>
41#include <com/sun/star/security/XDocumentDigitalSignatures.hpp>
42#include <com/sun/star/task/DocumentMacroConfirmationRequest.hpp>

44#include <cppuhelper/exc_hlp.hxx>
45#include <cppuhelper/implbase.hxx>
46#include <comphelper/documentinfo.hxx>
47#include <comphelper/storagehelper.hxx>
48#include <comphelper/types.hxx>
49#include <comphelper/processfactory.hxx>
50#include <sfx2/docfile.hxx>
51#include <sfx2/signaturestate.hxx>
52#include <tools/diagnose_ex.h>
53#include <osl/file.hxx>
54#include <osl/diagnose.h>
55#include <sal/log.hxx>
56#include <tools/urlobj.hxx>
57#include <unotools/configmgr.hxx>
58#include <unotools/tempfile.hxx>
59#include <i18nlangtag/languagetag.hxx>

61#include <algorithm>

63using namespace css;
64using namespace ::com::sun::star::document;
65using namespace ::com::sun::star::sdbc;
66using namespace ::com::sun::star::sdbcx;
67using namespace ::com::sun::star::sdb;
68using namespace ::com::sun::star::beans;
69using namespace ::com::sun::star::uno;
70using namespace ::com::sun::star::lang;
71using namespace ::com::sun::star::embed;
72using namespace ::com::sun::star::container;
73using namespace ::com::sun::star::util;
74using namespace ::com::sun::star::io;
75using namespace ::com::sun::star::ucb;
76using namespace ::com::sun::star::frame;
77using namespace ::com::sun::star::view;
78using namespace ::com::sun::star::task;
79using namespace ::com::sun::star::script;
80using namespace ::cppu;
81using namespace ::osl;
82using namespace ::comphelper;

84namespace dbaccess
85{

87// DocumentStorageAccess
88class DocumentStorageAccess : public ::cppu::WeakImplHelper<   XDocumentSubStorageSupplier
                                                         ,   XTransactionListener >
90{
  typedef std::map< OUString, Reference< XStorage > >    NamedStorages;

  ::osl::Mutex        m_aMutex;
  /// all sub storages which we ever gave to the outer world
  NamedStorages       m_aExposedStorages;
  ODatabaseModelImpl* m_pModelImplementation;
  bool                m_bPropagateCommitToRoot;
  bool                m_bDisposingSubStorages;

100public:
  explicit DocumentStorageAccess( ODatabaseModelImpl& _rModelImplementation )
      :m_pModelImplementation( &_rModelImplementation )
      ,m_bPropagateCommitToRoot( true )
      ,m_bDisposingSubStorages( false )
  {
  }

108protected:
  virtual ~DocumentStorageAccess() override
  {
  }

113public:
  void dispose();

  // XDocumentSubStorageSupplier
  virtual Reference< XStorage > SAL_CALL getDocumentSubStorage( const OUString& aStorageName, ::sal_Int32 _nMode ) override;
  virtual Sequence< OUString > SAL_CALL getDocumentSubStoragesNames(  ) override;

  // XTransactionListener
  virtual void SAL_CALL preCommit( const css::lang::EventObject& aEvent ) override;
  virtual void SAL_CALL commited( const css::lang::EventObject& aEvent ) override;
  virtual void SAL_CALL preRevert( const css::lang::EventObject& aEvent ) override;
  virtual void SAL_CALL reverted( const css::lang::EventObject& aEvent ) override;

  // XEventListener
  virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override;

  /// disposes all storages managed by this instance
  void disposeStorages();

  /// disposes all known sub storages
  void commitStorages();

  /// commits the dedicated "database" storage
  bool commitEmbeddedStorage( bool _bPreventRootCommits );

138private:
  /** opens the sub storage with the given name, in the given mode
  */
  Reference< XStorage > impl_openSubStorage_nothrow( const OUString& _rStorageName, sal_Int32 _nMode );

  void impl_suspendCommitPropagation()
  {
      OSL_ENSURE( m_bPropagateCommitToRoot, "DocumentStorageAccess::impl_suspendCommitPropagation: already suspended" )do { if (true && (!(m_bPropagateCommitToRoot))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "145" ": "), "%s", "DocumentStorageAccess::impl_suspendCommitPropagation: already suspended"
); } } while (false);
      m_bPropagateCommitToRoot = false;
  }
  void impl_resumeCommitPropagation()
  {
      OSL_ENSURE( !m_bPropagateCommitToRoot, "DocumentStorageAccess::impl_resumeCommitPropagation: not suspended" )do { if (true && (!(!m_bPropagateCommitToRoot))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "150" ": "), "%s", "DocumentStorageAccess::impl_resumeCommitPropagation: not suspended"
); } } while (false);
      m_bPropagateCommitToRoot = true;
  }

154};

156void DocumentStorageAccess::dispose()
157{
  ::osl::MutexGuard aGuard( m_aMutex );

  for (auto const& exposedStorage : m_aExposedStorages)
  {
      try
      {
          Reference< XTransactionBroadcaster > xBroadcaster(exposedStorage.second, UNO_QUERY);
          if ( xBroadcaster.is() )
              xBroadcaster->removeTransactionListener( this );
      }
      catch( const Exception& )
      {
          DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "170" ": ", "dbaccess" );;
      }
  }

  m_aExposedStorages.clear();

  m_pModelImplementation = nullptr;
177}

179Reference< XStorage > DocumentStorageAccess::impl_openSubStorage_nothrow( const OUString& _rStorageName, sal_Int32 _nDesiredMode )
180{
  OSL_ENSURE( !_rStorageName.isEmpty(),"ODatabaseModelImpl::impl_openSubStorage_nothrow: Invalid storage name!" )do { if (true && (!(!_rStorageName.isEmpty()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "181" ": "), "%s", "ODatabaseModelImpl::impl_openSubStorage_nothrow: Invalid storage name!"
); } } while (false);

  Reference< XStorage > xStorage;
  try
  {
      Reference< XStorage > xRootStorage( m_pModelImplementation->getOrCreateRootStorage() );
      if ( xRootStorage.is() )
      {
          sal_Int32 nRealMode = m_pModelImplementation->m_bDocumentReadOnly ? ElementModes::READ : _nDesiredMode;
          if ( nRealMode == ElementModes::READ )
          {
              if ( xRootStorage.is() && !xRootStorage->hasByName( _rStorageName ) )
                  return xStorage;
          }

          xStorage = xRootStorage->openStorageElement( _rStorageName, nRealMode );

          Reference< XTransactionBroadcaster > xBroad( xStorage, UNO_QUERY );
          if ( xBroad.is() )
              xBroad->addTransactionListener( this );
      }
  }
  catch( const Exception& )
  {
      DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "205" ": ", "dbaccess" );;
  }

  return xStorage;
209}

211void DocumentStorageAccess::disposeStorages()
212{
  m_bDisposingSubStorages = true;

  for (auto & exposedStorage : m_aExposedStorages)
  {
      try
      {
          ::comphelper::disposeComponent( exposedStorage.second );
      }
      catch( const Exception& )
      {
          DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "223" ": ", "dbaccess" );;
      }
  }
  m_aExposedStorages.clear();

  m_bDisposingSubStorages = false;
229}

231void DocumentStorageAccess::commitStorages()
232{
  try
  {
      for (auto const& exposedStorage : m_aExposedStorages)
      {
          tools::stor::commitStorageIfWriteable( exposedStorage.second );
      }
  }
  catch(const WrappedTargetException&)
  {
      // WrappedTargetException not allowed to leave
      throw IOException();
  }
245}

247bool DocumentStorageAccess::commitEmbeddedStorage( bool _bPreventRootCommits )
248{
  if ( _bPreventRootCommits )
      impl_suspendCommitPropagation();

  bool bSuccess = false;
  try
  {
      NamedStorages::const_iterator pos = m_aExposedStorages.find( "database" );
      if ( pos != m_aExposedStorages.end() )
          bSuccess = tools::stor::commitStorageIfWriteable( pos->second );
  }
  catch( Exception& )
  {
      DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "261" ": ", "dbaccess" );;
  }

  if ( _bPreventRootCommits )
      impl_resumeCommitPropagation();

  return bSuccess;

269}

271Reference< XStorage > SAL_CALL DocumentStorageAccess::getDocumentSubStorage( const OUString& aStorageName, ::sal_Int32 _nDesiredMode )
272{
  ::osl::MutexGuard aGuard( m_aMutex );
  NamedStorages::const_iterator pos = m_aExposedStorages.find( aStorageName );
  if ( pos == m_aExposedStorages.end() )
  {
      Reference< XStorage > xResult = impl_openSubStorage_nothrow( aStorageName, _nDesiredMode );
      pos = m_aExposedStorages.emplace( aStorageName, xResult ).first;
  }

  return pos->second;
282}

284Sequence< OUString > SAL_CALL DocumentStorageAccess::getDocumentSubStoragesNames(  )
285{
  Reference< XStorage > xRootStor( m_pModelImplementation->getRootStorage() );
  if ( !xRootStor.is() )
      return Sequence< OUString >();

  std::vector< OUString > aNames;

  const Sequence< OUString > aElementNames( xRootStor->getElementNames() );
  for ( OUString const & name : aElementNames )
  {
      if ( xRootStor->isStorageElement( name ) )
          aNames.push_back( name );
  }
  return aNames.empty()
      ?  Sequence< OUString >()
      :  Sequence< OUString >( aNames.data(), aNames.size() );
301}

303void SAL_CALL DocumentStorageAccess::preCommit( const css::lang::EventObject& /*aEvent*/ )
304{
  // not interested in
306}

308void SAL_CALL DocumentStorageAccess::commited( const css::lang::EventObject& aEvent )
309{
  ::osl::MutexGuard aGuard( m_aMutex );

  if ( m_pModelImplementation )
      m_pModelImplementation->setModified( true );

  if ( !(m_pModelImplementation && m_bPropagateCommitToRoot) )
      return;

  Reference< XStorage > xStorage( aEvent.Source, UNO_QUERY );

  // check if this is the dedicated "database" sub storage
  NamedStorages::const_iterator pos = m_aExposedStorages.find( "database" );
  if  (   ( pos != m_aExposedStorages.end() )
      &&  ( pos->second == xStorage )
      )
  {
      // if so, also commit the root storage
      m_pModelImplementation->commitRootStorage();
  }
329}

331void SAL_CALL DocumentStorageAccess::preRevert( const css::lang::EventObject& /*aEvent*/ )
332{
  // not interested in
334}

336void SAL_CALL DocumentStorageAccess::reverted( const css::lang::EventObject& /*aEvent*/ )
337{
  // not interested in
339}

341void SAL_CALL DocumentStorageAccess::disposing( const css::lang::EventObject& Source )
342{
  OSL_ENSURE( Reference< XStorage >( Source.Source, UNO_QUERY ).is(), "DocumentStorageAccess::disposing: No storage? What's this?" )do { if (true && (!(Reference< XStorage >( Source
.Source, UNO_QUERY ).is()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "343" ": "), "%s", "DocumentStorageAccess::disposing: No storage? What's this?"
); } } while (false);

  if ( m_bDisposingSubStorages )
      return;

  auto find = std::find_if(m_aExposedStorages.begin(), m_aExposedStorages.end(),
      [&Source](const NamedStorages::value_type& rEntry) { return rEntry.second == Source.Source; });
  if (find != m_aExposedStorages.end())
      m_aExposedStorages.erase( find );
352}

354// ODatabaseModelImpl

356ODatabaseModelImpl::ODatabaseModelImpl( const Reference< XComponentContext >& _rxContext, ODatabaseContext& _rDBContext )
          :m_xModel()
          ,m_xDataSource()
          ,m_aContainer(4)
          ,m_aMacroMode( *this )
          ,m_nImposedMacroExecMode( MacroExecMode::NEVER_EXECUTE )
          ,m_rDBContext( _rDBContext )
          ,m_refCount(0)
          ,m_aEmbeddedMacros()
          ,m_bModificationLock( false )
          ,m_bDocumentInitialized( false )
          ,m_nScriptingSignatureState(SignatureState::UNKNOWN)
          ,m_aContext( _rxContext )
          ,m_nLoginTimeout(0)
          ,m_bReadOnly(false)
          ,m_bPasswordRequired(false)
          ,m_bSuppressVersionColumns(true)
          ,m_bModified(false)
          ,m_bDocumentReadOnly(false)
          ,m_bMacroCallsSeenWhileLoading(false)
          ,m_pSharedConnectionManager(nullptr)
          ,m_nControllerLockCount(0)
378{
  // some kind of default
  m_sConnectURL = "jdbc:";
  m_aTableFilter.realloc(1);
  m_aTableFilter[0] = "%";
  impl_construct_nothrow();
384}

386ODatabaseModelImpl::ODatabaseModelImpl(
                  const OUString& _rRegistrationName,
                  const Reference< XComponentContext >& _rxContext,
                  ODatabaseContext& _rDBContext
                  )
          :m_xModel()
          ,m_xDataSource()
          ,m_aContainer(4)
          ,m_aMacroMode( *this )
          ,m_nImposedMacroExecMode( MacroExecMode::NEVER_EXECUTE )
          ,m_rDBContext( _rDBContext )
          ,m_refCount(0)
          ,m_aEmbeddedMacros()
          ,m_bModificationLock( false )
          ,m_bDocumentInitialized( false )
          ,m_nScriptingSignatureState(SignatureState::UNKNOWN)
          ,m_aContext( _rxContext )
          ,m_sName(_rRegistrationName)
          ,m_nLoginTimeout(0)
          ,m_bReadOnly(false)
          ,m_bPasswordRequired(false)
          ,m_bSuppressVersionColumns(true)
          ,m_bModified(false)
          ,m_bDocumentReadOnly(false)
          ,m_bMacroCallsSeenWhileLoading(false)
          ,m_pSharedConnectionManager(nullptr)
          ,m_nControllerLockCount(0)
413{
  impl_construct_nothrow();
415}

417ODatabaseModelImpl::~ODatabaseModelImpl()
418{
419}

421void ODatabaseModelImpl::impl_construct_nothrow()
422{
  // create the property bag to hold the settings (also known as "Info" property)
  try
  {
      // the set of property value types in the bag is limited:
      Sequence< Type > aAllowedTypes({
           cppu::UnoType<sal_Bool>::get(),
           cppu::UnoType<double>::get(),
           cppu::UnoType<OUString>::get(),
           cppu::UnoType<sal_Int32>::get(),
           cppu::UnoType<sal_Int16>::get(),
           cppu::UnoType<Sequence< Any >>::get(),
      });

      m_xSettings = PropertyBag::createWithTypes( m_aContext, aAllowedTypes, false/*AllowEmptyPropertyName*/, true/*AutomaticAddition*/ );

      // insert the default settings
      Reference< XPropertyContainer > xContainer( m_xSettings, UNO_QUERY_THROW );
      Reference< XSet > xSettingsSet( m_xSettings, UNO_QUERY_THROW );
      const AsciiPropertyValue* pSettings = getDefaultDataSourceSettings();
      for ( ; pSettings->AsciiName; ++pSettings )
      {
          if ( !pSettings->DefaultValue.hasValue() )
          {
              Property aProperty(
                  OUString::createFromAscii( pSettings->AsciiName ),
                  -1,
                  pSettings->ValueType,
                  PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT | PropertyAttribute::MAYBEVOID
              );
              xSettingsSet->insert( makeAny( aProperty ) );
          }
          else
          {
              xContainer->addProperty(
                  OUString::createFromAscii( pSettings->AsciiName ),
                  PropertyAttribute::BOUND | PropertyAttribute::MAYBEDEFAULT,
                  pSettings->DefaultValue
              );
          }
      }
  }
  catch( const Exception& )
  {
      DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "466" ": ", "dbaccess" );;
  }
  m_rDBContext.appendAtTerminateListener(*this);
469}

471namespace
472{
  OUString lcl_getContainerStorageName_throw( ODatabaseModelImpl::ObjectType _eType )
  {
      const char* pAsciiName( nullptr );
      switch ( _eType )
      {
      case ODatabaseModelImpl::E_FORM:   pAsciiName = "forms"; break;
      case ODatabaseModelImpl::E_REPORT: pAsciiName = "reports"; break;
      case ODatabaseModelImpl::E_QUERY:  pAsciiName = "queries"; break;
      case ODatabaseModelImpl::E_TABLE:  pAsciiName = "tables"; break;
      default:
          throw RuntimeException();
      }
      return OUString::createFromAscii( pAsciiName );
  }

  bool lcl_hasObjectWithMacros_throw( const ODefinitionContainer_Impl& _rObjectDefinitions, const Reference< XStorage >& _rxContainerStorage )
  {
      bool bSomeDocHasMacros = false;

      for (auto const& objectDefinition : _rObjectDefinitions)
      {
          const TContentPtr& rDefinition( objectDefinition.second );
          const OUString& rPersistentName( rDefinition->m_aProps.sPersistentName );

          if ( rPersistentName.isEmpty() )
          {   // it's a logical sub folder used to organize the real objects
              const ODefinitionContainer_Impl& rSubFoldersObjectDefinitions( dynamic_cast< const ODefinitionContainer_Impl& >( *rDefinition ) );
              bSomeDocHasMacros = lcl_hasObjectWithMacros_throw( rSubFoldersObjectDefinitions, _rxContainerStorage );
              if (bSomeDocHasMacros)
                  break;
              continue;
          }

          bSomeDocHasMacros = ODatabaseModelImpl::objectHasMacros( _rxContainerStorage, rPersistentName );
          if (bSomeDocHasMacros)
              break;
      }
      return bSomeDocHasMacros;
  }

  bool lcl_hasObjectsWithMacros_nothrow( ODatabaseModelImpl& _rModel, const ODatabaseModelImpl::ObjectType _eType )
  {
      bool bSomeDocHasMacros = false;

      const OContentHelper_Impl& rContainerData( *_rModel.getObjectContainer( _eType ) );
      const ODefinitionContainer_Impl& rObjectDefinitions = dynamic_cast< const ODefinitionContainer_Impl& >( rContainerData );

      try
      {
          Reference< XStorage > xContainerStorage( _rModel.getStorage( _eType ) );
          // note the READWRITE here: If the storage already existed before, then the OpenMode will
          // be ignored, anyway.
          // If the storage did not yet exist, then it will be created. If the database document
          // is read-only, the OpenMode will be automatically downgraded to READ. Otherwise,
          // the storage will in fact be created as READWRITE. While this is not strictly necessary
          // for this particular use case here, it is required since the storage is *cached*, and
          // later use cases will need the READWRITE mode.

          if ( xContainerStorage.is() )
              bSomeDocHasMacros = lcl_hasObjectWithMacros_throw( rObjectDefinitions, xContainerStorage );
      }
      catch( const Exception& )
      {
          DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "536" ": ", "dbaccess" );;
          // be on the safe side: If we can't reliably determine whether there are macros,
          // assume there actually are. Better this way, than the other way round.
          bSomeDocHasMacros = true;
      }

      return bSomeDocHasMacros;
  }
544}

546bool ODatabaseModelImpl::objectHasMacros( const Reference< XStorage >& _rxContainerStorage, const OUString& _rPersistentName )
547{
  OSL_PRECOND( _rxContainerStorage.is(), "ODatabaseModelImpl::objectHasMacros: this will crash!" )do { if (true && (!(_rxContainerStorage.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "548" ": "), "%s", "ODatabaseModelImpl::objectHasMacros: this will crash!"
); } } while (false);

  bool bHasMacros = true;
  try
  {
      if ( !_rxContainerStorage->hasByName( _rPersistentName ) )
          return false;

      Reference< XStorage > xObjectStor( _rxContainerStorage->openStorageElement(
          _rPersistentName, ElementModes::READ ) );

      bHasMacros = ::sfx2::DocumentMacroMode::storageHasMacros( xObjectStor );
  }
  catch( const Exception& )
  {
      DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "563" ": ", "dbaccess" );;
  }
  return bHasMacros;
566}

568void ODatabaseModelImpl::reset()
569{
  m_bReadOnly = false;
  std::vector< TContentPtr > aEmptyContainers( 4 );
  m_aContainer.swap( aEmptyContainers );

  if ( m_pStorageAccess.is() )
  {
      m_pStorageAccess->dispose();
      m_pStorageAccess.clear();
  }
579}

581void ODatabaseModelImpl::disposing( const css::lang::EventObject& Source )
582{
  Reference<XConnection> xCon(Source.Source,UNO_QUERY);
  if ( xCon.is() )
  {
      bool bStore = false;
      for (OWeakConnectionArray::iterator i = m_aConnections.begin(); i != m_aConnections.end(); )
      {
          css::uno::Reference< css::sdbc::XConnection > xIterConn ( *i );
          if ( !xIterConn.is())
          {
              i = m_aConnections.erase(i);
          }
          else if ( xCon == xIterConn )
          {
              *i = css::uno::WeakReference< css::sdbc::XConnection >();
              bStore = true;
              break;
          } else
              ++i;
      }

      if ( bStore )
          commitRootStorage();
  }
  else
  {
      OSL_FAIL( "ODatabaseModelImpl::disposing: where does this come from?" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "608" ": "), "%s", "ODatabaseModelImpl::disposing: where does this come from?"
); } } while (false);
  }
610}

612void ODatabaseModelImpl::clearConnections()
613{
  OWeakConnectionArray aConnections;
  aConnections.swap( m_aConnections );

  Reference< XConnection > xConn;
  for (auto const& connection : aConnections)
  {
      xConn = connection;
      if ( xConn.is() )
      {
          try
          {
              xConn->close();
          }
          catch(const Exception&)
          {
              DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "629" ": ", "dbaccess" );;
          }
      }
  }

  m_pSharedConnectionManager = nullptr;
  m_xSharedConnectionManager = nullptr;
636}

638void ODatabaseModelImpl::dispose()
639{
  // dispose the data source and the model
  try
  {
      Reference< XDataSource > xDS( m_xDataSource );
      ::comphelper::disposeComponent( xDS );

      Reference< XModel > xModel( m_xModel );
      ::comphelper::disposeComponent( xModel );
  }
  catch( const Exception& )
  {
      DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "651" ": ", "dbaccess" );;
  }
  m_xDataSource = WeakReference<XDataSource>();
  m_xModel = WeakReference< XModel >();

  for (auto const& elem : m_aContainer)
  {
      if ( elem )
          elem->m_pDataSource = nullptr;
  }
  m_aContainer.clear();

  clearConnections();

  m_xNumberFormatsSupplier = nullptr;

  try
  {
      bool bCouldStore = commitEmbeddedStorage( true );
          // "true" means that committing the embedded storage should not trigger committing the root
          // storage. This is because we are going to commit the root storage ourself, anyway
      disposeStorages();
      if ( bCouldStore )
          commitRootStorage();

      impl_switchToStorage_throw( nullptr );
  }
  catch( const Exception& )
  {
      DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "680" ": ", "dbaccess" );;
  }

  if ( m_pStorageAccess.is() )
  {
      m_pStorageAccess->dispose();
      m_pStorageAccess.clear();
  }
688}

690const Reference< XNumberFormatsSupplier > & ODatabaseModelImpl::getNumberFormatsSupplier()
691{
  if (!m_xNumberFormatsSupplier.is())
  {
      // the arguments : the work locale of the current user
      Locale aLocale( LanguageTag::convertToLocale( utl::ConfigManager::getWorkLocale(), false));

      m_xNumberFormatsSupplier.set( NumberFormatsSupplier::createWithLocale( m_aContext, aLocale ) );
  }
  return m_xNumberFormatsSupplier;
700}

702void ODatabaseModelImpl::setDocFileLocation( const OUString& i_rLoadedFrom )
703{
  ENSURE_OR_THROW( !i_rLoadedFrom.isEmpty(), "invalid URL" )if( !(!i_rLoadedFrom.isEmpty()) ){ do { if (true && (
!(!i_rLoadedFrom.isEmpty()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "704" ": "), "%s", "invalid URL"); } } while (false); throw
 css::uno::RuntimeException( __func__ + OUStringLiteral(u",\n"
 "invalid URL"), css::uno::Reference< css::uno::XInterface
 >() ); };
  m_sDocFileLocation = i_rLoadedFrom;
706}

708void ODatabaseModelImpl::setResource( const OUString& i_rDocumentURL, const Sequence< PropertyValue >& _rArgs )
709{
  ENSURE_OR_THROW( !i_rDocumentURL.isEmpty(), "invalid URL" )if( !(!i_rDocumentURL.isEmpty()) ){ do { if (true && (
!(!i_rDocumentURL.isEmpty()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "710" ": "), "%s", "invalid URL"); } } while (false); throw
 css::uno::RuntimeException( __func__ + OUStringLiteral(u",\n"
 "invalid URL"), css::uno::Reference< css::uno::XInterface
 >() ); };

  ::comphelper::NamedValueCollection aMediaDescriptor( _rArgs );
713#if OSL_DEBUG_LEVEL1 > 0
  if ( aMediaDescriptor.has( "SalvagedFile" ) )
  {
      OUString sSalvagedFile( aMediaDescriptor.getOrDefault( "SalvagedFile", OUString() ) );
      // If SalvagedFile is an empty string, this indicates "the document is being recovered, but i_rDocumentURL already
      // is the real document URL, not the temporary document location"
      if ( sSalvagedFile.isEmpty() )
          sSalvagedFile = i_rDocumentURL;

      OSL_ENSURE( sSalvagedFile == i_rDocumentURL, "ODatabaseModelImpl::setResource: inconsistency!" )do { if (true && (!(sSalvagedFile == i_rDocumentURL))
) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "722" ": "), "%s", "ODatabaseModelImpl::setResource: inconsistency!"
); } } while (false);
          // nowadays, setResource should only be called with the logical URL of the document
  }
725#endif

  m_aMediaDescriptor = stripLoadArguments( aMediaDescriptor );

  impl_switchToLogicalURL( i_rDocumentURL );
730}

:comphelper::NamedValueCollection ODatabaseModelImpl::stripLoadArguments( const ::comphelper::NamedValueCollection& _rArguments )
733{
  OSL_ENSURE( !_rArguments.has( "Model" ), "ODatabaseModelImpl::stripLoadArguments: this is suspicious (1)!" )do { if (true && (!(!_rArguments.has( "Model" )))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "734" ": "), "%s", "ODatabaseModelImpl::stripLoadArguments: this is suspicious (1)!"
); } } while (false);
  OSL_ENSURE( !_rArguments.has( "ViewName" ), "ODatabaseModelImpl::stripLoadArguments: this is suspicious (2)!" )do { if (true && (!(!_rArguments.has( "ViewName" ))))
 { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "735" ": "), "%s", "ODatabaseModelImpl::stripLoadArguments: this is suspicious (2)!"
); } } while (false);

  ::comphelper::NamedValueCollection aMutableArgs( _rArguments );
  aMutableArgs.remove( "Model" );
  aMutableArgs.remove( "ViewName" );
  return aMutableArgs;
741}

743void ODatabaseModelImpl::disposeStorages()
744{
  getDocumentStorageAccess()->disposeStorages();
746}

748Reference< XSingleServiceFactory > ODatabaseModelImpl::createStorageFactory() const
749{
  return StorageFactory::create( m_aContext );
751}

753void ODatabaseModelImpl::commitRootStorage()
754{
  Reference< XStorage > xStorage( getOrCreateRootStorage() );
  bool bSuccess = commitStorageIfWriteable_ignoreErrors( xStorage );
  SAL_WARN_IF(!bSuccess && xStorage.is(), "dbaccess",do { if (true && (!bSuccess && xStorage.is())
) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "dbaccess")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "ODatabaseModelImpl::commitRootStorage: could not commit the storage!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("dbaccess"
), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "758" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ODatabaseModelImpl::commitRootStorage: could not commit the storage!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ODatabaseModelImpl::commitRootStorage: could not commit the storage!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("dbaccess"
), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "758" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ODatabaseModelImpl::commitRootStorage: could not commit the storage!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("dbaccess"
), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "758" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ODatabaseModelImpl::commitRootStorage: could not commit the storage!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ODatabaseModelImpl::commitRootStorage: could not commit the storage!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("dbaccess"
), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "758" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false)
      "ODatabaseModelImpl::commitRootStorage: could not commit the storage!")do { if (true && (!bSuccess && xStorage.is())
) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "dbaccess")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "ODatabaseModelImpl::commitRootStorage: could not commit the storage!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("dbaccess"
), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "758" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ODatabaseModelImpl::commitRootStorage: could not commit the storage!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ODatabaseModelImpl::commitRootStorage: could not commit the storage!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("dbaccess"
), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "758" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "ODatabaseModelImpl::commitRootStorage: could not commit the storage!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("dbaccess"
), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "758" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "ODatabaseModelImpl::commitRootStorage: could not commit the storage!"
), 0); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "ODatabaseModelImpl::commitRootStorage: could not commit the storage!"
; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("dbaccess"
), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "758" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
759}

761Reference< XStorage > const & ODatabaseModelImpl::getOrCreateRootStorage()
762{
  if ( !m_xDocumentStorage.is() )
  {
      Reference< XSingleServiceFactory> xStorageFactory = StorageFactory::create( m_aContext );
      Any aSource = m_aMediaDescriptor.get( "Stream" );
      if ( !aSource.hasValue() )
          aSource = m_aMediaDescriptor.get( "InputStream" );
      if ( !aSource.hasValue() && !m_sDocFileLocation.isEmpty() )
          aSource <<= m_sDocFileLocation;
      // TODO: shouldn't we also check URL?

      OSL_ENSURE( aSource.hasValue(), "ODatabaseModelImpl::getOrCreateRootStorage: no source to create the storage from!" )do { if (true && (!(aSource.hasValue()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "773" ": "), "%s", "ODatabaseModelImpl::getOrCreateRootStorage: no source to create the storage from!"
); } } while (false);

      if ( aSource.hasValue() )
      {
          Sequence< Any > aStorageCreationArgs(2);
          aStorageCreationArgs[0] = aSource;
          aStorageCreationArgs[1] <<= ElementModes::READWRITE;

          Reference< XStorage > xDocumentStorage;
          OUString sURL;
          aSource >>= sURL;
          // Don't try to load a meta-URL as-is.
          if (!sURL.startsWithIgnoreAsciiCase("vnd.sun.star.pkg:"))
          {
              try
              {
                  xDocumentStorage.set( xStorageFactory->createInstanceWithArguments( aStorageCreationArgs ), UNO_QUERY_THROW );
              }
              catch( const Exception& )
              {
                  m_bDocumentReadOnly = true;
                  aStorageCreationArgs[1] <<= ElementModes::READ;
                  try
                  {
                      xDocumentStorage.set( xStorageFactory->createInstanceWithArguments( aStorageCreationArgs ), UNO_QUERY_THROW );
                  }
                  catch( const Exception& )
                  {
                      DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "801" ": ", "dbaccess" );;
                  }
              }
          }

          impl_switchToStorage_throw( xDocumentStorage );
      }
  }
  return m_xDocumentStorage.getTyped();
810}

812DocumentStorageAccess* ODatabaseModelImpl::getDocumentStorageAccess()
813{
  if ( !m_pStorageAccess.is() )
  {
      m_pStorageAccess = new DocumentStorageAccess( *this );
  }
  return m_pStorageAccess.get();
819}

821void ODatabaseModelImpl::modelIsDisposing( const bool _wasInitialized, ResetModelAccess )
822{
  m_xModel.clear();

  // Basic libraries and Dialog libraries are a model facet, though held at this impl class.
  // They automatically dispose themself when the model they belong to is being disposed.
  // So, to not be tempted to do anything with them, again, we reset them.
  m_xBasicLibraries.clear();
  m_xDialogLibraries.clear();

  m_bDocumentInitialized = _wasInitialized;
832}

834Reference< XDocumentSubStorageSupplier > ODatabaseModelImpl::getDocumentSubStorageSupplier()
835{
  return getDocumentStorageAccess();
837}

839bool ODatabaseModelImpl::commitEmbeddedStorage( bool _bPreventRootCommits )
840{
  return getDocumentStorageAccess()->commitEmbeddedStorage( _bPreventRootCommits );
842}

844bool ODatabaseModelImpl::commitStorageIfWriteable_ignoreErrors( const Reference< XStorage >& _rxStorage )
845{
  bool bTryToPreserveScriptSignature = false;
  utl::TempFile aTempFile;
  aTempFile.EnableKillingFile();
  OUString sTmpFileUrl = aTempFile.GetURL();
  SignatureState aSignatureState = getScriptingSignatureState();
  OUString sLocation = getDocFileLocation();
  bool bIsEmbedded = sLocation.startsWith("vnd.sun.star.pkg:") && sLocation.endsWith("/EmbeddedDatabase");
  if (!bIsEmbedded && !sLocation.isEmpty()
      && (aSignatureState == SignatureState::OK || aSignatureState == SignatureState::NOTVALIDATED
          || aSignatureState == SignatureState::INVALID
          || aSignatureState == SignatureState::UNKNOWN))
  {
      bTryToPreserveScriptSignature = true;
      // We need to first save the file (which removes the macro signature), then add the macro signature again.
      // For that, we need a temporary copy of the original file.
      osl::File::RC rc = osl::File::copy(sLocation, sTmpFileUrl);
      if (rc != osl::FileBase::E_None)
          throw uno::RuntimeException("Could not create temp file");
  }

  bool bSuccess = false;
  try
  {
      bSuccess = tools::stor::commitStorageIfWriteable( _rxStorage );
  }
  catch( const Exception& )
  {
      DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "873" ": ", "dbaccess" );;
  }

  // Preserve script signature if the script has not changed
  if (bTryToPreserveScriptSignature)
  {
      OUString aODFVersion(comphelper::OStorageHelper::GetODFVersionFromStorage(_rxStorage));
      uno::Reference<security::XDocumentDigitalSignatures> xDDSigns;
      try
      {
          xDDSigns = security::DocumentDigitalSignatures::createWithVersion(
              comphelper::getProcessComponentContext(), aODFVersion);

          const OUString aScriptSignName
              = xDDSigns->getScriptingContentSignatureDefaultStreamName();

          if (!aScriptSignName.isEmpty())
          {
              Reference<XStorage> xReadOrig
                  = comphelper::OStorageHelper::GetStorageOfFormatFromURL(
                      ZIP_STORAGE_FORMAT_STRING"ZipFormat", sTmpFileUrl, ElementModes::READ);
              if (!xReadOrig.is())
                  throw uno::RuntimeException("Could not read " + sTmpFileUrl);
              uno::Reference<embed::XStorage> xMetaInf
                  = xReadOrig->openStorageElement("META-INF", embed::ElementModes::READ);

              uno::Reference<embed::XStorage> xTargetMetaInf
                  = _rxStorage->openStorageElement("META-INF", embed::ElementModes::READWRITE);
              if (xMetaInf.is() && xTargetMetaInf.is())
              {
                  xMetaInf->copyElementTo(aScriptSignName, xTargetMetaInf, aScriptSignName);

                  uno::Reference<embed::XTransactedObject> xTransact(xTargetMetaInf,
                                                                      uno::UNO_QUERY);
                  if (xTransact.is())
                      xTransact->commit();

                  xTargetMetaInf->dispose();

                  // now check the copied signature
                  uno::Sequence<security::DocumentSignatureInformation> aInfos
                      = xDDSigns->verifyScriptingContentSignatures(
                          _rxStorage, uno::Reference<io::XInputStream>());
                  SignatureState nState = DocumentSignatures::getSignatureState(aInfos);
                  if (nState == SignatureState::OK || nState == SignatureState::NOTVALIDATED
                      || nState == SignatureState::PARTIAL_OK)
                  {
                      // commit the ZipStorage from target medium
                      xTransact.set(_rxStorage, uno::UNO_QUERY);
                      if (xTransact.is())
                          xTransact->commit();
                  }
                  else
                  {
                      SAL_WARN("dbaccess", "An invalid signature was copied!")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "dbaccess")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "An invalid signature was copied!"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("dbaccess"
), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "927" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "An invalid signature was copied!"), 0
); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "An invalid signature was copied!"; ::sal::detail::
log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("dbaccess"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "927" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "An invalid signature was copied!") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("dbaccess"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "927" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "An invalid signature was copied!"), 0
); } else { ::std::ostringstream sal_detail_stream; sal_detail_stream
 << "An invalid signature was copied!"; ::sal::detail::
log( (::SAL_DETAIL_LOG_LEVEL_WARN), ("dbaccess"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "927" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
                  }
              }
          }
      }
      catch (uno::Exception&)
      {
          TOOLS_WARN_EXCEPTION("dbaccess", "")do { css::uno::Any tools_warn_exception( DbgGetCaughtException
() ); do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN
, "dbaccess")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "" << " " <<
 exceptionToString(tools_warn_exception)) == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_WARN), ("dbaccess"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "934" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("dbaccess"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "934" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "" << " " << exceptionToString(tools_warn_exception
)) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN), (
"dbaccess"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "934" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "" << " " << exceptionToString
(tools_warn_exception)), 0); } else { ::std::ostringstream sal_detail_stream
; sal_detail_stream << "" << " " << exceptionToString
(tools_warn_exception); ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN
), ("dbaccess"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "934" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false); } while (false);
      }
  }

  return bSuccess;
939}

941void ODatabaseModelImpl::setModified( bool _bModified )
942{
  if ( isModifyLocked() )
      return;

  try
  {
      Reference< XModifiable > xModi( m_xModel.get(), UNO_QUERY );
      if ( xModi.is() )
          xModi->setModified( _bModified );
      else
          m_bModified = _bModified;
  }
  catch( const Exception& )
  {
      DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "956" ": ", "dbaccess" );;
  }
958}

960Reference<XDataSource> ODatabaseModelImpl::getOrCreateDataSource()
961{
  Reference<XDataSource> xDs = m_xDataSource;
  if ( !xDs.is() )
1
Taking true branch→
  {
      xDs = new ODatabaseSource(this);
2
←
Calling '~Reference'→
10
←
Returning from '~Reference'→
      m_xDataSource = xDs;
11
←
Calling 'WeakReference::operator='→
  }
  return xDs;
969}

971Reference< XModel> ODatabaseModelImpl::getModel_noCreate() const
972{
  return m_xModel;
974}

976Reference< XModel > ODatabaseModelImpl::createNewModel_deliverOwnership()
977{
  Reference< XModel > xModel( m_xModel );
  OSL_PRECOND( !xModel.is(), "ODatabaseModelImpl::createNewModel_deliverOwnership: not to be called if there already is a model!" )do { if (true && (!(!xModel.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "979" ": "), "%s", "ODatabaseModelImpl::createNewModel_deliverOwnership: not to be called if there already is a model!"
); } } while (false);
  if ( !xModel.is() )
  {
      bool bHadModelBefore = m_bDocumentInitialized;

      xModel = ODatabaseDocument::createDatabaseDocument( this, ODatabaseDocument::FactoryAccess() );
      m_xModel = xModel;

      try
      {
          Reference< XGlobalEventBroadcaster > xModelCollection = theGlobalEventBroadcaster::get( m_aContext );
          xModelCollection->insert( makeAny( xModel ) );
      }
      catch( const Exception& )
      {
          DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "994" ": ", "dbaccess" );;
      }

      if ( bHadModelBefore )
      {
          // do an attachResources
          // In case the document is loaded regularly, this is not necessary, as our loader will do it.
          // However, in case that the document is implicitly created by asking the data source for the document,
          // then nobody would call the doc's attachResource. So, we do it here, to ensure it's in a proper
          // state, fires all events, and so on.
          // #i105505#
          xModel->attachResource( xModel->getURL(), m_aMediaDescriptor.getPropertyValues() );
      }
  }
  return xModel;
1009}

1011void ODatabaseModelImpl::acquire()
1012{
  osl_atomic_increment(&m_refCount)__sync_add_and_fetch((&m_refCount), 1);
1014}

1016void ODatabaseModelImpl::release()
1017{
  if ( osl_atomic_decrement(&m_refCount)__sync_sub_and_fetch((&m_refCount), 1) == 0 )
5
←
Assuming the condition is true→
6
←
Taking true branch→
  {
      acquire();  // prevent multiple releases
      m_rDBContext.removeFromTerminateListener(*this);
      dispose();
      m_rDBContext.storeTransientProperties(*this);
      if (!m_sDocumentURL.isEmpty())
7
←
Taking false branch→
          m_rDBContext.revokeDatabaseDocument(*this);
      delete this;
8
←
Memory is released→
  }
1028}

1030void ODatabaseModelImpl::commitStorages()
1031{
  getDocumentStorageAccess()->commitStorages();
1033}

1035Reference< XStorage > ODatabaseModelImpl::getStorage( const ObjectType _eType )
1036{
  return getDocumentStorageAccess()->getDocumentSubStorage( getObjectContainerStorageName( _eType ),
                  css::embed::ElementModes::READWRITE );
1039}

1041const AsciiPropertyValue* ODatabaseModelImpl::getDefaultDataSourceSettings()
1042{
  static const AsciiPropertyValue aKnownSettings[] =
  {
      // known JDBC settings
      AsciiPropertyValue( "JavaDriverClass",            makeAny( OUString() ) ),
      AsciiPropertyValue( "JavaDriverClassPath",        makeAny( OUString() ) ),
      AsciiPropertyValue( "IgnoreCurrency",             makeAny( false ) ),
      // known settings for file-based drivers
      AsciiPropertyValue( "Extension",                  makeAny( OUString() ) ),
      AsciiPropertyValue( "CharSet",                    makeAny( OUString() ) ),
      AsciiPropertyValue( "HeaderLine",                 makeAny( true ) ),
      AsciiPropertyValue( "FieldDelimiter",             makeAny( OUString( "," ) ) ),
      AsciiPropertyValue( "StringDelimiter",            makeAny( OUString( "\"" ) ) ),
      AsciiPropertyValue( "DecimalDelimiter",           makeAny( OUString( "." ) ) ),
      AsciiPropertyValue( "ThousandDelimiter",          makeAny( OUString() ) ),
      AsciiPropertyValue( "ShowDeleted",                makeAny( false ) ),
      // known ODBC settings
      AsciiPropertyValue( "SystemDriverSettings",       makeAny( OUString() ) ),
      AsciiPropertyValue( "UseCatalog",                 makeAny( false ) ),
      AsciiPropertyValue( "TypeInfoSettings",           makeAny( Sequence< Any >()) ),
      // settings related to auto increment handling
      AsciiPropertyValue( "AutoIncrementCreation",      makeAny( OUString() ) ),
      AsciiPropertyValue( "AutoRetrievingStatement",    makeAny( OUString() ) ),
      AsciiPropertyValue( "IsAutoRetrievingEnabled",    makeAny( false ) ),
      // known LDAP driver settings
      AsciiPropertyValue( "HostName",                   makeAny( OUString() ) ),
      AsciiPropertyValue( "PortNumber",                 makeAny( sal_Int32(389) ) ),
      AsciiPropertyValue( "BaseDN",                     makeAny( OUString() ) ),
      AsciiPropertyValue( "MaxRowCount",                makeAny( sal_Int32(100) ) ),
      // known MySQLNative driver settings
      AsciiPropertyValue( "LocalSocket",                makeAny( OUString() ) ),
      AsciiPropertyValue( "NamedPipe",                  makeAny( OUString() ) ),
      // misc known driver settings
      AsciiPropertyValue( "ParameterNameSubstitution",  makeAny( false ) ),
      AsciiPropertyValue( "AddIndexAppendix",           makeAny( true ) ),
      AsciiPropertyValue( "IgnoreDriverPrivileges",     makeAny( true ) ),
      AsciiPropertyValue( "ImplicitCatalogRestriction", ::cppu::UnoType< OUString >::get() ),
      AsciiPropertyValue( "ImplicitSchemaRestriction",  ::cppu::UnoType< OUString >::get() ),
      AsciiPropertyValue( "PrimaryKeySupport",          ::cppu::UnoType< sal_Bool >::get() ),
      AsciiPropertyValue( "ShowColumnDescription",      makeAny( false ) ),
      // known SDB level settings
      AsciiPropertyValue( "NoNameLengthLimit",          makeAny( false ) ),
      AsciiPropertyValue( "AppendTableAliasName",       makeAny( false ) ),
      AsciiPropertyValue( "GenerateASBeforeCorrelationName",  makeAny( false ) ),
      AsciiPropertyValue( "ColumnAliasInOrderBy",       makeAny( true ) ),
      AsciiPropertyValue( "EnableSQL92Check",           makeAny( false ) ),
      AsciiPropertyValue( "BooleanComparisonMode",      makeAny( BooleanComparisonMode::EQUAL_INTEGER ) ),
      AsciiPropertyValue( "TableTypeFilterMode",        makeAny( sal_Int32(3) ) ),
      AsciiPropertyValue( "RespectDriverResultSetType", makeAny( false ) ),
      AsciiPropertyValue( "UseSchemaInSelect",          makeAny( true ) ),
      AsciiPropertyValue( "UseCatalogInSelect",         makeAny( true ) ),
      AsciiPropertyValue( "EnableOuterJoinEscape",      makeAny( true ) ),
      AsciiPropertyValue( "PreferDosLikeLineEnds",      makeAny( false ) ),
      AsciiPropertyValue( "FormsCheckRequiredFields",   makeAny( true ) ),
      AsciiPropertyValue( "EscapeDateTime",             makeAny( true ) ),

      // known services to handle database tasks
      AsciiPropertyValue( "TableAlterationServiceName", makeAny( OUString() ) ),
      AsciiPropertyValue( "TableRenameServiceName",     makeAny( OUString() ) ),
      AsciiPropertyValue( "ViewAlterationServiceName",  makeAny( OUString() ) ),
      AsciiPropertyValue( "ViewAccessServiceName",      makeAny( OUString() ) ),
      AsciiPropertyValue( "CommandDefinitions",         makeAny( OUString() ) ),
      AsciiPropertyValue( "Forms",                      makeAny( OUString() ) ),
      AsciiPropertyValue( "Reports",                    makeAny( OUString() ) ),
      AsciiPropertyValue( "KeyAlterationServiceName",   makeAny( OUString() ) ),
      AsciiPropertyValue( "IndexAlterationServiceName", makeAny( OUString() ) ),

      AsciiPropertyValue()
  };
  return aKnownSettings;
1112}

1114TContentPtr& ODatabaseModelImpl::getObjectContainer( ObjectType _eType )
1115{
  OSL_PRECOND( _eType >= E_FORM && _eType <= E_TABLE, "ODatabaseModelImpl::getObjectContainer: illegal index!" )do { if (true && (!(_eType >= E_FORM && _eType
 <= E_TABLE))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "1116" ": "), "%s", "ODatabaseModelImpl::getObjectContainer: illegal index!"
); } } while (false);
  TContentPtr& rContentPtr = m_aContainer[ _eType ];

  if ( !rContentPtr )
  {
      rContentPtr = std::make_shared<ODefinitionContainer_Impl>();
      rContentPtr->m_pDataSource = this;
      rContentPtr->m_aProps.aTitle = lcl_getContainerStorageName_throw( _eType );
  }
  return rContentPtr;
1126}

1128bool ODatabaseModelImpl::adjustMacroMode_AutoReject()
1129{
  return m_aMacroMode.adjustMacroMode( nullptr );
1131}

1133bool ODatabaseModelImpl::checkMacrosOnLoading()
1134{
  Reference< XInteractionHandler > xInteraction;
  xInteraction = m_aMediaDescriptor.getOrDefault( "InteractionHandler", xInteraction );
  return m_aMacroMode.checkMacrosOnLoading( xInteraction );
1138}

1140void ODatabaseModelImpl::resetMacroExecutionMode()
1141{
  m_aMacroMode = ::sfx2::DocumentMacroMode( *this );
1143}

1145Reference< XStorageBasedLibraryContainer > ODatabaseModelImpl::getLibraryContainer( bool _bScript )
1146{
  Reference< XStorageBasedLibraryContainer >& rxContainer( _bScript ? m_xBasicLibraries : m_xDialogLibraries );
  if ( rxContainer.is() )
      return rxContainer;

  Reference< XStorageBasedDocument > xDocument( getModel_noCreate(), UNO_QUERY_THROW );
      // this is only to be called if there already exists a document model - in fact, it is
      // to be called by the document model only

  try
  {
      Reference< XStorageBasedLibraryContainer > (*Factory)( const Reference< XComponentContext >&, const Reference< XStorageBasedDocument >&)
          = _bScript ? &DocumentScriptLibraryContainer::create : &DocumentDialogLibraryContainer::create;

      rxContainer.set(
          (*Factory)( m_aContext, xDocument ),
          UNO_SET_THROW
      );
  }
  catch( const RuntimeException& )
  {
      throw;
  }
  catch( const Exception& )
  {
      throw WrappedTargetRuntimeException(
          OUString(),
          xDocument,
          ::cppu::getCaughtException()
      );
  }
  return rxContainer;
1178}

1180void ODatabaseModelImpl::storeLibraryContainersTo( const Reference< XStorage >& _rxToRootStorage )
1181{
  if ( m_xBasicLibraries.is() )
      m_xBasicLibraries->storeLibrariesToStorage( _rxToRootStorage );

  if ( m_xDialogLibraries.is() )
      m_xDialogLibraries->storeLibrariesToStorage( _rxToRootStorage );
1187}

1189Reference< XStorage > ODatabaseModelImpl::switchToStorage( const Reference< XStorage >& _rxNewRootStorage )
1190{
  if ( !_rxNewRootStorage.is() )
      throw IllegalArgumentException();

  return impl_switchToStorage_throw( _rxNewRootStorage );
1195}

1197namespace
1198{
  void lcl_modifyListening( ::sfx2::IModifiableDocument& _rDocument,
      const Reference< XStorage >& _rxStorage, ::rtl::Reference< ::sfx2::DocumentStorageModifyListener >& _inout_rListener,
      comphelper::SolarMutex& _rMutex, bool _bListen )
  {
      Reference< XModifiable > xModify( _rxStorage, UNO_QUERY );
      OSL_ENSURE( xModify.is() || !_rxStorage.is(), "lcl_modifyListening: storage can't notify us!" )do { if (true && (!(xModify.is() || !_rxStorage.is())
)) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"
), ("/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "1204" ": "), "%s", "lcl_modifyListening: storage can't notify us!"
); } } while (false);

      if ( xModify.is() && !_bListen && _inout_rListener.is() )
      {
          xModify->removeModifyListener( _inout_rListener.get() );
      }

      if ( _inout_rListener.is() )
      {
          _inout_rListener->dispose();
          _inout_rListener = nullptr;
      }

      if ( xModify.is() && _bListen )
      {
          _inout_rListener = new ::sfx2::DocumentStorageModifyListener( _rDocument, _rMutex );
          xModify->addModifyListener( _inout_rListener.get() );
      }
  }
1223}

1225namespace
1226{
  void lcl_rebaseScriptStorage_throw( const Reference< XStorageBasedLibraryContainer >& _rxContainer,
      const Reference< XStorage >& _rxNewRootStorage )
  {
      if ( _rxContainer.is() )
      {
          if ( _rxNewRootStorage.is() )
              _rxContainer->setRootStorage( _rxNewRootStorage );
1234//            else
                 // TODO: what to do here? dispose the container?
      }
  }
1238}

1240Reference< XStorage > const & ODatabaseModelImpl::impl_switchToStorage_throw( const Reference< XStorage >& _rxNewRootStorage )
1241{
  // stop listening for modifications at the old storage
  lcl_modifyListening( *this, m_xDocumentStorage.getTyped(), m_pStorageModifyListener, Application::GetSolarMutex(), false );

  // set new storage
  m_xDocumentStorage.reset( _rxNewRootStorage, SharedStorage::TakeOwnership );

  // start listening for modifications
  lcl_modifyListening( *this, m_xDocumentStorage.getTyped(), m_pStorageModifyListener, Application::GetSolarMutex(), true );

  // forward new storage to Basic and Dialog library containers
  lcl_rebaseScriptStorage_throw( m_xBasicLibraries, m_xDocumentStorage.getTyped() );
  lcl_rebaseScriptStorage_throw( m_xDialogLibraries, m_xDocumentStorage.getTyped() );

  m_bReadOnly = !tools::stor::storageIsWritable_nothrow( m_xDocumentStorage.getTyped() );
  // TODO: our data source, if it exists, must broadcast the change of its ReadOnly property

  return m_xDocumentStorage.getTyped();
1259}

1261void ODatabaseModelImpl::impl_switchToLogicalURL( const OUString& i_rDocumentURL )
1262{
  if ( i_rDocumentURL == m_sDocumentURL )
      return;

  const OUString sOldURL( m_sDocumentURL );
  // update our name, if necessary
  if  (   ( m_sName == m_sDocumentURL )   // our name is our old URL
      ||  ( m_sName.isEmpty() )        // we do not have a name, yet (i.e. are not registered at the database context)
      )
  {
      INetURLObject aURL( i_rDocumentURL );
      if ( aURL.GetProtocol() != INetProtocol::NotValid )
      {
          m_sName = i_rDocumentURL;
          // TODO: our data source must broadcast the change of the Name property
      }
  }

  // remember URL
  m_sDocumentURL = i_rDocumentURL;

  // update our location, if necessary
  if  ( m_sDocFileLocation.isEmpty() )
      m_sDocFileLocation = m_sDocumentURL;

  // register at the database context, or change registration
  if (!sOldURL.isEmpty())
      m_rDBContext.databaseDocumentURLChange( sOldURL, m_sDocumentURL );
  else
      m_rDBContext.registerDatabaseDocument( *this );
1292}

1294OUString ODatabaseModelImpl::getObjectContainerStorageName( const ObjectType _eType )
1295{
  return lcl_getContainerStorageName_throw( _eType );
1297}

1299sal_Int16 ODatabaseModelImpl::getCurrentMacroExecMode() const
1300{
  sal_Int16 nCurrentMode = MacroExecMode::NEVER_EXECUTE;
  try
  {
      nCurrentMode = m_aMediaDescriptor.getOrDefault( "MacroExecutionMode", nCurrentMode );
  }
  catch( const Exception& )
  {
      DBG_UNHANDLED_EXCEPTION("dbaccess")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/dbaccess/source/core/dataaccess/ModelImpl.cxx"
 ":" "1308" ": ", "dbaccess" );;
  }
  return nCurrentMode;
1311}

1313void ODatabaseModelImpl::setCurrentMacroExecMode( sal_uInt16 nMacroMode )
1314{
  m_aMediaDescriptor.put( "MacroExecutionMode", nMacroMode );
1316}

1318OUString ODatabaseModelImpl::getDocumentLocation() const
1319{
  return getURL();
  // formerly, we returned getDocFileLocation here, which is the location of the file from which we
  // recovered the "real" document.
  // However, during CWS autorecovery evolving, we clarified (with MAV/MT) the role of XModel::getURL and
  // XStorable::getLocation. In this course, we agreed that for a macro security check, the *document URL*
  // (not the recovery file URL) is to be used: The recovery file lies in the backup folder, and by definition,
  // this folder is considered to be secure. So, the document URL needs to be used to decide about the security.
1327}

1329ODatabaseModelImpl::EmbeddedMacros ODatabaseModelImpl::determineEmbeddedMacros()
1330{
  if ( !m_aEmbeddedMacros )
  {
      if ( ::sfx2::DocumentMacroMode::storageHasMacros( getOrCreateRootStorage() ) )
      {
          m_aEmbeddedMacros = eDocumentWideMacros;
      }
      else if (   lcl_hasObjectsWithMacros_nothrow( *this, E_FORM )
              ||  lcl_hasObjectsWithMacros_nothrow( *this, E_REPORT )
              )
      {
          m_aEmbeddedMacros = eSubDocumentMacros;
      }
      else
      {
          m_aEmbeddedMacros = eNoMacros;
      }
  }
  return *m_aEmbeddedMacros;
1349}

1351bool ODatabaseModelImpl::documentStorageHasMacros() const
1352{
  const_cast< ODatabaseModelImpl* >( this )->determineEmbeddedMacros();
  return ( *m_aEmbeddedMacros != eNoMacros );
1355}

1357bool ODatabaseModelImpl::macroCallsSeenWhileLoading() const
1358{
  return m_bMacroCallsSeenWhileLoading;
1360}

1362Reference< XEmbeddedScripts > ODatabaseModelImpl::getEmbeddedDocumentScripts() const
1363{
  return Reference< XEmbeddedScripts >( getModel_noCreate(), UNO_QUERY );
1365}

1367SignatureState ODatabaseModelImpl::getScriptingSignatureState()
1368{
  return m_nScriptingSignatureState;
1370}

1372bool ODatabaseModelImpl::hasTrustedScriptingSignature(bool bAllowUIToAddAuthor)
1373{
  bool bResult = false;

  try
  {
      // Don't use m_xDocumentStorage, that somehow has an incomplete storage representation
      // which leads to signatures not being found
      Reference<XStorage> xStorage = comphelper::OStorageHelper::GetStorageOfFormatFromURL(
          ZIP_STORAGE_FORMAT_STRING"ZipFormat", m_sDocFileLocation, ElementModes::READ);

      OUString aODFVersion(comphelper::OStorageHelper::GetODFVersionFromStorage(getOrCreateRootStorage()));
      uno::Reference<security::XDocumentDigitalSignatures> xSigner(
          security::DocumentDigitalSignatures::createWithVersion(
              comphelper::getProcessComponentContext(), aODFVersion));
      uno::Sequence<security::DocumentSignatureInformation> aInfo
          = xSigner->verifyScriptingContentSignatures(xStorage,
                                                      uno::Reference<io::XInputStream>());

      if (!aInfo.hasElements())
          return false;

      m_nScriptingSignatureState = DocumentSignatures::getSignatureState(aInfo);
      if (m_nScriptingSignatureState == SignatureState::OK
          || m_nScriptingSignatureState == SignatureState::NOTVALIDATED)
      {
          bResult = std::any_of(aInfo.begin(), aInfo.end(),
                                [&xSigner](const security::DocumentSignatureInformation& rInfo) {
                                    return xSigner->isAuthorTrusted(rInfo.Signer);
                                });
      }

      if (!bResult && bAllowUIToAddAuthor)
      {
          Reference<XInteractionHandler> xInteraction;
          xInteraction = m_aMediaDescriptor.getOrDefault("InteractionHandler", xInteraction);
          if (xInteraction.is())
          {
              task::DocumentMacroConfirmationRequest aRequest;
              aRequest.DocumentURL = m_sDocFileLocation;
              aRequest.DocumentStorage = xStorage;
              aRequest.DocumentSignatureInformation = aInfo;
              aRequest.DocumentVersion = aODFVersion;
              aRequest.Classification = task::InteractionClassification_QUERY;
              bResult = SfxMedium::CallApproveHandler(xInteraction, uno::makeAny(aRequest), true);
          }
      }
  }
  catch (uno::Exception&)
  {
  }

  return bResult;
1425}

1427void ODatabaseModelImpl::storageIsModified()
1428{
  setModified( true );
1430}

1432ModelDependentComponent::ModelDependentComponent( const ::rtl::Reference< ODatabaseModelImpl >& _model )
  :m_pImpl( _model )
1434{
1435}

1437ModelDependentComponent::~ModelDependentComponent()
1438{
1439}

1441}   // namespace dbaccess

1443/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/rtl/ref.hxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* 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 .
*/

20#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX

23#include "sal/config.h"

25#include <cassert>
26#include <cstddef>
27#include <functional>
28#ifdef LIBO_INTERNAL_ONLY1
29#include <type_traits>
30#endif

32#include "sal/types.h"

34namespace rtl
35{

37/** Template reference class for reference type.
38*/
39template <class reference_type>
40class Reference
41{
  /** The <b>reference_type</b> body pointer.
   */
  reference_type * m_pBody;


47public:
  /** Constructor...
   */
  Reference()
      : m_pBody (NULL__null)
  {}


  /** Constructor...
   */
  Reference (reference_type * pBody, __sal_NoAcquire)
      : m_pBody (pBody)
  {
  }

  /** Constructor...
   */
  Reference (reference_type * pBody)
      : m_pBody (pBody)
  {
      if (m_pBody)
          m_pBody->acquire();
  }

  /** Copy constructor...
   */
  Reference (const Reference<reference_type> & handle)
      : m_pBody (handle.m_pBody)
  {
      if (m_pBody)
          m_pBody->acquire();
  }

80#ifdef LIBO_INTERNAL_ONLY1
  /** Move constructor...
   */
  Reference (Reference<reference_type> && handle) noexcept
      : m_pBody (handle.m_pBody)
  {
      handle.m_pBody = nullptr;
  }
88#endif

90#if defined LIBO_INTERNAL_ONLY1
  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template< class derived_type >
  inline Reference(
      const Reference< derived_type > & rRef,
      std::enable_if_t<std::is_base_of_v<reference_type, derived_type>, int> = 0 )
      : m_pBody (rRef.get())
  {
      if (m_pBody)
          m_pBody->acquire();
  }
106#endif

  /** Destructor...
   */
  ~Reference() COVERITY_NOEXCEPT_FALSE
  {
      if (m_pBody2.1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
)
3
←
Taking true branch→
          m_pBody->release();
4
←
Calling 'ODatabaseModelImpl::release'→
9
←
Returning; memory was released→
  }

  /** Set...
       Similar to assignment.
   */
  Reference<reference_type> &
  SAL_CALL set (reference_type * pBody)
  {
      if (pBody)
          pBody->acquire();
      reference_type * const pOld = m_pBody;
      m_pBody = pBody;
      if (pOld)
          pOld->release();
      return *this;
  }

  /** Assignment.
       Unbinds this instance from its body (if bound) and
       bind it to the body represented by the handle.
   */
  Reference<reference_type> &
  SAL_CALL operator= (const Reference<reference_type> & handle)
  {
      return set( handle.m_pBody );
  }

141#ifdef LIBO_INTERNAL_ONLY1
  /** Assignment.
   *   Unbinds this instance from its body (if bound),
   *   bind it to the body represented by the handle, and
   *   set the body represented by the handle to nullptr.
   */
  Reference<reference_type> &
  operator= (Reference<reference_type> && handle)
  {
      // self-movement guts ourself
      if (m_pBody)
          m_pBody->release();
      m_pBody = handle.m_pBody;
      handle.m_pBody = nullptr;
      return *this;
  }
157#endif

  /** Assignment...
   */
  Reference<reference_type> &
  SAL_CALL operator= (reference_type * pBody)
  {
      return set( pBody );
  }

  /** Unbind the body from this handle.
       Note that for a handle representing a large body,
       "handle.clear().set(new body());" _might_
       perform a little bit better than "handle.set(new body());",
       since in the second case two large objects exist in memory
       (the old body and the new body).
   */
  Reference<reference_type> & SAL_CALL clear()
  {
      if (m_pBody)
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
      }
      return *this;
  }


  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
   */
  reference_type * SAL_CALL get() const
  {
      return m_pBody;
  }


  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * SAL_CALL operator->() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 200, __extension__ __PRETTY_FUNCTION__));
      return m_pBody;
  }


  /** Allows (*handle).someBodyOp().
  */
  reference_type & SAL_CALL operator*() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 209, __extension__ __PRETTY_FUNCTION__));
      return *m_pBody;
  }


  /** Returns True if the handle does point to a valid body.
   */
  bool SAL_CALL is() const
  {
      return (m_pBody != NULL__null);
  }

221#if defined LIBO_INTERNAL_ONLY1
  /** Returns True if the handle does point to a valid body.
   */
  explicit operator bool() const
  {
      return is();
  }
228#endif

  /** Returns True if this points to pBody.
   */
  bool SAL_CALL operator== (const reference_type * pBody) const
  {
      return (m_pBody == pBody);
  }


  /** Returns True if handle points to the same body.
   */
  bool
  SAL_CALL operator== (const Reference<reference_type> & handle) const
  {
      return (m_pBody == handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator!= (const Reference<reference_type> & handle) const
  {
      return (m_pBody != handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator< (const Reference<reference_type> & handle) const
  {
      return (m_pBody < handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator> (const Reference<reference_type> & handle) const
  {
      return (m_pBody > handle.m_pBody);
  }
272};

274} // namespace rtl

276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{

280/// @cond INTERNAL
281/**
Make rtl::Reference hashable by default for use in STL containers.

@since LibreOffice 6.3
285*/
286template<typename T>
287struct hash<::rtl::Reference<T>>
288{
  std::size_t operator()(::rtl::Reference<T> const & s) const
  { return std::size_t(s.get()); }
291};
292/// @endcond

294}

296#endif

298#endif /* ! INCLUDED_RTL_REF_HXX */

300/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/include/cppuhelper/weakref.hxx

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* 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 .
*/
19#ifndef INCLUDED_CPPUHELPER_WEAKREF_HXX
20#define INCLUDED_CPPUHELPER_WEAKREF_HXX

22#include "sal/config.h"

24#include <cstddef>

26#include "com/sun/star/uno/Reference.hxx"
27#include "com/sun/star/uno/XInterface.hpp"
28#include "cppuhelper/cppuhelperdllapi.h"


31namespace com
32{
33namespace sun
34{
35namespace star
36{
37namespace uno
38{

40class OWeakRefListener;

42/** The WeakReferenceHelper holds a weak reference to an object.

  That object must implement the css::uno::XWeak interface.

  The WeakReferenceHelper itself is *not* thread safe, just as
  Reference itself isn't, but the implementation of the listeners etc.
  behind it *is* thread-safe, so multiple threads can have their own
  WeakReferences to the same XWeak object.
50*/
51class CPPUHELPER_DLLPUBLIC__attribute__ ((visibility("default"))) WeakReferenceHelper
52{
53public:
  /** Default ctor.  Creates an empty weak reference.
  */
  WeakReferenceHelper()
      : m_pImpl( NULL__null )
      {}

  /** Copy ctor.  Initialize this reference with the same interface as in rWeakRef.

      @param rWeakRef another weak ref
  */
  WeakReferenceHelper( const WeakReferenceHelper & rWeakRef );

66#if defined LIBO_INTERNAL_ONLY1
  WeakReferenceHelper(WeakReferenceHelper && other) noexcept : m_pImpl(other.m_pImpl)
  { other.m_pImpl = nullptr; }
69#endif

  /** Initialize this reference with the hard interface reference xInt. If the implementation
      behind xInt does not support XWeak or xInt is null then this reference will be null.

      @param xInt another hard interface reference
  */
  WeakReferenceHelper( const css::uno::Reference< css::uno::XInterface > & xInt );

  /** Releases this reference.
  */
  ~WeakReferenceHelper();

  /** Releases this reference and takes over rWeakRef.

      @param rWeakRef another weak ref
  */
  WeakReferenceHelper & SAL_CALL operator = ( const WeakReferenceHelper & rWeakRef );

88#if defined LIBO_INTERNAL_ONLY1
  WeakReferenceHelper & SAL_CALL operator =(WeakReferenceHelper && other);
90#endif

  /** Releases this reference and takes over hard reference xInt.
      If the implementation behind xInt does not support XWeak
      or XInt is null, then this reference is null.

      @param xInt another hard reference
  */
  WeakReferenceHelper & SAL_CALL operator = (
          const css::uno::Reference< css::uno::XInterface > & xInt );

  /** Returns true if both weak refs reference to the same object.

      @param rObj another weak ref
      @return true, if both weak refs reference to the same object.
  */
  bool SAL_CALL operator == ( const WeakReferenceHelper & rObj ) const
      { return (get() == rObj.get()); }

  /**  Gets a hard reference to the object.

       @return hard reference or null, if the weakly referenced interface has gone
  */
  css::uno::Reference< css::uno::XInterface > SAL_CALL get() const;

  /**  Gets a hard reference to the object.

       @return hard reference or null, if the weakly referenced interface has gone
  */
  SAL_CALL operator Reference< XInterface > () const
      { return get(); }

  /** Releases this reference.

      @since UDK 3.2.12
  */
  void SAL_CALL clear();

128protected:
  /// @cond INTERNAL
  OWeakRefListener * m_pImpl;
  /// @endcond
132};

134/** The WeakReference<> holds a weak reference to an object.

  That object must implement the css::uno::XWeak interface.

  The WeakReference itself is *not* thread safe, just as
  Reference itself isn't, but the implementation of the listeners etc.
  behind it *is* thread-safe, so multiple threads can have their own
  WeakReferences to the same XWeak object.

  @tparam interface_type type of interface
144*/
145template< class interface_type >
146class SAL_WARN_UNUSED__attribute__((warn_unused)) WeakReference : public WeakReferenceHelper
147{
148public:
  /** Default ctor.  Creates an empty weak reference.
  */
  WeakReference()
      : WeakReferenceHelper()
      {}

  /** Copy ctor.  Initialize this reference with a hard reference.

      @param rRef another hard ref
  */
  WeakReference( const Reference< interface_type > & rRef )
      : WeakReferenceHelper( rRef )
      {}

  /** Releases this reference and takes over hard reference xInt.
      If the implementation behind xInt does not support XWeak
      or XInt is null, then this reference is null.

      @param xInt another hard reference

      @since UDK 3.2.12
  */
  WeakReference & SAL_CALL operator = (
          const css::uno::Reference< interface_type > & xInt )
      { WeakReferenceHelper::operator=(xInt); return *this; }
12
←
Use of memory after it is freed

175#if defined LIBO_INTERNAL_ONLY1
  WeakReference & SAL_CALL operator = (
          css::uno::Reference< interface_type > && xInt )
      { WeakReferenceHelper::operator=(std::move(xInt)); return *this; }
179#endif

  /**  Gets a hard reference to the object.

       @return hard reference or null, if the weakly referenced interface has gone
  */
  SAL_CALL operator Reference< interface_type > () const
      { return Reference< interface_type >::query( get() ); }
187};

189}
190}
191}
192}

194#endif

196/* vim:set shiftwidth=4 softtabstop=4 expandtab: */