ruby/dln.c

/**********************************************************************

  dln.c -

  $Author$
  created at: Tue Jan 18 17:05:06 JST 1994

  Copyright (C) 1993-2007 Yukihiro Matsumoto

**********************************************************************/

#ifdef RUBY_EXPORT
#include "ruby/ruby.h"
#define dln_notimplement rb_notimplement
#define dln_memerror rb_memerror
#define dln_exit rb_exit
#define dln_loaderror rb_loaderror
#define dln_fatalerror rb_fatal
#else
#define dln_notimplement --->>> dln not implemented <<<---
#define dln_memerror abort
#define dln_exit exit
static void dln_loaderror(const char *format, ...);
#define dln_fatalerror dln_loaderror
#endif
#include "dln.h"
#include "internal.h"
#include "internal/compilers.h"

#ifdef HAVE_STDLIB_H
# include <stdlib.h>
#endif

#if defined(HAVE_ALLOCA_H)
#include <alloca.h>
#endif

#ifdef HAVE_STRING_H
# include <string.h>
#else
# include <strings.h>
#endif

#if defined __APPLE__
# include <AvailabilityMacros.h>
#endif

#ifndef xmalloc
void *xmalloc();
void *xcalloc();
void *xrealloc();
#endif

#undef free
#define free(x) xfree(x)

#include <stdio.h>
#if defined(_WIN32)
#include "missing/file.h"
#endif
#include <sys/types.h>
#include <sys/stat.h>

#ifndef S_ISDIR
# define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
#endif

#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
#endif
#ifndef MAXPATHLEN
# define MAXPATHLEN 1024
#endif

#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif

#ifndef dln_loaderror
static void
dln_loaderror(const char *format, ...)
{
    va_list ap;
    va_start(ap, format);
    vfprintf(stderr, format, ap);
    va_end(ap);
    abort();
}
#endif

#if defined(HAVE_DLOPEN) && !defined(_AIX) && !defined(_UNICOSMP)
/* dynamic load with dlopen() */
# define USE_DLN_DLOPEN
#endif

#if defined(__hp9000s300) || ((defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)) && !defined(__ELF__)) || defined(NeXT)
# define EXTERNAL_PREFIX "_"
#else
# define EXTERNAL_PREFIX ""
#endif
#define FUNCNAME_PREFIX EXTERNAL_PREFIX"Init_"

#if defined __CYGWIN__ || defined DOSISH
#define isdirsep(x) ((x) == '/' || (x) == '\\')
#else
#define isdirsep(x) ((x) == '/')
#endif

#if defined(_WIN32) || defined(USE_DLN_DLOPEN)
struct string_part {
    const char *ptr;
    size_t len;
};

static struct string_part
init_funcname_len(const char *file)
{
    const char *p = file, *base, *dot = NULL;

    /* Load the file as an object one */
    for (base = p; *p; p++) { /* Find position of last '/' */
        if (*p == '.' && !dot) dot = p;
        if (isdirsep(*p)) base = p+1, dot = NULL;
    }
    /* Delete suffix if it exists */
    const size_t len = (dot ? dot : p) - base;
    return (struct string_part){base, len};
}

static inline char *
concat_funcname(char *buf, const char *prefix, size_t plen, const struct string_part base)
{
    if (!buf) {
        dln_memerror();
    }
    memcpy(buf, prefix, plen);
    memcpy(buf + plen, base.ptr, base.len);
    buf[plen + base.len] = '\0';
    return buf;
}

#define build_funcname(prefix, buf, file) do {\
    const struct string_part f = init_funcname_len(file);\
    const size_t plen = sizeof(prefix "") - 1;\
    *(buf) = concat_funcname(ALLOCA_N(char, plen+f.len+1), prefix, plen, f);\
} while (0)

#define init_funcname(buf, file) build_funcname(FUNCNAME_PREFIX, buf, file)
#endif

#ifdef USE_DLN_DLOPEN
# include <dlfcn.h>
#endif

