cppu/source/uno/lbmap.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
  21 #include "IdentityMapping.hxx"
  22
  23 #include <boost/unordered_map.hpp>
  24 #include <set>
  25 #include <algorithm>
  26
  27 #include "rtl/unload.h"
  28 #include "rtl/ustring.hxx"
  29 #include "rtl/ustrbuf.hxx"
  30 #include "osl/module.h"
  31 #include "osl/diagnose.h"
  32 #include "osl/mutex.hxx"
  33 #include "osl/interlck.h"
  34
  35 #include "uno/dispatcher.h"
  36 #include "uno/mapping.h"
  37 #include "uno/lbnames.h"
  38 #include "uno/environment.hxx"
  39
  40 #include "typelib/typedescription.h"
  41
  42 #include "cppu/EnvDcp.hxx"
  43 #include "cascade_mapping.hxx"
  44 #include "IdentityMapping.hxx"
  45 #include "loadmodule.hxx"
  46
  47 using namespace std;
  48 using namespace osl;
  49 using namespace com::sun::star::uno;
  50 using ::rtl::OUString;
  51 using ::rtl::OUStringBuffer;
  52 using ::rtl::OUStringToOString;
  53 using ::rtl::OString;
  54
  55 namespace cppu
  56 {
  57
  58 class Mapping
  59 {
  60     uno_Mapping * _pMapping;
  61
  62 public:
  63     inline explicit Mapping( uno_Mapping * pMapping = 0 ) SAL_THROW(());
  64     inline Mapping( const Mapping & rMapping ) SAL_THROW(());
  65     inline ~Mapping() SAL_THROW(());
  66     inline Mapping & SAL_CALL operator = ( uno_Mapping * pMapping ) SAL_THROW(());
  67     inline Mapping & SAL_CALL operator = ( const Mapping & rMapping ) SAL_THROW(())
  68         { return operator = ( rMapping._pMapping ); }
  69     inline uno_Mapping * SAL_CALL get() const SAL_THROW(())
  70         { return _pMapping; }
  71     inline sal_Bool SAL_CALL is() const SAL_THROW(())
  72         { return (_pMapping != 0); }
  73 };
  74 //__________________________________________________________________________________________________
  75 inline Mapping::Mapping( uno_Mapping * pMapping ) SAL_THROW(())
  76     : _pMapping( pMapping )
  77 {
  78     if (_pMapping)
  79         (*_pMapping->acquire)( _pMapping );
  80 }
  81 //__________________________________________________________________________________________________
  82 inline Mapping::Mapping( const Mapping & rMapping ) SAL_THROW(())
  83     : _pMapping( rMapping._pMapping )
  84 {
  85     if (_pMapping)
  86         (*_pMapping->acquire)( _pMapping );
  87 }
  88 //__________________________________________________________________________________________________
  89 inline Mapping::~Mapping() SAL_THROW(())
  90 {
  91     if (_pMapping)
  92         (*_pMapping->release)( _pMapping );
  93 }
  94 //__________________________________________________________________________________________________
  95 inline Mapping & Mapping::operator = ( uno_Mapping * pMapping ) SAL_THROW(())
  96 {
  97     if (pMapping)
  98         (*pMapping->acquire)( pMapping );
  99     if (_pMapping)
 100         (*_pMapping->release)( _pMapping );
 101     _pMapping = pMapping;
 102     return *this;
 103 }
 104
 105 //==================================================================================================
 106 struct MappingEntry
 107 {
 108     sal_Int32           nRef;
 109     uno_Mapping *       pMapping;
 110     uno_freeMappingFunc freeMapping;
 111     OUString            aMappingName;
 112
 113     MappingEntry(
 114         uno_Mapping * pMapping_, uno_freeMappingFunc freeMapping_,
 115         const OUString & rMappingName_ )
 116         SAL_THROW(())
 117         : nRef( 1 )
 118         , pMapping( pMapping_ )
 119         , freeMapping( freeMapping_ )
 120         , aMappingName( rMappingName_ )
 121         {}
 122 };
 123 //--------------------------------------------------------------------------------------------------
 124 struct FctOUStringHash : public std::unary_function< const OUString &, size_t >
 125 {
 126     size_t operator()( const OUString & rKey ) const SAL_THROW(())
 127         { return (size_t)rKey.hashCode(); }
 128 };
 129 //--------------------------------------------------------------------------------------------------
 130 struct FctPtrHash : public std::unary_function< uno_Mapping *, size_t >
 131 {
 132     size_t operator()( uno_Mapping * pKey ) const SAL_THROW(())
 133         { return (size_t)pKey; }
 134 };
 135
 136 typedef boost::unordered_map<
 137     OUString, MappingEntry *, FctOUStringHash, equal_to< OUString > > t_OUString2Entry;
 138 typedef boost::unordered_map<
 139     uno_Mapping *, MappingEntry *, FctPtrHash, equal_to< uno_Mapping * > > t_Mapping2Entry;
 140
 141 typedef set< uno_getMappingFunc > t_CallbackSet;
 142 typedef set< OUString > t_OUStringSet;
 143
 144 //==================================================================================================
 145 struct MappingsData
 146 {
 147     Mutex               aMappingsMutex;
 148     t_OUString2Entry    aName2Entry;
 149     t_Mapping2Entry     aMapping2Entry;
 150
 151     Mutex               aCallbacksMutex;
 152     t_CallbackSet       aCallbacks;
 153
 154     Mutex               aNegativeLibsMutex;
 155     t_OUStringSet       aNegativeLibs;
 156 };
 157 //--------------------------------------------------------------------------------------------------
 158 static MappingsData & getMappingsData() SAL_THROW(())
 159 {
 160     static MappingsData * s_p = 0;
 161     if (! s_p)
 162     {
 163         MutexGuard aGuard( Mutex::getGlobalMutex() );
 164         if (! s_p)
 165         {
 166             //TODO  This memory is leaked; see #i63473# for when this should be
 167             // changed again:
 168             s_p = new MappingsData;
 169         }
 170     }
 171     return *s_p;
 172 }
 173
 174 /**
 175  * This class mediates two different mapping via uno, e.g. form any language to uno,
 176  * then from uno to any other language.
 177  */
 178 struct uno_Mediate_Mapping : public uno_Mapping
 179 {
 180     sal_Int32   nRef;
 181
 182     Environment aFrom;
 183     Environment aTo;
 184
 185     Mapping     aFrom2Uno;
 186     Mapping     aUno2To;
 187
 188     OUString    aAddPurpose;
 189
 190     uno_Mediate_Mapping(
 191         const Environment & rFrom_, const Environment & rTo_,
 192         const Mapping & rFrom2Uno_, const Mapping & rUno2To_,
 193         const OUString & rAddPurpose )
 194         SAL_THROW(());
 195 };
 196 extern "C"
 197 {
 198 //--------------------------------------------------------------------------------------------------
 199 static void SAL_CALL mediate_free( uno_Mapping * pMapping )
 200     SAL_THROW(())
 201 {
 202     delete static_cast< uno_Mediate_Mapping * >( pMapping );
 203 }
 204 //--------------------------------------------------------------------------------------------------
 205 static void SAL_CALL mediate_acquire( uno_Mapping * pMapping )
 206     SAL_THROW(())
 207 {
 208     if (1 == ::osl_atomic_increment(
 209         & static_cast< uno_Mediate_Mapping * >( pMapping )->nRef ))
 210     {
 211         uno_registerMapping(
 212             &pMapping, mediate_free,
 213             static_cast< uno_Mediate_Mapping * >( pMapping )->aFrom.get(),
 214             static_cast< uno_Mediate_Mapping * >( pMapping )->aTo.get(),
 215             static_cast< uno_Mediate_Mapping * >( pMapping )->aAddPurpose.pData );
 216     }
 217 }
 218 //--------------------------------------------------------------------------------------------------
 219 static void SAL_CALL mediate_release( uno_Mapping * pMapping )
 220     SAL_THROW(())
 221 {
 222     if (! ::osl_atomic_decrement(
 223         & static_cast< uno_Mediate_Mapping * >( pMapping )->nRef ))
 224     {
 225         uno_revokeMapping( pMapping );
 226     }
 227 }
 228 //--------------------------------------------------------------------------------------------------
 229 static void SAL_CALL mediate_mapInterface(
 230     uno_Mapping * pMapping,
 231     void ** ppOut, void * pInterface,
 232     typelib_InterfaceTypeDescription * pInterfaceTypeDescr )
 233     SAL_THROW(())
 234 {
 235     OSL_ENSURE( pMapping && ppOut, "### null ptr!" );
 236     if (pMapping && ppOut)
 237     {
 238         uno_Mediate_Mapping * that = static_cast< uno_Mediate_Mapping * >( pMapping );
 239         uno_Mapping * pFrom2Uno = that->aFrom2Uno.get();
 240
 241         uno_Interface * pUnoI = 0;
 242         (*pFrom2Uno->mapInterface)( pFrom2Uno, (void **) &pUnoI, pInterface, pInterfaceTypeDescr );
 243         if (0 == pUnoI)
 244         {
 245             void * pOut = *ppOut;
 246             if (0 != pOut)
 247             {
 248                 uno_ExtEnvironment * pTo = that->aTo.get()->pExtEnv;
 249                 OSL_ENSURE( 0 != pTo, "### cannot release out interface: leaking!" );
 250                 if (0 != pTo)
 251                     (*pTo->releaseInterface)( pTo, pOut );
 252                 *ppOut = 0; // set to 0 anyway, because mapping was not successfull!
 253             }
 254         }
 255         else
 256         {
 257             uno_Mapping * pUno2To = that->aUno2To.get();
 258             (*pUno2To->mapInterface)( pUno2To, ppOut, pUnoI, pInterfaceTypeDescr );
 259             (*pUnoI->release)( pUnoI );
 260         }
 261     }
 262 }
 263 }
 264 //__________________________________________________________________________________________________
 265 uno_Mediate_Mapping::uno_Mediate_Mapping(
 266     const Environment & rFrom_, const Environment & rTo_,
 267     const Mapping & rFrom2Uno_, const Mapping & rUno2To_,
 268     const OUString & rAddPurpose_ )
 269     SAL_THROW(())
 270     : nRef( 1 )
 271     , aFrom( rFrom_ )
 272     , aTo( rTo_ )
 273     , aFrom2Uno( rFrom2Uno_ )
 274     , aUno2To( rUno2To_ )
 275     , aAddPurpose( rAddPurpose_ )
 276 {
 277     uno_Mapping::acquire        = mediate_acquire;
 278     uno_Mapping::release        = mediate_release;
 279     uno_Mapping::mapInterface   = mediate_mapInterface;
 280 }
 281
 282 //==================================================================================================
 283 static inline OUString getMappingName(
 284     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
 285     SAL_THROW(())
 286 {
 287     OUStringBuffer aKey( 64 );
 288     aKey.append( rAddPurpose );
 289     aKey.append( (sal_Unicode)';' );
 290     aKey.append( rFrom.getTypeName() );
 291     aKey.append( (sal_Unicode)'[' );
 292     aKey.append( reinterpret_cast< sal_IntPtr >(rFrom.get()), 16 );
 293     aKey.appendAscii( RTL_CONSTASCII_STRINGPARAM("];") );
 294     aKey.append( rTo.getTypeName() );
 295     aKey.append( (sal_Unicode)'[' );
 296     aKey.append( reinterpret_cast< sal_IntPtr >(rTo.get()), 16 );
 297     aKey.append( (sal_Unicode)']' );
 298     return aKey.makeStringAndClear();
 299 }
 300 //==================================================================================================
 301 static inline OUString getBridgeName(
 302     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
 303     SAL_THROW(())
 304 {
 305     OUStringBuffer aBridgeName( 16 );
 306     if (!rAddPurpose.isEmpty())
 307     {
 308         aBridgeName.append( rAddPurpose );
 309         aBridgeName.append( (sal_Unicode)'_' );
 310     }
 311     aBridgeName.append( EnvDcp::getTypeName(rFrom.getTypeName()) );
 312     aBridgeName.append( (sal_Unicode)'_' );
 313     aBridgeName.append( EnvDcp::getTypeName(rTo.getTypeName()) );
 314     return aBridgeName.makeStringAndClear();
 315 }
 316 //==================================================================================================
 317 static inline void setNegativeBridge( const OUString & rBridgeName )
 318     SAL_THROW(())
 319 {
 320     MappingsData & rData = getMappingsData();
 321     MutexGuard aGuard( rData.aNegativeLibsMutex );
 322     rData.aNegativeLibs.insert( rBridgeName );
 323 }
 324
 325 #ifdef DISABLE_DYNLOADING
 326
 327 static uno_ext_getMappingFunc selectMapFunc( const OUString & rBridgeName )
 328     SAL_THROW(())
 329 {
 330     if (rBridgeName.equalsAscii( CPPU_CURRENT_LANGUAGE_BINDING_NAME "_uno" ))
 331         return CPPU_ENV_uno_ext_getMapping;
 332 #ifdef SOLAR_JAVA
 333     if (rBridgeName.equalsAscii( "java" "_uno" ))
 334         return java_uno_ext_getMapping;
 335 #endif
 336
 337 #if 0
 338     // I don't think the affine or log bridges will be needed on any
 339     // DISABLE_DYNLOADING platform (iOS at least, possibly Android), but if
 340     // somebody wants to experiment, need to find out then whether these are
 341     // needed.
 342     if (rBridgeName.equalsAscii( "affine_uno_uno" ))
 343         return affine_uno_uno_ext_getMapping;
 344     if (rBridgeName.equalsAscii( "log_uno_uno" ))
 345         return log_uno_uno_ext_getMapping;
 346 #endif
 347     return 0;
 348 }
 349
 350 #else
 351
 352 static inline oslModule loadModule( const OUString & rBridgeName )
 353     SAL_THROW(())
 354 {
 355     sal_Bool bNeg;
 356     {
 357     MappingsData & rData = getMappingsData();
 358     MutexGuard aGuard( rData.aNegativeLibsMutex );
 359     const t_OUStringSet::const_iterator iFind( rData.aNegativeLibs.find( rBridgeName ) );
 360     bNeg = (iFind != rData.aNegativeLibs.end());
 361     }
 362
 363     if (! bNeg)
 364     {
 365         oslModule hModule = cppu::detail::loadModule( rBridgeName );
 366
 367         if (hModule)
 368             return hModule;
 369
 370         setNegativeBridge( rBridgeName ); // no load again
 371     }
 372     return 0;
 373 }
 374
 375 #endif
 376
 377 //==================================================================================================
 378 static Mapping loadExternalMapping(
 379     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
 380     SAL_THROW(())
 381 {
 382     OSL_ASSERT( rFrom.is() && rTo.is() );
 383     if (rFrom.is() && rTo.is())
 384     {
 385 #ifdef DISABLE_DYNLOADING
 386         OUString aName;
 387         uno_ext_getMappingFunc fpGetMapFunc = 0;
 388
 389         if (EnvDcp::getTypeName(rFrom.getTypeName()).equalsAsciiL( RTL_CONSTASCII_STRINGPARAM(UNO_LB_UNO) ))
 390         {
 391             aName = getBridgeName( rTo, rFrom, rAddPurpose );
 392             fpGetMapFunc = selectMapFunc( aName );
 393         }
 394         if (! fpGetMapFunc)
 395         {
 396             aName = getBridgeName( rFrom, rTo, rAddPurpose );
 397             fpGetMapFunc = selectMapFunc( aName );
 398         }
 399         if (! fpGetMapFunc)
 400         {
 401             aName = getBridgeName( rTo, rFrom, rAddPurpose );
 402             fpGetMapFunc = selectMapFunc( aName );
 403         }
 404
 405         if (! fpGetMapFunc)
 406         {
 407 #if OSL_DEBUG_LEVEL > 1
 408             OSL_TRACE( "Could not find mapfunc for %s", OUStringToOString( aName, RTL_TEXTENCODING_ASCII_US ).getStr());
 409 #endif
 410             return Mapping();
 411         }
 412
 413         if (fpGetMapFunc)
 414         {
 415             Mapping aExt;
 416             (*fpGetMapFunc)( (uno_Mapping **)&aExt, rFrom.get(), rTo.get() );
 417             OSL_ASSERT( aExt.is() );
 418             if (aExt.is())
 419                 return aExt;
 420         }
 421 #else
 422         // find proper lib
 423         oslModule hModule = 0;
 424         OUString aName;
 425
 426         if ( EnvDcp::getTypeName(rFrom.getTypeName()) == UNO_LB_UNO )
 427             hModule = loadModule( aName = getBridgeName( rTo, rFrom, rAddPurpose ) );
 428         if (! hModule)
 429             hModule = loadModule( aName = getBridgeName( rFrom, rTo, rAddPurpose ) );
 430         if (! hModule)
 431             hModule = loadModule( aName = getBridgeName( rTo, rFrom, rAddPurpose ) );
 432
 433         if (hModule)
 434         {
 435             OUString aSymbolName( RTL_CONSTASCII_USTRINGPARAM(UNO_EXT_GETMAPPING) );
 436             uno_ext_getMappingFunc fpGetMapFunc =
 437                 (uno_ext_getMappingFunc)::osl_getFunctionSymbol(
 438                     hModule, aSymbolName.pData );
 439
 440             if (fpGetMapFunc)
 441             {
 442                 Mapping aExt;
 443                 (*fpGetMapFunc)( (uno_Mapping **)&aExt, rFrom.get(), rTo.get() );
 444                 OSL_ASSERT( aExt.is() );
 445                 if (aExt.is())
 446                 {
 447                     ::rtl_registerModuleForUnloading( hModule );
 448                     return aExt;
 449                 }
 450             }
 451             ::osl_unloadModule( hModule );
 452             setNegativeBridge( aName );
 453         }
 454 #endif
 455     }
 456     return Mapping();
 457 }
 458
 459 //==================================================================================================
 460 static Mapping getDirectMapping(
 461     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose = OUString() )
 462     SAL_THROW(())
 463 {
 464     OSL_ASSERT( rFrom.is() && rTo.is() );
 465     if (rFrom.is() && rTo.is())
 466     {
 467         MappingsData & rData = getMappingsData();
 468         ClearableMutexGuard aGuard( rData.aMappingsMutex );
 469
 470         // try to find registered mapping
 471         const t_OUString2Entry::const_iterator iFind( rData.aName2Entry.find(
 472             getMappingName( rFrom, rTo, rAddPurpose ) ) );
 473
 474         if (iFind == rData.aName2Entry.end())
 475         {
 476             aGuard.clear();
 477             return loadExternalMapping( rFrom, rTo, rAddPurpose );
 478         }
 479         else
 480         {
 481             return Mapping( (*iFind).second->pMapping );
 482         }
 483     }
 484     return Mapping();
 485 }
 486
 487 //--------------------------------------------------------------------------------------------------
 488 static inline Mapping createMediateMapping(
 489     const Environment & rFrom, const Environment & rTo,
 490     const Mapping & rFrom2Uno, const Mapping & rUno2To,
 491     const OUString & rAddPurpose )
 492     SAL_THROW(())
 493 {
 494     uno_Mapping * pRet = new uno_Mediate_Mapping(
 495         rFrom, rTo, rFrom2Uno, rUno2To, rAddPurpose ); // ref count initially 1
 496     uno_registerMapping(
 497         &pRet, mediate_free, rFrom.get(), rTo.get(), rAddPurpose.pData );
 498     Mapping aRet( pRet );
 499     (*pRet->release)( pRet );
 500     return aRet;
 501 }
 502 //==================================================================================================
 503 static Mapping getMediateMapping(
 504     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
 505     SAL_THROW(())
 506 {
 507     Environment aUno;
 508     Mapping aUno2To;
 509
 510     // backwards: from dest to source of mapping chain
 511
 512     // connect to uno
 513     OUString aUnoEnvTypeName( RTL_CONSTASCII_USTRINGPARAM(UNO_LB_UNO) );
 514     if (rTo.getTypeName() == aUnoEnvTypeName) // to is uno
 515     {
 516         aUno = rTo;
 517         // no Uno2To mapping necessary
 518     }
 519     else
 520     {
 521         // get registered uno env
 522         ::uno_getEnvironment( (uno_Environment **)&aUno, aUnoEnvTypeName.pData, 0 );
 523
 524         aUno2To = getDirectMapping( aUno, rTo );
 525         // : uno <-> to
 526         if (! aUno2To.is())
 527             return Mapping();
 528     }
 529
 530     // connect to uno
 531     if (!rAddPurpose.isEmpty()) // insert purpose mapping between new ano_uno <-> uno
 532     {
 533         // create anonymous uno env
 534         Environment aAnUno;
 535         ::uno_createEnvironment( (uno_Environment **)&aAnUno, aUnoEnvTypeName.pData, 0 );
 536
 537         Mapping aAnUno2Uno( getDirectMapping( aAnUno, aUno, rAddPurpose ) );
 538         if (! aAnUno2Uno.is())
 539             return Mapping();
 540
 541         if (aUno2To.is()) // to is not uno
 542         {
 543             // create another purposed mediate mapping
 544             aUno2To = createMediateMapping( aAnUno, rTo, aAnUno2Uno, aUno2To, rAddPurpose );
 545             // : ano_uno <-> uno <-> to
 546         }
 547         else
 548         {
 549             aUno2To = aAnUno2Uno;
 550             // : ano_uno <-> to (i.e., uno)
 551         }
 552         aUno = aAnUno;
 553     }
 554
 555     Mapping aFrom2Uno( getDirectMapping( rFrom, aUno ) );
 556     if (aFrom2Uno.is() && aUno2To.is())
 557     {
 558         return createMediateMapping( rFrom, rTo, aFrom2Uno, aUno2To, rAddPurpose );
 559         // : from <-> some uno ...
 560     }
 561
 562     return Mapping();
 563 }
 564 }
 565
 566 using namespace ::cppu;
 567
 568 extern "C"
 569 {
 570 //##################################################################################################
 571 void SAL_CALL uno_getMapping(
 572     uno_Mapping ** ppMapping, uno_Environment * pFrom, uno_Environment * pTo,
 573     rtl_uString * pAddPurpose )
 574     SAL_THROW_EXTERN_C()
 575 {
 576     OSL_ENSURE( ppMapping && pFrom && pTo, "### null ptr!" );
 577     if (*ppMapping)
 578     {
 579         (*(*ppMapping)->release)( *ppMapping );
 580         *ppMapping = 0;
 581     }
 582
 583     Mapping aRet;
 584     Environment aFrom( pFrom ), aTo( pTo );
 585
 586     OUString aAddPurpose;
 587     if (pAddPurpose)
 588         aAddPurpose = pAddPurpose;
 589
 590     MappingsData & rData = getMappingsData();
 591
 592     // try registered mapping
 593     {
 594     MutexGuard aGuard( rData.aMappingsMutex );
 595     const t_OUString2Entry::const_iterator iFind( rData.aName2Entry.find(
 596         getMappingName( aFrom, aTo, aAddPurpose ) ) );
 597     if (iFind != rData.aName2Entry.end())
 598         aRet = (*iFind).second->pMapping;
 599     }
 600
 601     // See if an identity mapping does fit.
 602     if (!aRet.is() && pFrom == pTo && aAddPurpose.isEmpty())
 603         aRet = createIdentityMapping(pFrom);
 604
 605     if (!aRet.is())
 606     {
 607         getCascadeMapping(ppMapping, pFrom, pTo, pAddPurpose);
 608
 609         if (*ppMapping)
 610             return;
 611     }
 612
 613     if (! aRet.is()) // try callback chain
 614     {
 615         MutexGuard aGuard( rData.aCallbacksMutex );
 616         for ( t_CallbackSet::const_iterator iPos( rData.aCallbacks.begin() );
 617               iPos != rData.aCallbacks.end(); ++iPos )
 618         {
 619             (**iPos)( ppMapping, pFrom, pTo, aAddPurpose.pData );
 620             if (*ppMapping)
 621                 return;
 622         }
 623     }
 624
 625     if (! aRet.is())
 626     {
 627         aRet = loadExternalMapping( aFrom, aTo, aAddPurpose ); // direct try
 628         if (! aRet.is())
 629             aRet = getMediateMapping( aFrom, aTo, aAddPurpose ); // try via uno
 630     }
 631
 632     if (aRet.is())
 633     {
 634         (*aRet.get()->acquire)( aRet.get() );
 635         *ppMapping = aRet.get();
 636     }
 637 }
 638 //##################################################################################################
 639 void SAL_CALL uno_getMappingByName(
 640     uno_Mapping ** ppMapping, rtl_uString * pFrom, rtl_uString * pTo,
 641     rtl_uString * pAddPurpose )
 642     SAL_THROW_EXTERN_C()
 643 {
 644     OSL_ENSURE( ppMapping && pFrom && pTo, "### null ptr!" );
 645     if (*ppMapping)
 646     {
 647         (*(*ppMapping)->release)( *ppMapping );
 648         *ppMapping = 0;
 649     }
 650
 651     uno_Environment * pEFrom = 0;
 652     uno_getEnvironment( &pEFrom, pFrom, 0 );
 653     OSL_ENSURE( pEFrom, "### cannot get source environment!" );
 654     if (pEFrom)
 655     {
 656         uno_Environment * pETo = 0;
 657         uno_getEnvironment( &pETo, pTo, 0 );
 658         OSL_ENSURE( pETo, "### cannot get target environment!" );
 659         if (pETo)
 660         {
 661             ::uno_getMapping( ppMapping, pEFrom, pETo, pAddPurpose );
 662             (*pETo->release)( pETo );
 663         }
 664         (*pEFrom->release)( pEFrom );
 665     }
 666 }
 667
 668 //##################################################################################################
 669 CPPU_DLLPUBLIC void SAL_CALL uno_registerMapping(
 670     uno_Mapping ** ppMapping, uno_freeMappingFunc freeMapping,
 671     uno_Environment * pFrom, uno_Environment * pTo, rtl_uString * pAddPurpose )
 672     SAL_THROW_EXTERN_C()
 673 {
 674     MappingsData & rData = getMappingsData();
 675     ClearableMutexGuard aGuard( rData.aMappingsMutex );
 676
 677     const t_Mapping2Entry::const_iterator iFind( rData.aMapping2Entry.find( *ppMapping ) );
 678     if (iFind == rData.aMapping2Entry.end())
 679     {
 680         OUString aMappingName(
 681             getMappingName( pFrom, pTo, pAddPurpose ? OUString(pAddPurpose) : OUString() ) );
 682 #if OSL_DEBUG_LEVEL > 2
 683         OString cstr( OUStringToOString( aMappingName, RTL_TEXTENCODING_ASCII_US ) );
 684         OSL_TRACE( "> inserting new mapping: %s", cstr.getStr() );
 685 #endif
 686         // count initially 1
 687         MappingEntry * pEntry = new MappingEntry( *ppMapping, freeMapping, aMappingName );
 688         rData.aName2Entry[ aMappingName ] = pEntry;
 689         rData.aMapping2Entry[ *ppMapping ] = pEntry;
 690     }
 691     else
 692     {
 693         MappingEntry * pEntry = (*iFind).second;
 694         ++pEntry->nRef;
 695
 696         if (pEntry->pMapping != *ppMapping) // exchange mapping to be registered
 697         {
 698             (*pEntry->pMapping->acquire)( pEntry->pMapping );
 699             --pEntry->nRef; // correct count; kill mapping to be registered
 700             aGuard.clear();
 701             (*freeMapping)( *ppMapping );
 702             *ppMapping = pEntry->pMapping;
 703         }
 704     }
 705 }
 706 //##################################################################################################
 707 CPPU_DLLPUBLIC void SAL_CALL uno_revokeMapping(
 708     uno_Mapping * pMapping )
 709     SAL_THROW_EXTERN_C()
 710 {
 711     MappingsData & rData = getMappingsData();
 712     ClearableMutexGuard aGuard( rData.aMappingsMutex );
 713
 714     const t_Mapping2Entry::const_iterator iFind( rData.aMapping2Entry.find( pMapping ) );
 715     OSL_ASSERT( iFind != rData.aMapping2Entry.end() );
 716     MappingEntry * pEntry = (*iFind).second;
 717     if (! --pEntry->nRef)
 718     {
 719         rData.aMapping2Entry.erase( pEntry->pMapping );
 720         rData.aName2Entry.erase( pEntry->aMappingName );
 721         aGuard.clear();
 722 #if OSL_DEBUG_LEVEL > 2
 723         OString cstr( OUStringToOString( pEntry->aMappingName, RTL_TEXTENCODING_ASCII_US  ) );
 724         OSL_TRACE( "> revoking mapping %s", cstr.getStr() );
 725 #endif
 726         (*pEntry->freeMapping)( pEntry->pMapping );
 727         delete pEntry;
 728     }
 729 }
 730
 731 //##################################################################################################
 732 CPPU_DLLPUBLIC void SAL_CALL uno_registerMappingCallback(
 733     uno_getMappingFunc pCallback )
 734     SAL_THROW_EXTERN_C()
 735 {
 736     OSL_ENSURE( pCallback, "### null ptr!" );
 737     MappingsData & rData = getMappingsData();
 738     MutexGuard aGuard( rData.aCallbacksMutex );
 739     rData.aCallbacks.insert( pCallback );
 740 }
 741 //##################################################################################################
 742 CPPU_DLLPUBLIC void SAL_CALL uno_revokeMappingCallback(
 743     uno_getMappingFunc pCallback )
 744     SAL_THROW_EXTERN_C()
 745 {
 746     OSL_ENSURE( pCallback, "### null ptr!" );
 747     MappingsData & rData = getMappingsData();
 748     MutexGuard aGuard( rData.aCallbacksMutex );
 749     rData.aCallbacks.erase( pCallback );
 750 }
 751 } // extern "C"
 752
 753 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */