amxb_ubus.c File Reference

#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <amxc/amxc_string_split.h>
#include <amxb_be_ubus/amxb_be_ubus.h>
#include "amxb_ubus.h"
#include <amxb_ubus_version.h>

Go to the source code of this file.

Functions
static void	amxb_ubus_remove_sub (AMXB_UNUSED const char *key, amxc_htable_it_t *it)
static int	amxb_ubus_set_config (amxc_var_t *const configuration)
static void	amxb_ubus_remove_connections (amxc_llist_it_t *lit)
static void	amxb_ubus_reactivate_subscription (UNUSED amxp_timer_t *timer, void *priv)
static void	amxb_ubus_watcher (UNUSED struct ubus_context *ctx, struct ubus_event_handler *ev, UNUSED const char *type, struct blob_attr *msg)
static void	amxb_ubus_object_available (UNUSED amxp_timer_t *timer, UNUSED void *priv)
static void	amxb_ubus_wait_watcher (UNUSED struct ubus_context *ctx, UNUSED struct ubus_event_handler *ev, UNUSED const char *type, struct blob_attr *msg)
static void	amxb_ubus_config_changed (UNUSED const char *const sig_name, UNUSED const amxc_var_t *const data, void *const priv)
const amxc_var_t *	amxb_ubus_get_config_option (const char *name)
void *PRIVATE	amxb_ubus_connect (const char *host, const char *port, const char *path, amxp_signal_mngr_t *sigmngr)
int PRIVATE	amxb_ubus_disconnect (void *ctx)
int PRIVATE	amxb_ubus_get_fd (void *ctx)
int PRIVATE	amxb_ubus_read (void *ctx)
void PRIVATE	amxb_ubus_free (void *ctx)
static void	amxb_ubus_wait_for_done (UNUSED const char *const sig_name, UNUSED const amxc_var_t *const d, void *const priv)
static int	amxb_ubus_wait_for (void *const ctx, UNUSED const char *object)
static uint32_t	amxb_ubus_capabilities (UNUSED void *ctx)
static bool	amxb_ubus_has (void *ctx, const char *object)
amxb_be_info_t *	amxb_be_info (void)
int	amxb_be_ubus_init (void)
int	amxb_be_ubus_clean (void)

Variables
static const amxc_var_t *	config_opts = NULL
static amxp_timer_t *	wait_timer = NULL
static amxc_llist_t	avaiable_paths
static amxb_be_funcs_t	amxb_ubus_impl
static amxb_version_t	sup_min_lib_version
static amxb_version_t	sup_max_lib_version
static amxb_version_t	ubus_be_version
amxb_be_info_t	amxb_ubus_be_info

Function Documentation

amxb_be_info()

amxb_be_info_t* amxb_be_info

(

void

)

Definition at line 442 of file amxb_ubus.c.

                                   {
    return &amxb_ubus_be_info;
}

Here is the caller graph for this function:

amxb_be_ubus_clean()

int amxb_be_ubus_clean

(

void

)

Definition at line 450 of file amxb_ubus.c.

                             {
    amxc_llist_clean(&amxb_ubus_impl.connections, amxb_ubus_remove_connections);
 
    return amxb_be_unregister(&amxb_ubus_impl);
}

Here is the call graph for this function:

amxb_be_ubus_init()

int amxb_be_ubus_init

(

void

)

Definition at line 446 of file amxb_ubus.c.

                            {
    return amxb_be_register(&amxb_ubus_impl);
}

amxb_ubus_capabilities()

static uint32_t amxb_ubus_capabilities ( UNUSED void *  ctx )

static

Definition at line 356 of file amxb_ubus.c.

                                                         {
    return AMXB_BE_DISCOVER | AMXB_BE_DISCOVER_RESOLVE;
}

amxb_ubus_config_changed()

static void amxb_ubus_config_changed ( UNUSED const char *const  sig_name, UNUSED const amxc_var_t *const  data, void *const  priv  )

static

Definition at line 200 of file amxb_ubus.c.

                                                       {
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) priv;
    if(GET_BOOL(config_opts, "watch-ubus-events")) {
        if(amxb_ubus_ctx->watcher.cb == NULL) {
            amxb_ubus_ctx->watcher.cb = amxb_ubus_watcher;
            ubus_register_event_handler(amxb_ubus_ctx->ubus_ctx,
                                        &amxb_ubus_ctx->watcher, "ubus.object.add");
        }
    } else {
        if(amxb_ubus_ctx->watcher.cb != NULL) {
            ubus_unregister_event_handler(amxb_ubus_ctx->ubus_ctx, &amxb_ubus_ctx->watcher);
            amxb_ubus_ctx->watcher.cb = NULL;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

amxb_ubus_connect()

void* PRIVATE amxb_ubus_connect	(	const char *	host,
		const char *	port,
		const char *	path,
		amxp_signal_mngr_t *	sigmngr
	)

Definition at line 222 of file amxb_ubus.c.

                                                             {
    amxb_ubus_t* amxb_ubus_ctx = NULL;
 
    when_not_null(host, exit);
    when_not_null(port, exit);
 
    amxb_ubus_ctx = (amxb_ubus_t*) calloc(1, sizeof(amxb_ubus_t));
    when_null(amxb_ubus_ctx, exit);
 
    amxb_ubus_ctx->ubus_ctx = ubus_connect(path);
    if(amxb_ubus_ctx->ubus_ctx == NULL) {
        free(amxb_ubus_ctx);
        amxb_ubus_ctx = NULL;
        goto exit;
    }
 
    amxc_htable_init(&amxb_ubus_ctx->subscribers, 5);
    blob_buf_init(&amxb_ubus_ctx->b, 0);
    amxb_ubus_ctx->sigmngr = sigmngr;
    amxc_llist_init(&amxb_ubus_ctx->registered_objs);
    amxc_llist_init(&amxb_ubus_ctx->pending_reqs);
 
    if(GET_BOOL(config_opts, "watch-ubus-events")) {
        amxb_ubus_ctx->watcher.cb = amxb_ubus_watcher;
        ubus_register_event_handler(amxb_ubus_ctx->ubus_ctx,
                                    &amxb_ubus_ctx->watcher, "ubus.object.add");
    }
    amxp_slot_connect(NULL,
                      "config:changed",
                      NULL,
                      amxb_ubus_config_changed,
                      amxb_ubus_ctx);
 
exit:
    return amxb_ubus_ctx;
}

Here is the call graph for this function:

Here is the caller graph for this function:

amxb_ubus_disconnect()

int PRIVATE amxb_ubus_disconnect

(

void *

ctx

)

Definition at line 262 of file amxb_ubus.c.

                                            {
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) ctx;
 
    when_null(amxb_ubus_ctx, exit);
    when_null(amxb_ubus_ctx->ubus_ctx, exit);
 
    amxp_slot_disconnect_with_priv(NULL,
                                   amxb_ubus_config_changed,
                                   amxb_ubus_ctx);
 
    amxc_htable_clean(&amxb_ubus_ctx->subscribers, amxb_ubus_remove_sub);
    amxb_ubus_cancel_requests(amxb_ubus_ctx);
    ubus_free(amxb_ubus_ctx->ubus_ctx);
    blob_buf_free(&amxb_ubus_ctx->b);
    amxb_ubus_ctx->ubus_ctx = NULL;
 
exit:
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

amxb_ubus_free()

void PRIVATE amxb_ubus_free

(

void *

ctx

)

Definition at line 316 of file amxb_ubus.c.

                                       {
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) ctx;
 
    when_null(amxb_ubus_ctx, exit);
    amxc_llist_clean(&amxb_ubus_ctx->registered_objs, amxb_ubus_obj_it_free);
    free(amxb_ubus_ctx);
 
exit:
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

amxb_ubus_get_config_option()

const amxc_var_t* amxb_ubus_get_config_option

(

const char *

name

)

Definition at line 218 of file amxb_ubus.c.

                                                                {
    return GET_ARG(config_opts, name);
}

amxb_ubus_get_fd()

int PRIVATE amxb_ubus_get_fd

(

void *

ctx

)

Definition at line 282 of file amxb_ubus.c.

                                        {
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) ctx;
    int fd = -1;
 
    when_null(amxb_ubus_ctx, exit);
    when_null(amxb_ubus_ctx->ubus_ctx, exit);
 
    fd = amxb_ubus_ctx->ubus_ctx->sock.fd;
 
exit:
    return fd;
}

Here is the caller graph for this function:

amxb_ubus_has()

static bool amxb_ubus_has ( void *  ctx, const char *  object  )

static

Definition at line 360 of file amxb_ubus.c.

                                                         {
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) ctx;
    int retval = -1;
    bool has_object = false;
    uint32_t id = 0;
    when_null(object, exit);
 
    retval = ubus_lookup_id(amxb_ubus_ctx->ubus_ctx, object, &id);
 
    when_failed(retval, exit);
 
    has_object = (id != 0);
 
exit:
    return has_object;
}

amxb_ubus_object_available()

static void amxb_ubus_object_available ( UNUSED amxp_timer_t *  timer, UNUSED void *  priv  )

static

Definition at line 163 of file amxb_ubus.c.

                                                                                      {
    amxc_llist_for_each(it, &avaiable_paths) {
        amxc_string_t* path = amxc_string_from_llist_it(it);
        amxp_sigmngr_emit_signal(NULL, amxc_string_get(path, 0), NULL);
        amxc_string_delete(&path);
    }
 
    amxp_timer_delete(&wait_timer);
}

Here is the caller graph for this function:

amxb_ubus_reactivate_subscription()

static void amxb_ubus_reactivate_subscription ( UNUSED amxp_timer_t *  timer, void *  priv  )

static

Definition at line 103 of file amxb_ubus.c.

                                                                                      {
    amxb_ubus_sub_t* amxb_ubus_sub = (amxb_ubus_sub_t*) priv;
    amxc_htable_t* subscribers = NULL;
    amxb_ubus_t* amxb_ubus_ctx = NULL;
    const char* path = NULL;
    int ret = 0;
 
    subscribers = container_of(amxb_ubus_sub->it.ait->array, amxc_htable_t, table);
    amxb_ubus_ctx = container_of(subscribers, amxb_ubus_t, subscribers);
    path = amxc_htable_it_get_key(&amxb_ubus_sub->it);
 
    amxc_htable_it_take(&amxb_ubus_sub->it);
    ret = ubus_unregister_subscriber(amxb_ubus_ctx->ubus_ctx, &amxb_ubus_sub->sub);
    when_failed(ret, exit);
    amxb_ubus_subscribe(amxb_ubus_ctx, path);
 
exit:
    amxp_timer_delete(&amxb_ubus_sub->reactivate);
    amxc_htable_it_clean(&amxb_ubus_sub->it, NULL);
    free(amxb_ubus_sub);
}

Here is the call graph for this function:

Here is the caller graph for this function:

amxb_ubus_read()

int PRIVATE amxb_ubus_read

(

void *

ctx

)

Definition at line 295 of file amxb_ubus.c.

                                      {
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) ctx;
    struct ubus_context* ubus_ctx = NULL;
    int retval = -1;
 
    when_null(amxb_ubus_ctx, exit);
    when_null(amxb_ubus_ctx->ubus_ctx, exit);
 
    ubus_ctx = amxb_ubus_ctx->ubus_ctx;
    ubus_ctx->sock.cb(&ubus_ctx->sock, ULOOP_READ);
 
    if(ubus_ctx->sock.eof) {
        retval = -1;
    } else {
        retval = 0;
    }
 
exit:
    return retval;
}

amxb_ubus_remove_connections()

static void amxb_ubus_remove_connections ( amxc_llist_it_t *  lit )

static

Definition at line 98 of file amxb_ubus.c.

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

Here is the caller graph for this function:

amxb_ubus_remove_sub()

static void amxb_ubus_remove_sub ( AMXB_UNUSED const char *  key, amxc_htable_it_t *  it  )

static

Definition at line 71 of file amxb_ubus.c.

                                                       {
    amxb_ubus_sub_t* sub = amxc_htable_it_get_data(it, amxb_ubus_sub_t, it);
    amxp_timer_delete(&sub->reactivate);
    free(sub);
}

Here is the caller graph for this function:

amxb_ubus_set_config()

static int amxb_ubus_set_config ( amxc_var_t *const  configuration )

static

Definition at line 78 of file amxb_ubus.c.

                                                                 {
    struct stat sb;
    amxc_var_t* uris = GET_ARG(configuration, "uris");
 
    config_opts = configuration;
 
    if((configuration != NULL) && (uris == NULL)) {
        uris = amxc_var_add_key(amxc_llist_t, configuration, "uris", NULL);
    }
 
    if(stat("/var/run/ubus.sock", &sb) == 0) {
        amxc_var_add(cstring_t, uris, "ubus:/var/run/ubus.sock");
    }
    if(stat("/var/run/ubus/ubus.sock", &sb) == 0) {
        amxc_var_add(cstring_t, uris, "ubus:/var/run/ubus/ubus.sock");
    }
 
    return 0;
}

amxb_ubus_wait_for()

static int amxb_ubus_wait_for ( void *const  ctx, UNUSED const char *  object  )

static

Definition at line 338 of file amxb_ubus.c.

                                                                          {
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) ctx;
    int retval = -1;
 
    when_null(amxb_ubus_ctx, exit);
    if(amxb_ubus_ctx->wait_watcher.cb == NULL) {
        amxb_ubus_ctx->wait_watcher.cb = amxb_ubus_wait_watcher;
        ubus_register_event_handler(amxb_ubus_ctx->ubus_ctx,
                                    &amxb_ubus_ctx->wait_watcher, "ubus.object.add");
        amxp_slot_connect(NULL, "wait:done", NULL, amxb_ubus_wait_for_done, amxb_ubus_ctx);
    }
 
    retval = 0;
 
exit:
    return retval;
}

Here is the call graph for this function:

amxb_ubus_wait_for_done()

static void amxb_ubus_wait_for_done ( UNUSED const char *const  sig_name, UNUSED const amxc_var_t *const  d, void *const  priv  )

static

Definition at line 327 of file amxb_ubus.c.

                                                      {
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) priv;
    if(amxb_ubus_ctx->wait_watcher.cb != NULL) {
        ubus_unregister_event_handler(amxb_ubus_ctx->ubus_ctx, &amxb_ubus_ctx->wait_watcher);
        amxb_ubus_ctx->wait_watcher.cb = NULL;
        amxp_slot_disconnect_with_priv(NULL, amxb_ubus_wait_for_done, amxb_ubus_ctx);
    }
}

Here is the caller graph for this function:

amxb_ubus_wait_watcher()

static void amxb_ubus_wait_watcher ( UNUSED struct ubus_context *  ctx, UNUSED struct ubus_event_handler *  ev, UNUSED const char *  type, struct blob_attr *  msg  )

static

Definition at line 173 of file amxb_ubus.c.

                                                          {
    amxc_var_t watch_event;
    amxc_string_t* sig_name = NULL;
 
    amxc_var_init(&watch_event);
    amxc_var_set_type(&watch_event, AMXC_VAR_ID_HTABLE);
    amxb_ubus_parse_blob_table(&watch_event,
                               (struct blob_attr*) blob_data(msg),
                               blob_len(msg));
 
    amxc_string_new(&sig_name, 0);
    amxc_string_setf(sig_name, "wait:%s.", GET_CHAR(&watch_event, "path"));
    if(amxp_sigmngr_find_signal(NULL, amxc_string_get(sig_name, 0)) != NULL) {
        amxc_llist_append(&avaiable_paths, &sig_name->it);
        if(wait_timer == NULL) {
            amxp_timer_new(&wait_timer, amxb_ubus_object_available, NULL);
        }
        amxp_timer_start(wait_timer, 100);
    } else {
        amxc_string_delete(&sig_name);
    }
    amxc_var_clean(&watch_event);
}

Here is the call graph for this function:

Here is the caller graph for this function:

amxb_ubus_watcher()

static void amxb_ubus_watcher ( UNUSED struct ubus_context *  ctx, struct ubus_event_handler *  ev, UNUSED const char *  type, struct blob_attr *  msg  )

static

Definition at line 125 of file amxb_ubus.c.

                                                     {
    amxb_ubus_t* amxb_ubus_ctx = container_of(ev, amxb_ubus_t, watcher);
    amxc_var_t watch_event;
    amxc_htable_it_t* it = NULL;
    const char* p = NULL;
    amxb_ubus_sub_t* amxb_ubus_sub = NULL;
    amxc_string_t signal_name;
 
    amxc_string_init(&signal_name, 0);
    amxc_var_init(&watch_event);
    amxc_var_set_type(&watch_event, AMXC_VAR_ID_HTABLE);
    amxb_ubus_parse_blob_table(&watch_event,
                               (struct blob_attr*) blob_data(msg),
                               blob_len(msg));
 
    p = GET_CHAR(&watch_event, "path");
    amxc_string_setf(&signal_name, "wait:%s.", p);
    amxp_sigmngr_trigger_signal(NULL, amxc_string_get(&signal_name, 0), NULL);
 
    it = amxc_htable_get(&amxb_ubus_ctx->subscribers, p);
    when_null(it, exit);
    amxb_ubus_sub = amxc_container_of(it, amxb_ubus_sub_t, it);
 
    if(amxb_ubus_sub->reactivate == NULL) {
        amxp_timer_new(&amxb_ubus_sub->reactivate,
                       amxb_ubus_reactivate_subscription,
                       amxb_ubus_sub);
    }
    amxp_timer_start(amxb_ubus_sub->reactivate, 100);
 
exit:
    amxc_string_clean(&signal_name);
    amxc_var_clean(&watch_event);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

amxb_ubus_be_info

amxb_be_info_t amxb_ubus_be_info

Initial value:

= {
    .min_supported = &sup_min_lib_version,
    .max_supported = &sup_max_lib_version,
    .be_version = &ubus_be_version,
    .name = "ubus",
    .description = "AMXB Backend for UBUS (Openwrt/Prplwrt)",
    .funcs = &amxb_ubus_impl,
}

Definition at line 433 of file amxb_ubus.c.

amxb_ubus_impl

amxb_be_funcs_t amxb_ubus_impl

static

Definition at line 377 of file amxb_ubus.c.

avaiable_paths

amxc_llist_t avaiable_paths

static

Definition at line 69 of file amxb_ubus.c.

config_opts

const amxc_var_t* config_opts = NULL

static

Definition at line 67 of file amxb_ubus.c.

sup_max_lib_version

amxb_version_t sup_max_lib_version

static

Initial value:

= {
    .major = 4,
    .minor = -1,
    .build = -1
}

Definition at line 421 of file amxb_ubus.c.

sup_min_lib_version

amxb_version_t sup_min_lib_version

static

Initial value:

= {
    .major = 4,
    .minor = 8,
    .build = 0
}

Definition at line 415 of file amxb_ubus.c.

ubus_be_version

amxb_version_t ubus_be_version

static

Initial value:

= {
    .major = AMXB_UBUS_VERSION_MAJOR,
    .minor = AMXB_UBUS_VERSION_MINOR,
    .build = AMXB_UBUS_VERSION_BUILD,
}

Definition at line 427 of file amxb_ubus.c.

wait_timer

amxp_timer_t* wait_timer = NULL

static

Definition at line 68 of file amxb_ubus.c.