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 wxString wxDynamicLibrary::ms_dllext( _T(".dll") );
  69 #elif defined(__UNIX__)
  70 #if defined(__HPUX__)
  71 const wxString wxDynamicLibrary::ms_dllext( _T(".sl") );
  72 #else
  73 const wxString 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     bool OnInit() { wxPluginLibrary::ms_classes = new wxDLImports(wxKEY_STRING); return TRUE; }
 291     void OnExit() { delete wxPluginLibrary::ms_classes; wxPluginLibrary::ms_classes = NULL;
 292                     wxPluginManager::ClearManifest(); }
 293
 294 private:
 295     DECLARE_DYNAMIC_CLASS(wxPluginLibraryModule )
 296 };
 297
 298 IMPLEMENT_DYNAMIC_CLASS(wxPluginLibraryModule, wxModule)
 299
 300
 301 wxPluginLibrary::wxPluginLibrary(const wxString &libname, int flags)
 302         : m_linkcount(1)
 303         , m_objcount(0)
 304 {
 305     m_before = wxClassInfo::sm_first;
 306     Load( libname, flags );
 307     m_after = wxClassInfo::sm_first;
 308
 309     if( m_handle != 0 )
 310     {
 311         UpdateClassInfo();
 312         RegisterModules();
 313     }
 314     else
 315         --m_linkcount;      // Flag us for deletion
 316 }
 317
 318 wxPluginLibrary::~wxPluginLibrary()
 319 {
 320     if( m_handle != 0 )
 321     {
 322         UnregisterModules();
 323         RestoreClassInfo();
 324     }
 325 }
 326
 327 bool wxPluginLibrary::UnrefLib()
 328 {
 329     wxASSERT_MSG( m_objcount == 0, _T("Library unloaded before all objects were destroyed") );
 330     if( m_linkcount == 0 || --m_linkcount == 0 )
 331     {
 332         delete this;
 333         return TRUE;
 334     }
 335     return FALSE;
 336 }
 337
 338 // ------------------------
 339 // Private methods
 340 // ------------------------
 341
 342 void wxPluginLibrary::UpdateClassInfo()
 343 {
 344     wxClassInfo     *info;
 345     wxHashTable     *t = wxClassInfo::sm_classTable;
 346
 347         // FIXME: Below is simply a cut and paste specialisation of
 348         //        wxClassInfo::InitializeClasses.  Once this stabilises,
 349         //        the two should probably be merged.
 350         //
 351         //        Actually it's becoming questionable whether we should merge
 352         //        this info with the main ClassInfo tables since we can nearly
 353         //        handle this completely internally now and it does expose
 354         //        certain (minimal % user_stupidy) risks.
 355
 356     for(info = m_after; info != m_before; info = info->m_next)
 357     {
 358         if( info->m_className )
 359         {
 360             if( t->Get(info->m_className) == 0 )
 361                 t->Put(info->m_className, (wxObject *)info);
 362
 363             // Hash all the class names into a local table too so
 364             // we can quickly find the entry they correspond to.
 365
 366             if( ms_classes->Get(info->m_className) == 0 )
 367                 ms_classes->Put(info->m_className, (wxObject *) this);
 368         }
 369     }
 370
 371     for(info = m_after; info != m_before; info = info->m_next)
 372     {
 373         if( info->m_baseClassName1 )
 374             info->m_baseInfo1 = (wxClassInfo *)t->Get(info->m_baseClassName1);
 375         if( info->m_baseClassName2 )
 376             info->m_baseInfo2 = (wxClassInfo *)t->Get(info->m_baseClassName2);
 377     }
 378 }
 379
 380 void wxPluginLibrary::RestoreClassInfo()
 381 {
 382     wxClassInfo *info;
 383
 384     for(info = m_after; info != m_before; info = info->m_next)
 385     {
 386         wxClassInfo::sm_classTable->Delete(info->m_className);
 387         ms_classes->Delete(info->m_className);
 388     }
 389
 390     if( wxClassInfo::sm_first == m_after )
 391         wxClassInfo::sm_first = m_before;
 392     else
 393     {
 394         info = wxClassInfo::sm_first;
 395         while( info->m_next && info->m_next != m_after ) info = info->m_next;
 396
 397         wxASSERT_MSG( info, _T("ClassInfo from wxPluginLibrary not found on purge"))
 398
 399         info->m_next = m_before;
 400     }
 401 }
 402
 403 void wxPluginLibrary::RegisterModules()
 404 {
 405     // Plugin libraries might have wxModules, Register and initialise them if
 406     // they do.
 407     //
 408     // Note that these classes are NOT included in the reference counting since
 409     // it's implicit that they will be unloaded if and when the last handle to
 410     // the library is.  We do have to keep a copy of the module's pointer
 411     // though, as there is currently no way to Unregister it without it.
 412
 413     wxASSERT_MSG( m_linkcount == 1,
 414                   _T("RegisterModules should only be called for the first load") );
 415
 416     for(wxClassInfo *info = m_after; info != m_before; info = info->m_next)
 417     {
 418         if( info->IsKindOf(CLASSINFO(wxModule)) )
 419         {
 420             wxModule *m = wxDynamicCast(info->CreateObject(), wxModule);
 421
 422             wxASSERT_MSG( m, _T("wxDynamicCast of wxModule failed") );
 423
 424             m_wxmodules.Append(m);
 425             wxModule::RegisterModule(m);
 426         }
 427     }
 428
 429     // FIXME: Likewise this is (well was) very similar to InitializeModules()
 430
 431     for(wxModuleList::Node *node = m_wxmodules.GetFirst(); node; node->GetNext())
 432     {
 433         if( !node->GetData()->Init() )
 434         {
 435             wxLogDebug(_T("wxModule::Init() failed for wxPluginLibrary"));
 436
 437             // XXX: Watch this, a different hash implementation might break it,
 438             //      a good hash implementation would let us fix it though.
 439
 440             // The name of the game is to remove any uninitialised modules and
 441             // let the dtor Exit the rest on shutdown, (which we'll initiate
 442             // shortly).
 443
 444             wxModuleList::Node *oldNode = 0;
 445             do {
 446                 node = node->GetNext();
 447                 delete oldNode;
 448                 wxModule::UnregisterModule( node->GetData() );
 449                 oldNode = node;
 450             } while( node );
 451
 452             --m_linkcount;     // Flag us for deletion
 453             break;
 454         }
 455     }
 456 }
 457
 458 void wxPluginLibrary::UnregisterModules()
 459 {
 460     wxModuleList::Node  *node;
 461
 462     for(node = m_wxmodules.GetFirst(); node; node->GetNext())
 463         node->GetData()->Exit();
 464
 465     for(node = m_wxmodules.GetFirst(); node; node->GetNext())
 466         wxModule::UnregisterModule( node->GetData() );
 467
 468     m_wxmodules.DeleteContents(TRUE);
 469 }
 470
 471
 472 // ---------------------------------------------------------------------------
 473 // wxPluginLibrary
 474 // ---------------------------------------------------------------------------
 475
 476 wxDLManifest*   wxPluginManager::ms_manifest = NULL;
 477
 478 // ------------------------
 479 // Static accessors
 480 // ------------------------
 481
 482 wxPluginLibrary *wxPluginManager::LoadLibrary(const wxString &libname, int flags)
 483 {
 484     wxString realname(libname);
 485
 486     if( !(flags & wxDL_VERBATIM) )
 487         realname += wxDynamicLibrary::GetDllExt();
 488
 489     wxPluginLibrary *entry = (wxPluginLibrary*) ms_manifest->Get(realname);
 490
 491     if( entry != 0 )
 492     {
 493         entry->RefLib();
 494     }
 495     else
 496     {
 497         entry = new wxPluginLibrary( libname, flags );
 498
 499         if( entry->IsLoaded() )
 500         {
 501             ms_manifest->Put(realname, (wxObject*) entry);
 502         }
 503         else
 504         {
 505             wxCHECK_MSG( entry->UnrefLib(), 0,
 506                          _T("Currently linked library is, ..not loaded??") );
 507             entry = 0;
 508         }
 509     }
 510     return entry;
 511 }
 512
 513 bool wxPluginManager::UnloadLibrary(const wxString &libname)
 514 {
 515     wxPluginLibrary *entry = (wxPluginLibrary*) ms_manifest->Get(libname);
 516
 517     if( !entry )
 518         entry = (wxPluginLibrary*) ms_manifest->Get(libname + wxDynamicLibrary::GetDllExt());
 519
 520     if( entry )
 521         return entry->UnrefLib();
 522
 523     wxLogDebug(_T("Attempt to Unlink library '%s' (which is not linked)."), libname.c_str());
 524     return FALSE;
 525 }
 526
 527 #if WXWIN_COMPATIBILITY_2_2
 528 wxPluginLibrary *wxPluginManager::GetObjectFromHandle(wxDllType handle)
 529 {
 530     wxNode  *node;
 531     ms_manifest->BeginFind();
 532
 533     for(node = ms_manifest->Next(); node; node = ms_manifest->Next())
 534         if( ((wxPluginLibrary*)node->GetData())->GetLibHandle() == handle )
 535             return (wxPluginLibrary*)node->GetData();
 536
 537     return 0;
 538 }
 539 #endif
 540
 541 // ------------------------
 542 // Class implementation
 543 // ------------------------
 544
 545 bool wxPluginManager::Load(const wxString &libname, int flags)
 546 {
 547     m_entry = wxPluginManager::LoadLibrary(libname, flags);
 548     return IsLoaded();
 549 }
 550
 551 void wxPluginManager::Unload()
 552 {
 553     wxNode  *node;
 554     ms_manifest->BeginFind();
 555
 556     // It's either this or store the name of the lib just to do this.
 557
 558     for(node = ms_manifest->Next(); node; node = ms_manifest->Next())
 559         if( (wxPluginLibrary*)node->GetData() == m_entry )
 560             break;
 561
 562     if( m_entry && m_entry->UnrefLib() )
 563     {
 564         delete node;
 565         m_entry = 0;
 566     }
 567 }
 568
 569 // ---------------------------------------------------------------------------
 570 // wxDllLoader   (all these methods are static)
 571 // ---------------------------------------------------------------------------
 572
 573 #if WXWIN_COMPATIBILITY_2_2
 574
 575 wxDllType wxDllLoader::LoadLibrary(const wxString &name)
 576 {
 577     wxPluginLibrary *p = wxPluginManager::LoadLibrary(name, wxDL_DEFAULT | wxDL_VERBATIM);
 578     return p->GetLibHandle();
 579 }
 580
 581 void wxDllLoader::UnloadLibrary(wxDllType handle)
 582 {
 583     wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(handle);
 584     p->UnrefLib();
 585 }
 586
 587 void *wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name, bool *success)
 588 {
 589     wxPluginLibrary *p = wxPluginManager::GetObjectFromHandle(dllHandle);
 590     return p->GetSymbol(name, success);
 591 }
 592
 593 #endif  // WXWIN_COMPATIBILITY_2_2
 594
 595 #endif  // wxUSE_DYNAMIC_LOADER
 596
 597 // vi:sts=4:sw=4:et