amxb_backend_mngr.c File Reference

#include <dlfcn.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <amxc/amxc.h>
#include <amxp/amxp.h>
#include <amxd/amxd_dm.h>
#include <amxd/amxd_object.h>
#include <amxd/amxd_path.h>
#include <amxb/amxb_be_intf.h>
#include <amxb/amxb.h>
#include "amxb_priv.h"
#include "amxb_version.h"

Go to the source code of this file.

Data Structures
struct	_amxb_who_has_cache

Macros
#define	_GNU_SOURCE

Typedefs
typedef struct _amxb_who_has_cache	amxb_who_has_cache_t

Functions
static int	amxb_close_backend (UNUSED amxb_be_funcs_t *fns)
static void	amxb_be_remove_connections (amxc_llist_it_t *lit)
static void	amxb_be_remove_backend (UNUSED const char *key, amxc_htable_it_t *it)
static int	amxb_be_invoke_on_all_connections (amxc_llist_t *connections, amxb_be_task_fn_t fn, const amxc_var_t *args, uint32_t type, void *priv)
static bool	amxb_has_object (amxb_bus_ctx_t *bus_ctx, const char *object, bool full_match)
static void	amxb_be_object_exists (UNUSED const amxb_bus_ctx_t *bus_ctx, const amxc_var_t *const data, void *priv)
static amxb_bus_ctx_t *	amxb_be_find_connection (amxc_llist_t *connections, const char *object_path, bool full_match)
static void	amxb_apply_be_config (amxb_be_funcs_t *funcs, amxc_var_t *const config)
amxb_bus_ctx_t *	amxb_be_who_has_impl (const char *object_path, bool full_match)
int	amxb_check_version (const amxb_version_t *be_version)
	Compares the given version with the library version. More...
int	amxb_check_be_versions (const amxb_version_t *min, const amxb_version_t *max)
	Checks if the library version is in the given range. More...
const amxb_version_t *	amxb_get_version (void)
	Gets the version of the library. More...
int	amxb_be_register (amxb_be_funcs_t *const funcs)
	Registers backend interface. More...
int	amxb_be_unregister (amxb_be_funcs_t *const funcs)
	Unregisters a backend interface. More...
amxb_be_funcs_t *	amxb_be_find (const char *name)
	Gets a backend function table using its name. More...
const amxb_be_info_t *	amxb_be_get_info (const char *name)
	Gets a backend information. More...
int	amxb_be_load (const char *path_name)
	Loads a shared object that implements a bus specific backend interface. More...
int	amxb_be_load_multiple (amxc_var_t *const bes)
	Loads multiple shared objects that each implement a bus specific backend interface. More...
int	amxb_be_remove (const char *backend_name)
	Removes and unloads a backend with a given name. More...
void	amxb_be_remove_all (void)
	Removes and unloads all backends. More...
amxc_array_t *	amxb_be_list (void)
	Get the loaded back-end names. More...
int	amxb_be_for_all_connections (amxb_be_task_fn_t fn, const amxc_var_t *args, void *priv)
	Calls a function on all open connections. More...
int	amxb_be_for_all_listeners (amxb_be_task_fn_t fn, const amxc_var_t *args, void *priv)
	Calls a function on all listen sockets. More...
amxb_bus_ctx_t *	amxb_be_who_has (const char *object_path)
	Searches a bus context that can provide a certain object. More...
void	amxb_be_cache_remove_ctx (amxb_bus_ctx_t *ctx)
	Removes a bus context from the lookup cache. More...
void	amxb_be_cache_remove_path (const char *object_path)
	Removes an object path and its corresponding bus context from the lookup cache. More...
void	amxb_be_cache_set_size (uint32_t size)
	Changes the size of the lookup cache. More...
int	amxb_set_config (amxc_var_t *const config)
	Passes configuration options to the backends. More...
static CONSTRUCTOR void	amxb_cache_init (void)
static DESTRUCTOR void	amxb_cache_clean (void)

Variables
static amxc_htable_t	amxb_backends
static amxb_be_funcs_t *	current_be = NULL
static const amxc_var_t *	amxb_conf = NULL
static uint32_t	amxb_cache_size = 5
static amxc_llist_t	amxb_cache_list
static amxc_htable_t	amxb_cache_table
static amxb_version_t	lib_version

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE

Definition at line 56 of file amxb_backend_mngr.c.

Typedef Documentation

amxb_who_has_cache_t

typedef struct _amxb_who_has_cache amxb_who_has_cache_t

Function Documentation

amxb_apply_be_config()

static void amxb_apply_be_config ( amxb_be_funcs_t *  funcs, amxc_var_t *const  config  )

static

Definition at line 250 of file amxb_backend_mngr.c.

                                                           {
    if(amxb_is_valid_be_func(funcs, set_config, funcs->set_config)) {
        funcs->set_config(config);
    }
}

amxb_be_find_connection()

static amxb_bus_ctx_t* amxb_be_find_connection ( amxc_llist_t *  connections, const char *  object_path, bool  full_match  )

static

Definition at line 189 of file amxb_backend_mngr.c.

                                                                {
    amxb_bus_ctx_t* ctx = NULL;
    amxc_var_t data;
    bool found = false;
    amxd_path_t path;
    char* fixed_path = NULL;
    uint32_t caps = 0;
 
    amxd_path_init(&path, NULL);
    amxc_var_init(&data);
    amxd_path_setf(&path, true, "%s", object_path);
    fixed_path = amxd_path_get_fixed_part(&path, false);
 
    // remove the trailing dot if any
    if((fixed_path != NULL) && (*fixed_path != 0)) {
        int len = strlen(fixed_path);
        if(fixed_path[len - 1] == '.') {
            fixed_path[len - 1] = 0;
        }
    }
 
    amxc_llist_for_each(it, connections) {
        ctx = amxc_llist_it_get_data(it, amxb_bus_ctx_t, it);
        if(ctx->socket_type == AMXB_LISTEN_SOCK) {
            ctx = NULL;
            continue;
        }
        if(amxb_is_local_object(ctx, fixed_path)) {
            break;
        }
        caps = amxb_be_get_capabilities(ctx);
        if(((caps & AMXB_BE_DISCOVER) == AMXB_BE_DISCOVER) &&
           amxb_has_object(ctx, fixed_path, full_match)) {
            break;
        }
        if(((caps & AMXB_BE_DISCOVER_DESCRIBE) == AMXB_BE_DISCOVER_DESCRIBE) &&
           ( amxb_describe(ctx, fixed_path, AMXB_FLAG_EXISTS, &data, 5) == 0)) {
            if(amxc_var_is_null(&data)) {
                ctx = NULL;
                continue;
            }
            break;
        }
        if((caps & AMXB_BE_DISCOVER_LIST) == AMXB_BE_DISCOVER_LIST) {
            amxb_list(ctx, fixed_path, AMXB_FLAG_FIRST_LVL | AMXB_FLAG_EXISTS,
                      amxb_be_object_exists, &found);
            if(found) {
                break;
            }
        }
        ctx = NULL;
    }
 
    free(fixed_path);
    amxd_path_clean(&path);
    amxc_var_clean(&data);
    return ctx;
}

amxb_be_invoke_on_all_connections()

static int amxb_be_invoke_on_all_connections ( amxc_llist_t *  connections, amxb_be_task_fn_t  fn, const amxc_var_t *  args, uint32_t  type, void *  priv  )

static

Definition at line 130 of file amxb_backend_mngr.c.

                                                         {
    int retval = 0;
 
    amxc_llist_for_each(it, connections) {
        amxb_bus_ctx_t* ctx = amxc_llist_it_get_data(it, amxb_bus_ctx_t, it);
        if(ctx->socket_type != type) {
            continue;
        }
        retval = fn(ctx, args, priv);
        when_failed(retval, exit);
    }
 
exit:
    return retval;
}

amxb_be_object_exists()

static void amxb_be_object_exists ( UNUSED const amxb_bus_ctx_t *  bus_ctx, const amxc_var_t *const  data, void *  priv  )

static

Definition at line 179 of file amxb_backend_mngr.c.

                                              {
    bool* found = (bool*) priv;
 
    if(data != NULL) {
        *found = true;
    }
}

amxb_be_remove_backend()

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

static

Definition at line 119 of file amxb_backend_mngr.c.

                                                         {
    amxb_be_funcs_t* fns = NULL;
 
    fns = amxc_htable_it_get_data(it, amxb_be_funcs_t, it);
    amxc_llist_clean(&fns->connections, amxb_be_remove_connections);
    if(fns->handle != NULL) {
        amxb_close_backend(fns);
    }
}

amxb_be_remove_connections()

static void amxb_be_remove_connections ( amxc_llist_it_t *  lit )

static

Definition at line 114 of file amxb_backend_mngr.c.

                                                             {
    amxb_bus_ctx_t* bus_ctx = amxc_llist_it_get_data(lit, amxb_bus_ctx_t, it);
    amxb_free(&bus_ctx);
}

amxb_be_who_has_impl()

amxb_bus_ctx_t* amxb_be_who_has_impl	(	const char *	object_path,
		bool	full_match
	)

Definition at line 257 of file amxb_backend_mngr.c.

                                                                               {
    amxb_bus_ctx_t* ctx = NULL;
    amxc_htable_it_t* cache_hit = NULL;
    amxb_who_has_cache_t* cache = NULL;
 
    when_str_empty(object_path, exit);
    when_true(strcmp(object_path, ".") == 0, exit);
 
    cache_hit = amxc_htable_get(&amxb_cache_table, object_path);
    if(cache_hit != NULL) {
        cache = amxc_container_of(cache_hit, amxb_who_has_cache_t, hit);
        ctx = cache->ctx;
        amxc_llist_prepend(&amxb_cache_list, &cache->lit);
        goto exit;
    }
 
    amxc_htable_for_each(hit, &amxb_backends) {
        amxb_be_funcs_t* funcs = amxc_htable_it_get_data(hit, amxb_be_funcs_t, it);
        ctx = amxb_be_find_connection(&funcs->connections, object_path, full_match);
        if(ctx == NULL) {
            continue;
        }
        if(amxb_cache_size == 0) {
            break;
        }
        if(amxc_htable_size(&amxb_cache_table) >= amxb_cache_size) {
            amxc_llist_it_t* it = amxc_llist_take_last(&amxb_cache_list);
            if(it != NULL) {
                cache = amxc_container_of(it, amxb_who_has_cache_t, lit);
                amxc_htable_it_clean(&cache->hit, NULL);
                free(cache);
            }
        }
 
        cache = (amxb_who_has_cache_t*) calloc(1, sizeof(amxb_who_has_cache_t));
        when_null(cache, exit);
        cache->ctx = ctx;
        amxc_htable_insert(&amxb_cache_table, object_path, &cache->hit);
        amxc_llist_prepend(&amxb_cache_list, &cache->lit);
        break;
    }
 
exit:
    return ctx;
}

amxb_cache_clean()

static DESTRUCTOR void amxb_cache_clean ( void  )

static

Definition at line 732 of file amxb_backend_mngr.c.

                                              {
    amxc_htable_clean(&amxb_cache_table, NULL);
}

amxb_cache_init()

static CONSTRUCTOR void amxb_cache_init ( void  )

static

Definition at line 728 of file amxb_backend_mngr.c.

                                              {
    amxc_htable_init(&amxb_cache_table, amxb_cache_size * 2);
}

amxb_close_backend()

static int amxb_close_backend ( UNUSED amxb_be_funcs_t *  fns )

static

Definition at line 97 of file amxb_backend_mngr.c.

                                                           {
    void* handle = fns->handle;
    char* no_dlclose = getenv("AMXB_NO_DLCLOSE");
    int retval = 0;
 
    fns->handle = NULL;
    if(no_dlclose == NULL) {
        retval = dlclose(handle);
        if(retval != 0) {
            const char* errstr = dlerror();
            printf("dlclose failed - %s", errstr != NULL? errstr:"no error");
        }
    }
 
    return retval;
}

amxb_has_object()

static bool amxb_has_object ( amxb_bus_ctx_t *  bus_ctx, const char *  object, bool  full_match  )

static

Definition at line 150 of file amxb_backend_mngr.c.

                                                                                          {
    bool retval = false;
    const amxb_be_funcs_t* fns = NULL;
 
    fns = bus_ctx->bus_fn;
    if(amxb_is_valid_be_func(fns, has, fns->has)) {
        if(full_match) {
            retval = fns->has(bus_ctx->bus_ctx, object);
        } else {
            amxd_path_t path;
            char* part = NULL;
 
            amxd_path_init(&path, NULL);
            amxd_path_setf(&path, true, "%s", object);
 
            do {
                free(part);
                object = amxd_path_get(&path, 0);
                retval = fns->has(bus_ctx->bus_ctx, object);
                part = amxd_path_get_last(&path, true);
            } while(part != NULL && !retval);
            free(part);
            amxd_path_clean(&path);
        }
    }
 
    return retval;
}

Variable Documentation

amxb_backends

amxc_htable_t amxb_backends

static

Definition at line 83 of file amxb_backend_mngr.c.

amxb_cache_list

amxc_llist_t amxb_cache_list

static

Definition at line 88 of file amxb_backend_mngr.c.

amxb_cache_size

uint32_t amxb_cache_size = 5

static

Definition at line 87 of file amxb_backend_mngr.c.

amxb_cache_table

amxc_htable_t amxb_cache_table

static

Definition at line 89 of file amxb_backend_mngr.c.

amxb_conf

const amxc_var_t* amxb_conf = NULL

static

Definition at line 85 of file amxb_backend_mngr.c.

current_be

amxb_be_funcs_t* current_be = NULL

static

Definition at line 84 of file amxb_backend_mngr.c.

lib_version

amxb_version_t lib_version

static

Initial value:

= {
    .major = AMXB_VERSION_MAJOR,
    .minor = AMXB_VERSION_MINOR,
    .build = AMXB_VERSION_BUILD
}

Definition at line 91 of file amxb_backend_mngr.c.