amxo_import_resolver.c File Reference

#include "amxo_parser_priv.h"

Go to the source code of this file.

Data Structures
struct	_amxo_import_lib
union	_fn_caster

Macros
#define	_GNU_SOURCE
#define	GET_OPTION(parser, name)    amxo_parser_get_config(parser, name)

Typedefs
typedef struct _amxo_import_lib	amxo_import_lib_t
typedef union _fn_caster	fn_caster_t

Functions
static void	amxo_import_lib_free (UNUSED const char *key, amxc_htable_it_t *it)
static void	amxo_resolver_import_defaults (amxo_parser_t *parser, UNUSED void *priv)
static char *	amxo_resolver_import_get_symbol (amxo_parser_t *parser, const char *fn_name, bool prefix)
static amxo_fn_ptr_t	amxo_resolver_try (amxo_parser_t *parser, const char *fn_name, const char *symbol, const char *lib_name, amxo_import_lib_t *lib, amxc_string_t *msg)
static void	amxo_resolver_import_parse_data (const char *data, char **lib, char **symbol)
static amxo_fn_ptr_t	amxo_resolver_import_data (amxo_parser_t *parser, amxc_htable_t *import_data, const char *fn_name, const char *data)
static amxo_fn_ptr_t	amxo_resolver_import (amxo_parser_t *parser, const char *fn_name, UNUSED amxo_fn_type_t type, const char *data, UNUSED void *priv)
static bool	amxo_resolver_import_alias_exists (amxc_htable_t *import_data, const char *alias)
static bool	amxo_parser_no_import (amxo_parser_t *parser)
static void *	amxo_resolver_import_lib (amxo_parser_t *parser, const char *so_name, const char *full_path, int flags)
int	amxo_resolver_import_open (amxo_parser_t *parser, const char *so_name, const char *alias, int flags)
	Opens a shared object file (.so file) More...
void	amxo_resolver_import_clean (amxo_parser_t *parser, UNUSED void *priv)
void	amxo_resolver_import_close_all (void)
	Unloads all loaded shared objects. More...
	CONSTRUCTOR_LVL (110)
	DESTRUCTOR_LVL (110)

Variables
static amxc_htable_t	import_libs
static bool	dbg = false
static amxo_resolver_t	import

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE

Definition at line 56 of file amxo_import_resolver.c.

GET_OPTION

#define GET_OPTION	(		parser,
			name
	)		amxo_parser_get_config(parser, name)

Definition at line 61 of file amxo_import_resolver.c.

Typedef Documentation

amxo_import_lib_t

typedef struct _amxo_import_lib amxo_import_lib_t

fn_caster_t

typedef union _fn_caster fn_caster_t

Function Documentation

amxo_import_lib_free()

static void amxo_import_lib_free ( UNUSED const char *  key, amxc_htable_it_t *  it  )

static

Definition at line 78 of file amxo_import_resolver.c.

                                                       {
    amxo_import_lib_t* import =
        amxc_htable_it_get_data(it, amxo_import_lib_t, hit);
    char* no_dlclose = getenv("AMXO_NO_DLCLOSE");
 
    if(no_dlclose == NULL) {
        dlclose(import->handle);
    }
    free(import);
}

amxo_parser_no_import()

static bool amxo_parser_no_import ( amxo_parser_t *  parser )

static

Definition at line 315 of file amxo_import_resolver.c.

                                                         {
    amxc_var_t* var_import = GET_OPTION(parser, "odl-import");
    bool import = true;
 
    if(var_import != NULL) {
        import = amxc_var_dyncast(bool, var_import);
    }
 
    return !import;
}

amxo_resolver_import()

static amxo_fn_ptr_t amxo_resolver_import ( amxo_parser_t *  parser, const char *  fn_name, UNUSED amxo_fn_type_t  type, const char *  data, UNUSED void *  priv  )

static

Definition at line 254 of file amxo_import_resolver.c.

                                                             {
    amxc_htable_t* import_data = amxo_parser_get_resolver_data(parser, "import");
    amxo_fn_ptr_t fn = NULL;
    amxc_string_t msg;
 
    amxc_string_init(&msg, 0);
 
    if((data != NULL) && (data[0] != 0)) {
        fn = amxo_resolver_import_data(parser, import_data, fn_name, data);
    } else {
        amxc_htable_for_each(it, import_data) {
            const char* lib_name = amxc_htable_it_get_key(it);
            amxo_import_lib_t* import =
                amxc_htable_it_get_data(it, amxo_import_lib_t, hit);
            char* symbol = amxo_resolver_import_get_symbol(parser, fn_name, true);
            fn = amxo_resolver_try(parser, fn_name, symbol, lib_name, import, &msg);
            free(symbol);
            if(fn == NULL) {
                symbol = amxo_resolver_import_get_symbol(parser, fn_name, false);
                fn = amxo_resolver_try(parser, fn_name, symbol, lib_name, import, &msg);
                free(symbol);
            }
            if(fn != NULL) {
                break;
            }
        }
    }
 
    if((fn == NULL) && !amxc_string_is_empty(&msg)) {
        fprintf(stderr, "%s", amxc_string_get(&msg, 0));
    }
 
    amxc_string_clean(&msg);
    return fn;
}

amxo_resolver_import_alias_exists()

static bool amxo_resolver_import_alias_exists ( amxc_htable_t *  import_data, const char *  alias  )

static

Definition at line 294 of file amxo_import_resolver.c.

                                                                 {
    bool retval = true;
    amxc_htable_it_t* it = NULL;
 
    it = amxc_htable_get(&import_libs, alias);
    if(it != NULL) {
        amxc_htable_insert(import_data, alias, it);
        goto exit;
    }
    it = amxc_htable_get(import_data, alias);
    if(it != NULL) {
        goto exit;
    }
 
    retval = false;
 
exit:
    return retval;
}

amxo_resolver_import_clean()

void amxo_resolver_import_clean	(	amxo_parser_t *	parser,
		UNUSED void *	priv
	)

Definition at line 424 of file amxo_import_resolver.c.

                                                   {
    amxc_htable_t* import_data = NULL;
    amxc_htable_it_t* it = NULL;
    bool silent = amxc_var_constcast(bool, GET_OPTION(parser, "silent"));
    dbg = amxc_var_constcast(bool, GET_OPTION(parser, "import-dbg"));
    import_data = amxo_parser_get_resolver_data(parser, "import");
 
    it = amxc_htable_take_first(import_data);
    while(it) {
        amxo_import_lib_t* import =
            amxc_htable_it_get_data(it, amxo_import_lib_t, hit);
        const char* key = amxc_htable_it_get_key(it);
        if(dbg && !silent) {
            fprintf(stderr, "[IMPORT-DBG] - symbols used of %s = %d\n", key, import->references);
        }
        if(import->references != 0) {
            amxc_htable_insert(&import_libs, key, it);
        } else {
            amxc_htable_it_clean(it, amxo_import_lib_free);
        }
        it = amxc_htable_take_first(import_data);
    }
    amxc_htable_clean(import_data, amxo_import_lib_free);
    amxo_parser_remove_resolver_data(parser, "import");
}

amxo_resolver_import_data()

static amxo_fn_ptr_t amxo_resolver_import_data ( amxo_parser_t *  parser, amxc_htable_t *  import_data, const char *  fn_name, const char *  data  )

static

Definition at line 202 of file amxo_import_resolver.c.

                                                                 {
    amxo_fn_ptr_t fn = NULL;
    char* lib = NULL;
    char* symbol = NULL;
    amxc_string_t res_name;
    amxc_htable_it_t* it = NULL;
    amxo_import_lib_t* import = NULL;
    amxc_string_t msg;
    amxc_string_init(&msg, 0);
    amxc_string_init(&res_name, 0);
    amxo_resolver_import_parse_data(data, &lib, &symbol);
 
    if(amxc_string_set_resolved(&res_name, lib, &parser->config) > 0) {
        free(lib);
        lib = amxc_string_take_buffer(&res_name);
    }
 
    it = amxc_htable_get(import_data, lib);
    import = amxc_htable_it_get_data(it, amxo_import_lib_t, hit);
    if(import == NULL) {
        amxo_parser_msg(parser, "No import library found with name \"%s\"", lib);
        parser->status = amxd_status_file_not_found;
        goto exit;
    }
 
    if(symbol != NULL) {
        fn = amxo_resolver_try(parser, fn_name, symbol, lib, import, &msg);
    } else {
        symbol = amxo_resolver_import_get_symbol(parser, fn_name, true);
        fn = amxo_resolver_try(parser, fn_name, symbol, lib, import, &msg);
        when_true(fn != NULL, exit);
        free(symbol);
        symbol = amxo_resolver_import_get_symbol(parser, fn_name, false);
        fn = amxo_resolver_try(parser, fn_name, symbol, lib, import, &msg);
    }
 
    if((fn == NULL) && !amxc_string_is_empty(&msg)) {
        fprintf(stderr, "%s", amxc_string_get(&msg, 0));
    }
 
exit:
    amxc_string_clean(&res_name);
    amxc_string_clean(&msg);
    free(lib);
    free(symbol);
 
    return fn;
}

amxo_resolver_import_defaults()

static void amxo_resolver_import_defaults ( amxo_parser_t *  parser, UNUSED void *  priv  )

static

Definition at line 90 of file amxo_import_resolver.c.

                                                             {
    amxc_var_t* config = amxo_parser_claim_config(parser, "import-dirs");
 
    amxc_var_set_type(config, AMXC_VAR_ID_LIST);
    amxc_var_add(cstring_t, config, ".");
 
    config = amxo_parser_claim_config(parser, "import-dbg");
    amxc_var_set_type(config, AMXC_VAR_ID_BOOL);
    amxc_var_set(bool, config, false);
 
    return;
}

amxo_resolver_import_get_symbol()

static char* amxo_resolver_import_get_symbol ( amxo_parser_t *  parser, const char *  fn_name, bool  prefix  )

static

Definition at line 104 of file amxo_import_resolver.c.

                                                          {
    amxc_string_t symbol;
    amxc_string_init(&symbol, 0);
 
    if(parser->param != NULL) {
        const char* param_name = amxd_param_get_name(parser->param);
        if(prefix) {
            amxc_string_setf(&symbol, "_%s_%s", param_name, fn_name);
        } else {
            amxc_string_setf(&symbol, "_%s", fn_name);
        }
    } else {
        const char* obj_name = amxd_object_get_name(parser->object,
                                                    AMXD_OBJECT_NAMED);
        if(obj_name != NULL) {
            if(prefix) {
                amxc_string_setf(&symbol, "_%s_%s", obj_name, fn_name);
            } else {
                amxc_string_setf(&symbol, "_%s", fn_name);
            }
        } else {
            amxc_string_setf(&symbol, "_%s", fn_name);
        }
    }
 
    return amxc_string_take_buffer(&symbol);
}

amxo_resolver_import_lib()

static void* amxo_resolver_import_lib ( amxo_parser_t *  parser, const char *  so_name, const char *  full_path, int  flags  )

static

Definition at line 326 of file amxo_import_resolver.c.

                                                 {
    void* handle = NULL;
    bool silent = amxc_var_constcast(bool, GET_OPTION(parser, "silent"));
    dbg = amxc_var_constcast(bool, GET_OPTION(parser, "import-dbg"));
 
    if((flags & (RTLD_LAZY | RTLD_NOW)) == 0) {
        flags |= RTLD_LAZY;
    }
    dlerror();
    handle = dlopen(full_path, flags);
    if(handle == NULL) {
        char* error = dlerror();
        if(dbg && !silent) {
            fprintf(stderr, "[IMPORT-DBG] - failed to load %s - %s\n", so_name, error);
        }
        amxc_string_setf(&parser->msg, "Failed to load lib %s", error);
    } else {
        if(dbg && !silent) {
            fprintf(stderr, "[IMPORT-DBG] - dlopen - %s (%p)\n", so_name, handle);
        }
    }
 
    return handle;
}

amxo_resolver_import_parse_data()

static void amxo_resolver_import_parse_data ( const char *  data, char **  lib, char **  symbol  )

static

Definition at line 171 of file amxo_import_resolver.c.

                                                           {
    amxc_string_t str_data;
    amxc_llist_t parts;
    size_t length = 0;
    amxc_llist_it_t* it = NULL;
 
    amxc_llist_init(&parts);
    amxc_string_init(&str_data, 0);
    amxc_string_push_buffer(&str_data, (char*) data, strlen(data) + 1);
    amxc_string_split_to_llist(&str_data, &parts, ':');
    length = amxc_llist_size(&parts);
 
    when_true(length > 2, exit);
 
    it = amxc_llist_get_first(&parts);
    amxc_string_trim(amxc_string_from_llist_it(it), NULL);
    *lib = amxc_string_take_buffer(amxc_string_from_llist_it(it));
 
    if(length > 1) {
        it = amxc_llist_get_last(&parts);
        amxc_string_trim(amxc_string_from_llist_it(it), NULL);
        *symbol = amxc_string_take_buffer(amxc_string_from_llist_it(it));
    }
 
exit:
    amxc_llist_clean(&parts, amxc_string_list_it_free);
    return;
}

amxo_resolver_try()

static amxo_fn_ptr_t amxo_resolver_try ( amxo_parser_t *  parser, const char *  fn_name, const char *  symbol, const char *  lib_name, amxo_import_lib_t *  lib, amxc_string_t *  msg  )

static

Definition at line 134 of file amxo_import_resolver.c.

                                                           {
    char* dl_error = NULL;
    fn_caster_t helper;
    bool silent = amxc_var_constcast(bool, GET_OPTION(parser, "silent"));
    dbg = amxc_var_constcast(bool, GET_OPTION(parser, "import-dbg"));
 
    helper.fn = NULL;
    dlerror();
    helper.fn = dlsym(lib->handle, symbol);
    dl_error = dlerror();
    if(dl_error == NULL) {
        if(dbg && !silent) {
            fprintf(stderr,
                    "[IMPORT-DBG] - symbol %s resolved (for %s) from %s\n",
                    symbol,
                    fn_name,
                    lib_name);
        }
        lib->references++;
    } else {
        if(dbg && !silent) {
            amxc_string_appendf(msg,
                                "[IMPORT-DBG] - resolving symbol %s (for %s) from %s failed - [%s]\n",
                                symbol,
                                fn_name,
                                lib_name,
                                dl_error);
        }
    }
    return helper.amxo_fn;
}

CONSTRUCTOR_LVL()

CONSTRUCTOR_LVL

(

110

)

Definition at line 464 of file amxo_import_resolver.c.

                                                        {
    amxc_htable_init(&import_libs, 10);
    amxo_register_resolver("import", &import);
}

DESTRUCTOR_LVL()

DESTRUCTOR_LVL

(

110

)

Definition at line 469 of file amxo_import_resolver.c.

                                                          {
    amxc_htable_clean(&import_libs, amxo_import_lib_free);
    amxo_unregister_resolver("import");
}

Variable Documentation

dbg

bool dbg = false

static

Definition at line 76 of file amxo_import_resolver.c.

import

amxo_resolver_t import

static

Initial value:

= {
    .hit = { .ait = NULL, .key = NULL, .next = NULL },
    .get = amxo_resolver_import_defaults,
    .resolve = amxo_resolver_import,
    .clean = amxo_resolver_import_clean,
    .priv = NULL
}

Definition at line 456 of file amxo_import_resolver.c.

import_libs

amxc_htable_t import_libs

static

Definition at line 75 of file amxo_import_resolver.c.