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