src/dynlib.c

   1 /* Portable API for dynamic loading.
   2
   3 Copyright 2015-2018 Free Software Foundation, Inc.
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software: you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation, either version 3 of the License, or (at
  10 your option) any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
  19
  20
  21 /* Assume modules are enabled on modern systems...  *Yes*, the
  22    preprocessor macro checks could be more precise.  I don't care.
  23
  24    If you think the abstraction is too leaky use libltdl (libtool),
  25    don't reinvent the wheel by fixing this one.  */
  26
  27 #include <config.h>
  28
  29 #include "dynlib.h"
  30
  31 #include <stddef.h>
  32
  33 #ifdef WINDOWSNT
  34
  35 /* MS-Windows systems.  */
  36
  37 #include <errno.h>
  38 #include "lisp.h"
  39 #include "w32common.h"  /* for os_subtype */
  40 #include "w32.h"
  41
  42 static BOOL g_b_init_get_module_handle_ex;
  43 static DWORD dynlib_last_err;
  44
  45 /* Some versions of w32api headers only expose the following when
  46    _WIN32_WINNT is set to higher values that we use.  */
  47 typedef BOOL (WINAPI *GetModuleHandleExA_Proc) (DWORD,LPCSTR,HMODULE*);
  48 #ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
  49 # define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS 4
  50 #endif
  51 #ifndef GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT
  52 # define GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT 2
  53 #endif
  54
  55 /* This needs to be called at startup to countermand any non-zero
  56    values recorded by temacs.  */
  57 void dynlib_reset_last_error (void);
  58 void
  59 dynlib_reset_last_error (void)
  60 {
  61   g_b_init_get_module_handle_ex = 0;
  62   dynlib_last_err = 0;
  63 }
  64
  65 dynlib_handle_ptr
  66 dynlib_open (const char *dll_fname)
  67 {
  68   HMODULE hdll;
  69   char dll_fname_local[MAX_UTF8_PATH];
  70
  71   if (!dll_fname)
  72     {
  73       errno = ENOTSUP;
  74       return NULL;
  75     }
  76
  77   if (!dll_fname)
  78     hdll = GetModuleHandle (NULL);
  79   else
  80     {
  81       /* LoadLibrary wants backslashes.  */
  82       strcpy (dll_fname_local, dll_fname);
  83       unixtodos_filename (dll_fname_local);
  84
  85       if (w32_unicode_filenames)
  86         {
  87           wchar_t dll_fname_w[MAX_PATH];
  88
  89           filename_to_utf16 (dll_fname_local, dll_fname_w);
  90           hdll = LoadLibraryW (dll_fname_w);
  91         }
  92       else
  93         {
  94           char dll_fname_a[MAX_PATH];
  95
  96           filename_to_ansi (dll_fname_local, dll_fname_a);
  97           hdll = LoadLibraryA (dll_fname_a);
  98         }
  99     }
 100
 101   if (!hdll)
 102     dynlib_last_err = GetLastError ();
 103
 104   return (dynlib_handle_ptr) hdll;
 105 }
 106
 107 void *
 108 dynlib_sym (dynlib_handle_ptr h, const char *sym)
 109 {
 110   FARPROC sym_addr = NULL;
 111
 112   if (!h || h == INVALID_HANDLE_VALUE || !sym)
 113     {
 114       dynlib_last_err = ERROR_INVALID_PARAMETER;
 115       return NULL;
 116     }
 117
 118   sym_addr = GetProcAddress ((HMODULE) h, sym);
 119   if (!sym_addr)
 120     dynlib_last_err = GetLastError ();
 121
 122   return (void *)sym_addr;
 123 }
 124
 125 void
 126 dynlib_addr (void *addr, const char **fname, const char **symname)
 127 {
 128   static char dll_filename[MAX_UTF8_PATH];
 129   static GetModuleHandleExA_Proc s_pfn_Get_Module_HandleExA = NULL;
 130   char *dll_fn = NULL;
 131   HMODULE hm_kernel32 = NULL;
 132   HMODULE hm_dll = NULL;
 133   wchar_t mfn_w[MAX_PATH];
 134   char mfn_a[MAX_PATH];
 135
 136   /* Step 1: Find the handle of the module where ADDR lives.  */
 137   if (os_subtype == OS_9X
 138       /* Windows NT family version before XP (v5.1).  */
 139       || ((w32_major_version + (w32_minor_version > 0)) < 6))
 140     {
 141       MEMORY_BASIC_INFORMATION mbi;
 142
 143       /* According to Matt Pietrek, the module handle is just the base
 144          address where it's loaded in memory.  */
 145       if (VirtualQuery (addr, &mbi, sizeof(mbi)))
 146         hm_dll = (HMODULE)mbi.AllocationBase;
 147     }
 148   else
 149     {
 150       /* Use the documented API when available (XP and later).  */
 151       if (g_b_init_get_module_handle_ex == 0)
 152         {
 153           g_b_init_get_module_handle_ex = 1;
 154           hm_kernel32 = LoadLibrary ("kernel32.dll");
 155           /* We load the ANSI version of the function because the
 156              address we pass to it is not an address of a string, but
 157              an address of a function.  So we don't care about the
 158              Unicode version.  */
 159           s_pfn_Get_Module_HandleExA =
 160             (GetModuleHandleExA_Proc) GetProcAddress (hm_kernel32,
 161                                                       "GetModuleHandleExA");
 162         }
 163       if (s_pfn_Get_Module_HandleExA)
 164         {
 165           DWORD flags = (GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
 166                          /* We don't want to call FreeLibrary at the
 167                             end, because then we'd need to remember
 168                             whether we obtained the handle by this
 169                             method or the above one.  */
 170                          | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT);
 171
 172           if (!s_pfn_Get_Module_HandleExA (flags, addr, &hm_dll))
 173             {
 174               dynlib_last_err = GetLastError ();
 175               hm_dll = NULL;
 176             }
 177         }
 178     }
 179
 180   /* Step 2: Find the absolute file name of the module corresponding
 181      to the hm_dll handle.  */
 182   if (hm_dll)
 183     {
 184       DWORD retval;
 185
 186       if (w32_unicode_filenames)
 187         {
 188           retval = GetModuleFileNameW (hm_dll, mfn_w, MAX_PATH);
 189           if (retval > 0 && retval < MAX_PATH
 190               && filename_from_utf16 (mfn_w, dll_filename) == 0)
 191             dll_fn = dll_filename;
 192           else if (retval == MAX_PATH)
 193             dynlib_last_err = ERROR_INSUFFICIENT_BUFFER;
 194           else
 195             dynlib_last_err = GetLastError ();
 196         }
 197       else
 198         {
 199           retval = GetModuleFileNameA (hm_dll, mfn_a, MAX_PATH);
 200           if (retval > 0 && retval < MAX_PATH
 201               && filename_from_ansi (mfn_a, dll_filename) == 0)
 202             dll_fn = dll_filename;
 203           else if (retval == MAX_PATH)
 204             dynlib_last_err = ERROR_INSUFFICIENT_BUFFER;
 205           else
 206             dynlib_last_err = GetLastError ();
 207         }
 208       if (dll_fn)
 209         dostounix_filename (dll_fn);
 210     }
 211
 212   *fname = dll_fn;
 213
 214   /* We cannot easily produce the function name, since typically all
 215      of the module functions will be unexported, and probably even
 216      static, which means the symbols can be obtained only if we link
 217      against libbfd (and the DLL can be stripped anyway).  So we just
 218      show the address and the file name (see print_vectorlike in
 219      print.c); they can use that with addr2line or GDB to recover the
 220      symbolic name.  */
 221   *symname = NULL;
 222 }
 223
 224 const char *
 225 dynlib_error (void)
 226 {
 227   char *error_string = NULL;
 228
 229   if (dynlib_last_err)
 230     {
 231       error_string = w32_strerror (dynlib_last_err);
 232       dynlib_last_err = 0;
 233     }
 234
 235   return error_string;
 236 }
 237
 238 int
 239 dynlib_close (dynlib_handle_ptr h)
 240 {
 241   if (!h || h == INVALID_HANDLE_VALUE)
 242     {
 243       dynlib_last_err = ERROR_INVALID_PARAMETER;
 244       return -1;
 245     }
 246   /* If the handle is for the main module (the .exe file), it
 247      shouldn't be passed to FreeLibrary, because GetModuleHandle
 248      doesn't increment the refcount, but FreeLibrary does decrement
 249      it.  I don't think this should matter for the main module, but
 250      just in case, we avoid the call here, relying on another call to
 251      GetModuleHandle to return the same value.  */
 252   if (h == GetModuleHandle (NULL))
 253     return 0;
 254
 255   if (!FreeLibrary ((HMODULE) h))
 256     {
 257       dynlib_last_err = GetLastError ();
 258       return -1;
 259     }
 260
 261   return 0;
 262 }
 263
 264 #elif defined HAVE_UNISTD_H
 265
 266 /* POSIX systems.  */
 267
 268 #include <dlfcn.h>
 269
 270 dynlib_handle_ptr
 271 dynlib_open (const char *path)
 272 {
 273   return dlopen (path, RTLD_LAZY);
 274 }
 275
 276 void *
 277 dynlib_sym (dynlib_handle_ptr h, const char *sym)
 278 {
 279   return dlsym (h, sym);
 280 }
 281
 282 void
 283 dynlib_addr (void *ptr, const char **path, const char **sym)
 284 {
 285   *path = NULL;
 286   *sym = NULL;
 287 #ifdef HAVE_DLADDR
 288   Dl_info info;
 289   if (dladdr (ptr, &info) && info.dli_fname && info.dli_sname)
 290     {
 291       *path = info.dli_fname;
 292       *sym = info.dli_sname;
 293     }
 294 #endif
 295 }
 296
 297 const char *
 298 dynlib_error (void)
 299 {
 300   return dlerror ();
 301 }
 302
 303 /* FIXME: Currently there is no way to unload a module, so this
 304    function is never used.  */
 305 #if false
 306 int
 307 dynlib_close (dynlib_handle_ptr h)
 308 {
 309   return dlclose (h) == 0;
 310 }
 311 #endif
 312
 313 #else
 314
 315 #error "No dynamic loading for this system"
 316
 317 #endif
 318
 319 #if !HAVE_DLFUNC
 320 # define dlfunc dynlib_sym
 321 #endif
 322
 323 dynlib_function_ptr
 324 dynlib_func (dynlib_handle_ptr h, const char *sym)
 325 {
 326   return (dynlib_function_ptr) dlfunc (h, sym);
 327 }