ACE/ace/OS_NS_dlfcn.inl

   1 // -*- C++ -*-
   2 #include "ace/OS_NS_macros.h"
   3 #include "ace/OS_NS_errno.h"
   4 #include "ace/OS_NS_fcntl.h"
   5 #include "ace/OS_NS_string.h"
   6 #include "ace/OS_NS_unistd.h"
   7 #include "ace/Default_Constants.h"
   8 #include "ace/os_include/os_fcntl.h"
   9 #include "ace/os_include/os_string.h"
  10
  11 #if defined (ACE_USES_ASM_SYMBOL_IN_DLSYM)
  12 #  include "ace/OS_Memory.h"
  13 #  include "ace/OS_NS_string.h"
  14 #endif /* ACE_USES_ASM_SYMBOL_IN_DLSYM */
  15
  16 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  17
  18 ACE_INLINE int
  19 ACE_OS::dlclose (ACE_SHLIB_HANDLE handle)
  20 {
  21   ACE_OS_TRACE ("ACE_OS::dlclose");
  22 #if defined (ACE_LACKS_DLCLOSE)
  23   ACE_UNUSED_ARG (handle);
  24   return 0;
  25 #elif defined (ACE_HAS_SVR4_DYNAMIC_LINKING)
  26
  27 # if !defined (ACE_HAS_AUTOMATIC_INIT_FINI)
  28   // SunOS4 does not automatically call _fini()!
  29   void *ptr;
  30
  31   ACE_OSCALL (::dlsym (handle, ACE_TEXT ("_fini")), void *, ptr);
  32
  33   if (ptr != 0)
  34     (*((int (*)(void)) ptr)) (); // Call _fini hook explicitly.
  35 # endif /* ACE_HAS_AUTOMATIC_INIT_FINI */
  36   return ::dlclose (handle);
  37 #elif defined (ACE_WIN32)
  38   ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::FreeLibrary (handle), ace_result_), int, -1);
  39 #else
  40   ACE_UNUSED_ARG (handle);
  41   ACE_NOTSUP_RETURN (-1);
  42 #endif /* ACE_HAS_SVR4_DYNAMIC_LINKING */
  43 }
  44
  45 ACE_INLINE ACE_TCHAR *
  46 ACE_OS::dlerror ()
  47 {
  48   ACE_OS_TRACE ("ACE_OS::dlerror");
  49 # if defined (ACE_HAS_SVR4_DYNAMIC_LINKING)
  50   const char *err = 0;
  51   ACE_OSCALL (::dlerror (), const char *, err);
  52   if (err == 0)
  53     return 0;
  54 #   if defined (ACE_USES_WCHAR)
  55   const size_t BufLen = 256;
  56   static wchar_t buf[BufLen];
  57   ACE_OS::strncpy (buf, ACE_TEXT_CHAR_TO_TCHAR (err), BufLen);
  58   return buf;
  59 #   else
  60   return const_cast <char *> (err);
  61 #   endif /* ACE_USES_WCHAR */
  62 # elif defined (ACE_VXWORKS)
  63   //FUZZ: disable check_for_lack_ACE_OS
  64   return ::strerror(errno);
  65   //FUZZ: enable check_for_lack_ACE_OS
  66 # elif defined (ACE_WIN32)
  67   static ACE_TCHAR buf[128];
  68   ACE_TEXT_FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM,
  69                           0,
  70                           ::GetLastError (),
  71                           0,
  72                           buf,
  73                           sizeof buf / sizeof buf[0],
  74                           0);
  75   return buf;
  76 # else
  77   ACE_NOTSUP_RETURN (0);
  78 # endif /* ACE_HAS_SVR4_DYNAMIC_LINKING */
  79 }
  80
  81 ACE_INLINE ACE_SHLIB_HANDLE
  82 ACE_OS::dlopen (const ACE_TCHAR *fname,
  83                 int mode)
  84 {
  85   ACE_OS_TRACE ("ACE_OS::dlopen");
  86
  87 # if defined (ACE_HAS_SVR4_DYNAMIC_LINKING)
  88   void *handle;
  89   ACE_OSCALL (::dlopen (ACE_TEXT_ALWAYS_CHAR (fname), mode), void *, handle);
  90 #   if !defined (ACE_HAS_AUTOMATIC_INIT_FINI)
  91   if (handle != 0)
  92     {
  93       void *ptr;
  94       // Some systems (e.g., SunOS4) do not automatically call _init(), so
  95       // we'll have to call it manually.
  96
  97       ACE_OSCALL (::dlsym (handle, ACE_TEXT ("_init")), void *, ptr);
  98
  99       if (ptr != 0 && (*((int (*)(void)) ptr)) () == -1) // Call _init hook explicitly.
 100         {
 101           // Close down the handle to prevent leaks.
 102           ::dlclose (handle);
 103           return 0;
 104         }
 105     }
 106 #   endif /* ACE_HAS_AUTOMATIC_INIT_FINI */
 107   return handle;
 108 # elif defined (ACE_WIN32)
 109   ACE_UNUSED_ARG (mode);
 110
 111   ACE_WIN32CALL_RETURN (ACE_TEXT_LoadLibrary (fname), ACE_SHLIB_HANDLE, 0);
 112 # elif defined (ACE_VXWORKS) && !defined (__RTP__)
 113   ACE_UNUSED_ARG (mode);
 114   MODULE* handle = 0;
 115   // Open readonly
 116   ACE_HANDLE filehandle = ACE_OS::open (fname,
 117                                         O_RDONLY,
 118                                         ACE_DEFAULT_FILE_PERMS);
 119
 120   if (filehandle != ACE_INVALID_HANDLE)
 121     {
 122       ACE_OS::last_error(0);
 123       ACE_OSCALL ( ::loadModule (filehandle, LOAD_GLOBAL_SYMBOLS|LOAD_COMMON_MATCH_ALL ), MODULE *, handle);
 124       int loaderror = ACE_OS::last_error();
 125       ACE_OS::close (filehandle);
 126
 127       if ( (loaderror != 0) && (handle != 0) )
 128         {
 129           // ouch something went wrong most likely unresolved externals
 130           if (handle)
 131             ::unldByModuleId ( handle, 0 );
 132           handle = 0;
 133         }
 134     }
 135   else
 136     {
 137       // couldn't open file
 138       handle = 0;
 139     }
 140   return handle;
 141 # else
 142   ACE_UNUSED_ARG (fname);
 143   ACE_UNUSED_ARG (mode);
 144   ACE_NOTSUP_RETURN (0);
 145 # endif /* ACE_HAS_SVR4_DYNAMIC_LINKING */
 146 }
 147
 148 ACE_INLINE void *
 149 ACE_OS::dlsym (ACE_SHLIB_HANDLE handle,
 150                const ACE_TCHAR *sname)
 151 {
 152   ACE_OS_TRACE ("ACE_OS::dlsym");
 153
 154   // Check if the handle is valid before making any calls using it.
 155   if (handle == ACE_SHLIB_INVALID_HANDLE)
 156     return nullptr;
 157
 158   // Get the correct OS type.
 159 #if defined (ACE_USES_WCHAR)
 160   ACE_Wide_To_Ascii w_sname (sname);
 161   char *symbolname = w_sname.char_rep ();
 162 #elif defined (ACE_VXWORKS)
 163   char *symbolname = const_cast<char *> (sname);
 164 #else
 165   const char *symbolname = sname;
 166 #endif /* ACE_USES_WCHAR */
 167
 168 # if defined (ACE_HAS_SVR4_DYNAMIC_LINKING)
 169
 170 #   if defined (ACE_USES_ASM_SYMBOL_IN_DLSYM)
 171   int const l = ACE_OS::strlen (symbolname) + 2;
 172   char *asm_symbolname {};
 173   ACE_NEW_RETURN (asm_symbolname, char[l], 0);
 174   ACE_OS::strcpy (asm_symbolname, "_") ;
 175   ACE_OS::strcpy (asm_symbolname + 1, symbolname) ;
 176   void *ace_result;
 177   ACE_OSCALL (::dlsym (handle, asm_symbolname), void *, ace_result);
 178   delete [] asm_symbolname;
 179   return ace_result;
 180 #   else
 181   return ::dlsym (handle, symbolname);
 182 #   endif /* ACE_USES_ASM_SYMBOL_IN_DLSYM */
 183 # elif defined (ACE_WIN32)
 184   ACE_WIN32CALL_RETURN (::GetProcAddress (handle, symbolname), void *, 0);
 185 # elif defined (ACE_VXWORKS) && !defined (__RTP__)
 186   // For now we use the VxWorks global symbol table
 187   // which resolves the most recently loaded symbols, which resolve
 188   // mostly what we want..
 189   ACE_UNUSED_ARG (handle);
 190 #if (ACE_VXWORKS < 0x690)
 191   SYM_TYPE symtype;
 192   char *value = 0;
 193   STATUS status;
 194   ACE_OSCALL (::symFindByName(sysSymTbl, symbolname, &value, &symtype), int, status);
 195
 196   return status == OK ? reinterpret_cast <void*>(value) : nullptr;
 197 #else
 198   STATUS status;
 199
 200   SYMBOL_DESC symbolDesc;     /* symFind() descriptor */
 201   ACE_OS::memset (&symbolDesc, 0, sizeof (SYMBOL_DESC));
 202   symbolDesc.mask = SYM_FIND_BY_NAME;
 203   symbolDesc.name = symbolname;
 204
 205   ACE_OSCALL (::symFind(sysSymTbl, &symbolDesc), int, status);
 206
 207   return status == OK ? reinterpret_cast <void*>(symbolDesc.value) : nullptr;
 208 #endif /* (ACE_VXWORKS < 0x690) */
 209
 210 # else
 211   ACE_UNUSED_ARG (handle);
 212   ACE_UNUSED_ARG (symbolname);
 213   ACE_NOTSUP_RETURN (nullptr);
 214 # endif /* ACE_HAS_SVR4_DYNAMIC_LINKING */
 215 }
 216
 217 ACE_END_VERSIONED_NAMESPACE_DECL