cppu/source/uno/lbenv.cxx

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