Import Resolver API

Collaboration diagram for Import Resolver API:

Functions
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_close_all (void)
	Unloads all loaded shared objects. More...

Detailed Description

Function Documentation

amxo_resolver_import_close_all()

void amxo_resolver_import_close_all

(

void

)

Unloads all loaded shared objects.

Removes all loaded shared objects from memory, regardless whether they are referenced. This function is typically called just before exiting the application,

Warning

Call this method before exiting the application. Do not call this method when resolved functions are still being used.

Definition at line 451 of file amxo_import_resolver.c.

                                          {
    amxc_htable_clean(&import_libs, amxo_import_lib_free);
    amxc_htable_init(&import_libs, 10);
}

amxo_resolver_import_open()

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)

The import function resolver can load shared objects. During parsing of the odl file all "import" mentions will call this method to open and load the shared object.

Using this function it is possible to load shared objects prior to start parsing an odl file.

After parsing the referenced shared objects are kept in memory. When they are not needed anymore they can be unloaded by using amxo_resolver_import_close_all

Note

The alias must be unique, if another shared object is loaded with same alias the loading will fail.

Warning

After parsing of an odl file, all shared objects not referenced are unloaded. A shared object is considered referenced when at least one function is resolved from that shared object.

Parameters

parser	the odl parser instance
so_name	file name of the shared object (can include relative or absolute path).
alias	alias for the shared object, makes it easier to use in odl files
flags	dlopen flags

Returns

Returns 0 when the function is removed from the function table.

Definition at line 354 of file amxo_import_resolver.c.

                                         {
    int retval = -1;
    void* handle = NULL;
    amxo_import_lib_t* import_lib = NULL;
    char* full_path = NULL;
    bool silent = amxc_var_constcast(bool, GET_OPTION(parser, "silent"));
    const amxc_llist_t* impdirs =
        amxc_var_constcast(amxc_llist_t, GET_OPTION(parser, "import-dirs"));
    amxc_htable_t* import_data = amxo_parser_claim_resolver_data(parser, "import");
    amxc_string_t res_so_name;
    amxc_string_t res_alias;
    amxc_string_init(&res_so_name, 0);
    amxc_string_init(&res_alias, 0);
 
    dbg = amxc_var_constcast(bool, GET_OPTION(parser, "import-dbg"));
 
    when_null(parser, exit);
    parser->status = amxd_status_invalid_arg;
    when_str_empty(so_name, exit);
    when_true(alias != NULL && alias[0] == 0, exit);
 
    parser->status = amxd_status_ok;
    when_true_status(amxo_parser_no_import(parser), exit, retval = 0);
 
    if(amxc_string_set_resolved(&res_alias, alias, &parser->config) > 0) {
        alias = amxc_string_get(&res_alias, 0);
    }
    if(amxc_string_set_resolved(&res_so_name, so_name, &parser->config) > 0) {
        so_name = amxc_string_get(&res_so_name, 0);
    }
 
    when_true_status(amxo_resolver_import_alias_exists(import_data, alias),
                     exit,
                     retval = 0);
 
    if(!amxo_parser_find(parser, impdirs, so_name, &full_path)) {
        if(dbg && !silent) {
            fprintf(stderr, "[IMPORT-DBG] - file not found %s\n", so_name);
        }
        parser->status = amxd_status_file_not_found;
        amxo_parser_msg(parser, "Import file not found !!! \"%s\"", so_name);
        goto exit;
    }
 
    handle = amxo_resolver_import_lib(parser, so_name, full_path, (flags & ~RTLD_NODELETE));
    when_null(handle, exit);
 
    import_lib = (amxo_import_lib_t*) calloc(1, sizeof(amxo_import_lib_t));
    when_true_status(import_lib == NULL, exit, parser->status = amxd_status_out_of_mem);
 
    import_lib->handle = handle;
    if((flags & RTLD_NODELETE) == RTLD_NODELETE) {
        import_lib->references++;
    }
    amxc_htable_insert(import_data, alias, &import_lib->hit);
    retval = 0;
 
exit:
    amxc_string_clean(&res_alias);
    amxc_string_clean(&res_so_name);
    free(full_path);
    if((retval != 0) && (handle != NULL)) {
        dlclose(handle);
    }
    return retval;
}