#if defined(_AIX)
#include <ctype.h>	/* for isdigit()	*/
#include <errno.h>	/* for global errno	*/
#include <sys/ldr.h>
#endif

#ifdef NeXT
#if NS_TARGET_MAJOR < 4
#include <mach-o/rld.h>
#else
#include <mach-o/dyld.h>
#ifndef NSLINKMODULE_OPTION_BINDNOW
#define NSLINKMODULE_OPTION_BINDNOW 1
#endif
#endif
#endif

#ifdef _WIN32
#include <windows.h>
#include <imagehlp.h>
#endif

#ifdef _WIN32
static const char *
dln_strerror(char *message, size_t size)
{
    int error = GetLastError();
    char *p = message;
    size_t len = snprintf(message, size, "%d: ", error);

#define format_message(sublang) FormatMessage(\
        FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,	\
        NULL, error, MAKELANGID(LANG_NEUTRAL, (sublang)),		\
        message + len, size - len, NULL)
    if (format_message(SUBLANG_ENGLISH_US) == 0)
        format_message(SUBLANG_DEFAULT);
    for (p = message + len; *p; p++) {
        if (*p == '\n' || *p == '\r')
            *p = ' ';
    }
    return message;
}
#define dln_strerror() dln_strerror(message, sizeof message)
#elif defined USE_DLN_DLOPEN
static const char *
dln_strerror(void)
{
    return (char*)dlerror();
}
#endif

#if defined(_AIX)
static void
aix_loaderror(const char *pathname)
{
    char *message[1024], errbuf[1024];
    int i;
#define ERRBUF_APPEND(s) strlcat(errbuf, (s), sizeof(errbuf))
    snprintf(errbuf, sizeof(errbuf), "load failed - %s. ", pathname);

    if (loadquery(L_GETMESSAGES, &message[0], sizeof(message)) != -1) {
        ERRBUF_APPEND("Please issue below command for detailed reasons:\n\t");
        ERRBUF_APPEND("/usr/sbin/execerror ruby ");
        for (i=0; message[i]; i++) {
            ERRBUF_APPEND("\"");
            ERRBUF_APPEND(message[i]);
            ERRBUF_APPEND("\" ");
        }
        ERRBUF_APPEND("\n");
    }
    else {
        ERRBUF_APPEND(strerror(errno));
        ERRBUF_APPEND("[loadquery failed]");
    }
    dln_loaderror("%s", errbuf);
}
#endif

#if defined _WIN32 && defined RUBY_EXPORT
HANDLE rb_libruby_handle(void);

static int
rb_w32_check_imported(HMODULE ext, HMODULE mine)
{
    ULONG size;
    const IMAGE_IMPORT_DESCRIPTOR *desc;

    desc = ImageDirectoryEntryToData(ext, TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &size);
    if (!desc) return 0;
    while (desc->Name) {
        PIMAGE_THUNK_DATA pint = (PIMAGE_THUNK_DATA)((char *)ext + desc->Characteristics);
        PIMAGE_THUNK_DATA piat = (PIMAGE_THUNK_DATA)((char *)ext + desc->FirstThunk);
        for (; piat->u1.Function; piat++, pint++) {
            static const char prefix[] = "rb_";
            PIMAGE_IMPORT_BY_NAME pii;
            const char *name;

            if (IMAGE_SNAP_BY_ORDINAL(pint->u1.Ordinal)) continue;
            pii = (PIMAGE_IMPORT_BY_NAME)((char *)ext + (size_t)pint->u1.AddressOfData);
            name = (const char *)pii->Name;
            if (strncmp(name, prefix, sizeof(prefix) - 1) == 0) {
                FARPROC addr = GetProcAddress(mine, name);
                if (addr) return (FARPROC)piat->u1.Function == addr;
            }
        }
        desc++;
    }
    return 1;
}
#endif

#if defined(DLN_NEEDS_ALT_SEPARATOR) && DLN_NEEDS_ALT_SEPARATOR
#define translit_separator(src) do { \
        char *tmp = ALLOCA_N(char, strlen(src) + 1), *p = tmp, c; \
        do { \
            *p++ = ((c = *file++) == '/') ? DLN_NEEDS_ALT_SEPARATOR : c; \
        } while (c); \
        (src) = tmp; \
    } while (0)
