libubus.h File Reference

#include <libubox/avl.h>
#include <libubox/list.h>
#include <libubox/blobmsg.h>
#include <libubox/uloop.h>
#include <stdint.h>
#include "ubusmsg.h"
#include "ubus_common.h"

Go to the source code of this file.

Data Structures
struct	ubus_msghdr_buf
struct	ubus_method
struct	ubus_object_type
struct	ubus_object
struct	ubus_subscriber
struct	ubus_event_handler
struct	ubus_context
struct	ubus_object_data
struct	ubus_acl_key
struct	ubus_request_data
struct	ubus_request
struct	ubus_notify_request
struct	ubus_auto_conn
struct	acl_object

Macros
#define	UBUS_MAX_NOTIFY_PEERS   16
#define	UBUS_OBJECT_TYPE(_name, _methods)
#define	__UBUS_METHOD_NOARG(_name, _handler, _tags)
#define	__UBUS_METHOD(_name, _handler, _policy, _tags)
#define	UBUS_METHOD(_name, _handler, _policy)    { __UBUS_METHOD(_name, _handler, _policy, 0) }
#define	UBUS_METHOD_TAG(_name, _handler, _policy, _tags)    { __UBUS_METHOD(_name, _handler, _policy, _tags) }
#define	UBUS_METHOD_MASK(_name, _handler, _policy, _mask)
#define	UBUS_METHOD_NOARG(_name, _handler)    { __UBUS_METHOD_NOARG(_name, _handler, 0) }
#define	UBUS_METHOD_TAG_NOARG(_name, _handler, _tags)    { __UBUS_METHOD_NOARG(_name, _handler, _tags) }
#define	UBUS_TAG_STATUS   BIT(0)
#define	UBUS_TAG_ADMIN   BIT(1)
#define	UBUS_TAG_PRIVATE   BIT(2)
#define	acl_for_each(o, m)

Typedefs
typedef void(*	ubus_lookup_handler_t) (struct ubus_context *ctx, struct ubus_object_data *obj, void *priv)
typedef int(*	ubus_handler_t) (struct ubus_context *ctx, struct ubus_object *obj, struct ubus_request_data *req, const char *method, struct blob_attr *msg)
typedef void(*	ubus_state_handler_t) (struct ubus_context *ctx, struct ubus_object *obj)
typedef void(*	ubus_remove_handler_t) (struct ubus_context *ctx, struct ubus_subscriber *obj, uint32_t id)
typedef void(*	ubus_event_handler_t) (struct ubus_context *ctx, struct ubus_event_handler *ev, const char *type, struct blob_attr *msg)
typedef void(*	ubus_data_handler_t) (struct ubus_request *req, int type, struct blob_attr *msg)
typedef void(*	ubus_fd_handler_t) (struct ubus_request *req, int fd)
typedef void(*	ubus_complete_handler_t) (struct ubus_request *req, int ret)
typedef void(*	ubus_notify_complete_handler_t) (struct ubus_notify_request *req, int idx, int ret)
typedef void(*	ubus_notify_data_handler_t) (struct ubus_notify_request *req, int type, struct blob_attr *msg)
typedef void(*	ubus_connect_handler_t) (struct ubus_context *ctx)
typedef bool(*	ubus_new_object_handler_t) (struct ubus_context *ctx, struct ubus_subscriber *sub, const char *path)

