ubusd.h File Reference

#include <libubox/list.h>
#include <libubox/uloop.h>
#include <libubox/blobmsg.h>
#include "ubus_common.h"
#include "ubusd_id.h"
#include "ubusd_obj.h"
#include "ubusmsg.h"
#include "ubusd_acl.h"

Go to the source code of this file.

Data Structures
struct	ubus_msg_buf
struct	ubus_msg_buf_list
struct	ubus_client_cmd
struct	ubus_client
struct	ubus_path

Macros
#define	UBUS_OBJ_HASH_BITS   4
#define	UBUS_CLIENT_MAX_TXQ_LEN   UBUS_MAX_MSGLEN

Typedefs
typedef struct ubus_msg_buf *(*	event_fill_cb) (void *priv, const char *id)

Functions
struct ubus_msg_buf *	ubus_msg_new (void *data, int len, bool shared)
void	ubus_msg_send (struct ubus_client *cl, struct ubus_msg_buf *ub)
ssize_t	ubus_msg_writev (int fd, struct ubus_msg_buf *ub, size_t offset)
void	ubus_msg_free (struct ubus_msg_buf *ub)
void	ubus_msg_list_free (struct ubus_msg_buf_list *ubl)
struct blob_attr **	ubus_parse_msg (struct blob_attr *msg, size_t len)
struct ubus_client *	ubusd_proto_new_client (int fd, uloop_fd_handler cb)
void	ubusd_proto_receive_message (struct ubus_client *cl, struct ubus_msg_buf *ub)
void	ubusd_proto_free_client (struct ubus_client *cl)
void	ubus_proto_send_msg_from_blob (struct ubus_client *cl, struct ubus_msg_buf *ub, uint8_t type)
int	ubusd_cmd_lookup (struct ubus_client *cl, struct ubus_client_cmd *cmd)
void	ubusd_event_init (void)
void	ubusd_event_cleanup_object (struct ubus_object *obj)
void	ubusd_send_obj_event (struct ubus_object *obj, bool add)
int	ubusd_send_event (struct ubus_client *cl, const char *id, event_fill_cb fill_cb, void *cb_priv)
void	ubusd_acl_init (void)
void	ubusd_monitor_init (void)
void	ubusd_monitor_message (struct ubus_client *cl, struct ubus_msg_buf *ub, bool send)
void	ubusd_monitor_disconnect (struct ubus_client *cl)

Variables
struct blob_buf	b
const char *	ubusd_acl_dir

Macro Definition Documentation

UBUS_CLIENT_MAX_TXQ_LEN

#define UBUS_CLIENT_MAX_TXQ_LEN   UBUS_MAX_MSGLEN

Definition at line 27 of file ubusd.h.

UBUS_OBJ_HASH_BITS

#define UBUS_OBJ_HASH_BITS   4

Definition at line 26 of file ubusd.h.

Typedef Documentation

event_fill_cb

typedef struct ubus_msg_buf*(* event_fill_cb) (void *priv, const char *id)

Definition at line 96 of file ubusd.h.

Function Documentation

ubus_msg_free()

void ubus_msg_free

(

struct ubus_msg_buf *

ub

)

Definition at line 67 of file ubusd.c.

{
        switch (ub->refcount) {
        case 1:
        case USES_EXTERNAL_BUFFER:
                if (ub->fd >= 0)
                        close(ub->fd);
 
                free(ub);
                break;
        default:
                ub->refcount--;
                break;
        }
}

Here is the caller graph for this function:

ubus_msg_list_free()

void ubus_msg_list_free

(

struct ubus_msg_buf_list *

ubl

)

Definition at line 136 of file ubusd.c.

