src/lj_clib.c

   1 /*
   2 ** FFI C library loader.
   3 ** Copyright (C) 2005-2014 Mike Pall. See Copyright Notice in luajit.h
   4 */
   5
   6 #include "lj_obj.h"
   7
   8 #if LJ_HASFFI
   9
  10 #include "lj_gc.h"
  11 #include "lj_err.h"
  12 #include "lj_tab.h"
  13 #include "lj_str.h"
  14 #include "lj_udata.h"
  15 #include "lj_ctype.h"
  16 #include "lj_cconv.h"
  17 #include "lj_cdata.h"
  18 #include "lj_clib.h"
  19 #include "lj_strfmt.h"
  20
  21 /* -- OS-specific functions ----------------------------------------------- */
  22
  23 #if LJ_TARGET_DLOPEN
  24
  25 #include <dlfcn.h>
  26 #include <stdio.h>
  27
  28 #if defined(RTLD_DEFAULT)
  29 #define CLIB_DEFHANDLE  RTLD_DEFAULT
  30 #elif LJ_TARGET_OSX || LJ_TARGET_BSD
  31 #define CLIB_DEFHANDLE  ((void *)(intptr_t)-2)
  32 #else
  33 #define CLIB_DEFHANDLE  NULL
  34 #endif
  35
  36 LJ_NORET LJ_NOINLINE static void clib_error_(lua_State *L)
  37 {
  38   lj_err_callermsg(L, dlerror());
  39 }
  40
  41 #define clib_error(L, fmt, name)        clib_error_(L)
  42
  43 #if defined(__CYGWIN__)
  44 #define CLIB_SOPREFIX   "cyg"
  45 #else
  46 #define CLIB_SOPREFIX   "lib"
  47 #endif
  48
  49 #if LJ_TARGET_OSX
  50 #define CLIB_SOEXT      "%s.dylib"
  51 #elif defined(__CYGWIN__)
  52 #define CLIB_SOEXT      "%s.dll"
  53 #else
  54 #define CLIB_SOEXT      "%s.so"
  55 #endif
  56
  57 static const char *clib_extname(lua_State *L, const char *name)
  58 {
  59   if (!strchr(name, '/')
  60 #ifdef __CYGWIN__
  61       && !strchr(name, '\\')
  62 #endif
  63      ) {
  64     if (!strchr(name, '.')) {
  65       name = lj_strfmt_pushf(L, CLIB_SOEXT, name);
  66       L->top--;
  67 #ifdef __CYGWIN__
  68     } else {
  69       return name;
  70 #endif
  71     }
  72     if (!(name[0] == CLIB_SOPREFIX[0] && name[1] == CLIB_SOPREFIX[1] &&
  73           name[2] == CLIB_SOPREFIX[2])) {
  74       name = lj_strfmt_pushf(L, CLIB_SOPREFIX "%s", name);
  75       L->top--;
  76     }
  77   }
  78   return name;
  79 }
  80
  81 /* Check for a recognized ld script line. */
  82 static const char *clib_check_lds(lua_State *L, const char *buf)
  83 {
  84   char *p, *e;
  85   if ((!strncmp(buf, "GROUP", 5) || !strncmp(buf, "INPUT", 5)) &&
  86       (p = strchr(buf, '('))) {
  87     while (*++p == ' ') ;
  88     for (e = p; *e && *e != ' ' && *e != ')'; e++) ;
  89     return strdata(lj_str_new(L, p, e-p));
  90   }
  91   return NULL;
  92 }
  93
  94 /* Quick and dirty solution to resolve shared library name from ld script. */
  95 static const char *clib_resolve_lds(lua_State *L, const char *name)
  96 {
  97   FILE *fp = fopen(name, "r");
  98   const char *p = NULL;
  99   if (fp) {
 100     char buf[256];
 101     if (fgets(buf, sizeof(buf), fp)) {
 102       if (!strncmp(buf, "/* GNU ld script", 16)) {  /* ld script magic? */
 103         while (fgets(buf, sizeof(buf), fp)) {  /* Check all lines. */
 104           p = clib_check_lds(L, buf);
 105           if (p) break;
 106         }
 107       } else {  /* Otherwise check only the first line. */
 108         p = clib_check_lds(L, buf);
 109       }
 110     }
 111     fclose(fp);
 112   }
 113   return p;
 114 }
 115
 116 static void *clib_loadlib(lua_State *L, const char *name, int global)
 117 {
 118   void *h = dlopen(clib_extname(L, name),
 119                    RTLD_LAZY | (global?RTLD_GLOBAL:RTLD_LOCAL));
 120   if (!h) {
 121     const char *e, *err = dlerror();
 122     if (*err == '/' && (e = strchr(err, ':')) &&
 123         (name = clib_resolve_lds(L, strdata(lj_str_new(L, err, e-err))))) {
 124       h = dlopen(name, RTLD_LAZY | (global?RTLD_GLOBAL:RTLD_LOCAL));
 125       if (h) return h;
 126       err = dlerror();
 127     }
 128     lj_err_callermsg(L, err);
 129   }
 130   return h;
 131 }
 132
 133 static void clib_unloadlib(CLibrary *cl)
 134 {
 135   if (cl->handle && cl->handle != CLIB_DEFHANDLE)
 136     dlclose(cl->handle);
 137 }
 138
 139 static void *clib_getsym(CLibrary *cl, const char *name)
 140 {
 141   void *p = dlsym(cl->handle, name);
 142   return p;
 143 }
 144
 145 #elif LJ_TARGET_WINDOWS
 146
 147 #define WIN32_LEAN_AND_MEAN
 148 #include <windows.h>
 149
 150 #ifndef GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS
 151 #define GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS  4
 152 #define GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT    2
 153 BOOL WINAPI GetModuleHandleExA(DWORD, LPCSTR, HMODULE*);
 154 #endif
 155
 156 #define CLIB_DEFHANDLE  ((void *)-1)
 157
 158 /* Default libraries. */
 159 enum {
 160   CLIB_HANDLE_EXE,
 161   CLIB_HANDLE_DLL,
 162   CLIB_HANDLE_CRT,
 163   CLIB_HANDLE_KERNEL32,
 164   CLIB_HANDLE_USER32,
 165   CLIB_HANDLE_GDI32,
 166   CLIB_HANDLE_MAX
 167 };
 168
 169 static void *clib_def_handle[CLIB_HANDLE_MAX];
 170
 171 LJ_NORET LJ_NOINLINE static void clib_error(lua_State *L, const char *fmt,
 172                                             const char *name)
 173 {
 174   DWORD err = GetLastError();
 175   char buf[128];
 176   if (!FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS|FORMAT_MESSAGE_FROM_SYSTEM,
 177                       NULL, err, 0, buf, sizeof(buf), NULL))
 178     buf[0] = '\0';
 179   lj_err_callermsg(L, lj_strfmt_pushf(L, fmt, name, buf));
 180 }
 181
 182 static int clib_needext(const char *s)
 183 {
 184   while (*s) {
 185     if (*s == '/' || *s == '\\' || *s == '.') return 0;
 186     s++;
 187   }
 188   return 1;
 189 }
 190
 191 static const char *clib_extname(lua_State *L, const char *name)
 192 {
 193   if (clib_needext(name)) {
 194     name = lj_strfmt_pushf(L, "%s.dll", name);
 195     L->top--;
 196   }
 197   return name;
 198 }
 199
 200 static void *clib_loadlib(lua_State *L, const char *name, int global)
 201 {
 202   DWORD oldwerr = GetLastError();
 203   void *h = (void *)LoadLibraryA(clib_extname(L, name));
 204   if (!h) clib_error(L, "cannot load module " LUA_QS ": %s", name);
 205   SetLastError(oldwerr);
 206   UNUSED(global);
 207   return h;
 208 }
 209
 210 static void clib_unloadlib(CLibrary *cl)
 211 {
 212   if (cl->handle == CLIB_DEFHANDLE) {
 213     MSize i;
 214     for (i = CLIB_HANDLE_KERNEL32; i < CLIB_HANDLE_MAX; i++) {
 215       void *h = clib_def_handle[i];
 216       if (h) {
 217         clib_def_handle[i] = NULL;
 218         FreeLibrary((HINSTANCE)h);
 219       }
 220     }
 221   } else if (cl->handle) {
 222     FreeLibrary((HINSTANCE)cl->handle);
 223   }
 224 }
 225
 226 static void *clib_getsym(CLibrary *cl, const char *name)
 227 {
 228   void *p = NULL;
 229   if (cl->handle == CLIB_DEFHANDLE) {  /* Search default libraries. */
 230     MSize i;
 231     for (i = 0; i < CLIB_HANDLE_MAX; i++) {
 232       HINSTANCE h = (HINSTANCE)clib_def_handle[i];
 233       if (!(void *)h) {  /* Resolve default library handles (once). */
 234         switch (i) {
 235         case CLIB_HANDLE_EXE: GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, NULL, &h); break;
 236         case CLIB_HANDLE_DLL:
 237           GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS|GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
 238                              (const char *)clib_def_handle, &h);
 239           break;
 240         case CLIB_HANDLE_CRT:
 241           GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS|GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
 242                              (const char *)&_fmode, &h);
 243           break;
 244         case CLIB_HANDLE_KERNEL32: h = LoadLibraryA("kernel32.dll"); break;
 245         case CLIB_HANDLE_USER32: h = LoadLibraryA("user32.dll"); break;
 246         case CLIB_HANDLE_GDI32: h = LoadLibraryA("gdi32.dll"); break;
 247         }
 248         if (!h) continue;
 249         clib_def_handle[i] = (void *)h;
 250       }
 251       p = (void *)GetProcAddress(h, name);
 252       if (p) break;
 253     }
 254   } else {
 255     p = (void *)GetProcAddress((HINSTANCE)cl->handle, name);
 256   }
 257   return p;
 258 }
 259
 260 #else
 261
 262 #define CLIB_DEFHANDLE  NULL
 263
 264 LJ_NORET LJ_NOINLINE static void clib_error(lua_State *L, const char *fmt,
 265                                             const char *name)
 266 {
 267   lj_err_callermsg(L, lj_strfmt_pushf(L, fmt, name, "no support for this OS"));
 268 }
 269
 270 static void *clib_loadlib(lua_State *L, const char *name, int global)
 271 {
 272   lj_err_callermsg(L, "no support for loading dynamic libraries for this OS");
 273   UNUSED(name); UNUSED(global);
 274   return NULL;
 275 }
 276
 277 static void clib_unloadlib(CLibrary *cl)
 278 {
 279   UNUSED(cl);
 280 }
 281
 282 static void *clib_getsym(CLibrary *cl, const char *name)
 283 {
 284   UNUSED(cl); UNUSED(name);
 285   return NULL;
 286 }
 287
 288 #endif
 289
 290 /* -- C library indexing -------------------------------------------------- */
 291
 292 #if LJ_TARGET_X86 && LJ_ABI_WIN
 293 /* Compute argument size for fastcall/stdcall functions. */
 294 static CTSize clib_func_argsize(CTState *cts, CType *ct)
 295 {
 296   CTSize n = 0;
 297   while (ct->sib) {
 298     CType *d;
 299     ct = ctype_get(cts, ct->sib);
 300     if (ctype_isfield(ct->info)) {
 301       d = ctype_rawchild(cts, ct);
 302       n += ((d->size + 3) & ~3);
 303     }
 304   }
 305   return n;
 306 }
 307 #endif
 308
 309 /* Get redirected or mangled external symbol. */
 310 static const char *clib_extsym(CTState *cts, CType *ct, GCstr *name)
 311 {
 312   if (ct->sib) {
 313     CType *ctf = ctype_get(cts, ct->sib);
 314     if (ctype_isxattrib(ctf->info, CTA_REDIR))
 315       return strdata(gco2str(gcref(ctf->name)));
 316   }
 317   return strdata(name);
 318 }
 319
 320 /* Index a C library by name. */
 321 TValue *lj_clib_index(lua_State *L, CLibrary *cl, GCstr *name)
 322 {
 323   TValue *tv = lj_tab_setstr(L, cl->cache, name);
 324   if (LJ_UNLIKELY(tvisnil(tv))) {
 325     CTState *cts = ctype_cts(L);
 326     CType *ct;
 327     CTypeID id = lj_ctype_getname(cts, &ct, name, CLNS_INDEX);
 328     if (!id)
 329       lj_err_callerv(L, LJ_ERR_FFI_NODECL, strdata(name));
 330     if (ctype_isconstval(ct->info)) {
 331       CType *ctt = ctype_child(cts, ct);
 332       lua_assert(ctype_isinteger(ctt->info) && ctt->size <= 4);
 333       if ((ctt->info & CTF_UNSIGNED) && (int32_t)ct->size < 0)
 334         setnumV(tv, (lua_Number)(uint32_t)ct->size);
 335       else
 336         setintV(tv, (int32_t)ct->size);
 337     } else {
 338       const char *sym = clib_extsym(cts, ct, name);
 339 #if LJ_TARGET_WINDOWS
 340       DWORD oldwerr = GetLastError();
 341 #endif
 342       void *p = clib_getsym(cl, sym);
 343       GCcdata *cd;
 344       lua_assert(ctype_isfunc(ct->info) || ctype_isextern(ct->info));
 345 #if LJ_TARGET_X86 && LJ_ABI_WIN
 346       /* Retry with decorated name for fastcall/stdcall functions. */
 347       if (!p && ctype_isfunc(ct->info)) {
 348         CTInfo cconv = ctype_cconv(ct->info);
 349         if (cconv == CTCC_FASTCALL || cconv == CTCC_STDCALL) {
 350           CTSize sz = clib_func_argsize(cts, ct);
 351           const char *symd = lj_strfmt_pushf(L,
 352                                cconv == CTCC_FASTCALL ? "@%s@%d" : "_%s@%d",
 353                                sym, sz);
 354           L->top--;
 355           p = clib_getsym(cl, symd);
 356         }
 357       }
 358 #endif
 359       if (!p)
 360         clib_error(L, "cannot resolve symbol " LUA_QS ": %s", sym);
 361 #if LJ_TARGET_WINDOWS
 362       SetLastError(oldwerr);
 363 #endif
 364       cd = lj_cdata_new(cts, id, CTSIZE_PTR);
 365       *(void **)cdataptr(cd) = p;
 366       setcdataV(L, tv, cd);
 367     }
 368   }
 369   return tv;
 370 }
 371
 372 /* -- C library management ------------------------------------------------ */
 373
 374 /* Create a new CLibrary object and push it on the stack. */
 375 static CLibrary *clib_new(lua_State *L, GCtab *mt)
 376 {
 377   GCtab *t = lj_tab_new(L, 0, 0);
 378   GCudata *ud = lj_udata_new(L, sizeof(CLibrary), t);
 379   CLibrary *cl = (CLibrary *)uddata(ud);
 380   cl->cache = t;
 381   ud->udtype = UDTYPE_FFI_CLIB;
 382   /* NOBARRIER: The GCudata is new (marked white). */
 383   setgcref(ud->metatable, obj2gco(mt));
 384   setudataV(L, L->top++, ud);
 385   return cl;
 386 }
 387
 388 /* Load a C library. */
 389 void lj_clib_load(lua_State *L, GCtab *mt, GCstr *name, int global)
 390 {
 391   void *handle = clib_loadlib(L, strdata(name), global);
 392   CLibrary *cl = clib_new(L, mt);
 393   cl->handle = handle;
 394 }
 395
 396 /* Unload a C library. */
 397 void lj_clib_unload(CLibrary *cl)
 398 {
 399   clib_unloadlib(cl);
 400   cl->handle = NULL;
 401 }
 402
 403 /* Create the default C library object. */
 404 void lj_clib_default(lua_State *L, GCtab *mt)
 405 {
 406   CLibrary *cl = clib_new(L, mt);
 407   cl->handle = CLIB_DEFHANDLE;
 408 }
 409
 410 #endif