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     for(info = m_after; info != m_before; info = info->m_next)
 426     {
 427         if( info->m_baseClassName1 )
 428             info->m_baseInfo1 = (wxClassInfo *)t->Get(info->m_baseClassName1);
 429         if( info->m_baseClassName2 )
 430             info->m_baseInfo2 = (wxClassInfo *)t->Get(info->m_baseClassName2);
 431     }
 432 }
 433
 434 void wxPluginLibrary::RestoreClassInfo()
 435 {
 436     wxClassInfo *info;
 437
 438     for(info = m_after; info != m_before; info = info->m_next)
 439     {
 440         wxClassInfo::sm_classTable->Delete(info->m_className);
 441         ms_classes->erase(ms_classes->find(info->m_className));
 442     }
 443
 444     if( wxClassInfo::sm_first == m_after )
 445         wxClassInfo::sm_first = m_before;
 446     else
 447     {
 448         info = wxClassInfo::sm_first;
 449         while( info->m_next && info->m_next != m_after ) info = info->m_next;
 450
 451         wxASSERT_MSG( info, _T("ClassInfo from wxPluginLibrary not found on purge"));
 452
 453         info->m_next = m_before;
 454     }
 455 }
 456
 457 void wxPluginLibrary::RegisterModules()
 458 {
 459     // Plugin libraries might have wxModules, Register and initialise them if
 460     // they do.
 461     //
 462     // Note that these classes are NOT included in the reference counting since
 463     // it's implicit that they will be unloaded if and when the last handle to
 464     // the library is.  We do have to keep a copy of the module's pointer
 465     // though, as there is currently no way to Unregister it without it.
 466
 467     wxASSERT_MSG( m_linkcount == 1,
 468                   _T("RegisterModules should only be called for the first load") );
 469
 470     for ( wxClassInfo *info = m_after; info != m_before; info = info->m_next)
 471     {
 472         if( info->IsKindOf(CLASSINFO(wxModule)) )
 473         {
 474             wxModule *m = wxDynamicCast(info->CreateObject(), wxModule);
 475
 476             wxASSERT_MSG( m, _T("wxDynamicCast of wxModule failed") );
 477
 478             m_wxmodules.push_back(m);
 479             wxModule::RegisterModule(m);
 480         }
 481     }
 482
 483     // FIXME: Likewise this is (well was) very similar to InitializeModules()
 484
 485     for ( wxModuleList::iterator it = m_wxmodules.begin();
 486           it != m_wxmodules.end();
 487           ++it)
 488     {
 489         if( !(*it)->Init() )
 490         {
 491             wxLogDebug(_T("wxModule::Init() failed for wxPluginLibrary"));
 492
 493             // XXX: Watch this, a different hash implementation might break it,
 494             //      a good hash implementation would let us fix it though.
 495
 496             // The name of the game is to remove any uninitialised modules and
 497             // let the dtor Exit the rest on shutdown, (which we'll initiate
 498             // shortly).
 499
 500             wxModuleList::iterator oldNode = m_wxmodules.end();
 501             do {
 502                 ++it;
 503                 if( oldNode != m_wxmodules.end() )
 504                     m_wxmodules.erase(oldNode);
 505                 wxModule::UnregisterModule( *it );
 506                 oldNode = it;
 507             } while( it != m_wxmodules.end() );
 508
 509             --m_linkcount;     // Flag us for deletion
 510             break;
 511         }
 512     }
 513 }
 514
 515 void wxPluginLibrary::UnregisterModules()
 516 {
 517     wxModuleList::iterator it;
 518
 519     for ( it = m_wxmodules.begin(); it != m_wxmodules.end(); ++it )
 520         (*it)->Exit();
 521
 522     for ( it = m_wxmodules.begin(); it != m_wxmodules.end(); ++it )
 523         wxModule::UnregisterModule( *it );
 524
 525     WX_CLEAR_LIST(wxModuleList, m_wxmodules);
 526 }
 527
 528
 529 // ---------------------------------------------------------------------------
 530 // wxPluginManager
 531 // ---------------------------------------------------------------------------
 532
 533 wxDLManifest*   wxPluginManager::ms_manifest = NULL;
 534
 535 // ------------------------
 536 // Static accessors
 537 // ------------------------
 538
 539 wxPluginLibrary *
 540 wxPluginManager::LoadLibrary(const wxString &libname, int flags)
 541 {
 542     wxString realname(libname);
 543
 544     if( !(flags & wxDL_VERBATIM) )
 545         realname += wxDynamicLibrary::GetDllExt();
 546
 547     wxPluginLibrary *entry;
 548
 549     if ( flags & wxDL_NOSHARE )
 550     {
 551         entry = NULL;
 552     }
 553     else
 554     {
 555         entry = FindByName(realname);
 556     }
 557
 558     if ( entry )
 559     {
 560         wxLogTrace(_T("dll"),
 561                    _T("LoadLibrary(%s): already loaded."), realname.c_str());
 562
 563         entry->RefLib();
 564     }
 565     else
 566     {
 567         entry = new wxPluginLibrary( libname, flags );
 568
 569         if ( entry->IsLoaded() )
 570         {
 571             (*ms_manifest)[realname] = entry;
 572
 573             wxLogTrace(_T("dll"),
 574                        _T("LoadLibrary(%s): loaded ok."), realname.c_str());
 575
 576         }
 577         else
 578         {
 579             wxLogTrace(_T("dll"),
 580                        _T("LoadLibrary(%s): failed to load."), realname.c_str());
 581
 582             // we have created entry just above
 583             if ( !entry->UnrefLib() )
 584             {
 585                 // ... so UnrefLib() is supposed to delete it
 586                 wxFAIL_MSG( _T("Currently linked library is not loaded?") );
 587             }
 588
 589             entry = NULL;
 590         }
 591     }
 592
 593     return entry;
 594 }
 595
 596 bool wxPluginManager::UnloadLibrary(const wxString& libname)
 597 {
 598     wxString realname = libname;
 599
 600     wxPluginLibrary *entry = FindByName(realname);
 601
 602     if ( !entry )
 603     {
 604         realname += wxDynamicLibrary::GetDllExt();
 605
 606         entry = FindByName(realname);
 607     }
 608
 609     if ( !entry )
 610     {
 611         wxLogDebug(_T("Attempt to unload library '%s' which is not loaded."),
 612                    libname.c_str());
 613
 614         return FALSE;
 615     }
 616
 617     wxLogTrace(_T("dll"), _T("UnloadLibrary(%s)"), realname.c_str());
 618
 619     if ( !entry->UnrefLib() )
 620     {
 621         // not really unloaded yet
 622         return FALSE;
 623     }
 624
 625     ms_manifest->erase(ms_manifest->find(realname));
 626
 627     return TRUE;
 628 }
 629
 630 #if WXWIN_COMPATIBILITY_2_2
 631 wxPluginLibrary *wxPluginManager::GetObjectFromHandle(wxDllType handle)
 632 {
 633     for ( wxDLManifest::iterator i = ms_manifest->begin();
 634           i != ms_manifest->end();
 635           ++i )
 636     {
 637         wxPluginLibrary * const lib = i->second;
 638
 639         if ( lib->GetLibHandle() == handle )
 640             return lib;
 641     }
 642
 643     return NULL;
 644 }
 645 #endif // WXWIN_COMPATIBILITY_2_2
 646
 647 // ------------------------
 648 // Class implementation
 649 // ------------------------
 650
 651 bool wxPluginManager::Load(const wxString &libname, int flags)
 652 {
 653     m_entry = wxPluginManager::LoadLibrary(libname, flags);
 654
 655     return IsLoaded();
 656 }
 657
 658 void wxPluginManager::Unload()
 659 {
 660     wxCHECK_RET( m_entry, _T("unloading an invalid wxPluginManager?") );
 661
 662     for ( wxDLManifest::iterator i = ms_manifest->begin();
 663           i != ms_manifest->end();
 664           ++i )
 665     {
 666         if ( i->second == m_entry )
 667         {
 668             ms_manifest->erase(i);
 669             break;
 670         }
 671     }
 672
 673     m_entry->UnrefLib();
 674
 675     m_entry = NULL;
 676 }
 677
 678 // ---------------------------------------------------------------------------
 679 // wxDllLoader   (all these methods are static)
 680 // ---------------------------------------------------------------------------
 681
 682 #if WXWIN_COMPATIBILITY_2_2
 683
 684 wxDllType wxDllLoader::LoadLibrary(const wxString &name, bool *success)
 685 {
 686     wxPluginLibrary *p = wxPluginManager::LoadLibrary
 687                          (
 688                             name,
 689                             wxDL_DEFAULT | wxDL_VERBATIM | wxDL_NOSHARE
 690                          );
 691
 692     if ( success )
 693         *success = p != NULL;
 694
 695     return p ? p->GetLibHandle() : 0;
 696 }
 697
 698 void wxDllLoader::UnloadLibrary(wxDllType handle)
 699 {
 700     wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(handle);
 701
 702     wxCHECK_RET( p, _T("Unloading a library not loaded with wxDllLoader?") );
 703
 704     p->UnrefLib();
 705 }
 706
 707 void *
 708 wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *success)
 709 {
 710     wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(dllHandle);
 711
 712     if ( !p )
 713     {
 714         wxFAIL_MSG( _T("Using a library not loaded with wxDllLoader?") );
 715
 716         if ( success )
 717             *success = FALSE;
 718
 719         return NULL;
 720     }
 721
 722     return p->GetSymbol(name, success);
 723 }
 724
 725 #endif  // WXWIN_COMPATIBILITY_2_2
 726
 727 #endif  // wxUSE_DYNAMIC_LOADER
 728