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