src/common/dynload.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:         dynload.cpp
   3 // Purpose:      Dynamic loading framework
   4 // Author:       Ron Lee, David Falkinder, Vadim Zeitlin and a cast of 1000's
   5 //               (derived in part from dynlib.cpp (c) 1998 Guilhem Lavaux)
   6 // Modified by:
   7 // Created:      03/12/01
   8 // RCS-ID:       $Id$
   9 // Copyright:    (c) 2001 Ron Lee <ron@debian.org>
  10 // Licence:      wxWindows licence
  11 /////////////////////////////////////////////////////////////////////////////
  12
  13 #ifdef __GNUG__
  14 #pragma implementation "dynload.h"
  15 #endif
  16
  17 // ----------------------------------------------------------------------------
  18 // headers
  19 // ----------------------------------------------------------------------------
  20
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #if wxUSE_DYNAMIC_LOADER
  28
  29 #ifdef __WINDOWS__
  30     #include "wx/msw/private.h"
  31 #endif
  32
  33 #ifndef WX_PRECOMP
  34     #include "wx/log.h"
  35     #include "wx/intl.h"
  36     #include "wx/hash.h"
  37 #endif
  38
  39 #include "wx/filename.h"        // for SplitPath()
  40 #include "wx/strconv.h"
  41
  42 #include "wx/dynload.h"
  43 #include "wx/module.h"
  44
  45 #if defined(__DARWIN__)
  46 /* Porting notes:
  47  *   The dlopen port is a port from dl_next.xs by Anno Siegel.
  48  *   dl_next.xs is itself a port from dl_dlopen.xs by Paul Marquess.
  49  *   The method used here is just to supply the sun style dlopen etc.
  50  *   functions in terms of Darwin NS*.
  51  */
  52 void *dlopen(const char *path, int mode /* mode is ignored */);
  53 void *dlsym(void *handle, const char *symbol);
  54 int   dlclose(void *handle);
  55 const char *dlerror(void);
  56 #endif
  57
  58 // ============================================================================
  59 // implementation
  60 // ============================================================================
  61
  62 // ---------------------------------------------------------------------------
  63 // wxDynamicLibrary
  64 // ---------------------------------------------------------------------------
  65
  66 //FIXME:  This class isn't really common at all, it should be moved into
  67 //        platform dependent files.
  68
  69 #if defined(__WINDOWS__) || defined(__WXPM__) || defined(__EMX__)
  70     const wxChar *wxDynamicLibrary::ms_dllext = _T(".dll");
  71 #elif defined(__UNIX__)
  72     #if defined(__HPUX__)
  73         const wxChar *wxDynamicLibrary::ms_dllext = _T(".sl");
  74     #else
  75         const wxChar *wxDynamicLibrary::ms_dllext = _T(".so");
  76     #endif
  77 #endif
  78
  79 wxDllType wxDynamicLibrary::GetProgramHandle()
  80 {
  81 #if defined( HAVE_DLOPEN ) && !defined(__EMX__)
  82    return dlopen(0, RTLD_LAZY);
  83 #elif defined (HAVE_SHL_LOAD)
  84    return PROG_HANDLE;
  85 #else
  86    wxFAIL_MSG( wxT("This method is not implemented under Windows or OS/2"));
  87    return 0;
  88 #endif
  89 }
  90
  91 bool wxDynamicLibrary::Load(wxString libname, int flags)
  92 {
  93     wxASSERT_MSG(m_handle == 0, _T("Library already loaded."));
  94
  95     // add the proper extension for the DLL ourselves unless told not to
  96     if ( !(flags & wxDL_VERBATIM) )
  97     {
  98         // and also check that the libname doesn't already have it
  99         wxString ext;
 100         wxFileName::SplitPath(libname, NULL, NULL, &ext);
 101         if ( ext.empty() )
 102         {
 103             libname += GetDllExt();
 104         }
 105     }
 106
 107     // different ways to load a shared library
 108     //
 109     // FIXME: should go to the platform-specific files!
 110 #if defined(__WXMAC__) && !defined(__DARWIN__)
 111     FSSpec      myFSSpec;
 112     Ptr         myMainAddr;
 113     Str255      myErrName;
 114
 115     wxMacFilename2FSSpec( libname , &myFSSpec );
 116
 117     if( GetDiskFragment( &myFSSpec,
 118                          0,
 119                          kCFragGoesToEOF,
 120                          "\p",
 121                          kPrivateCFragCopy,
 122                          &m_handle,
 123                          &myMainAddr,
 124                          myErrName ) != noErr )
 125     {
 126         p2cstr( myErrName );
 127         wxLogSysError( _("Failed to load shared library '%s' Error '%s'"),
 128                        libname.c_str(),
 129                        (char*)myErrName );
 130         m_handle = 0;
 131     }
 132
 133 #elif defined(__WXPM__) || defined(__EMX__)
 134     char    err[256] = "";
 135     DosLoadModule(err, sizeof(err), libname.c_str(), &m_handle);
 136
 137 #elif defined(HAVE_DLOPEN) || defined(__DARWIN__)
 138
 139 #if defined(__VMS) || defined(__DARWIN__)
 140     m_handle = dlopen(libname.c_str(), 0);  // The second parameter is ignored
 141 #else // !__VMS  && !__DARWIN__
 142     int rtldFlags = 0;
 143
 144     if ( flags & wxDL_LAZY )
 145     {
 146         wxASSERT_MSG( (flags & wxDL_NOW) == 0,
 147                       _T("wxDL_LAZY and wxDL_NOW are mutually exclusive.") );
 148 #ifdef RTLD_LAZY
 149         rtldFlags |= RTLD_LAZY;
 150 #else
 151         wxLogDebug(_T("wxDL_LAZY is not supported on this platform"));
 152 #endif
 153     }
 154     else if ( flags & wxDL_NOW )
 155     {
 156 #ifdef RTLD_NOW
 157         rtldFlags |= RTLD_NOW;
 158 #else
 159         wxLogDebug(_T("wxDL_NOW is not supported on this platform"));
 160 #endif
 161     }
 162
 163     if ( flags & wxDL_GLOBAL )
 164     {
 165 #ifdef RTLD_GLOBAL
 166         rtldFlags |= RTLD_GLOBAL;
 167 #else
 168         wxLogDebug(_T("RTLD_GLOBAL is not supported on this platform."));
 169 #endif
 170     }
 171
 172     m_handle = dlopen(libname.fn_str(), rtldFlags);
 173 #endif  // __VMS || __DARWIN__ ?
 174
 175 #elif defined(HAVE_SHL_LOAD)
 176     int shlFlags = 0;
 177
 178     if( flags & wxDL_LAZY )
 179     {
 180         wxASSERT_MSG( (flags & wxDL_NOW) == 0,
 181                       _T("wxDL_LAZY and wxDL_NOW are mutually exclusive.") );
 182         shlFlags |= BIND_DEFERRED;
 183     }
 184     else if( flags & wxDL_NOW )
 185     {
 186         shlFlags |= BIND_IMMEDIATE;
 187     }
 188     m_handle = shl_load(libname.fn_str(), BIND_DEFERRED, 0);
 189
 190 #elif defined(__WINDOWS__)
 191     m_handle = ::LoadLibrary(libname.c_str());
 192 #else
 193     #error  "runtime shared lib support not implemented on this platform"
 194 #endif
 195
 196     if ( m_handle == 0 )
 197     {
 198         wxString msg(_("Failed to load shared library '%s'"));
 199 #if defined(HAVE_DLERROR) && !defined(__EMX__)
 200
 201 #if wxUSE_UNICODE
 202         wxWCharBuffer buffer = wxConvLocal.cMB2WC( dlerror() );
 203         const wxChar *err = buffer;
 204 #else
 205         const wxChar *err = dlerror();
 206 #endif
 207
 208         if( err )
 209             wxLogError( msg, err );
 210 #else
 211         wxLogSysError( msg, libname.c_str() );
 212 #endif
 213     }
 214
 215     return IsLoaded();
 216 }
 217
 218 void wxDynamicLibrary::Unload()
 219 {
 220     if( IsLoaded() )
 221     {
 222 #if defined(__WXPM__) || defined(__EMX__)
 223         DosFreeModule( m_handle );
 224 #elif defined(HAVE_DLOPEN) || defined(__DARWIN__)
 225         dlclose( m_handle );
 226 #elif defined(HAVE_SHL_LOAD)
 227         shl_unload( m_handle );
 228 #elif defined(__WINDOWS__)
 229         ::FreeLibrary( m_handle );
 230 #elif defined(__WXMAC__) && !defined(__DARWIN__)
 231         CloseConnection( (CFragConnectionID*) &m_handle );
 232 #else
 233 #error  "runtime shared lib support not implemented"
 234 #endif
 235         m_handle = 0;
 236     }
 237 }
 238
 239 void *wxDynamicLibrary::GetSymbol(const wxString &name, bool *success) const
 240 {
 241     wxCHECK_MSG( IsLoaded(), NULL,
 242                  _T("Can't load symbol from unloaded library") );
 243
 244     bool     failed = FALSE;
 245     void    *symbol = 0;
 246
 247 #if defined(__WXMAC__) && !defined(__DARWIN__)
 248     Ptr                 symAddress;
 249     CFragSymbolClass    symClass;
 250     Str255              symName;
 251 #if TARGET_CARBON
 252     c2pstrcpy( (StringPtr) symName, name );
 253 #else
 254     strcpy( (char *)symName, name );
 255     c2pstr( (char *)symName );
 256 #endif
 257     if( FindSymbol( dllHandle, symName, &symAddress, &symClass ) == noErr )
 258         symbol = (void *)symAddress;
 259
 260 #elif defined(__WXPM__) || defined(__EMX__)
 261     DosQueryProcAddr( m_handle, 1L, name.c_str(), (PFN*)symbol );
 262
 263 #elif defined(HAVE_DLOPEN) || defined(__DARWIN__)
 264     symbol = dlsym( m_handle, name.fn_str() );
 265
 266 #elif defined(HAVE_SHL_LOAD)
 267     // use local variable since shl_findsym modifies the handle argument
 268     // to indicate where the symbol was found (GD)
 269     wxDllType the_handle = m_handle;
 270     if( shl_findsym( &the_handle, name.fn_str(), TYPE_UNDEFINED, &symbol ) != 0 )
 271         symbol = 0;
 272
 273 #elif defined(__WINDOWS__)
 274     symbol = (void*) ::GetProcAddress( m_handle, name.mb_str() );
 275
 276 #else
 277 #error  "runtime shared lib support not implemented"
 278 #endif
 279
 280     if ( !symbol )
 281     {
 282 #if defined(HAVE_DLERROR) && !defined(__EMX__)
 283
 284 #if wxUSE_UNICODE
 285         wxWCharBuffer buffer = wxConvLocal.cMB2WC( dlerror() );
 286         const wxChar *err = buffer;
 287 #else
 288         const wxChar *err = dlerror();
 289 #endif
 290
 291         if( err )
 292         {
 293             wxLogError(wxT("%s"), err);
 294         }
 295 #else
 296         failed = TRUE;
 297         wxLogSysError(_("Couldn't find symbol '%s' in a dynamic library"),
 298                       name.c_str());
 299 #endif
 300     }
 301     if( success )
 302         *success = !failed;
 303
 304     return symbol;
 305 }
 306
 307
 308 // ---------------------------------------------------------------------------
 309 // wxPluginLibrary
 310 // ---------------------------------------------------------------------------
 311
 312
 313 wxDLImports*  wxPluginLibrary::ms_classes = NULL;
 314
 315 class wxPluginLibraryModule : public wxModule
 316 {
 317 public:
 318     wxPluginLibraryModule() { }
 319
 320     // TODO: create ms_classes on demand, why always preallocate it?
 321     virtual bool OnInit()
 322     {
 323         wxPluginLibrary::ms_classes = new wxDLImports(wxKEY_STRING);
 324         wxPluginManager::CreateManifest();
 325         return TRUE;
 326     }
 327
 328     virtual void OnExit()
 329     {
 330         delete wxPluginLibrary::ms_classes;
 331         wxPluginLibrary::ms_classes = NULL;
 332         wxPluginManager::ClearManifest();
 333     }
 334
 335 private:
 336     DECLARE_DYNAMIC_CLASS(wxPluginLibraryModule )
 337 };
 338
 339 IMPLEMENT_DYNAMIC_CLASS(wxPluginLibraryModule, wxModule)
 340
 341
 342 wxPluginLibrary::wxPluginLibrary(const wxString &libname, int flags)
 343         : m_linkcount(1)
 344         , m_objcount(0)
 345 {
 346     m_before = wxClassInfo::sm_first;
 347     Load( libname, flags );
 348     m_after = wxClassInfo::sm_first;
 349
 350     if( m_handle != 0 )
 351     {
 352         UpdateClassInfo();
 353         RegisterModules();
 354     }
 355     else
 356     {
 357         // Flag us for deletion
 358         --m_linkcount;
 359     }
 360 }
 361
 362 wxPluginLibrary::~wxPluginLibrary()
 363 {
 364     if( m_handle != 0 )
 365     {
 366         UnregisterModules();
 367         RestoreClassInfo();
 368     }
 369 }
 370
 371 wxPluginLibrary *wxPluginLibrary::RefLib()
 372 {
 373     wxCHECK_MSG( m_linkcount > 0, NULL,
 374                  _T("Library had been already deleted!") );
 375
 376     ++m_linkcount;
 377     return this;
 378 }
 379
 380 bool wxPluginLibrary::UnrefLib()
 381 {
 382     wxASSERT_MSG( m_objcount == 0,
 383                   _T("Library unloaded before all objects were destroyed") );
 384
 385     if ( --m_linkcount == 0 )
 386     {
 387         delete this;
 388         return TRUE;
 389     }
 390
 391     return FALSE;
 392 }
 393
 394 // ------------------------
 395 // Private methods
 396 // ------------------------
 397
 398 void wxPluginLibrary::UpdateClassInfo()
 399 {
 400     wxClassInfo     *info;
 401     wxHashTable     *t = wxClassInfo::sm_classTable;
 402
 403         // FIXME: Below is simply a cut and paste specialisation of
 404         //        wxClassInfo::InitializeClasses.  Once this stabilises,
 405         //        the two should probably be merged.
 406         //
 407         //        Actually it's becoming questionable whether we should merge
 408         //        this info with the main ClassInfo tables since we can nearly
 409         //        handle this completely internally now and it does expose
 410         //        certain (minimal % user_stupidy) risks.
 411
 412     for(info = m_after; info != m_before; info = info->m_next)
 413     {
 414         if( info->m_className )
 415         {
 416             if( t->Get(info->m_className) == 0 )
 417                 t->Put(info->m_className, (wxObject *)info);
 418
 419             // Hash all the class names into a local table too so
 420             // we can quickly find the entry they correspond to.
 421             (*ms_classes)[info->m_className] = this;
 422         }
 423     }
 424
 425 #if wxUSE_EXTENDED_RTTI == 0
 426     for(info = m_after; info != m_before; info = info->m_next)
 427     {
 428         if( info->m_baseClassName1 )
 429             info->m_baseInfo1 = (wxClassInfo *)t->Get(info->m_baseClassName1);
 430         if( info->m_baseClassName2 )
 431             info->m_baseInfo2 = (wxClassInfo *)t->Get(info->m_baseClassName2);
 432     }
 433 #endif
 434 }
 435
 436 void wxPluginLibrary::RestoreClassInfo()
 437 {
 438     wxClassInfo *info;
 439
 440     for(info = m_after; info != m_before; info = info->m_next)
 441     {
 442         wxClassInfo::sm_classTable->Delete(info->m_className);
 443         ms_classes->erase(ms_classes->find(info->m_className));
 444     }
 445
 446     if( wxClassInfo::sm_first == m_after )
 447         wxClassInfo::sm_first = m_before;
 448     else
 449     {
 450         info = wxClassInfo::sm_first;
 451         while( info->m_next && info->m_next != m_after ) info = info->m_next;
 452
 453         wxASSERT_MSG( info, _T("ClassInfo from wxPluginLibrary not found on purge"));
 454
 455         info->m_next = m_before;
 456     }
 457 }
 458
 459 void wxPluginLibrary::RegisterModules()
 460 {
 461     // Plugin libraries might have wxModules, Register and initialise them if
 462     // they do.
 463     //
 464     // Note that these classes are NOT included in the reference counting since
 465     // it's implicit that they will be unloaded if and when the last handle to
 466     // the library is.  We do have to keep a copy of the module's pointer
 467     // though, as there is currently no way to Unregister it without it.
 468
 469     wxASSERT_MSG( m_linkcount == 1,
 470                   _T("RegisterModules should only be called for the first load") );
 471
 472     for ( wxClassInfo *info = m_after; info != m_before; info = info->m_next)
 473     {
 474         if( info->IsKindOf(CLASSINFO(wxModule)) )
 475         {
 476             wxModule *m = wxDynamicCast(info->CreateObject(), wxModule);
 477
 478             wxASSERT_MSG( m, _T("wxDynamicCast of wxModule failed") );
 479
 480             m_wxmodules.push_back(m);
 481             wxModule::RegisterModule(m);
 482         }
 483     }
 484
 485     // FIXME: Likewise this is (well was) very similar to InitializeModules()
 486
 487     for ( wxModuleList::iterator it = m_wxmodules.begin();
 488           it != m_wxmodules.end();
 489           ++it)
 490     {
 491         if( !(*it)->Init() )
 492         {
 493             wxLogDebug(_T("wxModule::Init() failed for wxPluginLibrary"));
 494
 495             // XXX: Watch this, a different hash implementation might break it,
 496             //      a good hash implementation would let us fix it though.
 497
 498             // The name of the game is to remove any uninitialised modules and
 499             // let the dtor Exit the rest on shutdown, (which we'll initiate
 500             // shortly).
 501
 502             wxModuleList::iterator oldNode = m_wxmodules.end();
 503             do {
 504                 ++it;
 505                 if( oldNode != m_wxmodules.end() )
 506                     m_wxmodules.erase(oldNode);
 507                 wxModule::UnregisterModule( *it );
 508                 oldNode = it;
 509             } while( it != m_wxmodules.end() );
 510
 511             --m_linkcount;     // Flag us for deletion
 512             break;
 513         }
 514     }
 515 }
 516
 517 void wxPluginLibrary::UnregisterModules()
 518 {
 519     wxModuleList::iterator it;
 520
 521     for ( it = m_wxmodules.begin(); it != m_wxmodules.end(); ++it )
 522         (*it)->Exit();
 523
 524     for ( it = m_wxmodules.begin(); it != m_wxmodules.end(); ++it )
 525         wxModule::UnregisterModule( *it );
 526
 527     WX_CLEAR_LIST(wxModuleList, m_wxmodules);
 528 }
 529
 530
 531 // ---------------------------------------------------------------------------
 532 // wxPluginManager
 533 // ---------------------------------------------------------------------------
 534
 535 wxDLManifest*   wxPluginManager::ms_manifest = NULL;
 536
 537 // ------------------------
 538 // Static accessors
 539 // ------------------------
 540
 541 wxPluginLibrary *
 542 wxPluginManager::LoadLibrary(const wxString &libname, int flags)
 543 {
 544     wxString realname(libname);
 545
 546     if( !(flags & wxDL_VERBATIM) )
 547         realname += wxDynamicLibrary::GetDllExt();
 548
 549     wxPluginLibrary *entry;
 550
 551     if ( flags & wxDL_NOSHARE )
 552     {
 553         entry = NULL;
 554     }
 555     else
 556     {
 557         entry = FindByName(realname);
 558     }
 559
 560     if ( entry )
 561     {
 562         wxLogTrace(_T("dll"),
 563                    _T("LoadLibrary(%s): already loaded."), realname.c_str());
 564
 565         entry->RefLib();
 566     }
 567     else
 568     {
 569         entry = new wxPluginLibrary( libname, flags );
 570
 571         if ( entry->IsLoaded() )
 572         {
 573             (*ms_manifest)[realname] = entry;
 574
 575             wxLogTrace(_T("dll"),
 576                        _T("LoadLibrary(%s): loaded ok."), realname.c_str());
 577
 578         }
 579         else
 580         {
 581             wxLogTrace(_T("dll"),
 582                        _T("LoadLibrary(%s): failed to load."), realname.c_str());
 583
 584             // we have created entry just above
 585             if ( !entry->UnrefLib() )
 586             {
 587                 // ... so UnrefLib() is supposed to delete it
 588                 wxFAIL_MSG( _T("Currently linked library is not loaded?") );
 589             }
 590
 591             entry = NULL;
 592         }
 593     }
 594
 595     return entry;
 596 }
 597
 598 bool wxPluginManager::UnloadLibrary(const wxString& libname)
 599 {
 600     wxString realname = libname;
 601
 602     wxPluginLibrary *entry = FindByName(realname);
 603
 604     if ( !entry )
 605     {
 606         realname += wxDynamicLibrary::GetDllExt();
 607
 608         entry = FindByName(realname);
 609     }
 610
 611     if ( !entry )
 612     {
 613         wxLogDebug(_T("Attempt to unload library '%s' which is not loaded."),
 614                    libname.c_str());
 615
 616         return FALSE;
 617     }
 618
 619     wxLogTrace(_T("dll"), _T("UnloadLibrary(%s)"), realname.c_str());
 620
 621     if ( !entry->UnrefLib() )
 622     {
 623         // not really unloaded yet
 624         return FALSE;
 625     }
 626
 627     ms_manifest->erase(ms_manifest->find(realname));
 628
 629     return TRUE;
 630 }
 631
 632 #if WXWIN_COMPATIBILITY_2_2
 633 wxPluginLibrary *wxPluginManager::GetObjectFromHandle(wxDllType handle)
 634 {
 635     for ( wxDLManifest::iterator i = ms_manifest->begin();
 636           i != ms_manifest->end();
 637           ++i )
 638     {
 639         wxPluginLibrary * const lib = i->second;
 640
 641         if ( lib->GetLibHandle() == handle )
 642             return lib;
 643     }
 644
 645     return NULL;
 646 }
 647 #endif // WXWIN_COMPATIBILITY_2_2
 648
 649 // ------------------------
 650 // Class implementation
 651 // ------------------------
 652
 653 bool wxPluginManager::Load(const wxString &libname, int flags)
 654 {
 655     m_entry = wxPluginManager::LoadLibrary(libname, flags);
 656
 657     return IsLoaded();
 658 }
 659
 660 void wxPluginManager::Unload()
 661 {
 662     wxCHECK_RET( m_entry, _T("unloading an invalid wxPluginManager?") );
 663
 664     for ( wxDLManifest::iterator i = ms_manifest->begin();
 665           i != ms_manifest->end();
 666           ++i )
 667     {
 668         if ( i->second == m_entry )
 669         {
 670             ms_manifest->erase(i);
 671             break;
 672         }
 673     }
 674
 675     m_entry->UnrefLib();
 676
 677     m_entry = NULL;
 678 }
 679
 680 // ---------------------------------------------------------------------------
 681 // wxDllLoader   (all these methods are static)
 682 // ---------------------------------------------------------------------------
 683
 684 #if WXWIN_COMPATIBILITY_2_2
 685
 686 wxDllType wxDllLoader::LoadLibrary(const wxString &name, bool *success)
 687 {
 688     wxPluginLibrary *p = wxPluginManager::LoadLibrary
 689                          (
 690                             name,
 691                             wxDL_DEFAULT | wxDL_VERBATIM | wxDL_NOSHARE
 692                          );
 693
 694     if ( success )
 695         *success = p != NULL;
 696
 697     return p ? p->GetLibHandle() : 0;
 698 }
 699
 700 void wxDllLoader::UnloadLibrary(wxDllType handle)
 701 {
 702     wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(handle);
 703
 704     wxCHECK_RET( p, _T("Unloading a library not loaded with wxDllLoader?") );
 705
 706     p->UnrefLib();
 707 }
 708
 709 void *
 710 wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *success)
 711 {
 712     wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(dllHandle);
 713
 714     if ( !p )
 715     {
 716         wxFAIL_MSG( _T("Using a library not loaded with wxDllLoader?") );
 717
 718         if ( success )
 719             *success = FALSE;
 720
 721         return NULL;
 722     }
 723
 724     return p->GetSymbol(name, success);
 725 }
 726
 727 #endif  // WXWIN_COMPATIBILITY_2_2
 728
 729 #endif  // wxUSE_DYNAMIC_LOADER
 730