src/common/dynlib.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        dynlib.cpp
   3 // Purpose:     Dynamic library management
   4 // Author:      Guilhem Lavaux
   5 // Modified by:
   6 // Created:     20/07/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Guilhem Lavaux
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21 #   pragma implementation "dynlib.h"
  22 #endif
  23
  24 #include  "wx/wxprec.h"
  25
  26 #ifdef __BORLANDC__
  27   #pragma hdrstop
  28 #endif
  29
  30 #if wxUSE_DYNLIB_CLASS
  31
  32 #if defined(__WINDOWS__)
  33     #include "wx/msw/private.h"
  34 #endif
  35
  36 #include "wx/dynlib.h"
  37 #include "wx/filefn.h"
  38 #include "wx/intl.h"
  39 #include "wx/log.h"
  40 #include "wx/tokenzr.h"
  41
  42 // ----------------------------------------------------------------------------
  43 // conditional compilation
  44 // ----------------------------------------------------------------------------
  45
  46 #if defined(__WXPM__) || defined(__EMX__)
  47 #  define INCL_DOS
  48 #  include <os2.h>
  49 #  define wxDllOpen(error, lib, handle)     DosLoadModule(error, sizeof(error), lib, &handle)
  50 #  define wxDllGetSymbol(handle, modaddr)   DosQueryProcAddr(handle, 1L, NULL, (PFN*)modaddr)
  51 #  define wxDllClose(handle)                DosFreeModule(handle)
  52 #elif defined(HAVE_DLOPEN)
  53     // note about dlopen() flags: we use RTLD_NOW to have more Windows-like
  54     // behaviour (Win won't let you load a library with missing symbols) and
  55     // RTLD_GLOBAL because it is needed sometimes and probably doesn't hurt
  56     // otherwise
  57 #   define wxDllOpen(lib)                dlopen(lib.fn_str(), RTLD_LAZY | RTLD_GLOBAL)
  58 #   define wxDllGetSymbol(handle, name)  dlsym(handle, name)
  59 #   define wxDllClose                    dlclose
  60 #elif defined(HAVE_SHL_LOAD)
  61 #   define wxDllOpen(lib)                shl_load(lib.fn_str(), BIND_DEFERRED, 0)
  62 #   define wxDllClose                    shl_unload
  63
  64     static inline void *wxDllGetSymbol(shl_t handle, const wxString& name)
  65     {
  66         void *sym;
  67         if ( shl_findsym(&handle, name.mb_str(), TYPE_UNDEFINED, &sym) == 0 )
  68             return sym;
  69         else
  70             return (void *)0;
  71     }
  72 #elif defined(__WINDOWS__)
  73     // using LoadLibraryEx under Win32 to avoid name clash with LoadLibrary
  74 #   ifdef __WIN32__
  75 #ifdef _UNICODE
  76 #      define wxDllOpen(lib)                  ::LoadLibraryExW(lib, 0, 0)
  77 #else
  78 #      define wxDllOpen(lib)                  ::LoadLibraryExA(lib, 0, 0)
  79 #endif
  80 #   else   // Win16
  81 #      define wxDllOpen(lib)                  ::LoadLibrary(lib)
  82 #   endif  // Win32/16
  83 #   define wxDllGetSymbol(handle, name)    ::GetProcAddress(handle, name)
  84 #   define wxDllClose                      ::FreeLibrary
  85 #else
  86 #   error "Don't know how to load shared libraries on this platform."
  87 #endif // OS
  88
  89 // ---------------------------------------------------------------------------
  90 // Global variables
  91 // ---------------------------------------------------------------------------
  92
  93 wxLibraries wxTheLibraries;
  94
  95 // ============================================================================
  96 // implementation
  97 // ============================================================================
  98
  99 // construct the full name from the base shared object name: adds a .dll
 100 // suffix under Windows or .so under Unix
 101 static wxString ConstructLibraryName(const wxString& basename)
 102 {
 103     wxString fullname;
 104     fullname << basename << wxDllLoader::GetDllExt();
 105
 106     return fullname;
 107 }
 108
 109 // ---------------------------------------------------------------------------
 110 // wxLibrary (one instance per dynamic library)
 111 // ---------------------------------------------------------------------------
 112
 113 wxLibrary::wxLibrary(wxDllType handle)
 114 {
 115     typedef wxClassInfo *(*t_get_first)(void);
 116     t_get_first get_first;
 117
 118     m_handle = handle;
 119
 120     // Some system may use a local heap for library.
 121     get_first = (t_get_first)GetSymbol("wxGetClassFirst");
 122     // It is a wxWindows DLL.
 123     if (get_first)
 124         PrepareClasses(get_first());
 125 }
 126
 127 wxLibrary::~wxLibrary()
 128 {
 129     if ( m_handle )
 130     {
 131         wxDllClose(m_handle);
 132     }
 133 }
 134
 135 wxObject *wxLibrary::CreateObject(const wxString& name)
 136 {
 137     wxClassInfo *info = (wxClassInfo *)classTable.Get(name);
 138
 139     if (!info)
 140         return NULL;
 141
 142     return info->CreateObject();
 143 }
 144
 145 void wxLibrary::PrepareClasses(wxClassInfo *first)
 146 {
 147     // Index all class infos by their class name
 148     wxClassInfo *info = first;
 149     while (info)
 150     {
 151         if (info->m_className)
 152             classTable.Put(info->m_className, (wxObject *)info);
 153         info = info->GetNext();
 154     }
 155
 156     // Set base pointers for each wxClassInfo
 157     info = first;
 158     while (info)
 159     {
 160         if (info->GetBaseClassName1())
 161             info->m_baseInfo1 = (wxClassInfo *)classTable.Get(info->GetBaseClassName1());
 162         if (info->GetBaseClassName2())
 163             info->m_baseInfo2 = (wxClassInfo *)classTable.Get(info->GetBaseClassName2());
 164         info = info->m_next;
 165     }
 166 }
 167
 168 void *wxLibrary::GetSymbol(const wxString& symbname)
 169 {
 170    return wxDllLoader::GetSymbol(m_handle, symbname);
 171 }
 172
 173 // ---------------------------------------------------------------------------
 174 // wxDllLoader
 175 // ---------------------------------------------------------------------------
 176
 177 /* static */
 178 wxString wxDllLoader::GetDllExt()
 179 {
 180     wxString ext;
 181
 182 #if defined(__WINDOWS__) || defined(__WXPM__) || defined(__EMX__)
 183     ext = _T(".dll");
 184 #elif defined(__UNIX__)
 185 #   if defined(__HPUX__)
 186         ext = _T(".sl");
 187 #   else //__HPUX__
 188         ext = _T(".so");
 189 #   endif //__HPUX__
 190 #endif
 191
 192     return ext;
 193 }
 194
 195 /* static */
 196 wxDllType
 197 wxDllLoader::GetProgramHandle(void)
 198 {
 199 #if defined( HAVE_DLOPEN ) && !defined(__EMX__)
 200    // optain handle for main program
 201    return dlopen(NULL, RTLD_NOW/*RTLD_LAZY*/);
 202 #elif defined (HAVE_SHL_LOAD)
 203    // shl_findsymbol with NULL handle looks up in main program
 204    return 0;
 205 #else
 206    wxFAIL_MSG( wxT("This method is not implemented under Windows or OS/2"));
 207    return 0;
 208 #endif
 209 }
 210
 211 /* static */
 212 wxDllType
 213 wxDllLoader::LoadLibrary(const wxString & libname, bool *success)
 214 {
 215     wxDllType handle;
 216
 217 #if defined(__WXMAC__)
 218     FSSpec myFSSpec ;
 219     Ptr myMainAddr ;
 220     Str255 myErrName ;
 221
 222     wxMacPathToFSSpec( libname , &myFSSpec ) ;
 223     if (GetDiskFragment( &myFSSpec , 0 , kCFragGoesToEOF , "\p" , kPrivateCFragCopy , &handle , &myMainAddr ,
 224                 myErrName ) != noErr )
 225     {
 226         p2cstr( myErrName ) ;
 227         wxASSERT_MSG( 1 , (char*)myErrName ) ;
 228         return NULL ;
 229     }
 230 #elif defined(__WXPM__) || defined(__EMX__)
 231     char zError[256] = "";
 232     wxDllOpen(zError, libname, handle);
 233 #else // !Mac
 234     handle = wxDllOpen(libname);
 235 #endif // OS
 236
 237     if ( !handle )
 238     {
 239         wxString msg(_("Failed to load shared library '%s'"));
 240
 241 #ifdef HAVE_DLERROR
 242         const char *errmsg = dlerror();
 243         if ( errmsg )
 244         {
 245             // the error string format is "libname: ...", but we already have
 246             // libname, so cut it off
 247             const char *p = strchr(errmsg, ':');
 248             if ( p )
 249             {
 250                 if ( *++p == ' ' )
 251                     p++;
 252             }
 253             else
 254             {
 255                 p = errmsg;
 256             }
 257
 258             msg += _T(" (%s)");
 259             wxLogError(msg, libname.c_str(), p);
 260         }
 261         else
 262 #endif // HAVE_DLERROR
 263         {
 264             wxLogSysError(msg, libname.c_str());
 265         }
 266     }
 267
 268     if ( success )
 269     {
 270         *success = handle != 0;
 271     }
 272
 273     return handle;
 274 }
 275
 276
 277 /* static */
 278 void
 279 wxDllLoader::UnloadLibrary(wxDllType handle)
 280 {
 281    wxDllClose(handle);
 282 }
 283
 284 /* static */
 285 void *
 286 wxDllLoader::GetSymbol(wxDllType dllHandle, const wxString &name)
 287 {
 288     void *symbol = NULL;    // return value
 289
 290 #if defined( __WXMAC__ )
 291     Ptr symAddress ;
 292     CFragSymbolClass symClass ;
 293     Str255 symName ;
 294
 295     strcpy( (char*) symName , name ) ;
 296     c2pstr( (char*) symName ) ;
 297
 298     if ( FindSymbol( dllHandle , symName , &symAddress , &symClass ) == noErr )
 299         symbol = (void *)symAddress ;
 300 #elif defined( __WXPM__ ) || defined(__EMX__)
 301     wxDllGetSymbol(dllHandle, symbol);
 302 #else
 303     // mb_str() is necessary in Unicode build
 304     symbol = wxDllGetSymbol(dllHandle, name.mb_str());
 305 #endif
 306
 307     if ( !symbol )
 308     {
 309         wxLogSysError(_("Couldn't find symbol '%s' in a dynamic library"),
 310                       name.c_str());
 311     }
 312     return symbol;
 313 }
 314
 315 // ---------------------------------------------------------------------------
 316 // wxLibraries (only one instance should normally exist)
 317 // ---------------------------------------------------------------------------
 318
 319 wxLibraries::wxLibraries():m_loaded(wxKEY_STRING)
 320 {
 321 }
 322
 323 wxLibraries::~wxLibraries()
 324 {
 325     wxNode *node = m_loaded.First();
 326
 327     while (node) {
 328         wxLibrary *lib = (wxLibrary *)node->Data();
 329         delete lib;
 330
 331         node = node->Next();
 332     }
 333 }
 334
 335 wxLibrary *wxLibraries::LoadLibrary(const wxString& name)
 336 {
 337     wxNode *node;
 338     wxLibrary *lib;
 339     wxClassInfo *old_sm_first;
 340
 341 #if defined(__VISAGECPP__)
 342     node = m_loaded.Find(name.GetData());
 343     if (node != NULL)
 344         return ((wxLibrary *)node->Data());
 345 #else // !OS/2
 346     if ( (node = m_loaded.Find(name.GetData())) )
 347         return ((wxLibrary *)node->Data());
 348 #endif
 349     // If DLL shares data, this is necessary.
 350     old_sm_first = wxClassInfo::sm_first;
 351     wxClassInfo::sm_first = NULL;
 352
 353     wxString libname = ConstructLibraryName(name);
 354
 355 /*
 356   Unix automatically builds that library name, at least for dlopen()
 357 */
 358 #if 0
 359 #if defined(__UNIX__)
 360     // found the first file in LD_LIBRARY_PATH with this name
 361     wxString libPath("/lib:/usr/lib"); // system path first
 362     const char *envLibPath = getenv("LD_LIBRARY_PATH");
 363     if ( envLibPath )
 364         libPath << wxT(':') << envLibPath;
 365     wxStringTokenizer tokenizer(libPath, wxT(':'));
 366     while ( tokenizer.HasMoreToken() )
 367     {
 368         wxString fullname(tokenizer.NextToken());
 369
 370         fullname << wxT('/') << libname;
 371         if ( wxFileExists(fullname) )
 372         {
 373             libname = fullname;
 374
 375             // found the library
 376             break;
 377         }
 378     }
 379     //else: not found in the path, leave the name as is (secutiry risk?)
 380
 381 #endif // __UNIX__
 382 #endif
 383
 384     bool success = FALSE;
 385     wxDllType handle = wxDllLoader::LoadLibrary(libname, &success);
 386     if(success)
 387     {
 388        lib = new wxLibrary(handle);
 389        wxClassInfo::sm_first = old_sm_first;
 390        m_loaded.Append(name.GetData(), lib);
 391     }
 392     else
 393        lib = NULL;
 394     return lib;
 395 }
 396
 397 wxObject *wxLibraries::CreateObject(const wxString& path)
 398 {
 399     wxNode *node = m_loaded.First();
 400     wxObject *obj;
 401
 402     while (node) {
 403         obj = ((wxLibrary *)node->Data())->CreateObject(path);
 404         if (obj)
 405             return obj;
 406
 407         node = node->Next();
 408     }
 409     return NULL;
 410 }
 411
 412 #endif // wxUSE_DYNLIB_CLASS