X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/d8e342b79ef4e77130afc92b6121fd691cb289bd..6ba718d7aee2f519d9146b90424ccec9e2243479:/src/unix/dlunix.cpp

diff --git a/src/unix/dlunix.cpp b/src/unix/dlunix.cpp
index fcad9a5671..881ea77687 100644
--- a/src/unix/dlunix.cpp
+++ b/src/unix/dlunix.cpp
@@ -1,10 +1,9 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        unix/dlunix.cpp
+// Name:        src/unix/dlunix.cpp
 // Purpose:     Unix-specific part of wxDynamicLibrary and related classes
 // Author:      Vadim Zeitlin
 // Modified by:
 // Created:     2005-01-16 (extracted from common/dynlib.cpp)
-// RCS-ID:      $Id$
 // Copyright:   (c) 2000-2005 Vadim Zeitlin <vadim@wxwindows.org>
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
@@ -33,10 +32,28 @@
     #include "wx/log.h"
 #endif
 
-#if defined(__DARWIN__)
+#ifdef HAVE_DLOPEN
     #include <dlfcn.h>
 #endif
 
+#ifdef __DARWIN__
+    #include <AvailabilityMacros.h>
+#endif
+
+// if some flags are not supported, just ignore them
+#ifndef RTLD_LAZY
+    #define RTLD_LAZY 0
+#endif
+
+#ifndef RTLD_NOW
+    #define RTLD_NOW 0
+#endif
+
+#ifndef RTLD_GLOBAL
+    #define RTLD_GLOBAL 0
+#endif
+
+
 #if defined(HAVE_DLOPEN) || defined(__DARWIN__)
     #define USE_POSIX_DL_FUNCS
 #elif !defined(HAVE_SHL_LOAD)
@@ -47,24 +64,16 @@
 // constants
 // ----------------------------------------------------------------------------
 
-// standard shared libraries extensions for different Unix versions
-#if defined(__HPUX__)
-    const wxChar *wxDynamicLibrary::ms_dllext = _T(".sl");
-#elif defined(__DARWIN__)
-    const wxChar *wxDynamicLibrary::ms_dllext = _T(".bundle");
-#else
-    const wxChar *wxDynamicLibrary::ms_dllext = _T(".so");
-#endif
-
 // ============================================================================
 // wxDynamicLibrary implementation
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 // dlxxx() emulation for Darwin
+// Only useful if the OS X version could be < 10.3 at runtime
 // ----------------------------------------------------------------------------
 
-#if defined(__DARWIN__)
+#if defined(__DARWIN__) && (MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_3)
 // ---------------------------------------------------------------------------
 // For Darwin/Mac OS X
 //   supply the sun style dlopen functions in terms of Darwin NS*
@@ -82,43 +91,39 @@
 
 static char dl_last_error[1024];
 
-static
-void TranslateError(const char *path, int number)
-{
-    unsigned int index;
-    static char *OFIErrorStrings[] =
-    {
-        "%s(%d): Object Image Load Failure\n",
-        "%s(%d): Object Image Load Success\n",
-        "%s(%d): Not an recognisable object file\n",
-        "%s(%d): No valid architecture\n",
-        "%s(%d): Object image has an invalid format\n",
-        "%s(%d): Invalid access (permissions?)\n",
-        "%s(%d): Unknown error code from NSCreateObjectFileImageFromFile\n",
-    };
-#define NUM_OFI_ERRORS (sizeof(OFIErrorStrings) / sizeof(OFIErrorStrings[0]))
-
-    index = number;
-    if (index > NUM_OFI_ERRORS - 1) {
-        index = NUM_OFI_ERRORS - 1;
-    }
-    sprintf(dl_last_error, OFIErrorStrings[index], path, number);
-}
-
-const char *dlerror()
+static const char *wx_darwin_dlerror()
 {
     return dl_last_error;
 }
 
