cppu/source/uno/lbenv.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifdef DISABLE_DYNLOADING
  21 #include <config_java.h>
  22 #endif
  23
  24 #include <cppu/EnvDcp.hxx>
  25
  26 #include <sal/log.hxx>
  27 #include <osl/diagnose.h>
  28 #include <osl/interlck.h>
  29 #include <osl/mutex.hxx>
  30 #include <osl/module.hxx>
  31 #include <osl/process.h>
  32 #include <rtl/process.h>
  33 #include <rtl/string.hxx>
  34 #include <rtl/ustring.hxx>
  35 #include <rtl/ustrbuf.hxx>
  36 #include <typelib/typedescription.h>
  37 #include <uno/dispatcher.h>
  38 #include <uno/environment.h>
  39 #include <uno/lbnames.h>
  40 #include "prim.hxx"
  41 #include "loadmodule.hxx"
  42
  43 #include <string_view>
  44 #include <unordered_map>
  45 #include <utility>
  46 #include <vector>
  47 #include <stdio.h>
  48
  49
  50 namespace
  51 {
  52
  53
  54 bool td_equals( typelib_InterfaceTypeDescription const * pTD1,
  55                        typelib_InterfaceTypeDescription const * pTD2 )
  56 {
  57     return (pTD1 == pTD2 ||
  58             (pTD1->aBase.pTypeName->length == pTD2->aBase.pTypeName->length &&
  59              ::rtl_ustr_compare(
  60                  pTD1->aBase.pTypeName->buffer,
  61                  pTD2->aBase.pTypeName->buffer ) == 0));
  62 }
  63
  64 struct uno_DefaultEnvironment;
  65
  66
  67 struct InterfaceEntry
  68 {
  69     sal_Int32 refCount;
  70     void * pInterface;
  71     uno_freeProxyFunc fpFreeProxy;
  72     typelib_InterfaceTypeDescription * pTypeDescr;
  73 };
  74
  75 struct ObjectEntry
  76 {
  77     OUString oid;
  78     std::vector< InterfaceEntry > aInterfaces;
  79     sal_Int32 nRef;
  80     bool mixedObject;
  81
  82     explicit ObjectEntry( OUString aOId_ );
  83
  84     void append(
  85         uno_DefaultEnvironment * pEnv,
  86         void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr,
  87         uno_freeProxyFunc fpFreeProxy );
  88     InterfaceEntry * find(
  89         typelib_InterfaceTypeDescription * pTypeDescr );
  90     sal_Int32 find( void const * iface_ptr, std::size_t pos ) const;
  91 };
  92
  93
  94 struct FctPtrHash
  95 {
  96     std::size_t operator () ( const void * pKey ) const
  97         { return reinterpret_cast< std::size_t>( pKey ); }
  98 };
  99
 100
 101 // mapping from environment name to environment
 102 typedef std::unordered_map<
 103     OUString, uno_Environment * > OUString2EnvironmentMap;
 104
 105 // mapping from ptr to object entry
 106 typedef std::unordered_map<
 107     void *, ObjectEntry *, FctPtrHash > Ptr2ObjectMap;
 108 // mapping from oid to object entry
 109 typedef std::unordered_map<
 110     OUString, ObjectEntry * > OId2ObjectMap;
 111
 112 struct EnvironmentsData
 113 {
 114     ::osl::Mutex mutex;
 115     OUString2EnvironmentMap aName2EnvMap;
 116
 117     EnvironmentsData() : isDisposing(false) {}
 118     ~EnvironmentsData();
 119
 120     void getEnvironment(
 121         uno_Environment ** ppEnv, std::u16string_view rEnvDcp, void * pContext );
 122     void registerEnvironment( uno_Environment ** ppEnv );
 123     void getRegisteredEnvironments(
 124         uno_Environment *** pppEnvs, sal_Int32 * pnLen,
 125         uno_memAlloc memAlloc, std::u16string_view rEnvDcp );
 126
 127     bool isDisposing;
 128 };
 129
 130 EnvironmentsData& theEnvironmentsData()
 131 {
 132     static EnvironmentsData SINGLETON;
 133     return SINGLETON;
 134 }
 135
 136 struct uno_DefaultEnvironment : public uno_ExtEnvironment
 137 {
 138     sal_Int32 nRef;
 139     sal_Int32 nWeakRef;
 140
 141     ::osl::Mutex mutex;
 142     Ptr2ObjectMap aPtr2ObjectMap;
 143     OId2ObjectMap aOId2ObjectMap;
 144
 145     uno_DefaultEnvironment(
 146         const OUString & rEnvDcp_, void * pContext_ );
 147     ~uno_DefaultEnvironment();
 148 };
 149
 150
 151 ObjectEntry::ObjectEntry( OUString aOId_ )
 152     : oid(std::move( aOId_ )),
 153       nRef( 0 ),
 154       mixedObject( false )
 155 {
 156     aInterfaces.reserve( 2 );
 157 }
 158
 159
 160 void ObjectEntry::append(
 161     uno_DefaultEnvironment * pEnv,
 162     void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr,
 163     uno_freeProxyFunc fpFreeProxy )
 164 {
 165     InterfaceEntry aNewEntry;
 166     if (! fpFreeProxy)
 167         (*pEnv->acquireInterface)( pEnv, pInterface );
 168     aNewEntry.refCount = 1;
 169     aNewEntry.pInterface = pInterface;
 170     aNewEntry.fpFreeProxy = fpFreeProxy;
 171     typelib_typedescription_acquire( &pTypeDescr->aBase );
 172     aNewEntry.pTypeDescr = pTypeDescr;
 173
 174     std::pair< Ptr2ObjectMap::iterator, bool > i(
 175         pEnv->aPtr2ObjectMap.emplace( pInterface, this ) );
 176     SAL_WARN_IF(
 177         !i.second && (find(pInterface, 0) == -1 || i.first->second != this),
 178         "cppu",
 179         "map already contains " << i.first->second << " != " << this << " for "
 180             << pInterface);
 181     aInterfaces.push_back( aNewEntry );
 182 }
 183
 184
 185 InterfaceEntry * ObjectEntry::find(
 186     typelib_InterfaceTypeDescription * pTypeDescr_ )
 187 {
 188     OSL_ASSERT( ! aInterfaces.empty() );
 189     if (aInterfaces.empty())
 190         return nullptr;
 191
 192     // shortcut common case:
 193     OUString const & type_name =
 194         OUString::unacquired( &pTypeDescr_->aBase.pTypeName );
 195     if ( type_name == "com.sun.star.uno.XInterface" )
 196     {
 197         return aInterfaces.data();
 198     }
 199
 200     std::size_t nSize = aInterfaces.size();
 201     for ( std::size_t nPos = 0; nPos < nSize; ++nPos )
 202     {
 203         typelib_InterfaceTypeDescription * pITD =
 204             aInterfaces[ nPos ].pTypeDescr;
 205         while (pITD)
 206         {
 207             if (td_equals( pITD, pTypeDescr_ ))
 208                 return &aInterfaces[ nPos ];
 209             pITD = pITD->pBaseTypeDescription;
 210         }
 211     }
 212     return nullptr;
 213 }
 214
 215
 216 sal_Int32 ObjectEntry::find(
 217     void const * iface_ptr, std::size_t pos ) const
 218 {
 219     std::size_t size = aInterfaces.size();
 220     for ( ; pos < size; ++pos )
 221     {
 222         if (aInterfaces[ pos ].pInterface == iface_ptr)
 223             return pos;
 224     }
 225     return -1;
 226 }
 227
 228 extern "C"
 229 {
 230
 231
 232 static void defenv_registerInterface(
 233     uno_ExtEnvironment * pEnv, void ** ppInterface,
 234     rtl_uString * pOId, typelib_InterfaceTypeDescription * pTypeDescr )
 235 {
 236     assert(pEnv && ppInterface && pOId && pTypeDescr && "### null ptr!");
 237     OUString const & rOId = OUString::unacquired( &pOId );
 238
 239     uno_DefaultEnvironment * that =
 240         static_cast< uno_DefaultEnvironment * >( pEnv );
 241     ::osl::ClearableMutexGuard guard( that->mutex );
 242
 243     // try to insert dummy 0:
 244     std::pair<OId2ObjectMap::iterator, bool> const insertion(
 245         that->aOId2ObjectMap.emplace(  rOId, nullptr ) );
 246     if (insertion.second)
 247     {
 248         ObjectEntry * pOEntry = new ObjectEntry( rOId );
 249         insertion.first->second = pOEntry;
 250         ++pOEntry->nRef; // another register call on object
 251         pOEntry->append( that, *ppInterface, pTypeDescr, nullptr );
 252     }
 253     else // object entry exists
 254     {
 255         ObjectEntry * pOEntry = insertion.first->second;
 256         ++pOEntry->nRef; // another register call on object
 257         InterfaceEntry * pIEntry = pOEntry->find( pTypeDescr );
 258
 259         if (pIEntry) // type entry exists
 260         {
 261             ++pIEntry->refCount;
 262             if (pIEntry->pInterface != *ppInterface)
 263             {
 264                 void * pInterface = pIEntry->pInterface;
 265                 (*pEnv->acquireInterface)( pEnv, pInterface );
 266                 guard.clear();
 267                 (*pEnv->releaseInterface)( pEnv, *ppInterface );
 268                 *ppInterface = pInterface;
 269             }
 270         }
 271         else
 272         {
 273             pOEntry->append( that, *ppInterface, pTypeDescr, nullptr );
 274         }
 275     }
 276 }
 277
 278 static void defenv_registerProxyInterface(
 279     uno_ExtEnvironment * pEnv, void ** ppInterface, uno_freeProxyFunc freeProxy,
 280     rtl_uString * pOId, typelib_InterfaceTypeDescription * pTypeDescr )
 281 {
 282     assert(pEnv && ppInterface && pOId && pTypeDescr && freeProxy && "### null ptr!");
 283     OUString const & rOId = OUString::unacquired( &pOId );
 284
 285     uno_DefaultEnvironment * that =
 286         static_cast< uno_DefaultEnvironment * >( pEnv );
 287     ::osl::ClearableMutexGuard guard( that->mutex );
 288
 289     // try to insert dummy 0:
 290     std::pair<OId2ObjectMap::iterator, bool> const insertion(
 291         that->aOId2ObjectMap.emplace(  rOId, nullptr ) );
 292     if (insertion.second)
 293     {
 294         ObjectEntry * pOEntry = new ObjectEntry( rOId );
 295         insertion.first->second = pOEntry;
 296         ++pOEntry->nRef; // another register call on object
 297         pOEntry->append( that, *ppInterface, pTypeDescr, freeProxy );
 298     }
 299     else // object entry exists
 300     {
 301         ObjectEntry * pOEntry = insertion.first->second;
 302
 303         // first registration was an original, then registerProxyInterface():
 304         pOEntry->mixedObject |=
 305             (!pOEntry->aInterfaces.empty() &&
 306              pOEntry->aInterfaces[ 0 ].fpFreeProxy == nullptr);
 307
 308         ++pOEntry->nRef; // another register call on object
 309         InterfaceEntry * pIEntry = pOEntry->find( pTypeDescr );
 310
 311         if (pIEntry) // type entry exists
 312         {
 313             if (pIEntry->pInterface == *ppInterface)
 314             {
 315                 ++pIEntry->refCount;
 316             }
 317             else
 318             {
 319                 void * pInterface = pIEntry->pInterface;
 320                 (*pEnv->acquireInterface)( pEnv, pInterface );
 321                 --pOEntry->nRef; // manual revoke of proxy to be freed
 322                 guard.clear();
 323                 (*freeProxy)( pEnv, *ppInterface );
 324                 *ppInterface = pInterface;
 325             }
 326         }
 327         else
 328         {
 329             pOEntry->append( that, *ppInterface, pTypeDescr, freeProxy );
 330         }
 331     }
 332 }
 333
 334 static void s_stub_defenv_revokeInterface(va_list * pParam)
 335 {
 336     uno_ExtEnvironment * pEnv       = va_arg(*pParam, uno_ExtEnvironment *);
 337     void               * pInterface = va_arg(*pParam, void *);
 338
 339     assert(pEnv && pInterface && "### null ptr!");
 340     uno_DefaultEnvironment * that =
 341         static_cast< uno_DefaultEnvironment * >( pEnv );
 342     ::osl::ClearableMutexGuard guard( that->mutex );
 343
 344     Ptr2ObjectMap::const_iterator const iFind(
 345         that->aPtr2ObjectMap.find( pInterface ) );
 346     assert(iFind != that->aPtr2ObjectMap.end());
 347     ObjectEntry * pOEntry = iFind->second;
 348     if (! --pOEntry->nRef)
 349     {
 350         // cleanup maps
 351         that->aOId2ObjectMap.erase( pOEntry->oid );
 352         sal_Int32 nPos;
 353         for ( nPos = pOEntry->aInterfaces.size(); nPos--; )
 354         {
 355             that->aPtr2ObjectMap.erase( pOEntry->aInterfaces[nPos].pInterface );
 356         }
 357
 358         // the last proxy interface of the environment might kill this
 359         // environment, because of releasing its language binding!!!
 360         guard.clear();
 361
 362         // release interfaces
 363         for ( nPos = pOEntry->aInterfaces.size(); nPos--; )
 364         {
 365             InterfaceEntry const & rEntry = pOEntry->aInterfaces[nPos];
 366             typelib_typedescription_release( &rEntry.pTypeDescr->aBase );
 367             if (rEntry.fpFreeProxy) // is proxy or used interface?
 368             {
 369                 (*rEntry.fpFreeProxy)( pEnv, rEntry.pInterface );
 370             }
 371             else
 372             {
 373                 (*pEnv->releaseInterface)( pEnv, rEntry.pInterface );
 374             }
 375         }
 376
 377         delete pOEntry;
 378     }
 379     else if (pOEntry->mixedObject)
 380     {
 381         OSL_ASSERT( !pOEntry->aInterfaces.empty() &&
 382                     pOEntry->aInterfaces[ 0 ].fpFreeProxy == nullptr );
 383
 384         sal_Int32 index = pOEntry->find( pInterface, 1 );
 385         OSL_ASSERT( index > 0 );
 386         if (index > 0)
 387         {
 388             InterfaceEntry & entry = pOEntry->aInterfaces[ index ];
 389             OSL_ASSERT( entry.pInterface == pInterface );
 390             if (entry.fpFreeProxy != nullptr)
 391             {
 392                 --entry.refCount;
 393                 if (entry.refCount == 0)
 394                 {
 395                     uno_freeProxyFunc fpFreeProxy = entry.fpFreeProxy;
 396                     typelib_TypeDescription * pTypeDescr =
 397                         reinterpret_cast< typelib_TypeDescription * >(
 398                             entry.pTypeDescr );
 399
 400                     pOEntry->aInterfaces.erase(
 401                         pOEntry->aInterfaces.begin() + index );
 402                     if (pOEntry->find( pInterface, index ) < 0)
 403                     {
 404                         // proxy ptr not registered for another interface:
 405                         // remove from ptr map
 406                         std::size_t erased =
 407                               that->aPtr2ObjectMap.erase( pInterface );
 408                         OSL_ASSERT( erased == 1 );
 409                     }
 410
 411                     guard.clear();
 412
 413                     typelib_typedescription_release( pTypeDescr );
 414                     (*fpFreeProxy)( pEnv, pInterface );
 415                 }
 416             }
 417         }
 418     }
 419 }
 420
 421 static void defenv_revokeInterface(uno_ExtEnvironment * pEnv, void * pInterface)
 422 {
 423     uno_Environment_invoke(&pEnv->aBase, s_stub_defenv_revokeInterface, pEnv, pInterface);
 424 }
 425
 426
 427 static void defenv_getObjectIdentifier(
 428     uno_ExtEnvironment * pEnv, rtl_uString ** ppOId, void * pInterface )
 429 {
 430     assert(pEnv && ppOId && pInterface && "### null ptr!");
 431     if (*ppOId)
 432     {
 433         ::rtl_uString_release( *ppOId );
 434         *ppOId = nullptr;
 435     }
 436
 437     uno_DefaultEnvironment * that =
 438         static_cast< uno_DefaultEnvironment * >( pEnv );
 439     ::osl::ClearableMutexGuard guard( that->mutex );
 440
 441     Ptr2ObjectMap::const_iterator const iFind(
 442         that->aPtr2ObjectMap.find( pInterface ) );
 443     if (iFind == that->aPtr2ObjectMap.end())
 444     {
 445         guard.clear();
 446         (*pEnv->computeObjectIdentifier)( pEnv, ppOId, pInterface );
 447     }
 448     else
 449     {
 450         rtl_uString * hstr = iFind->second->oid.pData;
 451         rtl_uString_acquire( hstr );
 452         *ppOId = hstr;
 453     }
 454 }
 455
 456 static void defenv_getRegisteredInterface(
 457     uno_ExtEnvironment * pEnv, void ** ppInterface,
 458     rtl_uString * pOId, typelib_InterfaceTypeDescription * pTypeDescr )
 459 {
 460     assert(pEnv && ppInterface && pOId && pTypeDescr && "### null ptr!");
 461     if (*ppInterface)
 462     {
 463         (*pEnv->releaseInterface)( pEnv, *ppInterface );
 464         *ppInterface = nullptr;
 465     }
 466
 467     OUString const & rOId = OUString::unacquired( &pOId );
 468     uno_DefaultEnvironment * that =
 469         static_cast< uno_DefaultEnvironment * >( pEnv );
 470     ::osl::MutexGuard guard( that->mutex );
 471
 472     OId2ObjectMap::const_iterator const iFind
 473         ( that->aOId2ObjectMap.find( rOId ) );
 474     if (iFind != that->aOId2ObjectMap.end())
 475     {
 476         InterfaceEntry const * pIEntry = iFind->second->find( pTypeDescr );
 477         if (pIEntry)
 478         {
 479             (*pEnv->acquireInterface)( pEnv, pIEntry->pInterface );
 480             *ppInterface = pIEntry->pInterface;
 481         }
 482     }
 483 }
 484
 485 static void defenv_getRegisteredInterfaces(
 486     uno_ExtEnvironment * pEnv, void *** pppInterfaces, sal_Int32 * pnLen,
 487     uno_memAlloc memAlloc )
 488 {
 489     assert(pEnv && pppInterfaces && pnLen && memAlloc && "### null ptr!");
 490     uno_DefaultEnvironment * that =
 491         static_cast< uno_DefaultEnvironment * >( pEnv );
 492     ::osl::MutexGuard guard( that->mutex );
 493
 494     sal_Int32 nLen = that->aPtr2ObjectMap.size();
 495     sal_Int32 nPos = 0;
 496     void ** ppInterfaces = static_cast<void **>((*memAlloc)( nLen * sizeof (void *) ));
 497
 498     for (const auto& rEntry : that->aPtr2ObjectMap)
 499     {
 500         ppInterfaces[nPos] = rEntry.first;
 501         (*pEnv->acquireInterface)( pEnv, ppInterfaces[nPos] );
 502         nPos++;
 503     }
 504
 505     *pppInterfaces = ppInterfaces;
 506     *pnLen = nLen;
 507 }
 508
 509
 510 static void defenv_acquire( uno_Environment * pEnv )
 511 {
 512     uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
 513     osl_atomic_increment( &that->nWeakRef );
 514     osl_atomic_increment( &that->nRef );
 515 }
 516
 517
 518 static void defenv_release( uno_Environment * pEnv )
 519 {
 520     uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
 521     if (! osl_atomic_decrement( &that->nRef ))
 522     {
 523         // invoke dispose callback
 524         if (pEnv->environmentDisposing)
 525         {
 526             (*pEnv->environmentDisposing)( pEnv );
 527         }
 528
 529         OSL_ENSURE( that->aOId2ObjectMap.empty(), "### object entries left!" );
 530     }
 531     // free memory if no weak refs left
 532     if (! osl_atomic_decrement( &that->nWeakRef ))
 533     {
 534         delete that;
 535     }
 536 }
 537
 538
 539 static void defenv_acquireWeak( uno_Environment * pEnv )
 540 {
 541     uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
 542     osl_atomic_increment( &that->nWeakRef );
 543 }
 544
 545
 546 static void defenv_releaseWeak( uno_Environment * pEnv )
 547 {
 548     uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
 549     if (! osl_atomic_decrement( &that->nWeakRef ))
 550     {
 551         delete that;
 552     }
 553 }
 554
 555
 556 static void defenv_harden(
 557     uno_Environment ** ppHardEnv, uno_Environment * pEnv )
 558 {
 559     if (*ppHardEnv)
 560     {
 561         (*(*ppHardEnv)->release)( *ppHardEnv );
 562         *ppHardEnv = nullptr;
 563     }
 564
 565     EnvironmentsData & rData = theEnvironmentsData();
 566
 567     if (rData.isDisposing)
 568         return;
 569
 570     uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
 571     {
 572     ::osl::MutexGuard guard( rData.mutex );
 573     if (1 == osl_atomic_increment( &that->nRef )) // is dead
 574     {
 575         that->nRef = 0;
 576         return;
 577     }
 578     }
 579     osl_atomic_increment( &that->nWeakRef );
 580     *ppHardEnv = pEnv;
 581 }
 582
 583
 584 static void defenv_dispose( SAL_UNUSED_PARAMETER uno_Environment * )
 585 {
 586 }
 587 }
 588
 589
 590 uno_DefaultEnvironment::uno_DefaultEnvironment(
 591     const OUString & rEnvDcp_, void * pContext_ )
 592     : nRef( 0 ),
 593       nWeakRef( 0 )
 594 {
 595     uno_Environment * that = reinterpret_cast< uno_Environment * >(this);
 596     that->pReserved = nullptr;
 597     // functions
 598     that->acquire = defenv_acquire;
 599     that->release = defenv_release;
 600     that->acquireWeak = defenv_acquireWeak;
 601     that->releaseWeak = defenv_releaseWeak;
 602     that->harden = defenv_harden;
 603     that->dispose = defenv_dispose;
 604     that->pExtEnv = this;
 605     // identifier
 606     ::rtl_uString_acquire( rEnvDcp_.pData );
 607     that->pTypeName = rEnvDcp_.pData;
 608     that->pContext = pContext_;
 609
 610     // will be late initialized
 611     that->environmentDisposing = nullptr;
 612
 613     uno_ExtEnvironment::registerInterface = defenv_registerInterface;
 614     uno_ExtEnvironment::registerProxyInterface = defenv_registerProxyInterface;
 615     uno_ExtEnvironment::revokeInterface = defenv_revokeInterface;
 616     uno_ExtEnvironment::getObjectIdentifier = defenv_getObjectIdentifier;
 617     uno_ExtEnvironment::getRegisteredInterface = defenv_getRegisteredInterface;
 618     uno_ExtEnvironment::getRegisteredInterfaces =
 619         defenv_getRegisteredInterfaces;
 620
 621 }
 622
 623
 624 uno_DefaultEnvironment::~uno_DefaultEnvironment()
 625 {
 626     ::rtl_uString_release( aBase.pTypeName );
 627 }
 628
 629
 630 void writeLine(
 631     void * stream, const char * pLine, const char * pFilter )
 632 {
 633     if (pFilter && *pFilter)
 634     {
 635         // lookup pFilter in pLine
 636         while (*pLine)
 637         {
 638             if (*pLine == *pFilter)
 639             {
 640                 sal_Int32 nPos = 1;
 641                 while (pLine[nPos] && pFilter[nPos] == pLine[nPos])
 642                 {
 643                     ++nPos;
 644                 }
 645                 if (! pFilter[nPos])
 646                 {
 647                     if (stream)
 648                     {
 649                         fprintf( static_cast<FILE *>(stream), "%s\n", pLine );
 650                     }
 651                     else
 652                     {
 653                         SAL_WARN("cppu", pLine );
 654                     }
 655                 }
 656             }
 657             ++pLine;
 658         }
 659     }
 660     else
 661     {
 662         if (stream)
 663         {
 664             fprintf( static_cast<FILE *>(stream), "%s\n", pLine );
 665         }
 666         else
 667         {
 668             fprintf( stderr, "%s\n", pLine );
 669         }
 670     }
 671 }
 672
 673
 674 void writeLine(
 675     void * stream, std::u16string_view rLine, const char * pFilter )
 676 {
 677     OString aLine( OUStringToOString(
 678                               rLine, RTL_TEXTENCODING_ASCII_US ) );
 679     writeLine( stream, aLine.getStr(), pFilter );
 680 }
 681
 682 }
 683
 684 extern "C" void SAL_CALL uno_dumpEnvironment(
 685     void * stream, uno_Environment * pEnv, const char * pFilter ) noexcept
 686 {
 687     assert(pEnv && "### null ptr!");
 688     OUStringBuffer buf;
 689
 690     if (! pEnv->pExtEnv)
 691     {
 692         writeLine( stream, "###################################"
 693                    "###########################################", pFilter );
 694         buf.append( OUString::Concat("environment: ") + OUString::unacquired(&pEnv->pTypeName) );
 695         writeLine( stream, buf, pFilter );
 696         buf.setLength(0);
 697         writeLine( stream, "NO INTERFACE INFORMATION AVAILABLE!", pFilter );
 698         return;
 699     }
 700
 701     writeLine( stream, "########################################"
 702                "######################################", pFilter );
 703     buf.append( OUString::Concat("environment dump: ") + OUString::unacquired(&pEnv->pTypeName) );
 704     writeLine( stream, buf, pFilter );
 705     buf.setLength(0);
 706
 707     uno_DefaultEnvironment * that =
 708         reinterpret_cast< uno_DefaultEnvironment * >(pEnv);
 709     ::osl::MutexGuard guard( that->mutex );
 710
 711     Ptr2ObjectMap ptr2obj( that->aPtr2ObjectMap );
 712     for (const auto& rEntry : that->aOId2ObjectMap)
 713     {
 714         ObjectEntry * pOEntry = rEntry.second;
 715
 716         buf.append( "+ " );
 717         if (pOEntry->mixedObject)
 718             buf.append( "mixed " );
 719         buf.append( "object entry: nRef="
 720                 + OUString::number(pOEntry->nRef)
 721                 + "; oid=\""
 722                 + pOEntry->oid
 723                 + "\"" );
 724         writeLine( stream, buf, pFilter );
 725         buf.setLength(0);
 726
 727         for ( std::size_t nPos = 0;
 728               nPos < pOEntry->aInterfaces.size(); ++nPos )
 729         {
 730             const InterfaceEntry & rIEntry = pOEntry->aInterfaces[nPos];
 731
 732             buf.append( OUString::Concat("  - ")
 733                 + OUString::unacquired(&rIEntry.pTypeDescr->aBase.pTypeName) );
 734             if (rIEntry.fpFreeProxy)
 735             {
 736                 buf.append( "; proxy free=0x"
 737                     + OUString::number( reinterpret_cast< sal_IntPtr >(rIEntry.fpFreeProxy), 16 ) );
 738             }
 739             else
 740             {
 741                 buf.append( "; original" );
 742             }
 743             buf.append( "; ptr=0x"
 744                 + OUString::number(reinterpret_cast< sal_IntPtr >(rIEntry.pInterface), 16 ) );
 745
 746             if (pOEntry->find( rIEntry.pInterface, nPos + 1 ) < 0)
 747             {
 748                 std::size_t erased = ptr2obj.erase( rIEntry.pInterface );
 749                 if (erased != 1)
 750                 {
 751                     buf.append( " (ptr not found in map!)" );
 752                 }
 753             }
 754             writeLine( stream, buf, pFilter );
 755             buf.setLength(0);
 756         }
 757     }
 758     if (! ptr2obj.empty())
 759         writeLine( stream, "ptr map inconsistency!!!", pFilter );
 760     writeLine( stream, "#####################################"
 761                "#########################################", pFilter );
 762 }
 763
 764
 765 extern "C" void SAL_CALL uno_dumpEnvironmentByName(
 766     void * stream, rtl_uString * pEnvDcp, const char * pFilter ) noexcept
 767 {
 768     uno_Environment * pEnv = nullptr;
 769     uno_getEnvironment( &pEnv, pEnvDcp, nullptr );
 770     if (pEnv)
 771     {
 772         ::uno_dumpEnvironment( stream, pEnv, pFilter );
 773         (*pEnv->release)( pEnv );
 774     }
 775     else
 776     {
 777         writeLine(
 778             stream,
 779             Concat2View("environment \"" + OUString::unacquired(&pEnvDcp) + "\" does not exist!"),
 780             pFilter );
 781     }
 782 }
 783
 784 namespace
 785 {
 786
 787 const OUString & unoenv_getStaticOIdPart()
 788 {
 789     static auto const theStaticOIdPart = [] {
 790             OUStringBuffer aRet( 64 );
 791             aRet.append( "];" );
 792             // pid
 793             oslProcessInfo info;
 794             info.Size = sizeof(oslProcessInfo);
 795             if (::osl_getProcessInfo( nullptr, osl_Process_IDENTIFIER, &info ) ==
 796                 osl_Process_E_None)
 797             {
 798                 aRet.append( static_cast<sal_Int64>(info.Ident), 16 );
 799             }
 800             else
 801             {
 802                 aRet.append( "unknown process id" );
 803             }
 804             // good guid
 805             sal_uInt8 ar[16];
 806             ::rtl_getGlobalProcessId( ar );
 807             aRet.append( ';' );
 808             for (unsigned char i : ar)
 809                 aRet.append( static_cast<sal_Int32>(i), 16 );
 810
 811             return aRet.makeStringAndClear();
 812         }();
 813     return theStaticOIdPart;
 814 }
 815
 816 }
 817
 818 extern "C"
 819 {
 820
 821
 822 static void unoenv_computeObjectIdentifier(
 823     uno_ExtEnvironment * pEnv, rtl_uString ** ppOId, void * pInterface )
 824 {
 825     assert(pEnv && ppOId && pInterface && "### null ptr!");
 826     if (*ppOId)
 827     {
 828         ::rtl_uString_release( *ppOId );
 829         *ppOId = nullptr;
 830     }
 831
 832     uno_Interface * pUnoI = static_cast<uno_Interface *>(
 833         ::cppu::binuno_queryInterface(
 834             pInterface, *typelib_static_type_getByTypeClass(
 835                 typelib_TypeClass_INTERFACE ) ));
 836     if (nullptr == pUnoI)
 837         return;
 838
 839     (*pUnoI->release)( pUnoI );
 840     OUString aStr(
 841         // interface
 842         OUString::number( reinterpret_cast< sal_IntPtr >(pUnoI), 16 ) + ";"
 843         // environment[context]
 844         + OUString::unacquired(&pEnv->aBase.pTypeName) + "["
 845         + OUString::number( reinterpret_cast< sal_IntPtr >(
 846                     reinterpret_cast<
 847                     uno_Environment * >(pEnv)->pContext ), 16 )
 848         // process;good guid
 849         + unoenv_getStaticOIdPart() );
 850     *ppOId = aStr.pData;
 851     ::rtl_uString_acquire( *ppOId );
 852 }
 853
 854
 855 static void unoenv_acquireInterface(
 856     SAL_UNUSED_PARAMETER uno_ExtEnvironment *, void * pUnoI_ )
 857 {
 858     uno_Interface * pUnoI = static_cast< uno_Interface * >(pUnoI_);
 859     (*pUnoI->acquire)( pUnoI );
 860 }
 861
 862
 863 static void unoenv_releaseInterface(
 864     SAL_UNUSED_PARAMETER uno_ExtEnvironment *, void * pUnoI_ )
 865 {
 866     uno_Interface * pUnoI = static_cast< uno_Interface * >(pUnoI_);
 867     (*pUnoI->release)( pUnoI );
 868 }
 869 }
 870
 871 namespace {
 872
 873 EnvironmentsData::~EnvironmentsData()
 874 {
 875     ::osl::MutexGuard guard( mutex );
 876     isDisposing = true;
 877
 878     for ( const auto& rEntry : aName2EnvMap )
 879     {
 880         uno_Environment * pWeak = rEntry.second;
 881         uno_Environment * pHard = nullptr;
 882         (*pWeak->harden)( &pHard, pWeak );
 883         (*pWeak->releaseWeak)( pWeak );
 884
 885         if (pHard)
 886         {
 887             (*pHard->dispose)( pHard ); // send explicit dispose
 888             (*pHard->release)( pHard );
 889         }
 890     }
 891 }
 892
 893
 894 void EnvironmentsData::getEnvironment(
 895     uno_Environment ** ppEnv, std::u16string_view rEnvDcp, void * pContext )
 896 {
 897     if (*ppEnv)
 898     {
 899         (*(*ppEnv)->release)( *ppEnv );
 900         *ppEnv = nullptr;
 901     }
 902
 903     OUString aKey = OUString::number( reinterpret_cast< sal_IntPtr >(pContext) ) + rEnvDcp;
 904
 905     // try to find registered mapping
 906     OUString2EnvironmentMap::const_iterator const iFind(
 907         aName2EnvMap.find( aKey ) );
 908     if (iFind != aName2EnvMap.end())
 909     {
 910         uno_Environment * pWeak = iFind->second;
 911         (*pWeak->harden)( ppEnv, pWeak );
 912     }
 913 }
 914
 915 void EnvironmentsData::registerEnvironment( uno_Environment ** ppEnv )
 916 {
 917     assert(ppEnv && "### null ptr!");
 918     uno_Environment * pEnv =  *ppEnv;
 919
 920     OUString aKey =
 921         OUString::number( reinterpret_cast< sal_IntPtr >(pEnv->pContext) ) +
 922         OUString::unacquired(&pEnv->pTypeName);
 923
 924     // try to find registered environment
 925     OUString2EnvironmentMap::const_iterator const iFind(
 926         aName2EnvMap.find( aKey ) );
 927     if (iFind == aName2EnvMap.end())
 928     {
 929         (*pEnv->acquireWeak)( pEnv );
 930         std::pair< OUString2EnvironmentMap::iterator, bool > insertion (
 931             aName2EnvMap.emplace( aKey, pEnv ) );
 932         SAL_WARN_IF( !insertion.second, "cppu", "key " << aKey << " already in env map" );
 933     }
 934     else
 935     {
 936         uno_Environment * pHard = nullptr;
 937         uno_Environment * pWeak = iFind->second;
 938         (*pWeak->harden)( &pHard, pWeak );
 939         if (pHard)
 940         {
 941             (*pEnv->release)( pEnv );
 942             *ppEnv = pHard;
 943         }
 944         else // registered one is dead
 945         {
 946             (*pWeak->releaseWeak)( pWeak );
 947             (*pEnv->acquireWeak)( pEnv );
 948             aName2EnvMap[ aKey ] = pEnv;
 949         }
 950     }
 951 }
 952
 953 void EnvironmentsData::getRegisteredEnvironments(
 954     uno_Environment *** pppEnvs, sal_Int32 * pnLen, uno_memAlloc memAlloc,
 955     std::u16string_view rEnvDcp )
 956 {
 957     assert(pppEnvs && pnLen && memAlloc && "### null ptr!");
 958
 959     // max size
 960     std::vector<uno_Environment*> aFounds(aName2EnvMap.size());
 961     sal_Int32 nSize = 0;
 962
 963     // find matching environment
 964     for ( const auto& rEntry : aName2EnvMap )
 965     {
 966         uno_Environment * pWeak = rEntry.second;
 967         if (rEnvDcp.empty() ||
 968             rEnvDcp == OUString::unacquired(&pWeak->pTypeName) )
 969         {
 970             aFounds[nSize] = nullptr;
 971             (*pWeak->harden)( &aFounds[nSize], pWeak );
 972             if (aFounds[nSize])
 973                 ++nSize;
 974         }
 975     }
 976
 977     *pnLen = nSize;
 978     if (nSize)
 979     {
 980         *pppEnvs = static_cast<uno_Environment **>((*memAlloc)(
 981             sizeof (uno_Environment *) * nSize ));
 982         OSL_ASSERT( *pppEnvs );
 983         while (nSize--)
 984         {
 985             (*pppEnvs)[nSize] = aFounds[nSize];
 986         }
 987     }
 988     else
 989     {
 990         *pppEnvs = nullptr;
 991     }
 992 }
 993
 994 bool loadEnv(OUString const  & cLibStem,
 995                     uno_Environment * pEnv)
 996 {
 997 #ifdef DISABLE_DYNLOADING
 998     uno_initEnvironmentFunc fpInit;
 999
1000     if ( cLibStem == CPPU_CURRENT_LANGUAGE_BINDING_NAME "_uno" )
1001         fpInit = CPPU_ENV_uno_initEnvironment;
1002 #if HAVE_FEATURE_JAVA
1003     else if ( cLibStem == "java_uno" )
1004         fpInit = java_uno_initEnvironment;
1005 #endif
1006     else
1007     {
1008         SAL_INFO("cppu", ": Unhandled env: " << cLibStem);
1009         return false;
1010     }
1011 #else
1012     // late init with some code from matching uno language binding
1013     // will be unloaded by environment
1014     osl::Module aMod;
1015     try {
1016         bool bMod = cppu::detail::loadModule(aMod, cLibStem);
1017         if (!bMod)
1018             return false;
1019     }
1020     catch(...) {
1021         // Catch everything and convert to return false
1022         return false;
1023     }
1024
1025
1026     uno_initEnvironmentFunc fpInit = reinterpret_cast<uno_initEnvironmentFunc>(aMod.getSymbol(u"" UNO_INIT_ENVIRONMENT ""_ustr));
1027
1028     if (!fpInit)
1029         return false;
1030
1031     aMod.release();
1032 #endif
1033
1034     (*fpInit)( pEnv ); // init of environment
1035     return true;
1036 }
1037
1038 }
1039
1040 extern "C"
1041 {
1042
1043
1044 static uno_Environment * initDefaultEnvironment(
1045     const OUString & rEnvDcp, void * pContext )
1046 {
1047     // coverity[leaked_storage : FALSE] - lifetime is controlled by acquire()/release() calls
1048     uno_Environment * pEnv = &(new uno_DefaultEnvironment( rEnvDcp, pContext ))->aBase;
1049     (*pEnv->acquire)( pEnv );
1050
1051     OUString envTypeName = cppu::EnvDcp::getTypeName(rEnvDcp);
1052
1053     // create default environment
1054     if ( envTypeName == UNO_LB_UNO )
1055     {
1056         uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
1057         that->computeObjectIdentifier = unoenv_computeObjectIdentifier;
1058         that->acquireInterface = unoenv_acquireInterface;
1059         that->releaseInterface = unoenv_releaseInterface;
1060
1061         OUString envPurpose = cppu::EnvDcp::getPurpose(rEnvDcp);
1062         if (!envPurpose.isEmpty())
1063         {
1064             OUString libStem(
1065                 OUString::Concat(envPurpose.subView(envPurpose.lastIndexOf(':') + 1)) + "_uno_uno");
1066             if(!loadEnv(libStem, pEnv))
1067             {
1068                 pEnv->release(pEnv);
1069                 return nullptr;
1070             }
1071         }
1072     }
1073     else
1074     {
1075         // late init with some code from matching uno language binding
1076         OUString aStr( envTypeName + "_uno" );
1077
1078         if (!loadEnv(aStr, pEnv))
1079         {
1080             pEnv->release(pEnv);
1081             return nullptr;
1082         }
1083     }
1084
1085     return pEnv;
1086 }
1087
1088
1089 void SAL_CALL uno_createEnvironment(
1090     uno_Environment ** ppEnv, rtl_uString * pEnvDcp, void * pContext ) noexcept
1091 {
1092     assert(ppEnv && "### null ptr!");
1093     if (*ppEnv)
1094         (*(*ppEnv)->release)( *ppEnv );
1095
1096     OUString const & rEnvDcp = OUString::unacquired( &pEnvDcp );
1097     *ppEnv = initDefaultEnvironment( rEnvDcp, pContext );
1098 }
1099
1100 void SAL_CALL uno_getEnvironment(
1101     uno_Environment ** ppEnv, rtl_uString * pEnvDcp, void * pContext ) noexcept
1102 {
1103     assert(ppEnv && "### null ptr!");
1104     OUString const & rEnvDcp = OUString::unacquired( &pEnvDcp );
1105
1106     EnvironmentsData & rData = theEnvironmentsData();
1107
1108     ::osl::MutexGuard guard( rData.mutex );
1109     rData.getEnvironment( ppEnv, rEnvDcp, pContext );
1110     if (! *ppEnv)
1111     {
1112         *ppEnv = initDefaultEnvironment( rEnvDcp, pContext );
1113         if (*ppEnv)
1114         {
1115             // register new environment:
1116             rData.registerEnvironment( ppEnv );
1117         }
1118     }
1119 }
1120
1121 void SAL_CALL uno_getRegisteredEnvironments(
1122     uno_Environment *** pppEnvs, sal_Int32 * pnLen, uno_memAlloc memAlloc,
1123     rtl_uString * pEnvDcp ) noexcept
1124 {
1125     EnvironmentsData & rData = theEnvironmentsData();
1126
1127     ::osl::MutexGuard guard( rData.mutex );
1128     rData.getRegisteredEnvironments(
1129         pppEnvs, pnLen, memAlloc,
1130         (pEnvDcp ? OUString(pEnvDcp) : OUString()) );
1131 }
1132
1133 } // extern "C"
1134
1135 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */