rz_lib.h File Reference

#include "rz_types.h"
#include "rz_list.h"
#include <ht_pu.h>

Go to the source code of this file.

Classes
struct	rz_lib_plugin_t
struct	rz_lib_handler_t
struct	rz_lib_struct_t
struct	rz_lib_t

Macros
#define	RZ_LIB_SEPARATOR   "."
#define	RZ_LIB_SYMNAME   "rizin_plugin"
#define	RZ_LIB_SYMFUNC   "rizin_plugin_function"
#define	RZ_LIB_ENV   "RZ_LIBR_PLUGINS"
#define	RZ_LIB_EXT   "so"

Typedefs
typedef struct rz_lib_plugin_t	RzLibPlugin
typedef struct rz_lib_handler_t	RzLibHandler
typedef struct rz_lib_struct_t	RzLibStruct
typedef RzLibStruct *(*	RzLibStructFunc) (void)
typedef struct rz_lib_t	RzLib
typedef int(*	RzLibCallback) (RzLibPlugin *, void *, void *)

Enumerations
enum	RzLibType {   RZ_LIB_TYPE_IO , RZ_LIB_TYPE_DBG , RZ_LIB_TYPE_LANG , RZ_LIB_TYPE_ASM ,   RZ_LIB_TYPE_ANALYSIS , RZ_LIB_TYPE_PARSE , RZ_LIB_TYPE_BIN , RZ_LIB_TYPE_BIN_XTR ,   RZ_LIB_TYPE_BIN_LDR , RZ_LIB_TYPE_BP , RZ_LIB_TYPE_SYSCALL , RZ_LIB_TYPE_FASTCALL ,   RZ_LIB_TYPE_CRYPTO , RZ_LIB_TYPE_HASH , RZ_LIB_TYPE_CORE , RZ_LIB_TYPE_EGG ,   RZ_LIB_TYPE_DEMANGLER , RZ_LIB_TYPE_UNKNOWN }

Functions
	RZ_LIB_VERSION_HEADER (rz_lib)
RZ_API void *	rz_lib_dl_open (const char *libname)
RZ_API void *	rz_lib_dl_sym (void *handler, const char *name)
RZ_API int	rz_lib_dl_close (void *handler)
RZ_API RzLib *	rz_lib_new (const char *symname, const char *symnamefunc)
RZ_API void	rz_lib_free (RzLib *lib)
RZ_API int	rz_lib_run_handler (RzLib *lib, RzLibPlugin *plugin, RzLibStruct *symbol)
RZ_API RzLibHandler *	rz_lib_get_handler (RzLib *lib, int type)
RZ_API int	rz_lib_open (RzLib *lib, const char *file)
RZ_API bool	rz_lib_opendir (RzLib *lib, const char *path, bool force)
	Open all the libraries in the given directory, if it wasn't already opened. More...
RZ_API int	rz_lib_open_ptr (RzLib *lib, const char *file, void *handler, RzLibStruct *stru)
RZ_API char *	rz_lib_path (const char *libname)
RZ_API void	rz_lib_list (RzLib *lib)
RZ_API bool	rz_lib_add_handler (RzLib *lib, int type, const char *desc, RzLibCallback ct, RzLibCallback dt, void *user)
RZ_API bool	rz_lib_del_handler (RzLib *lib, int type)
RZ_API int	rz_lib_close (RzLib *lib, const char *file)
RZ_API int	rz_lib_types_get_i (const char *str)

Macro Definition Documentation

RZ_LIB_ENV

#define RZ_LIB_ENV   "RZ_LIBR_PLUGINS"

Definition at line 23 of file rz_lib.h.

RZ_LIB_EXT

#define RZ_LIB_EXT   "so"

Definition at line 31 of file rz_lib.h.

RZ_LIB_SEPARATOR

#define RZ_LIB_SEPARATOR   "."

Definition at line 19 of file rz_lib.h.

RZ_LIB_SYMFUNC

#define RZ_LIB_SYMFUNC   "rizin_plugin_function"

Definition at line 21 of file rz_lib.h.

RZ_LIB_SYMNAME

#define RZ_LIB_SYMNAME   "rizin_plugin"

Definition at line 20 of file rz_lib.h.

Typedef Documentation

RzLib

typedef struct rz_lib_t RzLib

RzLibCallback

typedef int(* RzLibCallback) (RzLibPlugin *, void *, void *)

Definition at line 108 of file rz_lib.h.

RzLibHandler

typedef struct rz_lib_handler_t RzLibHandler

RzLibPlugin

typedef struct rz_lib_plugin_t RzLibPlugin

RzLibStruct

typedef struct rz_lib_struct_t RzLibStruct

RzLibStructFunc

typedef RzLibStruct*(* RzLibStructFunc) (void)

Definition at line 65 of file rz_lib.h.

Enumeration Type Documentation

RzLibType

enum RzLibType

Enumerator
RZ_LIB_TYPE_IO
RZ_LIB_TYPE_DBG
RZ_LIB_TYPE_LANG
RZ_LIB_TYPE_ASM
RZ_LIB_TYPE_ANALYSIS
RZ_LIB_TYPE_PARSE
RZ_LIB_TYPE_BIN
RZ_LIB_TYPE_BIN_XTR
RZ_LIB_TYPE_BIN_LDR
RZ_LIB_TYPE_BP
RZ_LIB_TYPE_SYSCALL
RZ_LIB_TYPE_FASTCALL
RZ_LIB_TYPE_CRYPTO
RZ_LIB_TYPE_HASH
RZ_LIB_TYPE_CORE
RZ_LIB_TYPE_EGG
RZ_LIB_TYPE_DEMANGLER
RZ_LIB_TYPE_UNKNOWN

Definition at line 68 of file rz_lib.h.

             {
    RZ_LIB_TYPE_IO, /* io layer */
    RZ_LIB_TYPE_DBG, /* debugger */
    RZ_LIB_TYPE_LANG, /* language */
    RZ_LIB_TYPE_ASM, /* assembler */
    RZ_LIB_TYPE_ANALYSIS, /* analysis */
    RZ_LIB_TYPE_PARSE, /* parsers */
    RZ_LIB_TYPE_BIN, /* bin headers */
    RZ_LIB_TYPE_BIN_XTR, /* bin extractors */
    RZ_LIB_TYPE_BIN_LDR, /* bin loaders */
    RZ_LIB_TYPE_BP, /* breakpoint */
    RZ_LIB_TYPE_SYSCALL, /* syscall */
    RZ_LIB_TYPE_FASTCALL, /* fastcall */
    RZ_LIB_TYPE_CRYPTO, /* cryptography */
    RZ_LIB_TYPE_HASH, /* hashes / message digests */
    RZ_LIB_TYPE_CORE, /* RzCore commands */
    RZ_LIB_TYPE_EGG, /* rz_egg plugin */
    RZ_LIB_TYPE_DEMANGLER, /* demanglers */
    RZ_LIB_TYPE_UNKNOWN
} RzLibType;

Function Documentation

rz_lib_add_handler()

RZ_API bool rz_lib_add_handler	(	RzLib *	lib,
		int	type,
		const char *	desc,
		RzLibCallback	ct,
		RzLibCallback	dt,
		void *	user
	)

Referenced by __load_plugins(), hash_load_plugins(), and rz_main_rz_bin().

rz_lib_close()

RZ_API int rz_lib_close	(	RzLib *	lib,
		const char *	file
	)

Definition at line 227 of file lib.c.

                                                      {
    RzLibPlugin *p;
    RzListIter *iter, *iter2;
    rz_list_foreach_safe (lib->plugins, iter, iter2, p) {
        if ((!file || !strcmp(file, p->file))) {
            int ret = 0;
            if (p->handler && p->handler->destructor) {
                ret = p->handler->destructor(p, p->handler->user, p->data);
            }
            if (p->free) {
                p->free(p->data);
            }
            free(p->file);
            rz_list_delete(lib->plugins, iter);
            if (file != NULL) {
                return ret;
            }
        }
    }
    if (!file) {
        return 0;
    }
    // delete similar plugin name
    rz_list_foreach (lib->plugins, iter, p) {
        if (strstr(p->file, file)) {
            int ret = 0;
            if (p->handler && p->handler->destructor) {
                ret = p->handler->destructor(p,
                    p->handler->user, p->data);
            }
            RZ_LOG_INFO("Unloaded %s\n", p->file);
            free(p->file);
            rz_list_delete(lib->plugins, iter);
            return ret;
        }
    }
    return -1;
}

References free(), NULL, p, rz_lib_t::plugins, rz_list_delete(), and RZ_LOG_INFO.

Referenced by rz_lib_free(), and rz_plugins_unload_handler().

rz_lib_del_handler()

RZ_API bool rz_lib_del_handler	(	RzLib *	lib,
		int	type
	)

Definition at line 528 of file lib.c.

                                                     {
    RzLibHandler *h;
    RzListIter *iter;
    // TODO: remove all handlers for that type? or only one?
    /* No _safe loop necessary because we return immediately after the delete. */
    rz_list_foreach (lib->handlers, iter, h) {
        if (type == h->type) {
            rz_list_delete(lib->handlers, iter);
            return true;
        }
    }
    return false;
}

References h, rz_lib_t::handlers, rz_list_delete(), and type.

rz_lib_dl_close()

RZ_API int rz_lib_dl_close

(

void *

handler

)

Definition at line 104 of file lib.c.

                                          {
#if __UNIX__
    return dlclose(handler);
#else
    return handler ? 0 : -1;
#endif
}

Referenced by _free_source_cb(), lang_lib_file_run(), rz_analysis_esil_load_source(), rz_analysis_esil_release_source(), rz_lib_open(), rz_lib_open_ptr(), rz_main_rz_bin(), and rz_run_start().

rz_lib_dl_open()

RZ_API void* rz_lib_dl_open

(

const char *

libname

)

Definition at line 54 of file lib.c.

                                                 {
    void *ret = NULL;
#if WANT_DYLINK
#if __UNIX__
    if (libname) {
        ret = dlopen(libname, RTLD_GLOBAL | RTLD_LAZY);
    } else {
        ret = dlopen(NULL, RTLD_NOW);
    }
    if (!ret) {
        RZ_LOG_ERROR("rz_lib_dl_open: error: %s (%s)\n", libname, dlerror());
    }
#elif __WINDOWS__
    LPTSTR libname_;
    if (libname && *libname) {
        libname_ = rz_sys_conv_utf8_to_win(libname);
    } else {
        libname_ = calloc(MAX_PATH, sizeof(TCHAR));
        if (!libname_) {
            RZ_LOG_ERROR("lib/rz_lib_dl_open: Failed to allocate memory.\n");
            return NULL;
        }
        if (!GetModuleFileName(NULL, libname_, MAX_PATH)) {
            libname_[0] = '\0';
        }
    }
    ret = LoadLibrary(libname_);
    free(libname_);
    if (!ret) {
        RZ_LOG_ERROR("rz_lib_dl_open: error: %s\n", libname);
    }
#endif
#endif
    return ret;
}

References calloc(), free(), NULL, and RZ_LOG_ERROR.

Referenced by lang_lib_file_run(), rz_analysis_esil_load_source(), rz_lib_open(), rz_main_rz_bin(), rz_run_start(), and rzpipe_open_dl().

rz_lib_dl_sym()

RZ_API void* rz_lib_dl_sym	(	void *	handler,
		const char *	name
	)

Definition at line 90 of file lib.c.

                                                            {
#if WANT_DYLINK
#if __UNIX__
    return dlsym(handler, name);
#elif __WINDOWS__
    return GetProcAddress(handler, name);
#else
    return NULL;
#endif
#else
    return NULL;
#endif
}

References NULL.

Referenced by lang_lib_file_run(), rz_analysis_esil_load_interrupts_from_lib(), rz_debug_continue_kill(), rz_lib_open(), rz_run_start(), rz_sys_get_environ(), and rzpipe_open_dl().

rz_lib_free()

RZ_API void rz_lib_free

(

RzLib *

lib

)

Definition at line 189 of file lib.c.

                                    {
    if (!lib) {
        return;
    }
    rz_lib_close(lib, NULL);
    rz_list_free(lib->handlers);
    rz_list_free(lib->plugins);
    free(lib->symname);
    free(lib->symnamefunc);
    ht_pu_free(lib->opened_dirs);
    free(lib);
}

References free(), rz_lib_t::handlers, NULL, rz_lib_t::opened_dirs, rz_lib_t::plugins, rz_lib_close(), rz_list_free(), rz_lib_t::symname, and rz_lib_t::symnamefunc.

Referenced by __as_free(), hash_load_plugins(), rz_core_fini(), and rz_main_rz_bin().

rz_lib_get_handler()

RZ_API RzLibHandler* rz_lib_get_handler	(	RzLib *	lib,
		int	type
	)

Definition at line 216 of file lib.c.

                                                              {
    RzLibHandler *h;
    RzListIter *iter;
    rz_list_foreach (lib->handlers, iter, h) {
        if (h->type == type) {
            return h;
        }
    }
    return NULL;
}

References h, rz_lib_t::handlers, NULL, and type.

Referenced by rz_lib_open_ptr().

rz_lib_list()

RZ_API void rz_lib_list

(

RzLib *

lib

)

Definition at line 543 of file lib.c.

                                    {
    RzListIter *iter;
    RzLibPlugin *p;
    rz_list_foreach (lib->plugins, iter, p) {
        printf(" %5s %p %s \n", __lib_types_get(p->type), p->dl_handler, p->file);
    }
}

References __lib_types_get(), p, rz_lib_t::plugins, and printf().

rz_lib_new()

RZ_API RzLib* rz_lib_new	(	const char *	symname,
		const char *	symnamefunc
	)

Definition at line 176 of file lib.c.

                                                                       {
    RzLib *lib = RZ_NEW(RzLib);
    if (!lib) {
        return NULL;
    }
    lib->handlers = rz_list_newf(free);
    lib->plugins = rz_list_newf(free);
    lib->symname = strdup(symname ? symname : RZ_LIB_SYMNAME);
    lib->symnamefunc = strdup(symnamefunc ? symnamefunc : RZ_LIB_SYMFUNC);
    lib->opened_dirs = ht_pu_new0();
    return lib;
}

References free(), rz_lib_t::handlers, NULL, rz_lib_t::opened_dirs, rz_lib_t::plugins, RZ_LIB_SYMFUNC, RZ_LIB_SYMNAME, rz_list_newf(), RZ_NEW, strdup(), rz_lib_t::symname, and rz_lib_t::symnamefunc.

Referenced by __as_new(), hash_load_plugins(), rz_core_loadlibs_init(), and rz_main_rz_bin().

rz_lib_open()

RZ_API int rz_lib_open	(	RzLib *	lib,
		const char *	file
	)

Definition at line 281 of file lib.c.

                                                     {
    /* ignored by filename */
    if (!__lib_dl_check_filename(file)) {
        RZ_LOG_ERROR("Invalid library extension: %s\n", file);
        return -1;
    }
 
    if (__already_loaded(lib, file)) {
        RZ_LOG_INFO("Not loading library because it has already been loaded from somewhere else: '%s'\n", file);
        return -1;
    }
 
    // TODO: remove after 0.4.0 is released
    if (strstr(file, RZ_HOME_OLD_PLUGINS)) {
        char *oldhomeplugins = rz_path_home_prefix(RZ_HOME_OLD_PLUGINS);
        char *homeplugins = rz_path_home_prefix(RZ_PLUGINS);
        const char *basename = rz_file_basename(file);
        RZ_LOG_WARN("Loading plugins from '%s' is deprecated, please install plugin '%s' in '%s' instead.\n", oldhomeplugins, basename, homeplugins);
        free(homeplugins);
        free(oldhomeplugins);
    }
 
    void *handler = rz_lib_dl_open(file);
    if (!handler) {
        RZ_LOG_INFO("Cannot open library: '%s'\n", file);
        return -1;
    }
 
    RzLibStructFunc strf = (RzLibStructFunc)rz_lib_dl_sym(handler, lib->symnamefunc);
    RzLibStruct *stru = NULL;
    if (strf) {
        stru = strf();
    }
    if (!stru) {
        stru = (RzLibStruct *)rz_lib_dl_sym(handler, lib->symname);
    }
    if (!stru) {
        RZ_LOG_INFO("Cannot find symbol '%s' in library '%s'\n",
            lib->symname, file);
        rz_lib_dl_close(handler);
        return -1;
    }
 
    int res = rz_lib_open_ptr(lib, file, handler, stru);
    if (strf) {
        free(stru);
    }
    return res;
}

References __already_loaded(), __lib_dl_check_filename(), basename, free(), NULL, rz_file_basename(), RZ_HOME_OLD_PLUGINS, rz_lib_dl_close(), rz_lib_dl_open(), rz_lib_dl_sym(), rz_lib_open_ptr(), RZ_LOG_ERROR, RZ_LOG_INFO, RZ_LOG_WARN, rz_path_home_prefix(), RZ_PLUGINS, rz_lib_t::symname, and rz_lib_t::symnamefunc.

Referenced by rz_lib_opendir(), rz_main_rizin(), rz_plugins_io_print_handler(), and rz_plugins_load_handler().

rz_lib_open_ptr()

RZ_API int rz_lib_open_ptr	(	RzLib *	lib,
		const char *	file,
		void *	handler,
		RzLibStruct *	stru
	)

Definition at line 343 of file lib.c.

                                                                                           {
    rz_return_val_if_fail(lib && file && stru, -1);
    if (stru->version) {
        char *mm0 = major_minor(stru->version);
        char *mm1 = major_minor(RZ_VERSION);
        bool mismatch = strcmp(mm0, mm1);
        free(mm0);
        free(mm1);
        if (mismatch) {
            RZ_LOG_WARN("Module version mismatch %s (%s) vs (%s)\n",
                file, stru->version, RZ_VERSION);
            if (stru->pkgname) {
                const char *dot = strchr(stru->version, '.');
                int major = atoi(stru->version);
                int minor = dot ? atoi(dot + 1) : 0;
                // The pkgname member was introduced in 4.2.0
                if (major > 4 || (major == 4 && minor >= 2)) {
                    printf("rz-pm -ci %s\n", stru->pkgname);
                }
            }
            return -1;
        }
    }
 
    RzLibHandler *lib_handler = rz_lib_get_handler(lib, stru->type);
    if (!lib_handler) {
        // the handler was not assigned for this type therefore
        // we skip this library (this happens when not loading
        // all the plugins types, like rz-bin does).
        RZ_LOG_DEBUG("rz_lib_open_ptr: no handler was defined for %s with type %d\n", file, stru->type);
        rz_lib_dl_close(handler);
        return -1;
    }
 
    RzLibPlugin *p = RZ_NEW0(RzLibPlugin);
    if (!p) {
        RZ_LOG_ERROR("rz_lib_open_ptr: Cannot allocate RzLibPlugin\n");
        rz_lib_dl_close(handler);
        return -1;
    }
 
    p->type = stru->type;
    p->data = stru->data;
    p->file = strdup(file);
    p->dl_handler = handler;
    p->handler = lib_handler;
    p->free = stru->free;
 
    int ret = rz_lib_run_handler(lib, p, stru);
    if (ret == -1) {
        RZ_LOG_INFO("Library handler has failed for '%s'\n", file);
        free(p->file);
        free(p);
        rz_lib_dl_close(handler);
    } else {
        rz_list_append(lib->plugins, p);
    }
 
    return ret;
}