Functions
struct ubus_context *	ubus_connect (const char *path)
int	ubus_connect_ctx (struct ubus_context *ctx, const char *path)
void	ubus_auto_connect (struct ubus_auto_conn *conn)
int	ubus_reconnect (struct ubus_context *ctx, const char *path)
void	ubus_free (struct ubus_context *ctx)
void	ubus_shutdown (struct ubus_context *ctx)
static void	ubus_auto_shutdown (struct ubus_auto_conn *conn)
const char *	ubus_strerror (int error)
static void	ubus_add_uloop (struct ubus_context *ctx)
static void	ubus_handle_event (struct ubus_context *ctx)
int	ubus_complete_request (struct ubus_context *ctx, struct ubus_request *req, int timeout)
void	ubus_complete_request_async (struct ubus_context *ctx, struct ubus_request *req)
void	ubus_abort_request (struct ubus_context *ctx, struct ubus_request *req)
int	ubus_lookup (struct ubus_context *ctx, const char *path, ubus_lookup_handler_t cb, void *priv)
int	ubus_lookup_id (struct ubus_context *ctx, const char *path, uint32_t *id)
int	ubus_add_object (struct ubus_context *ctx, struct ubus_object *obj)
int	ubus_remove_object (struct ubus_context *ctx, struct ubus_object *obj)
int	ubus_register_subscriber (struct ubus_context *ctx, struct ubus_subscriber *obj)
static int	ubus_unregister_subscriber (struct ubus_context *ctx, struct ubus_subscriber *obj)
int	ubus_subscribe (struct ubus_context *ctx, struct ubus_subscriber *obj, uint32_t id)
int	ubus_unsubscribe (struct ubus_context *ctx, struct ubus_subscriber *obj, uint32_t id)
int	__ubus_monitor (struct ubus_context *ctx, const char *type)
static int	ubus_monitor_start (struct ubus_context *ctx)
static int	ubus_monitor_stop (struct ubus_context *ctx)
int	ubus_register_acl (struct ubus_context *ctx)
int	ubus_invoke_fd (struct ubus_context *ctx, uint32_t obj, const char *method, struct blob_attr *msg, ubus_data_handler_t cb, void *priv, int timeout, int fd)
static int	ubus_invoke (struct ubus_context *ctx, uint32_t obj, const char *method, struct blob_attr *msg, ubus_data_handler_t cb, void *priv, int timeout)
int	ubus_invoke_async_fd (struct ubus_context *ctx, uint32_t obj, const char *method, struct blob_attr *msg, struct ubus_request *req, int fd)
static int	ubus_invoke_async (struct ubus_context *ctx, uint32_t obj, const char *method, struct blob_attr *msg, struct ubus_request *req)
int	ubus_send_reply (struct ubus_context *ctx, struct ubus_request_data *req, struct blob_attr *msg)
static void	ubus_defer_request (struct ubus_context *ctx, struct ubus_request_data *req, struct ubus_request_data *new_req)
static void	ubus_request_set_fd (struct ubus_context *ctx, struct ubus_request_data *req, int fd)
static int	ubus_request_get_caller_fd (struct ubus_request_data *req)
void	ubus_complete_deferred_request (struct ubus_context *ctx, struct ubus_request_data *req, int ret)
int	ubus_notify (struct ubus_context *ctx, struct ubus_object *obj, const char *type, struct blob_attr *msg, int timeout)
int	ubus_notify_async (struct ubus_context *ctx, struct ubus_object *obj, const char *type, struct blob_attr *msg, struct ubus_notify_request *req)
int	ubus_send_event (struct ubus_context *ctx, const char *id, struct blob_attr *data)
int	ubus_register_event_handler (struct ubus_context *ctx, struct ubus_event_handler *ev, const char *pattern)
static int	ubus_unregister_event_handler (struct ubus_context *ctx, struct ubus_event_handler *ev)

Variables
struct avl_tree	acl_objects

Macro Definition Documentation

__UBUS_METHOD

#define __UBUS_METHOD	(		_name,
			_handler,
			_policy,
			_tags
	)

Value:

        __UBUS_METHOD_NOARG(_name, _handler, _tags),    \
        .policy = _policy,                              \
        .n_policy = ARRAY_SIZE(_policy)

Definition at line 81 of file libubus.h.

__UBUS_METHOD_NOARG

#define __UBUS_METHOD_NOARG	(		_name,
			_handler,
			_tags
	)

Value:

        .name = _name,                                  \
        .handler = _handler,                            \
        .tags = _tags

Definition at line 76 of file libubus.h.

acl_for_each

#define acl_for_each	(		o,
			m
	)

Value:

        if ((m)->object && (m)->user && (m)->group) \
                avl_for_element_range(avl_find_ge_element(&acl_objects, m, o, avl), avl_find_le_element(&acl_objects, m, o, avl), o, avl)

Definition at line 343 of file libubus.h.

UBUS_MAX_NOTIFY_PEERS

#define UBUS_MAX_NOTIFY_PEERS   16

Definition at line 29 of file libubus.h.

UBUS_METHOD

#define UBUS_METHOD	(		_name,
			_handler,
			_policy
	)		{ __UBUS_METHOD(_name, _handler, _policy, 0) }

Definition at line 86 of file libubus.h.

UBUS_METHOD_MASK

#define UBUS_METHOD_MASK	(		_name,
			_handler,
			_policy,
			_mask
	)