#else
#define translit_separator(str) (void)(str)
#endif

#ifdef USE_DLN_DLOPEN
# include "ruby/internal/stdbool.h"
# include "internal/warnings.h"
static bool
dln_incompatible_func(void *handle, const char *funcname, void *const fp, const char **libname)
{
    void *ex = dlsym(handle, funcname);
    if (!ex) return false;
    if (ex == fp) return false;
#  if defined(HAVE_DLADDR) && !defined(__CYGWIN__)
    Dl_info dli;
    if (dladdr(ex, &dli)) {
        *libname = dli.dli_fname;
    }
#  endif
    return true;
}

COMPILER_WARNING_PUSH
#if defined(__clang__) || GCC_VERSION_SINCE(4, 2, 0)
COMPILER_WARNING_IGNORED(-Wpedantic)
#endif
static bool
dln_incompatible_library_p(void *handle, const char **libname)
{
#define check_func(func) \
    if (dln_incompatible_func(handle, EXTERNAL_PREFIX #func, (void *)&func, libname)) \
        return true
    check_func(ruby_xmalloc);
    return false;
}
COMPILER_WARNING_POP
#endif

#if !defined(MAC_OS_X_VERSION_MIN_REQUIRED)
/* assume others than old Mac OS X have no problem */
# define dln_disable_dlclose() false

#elif !defined(MAC_OS_X_VERSION_10_11) || \
    (MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_11)
/* targeting older versions only */
# define dln_disable_dlclose() true

#elif MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_11
/* targeting newer versions only */
# define dln_disable_dlclose() false

#else
/* support both versions, and check at runtime */
# include <sys/sysctl.h>

static bool
dln_disable_dlclose(void)
{
    int mib[] = {CTL_KERN, KERN_OSREV};
    int32_t rev;
    size_t size = sizeof(rev);
    if (sysctl(mib, numberof(mib), &rev, &size, NULL, 0)) return true;
    if (rev < MAC_OS_X_VERSION_10_11) return true;
    return false;
}
#endif

#if defined(_WIN32) || defined(USE_DLN_DLOPEN)
static void *
dln_open(const char *file)
{
    static const char incompatible[] = "incompatible library version";
    const char *error = NULL;
    void *handle;

#if defined(_WIN32)
    char message[1024];

    /* Convert the file path to wide char */
    WCHAR *winfile = rb_w32_mbstr_to_wstr(CP_UTF8, file, -1, NULL);
    if (!winfile) {
        dln_memerror();
    }

    /* Load file */
    handle = LoadLibraryW(winfile);
    free(winfile);

    if (!handle) {
        error = dln_strerror();
        goto failed;
    }

# if defined(RUBY_EXPORT)
    if (!rb_w32_check_imported(handle, rb_libruby_handle())) {
        FreeLibrary(handle);
        error = incompatible;
        goto failed;
    }
# endif

#elif defined(USE_DLN_DLOPEN)

# ifndef RTLD_LAZY
#  define RTLD_LAZY 1
# endif
# ifdef __INTERIX
#  undef RTLD_GLOBAL
# endif
# ifndef RTLD_GLOBAL
#  define RTLD_GLOBAL 0
# endif

    /* Load file */
    handle = dlopen(file, RTLD_LAZY|RTLD_GLOBAL);
    if (handle == NULL) {
        error = dln_strerror();
        goto failed;
    }

# if defined(RUBY_EXPORT)
    {
        const char *libruby_name = NULL;
        if (dln_incompatible_library_p(handle, &libruby_name)) {
            if (dln_disable_dlclose()) {
                /* dlclose() segfaults */
                if (libruby_name) {
                    dln_fatalerror("linked to incompatible %s - %s", libruby_name, file);
                }
                dln_fatalerror("%s - %s", incompatible, file);
            }
            else {
                if (libruby_name) {
                    const size_t len = strlen(libruby_name);
                    char *const tmp = ALLOCA_N(char, len + 1);
                    if (tmp) memcpy(tmp, libruby_name, len + 1);
                    libruby_name = tmp;
                }
                dlclose(handle);
                if (libruby_name) {
                    dln_loaderror("linked to incompatible %s - %s", libruby_name, file);
                }
                error = incompatible;
                goto failed;
            }
        }
    }
# endif
#endif

    return handle;

  failed:
    dln_loaderror("%s - %s", error, file);
}

static void *
dln_sym(void *handle, const char *symbol)
{
#if defined(_WIN32)
    return GetProcAddress(handle, symbol);
#elif defined(USE_DLN_DLOPEN)
    return dlsym(handle, symbol);
#endif
}

static uintptr_t
dln_sym_func(void *handle, const char *symbol)
{
    void *func = dln_sym(handle, symbol);

    if (func == NULL) {
        const char *error;
#if defined(_WIN32)
        char message[1024];
        error = dln_strerror();
#elif defined(USE_DLN_DLOPEN)
        const size_t errlen = strlen(error = dln_strerror()) + 1;
        error = memcpy(ALLOCA_N(char, errlen), error, errlen);
#endif
        dln_loaderror("%s - %s", error, symbol);
    }
    return (uintptr_t)func;
}

#define dln_sym_callable(rettype, argtype, handle, symbol) \
    (*(rettype (*)argtype)dln_sym_func(handle, symbol))
#endif

void *
dln_symbol(void *handle, const char *symbol)
{
#if defined(_WIN32) || defined(USE_DLN_DLOPEN)
    if (EXTERNAL_PREFIX[0]) {
        const size_t symlen = strlen(symbol);
        char *const tmp = ALLOCA_N(char, symlen + sizeof(EXTERNAL_PREFIX));
        if (!tmp) dln_memerror();
        memcpy(tmp, EXTERNAL_PREFIX, sizeof(EXTERNAL_PREFIX) - 1);
        memcpy(tmp + sizeof(EXTERNAL_PREFIX) - 1, symbol, symlen + 1);
        symbol = tmp;
    }
    if (handle == NULL) {
# if defined(USE_DLN_DLOPEN)
        handle = dlopen(NULL, RTLD_LAZY | RTLD_GLOBAL);
# elif defined(_WIN32)
        handle = rb_libruby_handle();
# else
        return NULL;
# endif
    }
    return dln_sym(handle, symbol);
#else
    return NULL;
#endif
}


#if defined(RUBY_DLN_CHECK_ABI) && defined(USE_DLN_DLOPEN)
static bool
abi_check_enabled_p(void)
{
    const char *val = getenv("RUBY_ABI_CHECK");
    return val == NULL || !(val[0] == '0' && val[1] == '\0');
}
#endif

void *
dln_load(const char *file)
{
#if defined(_WIN32) || defined(USE_DLN_DLOPEN)
    void *handle = dln_open(file);

#ifdef RUBY_DLN_CHECK_ABI
    typedef unsigned long long abi_version_number;
    abi_version_number binary_abi_version =
        dln_sym_callable(abi_version_number, (void), handle, EXTERNAL_PREFIX "ruby_abi_version")();
    if (binary_abi_version != RUBY_ABI_VERSION && abi_check_enabled_p()) {
        dln_loaderror("incompatible ABI version of binary - %s", file);
    }
#endif

    char *init_fct_name;
    init_funcname(&init_fct_name, file);

    /* Call the init code */
    dln_sym_callable(void, (void), handle, init_fct_name)();

    return handle;

#elif defined(_AIX)
    {
        void (*init_fct)(void);

        init_fct = (void(*)(void))load((char*)file, 1, 0);
        if (init_fct == NULL) {
            aix_loaderror(file);
        }
        if (loadbind(0, (void*)dln_load, (void*)init_fct) == -1) {
            aix_loaderror(file);
        }
        (*init_fct)();
        return (void*)init_fct;
    }
#else
    dln_notimplement();
#endif

    return 0;			/* dummy return */
}