xref: /aoo41x/main/cppu/source/uno/lbenv.cxx (revision cdf0e10c) 
1 /*************************************************************************
2  *
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * Copyright 2000, 2010 Oracle and/or its affiliates.
6  *
7  * OpenOffice.org - a multi-platform office productivity suite
8  *
9  * This file is part of OpenOffice.org.
10  *
11  * OpenOffice.org is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * OpenOffice.org is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU Lesser General Public License version 3 for more details
19  * (a copy is included in the LICENSE file that accompanied this code).
20  *
21  * You should have received a copy of the GNU Lesser General Public License
22  * version 3 along with OpenOffice.org.  If not, see
23  * <http://www.openoffice.org/license.html>
24  * for a copy of the LGPLv3 License.
25  *
26  ************************************************************************/
27 
28 // MARKER(update_precomp.py): autogen include statement, do not remove
29 #include "precompiled_cppu.hxx"
30 
31 #include "cppu/EnvDcp.hxx"
32 
33 #include "sal/alloca.h"
34 #include "osl/diagnose.h"
35 #include "osl/interlck.h"
36 #include "osl/mutex.hxx"
37 #include "osl/module.h"
38 #include "osl/process.h"
39 #include "rtl/process.h"
40 #include "rtl/unload.h"
41 #include "rtl/string.hxx"
42 #include "rtl/ustring.hxx"
43 #include "rtl/ustrbuf.hxx"
44 #include "rtl/instance.hxx"
45 #include "typelib/typedescription.h"
46 #include "uno/dispatcher.h"
47 #include "uno/environment.h"
48 #include "uno/lbnames.h"
49 #include "prim.hxx"
50 #include "destr.hxx"
51 #include "loadmodule.hxx"
52 
53 #include <hash_map>
54 #include <vector>
55 #include <stdio.h>
56 
57 
58 using ::rtl::OUString;
59 
60 namespace
61 {
62 
63 //------------------------------------------------------------------------------
64 inline static bool td_equals( typelib_InterfaceTypeDescription * pTD1,
65                               typelib_InterfaceTypeDescription * pTD2 )
66 {
67     return (pTD1 == pTD2 ||
68             (((typelib_TypeDescription *)pTD1)->pTypeName->length ==
69              ((typelib_TypeDescription *)pTD2)->pTypeName->length &&
70              ::rtl_ustr_compare(
71                  ((typelib_TypeDescription *) pTD1)->pTypeName->buffer,
72                  ((typelib_TypeDescription *) pTD2)->pTypeName->buffer ) == 0));
73 }
74 
75 struct ObjectEntry;
76 struct uno_DefaultEnvironment;
77 
78 //------------------------------------------------------------------------------
79 struct InterfaceEntry
80 {
81     sal_Int32 refCount;
82     void * pInterface;
83     uno_freeProxyFunc fpFreeProxy;
84     typelib_InterfaceTypeDescription * pTypeDescr;
85 };
86 
87 struct ObjectEntry
88 {
89     OUString oid;
90     sal_Int32 nRef;
91     ::std::vector< InterfaceEntry > aInterfaces;
92     bool mixedObject;
93 
94     inline ObjectEntry( const OUString & rOId_ );
95 
96     inline void append(
97         uno_DefaultEnvironment * pEnv,
98         void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr,
99         uno_freeProxyFunc fpFreeProxy );
100     inline InterfaceEntry * find(
101         typelib_InterfaceTypeDescription * pTypeDescr );
102     inline sal_Int32 find( void * iface_ptr, ::std::size_t pos );
103 };
104 
105 //------------------------------------------------------------------------------
106 struct FctPtrHash :
107     public ::std::unary_function< const void *, ::std::size_t >
108 {
109     ::std::size_t operator () ( const void * pKey ) const
110         { return (::std::size_t) pKey; }
111 };
112 
113 //------------------------------------------------------------------------------
114 struct FctOUStringHash :
115     public ::std::unary_function< const OUString &, ::std::size_t >
116 {
117     ::std::size_t operator () ( const OUString & rKey ) const
118         { return rKey.hashCode(); }
119 };
120 
121 // mapping from environment name to environment
122 typedef ::std::hash_map<
123     OUString, uno_Environment *, FctOUStringHash,
124     ::std::equal_to< OUString > > OUString2EnvironmentMap;
125 
126 // mapping from ptr to object entry
127 typedef ::std::hash_map<
128     void *, ObjectEntry *, FctPtrHash,
129     ::std::equal_to< void * > > Ptr2ObjectMap;
130 // mapping from oid to object entry
131 typedef ::std::hash_map<
132     OUString, ObjectEntry *, FctOUStringHash,
133     ::std::equal_to< OUString > > OId2ObjectMap;
134 
135 
136 //==============================================================================
137 struct EnvironmentsData
138 {
139     ::osl::Mutex mutex;
140     OUString2EnvironmentMap aName2EnvMap;
141 
142     EnvironmentsData() : isDisposing(false) {}
143     ~EnvironmentsData();
144 
145     inline void getEnvironment(
146         uno_Environment ** ppEnv, const OUString & rEnvDcp, void * pContext );
147     inline void registerEnvironment( uno_Environment ** ppEnv );
148     inline void getRegisteredEnvironments(
149         uno_Environment *** pppEnvs, sal_Int32 * pnLen,
150         uno_memAlloc memAlloc, const OUString & rEnvDcp );
151 
152     bool isDisposing;
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     EnvironmentsData & rData = theEnvironmentsData::get();
602 
603     if (rData.isDisposing)
604         return;
605 
606     uno_DefaultEnvironment * that = (uno_DefaultEnvironment *)pEnv;
607     {
608     ::osl::MutexGuard guard( rData.mutex );
609     if (1 == ::osl_incrementInterlockedCount( &that->nRef )) // is dead
610     {
611         that->nRef = 0;
612         return;
613     }
614     }
615     ::osl_incrementInterlockedCount( &that->nWeakRef );
616     *ppHardEnv = pEnv;
617 }
618 
619 //------------------------------------------------------------------------------
620 static void SAL_CALL defenv_dispose( uno_Environment * )
621 {
622 }
623 }
624 
625 //______________________________________________________________________________
626 uno_DefaultEnvironment::uno_DefaultEnvironment(
627     const OUString & rEnvDcp_, void * pContext_ )
628     : nRef( 0 ),
629       nWeakRef( 0 )
630 {
631     uno_Environment * that = reinterpret_cast< uno_Environment * >(this);
632     that->pReserved = 0;
633     // functions
634     that->acquire = defenv_acquire;
635     that->release = defenv_release;
636     that->acquireWeak = defenv_acquireWeak;
637     that->releaseWeak = defenv_releaseWeak;
638     that->harden = defenv_harden;
639     that->dispose = defenv_dispose;
640     that->pExtEnv = this;
641     // identifier
642     ::rtl_uString_acquire( rEnvDcp_.pData );
643     that->pTypeName = rEnvDcp_.pData;
644     that->pContext = pContext_;
645 
646     // will be late initialized
647     that->environmentDisposing = 0;
648 
649     uno_ExtEnvironment::registerInterface = defenv_registerInterface;
650     uno_ExtEnvironment::registerProxyInterface = defenv_registerProxyInterface;
651     uno_ExtEnvironment::revokeInterface = defenv_revokeInterface;
652     uno_ExtEnvironment::getObjectIdentifier = defenv_getObjectIdentifier;
653     uno_ExtEnvironment::getRegisteredInterface = defenv_getRegisteredInterface;
654     uno_ExtEnvironment::getRegisteredInterfaces =
655         defenv_getRegisteredInterfaces;
656 
657 }
658 
659 //______________________________________________________________________________
660 uno_DefaultEnvironment::~uno_DefaultEnvironment()
661 {
662     ::rtl_uString_release( ((uno_Environment *) this)->pTypeName );
663 }
664 
665 //==============================================================================
666 static void writeLine(
667     void * stream, const sal_Char * pLine, const sal_Char * pFilter )
668 {
669     if (pFilter && *pFilter)
670     {
671         // lookup pFilter in pLine
672         while (*pLine)
673         {
674             if (*pLine == *pFilter)
675             {
676                 sal_Int32 nPos = 1;
677                 while (pLine[nPos] && pFilter[nPos] == pLine[nPos])
678                 {
679                     ++nPos;
680                 }
681                 if (! pFilter[nPos])
682                 {
683                     if (stream)
684                     {
685                         fprintf( (FILE *) stream, "%s\n", pLine );
686                     }
687                     else
688                     {
689                         OSL_TRACE( pLine );
690                         OSL_TRACE( "\n" );
691                     }
692                 }
693             }
694             ++pLine;
695         }
696     }
697     else
698     {
699         if (stream)
700         {
701             fprintf( (FILE *) stream, "%s\n", pLine );
702         }
703         else
704         {
705             fprintf( stderr, "%s\n", pLine );
706         }
707     }
708 }
709 
710 //==============================================================================
711 static void writeLine(
712     void * stream, const OUString & rLine, const sal_Char * pFilter )
713 {
714     ::rtl::OString aLine( ::rtl::OUStringToOString(
715                               rLine, RTL_TEXTENCODING_ASCII_US ) );
716     writeLine( stream, aLine.getStr(), pFilter );
717 }
718 
719 //##############################################################################
720 extern "C" void SAL_CALL uno_dumpEnvironment(
721     void * stream, uno_Environment * pEnv, const sal_Char * pFilter )
722     SAL_THROW_EXTERN_C()
723 {
724     OSL_ENSURE( pEnv, "### null ptr!" );
725     ::rtl::OUStringBuffer buf;
726 
727     if (! pEnv->pExtEnv)
728     {
729         writeLine( stream, "###################################"
730                    "###########################################", pFilter );
731         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("environment: ") );
732         buf.append( pEnv->pTypeName );
733         writeLine( stream, buf.makeStringAndClear(), pFilter );
734         writeLine( stream, "NO INTERFACE INFORMATION AVAILABLE!", pFilter );
735         return;
736     }
737 
738     writeLine( stream, "########################################"
739                "######################################", pFilter );
740     buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("environment dump: ") );
741     buf.append( pEnv->pTypeName );
742     writeLine( stream, buf.makeStringAndClear(), pFilter );
743 
744     uno_DefaultEnvironment * that =
745         reinterpret_cast< uno_DefaultEnvironment * >(pEnv);
746     ::osl::MutexGuard guard( that->mutex );
747 
748     Ptr2ObjectMap ptr2obj( that->aPtr2ObjectMap );
749     OId2ObjectMap::const_iterator iPos( that->aOId2ObjectMap.begin() );
750     while (iPos != that->aOId2ObjectMap.end())
751     {
752         ObjectEntry * pOEntry = iPos->second;
753 
754         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("+ ") );
755         if (pOEntry->mixedObject)
756             buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("mixed ") );
757         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("object entry: nRef=") );
758         buf.append( pOEntry->nRef, 10 );
759         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("; oid=\"") );
760         buf.append( pOEntry->oid );
761         buf.append( (sal_Unicode) '\"' );
762         writeLine( stream, buf.makeStringAndClear(), pFilter );
763 
764         for ( ::std::size_t nPos = 0;
765               nPos < pOEntry->aInterfaces.size(); ++nPos )
766         {
767             const InterfaceEntry & rIEntry = pOEntry->aInterfaces[nPos];
768 
769             buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("  - ") );
770             buf.append(
771                 ((typelib_TypeDescription *) rIEntry.pTypeDescr)->pTypeName );
772             if (rIEntry.fpFreeProxy)
773             {
774                 buf.appendAscii(
775                     RTL_CONSTASCII_STRINGPARAM("; proxy free=0x") );
776                 buf.append(
777                     reinterpret_cast< sal_IntPtr >(rIEntry.fpFreeProxy), 16 );
778             }
779             else
780             {
781                 buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("; original") );
782             }
783             buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("; ptr=0x") );
784             buf.append(
785                 reinterpret_cast< sal_IntPtr >(rIEntry.pInterface), 16 );
786 
787             if (pOEntry->find( rIEntry.pInterface, nPos + 1 ) < 0)
788             {
789                 ::std::size_t erased = ptr2obj.erase( rIEntry.pInterface );
790                 if (erased != 1)
791                 {
792                     buf.appendAscii( RTL_CONSTASCII_STRINGPARAM(
793                                          " (ptr not found in map!)") );
794                 }
795             }
796             writeLine( stream, buf.makeStringAndClear(), pFilter );
797         }
798         ++iPos;
799     }
800     if (! ptr2obj.empty())
801         writeLine( stream, "ptr map inconsistency!!!", pFilter );
802     writeLine( stream, "#####################################"
803                "#########################################", pFilter );
804 }
805 
806 //##############################################################################
807 extern "C" void SAL_CALL uno_dumpEnvironmentByName(
808     void * stream, rtl_uString * pEnvDcp, const sal_Char * pFilter )
809     SAL_THROW_EXTERN_C()
810 {
811     uno_Environment * pEnv = 0;
812     uno_getEnvironment( &pEnv, pEnvDcp, 0 );
813     if (pEnv)
814     {
815         ::uno_dumpEnvironment( stream, pEnv, pFilter );
816         (*pEnv->release)( pEnv );
817     }
818     else
819     {
820         ::rtl::OUStringBuffer buf( 32 );
821         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("environment \"") );
822         buf.append( pEnvDcp );
823         buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("\" does not exist!") );
824         writeLine( stream, buf.makeStringAndClear(), pFilter );
825     }
826 }
827 
828 //------------------------------------------------------------------------------
829 inline static const OUString & unoenv_getStaticOIdPart()
830 {
831     static OUString * s_pStaticOidPart = 0;
832     if (! s_pStaticOidPart)
833     {
834         ::osl::MutexGuard guard( ::osl::Mutex::getGlobalMutex() );
835         if (! s_pStaticOidPart)
836         {
837             ::rtl::OUStringBuffer aRet( 64 );
838             aRet.appendAscii( RTL_CONSTASCII_STRINGPARAM("];") );
839             // pid
840             oslProcessInfo info;
841             info.Size = sizeof(oslProcessInfo);
842             if (::osl_getProcessInfo( 0, osl_Process_IDENTIFIER, &info ) ==
843                 osl_Process_E_None)
844             {
845                 aRet.append( (sal_Int64)info.Ident, 16 );
846             }
847             else
848             {
849                 aRet.appendAscii(
850                     RTL_CONSTASCII_STRINGPARAM("unknown process id") );
851             }
852             // good guid
853             sal_uInt8 ar[16];
854             ::rtl_getGlobalProcessId( ar );
855             aRet.append( (sal_Unicode)';' );
856             for ( sal_Int32 i = 0; i < 16; ++i )
857                 aRet.append( (sal_Int32)ar[i], 16 );
858 
859             static OUString s_aStaticOidPart( aRet.makeStringAndClear() );
860             s_pStaticOidPart = &s_aStaticOidPart;
861         }
862     }
863     return *s_pStaticOidPart;
864 }
865 
866 extern "C"
867 {
868 
869 //------------------------------------------------------------------------------
870 static void SAL_CALL unoenv_computeObjectIdentifier(
871     uno_ExtEnvironment * pEnv, rtl_uString ** ppOId, void * pInterface )
872 {
873     OSL_ENSURE( pEnv && ppOId && pInterface, "### null ptr!" );
874     if (*ppOId)
875     {
876         ::rtl_uString_release( *ppOId );
877         *ppOId = 0;
878     }
879 
880     uno_Interface * pUnoI = (uno_Interface *)
881         ::cppu::binuno_queryInterface(
882             pInterface, *typelib_static_type_getByTypeClass(
883                 typelib_TypeClass_INTERFACE ) );
884     if (0 != pUnoI)
885     {
886         (*pUnoI->release)( pUnoI );
887         // interface
888         ::rtl::OUStringBuffer oid( 64 );
889         oid.append( reinterpret_cast< sal_Int64 >(pUnoI), 16 );
890         oid.append( static_cast< sal_Unicode >(';') );
891         // environment[context]
892         oid.append( ((uno_Environment *) pEnv)->pTypeName );
893         oid.append( static_cast< sal_Unicode >('[') );
894         oid.append( reinterpret_cast< sal_Int64 >(
895                         reinterpret_cast<
896                         uno_Environment * >(pEnv)->pContext ), 16 );
897         // process;good guid
898         oid.append( unoenv_getStaticOIdPart() );
899         OUString aStr( oid.makeStringAndClear() );
900         ::rtl_uString_acquire( *ppOId = aStr.pData );
901     }
902 }
903 
904 //==============================================================================
905 static void SAL_CALL unoenv_acquireInterface(
906     uno_ExtEnvironment *, void * pUnoI_ )
907 {
908     uno_Interface * pUnoI = reinterpret_cast< uno_Interface * >(pUnoI_);
909     (*pUnoI->acquire)( pUnoI );
910 }
911 
912 //==============================================================================
913 static void SAL_CALL unoenv_releaseInterface(
914     uno_ExtEnvironment *, void * pUnoI_ )
915 {
916     uno_Interface * pUnoI = reinterpret_cast< uno_Interface * >(pUnoI_);
917     (*pUnoI->release)( pUnoI );
918 }
919 }
920 
921 //______________________________________________________________________________
922 EnvironmentsData::~EnvironmentsData()
923 {
924     ::osl::MutexGuard guard( mutex );
925     isDisposing = true;
926 
927     for ( OUString2EnvironmentMap::const_iterator iPos( aName2EnvMap.begin() );
928           iPos != aName2EnvMap.end(); ++iPos )
929     {
930         uno_Environment * pWeak = iPos->second;
931         uno_Environment * pHard = 0;
932         (*pWeak->harden)( &pHard, pWeak );
933         (*pWeak->releaseWeak)( pWeak );
934 
935         if (pHard)
936         {
937 #if OSL_DEBUG_LEVEL > 1
938             ::uno_dumpEnvironment( 0, pHard, 0 );
939 #endif
940             (*pHard->dispose)( pHard ); // send explicit dispose
941             (*pHard->release)( pHard );
942         }
943     }
944 }
945 
946 //______________________________________________________________________________
947 inline void EnvironmentsData::getEnvironment(
948     uno_Environment ** ppEnv, const OUString & rEnvDcp, void * pContext )
949 {
950     if (*ppEnv)
951     {
952         (*(*ppEnv)->release)( *ppEnv );
953         *ppEnv = 0;
954     }
955 
956     OUString aKey(
957         OUString::valueOf( reinterpret_cast< sal_IntPtr >(pContext) ) );
958     aKey += rEnvDcp;
959 
960     // try to find registered mapping
961     OUString2EnvironmentMap::const_iterator const iFind(
962         aName2EnvMap.find( aKey ) );
963     if (iFind != aName2EnvMap.end())
964     {
965         uno_Environment * pWeak = iFind->second;
966         (*pWeak->harden)( ppEnv, pWeak );
967     }
968 }
969 
970 //______________________________________________________________________________
971 inline void EnvironmentsData::registerEnvironment( uno_Environment ** ppEnv )
972 {
973     OSL_ENSURE( ppEnv, "### null ptr!" );
974     uno_Environment * pEnv =  *ppEnv;
975 
976     OUString aKey(
977         OUString::valueOf( reinterpret_cast< sal_IntPtr >(pEnv->pContext) ) );
978     aKey += pEnv->pTypeName;
979 
980     // try to find registered environment
981     OUString2EnvironmentMap::const_iterator const iFind(
982         aName2EnvMap.find( aKey ) );
983     if (iFind == aName2EnvMap.end())
984     {
985         (*pEnv->acquireWeak)( pEnv );
986         ::std::pair< OUString2EnvironmentMap::iterator, bool > insertion(
987             aName2EnvMap.insert(
988                 OUString2EnvironmentMap::value_type( aKey, pEnv ) ) );
989         OSL_ENSURE(
990             insertion.second, "### insertion of env into map failed?!" );
991     }
992     else
993     {
994         uno_Environment * pHard = 0;
995         uno_Environment * pWeak = iFind->second;
996         (*pWeak->harden)( &pHard, pWeak );
997         if (pHard)
998         {
999             if (pEnv)
1000                 (*pEnv->release)( pEnv );
1001             *ppEnv = pHard;
1002         }
1003         else // registered one is dead
1004         {
1005             (*pWeak->releaseWeak)( pWeak );
1006             (*pEnv->acquireWeak)( pEnv );
1007             aName2EnvMap[ aKey ] = pEnv;
1008         }
1009     }
1010 }
1011 
1012 //______________________________________________________________________________
1013 inline void EnvironmentsData::getRegisteredEnvironments(
1014     uno_Environment *** pppEnvs, sal_Int32 * pnLen, uno_memAlloc memAlloc,
1015     const OUString & rEnvDcp )
1016 {
1017     OSL_ENSURE( pppEnvs && pnLen && memAlloc, "### null ptr!" );
1018 
1019     // max size
1020     uno_Environment ** ppFound = (uno_Environment **)alloca(
1021         sizeof(uno_Environment *) * aName2EnvMap.size() );
1022     sal_Int32 nSize = 0;
1023 
1024     // find matching environment
1025     for ( OUString2EnvironmentMap::const_iterator iPos( aName2EnvMap.begin() );
1026           iPos != aName2EnvMap.end(); ++iPos )
1027     {
1028         uno_Environment * pWeak = iPos->second;
1029         if (!rEnvDcp.getLength() ||
1030             rEnvDcp.equals( pWeak->pTypeName ))
1031         {
1032             ppFound[nSize] = 0;
1033             (*pWeak->harden)( &ppFound[nSize], pWeak );
1034             if (ppFound[nSize])
1035                 ++nSize;
1036         }
1037     }
1038 
1039     *pnLen = nSize;
1040     if (nSize)
1041     {
1042         *pppEnvs = (uno_Environment **) (*memAlloc)(
1043             sizeof (uno_Environment *) * nSize );
1044         OSL_ASSERT( *pppEnvs );
1045         while (nSize--)
1046         {
1047             (*pppEnvs)[nSize] = ppFound[nSize];
1048         }
1049     }
1050     else
1051     {
1052         *pppEnvs = 0;
1053     }
1054 }
1055 
1056 static bool loadEnv(OUString const  & cLibStem,
1057 					uno_Environment * pEnv,
1058 					void            * /*pContext*/)
1059 {
1060 	// late init with some code from matching uno language binding
1061 	// will be unloaded by environment
1062 	oslModule hMod = cppu::detail::loadModule( cLibStem );
1063 
1064 	if (!hMod)
1065 		return false;
1066 
1067 	OUString aSymbolName(RTL_CONSTASCII_USTRINGPARAM(UNO_INIT_ENVIRONMENT));
1068 	uno_initEnvironmentFunc fpInit = (uno_initEnvironmentFunc)
1069 		::osl_getFunctionSymbol( hMod, aSymbolName.pData );
1070 	if (!fpInit)
1071 	{
1072 		::osl_unloadModule( hMod );
1073 		return false;
1074 	}
1075 
1076 	(*fpInit)( pEnv ); // init of environment
1077 	::rtl_registerModuleForUnloading( hMod );
1078 
1079 	return true;
1080 }
1081 
1082 
1083 extern "C"
1084 {
1085 
1086 //------------------------------------------------------------------------------
1087 static uno_Environment * initDefaultEnvironment(
1088     const OUString & rEnvDcp, void * pContext )
1089 {
1090     uno_Environment * pEnv = &(new uno_DefaultEnvironment( rEnvDcp, pContext ))->aBase;
1091 	(*pEnv->acquire)( pEnv );
1092 
1093 	OUString envTypeName = cppu::EnvDcp::getTypeName(rEnvDcp);
1094 
1095     // create default environment
1096     if (envTypeName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_LB_UNO) ))
1097     {
1098         uno_DefaultEnvironment * that = (uno_DefaultEnvironment *)pEnv;
1099 		that->computeObjectIdentifier = unoenv_computeObjectIdentifier;
1100 		that->acquireInterface = unoenv_acquireInterface;
1101 		that->releaseInterface = unoenv_releaseInterface;
1102 
1103 		OUString envPurpose = cppu::EnvDcp::getPurpose(rEnvDcp);
1104 		if (envPurpose.getLength())
1105 		{
1106 			rtl::OUString libStem = envPurpose.copy(envPurpose.lastIndexOf(':') + 1);
1107 			libStem += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("_uno_uno") );
1108 
1109 			if(!loadEnv(libStem, pEnv, pContext))
1110 			{
1111 				pEnv->release(pEnv);
1112 				return NULL;
1113 			}
1114 		}
1115     }
1116     else
1117     {
1118         // late init with some code from matching uno language binding
1119         ::rtl::OUStringBuffer aLibName( 16 );
1120         aLibName.append( envTypeName );
1121         aLibName.appendAscii( RTL_CONSTASCII_STRINGPARAM("_uno" ) );
1122         OUString aStr( aLibName.makeStringAndClear() );
1123 
1124 		if (!loadEnv(aStr, pEnv, pContext))
1125 		{
1126 			pEnv->release(pEnv);
1127 			return NULL;
1128 		}
1129     }
1130 
1131     return pEnv;
1132 }
1133 
1134 //##############################################################################
1135 void SAL_CALL uno_createEnvironment(
1136     uno_Environment ** ppEnv, rtl_uString * pEnvDcp, void * pContext )
1137     SAL_THROW_EXTERN_C()
1138 {
1139     OSL_ENSURE( ppEnv, "### null ptr!" );
1140     if (*ppEnv)
1141         (*(*ppEnv)->release)( *ppEnv );
1142 
1143     OUString const & rEnvDcp = OUString::unacquired( &pEnvDcp );
1144     *ppEnv = initDefaultEnvironment( rEnvDcp, pContext );
1145 }
1146 
1147 //##############################################################################
1148 void SAL_CALL uno_direct_getEnvironment(
1149     uno_Environment ** ppEnv, rtl_uString * pEnvDcp, void * pContext )
1150     SAL_THROW_EXTERN_C()
1151 {
1152     OSL_ENSURE( ppEnv, "### null ptr!" );
1153     OUString const & rEnvDcp = OUString::unacquired( &pEnvDcp );
1154 
1155     EnvironmentsData & rData = theEnvironmentsData::get();
1156 
1157     ::osl::MutexGuard guard( rData.mutex );
1158     rData.getEnvironment( ppEnv, rEnvDcp, pContext );
1159     if (! *ppEnv)
1160     {
1161         *ppEnv = initDefaultEnvironment( rEnvDcp, pContext );
1162         if (*ppEnv)
1163         {
1164             // register new environment:
1165             rData.registerEnvironment( ppEnv );
1166         }
1167     }
1168 }
1169 
1170 //##############################################################################
1171 void SAL_CALL uno_getRegisteredEnvironments(
1172     uno_Environment *** pppEnvs, sal_Int32 * pnLen, uno_memAlloc memAlloc,
1173     rtl_uString * pEnvDcp )
1174     SAL_THROW_EXTERN_C()
1175 {
1176     EnvironmentsData & rData = theEnvironmentsData::get();
1177 
1178     ::osl::MutexGuard guard( rData.mutex );
1179     rData.getRegisteredEnvironments(
1180         pppEnvs, pnLen, memAlloc,
1181         (pEnvDcp ? OUString(pEnvDcp) : OUString()) );
1182 }
1183 
1184 } // extern "C"
1185 
1186 }
1187 
1188