Value:

        {                                               \
                __UBUS_METHOD(_name, _handler, _policy, 0),\
                .mask = _mask                           \
        }

Definition at line 92 of file libubus.h.

UBUS_METHOD_NOARG

#define UBUS_METHOD_NOARG	(		_name,
			_handler
	)		{ __UBUS_METHOD_NOARG(_name, _handler, 0) }

Definition at line 98 of file libubus.h.

UBUS_METHOD_TAG

#define UBUS_METHOD_TAG	(		_name,
			_handler,
			_policy,
			_tags
	)		{ __UBUS_METHOD(_name, _handler, _policy, _tags) }

Definition at line 89 of file libubus.h.

UBUS_METHOD_TAG_NOARG

#define UBUS_METHOD_TAG_NOARG	(		_name,
			_handler,
			_tags
	)		{ __UBUS_METHOD_NOARG(_name, _handler, _tags) }

Definition at line 101 of file libubus.h.

UBUS_OBJECT_TYPE

#define UBUS_OBJECT_TYPE	(		_name,
			_methods
	)

Value:

        {                                               \
                .name = _name,                          \
                .id = 0,                                \
                .n_methods = ARRAY_SIZE(_methods),      \
                .methods = _methods                     \
        }

Definition at line 68 of file libubus.h.

UBUS_TAG_ADMIN

#define UBUS_TAG_ADMIN   BIT(1)

Definition at line 105 of file libubus.h.

UBUS_TAG_PRIVATE

#define UBUS_TAG_PRIVATE   BIT(2)

Definition at line 106 of file libubus.h.

UBUS_TAG_STATUS

#define UBUS_TAG_STATUS   BIT(0)

Definition at line 104 of file libubus.h.

Typedef Documentation

ubus_complete_handler_t

typedef void(* ubus_complete_handler_t) (struct ubus_request *req, int ret)

Definition at line 60 of file libubus.h.

ubus_connect_handler_t

typedef void(* ubus_connect_handler_t) (struct ubus_context *ctx)

Definition at line 65 of file libubus.h.

ubus_data_handler_t

typedef void(* ubus_data_handler_t) (struct ubus_request *req, int type, struct blob_attr *msg)

Definition at line 57 of file libubus.h.

ubus_event_handler_t

typedef void(* ubus_event_handler_t) (struct ubus_context *ctx, struct ubus_event_handler *ev, const char *type, struct blob_attr *msg)

Definition at line 55 of file libubus.h.

ubus_fd_handler_t

typedef void(* ubus_fd_handler_t) (struct ubus_request *req, int fd)

Definition at line 59 of file libubus.h.

ubus_handler_t

typedef int(* ubus_handler_t) (struct ubus_context *ctx, struct ubus_object *obj, struct ubus_request_data *req, const char *method, struct blob_attr *msg)

Definition at line 49 of file libubus.h.

ubus_lookup_handler_t

typedef void(* ubus_lookup_handler_t) (struct ubus_context *ctx, struct ubus_object_data *obj, void *priv)

Definition at line 46 of file libubus.h.

ubus_new_object_handler_t

typedef bool(* ubus_new_object_handler_t) (struct ubus_context *ctx, struct ubus_subscriber *sub, const char *path)

Definition at line 66 of file libubus.h.

ubus_notify_complete_handler_t

typedef void(* ubus_notify_complete_handler_t) (struct ubus_notify_request *req, int idx, int ret)

Definition at line 61 of file libubus.h.

ubus_notify_data_handler_t

typedef void(* ubus_notify_data_handler_t) (struct ubus_notify_request *req, int type, struct blob_attr *msg)

Definition at line 63 of file libubus.h.

ubus_remove_handler_t

typedef void(* ubus_remove_handler_t) (struct ubus_context *ctx, struct ubus_subscriber *obj, uint32_t id)

Definition at line 53 of file libubus.h.

ubus_state_handler_t

typedef void(* ubus_state_handler_t) (struct ubus_context *ctx, struct ubus_object *obj)

Definition at line 52 of file libubus.h.

Function Documentation

__ubus_monitor()

int __ubus_monitor	(	struct ubus_context *	ctx,
		const char *	type
	)

Definition at line 495 of file libubus-req.c.

{
        blob_buf_init(&b, 0);
        return ubus_invoke(ctx, UBUS_SYSTEM_OBJECT_MONITOR, type, b.head, NULL, NULL, 1000);
}

Here is the caller graph for this function:

ubus_abort_request()

void ubus_abort_request	(	struct ubus_context *	ctx,
		struct ubus_request *	req
	)

Definition at line 80 of file libubus-req.c.

{
        if (list_empty(&req->list))
                return;
 
        req->cancelled = true;
        __ubus_process_req_data(req);
        list_del_init(&req->list);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_add_object()

int ubus_add_object	(	struct ubus_context *	ctx,
		struct ubus_object *	obj
	)

Definition at line 209 of file libubus-obj.c.

{
        struct ubus_request req;
        int ret;
 
        blob_buf_init(&b, 0);
 
        if (obj->name && obj->type) {
                blob_put_string(&b, UBUS_ATTR_OBJPATH, obj->name);
 
                if (obj->type->id)
                        blob_put_int32(&b, UBUS_ATTR_OBJTYPE, obj->type->id);
                else if (!ubus_push_object_type(obj->type))
                        return UBUS_STATUS_INVALID_ARGUMENT;
        }
 
        if (ubus_start_request(ctx, &req, b.head, UBUS_MSG_ADD_OBJECT, 0) < 0)
                return UBUS_STATUS_INVALID_ARGUMENT;
 
        req.raw_data_cb = ubus_add_object_cb;
        req.priv = obj;
        ret = ubus_complete_request(ctx, &req, 0);
        if (ret)
                return ret;
 
        if (!obj->id)
                return UBUS_STATUS_NO_DATA;
 
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_add_uloop()

static void ubus_add_uloop ( struct ubus_context *  ctx )

inlinestatic

Definition at line 268 of file libubus.h.

{
        uloop_fd_add(&ctx->sock, ULOOP_BLOCKING | ULOOP_READ);
}

Here is the caller graph for this function:

ubus_auto_connect()

void ubus_auto_connect

(

struct ubus_auto_conn *

conn

)

Definition at line 345 of file libubus.c.

{
        conn->timer.cb = ubus_auto_connect_cb;
        ubus_auto_connect_cb(&conn->timer);
}

Here is the call graph for this function:

ubus_auto_shutdown()

static void ubus_auto_shutdown ( struct ubus_auto_conn *  conn )

inlinestatic

Definition at line 260 of file libubus.h.

{
        uloop_timeout_cancel(&conn->timer);
        ubus_shutdown(&conn->ctx);
}

Here is the call graph for this function:

ubus_complete_deferred_request()

void ubus_complete_deferred_request	(	struct ubus_context *	ctx,
		struct ubus_request_data *	req,
		int	ret
	)

Definition at line 189 of file libubus-req.c.

{
        blob_buf_init(&b, 0);
        blob_put_int32(&b, UBUS_ATTR_STATUS, ret);
        blob_put_int32(&b, UBUS_ATTR_OBJID, req->object);
        ubus_send_msg(ctx, req->seq, b.head, UBUS_MSG_STATUS, req->peer, req->fd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_complete_request()

int ubus_complete_request	(	struct ubus_context *	ctx,
		struct ubus_request *	req,
		int	timeout
	)

Definition at line 140 of file libubus-req.c.

{
        ubus_complete_handler_t complete_cb = req->complete_cb;
        int status = UBUS_STATUS_NO_DATA;
        int64_t timeout = 0, time_end = 0;
 
        if (req_timeout)
                time_end = get_time_msec() + req_timeout;
 
        ubus_complete_request_async(ctx, req);
        req->complete_cb = ubus_sync_req_cb;
 
        ctx->stack_depth++;
        while (!req->status_msg) {
                if (req_timeout) {
                        timeout = time_end - get_time_msec();
                        if (timeout <= 0) {
                                ubus_set_req_status(req, UBUS_STATUS_TIMEOUT);
                                break;
                        }
                }
 
                ubus_poll_data(ctx, (unsigned int) timeout);
 
                if (ctx->sock.eof) {
                        ubus_set_req_status(req, UBUS_STATUS_CONNECTION_FAILED);
                        ctx->cancel_poll = true;
                        break;
                }
        }
 
        ctx->stack_depth--;
        if (ctx->stack_depth)
                ctx->cancel_poll = true;
 
        if (req->status_msg)
                status = req->status_code;
 
        req->complete_cb = complete_cb;
        if (req->complete_cb)
                req->complete_cb(req, status);
 
        if (!ctx->stack_depth && !ctx->sock.registered)
                ctx->pending_timer.cb(&ctx->pending_timer);
 
        return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_complete_request_async()

void ubus_complete_request_async	(	struct ubus_context *	ctx,
		struct ubus_request *	req
	)

Definition at line 90 of file libubus-req.c.

{
        if (!list_empty(&req->list))
                return;
 
        list_add(&req->list, &ctx->requests);
}

Here is the caller graph for this function:

ubus_connect()

struct ubus_context* ubus_connect

(

const char *

path

)

Definition at line 351 of file libubus.c.

{
        struct ubus_context *ctx;
 
        ctx = calloc(1, sizeof(*ctx));
        if (!ctx)
                return NULL;
 
        if (ubus_connect_ctx(ctx, path)) {
                free(ctx);
                ctx = NULL;
        }
 
        return ctx;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_connect_ctx()

int ubus_connect_ctx	(	struct ubus_context *	ctx,
		const char *	path
	)

Definition at line 284 of file libubus.c.

{
        uloop_init();
        memset(ctx, 0, sizeof(*ctx));
 
        ctx->sock.fd = -1;
        ctx->sock.cb = ubus_handle_data;
        ctx->connection_lost = ubus_default_connection_lost;
        ctx->pending_timer.cb = ubus_process_pending_msg;
 
        ctx->msgbuf.data = calloc(1, UBUS_MSG_CHUNK_SIZE);
        if (!ctx->msgbuf.data)
                return -1;
        ctx->msgbuf_data_len = UBUS_MSG_CHUNK_SIZE;
 
        INIT_LIST_HEAD(&ctx->requests);
        INIT_LIST_HEAD(&ctx->pending);
        INIT_LIST_HEAD(&ctx->auto_subscribers);
        avl_init(&ctx->objects, ubus_cmp_id, false, NULL);
        if (ubus_reconnect(ctx, path)) {
                free(ctx->msgbuf.data);
                ctx->msgbuf.data = NULL;
                return -1;
        }
 
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_defer_request()

static void ubus_defer_request ( struct ubus_context *  ctx, struct ubus_request_data *  req, struct ubus_request_data *  new_req  )

inlinestatic

Definition at line 375 of file libubus.h.

{
    (void) ctx;
    memcpy(new_req, req, sizeof(*req));
    req->deferred = true;
}

Here is the caller graph for this function:

ubus_free()

void ubus_free

(

struct ubus_context *

ctx

)

Definition at line 378 of file libubus.c.

{
        ubus_shutdown(ctx);
        free(ctx);
}

Here is the caller graph for this function:

ubus_handle_event()

static void ubus_handle_event ( struct ubus_context *  ctx )

inlinestatic

Definition at line 274 of file libubus.h.

{
        ctx->sock.cb(&ctx->sock, ULOOP_READ);
}

ubus_invoke()

static int ubus_invoke ( struct ubus_context *  ctx, uint32_t  obj, const char *  method, struct blob_attr *  msg, ubus_data_handler_t  cb, void *  priv, int  timeout  )

inlinestatic

Definition at line 354 of file libubus.h.

{
        return ubus_invoke_fd(ctx, obj, method, msg, cb, priv, timeout, -1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_invoke_async()

static int ubus_invoke_async ( struct ubus_context *  ctx, uint32_t  obj, const char *  method, struct blob_attr *  msg, struct ubus_request *  req  )

inlinestatic

Definition at line 365 of file libubus.h.

{
        return ubus_invoke_async_fd(ctx, obj, method, msg, req, -1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_invoke_async_fd()

int ubus_invoke_async_fd	(	struct ubus_context *	ctx,
		uint32_t	obj,
		const char *	method,
		struct blob_attr *	msg,
		struct ubus_request *	req,
		int	fd
	)

Definition at line 220 of file libubus-req.c.

{
        blob_buf_init(&b, 0);
        blob_put_int32(&b, UBUS_ATTR_OBJID, obj);
        blob_put_string(&b, UBUS_ATTR_METHOD, method);
        ubus_put_data(&b, msg);
 
        memset(req, 0, sizeof(*req));
        req->fd = fd;
        if (__ubus_start_request(ctx, req, b.head, UBUS_MSG_INVOKE, obj) < 0)
                return UBUS_STATUS_INVALID_ARGUMENT;
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_invoke_fd()

int ubus_invoke_fd	(	struct ubus_context *	ctx,
		uint32_t	obj,
		const char *	method,
		struct blob_attr *	msg,
		ubus_data_handler_t	cb,
		void *	priv,
		int	timeout,
		int	fd
	)

Definition at line 236 of file libubus-req.c.

{
        struct ubus_request req;
        int rc;
 
        rc = ubus_invoke_async_fd(ctx, obj, method, msg, &req, fd);
        if (rc)
                return rc;
 
        req.data_cb = cb;
        req.priv = priv;
        return ubus_complete_request(ctx, &req, timeout);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_lookup()

int ubus_lookup	(	struct ubus_context *	ctx,
		const char *	path,
		ubus_lookup_handler_t	cb,
		void *	priv
	)

Definition at line 161 of file libubus.c.

{
        struct ubus_lookup_request lookup;
 
        blob_buf_init(&b, 0);
        if (path)
                blob_put_string(&b, UBUS_ATTR_OBJPATH, path);
 
        if (ubus_start_request(ctx, &lookup.req, b.head, UBUS_MSG_LOOKUP, 0) < 0)
                return UBUS_STATUS_INVALID_ARGUMENT;
 
        lookup.req.raw_data_cb = ubus_lookup_cb;
        lookup.req.priv = priv;
        lookup.cb = cb;
        return ubus_complete_request(ctx, &lookup.req, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_lookup_id()

int ubus_lookup_id	(	struct ubus_context *	ctx,
		const char *	path,
		uint32_t *	id
	)

Definition at line 192 of file libubus.c.

{
        struct ubus_request req;
 
        blob_buf_init(&b, 0);
        if (path)
                blob_put_string(&b, UBUS_ATTR_OBJPATH, path);
 
        if (ubus_start_request(ctx, &req, b.head, UBUS_MSG_LOOKUP, 0) < 0)
                return UBUS_STATUS_INVALID_ARGUMENT;
 
        req.raw_data_cb = ubus_lookup_id_cb;
        req.priv = id;
 
        return ubus_complete_request(ctx, &req, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_monitor_start()

static int ubus_monitor_start ( struct ubus_context *  ctx )

inlinestatic

Definition at line 321 of file libubus.h.

{
        return __ubus_monitor(ctx, "add");
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_monitor_stop()

static int ubus_monitor_stop ( struct ubus_context *  ctx )

inlinestatic

Definition at line 326 of file libubus.h.

{
        return __ubus_monitor(ctx, "remove");
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_notify()

int ubus_notify	(	struct ubus_context *	ctx,
		struct ubus_object *	obj,
		const char *	type,
		struct blob_attr *	msg,
		int	timeout
	)

Definition at line 311 of file libubus-req.c.

{
        struct ubus_notify_request req;
        int ret;
 
        ret = __ubus_notify_async(ctx, obj, type, msg, &req, timeout >= 0);
        if (ret < 0)
                return ret;
 
        if (timeout < 0) {
                ubus_abort_request(ctx, &req.req);
                return 0;
        }
 
        return ubus_complete_request(ctx, &req.req, timeout);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_notify_async()

int ubus_notify_async	(	struct ubus_context *	ctx,
		struct ubus_object *	obj,
		const char *	type,
		struct blob_attr *	msg,
		struct ubus_notify_request *	req
	)

Definition at line 304 of file libubus-req.c.

{
        return __ubus_notify_async(ctx, obj, type, msg, req, true);
}

Here is the call graph for this function:

ubus_reconnect()

int ubus_reconnect	(	struct ubus_context *	ctx,
		const char *	path
	)

Definition at line 395 of file libubus-io.c.

{
        struct {
                struct ubus_msghdr hdr;
                struct blob_attr data;
        } hdr;
        struct blob_attr *buf;
        int ret = UBUS_STATUS_UNKNOWN_ERROR;
 
        if (!path)
                path = UBUS_UNIX_SOCKET;
 
        if (ctx->sock.fd >= 0) {
                if (ctx->sock.registered)
                        uloop_fd_delete(&ctx->sock);
 
                close(ctx->sock.fd);
        }
 
        ctx->sock.eof = false;
        ctx->sock.error = false;
        ctx->sock.fd = usock(USOCK_UNIX, path, NULL);
        if (ctx->sock.fd < 0)
                return UBUS_STATUS_CONNECTION_FAILED;
 
        if (read(ctx->sock.fd, &hdr, sizeof(hdr)) != sizeof(hdr))
                goto out_close;
 
        if (!ubus_validate_hdr(&hdr.hdr))
                goto out_close;
 
        if (hdr.hdr.type != UBUS_MSG_HELLO)
                goto out_close;
 
        buf = calloc(1, blob_raw_len(&hdr.data));
        if (!buf)
                goto out_close;
 
        memcpy(buf, &hdr.data, sizeof(hdr.data));
        if (read(ctx->sock.fd, blob_data(buf), blob_len(buf)) != (ssize_t) blob_len(buf))
                goto out_free;
 
        ctx->local_id = hdr.hdr.peer;
        if (!ctx->local_id)
                goto out_free;
 
        ret = UBUS_STATUS_OK;
        fcntl(ctx->sock.fd, F_SETFL, fcntl(ctx->sock.fd, F_GETFL) | O_NONBLOCK | O_CLOEXEC);
 
        ubus_refresh_state(ctx);
 
out_free:
        free(buf);
out_close:
        if (ret)
                close(ctx->sock.fd);
 
        return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_register_acl()

int ubus_register_acl

(

struct ubus_context *

ctx

)

Definition at line 142 of file libubus-acl.c.

{
        int ret;
 
        acl_event.cb = acl_subscribe_cb;
 
        ret = ubus_register_event_handler(ctx, &acl_event, "ubus.acl.sequence");
        if (!ret)
                acl_query(ctx);
 
        return ret;
}

Here is the call graph for this function:

ubus_register_event_handler()

int ubus_register_event_handler	(	struct ubus_context *	ctx,
		struct ubus_event_handler *	ev,
		const char *	pattern
	)

Definition at line 225 of file libubus.c.

{
        struct ubus_object *obj = &ev->obj;
        struct blob_buf b2 = {};
        int ret;
 
        if (!obj->id) {
                obj->methods = &event_method;
                obj->n_methods = 1;
 
                if (!!obj->name ^ !!obj->type)
                        return UBUS_STATUS_INVALID_ARGUMENT;
 
                ret = ubus_add_object(ctx, obj);
                if (ret)
                        return ret;
        }
 
        /* use a second buffer, ubus_invoke() overwrites the primary one */
        blob_buf_init(&b2, 0);
        blobmsg_add_u32(&b2, "object", obj->id);
        if (pattern)
                blobmsg_add_string(&b2, "pattern", pattern);
 
        ret = ubus_invoke(ctx, UBUS_SYSTEM_OBJECT_EVENT, "register", b2.head,
                          NULL, NULL, 0);
        blob_buf_free(&b2);
 
        return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_register_subscriber()

int ubus_register_subscriber	(	struct ubus_context *	ctx,
		struct ubus_subscriber *	obj
	)

Definition at line 77 of file libubus-sub.c.

{
        struct ubus_object *obj = &s->obj;
        int ret;
 
        INIT_LIST_HEAD(&s->list);
        obj->methods = &watch_method;
        obj->n_methods = 1;
 
        ret = ubus_add_object(ctx, obj);
        if (ret)
                return ret;
 
        if (s->new_obj_cb) {
                struct ubus_event_handler *ev = &ctx->auto_subscribe_event_handler;
                list_add(&s->list, &ctx->auto_subscribers);
                ev->cb = ubus_auto_sub_event_handler_cb;
                if (!ev->obj.id)
                        ubus_register_event_handler(ctx, ev, "ubus.object.add");
                ubus_lookup(ctx, NULL, ubus_auto_sub_lookup, s);
        }
 
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_remove_object()

int ubus_remove_object	(	struct ubus_context *	ctx,
		struct ubus_object *	obj
	)

Definition at line 256 of file libubus-obj.c.

{
        struct ubus_request req;
        int ret;
 
        blob_buf_init(&b, 0);
        blob_put_int32(&b, UBUS_ATTR_OBJID, obj->id);
 
        if (ubus_start_request(ctx, &req, b.head, UBUS_MSG_REMOVE_OBJECT, 0) < 0)
                return UBUS_STATUS_INVALID_ARGUMENT;
 
        req.raw_data_cb = ubus_remove_object_cb;
        req.priv = obj;
        ret = ubus_complete_request(ctx, &req, 0);
        if (ret)
                return ret;
 
        if (obj->id)
                return UBUS_STATUS_NO_DATA;
 
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_request_get_caller_fd()

static int ubus_request_get_caller_fd ( struct ubus_request_data *  req )

inlinestatic

Definition at line 391 of file libubus.h.

{
    int fd = req->req_fd;
    req->req_fd = -1;
    
    return fd;
}

ubus_request_set_fd()

static void ubus_request_set_fd ( struct ubus_context *  ctx, struct ubus_request_data *  req, int  fd  )

inlinestatic

Definition at line 384 of file libubus.h.

{
    (void) ctx;
    req->fd = fd;
}

Here is the caller graph for this function:

ubus_send_event()

int ubus_send_event	(	struct ubus_context *	ctx,
		const char *	id,
		struct blob_attr *	data
	)

Definition at line 258 of file libubus.c.

{
        struct ubus_request req;
        void *s;
 
        blob_buf_init(&b, 0);
        blob_put_int32(&b, UBUS_ATTR_OBJID, UBUS_SYSTEM_OBJECT_EVENT);
        blob_put_string(&b, UBUS_ATTR_METHOD, "send");
        s = blob_nest_start(&b, UBUS_ATTR_DATA);
        blobmsg_add_string(&b, "id", id);
        blobmsg_add_field(&b, BLOBMSG_TYPE_TABLE, "data", blob_data(data), blob_len(data));
        blob_nest_end(&b, s);
 
        if (ubus_start_request(ctx, &req, b.head, UBUS_MSG_INVOKE, UBUS_SYSTEM_OBJECT_EVENT) < 0)
                return UBUS_STATUS_INVALID_ARGUMENT;
 
        return ubus_complete_request(ctx, &req, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_send_reply()

int ubus_send_reply	(	struct ubus_context *	ctx,
		struct ubus_request_data *	req,
		struct blob_attr *	msg
	)

Definition at line 205 of file libubus-req.c.

{
        int ret;
 
        blob_buf_init(&b, 0);
        blob_put_int32(&b, UBUS_ATTR_OBJID, req->object);
        ubus_put_data(&b, msg);
        ret = ubus_send_msg(ctx, req->seq, b.head, UBUS_MSG_DATA, req->peer, -1);
        if (ret < 0)
                return UBUS_STATUS_NO_DATA;
 
        return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_shutdown()

void ubus_shutdown

(

struct ubus_context *

ctx

)

Definition at line 367 of file libubus.c.

{
        blob_buf_free(&b);
        if (!ctx)
                return;
        uloop_fd_delete(&ctx->sock);
        close(ctx->sock.fd);
        uloop_timeout_cancel(&ctx->pending_timer);
        free(ctx->msgbuf.data);
}

Here is the caller graph for this function:

ubus_strerror()

const char* ubus_strerror

(

int

error

)

Definition at line 59 of file libubus.c.

{
        static char err[32];
 
        if (error < 0 || error >= __UBUS_STATUS_LAST)
                goto out;
 
        if (!__ubus_strerror[error])
                goto out;
 
        return __ubus_strerror[error];
 
out:
        sprintf(err, "Unknown error: %d", error);
        return err;
}

Here is the caller graph for this function:

ubus_subscribe()

int ubus_subscribe	(	struct ubus_context *	ctx,
		struct ubus_subscriber *	obj,
		uint32_t	id
	)

Definition at line 118 of file libubus-sub.c.

{
        return __ubus_subscribe_request(ctx, &obj->obj, id, UBUS_MSG_SUBSCRIBE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_unregister_event_handler()

static int ubus_unregister_event_handler ( struct ubus_context *  ctx, struct ubus_event_handler *  ev  )

inlinestatic

Definition at line 423 of file libubus.h.

{
    return ubus_remove_object(ctx, &ev->obj);
}

ubus_unregister_subscriber()

static int ubus_unregister_subscriber ( struct ubus_context *  ctx, struct ubus_subscriber *  obj  )

inlinestatic

Definition at line 309 of file libubus.h.

{
        if (!list_empty(&obj->list))
                list_del_init(&obj->list);
        return ubus_remove_object(ctx, &obj->obj);
}

Here is the call graph for this function:

ubus_unsubscribe()

int ubus_unsubscribe	(	struct ubus_context *	ctx,
		struct ubus_subscriber *	obj,
		uint32_t	id
	)

Definition at line 123 of file libubus-sub.c.

{
        return __ubus_subscribe_request(ctx, &obj->obj, id, UBUS_MSG_UNSUBSCRIBE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

acl_objects

struct avl_tree acl_objects

extern