References rz_lib_struct_t::data, free(), rz_lib_struct_t::free, major, major_minor(), minor, mm1, p, rz_lib_struct_t::pkgname, rz_lib_t::plugins, printf(), rz_lib_dl_close(), rz_lib_get_handler(), rz_lib_run_handler(), rz_list_append(), RZ_LOG_DEBUG, RZ_LOG_ERROR, RZ_LOG_INFO, RZ_LOG_WARN, RZ_NEW0, rz_return_val_if_fail, RZ_VERSION, strdup(), rz_lib_struct_t::type, and rz_lib_struct_t::version.

Referenced by rz_lib_open().

rz_lib_opendir()

RZ_API bool rz_lib_opendir	(	RzLib *	lib,
		const char *	path,
		bool	force
	)

Open all the libraries in the given directory, if it wasn't already opened.

Opens all the files ending with the right library extension (e.g. ".so") present in the directory pointed by path . If path was already opened, it is not opened again unless force is set to true.

Parameters

lib	Reference to RzLib
path	Directory to open
force	When true, a directory is re-scanned even if it was already opened

Returns

True when the directory is scanned for libs, false otherwise

Definition at line 417 of file lib.c.

                                                                     {
    rz_return_val_if_fail(lib && path, false);
 
    if (!force && ht_pu_find(lib->opened_dirs, path, NULL)) {
        return false;
    }
#if WANT_DYLINK
    rz_return_val_if_fail(lib && path, false);
#if __WINDOWS__
    wchar_t file[1024];
    WIN32_FIND_DATAW dir;
    HANDLE fh;
    wchar_t directory[MAX_PATH];
    wchar_t *wcpath;
    char *wctocbuff;
#else
    char file[1024];
    struct dirent *de;
    DIR *dh;
#endif
#ifdef RZ_LIBR_PLUGINS
    if (!path) {
        path = RZ_LIBR_PLUGINS;
    }
#endif
    if (!path) {
        return false;
    }
#if __WINDOWS__
    wcpath = rz_utf8_to_utf16(path);
    if (!wcpath) {
        return false;
    }
    swprintf(directory, _countof(directory), L"%ls\\*.*", wcpath);
    fh = FindFirstFileW(directory, &dir);
    if (fh == INVALID_HANDLE_VALUE) {
        RZ_LOG_INFO("Cannot open directory %ls\n", wcpath);
        free(wcpath);
        return false;
    }
    do {
        swprintf(file, _countof(file), L"%ls/%ls", wcpath, dir.cFileName);
        wctocbuff = rz_utf16_to_utf8(file);
        if (wctocbuff) {
            if (__lib_dl_check_filename(wctocbuff)) {
                rz_lib_open(lib, wctocbuff);
            } else {
                RZ_LOG_INFO("Cannot open %ls\n", dir.cFileName);
            }
            free(wctocbuff);
        }
    } while (FindNextFileW(fh, &dir));
    FindClose(fh);
    free(wcpath);
#else
    dh = opendir(path);
    if (!dh) {
        RZ_LOG_INFO("Cannot open directory '%s'\n", path);
        return false;
    }
    while ((de = (struct dirent *)readdir(dh))) {
        if (de->d_name[0] == '.' || strstr(de->d_name, ".dSYM")) {
            continue;
        }
        snprintf(file, sizeof(file), "%s/%s", path, de->d_name);
        if (__lib_dl_check_filename(file)) {
            RZ_LOG_INFO("Loading %s\n", file);
            rz_lib_open(lib, file);
        } else {
            RZ_LOG_INFO("Cannot open %s\n", file);
        }
    }
    closedir(dh);
#endif
#endif
    ht_pu_insert(lib->opened_dirs, path, 1);
    return true;
}

References __lib_dl_check_filename(), dirent::d_name, regress::directory, fh, free(), HANDLE, INVALID_HANDLE_VALUE, L, NULL, rz_lib_t::opened_dirs, path, readdir, rz_lib_open(), RZ_LOG_INFO, rz_return_val_if_fail, and snprintf.