{
        list_del_init(&ubl->list);
        ubus_msg_free(ubl->msg);
        free(ubl);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_msg_new()

struct ubus_msg_buf* ubus_msg_new	(	void *	data,
		int	len,
		bool	shared
	)

Definition at line 39 of file ubusd.c.

{
        struct ubus_msg_buf *ub;
        int buflen = sizeof(*ub);
 
        if (!shared)
                buflen += len;
 
        ub = calloc(1, buflen);
        if (!ub)
                return NULL;
 
        ub->fd = -1;
 
        if (shared) {
                ub->refcount = USES_EXTERNAL_BUFFER;
                ub->data = data;
        } else {
                ub->refcount = 1;
                ub->data = (void *) (ub + 1);
                if (data)
                        memcpy(ub + 1, data, len);
        }
 
        ub->len = len;
        return ub;
}

Here is the caller graph for this function:

ubus_msg_send()

void ubus_msg_send	(	struct ubus_client *	cl,
		struct ubus_msg_buf *	ub
	)

Definition at line 162 of file ubusd.c.

{
        ssize_t written;
 
        if (ub->hdr.type != UBUS_MSG_MONITOR)
                ubusd_monitor_message(cl, ub, true);
 
        if (list_empty(&cl->tx_queue)) {
                written = ubus_msg_writev(cl->sock.fd, ub, 0);
 
                if (written < 0)
                        written = 0;
 
                if (written >= (ssize_t) (ub->len + sizeof(ub->hdr)))
                        return;
 
                cl->txq_ofs = written;
                cl->txq_len = -written;
 
                /* get an event once we can write to the socket again */
                uloop_fd_add(&cl->sock, ULOOP_READ | ULOOP_WRITE | ULOOP_EDGE_TRIGGER);
        }
        ubus_msg_enqueue(cl, ub);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_msg_writev()

ssize_t ubus_msg_writev	(	int	fd,
		struct ubus_msg_buf *	ub,
		size_t	offset
	)

Definition at line 83 of file ubusd.c.

{
        uint8_t fd_buf[CMSG_SPACE(sizeof(int))] = { 0 };
        static struct iovec iov[2];
        struct msghdr msghdr = { 0 };
        struct ubus_msghdr hdr;
        struct cmsghdr *cmsg;
        ssize_t ret;
        int *pfd;
 
        msghdr.msg_iov = iov;
        msghdr.msg_iovlen = ARRAY_SIZE(iov);
        msghdr.msg_control = fd_buf;
        msghdr.msg_controllen = sizeof(fd_buf);
 
        cmsg = CMSG_FIRSTHDR(&msghdr);
        cmsg->cmsg_type = SCM_RIGHTS;
        cmsg->cmsg_level = SOL_SOCKET;
        cmsg->cmsg_len = CMSG_LEN(sizeof(int));
 
        pfd = (int *) CMSG_DATA(cmsg);
        msghdr.msg_controllen = cmsg->cmsg_len;
 
        *pfd = ub->fd;
        if (ub->fd < 0 || offset) {
                msghdr.msg_control = NULL;
                msghdr.msg_controllen = 0;
        }
 
        if (offset < sizeof(ub->hdr)) {
                hdr.version = ub->hdr.version;
                hdr.type = ub->hdr.type;
                hdr.seq = cpu_to_be16(ub->hdr.seq);
                hdr.peer = cpu_to_be32(ub->hdr.peer);
 
                iov[0].iov_base = ((char *) &hdr) + offset;
                iov[0].iov_len = sizeof(hdr) - offset;
                iov[1].iov_base = (char *) ub->data;
                iov[1].iov_len = ub->len;
        } else {
                offset -= sizeof(ub->hdr);
                iov[0].iov_base = ((char *) ub->data) + offset;
                iov[0].iov_len = ub->len - offset;
                msghdr.msg_iovlen = 1;
        }
 
        do {
                ret = sendmsg(fd, &msghdr, 0);
        } while (ret < 0 && errno == EINTR);
 
        return ret;
}

Here is the caller graph for this function:

ubus_parse_msg()

struct blob_attr** ubus_parse_msg	(	struct blob_attr *	msg,
		size_t	len
	)

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

{
        blob_parse_untrusted(msg, len, attrbuf, ubus_policy, UBUS_ATTR_MAX);
        return attrbuf;
}

Here is the caller graph for this function:

ubus_proto_send_msg_from_blob()

void ubus_proto_send_msg_from_blob	(	struct ubus_client *	cl,
		struct ubus_msg_buf *	ub,
		uint8_t	type
	)

Definition at line 78 of file ubusd_proto.c.

{
        /* keep the fd to be passed if it is UBUS_MSG_INVOKE */
        int fd = ub->fd;
        ub = ubus_reply_from_blob(ub, true);
        if (!ub)
                return;
 
        ub->hdr.type = type;
        ub->fd = fd;
 
        ubus_msg_send(cl, ub);
        ubus_msg_free(ub);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubusd_acl_init()

void ubusd_acl_init

(

void

)

Definition at line 568 of file ubusd_acl.c.

{
        ubus_init_string_tree(&ubusd_acls, true);
        acl_obj = ubusd_create_object_internal(NULL, UBUS_SYSTEM_OBJECT_ACL);
        acl_obj->recv_msg = ubusd_acl_recv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubusd_cmd_lookup()

int ubusd_cmd_lookup	(	struct ubus_client *	cl,
		struct ubus_client_cmd *	cmd
	)

Definition at line 285 of file ubusd_proto.c.

{
        struct ubus_msg_buf *ub = cmd->msg;
        struct blob_attr **attr;
        int ret;
 
        attr = ubus_parse_msg(ub->data, blob_raw_len(ub->data));
        ret = __ubusd_handle_lookup(cl, ub, attr, cmd);
 
        if (ret != -2) {
                struct ubus_msg_buf *retmsg = cl->retmsg;
                int *retmsg_data = blob_data(blob_data(retmsg->data));
 
                retmsg->hdr.seq = ub->hdr.seq;
                retmsg->hdr.peer = ub->hdr.peer;
 
                *retmsg_data = htonl(ret);
                ubus_msg_send(cl, retmsg);
        }
        return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubusd_event_cleanup_object()

void ubusd_event_cleanup_object

(

struct ubus_object *

obj

)

Definition at line 36 of file ubusd_event.c.

{
        struct event_source *ev, *tmp;
 
        list_for_each_entry_safe(ev, tmp, &obj->events, list) {
                ubusd_delete_event_source(ev);
        }
}

Here is the caller graph for this function:

ubusd_event_init()

void ubusd_event_init

(

void

)

Definition at line 266 of file ubusd_event.c.

{
        ubus_init_string_tree(&patterns, true);
        event_obj = ubusd_create_object_internal(NULL, UBUS_SYSTEM_OBJECT_EVENT);
        if (event_obj != NULL)
                event_obj->recv_msg = ubusd_event_recv;
}

Here is the caller graph for this function:

ubusd_monitor_disconnect()

void ubusd_monitor_disconnect

(

struct ubus_client *

cl

)

Definition at line 65 of file ubusd_monitor.c.

{
        struct ubus_monitor *m;
 
        m = ubusd_monitor_find(cl);
        if (!m)
                return;
 
        ubusd_monitor_free(m);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubusd_monitor_init()

void ubusd_monitor_init

(

void

)

Definition at line 128 of file ubusd_monitor.c.

{
        monitor_obj = ubusd_create_object_internal(NULL, UBUS_SYSTEM_OBJECT_MONITOR);
        if (monitor_obj != NULL)
                monitor_obj->recv_msg = ubusd_monitor_recv;
}

Here is the caller graph for this function:

ubusd_monitor_message()

void ubusd_monitor_message	(	struct ubus_client *	cl,
		struct ubus_msg_buf *	ub,
		bool	send
	)

Definition at line 77 of file ubusd_monitor.c.

{
        static struct blob_buf mb;
        struct ubus_monitor *m;
 
        if (list_empty(&monitors))
                return;
 
        blob_buf_init(&mb, 0);
        blob_put_int32(&mb, UBUS_MONITOR_CLIENT, cl->id.id);
        blob_put_int32(&mb, UBUS_MONITOR_PEER, ub->hdr.peer);
        blob_put_int32(&mb, UBUS_MONITOR_SEQ, ub->hdr.seq);
        blob_put_int32(&mb, UBUS_MONITOR_TYPE, ub->hdr.type);
        blob_put_int8(&mb, UBUS_MONITOR_SEND, send);
        blob_put(&mb, UBUS_MONITOR_DATA, blob_data(ub->data), blob_len(ub->data));
 
        ub = ubus_msg_new(mb.head, blob_raw_len(mb.head), true);
        ub->hdr.type = UBUS_MSG_MONITOR;
 
        list_for_each_entry(m, &monitors, list) {
                ub->hdr.seq = ++m->seq;
                ubus_msg_send(m->cl, ub);
        }
 
        ubus_msg_free(ub);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubusd_proto_free_client()

void ubusd_proto_free_client

(

struct ubus_client *

cl

)

Definition at line 600 of file ubusd_proto.c.

{
        struct ubus_object *obj, *tmp;
 
        list_for_each_entry_safe(obj, tmp, &cl->objects, list) {
                ubusd_free_object(obj);
        }
 
        ubus_msg_free(cl->retmsg);
        blob_buf_free(&cl->b);
 
        ubusd_acl_free_client(cl);
        ubus_free_id(&clients, &cl->id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubusd_proto_new_client()

struct ubus_client* ubusd_proto_new_client	(	int	fd,
		uloop_fd_handler	cb
	)

Definition at line 564 of file ubusd_proto.c.

{
        struct ubus_client *cl;
 
        cl = calloc(1, sizeof(*cl));
        if (!cl)
                return NULL;
 
        if (ubusd_acl_init_client(cl, fd))
                goto free;
 
        INIT_LIST_HEAD(&cl->objects);
        INIT_LIST_HEAD(&cl->cmd_queue);
        INIT_LIST_HEAD(&cl->tx_queue);
        cl->sock.fd = fd;
        cl->sock.cb = cb;
        cl->pending_msg_fd = -1;
 
        if (!ubus_alloc_id(&clients, &cl->id, 0))
                goto free;
 
        if (ubusd_proto_init_retmsg(cl))
                goto free;
 
        if (!ubusd_send_hello(cl))
                goto delete;
 
        return cl;
 
delete:
        ubus_free_id(&clients, &cl->id);
free:
        free(cl);
        return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubusd_proto_receive_message()

void ubusd_proto_receive_message	(	struct ubus_client *	cl,
		struct ubus_msg_buf *	ub
	)

Definition at line 512 of file ubusd_proto.c.

{
        ubus_cmd_cb cb = NULL;
        int ret;
        struct ubus_msg_buf *retmsg = cl->retmsg;
        int *retmsg_data = blob_data(blob_data(retmsg->data));
 
        retmsg->hdr.seq = ub->hdr.seq;
        retmsg->hdr.peer = ub->hdr.peer;
 
        if (ub->hdr.type < __UBUS_MSG_LAST)
                cb = handlers[ub->hdr.type];
 
        if (ub->hdr.type != UBUS_MSG_STATUS && ub->hdr.type != UBUS_MSG_INVOKE)
                ubus_msg_close_fd(ub);
 
        /* Note: no callback should free the `ub` buffer
                 that's always done right after the callback finishes */
        if (cb)
                ret = cb(cl, ub, ubus_parse_msg(ub->data, blob_raw_len(ub->data)));
        else
                ret = UBUS_STATUS_INVALID_COMMAND;
 
        /* Command has not been completed yet and got queued */
        if (ret == -2)
                return;
 
        ubus_msg_free(ub);
 
        if (ret == -1)
                return;
 
        *retmsg_data = htonl(ret);
        ubus_msg_send(cl, retmsg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubusd_send_event()

int ubusd_send_event	(	struct ubus_client *	cl,
		const char *	id,
		event_fill_cb	fill_cb,
		void *	cb_priv
	)

Definition at line 140 of file ubusd_event.c.

{
        struct ubus_msg_buf *ub = NULL;
        struct event_source *ev;
        int match_len = 0;
 
        if (ubusd_acl_check(cl, id, NULL, UBUS_ACL_SEND))
                return UBUS_STATUS_PERMISSION_DENIED;
 
        obj_event_seq++;
 
        /*
         * Since this tree is sorted alphabetically, we can only expect to find
         * matching entries as long as the number of matching characters
         * between the pattern string and our string is monotonically increasing.
         */
        avl_for_each_element(&patterns, ev, avl) {
                const char *key = ev->avl.key;
                int cur_match_len;
                bool full_match;
 
                full_match = ubus_strmatch_len(id, key, &cur_match_len);
                if (cur_match_len < match_len)
                        break;
 
                match_len = cur_match_len;
 
                if (!full_match) {
                        if (!ev->partial)
                                continue;
 
                        if (match_len != (int) strlen(key))
                                continue;
                }
 
                ubusd_send_event_msg(&ub, cl, ev->obj, id, fill_cb, cb_priv);
        }
 
        if (ub)
                ubus_msg_free(ub);
 
        return 0;
}

Here is the caller graph for this function:

ubusd_send_obj_event()

void ubusd_send_obj_event	(	struct ubus_object *	obj,
		bool	add
	)

Definition at line 259 of file ubusd_event.c.

{
        const char *id = add ? "ubus.object.add" : "ubus.object.remove";
 
        ubusd_send_event(NULL, id, ubusd_create_object_event_msg, obj);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

b

struct blob_buf b

extern

Definition at line 1 of file ubusd_proto.c.

ubusd_acl_dir

const char* ubusd_acl_dir

extern

Definition at line 71 of file ubusd_acl.c.