get_lib_info.c

Go to the documentation of this file.

 
#include <funcman.h>
#if defined(_WIN32)
    #define WIN32_LEAN_AND_MEAN
    #include <stddef.h>
    #include <stdint.h>
    #include <stdio.h>
    #include <string.h>
    #include <windows.h>
#else
    #include <dlfcn.h>
    #include <limits.h>
    #include <stddef.h>
    #include <stdint.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <unistd.h>
#endif

typedef enum get_lib_info_status_t
{
    MYLIB_OK = 0,
    MYLIB_EINVAL = -1,
    MYLIB_ENOBUFS = -2,
    MYLIB_EFAIL = -3
} get_lib_info_status_t;

static get_lib_info_status_t copy_str(char *dst, size_t dst_sz, const char *src)
{
    size_t n;
 
    if (!dst || dst_sz == 0 || !src)
        return MYLIB_EINVAL;
    n = strlen(src);
    if (n + 1 > dst_sz)
    {
        if (dst_sz > 0)
            dst[0] = '\0';
        return MYLIB_ENOBUFS;
    }
    memcpy(dst, src, n + 1);
    return MYLIB_OK;
}

static const char *get_ilename_part(const char *path)
{
    const char *p;
    const char *last = path;
 
    if (!path)
        return "";
    for (p = path; *p; ++p)
    {
        if (*p == '/' || *p == '\\')
            last = p + 1;
    }
    return last;
}

static void strip_extension_inplace(char *s)
{
    char *dot;
 
    if (!s)
        return;
 
#if !defined(_WIN32)
    {
        char *so_ver = strstr(s, ".so.");
        if (so_ver)
        {
            *so_ver = '\0';
            return;
        }
 
        {
            size_t len = strlen(s);
            if (len >= 3 && strcmp(s + (len - 3), ".so") == 0)
            {
                s[len - 3] = '\0';
                return;
            }
        }
 
        {
            size_t len = strlen(s);
            if (len >= 6 && strcmp(s + (len - 6), ".dylib") == 0)
            {
                s[len - 6] = '\0';
                return;
            }
        }
    }
#endif
 
    dot = strrchr(s, '.');
    if (dot && dot != s)
    {
        *dot = '\0';
    }
}
 
#if defined(_WIN32)

static get_lib_info_status_t narrow_utf8(const wchar_t *w, char *out_u8, size_t out_u8_sz)
{
    int need;
    if (!w || !out_u8 || out_u8_sz == 0)
        return MYLIB_EINVAL;
 
    need = WideCharToMultiByte(CP_UTF8, 0, w, -1, NULL, 0, NULL, NULL);
    if (need <= 0)
        return MYLIB_EFAIL;
    if ((size_t)need > out_u8_sz)
        return MYLIB_ENOBUFS;
 
    if (WideCharToMultiByte(CP_UTF8, 0, w, -1, out_u8, (int)out_u8_sz, NULL, NULL) <= 0)
        return MYLIB_EFAIL;
    return MYLIB_OK;
}

static get_lib_info_status_t get_self_path_w(wchar_t *out_w, size_t out_w_cap, const void *func_addr)
{
    HMODULE hm = NULL;
    wchar_t buf[MAX_PATH];
    DWORD n;
 
    if (!out_w || out_w_cap == 0 || !func_addr)
        return MYLIB_EINVAL;
 
    if (!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
                            (LPCWSTR)func_addr, &hm))
    {
        return MYLIB_EFAIL;
    }
 
    n = GetModuleFileNameW(hm, buf, (DWORD)(sizeof(buf) / sizeof(buf[0])));
    if (n == 0 || n >= (DWORD)(sizeof(buf) / sizeof(buf[0])))
    {
        return MYLIB_EFAIL;
    }
    buf[n] = L'\0';
 
    /* GetModuleFileNameW は通常フルパスを返しますが、念のため GetFullPathNameW で正規化します。 */
    /* (失敗した場合は buf をそのまま返す) */
    {
        wchar_t full[MAX_PATH];
        DWORD m = GetFullPathNameW(buf, (DWORD)(sizeof(full) / sizeof(full[0])), full, NULL);
        if (m == 0 || m >= (DWORD)(sizeof(full) / sizeof(full[0])))
        {
            if (wcslen(buf) + 1 > out_w_cap)
                return MYLIB_ENOBUFS;
            wcscpy_s(out_w, out_w_cap, buf);
            return MYLIB_OK;
        }
        if (wcslen(full) + 1 > out_w_cap)
            return MYLIB_ENOBUFS;
        wcscpy_s(out_w, out_w_cap, full);
        return MYLIB_OK;
    }
}
 
