Quelle lbenv.cxx
Sprache: unbekannt
|
|
Untersuchungsergebnis.cxx Download desUnknown {[0] [0] [0]}zum Wurzelverzeichnis wechseln
/* -*- 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 .
*/
#ifdef DISABLE_DYNLOADING
#include <config_java.h>
#endif
#include <cppu/EnvDcp.hxx>
#include <sal/log.hxx>
#include <osl/diagnose.h>
#include <osl/interlck.h>
#include <osl/mutex.hxx>
#include <osl/module.hxx>
#include <osl/process.h>
#include <rtl/process.h>
#include <rtl/string.hxx>
#include <rtl/ustring.hxx>
#include <rtl/ustrbuf.hxx>
#include <typelib/typedescription.h>
#include <uno/dispatcher.h>
#include <uno/environment.h>
#include <uno/lbnames.h>
#include "prim.hxx"
#include "loadmodule.hxx"
#include <string_view>
#include <unordered_map>
#include <utility>
#include <vector>
#include <stdio.h>
namespace
{
bool td_equals( typelib_InterfaceTypeDescription const * pTD1,
typelib_InterfaceTypeDescription const * pTD2 )
{
return (pTD1 == pTD2 ||
(pTD1->aBase.pTypeName->length == pTD2->aBase.pTypeName->length &&
::rtl_ustr_compare(
pTD1->aBase.pTypeName->buffer,
pTD2->aBase.pTypeName->buffer ) == 0));
}
struct uno_DefaultEnvironment;
struct InterfaceEntry
{
sal_Int32 refCount;
void * pInterface;
uno_freeProxyFunc fpFreeProxy;
typelib_InterfaceTypeDescription * pTypeDescr;
};
struct ObjectEntry
{
OUString oid;
std::vector< InterfaceEntry > aInterfaces;
sal_Int32 nRef;
bool mixedObject;
explicit ObjectEntry( OUString aOId_ );
void append(
uno_DefaultEnvironment * pEnv,
void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr,
uno_freeProxyFunc fpFreeProxy );
InterfaceEntry * find(
typelib_InterfaceTypeDescription * pTypeDescr );
sal_Int32 find( void const * iface_ptr, std::size_t pos ) const;
};
struct FctPtrHash
{
std::size_t operator () ( const void * pKey ) const
{ return reinterpret_cast< std::size_t>( pKey ); }
};
// mapping from environment name to environment
typedef std::unordered_map<
OUString, uno_Environment * > OUString2EnvironmentMap;
// mapping from ptr to object entry
typedef std::unordered_map<
void *, ObjectEntry *, FctPtrHash > Ptr2ObjectMap;
// mapping from oid to object entry
typedef std::unordered_map<
OUString, ObjectEntry * > OId2ObjectMap;
struct EnvironmentsData
{
::osl::Mutex mutex;
OUString2EnvironmentMap aName2EnvMap;
EnvironmentsData() : isDisposing(false) {}
~EnvironmentsData();
void getEnvironment(
uno_Environment ** ppEnv, std::u16string_view rEnvDcp, void * pContext );
void registerEnvironment( uno_Environment ** ppEnv );
void getRegisteredEnvironments(
uno_Environment *** pppEnvs, sal_Int32 * pnLen,
uno_memAlloc memAlloc, std::u16string_view rEnvDcp );
bool isDisposing;
};
EnvironmentsData& theEnvironmentsData()
{
static EnvironmentsData SINGLETON;
return SINGLETON;
}
struct uno_DefaultEnvironment : public uno_ExtEnvironment
{
sal_Int32 nRef;
sal_Int32 nWeakRef;
::osl::Mutex mutex;
Ptr2ObjectMap aPtr2ObjectMap;
OId2ObjectMap aOId2ObjectMap;
uno_DefaultEnvironment(
const OUString & rEnvDcp_, void * pContext_ );
~uno_DefaultEnvironment();
};
ObjectEntry::ObjectEntry( OUString aOId_ )
: oid(std::move( aOId_ )),
nRef( 0 ),
mixedObject( false )
{
aInterfaces.reserve( 2 );
}
void ObjectEntry::append(
uno_DefaultEnvironment * pEnv,
void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr,
uno_freeProxyFunc fpFreeProxy )
{
InterfaceEntry aNewEntry;
if (! fpFreeProxy)
(*pEnv->acquireInterface)( pEnv, pInterface );
aNewEntry.refCount = 1;
aNewEntry.pInterface = pInterface;
aNewEntry.fpFreeProxy = fpFreeProxy;
typelib_typedescription_acquire( &pTypeDescr->aBase );
aNewEntry.pTypeDescr = pTypeDescr;
std::pair< Ptr2ObjectMap::iterator, bool > i(
pEnv->aPtr2ObjectMap.emplace( pInterface, this ) );
SAL_WARN_IF(
!i.second && (find(pInterface, 0) == -1 || i.first->second != this),
"cppu",
"map already contains " << i.first->second << " != " << this << " for "
<< pInterface);
aInterfaces.push_back( aNewEntry );
}
InterfaceEntry * ObjectEntry::find(
typelib_InterfaceTypeDescription * pTypeDescr_ )
{
OSL_ASSERT( ! aInterfaces.empty() );
if (aInterfaces.empty())
return nullptr;
// shortcut common case:
OUString const & type_name =
OUString::unacquired( &pTypeDescr_->aBase.pTypeName );
if ( type_name == "com.sun.star.uno.XInterface" )
{
return aInterfaces.data();
}
std::size_t nSize = aInterfaces.size();
for ( std::size_t nPos = 0; nPos < nSize; ++nPos )
{
typelib_InterfaceTypeDescription * pITD =
aInterfaces[ nPos ].pTypeDescr;
while (pITD)
{
if (td_equals( pITD, pTypeDescr_ ))
return &aInterfaces[ nPos ];
pITD = pITD->pBaseTypeDescription;
}
}
return nullptr;
}
sal_Int32 ObjectEntry::find(
void const * iface_ptr, std::size_t pos ) const
{
std::size_t size = aInterfaces.size();
for ( ; pos < size; ++pos )
{
if (aInterfaces[ pos ].pInterface == iface_ptr)
return pos;
}
return -1;
}
extern "C"
{
static void defenv_registerInterface(
uno_ExtEnvironment * pEnv, void ** ppInterface,
rtl_uString * pOId, typelib_InterfaceTypeDescription * pTypeDescr )
{
assert(pEnv && ppInterface && pOId && pTypeDescr && "### null ptr!");
OUString const & rOId = OUString::unacquired( &pOId );
uno_DefaultEnvironment * that =
static_cast< uno_DefaultEnvironment * >( pEnv );
::osl::ClearableMutexGuard guard( that->mutex );
// try to insert dummy 0:
std::pair<OId2ObjectMap::iterator, bool> const insertion(
that->aOId2ObjectMap.emplace( rOId, nullptr ) );
if (insertion.second)
{
ObjectEntry * pOEntry = new ObjectEntry( rOId );
insertion.first->second = pOEntry;
++pOEntry->nRef; // another register call on object
pOEntry->append( that, *ppInterface, pTypeDescr, nullptr );
}
else // object entry exists
{
ObjectEntry * pOEntry = insertion.first->second;
++pOEntry->nRef; // another register call on object
InterfaceEntry * pIEntry = pOEntry->find( pTypeDescr );
if (pIEntry) // type entry exists
{
++pIEntry->refCount;
if (pIEntry->pInterface != *ppInterface)
{
void * pInterface = pIEntry->pInterface;
(*pEnv->acquireInterface)( pEnv, pInterface );
guard.clear();
(*pEnv->releaseInterface)( pEnv, *ppInterface );
*ppInterface = pInterface;
}
}
else
{
pOEntry->append( that, *ppInterface, pTypeDescr, nullptr );
}
}
}
static void defenv_registerProxyInterface(
uno_ExtEnvironment * pEnv, void ** ppInterface, uno_freeProxyFunc freeProxy,
rtl_uString * pOId, typelib_InterfaceTypeDescription * pTypeDescr )
{
assert(pEnv && ppInterface && pOId && pTypeDescr && freeProxy && "### null ptr!");
OUString const & rOId = OUString::unacquired( &pOId );
uno_DefaultEnvironment * that =
static_cast< uno_DefaultEnvironment * >( pEnv );
::osl::ClearableMutexGuard guard( that->mutex );
// try to insert dummy 0:
std::pair<OId2ObjectMap::iterator, bool> const insertion(
that->aOId2ObjectMap.emplace( rOId, nullptr ) );
if (insertion.second)
{
ObjectEntry * pOEntry = new ObjectEntry( rOId );
insertion.first->second = pOEntry;
++pOEntry->nRef; // another register call on object
pOEntry->append( that, *ppInterface, pTypeDescr, freeProxy );
}
else // object entry exists
{
ObjectEntry * pOEntry = insertion.first->second;
// first registration was an original, then registerProxyInterface():
pOEntry->mixedObject |=
(!pOEntry->aInterfaces.empty() &&
pOEntry->aInterfaces[ 0 ].fpFreeProxy == nullptr);
++pOEntry->nRef; // another register call on object
InterfaceEntry * pIEntry = pOEntry->find( pTypeDescr );
if (pIEntry) // type entry exists
{
if (pIEntry->pInterface == *ppInterface)
{
++pIEntry->refCount;
}
else
{
void * pInterface = pIEntry->pInterface;
(*pEnv->acquireInterface)( pEnv, pInterface );
--pOEntry->nRef; // manual revoke of proxy to be freed
guard.clear();
(*freeProxy)( pEnv, *ppInterface );
*ppInterface = pInterface;
}
}
else
{
pOEntry->append( that, *ppInterface, pTypeDescr, freeProxy );
}
}
}
static void s_stub_defenv_revokeInterface(va_list * pParam)
{
uno_ExtEnvironment * pEnv = va_arg(*pParam, uno_ExtEnvironment *);
void * pInterface = va_arg(*pParam, void *);
assert(pEnv && pInterface && "### null ptr!");
uno_DefaultEnvironment * that =
static_cast< uno_DefaultEnvironment * >( pEnv );
::osl::ClearableMutexGuard guard( that->mutex );
Ptr2ObjectMap::const_iterator const iFind(
that->aPtr2ObjectMap.find( pInterface ) );
assert(iFind != that->aPtr2ObjectMap.end());
ObjectEntry * pOEntry = iFind->second;
if (! --pOEntry->nRef)
{
// cleanup maps
that->aOId2ObjectMap.erase( pOEntry->oid );
sal_Int32 nPos;
for ( nPos = pOEntry->aInterfaces.size(); nPos--; )
{
that->aPtr2ObjectMap.erase( pOEntry->aInterfaces[nPos].pInterface );
}
// the last proxy interface of the environment might kill this
// environment, because of releasing its language binding!!!
guard.clear();
// release interfaces
for ( nPos = pOEntry->aInterfaces.size(); nPos--; )
{
InterfaceEntry const & rEntry = pOEntry->aInterfaces[nPos];
typelib_typedescription_release( &rEntry.pTypeDescr->aBase );
if (rEntry.fpFreeProxy) // is proxy or used interface?
{
(*rEntry.fpFreeProxy)( pEnv, rEntry.pInterface );
}
else
{
(*pEnv->releaseInterface)( pEnv, rEntry.pInterface );
}
}
delete pOEntry;
}
else if (pOEntry->mixedObject)
{
OSL_ASSERT( !pOEntry->aInterfaces.empty() &&
pOEntry->aInterfaces[ 0 ].fpFreeProxy == nullptr );
sal_Int32 index = pOEntry->find( pInterface, 1 );
OSL_ASSERT( index > 0 );
if (index > 0)
{
InterfaceEntry & entry = pOEntry->aInterfaces[ index ];
OSL_ASSERT( entry.pInterface == pInterface );
if (entry.fpFreeProxy != nullptr)
{
--entry.refCount;
if (entry.refCount == 0)
{
uno_freeProxyFunc fpFreeProxy = entry.fpFreeProxy;
typelib_TypeDescription * pTypeDescr =
reinterpret_cast< typelib_TypeDescription * >(
entry.pTypeDescr );
pOEntry->aInterfaces.erase(
pOEntry->aInterfaces.begin() + index );
if (pOEntry->find( pInterface, index ) < 0)
{
// proxy ptr not registered for another interface:
// remove from ptr map
std::size_t erased =
that->aPtr2ObjectMap.erase( pInterface );
OSL_ASSERT( erased == 1 );
}
guard.clear();
typelib_typedescription_release( pTypeDescr );
(*fpFreeProxy)( pEnv, pInterface );
}
}
}
}
}
static void defenv_revokeInterface(uno_ExtEnvironment * pEnv, void * pInterface)
{
uno_Environment_invoke(&pEnv->aBase, s_stub_defenv_revokeInterface, pEnv, pInterface);
}
static void defenv_getObjectIdentifier(
uno_ExtEnvironment * pEnv, rtl_uString ** ppOId, void * pInterface )
{
assert(pEnv && ppOId && pInterface && "### null ptr!");
if (*ppOId)
{
::rtl_uString_release( *ppOId );
*ppOId = nullptr;
}
uno_DefaultEnvironment * that =
static_cast< uno_DefaultEnvironment * >( pEnv );
::osl::ClearableMutexGuard guard( that->mutex );
Ptr2ObjectMap::const_iterator const iFind(
that->aPtr2ObjectMap.find( pInterface ) );
if (iFind == that->aPtr2ObjectMap.end())
{
guard.clear();
(*pEnv->computeObjectIdentifier)( pEnv, ppOId, pInterface );
}
else
{
rtl_uString * hstr = iFind->second->oid.pData;
rtl_uString_acquire( hstr );
*ppOId = hstr;
}
}
static void defenv_getRegisteredInterface(
uno_ExtEnvironment * pEnv, void ** ppInterface,
rtl_uString * pOId, typelib_InterfaceTypeDescription * pTypeDescr )
{
assert(pEnv && ppInterface && pOId && pTypeDescr && "### null ptr!");
if (*ppInterface)
{
(*pEnv->releaseInterface)( pEnv, *ppInterface );
*ppInterface = nullptr;
}
OUString const & rOId = OUString::unacquired( &pOId );
uno_DefaultEnvironment * that =
static_cast< uno_DefaultEnvironment * >( pEnv );
::osl::MutexGuard guard( that->mutex );
OId2ObjectMap::const_iterator const iFind
( that->aOId2ObjectMap.find( rOId ) );
if (iFind != that->aOId2ObjectMap.end())
{
InterfaceEntry const * pIEntry = iFind->second->find( pTypeDescr );
if (pIEntry)
{
(*pEnv->acquireInterface)( pEnv, pIEntry->pInterface );
*ppInterface = pIEntry->pInterface;
}
}
}
static void defenv_getRegisteredInterfaces(
uno_ExtEnvironment * pEnv, void *** pppInterfaces, sal_Int32 * pnLen,
uno_memAlloc memAlloc )
{
assert(pEnv && pppInterfaces && pnLen && memAlloc && "### null ptr!");
uno_DefaultEnvironment * that =
static_cast< uno_DefaultEnvironment * >( pEnv );
::osl::MutexGuard guard( that->mutex );
sal_Int32 nLen = that->aPtr2ObjectMap.size();
sal_Int32 nPos = 0;
void ** ppInterfaces = static_cast<void **>((*memAlloc)( nLen * sizeof (void *) ));
for (const auto& rEntry : that->aPtr2ObjectMap)
{
ppInterfaces[nPos] = rEntry.first;
(*pEnv->acquireInterface)( pEnv, ppInterfaces[nPos] );
nPos++;
}
*pppInterfaces = ppInterfaces;
*pnLen = nLen;
}
static void defenv_acquire( uno_Environment * pEnv )
{
uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
osl_atomic_increment( &that->nWeakRef );
osl_atomic_increment( &that->nRef );
}
static void defenv_release( uno_Environment * pEnv )
{
uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
if (! osl_atomic_decrement( &that->nRef ))
{
// invoke dispose callback
if (pEnv->environmentDisposing)
{
(*pEnv->environmentDisposing)( pEnv );
}
OSL_ENSURE( that->aOId2ObjectMap.empty(), "### object entries left!" );
}
// free memory if no weak refs left
if (! osl_atomic_decrement( &that->nWeakRef ))
{
delete that;
}
}
static void defenv_acquireWeak( uno_Environment * pEnv )
{
uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
osl_atomic_increment( &that->nWeakRef );
}
static void defenv_releaseWeak( uno_Environment * pEnv )
{
uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
if (! osl_atomic_decrement( &that->nWeakRef ))
{
delete that;
}
}
static void defenv_harden(
uno_Environment ** ppHardEnv, uno_Environment * pEnv )
{
if (*ppHardEnv)
{
(*(*ppHardEnv)->release)( *ppHardEnv );
*ppHardEnv = nullptr;
}
EnvironmentsData & rData = theEnvironmentsData();
if (rData.isDisposing)
return;
uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
{
::osl::MutexGuard guard( rData.mutex );
if (1 == osl_atomic_increment( &that->nRef )) // is dead
{
that->nRef = 0;
return;
}
}
osl_atomic_increment( &that->nWeakRef );
*ppHardEnv = pEnv;
}
static void defenv_dispose( SAL_UNUSED_PARAMETER uno_Environment * )
{
}
}
uno_DefaultEnvironment::uno_DefaultEnvironment(
const OUString & rEnvDcp_, void * pContext_ )
: nRef( 0 ),
nWeakRef( 0 )
{
uno_Environment * that = reinterpret_cast< uno_Environment * >(this);
that->pReserved = nullptr;
// functions
that->acquire = defenv_acquire;
that->release = defenv_release;
that->acquireWeak = defenv_acquireWeak;
that->releaseWeak = defenv_releaseWeak;
that->harden = defenv_harden;
that->dispose = defenv_dispose;
that->pExtEnv = this;
// identifier
::rtl_uString_acquire( rEnvDcp_.pData );
that->pTypeName = rEnvDcp_.pData;
that->pContext = pContext_;
// will be late initialized
that->environmentDisposing = nullptr;
uno_ExtEnvironment::registerInterface = defenv_registerInterface;
uno_ExtEnvironment::registerProxyInterface = defenv_registerProxyInterface;
uno_ExtEnvironment::revokeInterface = defenv_revokeInterface;
uno_ExtEnvironment::getObjectIdentifier = defenv_getObjectIdentifier;
uno_ExtEnvironment::getRegisteredInterface = defenv_getRegisteredInterface;
uno_ExtEnvironment::getRegisteredInterfaces =
defenv_getRegisteredInterfaces;
}
uno_DefaultEnvironment::~uno_DefaultEnvironment()
{
::rtl_uString_release( aBase.pTypeName );
}
void writeLine(
void * stream, const char * pLine, const char * pFilter )
{
if (pFilter && *pFilter)
{
// lookup pFilter in pLine
while (*pLine)
{
if (*pLine == *pFilter)
{
sal_Int32 nPos = 1;
while (pLine[nPos] && pFilter[nPos] == pLine[nPos])
{
++nPos;
}
if (! pFilter[nPos])
{
if (stream)
{
fprintf( static_cast<FILE *>(stream), "%s\n", pLine );
}
else
{
SAL_WARN("cppu", pLine );
}
}
}
++pLine;
}
}
else
{
if (stream)
{
fprintf( static_cast<FILE *>(stream), "%s\n", pLine );
}
else
{
fprintf( stderr, "%s\n", pLine );
}
}
}
void writeLine(
void * stream, std::u16string_view rLine, const char * pFilter )
{
OString aLine( OUStringToOString(
rLine, RTL_TEXTENCODING_ASCII_US ) );
writeLine( stream, aLine.getStr(), pFilter );
}
}
extern "C" void SAL_CALL uno_dumpEnvironment(
void * stream, uno_Environment * pEnv, const char * pFilter ) noexcept
{
assert(pEnv && "### null ptr!");
OUStringBuffer buf;
if (! pEnv->pExtEnv)
{
writeLine( stream, "###################################"
"###########################################", pFilter );
buf.append( OUString::Concat("environment: ") + OUString::unacquired(&pEnv->pTypeName) );
writeLine( stream, buf, pFilter );
buf.setLength(0);
writeLine( stream, "NO INTERFACE INFORMATION AVAILABLE!", pFilter );
return;
}
writeLine( stream, "########################################"
"######################################", pFilter );
buf.append( OUString::Concat("environment dump: ") + OUString::unacquired(&pEnv->pTypeName) );
writeLine( stream, buf, pFilter );
buf.setLength(0);
uno_DefaultEnvironment * that =
reinterpret_cast< uno_DefaultEnvironment * >(pEnv);
::osl::MutexGuard guard( that->mutex );
Ptr2ObjectMap ptr2obj( that->aPtr2ObjectMap );
for (const auto& rEntry : that->aOId2ObjectMap)
{
ObjectEntry * pOEntry = rEntry.second;
buf.append( "+ " );
if (pOEntry->mixedObject)
buf.append( "mixed " );
buf.append( "object entry: nRef="
+ OUString::number(pOEntry->nRef)
+ "; oid=\""
+ pOEntry->oid
+ "\"" );
writeLine( stream, buf, pFilter );
buf.setLength(0);
for ( std::size_t nPos = 0;
nPos < pOEntry->aInterfaces.size(); ++nPos )
{
const InterfaceEntry & rIEntry = pOEntry->aInterfaces[nPos];
buf.append( OUString::Concat(" - ")
+ OUString::unacquired(&rIEntry.pTypeDescr->aBase.pTypeName) );
if (rIEntry.fpFreeProxy)
{
buf.append( "; proxy free=0x"
+ OUString::number( reinterpret_cast< sal_IntPtr >(rIEntry.fpFreeProxy), 16 ) );
}
else
{
buf.append( "; original" );
}
buf.append( "; ptr=0x"
+ OUString::number(reinterpret_cast< sal_IntPtr >(rIEntry.pInterface), 16 ) );
if (pOEntry->find( rIEntry.pInterface, nPos + 1 ) < 0)
{
std::size_t erased = ptr2obj.erase( rIEntry.pInterface );
if (erased != 1)
{
buf.append( " (ptr not found in map!)" );
}
}
writeLine( stream, buf, pFilter );
buf.setLength(0);
}
}
if (! ptr2obj.empty())
writeLine( stream, "ptr map inconsistency!!!", pFilter );
writeLine( stream, "#####################################"
"#########################################", pFilter );
}
extern "C" void SAL_CALL uno_dumpEnvironmentByName(
void * stream, rtl_uString * pEnvDcp, const char * pFilter ) noexcept
{
uno_Environment * pEnv = nullptr;
uno_getEnvironment( &pEnv, pEnvDcp, nullptr );
if (pEnv)
{
::uno_dumpEnvironment( stream, pEnv, pFilter );
(*pEnv->release)( pEnv );
}
else
{
writeLine(
stream,
Concat2View("environment \"" + OUString::unacquired(&pEnvDcp) + "\" does not exist!"),
pFilter );
}
}
namespace
{
const OUString & unoenv_getStaticOIdPart()
{
static auto const theStaticOIdPart = [] {
OUStringBuffer aRet( 64 );
aRet.append( "];" );
// pid
oslProcessInfo info;
info.Size = sizeof(oslProcessInfo);
if (::osl_getProcessInfo( nullptr, osl_Process_IDENTIFIER, &info ) ==
osl_Process_E_None)
{
aRet.append( static_cast<sal_Int64>(info.Ident), 16 );
}
else
{
aRet.append( "unknown process id" );
}
// good guid
sal_uInt8 ar[16];
::rtl_getGlobalProcessId( ar );
aRet.append( ';' );
for (unsigned char i : ar)
aRet.append( static_cast<sal_Int32>(i), 16 );
return aRet.makeStringAndClear();
}();
return theStaticOIdPart;
}
}
extern "C"
{
static void unoenv_computeObjectIdentifier(
uno_ExtEnvironment * pEnv, rtl_uString ** ppOId, void * pInterface )
{
assert(pEnv && ppOId && pInterface && "### null ptr!");
if (*ppOId)
{
::rtl_uString_release( *ppOId );
*ppOId = nullptr;
}
uno_Interface * pUnoI = static_cast<uno_Interface *>(
::cppu::binuno_queryInterface(
pInterface, *typelib_static_type_getByTypeClass(
typelib_TypeClass_INTERFACE ) ));
if (nullptr == pUnoI)
return;
(*pUnoI->release)( pUnoI );
OUString aStr(
// interface
OUString::number( reinterpret_cast< sal_IntPtr >(pUnoI), 16 ) + ";"
// environment[context]
+ OUString::unacquired(&pEnv->aBase.pTypeName) + "["
+ OUString::number( reinterpret_cast< sal_IntPtr >(
reinterpret_cast<
uno_Environment * >(pEnv)->pContext ), 16 )
// process;good guid
+ unoenv_getStaticOIdPart() );
*ppOId = aStr.pData;
::rtl_uString_acquire( *ppOId );
}
static void unoenv_acquireInterface(
SAL_UNUSED_PARAMETER uno_ExtEnvironment *, void * pUnoI_ )
{
uno_Interface * pUnoI = static_cast< uno_Interface * >(pUnoI_);
(*pUnoI->acquire)( pUnoI );
}
static void unoenv_releaseInterface(
SAL_UNUSED_PARAMETER uno_ExtEnvironment *, void * pUnoI_ )
{
uno_Interface * pUnoI = static_cast< uno_Interface * >(pUnoI_);
(*pUnoI->release)( pUnoI );
}
}
namespace {
EnvironmentsData::~EnvironmentsData()
{
::osl::MutexGuard guard( mutex );
isDisposing = true;
for ( const auto& rEntry : aName2EnvMap )
{
uno_Environment * pWeak = rEntry.second;
uno_Environment * pHard = nullptr;
(*pWeak->harden)( &pHard, pWeak );
(*pWeak->releaseWeak)( pWeak );
if (pHard)
{
(*pHard->dispose)( pHard ); // send explicit dispose
(*pHard->release)( pHard );
}
}
}
void EnvironmentsData::getEnvironment(
uno_Environment ** ppEnv, std::u16string_view rEnvDcp, void * pContext )
{
if (*ppEnv)
{
(*(*ppEnv)->release)( *ppEnv );
*ppEnv = nullptr;
}
OUString aKey = OUString::number( reinterpret_cast< sal_IntPtr >(pContext) ) + rEnvDcp;
// try to find registered mapping
OUString2EnvironmentMap::const_iterator const iFind(
aName2EnvMap.find( aKey ) );
if (iFind != aName2EnvMap.end())
{
uno_Environment * pWeak = iFind->second;
(*pWeak->harden)( ppEnv, pWeak );
}
}
void EnvironmentsData::registerEnvironment( uno_Environment ** ppEnv )
{
assert(ppEnv && "### null ptr!");
uno_Environment * pEnv = *ppEnv;
OUString aKey =
OUString::number( reinterpret_cast< sal_IntPtr >(pEnv->pContext) ) +
OUString::unacquired(&pEnv->pTypeName);
// try to find registered environment
OUString2EnvironmentMap::const_iterator const iFind(
aName2EnvMap.find( aKey ) );
if (iFind == aName2EnvMap.end())
{
(*pEnv->acquireWeak)( pEnv );
std::pair< OUString2EnvironmentMap::iterator, bool > insertion (
aName2EnvMap.emplace( aKey, pEnv ) );
SAL_WARN_IF( !insertion.second, "cppu", "key " << aKey << " already in env map" );
}
else
{
uno_Environment * pHard = nullptr;
uno_Environment * pWeak = iFind->second;
(*pWeak->harden)( &pHard, pWeak );
if (pHard)
{
(*pEnv->release)( pEnv );
*ppEnv = pHard;
}
else // registered one is dead
{
(*pWeak->releaseWeak)( pWeak );
(*pEnv->acquireWeak)( pEnv );
aName2EnvMap[ aKey ] = pEnv;
}
}
}
void EnvironmentsData::getRegisteredEnvironments(
uno_Environment *** pppEnvs, sal_Int32 * pnLen, uno_memAlloc memAlloc,
std::u16string_view rEnvDcp )
{
assert(pppEnvs && pnLen && memAlloc && "### null ptr!");
// max size
std::vector<uno_Environment*> aFounds(aName2EnvMap.size());
sal_Int32 nSize = 0;
// find matching environment
for ( const auto& rEntry : aName2EnvMap )
{
uno_Environment * pWeak = rEntry.second;
if (rEnvDcp.empty() ||
rEnvDcp == OUString::unacquired(&pWeak->pTypeName) )
{
aFounds[nSize] = nullptr;
(*pWeak->harden)( &aFounds[nSize], pWeak );
if (aFounds[nSize])
++nSize;
}
}
*pnLen = nSize;
if (nSize)
{
*pppEnvs = static_cast<uno_Environment **>((*memAlloc)(
sizeof (uno_Environment *) * nSize ));
OSL_ASSERT( *pppEnvs );
while (nSize--)
{
(*pppEnvs)[nSize] = aFounds[nSize];
}
}
else
{
*pppEnvs = nullptr;
}
}
bool loadEnv(OUString const & cLibStem,
uno_Environment * pEnv)
{
#ifdef DISABLE_DYNLOADING
uno_initEnvironmentFunc fpInit;
if ( cLibStem == CPPU_CURRENT_LANGUAGE_BINDING_NAME "_uno" )
fpInit = CPPU_ENV_uno_initEnvironment;
#if HAVE_FEATURE_JAVA
else if ( cLibStem == "java_uno" )
fpInit = java_uno_initEnvironment;
#endif
else
{
SAL_INFO("cppu", ": Unhandled env: " << cLibStem);
return false;
}
#else
// late init with some code from matching uno language binding
// will be unloaded by environment
osl::Module aMod;
try {
bool bMod = cppu::detail::loadModule(aMod, cLibStem);
if (!bMod)
return false;
}
catch(...) {
// Catch everything and convert to return false
return false;
}
uno_initEnvironmentFunc fpInit = reinterpret_cast<uno_initEnvironmentFunc>(aMod.getSymbol(u"" UNO_INIT_ENVIRONMENT ""_ustr));
if (!fpInit)
return false;
aMod.release();
#endif
(*fpInit)( pEnv ); // init of environment
return true;
}
}
extern "C"
{
static uno_Environment * initDefaultEnvironment(
const OUString & rEnvDcp, void * pContext )
{
// coverity[leaked_storage : FALSE] - lifetime is controlled by acquire()/release() calls
uno_Environment * pEnv = &(new uno_DefaultEnvironment( rEnvDcp, pContext ))->aBase;
(*pEnv->acquire)( pEnv );
OUString envTypeName = cppu::EnvDcp::getTypeName(rEnvDcp);
// create default environment
if ( envTypeName == UNO_LB_UNO )
{
uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
that->computeObjectIdentifier = unoenv_computeObjectIdentifier;
that->acquireInterface = unoenv_acquireInterface;
that->releaseInterface = unoenv_releaseInterface;
OUString envPurpose = cppu::EnvDcp::getPurpose(rEnvDcp);
if (!envPurpose.isEmpty())
{
OUString libStem(
OUString::Concat(envPurpose.subView(envPurpose.lastIndexOf(':') + 1)) + "_uno_uno");
if(!loadEnv(libStem, pEnv))
{
pEnv->release(pEnv);
return nullptr;
}
}
}
else
{
// late init with some code from matching uno language binding
OUString aStr( envTypeName + "_uno" );
if (!loadEnv(aStr, pEnv))
{
pEnv->release(pEnv);
return nullptr;
}
}
return pEnv;
}
void SAL_CALL uno_createEnvironment(
uno_Environment ** ppEnv, rtl_uString * pEnvDcp, void * pContext ) noexcept
{
assert(ppEnv && "### null ptr!");
if (*ppEnv)
(*(*ppEnv)->release)( *ppEnv );
OUString const & rEnvDcp = OUString::unacquired( &pEnvDcp );
*ppEnv = initDefaultEnvironment( rEnvDcp, pContext );
}
void SAL_CALL uno_getEnvironment(
uno_Environment ** ppEnv, rtl_uString * pEnvDcp, void * pContext ) noexcept
{
assert(ppEnv && "### null ptr!");
OUString const & rEnvDcp = OUString::unacquired( &pEnvDcp );
EnvironmentsData & rData = theEnvironmentsData();
::osl::MutexGuard guard( rData.mutex );
rData.getEnvironment( ppEnv, rEnvDcp, pContext );
if (! *ppEnv)
{
*ppEnv = initDefaultEnvironment( rEnvDcp, pContext );
if (*ppEnv)
{
// register new environment:
rData.registerEnvironment( ppEnv );
}
}
}
void SAL_CALL uno_getRegisteredEnvironments(
uno_Environment *** pppEnvs, sal_Int32 * pnLen, uno_memAlloc memAlloc,
rtl_uString * pEnvDcp ) noexcept
{
EnvironmentsData & rData = theEnvironmentsData();
::osl::MutexGuard guard( rData.mutex );
rData.getRegisteredEnvironments(
pppEnvs, pnLen, memAlloc,
(pEnvDcp ? OUString(pEnvDcp) : OUString()) );
}
} // extern "C"
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
[ Verzeichnis aufwärts0.141unsichere Verbindung
]
|
2026-03-28
|