Referenced by __load_plugins(), hash_load_plugins(), loadSystemPlugins(), and rz_main_rz_bin().

rz_lib_path()

RZ_API char* rz_lib_path

(

const char *

libname

)

Definition at line 112 of file lib.c.

                                              {
#if __WINDOWS__
    char *tmp = rz_str_newf("%s." RZ_LIB_EXT, libname);
    if (!tmp) {
        return NULL;
    }
    WCHAR *name = rz_utf8_to_utf16(tmp);
    free(tmp);
    WCHAR *path = NULL;
    if (!name) {
        goto err;
    }
 
    int count;
    if (!(count = SearchPathW(NULL, name, NULL, 0, NULL, NULL))) {
        rz_sys_perror("SearchPath");
        goto err;
    }
    path = malloc(count * sizeof(WCHAR));
    if (!path) {
        goto err;
    }
    if (!(count = SearchPathW(NULL, name, NULL, count, path, NULL))) {
        RZ_FREE(path);
        rz_sys_perror("SearchPath");
        goto err;
    }
    tmp = rz_utf16_to_utf8(path);
    free(name);
    free(path);
    return tmp;
err:
    free(name);
    return NULL;
#else
#if __APPLE__
    char *env = rz_sys_getenv("DYLD_LIBRARY_PATH");
    env = rz_str_append(env, ":/lib:/usr/lib:/usr/local/lib");
#elif __UNIX__
    char *env = rz_sys_getenv("LD_LIBRARY_PATH");
    env = rz_str_append(env, ":/lib:/usr/lib:/usr/local/lib");
#endif
    if (!env) {
        env = strdup(".");
    }
    char *next, *path0 = env;
    do {
        next = strchr(path0, ':');
        if (next) {
            *next = 0;
        }
        char *libpath = rz_str_newf("%s/%s." RZ_LIB_EXT, path0, libname);
        if (rz_file_exists(libpath)) {
            free(env);
            return libpath;
        }
        free(libpath);
        path0 = next + 1;
    } while (next);
    free(env);
    return NULL;
#endif
}

References count, env, err, free(), malloc(), NULL, path, rz_file_exists(), RZ_FREE, RZ_LIB_EXT, rz_str_append(), rz_str_newf(), rz_sys_getenv(), rz_sys_perror, strdup(), and autogen_x86imm::tmp.

rz_lib_run_handler()

RZ_API int rz_lib_run_handler	(	RzLib *	lib,
		RzLibPlugin *	plugin,
		RzLibStruct *	symbol
	)

Definition at line 206 of file lib.c.

                                                                                    {
    RzLibHandler *h = plugin->handler;
    if (h && h->constructor) {
        RZ_LOG_DEBUG("PLUGIN LOADED %p fcn %p\n", h, h->constructor);
        return h->constructor(plugin, h->user, symbol->data);
    }
    RZ_LOG_WARN("Cannot find plugin constructor\n");
    return -1;
}

References rz_lib_struct_t::data, h, rz_lib_plugin_t::handler, RZ_LOG_DEBUG, and RZ_LOG_WARN.

Referenced by rz_lib_open_ptr().

rz_lib_types_get_i()

RZ_API int rz_lib_types_get_i

(

const char *

str

)

Definition at line 45 of file lib.c.

                                               {
    for (int i = 0; i < RZ_ARRAY_SIZE(rz_lib_types); ++i) {
        if (!strcmp(str, rz_lib_types[i].name)) {
            return rz_lib_types[i].id;
        }
    }
    return RZ_LIB_TYPE_UNKNOWN;
}

References i, rz_lib_type_name_t::id, RZ_ARRAY_SIZE, RZ_LIB_TYPE_UNKNOWN, rz_lib_types, and cmd_descs_generate::str.

RZ_LIB_VERSION_HEADER()

RZ_LIB_VERSION_HEADER

(

rz_lib

)