amxb_ubus.h File Reference

#include <libubus.h>
#include <libubox/blob.h>
#include <libubox/uloop.h>
#include <libubox/usock.h>
#include <libubox/list.h>
#include <amxc/amxc_macros.h>
#include <amxc/amxc.h>
#include <amxp/amxp.h>
#include <amxd/amxd_dm.h>
#include <amxd/amxd_object.h>
#include <amxd/amxd_function.h>
#include <amxd/amxd_path.h>
#include <amxb/amxb.h>
#include <amxb/amxb_be_intf.h>

Go to the source code of this file.

Data Structures
struct	_amxb_ubus_sub
struct	_amxb_ubus
struct	_amxb_ubus_object
struct	_amxb_ubus_request

Typedefs
typedef struct _amxb_ubus_sub	amxb_ubus_sub_t
typedef struct _amxb_ubus	amxb_ubus_t
typedef struct _amxb_ubus_object	amxb_ubus_object_t
typedef struct _amxb_ubus_request	amxb_ubus_request_t

Functions
amxb_be_info_t *	amxb_be_info (void)
int PRIVATE	amxb_ubus_parse_blob (amxc_var_t *var, struct blob_attr *attr, bool table)
int PRIVATE	amxb_ubus_parse_blob_table (amxc_var_t *var, struct blob_attr *attr, int len)
int PRIVATE	amxb_ubus_parse_blob_array (amxc_var_t *var, struct blob_attr *attr, int len)
int PRIVATE	amxb_ubus_format_blob (amxc_var_t *data, const char *key, struct blob_buf *b)
int PRIVATE	amxb_ubus_format_blob_table (const amxc_htable_t *table, struct blob_buf *b)
int PRIVATE	amxb_ubus_format_blob_array (const amxc_llist_t *list, struct blob_buf *b)
int PRIVATE	amxb_ubus_get_longest_path (amxb_ubus_t *amxb_ubus_ctx, amxd_path_t *path, amxc_string_t *rel_path)
void PRIVATE	amxb_ubus_result_data (struct ubus_request *req, int type, struct blob_attr *msg)
int PRIVATE	amxb_ubus_invoke_base (amxb_ubus_t *amxb_ubus_ctx, const char *object, amxc_var_t *args, amxb_request_t *request, uint32_t *id)
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)
int PRIVATE	amxb_ubus_invoke (void *const ctx, amxb_invoke_t *invoke_ctx, amxc_var_t *args, amxb_request_t *request, int timeout)
int PRIVATE	amxb_ubus_async_invoke (void *const ctx, amxb_invoke_t *invoke_ctx, amxc_var_t *args, amxb_request_t *request)
int PRIVATE	amxb_ubus_wait_request (void *const ctx, amxb_request_t *request, int timeout)
int PRIVATE	amxb_ubus_close_request (void *const ctx, amxb_request_t *request)
int PRIVATE	amxb_ubus_subscribe (void *const ctx, const char *object)
int PRIVATE	amxb_ubus_unsubscribe (void *const ctx, const char *object)
int PRIVATE	amxb_ubus_register (void *const ctx, amxd_dm_t *const dm)
void PRIVATE	amxb_ubus_cancel_requests (amxb_ubus_t *amxb_ubus_ctx)
void PRIVATE	amxb_ubus_obj_it_free (amxc_llist_it_t *it)
int PRIVATE	amxb_ubus_list (void *const bus_ctx, const char *object, uint32_t flags, uint32_t access, amxb_request_t *request)
const amxc_var_t *	amxb_ubus_get_config_option (const char *name)

Typedef Documentation

amxb_ubus_object_t

typedef struct _amxb_ubus_object amxb_ubus_object_t

amxb_ubus_request_t

typedef struct _amxb_ubus_request amxb_ubus_request_t

amxb_ubus_sub_t

typedef struct _amxb_ubus_sub amxb_ubus_sub_t

amxb_ubus_t

typedef struct _amxb_ubus amxb_ubus_t

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_ubus_async_invoke()

int PRIVATE amxb_ubus_async_invoke	(	void *const	ctx,
		amxb_invoke_t *	invoke_ctx,
		amxc_var_t *	args,
		amxb_request_t *	request
	)

Definition at line 405 of file amxb_ubus_invoke.c.

                                                            {
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) ctx;
    uint32_t id = 0;
    int ret = -1;
    amxb_ubus_request_t* amxb_ubus_req = NULL;
 
    when_str_empty(invoke_ctx->object, exit);
    amxb_ubus_req = (amxb_ubus_request_t*) calloc(1, sizeof(amxb_ubus_request_t));
    when_null(amxb_ubus_req, exit);
    amxc_var_init(&amxb_ubus_req->args);
    amxb_ubus_transform_args(&amxb_ubus_req->args, args, invoke_ctx->method);
 
    if(amxb_ubus_invoke_base(amxb_ubus_ctx,
                             invoke_ctx->object,
                             args,
                             request,
                             &id) != 0) {
        when_failed(amxb_ubus_convert(amxb_ubus_ctx, invoke_ctx, &amxb_ubus_req->args), exit);
        when_failed(amxb_ubus_invoke_base(amxb_ubus_ctx,
                                          invoke_ctx->object,
                                          &amxb_ubus_req->args,
                                          request,
                                          &id),
                    exit);
    }
 
    amxb_ubus_req->request = request;
    amxb_ubus_req->id = id;
    request->bus_data = amxb_ubus_req;
 
    amxb_ubus_req->ubus_req = (struct ubus_request*) calloc(1, sizeof(struct ubus_request));
    when_null(amxb_ubus_req->ubus_req, exit);
 
    ret = ubus_invoke_async(amxb_ubus_ctx->ubus_ctx,
                            id,
                            invoke_ctx->method,
                            amxb_ubus_ctx->b.head,
                            amxb_ubus_req->ubus_req);
 
    amxb_ubus_req->ubus_req->data_cb = amxb_ubus_result_data;
    amxb_ubus_req->ubus_req->complete_cb = amxb_ubus_request_done;
    amxb_ubus_req->ubus_req->priv = amxb_ubus_req;
 
    ubus_complete_request_async(amxb_ubus_ctx->ubus_ctx, amxb_ubus_req->ubus_req);
 
exit:
    if(ret != 0) {
        if(amxb_ubus_req != NULL) {
            amxc_var_clean(&amxb_ubus_req->args);
            free(amxb_ubus_req->ubus_req);
        }
        free(amxb_ubus_req);
        request->bus_data = NULL;
    }
    return ret;
}

Here is the call graph for this function:

amxb_ubus_cancel_requests()

void PRIVATE amxb_ubus_cancel_requests

(

amxb_ubus_t *

amxb_ubus_ctx

)

Definition at line 592 of file amxb_ubus_register.c.

                                                                   {
    amxc_var_t ret;
    amxc_var_init(&ret);
    amxc_llist_for_each(it, &amxb_ubus_ctx->pending_reqs) {
        amxb_ubus_fcall_t* fcall = amxc_container_of(it, amxb_ubus_fcall_t, it);
        blob_buf_init(&amxb_ubus_ctx->b, 0);
        amxb_ubus_func_return(fcall->amxb_ubus_ctx, &ret);
        ubus_send_reply(amxb_ubus_ctx->ubus_ctx, &fcall->req, amxb_ubus_ctx->b.head);
 
        ubus_complete_deferred_request(amxb_ubus_ctx->ubus_ctx,
                                       &fcall->req,
                                       UBUS_STATUS_UNKNOWN_ERROR);
 
        amxd_function_set_deferred_cb(fcall->call_id, NULL, NULL);
        amxd_function_deferred_remove(fcall->call_id);
        amxc_llist_it_take(it);
        free(fcall);
    }
 
    amxc_var_clean(&ret);
}

Here is the call graph for this function:

Here is the caller graph for this function:

amxb_ubus_close_request()

int PRIVATE amxb_ubus_close_request	(	void *const	ctx,
		amxb_request_t *	request
	)

Definition at line 475 of file amxb_ubus_invoke.c.

                                                             {
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) ctx;
    amxb_ubus_request_t* amxb_ubus_req = (amxb_ubus_request_t*) request->bus_data;
 
    if(amxb_ubus_req != NULL) {
        struct ubus_request* ubus_req = amxb_ubus_req->ubus_req;
        ubus_abort_request(amxb_ubus_ctx->ubus_ctx, ubus_req);
        amxc_var_clean(&amxb_ubus_req->args);
        free(ubus_req);
        free(amxb_ubus_req);
        request->bus_data = NULL;
    }
    return 0;
}

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_format_blob()

int PRIVATE amxb_ubus_format_blob	(	amxc_var_t *	data,
		const char *	key,
		struct blob_buf *	b
	)

Definition at line 166 of file amxb_ubus_blob.c.

                                                      {
    void* c;
 
    switch(amxc_var_type_of(data)) {
    case AMXC_VAR_ID_BOOL: {
        blobmsg_add_u8(b, key, (uint8_t) amxc_var_constcast(bool, data));
    }
    break;
 
    case AMXC_VAR_ID_INT8: {
        blobmsg_add_u8(b, key, (uint8_t) amxc_var_constcast(int8_t, data));
    }
    break;
    case AMXC_VAR_ID_UINT8: {
        if(amxc_var_constcast(uint8_t, data) > INT8_MAX) {
            blobmsg_add_u16(b, key, (uint16_t) amxc_var_constcast(uint8_t, data));
        } else {
            blobmsg_add_u8(b, key, (uint8_t) amxc_var_constcast(uint8_t, data));
        }
    }
    break;
    case AMXC_VAR_ID_INT16: {
        blobmsg_add_u16(b, key, (uint16_t) amxc_var_constcast(int16_t, data));
    }
    break;
    case AMXC_VAR_ID_UINT16: {
        if(amxc_var_constcast(uint16_t, data) > INT16_MAX) {
            blobmsg_add_u32(b, key, (uint32_t) amxc_var_constcast(uint16_t, data));
        } else {
            blobmsg_add_u16(b, key, (uint16_t) amxc_var_constcast(uint16_t, data));
        }
    }
    break;
    case AMXC_VAR_ID_INT32: {
        blobmsg_add_u32(b, key, (uint32_t) amxc_var_constcast(int32_t, data));
    }
    break;
    case AMXC_VAR_ID_UINT32: {
        if(amxc_var_constcast(uint32_t, data) > INT32_MAX) {
            blobmsg_add_u64(b, key, (uint64_t) amxc_var_constcast(uint32_t, data));
        } else {
            blobmsg_add_u32(b, key, (uint32_t) amxc_var_constcast(uint32_t, data));
        }
    }
    break;
    case AMXC_VAR_ID_INT64: {
        blobmsg_add_u64(b, key, (uint64_t) amxc_var_constcast(int64_t, data));
    }
    break;
    case AMXC_VAR_ID_UINT64: {
        blobmsg_add_u64(b, key, (uint64_t) amxc_var_constcast(uint64_t, data));
    }
    break;
 
    case AMXC_VAR_ID_HTABLE: {
        const amxc_htable_t* table = amxc_var_constcast(amxc_htable_t, data);
        c = blobmsg_open_table(b, key);
        amxb_ubus_format_blob_table(table, b);
        blobmsg_close_table(b, c);
    }
    break;
 
    case AMXC_VAR_ID_LIST: {
        const amxc_llist_t* list = amxc_var_constcast(amxc_llist_t, data);
        c = blobmsg_open_array(b, key);
        amxb_ubus_format_blob_array(list, b);
        blobmsg_close_array(b, c);
    }
    break;
 
    default: {
        char* string = amxc_var_dyncast(cstring_t, data);
        blobmsg_add_string(b, key, string == NULL ? "" : string);
        free(string);
    }
    break;
    }
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

amxb_ubus_format_blob_array()

int PRIVATE amxb_ubus_format_blob_array	(	const amxc_llist_t *	list,
		struct blob_buf *	b
	)

Definition at line 265 of file amxb_ubus_blob.c.

                                                            {
    int retval = -1;
 
    amxc_llist_for_each(it, list) {
        amxc_var_t* data = amxc_var_from_llist_it(it);
        when_failed(amxb_ubus_format_blob(data, NULL, b), exit);
    }
 
    retval = 0;
 
exit:
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

amxb_ubus_format_blob_table()

int PRIVATE amxb_ubus_format_blob_table	(	const amxc_htable_t *	table,
		struct blob_buf *	b
	)

Definition at line 249 of file amxb_ubus_blob.c.

                                                            {
    int retval = -1;
 
    amxc_htable_for_each(it, table) {
        const char* key = amxc_htable_it_get_key(it);
        amxc_var_t* data = amxc_var_from_htable_it(it);
        when_failed(amxb_ubus_format_blob(data, key, b), exit);
    }
 
    retval = 0;
 
exit:
    return retval;
}

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_get_longest_path()

int PRIVATE amxb_ubus_get_longest_path	(	amxb_ubus_t *	amxb_ubus_ctx,
		amxd_path_t *	path,
		amxc_string_t *	rel_path
	)

Definition at line 243 of file amxb_ubus_invoke.c.

                                                                {
    int retval = -1;
    char* part = NULL;
    const char* object = NULL;
    uint32_t id = 0;
 
    do{
        object = amxd_path_get(path, 0);
        when_str_empty(object, exit);
        retval = ubus_lookup_id(amxb_ubus_ctx->ubus_ctx, object, &id);
        if((retval == 0) && (id != 0)) {
            break;
        }
        free(part);
        part = amxd_path_get_last(path, true);
        amxc_string_prependf(rel_path, "%s", part);
    } while (part != NULL);
 
exit:
    free(part);
    return retval;
}

Here is the caller graph for this function:

amxb_ubus_invoke()

int PRIVATE amxb_ubus_invoke	(	void *const	ctx,
		amxb_invoke_t *	invoke_ctx,
		amxc_var_t *	args,
		amxb_request_t *	request,
		int	timeout
	)

Definition at line 331 of file amxb_ubus_invoke.c.

                                          {
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) ctx;
    uint32_t id = 0;
    int ret = amxd_status_unknown_error;
    amxb_ubus_request_t* amxb_ubus_req = NULL;
 
    when_str_empty(invoke_ctx->object, exit);
    amxb_ubus_req = (amxb_ubus_request_t*) calloc(1, sizeof(amxb_ubus_request_t));
    when_null(amxb_ubus_req, exit);
    amxc_var_init(&amxb_ubus_req->args);
    amxb_ubus_transform_args(&amxb_ubus_req->args, args, invoke_ctx->method);
 
    if(amxb_ubus_invoke_base(amxb_ubus_ctx,
                             invoke_ctx->object,
                             args,
                             request,
                             &id) != 0) {
        when_failed(amxb_ubus_convert(amxb_ubus_ctx, invoke_ctx, &amxb_ubus_req->args), exit);
        ret = amxb_ubus_invoke_base(amxb_ubus_ctx,
                                    invoke_ctx->object,
                                    &amxb_ubus_req->args,
                                    request,
                                    &id);
        ret = amxb_ubus_status_to_amxd_status(ret, request->result);
        request->bus_retval = ret;
        amxb_ubus_req->converted = true;
        when_failed(ret, exit);
    }
 
    amxb_ubus_req->request = request;
    request->bus_data = amxb_ubus_req;
 
    ret = ubus_invoke(amxb_ubus_ctx->ubus_ctx,
                      id,
                      invoke_ctx->method,
                      amxb_ubus_ctx->b.head,
                      amxb_ubus_result_data,
                      amxb_ubus_req,
                      timeout * 1000);
 
    if((ret == UBUS_STATUS_METHOD_NOT_FOUND) && (invoke_ctx->method[0] != '_')) {
        const amxc_htable_t* htable = NULL;
        htable = amxc_var_constcast(amxc_htable_t, &amxb_ubus_req->args);
        blob_buf_init(&amxb_ubus_ctx->b, 0);
 
        amxb_ubus_format_blob_table(htable, &amxb_ubus_ctx->b);
 
        ret = ubus_invoke(amxb_ubus_ctx->ubus_ctx,
                          id,
                          "_exec",
                          amxb_ubus_ctx->b.head,
                          amxb_ubus_result_data,
                          amxb_ubus_req,
                          timeout * 1000);
    }
 
    ret = amxb_ubus_status_to_amxd_status(ret, request->result);
    request->bus_retval = ret;
    if(amxb_ubus_req->converted) {
        amxb_ubus_convert_out_args(request->result);
    }
 
exit:
    if(amxb_ubus_req != NULL) {
        amxc_var_clean(&amxb_ubus_req->args);
    }
    free(amxb_ubus_req);
    return ret;
}

Here is the call graph for this function:

amxb_ubus_invoke_base()

int PRIVATE amxb_ubus_invoke_base	(	amxb_ubus_t *	amxb_ubus_ctx,
		const char *	object,
		amxc_var_t *	args,
		amxb_request_t *	request,
		uint32_t *	id
	)

Definition at line 303 of file amxb_ubus_invoke.c.

                                                {
    int retval = -1;
 
    // lookup id can cause the ubus blob msg to be overwritten
    // first do the lookup and then initialize the blob
    retval = ubus_lookup_id(amxb_ubus_ctx->ubus_ctx, object, id);
    if(retval != 0) {
        goto exit;
    }
 
    blob_buf_init(&amxb_ubus_ctx->b, 0);
 
    if(args != NULL) {
        when_true(amxc_var_type_of(args) != AMXC_VAR_ID_HTABLE, exit);
        const amxc_htable_t* htable = amxc_var_constcast(amxc_htable_t, args);
        when_failed(amxb_ubus_format_blob_table(htable, &amxb_ubus_ctx->b), exit);
    }
 
    amxc_var_set_type(request->result, AMXC_VAR_ID_LIST);
 
exit:
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

amxb_ubus_list()

int PRIVATE amxb_ubus_list	(	void *const	bus_ctx,
		const char *	object,
		uint32_t	flags,
		uint32_t	access,
		amxb_request_t *	request
	)

Definition at line 332 of file amxb_ubus_list.c.

                                            {
    amxb_bus_ctx_t* bus_ctx = NULL;
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) ctx;
    int rv = -1;
    ubus_filter_t filter;
 
    memset(&filter, 0, sizeof(ubus_filter_t));
    filter.flags = flags;
    filter.access = access;
    filter.request = request;
    amxc_var_set_type(&filter.amx_paths, AMXC_VAR_ID_LIST);
    amxc_var_set_type(&filter.objects, AMXC_VAR_ID_HTABLE);
 
    bus_ctx = amxb_request_get_ctx(request);
    if((object == NULL) || (*object == 0)) {
        filter.depth = 1;
        filter.flags &= ~(AMXB_FLAG_OBJECTS | AMXB_FLAG_INSTANCES);
        rv = ubus_lookup(amxb_ubus_ctx->ubus_ctx, NULL, amxb_ubus_objects_cb, &filter);
        filter.flags &= ~(AMXB_FLAG_PARAMETERS | AMXB_FLAG_FUNCTIONS);
        amxc_var_for_each(path, &filter.amx_paths) {
            const char* p = GET_CHAR(path, NULL);
            amxb_ubus_list_object_describe(bus_ctx, p, &filter);
        }
        request->cb_fn(bus_ctx, NULL, request->priv);
    } else {
        filter.flags |= (AMXB_FLAG_OBJECTS | AMXB_FLAG_INSTANCES);
        rv = amxb_ubus_list_object_describe(bus_ctx, object, &filter);
 
        if(rv != 0) {
            filter.flags &= ~(AMXB_FLAG_OBJECTS | AMXB_FLAG_INSTANCES);
            rv = amxb_ubus_list_native(amxb_ubus_ctx, object, &filter);
            amxc_var_for_each(path, &filter.amx_paths) {
                const char* p = GET_CHAR(path, NULL);
                amxb_ubus_list_object_describe(bus_ctx, p, &filter);
            }
        }
        request->cb_fn(bus_ctx, NULL, request->priv);
    }
 
    amxc_var_clean(&filter.objects);
    amxc_var_clean(&filter.amx_paths);
    amxb_close_request(&request);
    return rv;
}

Here is the call graph for this function:

amxb_ubus_obj_it_free()

void PRIVATE amxb_ubus_obj_it_free

(

amxc_llist_it_t *

it

)

Definition at line 614 of file amxb_ubus_register.c.

                                                        {
    amxb_ubus_object_t* obj = amxc_llist_it_get_data(it,
                                                     amxb_ubus_object_t,
                                                     it);
    struct ubus_method* methods = (struct ubus_method*) obj->ubus_obj.methods;
 
    amxc_llist_it_take(it);
    for(int i = 0; i < obj->ubus_obj.n_methods; i++) {
        struct blobmsg_policy* policy =
            (struct blobmsg_policy*) methods[i].policy;
        free(policy);
        methods[i].policy = NULL;
    }
 
 
    amxp_slot_disconnect_with_priv(&obj->amxb_ubus_ctx->dm->sigmngr,
                                   amxb_ubus_send_notification,
                                   obj);
 
    free(obj->ubus_path);
    free(methods);
    free(obj->ubus_obj.type);
    free(obj);
}

Here is the call graph for this function:

Here is the caller graph for this function:

amxb_ubus_parse_blob()

int PRIVATE amxb_ubus_parse_blob	(	amxc_var_t *	var,
		struct blob_attr *	attr,
		bool	table
	)

Definition at line 111 of file amxb_ubus_blob.c.

                                             {
    int len;
    int off = 0;
    void* data;
 
    if(!blobmsg_check_attr(attr, false)) {
        return 0;
    }
 
    if(table) {
        if(blobmsg_name(attr)[0] != 0) {
            var = amxc_var_add_new_key(var, blobmsg_name(attr));
            off++;
        } else {
            return 0;
        }
    }
 
    data = blobmsg_data(attr);
    len = blobmsg_data_len(attr);
    amxb_ubus_set_var(var, attr, data, len);
 
    return off + 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

amxb_ubus_parse_blob_array()

int PRIVATE amxb_ubus_parse_blob_array	(	amxc_var_t *	var,
		struct blob_attr *	attr,
		int	len
	)

Definition at line 152 of file amxb_ubus_blob.c.

                                                {
    int rem = len;
    struct blob_attr* pos;
 
    __blob_for_each_attr(pos, attr, rem) {
        amxc_var_t* item = amxc_var_add_new(var);
        amxb_ubus_parse_blob(item, pos, false);
    }
 
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

amxb_ubus_parse_blob_table()

int PRIVATE amxb_ubus_parse_blob_table	(	amxc_var_t *	var,
		struct blob_attr *	attr,
		int	len
	)

Definition at line 138 of file amxb_ubus_blob.c.

                                                {
    int rem = len;
    struct blob_attr* pos;
 
    __blob_for_each_attr(pos, attr, rem) {
        amxb_ubus_parse_blob(var, pos, true);
    }
 
    return 1;
}

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_register()

int PRIVATE amxb_ubus_register	(	void *const	ctx,
		amxd_dm_t *const	dm
	)

Definition at line 639 of file amxb_ubus_register.c.

                                                    {
    int status = UBUS_STATUS_UNKNOWN_ERROR;
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) ctx;
    const amxc_var_t* cfg_ros = amxb_ubus_get_config_option("register-on-start-event");
 
    when_not_null(amxb_ubus_ctx->dm, exit);
    amxb_ubus_ctx->dm = dm;
 
    if(amxc_var_dyncast(bool, cfg_ros)) {
        amxp_slot_connect(&dm->sigmngr,
                          "app:start",
                          NULL,
                          amxb_ubus_register_dm,
                          amxb_ubus_ctx);
    } else {
        amxb_ubus_register_dm(NULL, NULL, ctx);
    }
 
    status = UBUS_STATUS_OK;
 
exit:
    return status;
}

amxb_ubus_result_data()

void PRIVATE amxb_ubus_result_data	(	struct ubus_request *	req,
		int	type,
		struct blob_attr *	msg
	)

amxb_ubus_subscribe()

int PRIVATE amxb_ubus_subscribe	(	void *const	ctx,
		const char *	object
	)

Definition at line 95 of file amxb_ubus_subscribe.c.

                                                    {
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) ctx;
    amxc_htable_it_t* it = NULL;
    amxb_ubus_sub_t* amxb_ubus_sub = NULL;
    amxc_string_t rel_path;
    amxd_path_t path;
    int ret = -1;
    uint32_t id = 0;
 
    amxc_string_init(&rel_path, 64);
    amxd_path_init(&path, NULL);
    amxd_path_setf(&path, true, "%s", object);
 
    when_failed(amxb_ubus_get_longest_path(amxb_ubus_ctx, &path, &rel_path), exit);
 
    ret = ubus_lookup_id(amxb_ubus_ctx->ubus_ctx, amxd_path_get(&path, 0), &id);
    when_true(ret != 0, exit);
 
    it = amxc_htable_get(&amxb_ubus_ctx->subscribers, amxd_path_get(&path, 0));
    when_not_null(it, exit);
 
    amxb_ubus_sub = (amxb_ubus_sub_t*) calloc(1, sizeof(amxb_ubus_sub_t));
    amxc_htable_insert(&amxb_ubus_ctx->subscribers,
                       object,
                       &amxb_ubus_sub->it);
 
    ret = ubus_register_subscriber(amxb_ubus_ctx->ubus_ctx,
                                   &amxb_ubus_sub->sub);
    when_true(ret != 0, exit);
    amxb_ubus_sub->sub.cb = amxb_ubus_receive_notification;
 
    ret = ubus_subscribe(amxb_ubus_ctx->ubus_ctx, &amxb_ubus_sub->sub, id);
 
exit:
    amxc_string_clean(&rel_path);
    amxd_path_clean(&path);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

amxb_ubus_unsubscribe()

int PRIVATE amxb_ubus_unsubscribe	(	void *const	ctx,
		const char *	object
	)

Definition at line 135 of file amxb_ubus_subscribe.c.

                                                      {
    amxb_ubus_t* amxb_ubus_ctx = (amxb_ubus_t*) ctx;
    amxb_ubus_sub_t* amxb_ubus_sub = NULL;
    amxc_htable_it_t* it = NULL;
    amxc_string_t rel_path;
    amxd_path_t path;
    int ret = 0;
    uint32_t id = 0;
 
    amxc_string_init(&rel_path, 64);
    amxd_path_init(&path, NULL);
    amxd_path_setf(&path, true, "%s", object);
 
    amxb_ubus_get_longest_path(amxb_ubus_ctx, &path, &rel_path);
 
    it = amxc_htable_get(&amxb_ubus_ctx->subscribers, object);
    when_null(it, leave);
    amxb_ubus_sub = amxc_htable_it_get_data(it, amxb_ubus_sub_t, it);
 
    ret = ubus_lookup_id(amxb_ubus_ctx->ubus_ctx, amxd_path_get(&path, 0), &id);
    when_true(ret != 0, exit);
 
    ubus_unsubscribe(amxb_ubus_ctx->ubus_ctx, &amxb_ubus_sub->sub, id);
 
exit:
    ret = ubus_unregister_subscriber(amxb_ubus_ctx->ubus_ctx, &amxb_ubus_sub->sub);
 
    amxc_htable_it_clean(it, NULL);
    amxp_timer_delete(&amxb_ubus_sub->reactivate);
    free(amxb_ubus_sub);
 
leave:
    amxc_string_clean(&rel_path);
    amxd_path_clean(&path);
 
    return ret;
}

Here is the call graph for this function:

amxb_ubus_wait_request()

int PRIVATE amxb_ubus_wait_request	(	void *const	ctx,
		amxb_request_t *	request,
		int	timeout
	)