-void *dlopen(const char *path, int WXUNUSED(mode) /* mode is ignored */)
+static void *wx_darwin_dlopen(const char *path, int WXUNUSED(mode) /* mode is ignored */)
 {
     NSObjectFileImage ofile;
     NSModule handle = NULL;
 
-    int dyld_result = NSCreateObjectFileImageFromFile(path, &ofile);
+    unsigned dyld_result = NSCreateObjectFileImageFromFile(path, &ofile);
     if ( dyld_result != NSObjectFileImageSuccess )
     {
         handle = NULL;
+
+        static const char *const errorStrings[] =
+        {
+            "%d: Object Image Load Failure",
+            "%d: Object Image Load Success",
+            "%d: Not an recognisable object file",
+            "%d: No valid architecture",
+            "%d: Object image has an invalid format",
+            "%d: Invalid access (permissions?)",
+            "%d: Unknown error code from NSCreateObjectFileImageFromFile"
+        };
+
+        const int index = dyld_result < WXSIZEOF(errorStrings)
+                            ? dyld_result
+                            : WXSIZEOF(errorStrings) - 1;
+
+        // this call to sprintf() is safe as strings above are fixed at
+        // compile-time and are shorter than WXSIZEOF(dl_last_error)
+        sprintf(dl_last_error, errorStrings[index], dyld_result);
     }
     else
     {
@@ -129,21 +134,31 @@ void *dlopen(const char *path, int WXUNUSED(mode) /* mode is ignored */)
                     NSLINKMODULE_OPTION_BINDNOW |
                     NSLINKMODULE_OPTION_RETURN_ON_ERROR
                  );
+
+        if ( !handle )
+        {
+            NSLinkEditErrors err;
+            int code;
+            const char *filename;
+            const char *errmsg;
+
+            NSLinkEditError(&err, &code, &filename, &errmsg);
+            strncpy(dl_last_error, errmsg, WXSIZEOF(dl_last_error)-1);
+            dl_last_error[WXSIZEOF(dl_last_error)-1] = '\0';
+        }
     }
 
-    if ( !handle )
-        TranslateError(path, dyld_result);
 
     return handle;
 }
 
-int dlclose(void *handle)
+static int wx_darwin_dlclose(void *handle)
 {
-    NSUnLinkModule( handle, NSUNLINKMODULE_OPTION_NONE);
+    NSUnLinkModule((NSModule)handle, NSUNLINKMODULE_OPTION_NONE);
     return 0;
 }
 
-void *dlsym(void *handle, const char *symbol)
+static void *wx_darwin_dlsym(void *handle, const char *symbol)
 {
     // as on many other systems, C symbols have prepended underscores under
     // Darwin but unlike the normal dlopen(), NSLookupSymbolInModule() is not
@@ -153,10 +168,65 @@ void *dlsym(void *handle, const char *symbol)
     p[0] = '_';
     strcpy(p + 1, symbol);
 
-    NSSymbol nsSymbol = NSLookupSymbolInModule( handle, p );
+    NSSymbol nsSymbol = NSLookupSymbolInModule((NSModule)handle, p );
     return nsSymbol ? NSAddressOfSymbol(nsSymbol) : NULL;
 }
 
+// Add the weak linking attribute to dlopen's declaration
+extern void * dlopen(const char * __path, int __mode) AVAILABLE_MAC_OS_X_VERSION_10_3_AND_LATER;
+
+// For all of these methods we test dlopen since all of the dl functions we use were added
+// to OS X at the same time.  This also ensures we don't dlopen with the real function then
+// dlclose with the internal implementation.
+
+static inline void *wx_dlopen(const char *__path, int __mode)
+{
+#ifdef HAVE_DLOPEN
+    if(&dlopen != NULL)
+        return dlopen(__path, __mode);
+    else
+#endif
+        return wx_darwin_dlopen(__path, __mode);
+}
+
+static inline int wx_dlclose(void *__handle)
+{
+#ifdef HAVE_DLOPEN
+    if(&dlopen != NULL)
+        return dlclose(__handle);
+    else
+#endif
+        return wx_darwin_dlclose(__handle);
+}
+
+static inline const char *wx_dlerror()
+{
+#ifdef HAVE_DLOPEN
+    if(&dlopen != NULL)
+        return dlerror();
+    else
+#endif
+        return wx_darwin_dlerror();
+}
+
+static inline void *wx_dlsym(void *__handle, const char *__symbol)
+{
+#ifdef HAVE_DLOPEN
+    if(&dlopen != NULL)
+        return dlsym(__handle, __symbol);
+    else
+#endif
+        return wx_darwin_dlsym(__handle, __symbol);
+}
+
+#else // __DARWIN__/!__DARWIN__
+
+// Use preprocessor definitions for non-Darwin or OS X >= 10.3
+#define wx_dlopen(__path,__mode) dlopen(__path,__mode)
+#define wx_dlclose(__handle) dlclose(__handle)
+#define wx_dlerror() dlerror()
+#define wx_dlsym(__handle,__symbol) dlsym(__handle,__symbol)
+
 #endif // defined(__DARWIN__)
 
 // ----------------------------------------------------------------------------