#else /* Linux/Unix */

static get_lib_info_status_t get_self_path_posix(char *out_path, size_t out_path_sz, const void *func_addr)
{
    Dl_info info;
    const char *p;
    char resolved[PATH_MAX];
 
    if (!out_path || out_path_sz == 0 || !func_addr)
        return MYLIB_EINVAL;
 
    memset(&info, 0, sizeof(info));
    if (dladdr(func_addr, &info) == 0)
    {
        return MYLIB_EFAIL;
    }
 
    p = info.dli_fname ? info.dli_fname : "";
    if (p[0] == '\0')
        return MYLIB_EFAIL;
 
    /* realpath() は symlink 解決と絶対化を行います。 */
    /* ロード後にファイルが移動/削除される等で失敗する場合があるため、その場合はフォールバックします。 */
    if (realpath(p, resolved) != NULL)
    {
        return copy_str(out_path, out_path_sz, resolved);
    }
 
    /* すでに絶対パスならそのまま返す (正規化はできない) */
    if (p[0] == '/')
    {
        return copy_str(out_path, out_path_sz, p);
    }
 
    /* 相対パスなら CWD と結合して絶対化を試みる */
    {
        char cwd[PATH_MAX];
        char joined[PATH_MAX];
 
        if (getcwd(cwd, sizeof(cwd)) == NULL)
            return MYLIB_EFAIL;
        if (snprintf(joined, sizeof(joined), "%s/%s", cwd, p) <= 0)
            return MYLIB_EFAIL;
 
        if (realpath(joined, resolved) != NULL)
        {
            return copy_str(out_path, out_path_sz, resolved);
        }
 
        /* 最後の手段: 結合した絶対パス文字列 (正規化なし) */
        return copy_str(out_path, out_path_sz, joined);
    }
}
 
#endif
 
/* doxygen コメントは、ヘッダに記載 */
int get_lib_path(char *out_path, const size_t out_path_sz, const void *func_addr)
{
#if defined(_WIN32)
    wchar_t wpath[MAX_PATH];
    get_lib_info_status_t st = get_self_path_w(wpath, (size_t)(sizeof(wpath) / sizeof(wpath[0])), func_addr);
    if (st != MYLIB_OK)
    {
        if (out_path && out_path_sz)
            out_path[0] = '\0';
        return st;
    }
    return (int)narrow_utf8(wpath, out_path, out_path_sz);
#else
    return (int)get_self_path_posix(out_path, out_path_sz, func_addr);
#endif
}
 
/* doxygen コメントは、ヘッダに記載 */
int get_lib_basename(char *out_basename, const size_t out_basename_sz, const void *func_addr)
{
    get_lib_info_status_t st;
    char path_buf[4096];
    const char *fname;
    char tmp[1024];
 
    if (!out_basename || out_basename_sz == 0)
        return MYLIB_EINVAL;
 
    st = get_lib_path(path_buf, sizeof(path_buf), func_addr);
    if (st != MYLIB_OK)
    {
        out_basename[0] = '\0';
        return st;
    }
 
    fname = get_ilename_part(path_buf);
    if (!fname || fname[0] == '\0')
    {
        out_basename[0] = '\0';
        return MYLIB_EFAIL;
    }
 
    /* ファイル名のみをコピーして拡張子を除く */
    st = copy_str(tmp, sizeof(tmp), fname);
    if (st != MYLIB_OK)
    {
        out_basename[0] = '\0';
        return st;
    }
 
    strip_extension_inplace(tmp);
 
    return (int)copy_str(out_basename, out_basename_sz, tmp);
}