@@ -166,7 +236,7 @@ void *dlsym(void *handle, const char *symbol)
 wxDllType wxDynamicLibrary::GetProgramHandle()
 {
 #ifdef USE_POSIX_DL_FUNCS
-   return dlopen(0, RTLD_LAZY);
+   return wx_dlopen(0, RTLD_LAZY);
 #else
    return PROG_HANDLE;
 #endif
@@ -175,32 +245,19 @@ wxDllType wxDynamicLibrary::GetProgramHandle()
 /* static */
 wxDllType wxDynamicLibrary::RawLoad(const wxString& libname, int flags)
 {
-    wxASSERT_MSG( (flags & wxDL_NOW) == 0,
-                  _T("wxDL_LAZY and wxDL_NOW are mutually exclusive.") );
+    wxASSERT_MSG( !(flags & wxDL_NOW) || !(flags & wxDL_LAZY),
+                  wxT("wxDL_LAZY and wxDL_NOW are mutually exclusive.") );
 
 #ifdef USE_POSIX_DL_FUNCS
-    int rtldFlags = 0;
+    // we need to use either RTLD_NOW or RTLD_LAZY because if we call dlopen()
+    // with flags == 0 recent versions of glibc just fail the call, so use
+    // RTLD_NOW even if wxDL_NOW was not specified
+    int rtldFlags = flags & wxDL_LAZY ? RTLD_LAZY : RTLD_NOW;
 
-#ifdef RTLD_LAZY
-    if ( flags & wxDL_LAZY )
-    {
-        rtldFlags |= RTLD_LAZY;
-    }
-#endif
-#ifdef RTLD_NOW
-    if ( flags & wxDL_NOW )
-    {
-        rtldFlags |= RTLD_NOW;
-    }
-#endif
-#ifdef RTLD_GLOBAL
     if ( flags & wxDL_GLOBAL )
-    {
         rtldFlags |= RTLD_GLOBAL;
-    }
-#endif
 
-    return dlopen(libname.fn_str(), rtldFlags);
+    return wx_dlopen(libname.fn_str(), rtldFlags);
 #else // !USE_POSIX_DL_FUNCS
     int shlFlags = 0;
 
@@ -225,7 +282,7 @@ void wxDynamicLibrary::Unload(wxDllType handle)
 #endif
 
 #ifdef USE_POSIX_DL_FUNCS
-    dlclose(handle);
+    wx_dlclose(handle);
 #else // !USE_POSIX_DL_FUNCS
     shl_unload(handle);
 #endif // USE_POSIX_DL_FUNCS/!USE_POSIX_DL_FUNCS
@@ -242,7 +299,7 @@ void *wxDynamicLibrary::RawGetSymbol(wxDllType handle, const wxString& name)
     void *symbol;
 
 #ifdef USE_POSIX_DL_FUNCS
-    symbol = dlsym(handle, name.fn_str());
+    symbol = wx_dlsym(handle, name.fn_str());
 #else // !USE_POSIX_DL_FUNCS
     // note that shl_findsym modifies the handle argument to indicate where the
     // symbol was found, but it's ok to modify the local handle copy here
@@ -262,14 +319,12 @@ void *wxDynamicLibrary::RawGetSymbol(wxDllType handle, const wxString& name)
 /* static */
 void wxDynamicLibrary::Error()
 {
-#if wxUSE_UNICODE
-    wxWCharBuffer buffer = wxConvLocal.cMB2WC( dlerror() );
-    const wxChar *err = buffer;
-#else
-    const wxChar *err = dlerror();
-#endif
+    wxString err(wx_dlerror());
+
+    if ( err.empty() )
+        err = _("Unknown dynamic library error");
 
-    wxLogError(wxT("%s"), err ? err : _("Unknown dynamic library error"));
+    wxLogError(wxT("%s"), err);
 }
 
 #endif // wxHAVE_DYNLIB_ERROR
@@ -285,26 +340,26 @@ class wxDynamicLibraryDetailsCreator
 public:
     // create a new wxDynamicLibraryDetails from the given data
     static wxDynamicLibraryDetails *
-    New(unsigned long start, unsigned long end, const wxString& path)
+    New(void *start, void *end, const wxString& path)
     {
         wxDynamicLibraryDetails *details = new wxDynamicLibraryDetails;
         details->m_path = path;
-        details->m_name = path.AfterLast(_T('/'));
-        details->m_address = wx_reinterpret_cast(void *, start);
-        details->m_length = end - start;
+        details->m_name = path.AfterLast(wxT('/'));
+        details->m_address = start;
+        details->m_length = (char *)end - (char *)start;
 
         // try to extract the library version from its name
-        const size_t posExt = path.rfind(_T(".so"));
+        const size_t posExt = path.rfind(wxT(".so"));
         if ( posExt != wxString::npos )
         {
-            if ( path.c_str()[posExt + 3] == _T('.') )
+            if ( path.c_str()[posExt + 3] == wxT('.') )
             {
                 // assume "libfoo.so.x.y.z" case
                 details->m_version.assign(path, posExt + 4, wxString::npos);
             }
             else
             {
-                size_t posDash = path.find_last_of(_T('-'), posExt);
+                size_t posDash = path.find_last_of(wxT('-'), posExt);
                 if ( posDash != wxString::npos )
                 {
                     // assume "libbar-x.y.z.so" case
@@ -325,21 +380,22 @@ wxDynamicLibraryDetailsArray wxDynamicLibrary::ListLoaded()
 
 #ifdef __LINUX__
     // examine /proc/self/maps to find out what is loaded in our address space
-    wxFFile file("/proc/self/maps");
+    wxFFile file(wxT("/proc/self/maps"));
     if ( file.IsOpened() )
     {
         // details of the module currently being parsed
         wxString pathCur;
-        unsigned long startCur,
-                      endCur;
+        void *startCur = NULL,
+             *endCur = NULL;
 
         char path[1024];
         char buf[1024];
         while ( fgets(buf, WXSIZEOF(buf), file.fp()) )
         {
-            // format is: start-end perm something? maj:min inode path
-            unsigned long start, end;
-            switch ( sscanf(buf, "%08lx-%08lx %*4s %*08x %*02d:%*02d %*d %1024s\n",
+            // format is: "start-end perm offset maj:min inode path", see proc(5)
+            void *start,
+                 *end;
+            switch ( sscanf(buf, "%p-%p %*4s %*p %*02x:%*02x %*d %1024s\n",
                             &start, &end, path) )
             {
                 case 2:
@@ -354,11 +410,14 @@ wxDynamicLibraryDetailsArray wxDynamicLibrary::ListLoaded()
                 default:
                     // chop '\n'
                     buf[strlen(buf) - 1] = '\0';
-                    wxLogDebug(_T("Failed to parse line \"%s\" in /proc/self/maps."),
+                    wxLogDebug(wxT("Failed to parse line \"%s\" in /proc/self/maps."),
                                buf);
                     continue;
             }
 
+            wxASSERT_MSG( start >= endCur,
+                          wxT("overlapping regions in /proc/self/maps?") );
+
             wxString pathNew = wxString::FromAscii(path);
             if ( pathCur.empty() )
             {
@@ -367,10 +426,9 @@ wxDynamicLibraryDetailsArray wxDynamicLibrary::ListLoaded()
                 startCur = start;
                 endCur = end;
             }
-            else if ( pathCur == pathNew )
+            else if ( pathCur == pathNew && endCur == end )
             {
-                // continuation of the same module
-                wxASSERT_MSG( start == endCur, _T("hole in /proc/self/maps?") );
+                // continuation of the same module in the address space
                 endCur = end;
             }
             else // end of the current module