libubus-internal.h File Reference

Go to the source code of this file.

Functions
struct blob_attr **	ubus_parse_msg (struct blob_attr *msg, size_t len)
bool	ubus_validate_hdr (struct ubus_msghdr *hdr)
void	ubus_handle_data (struct uloop_fd *u, unsigned int events)
int	ubus_send_msg (struct ubus_context *ctx, uint32_t seq, struct blob_attr *msg, int cmd, uint32_t peer, int fd)
void	ubus_process_msg (struct ubus_context *ctx, struct ubus_msghdr_buf *buf, int fd)
int __hidden	ubus_start_request (struct ubus_context *ctx, struct ubus_request *req, struct blob_attr *msg, int cmd, uint32_t peer)
int __hidden	__ubus_start_request (struct ubus_context *ctx, struct ubus_request *req, struct blob_attr *msg, int cmd, uint32_t peer)
void	ubus_process_obj_msg (struct ubus_context *ctx, struct ubus_msghdr_buf *buf, int fd)
void	ubus_process_req_msg (struct ubus_context *ctx, struct ubus_msghdr_buf *buf, int fd)
void __hidden	ubus_poll_data (struct ubus_context *ctx, int timeout)

Variables
struct blob_buf	b
const struct ubus_method	watch_method

Function Documentation

__ubus_start_request()

int __hidden __ubus_start_request	(	struct ubus_context *	ctx,
		struct ubus_request *	req,
		struct blob_attr *	msg,
		int	cmd,
		uint32_t	peer
	)

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

{
 
        if (msg && blob_pad_len(msg) > UBUS_MAX_MSGLEN)
                return -1;
 
        INIT_LIST_HEAD(&req->list);
        INIT_LIST_HEAD(&req->pending);
        req->ctx = ctx;
        req->peer = peer;
        req->seq = ++ctx->request_seq;
 
        return ubus_send_msg(ctx, req->seq, msg, cmd, peer, req->fd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_handle_data()

void ubus_handle_data	(	struct uloop_fd *	u,
		unsigned int	events
	)

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

{
        struct ubus_context *ctx = container_of(u, struct ubus_context, sock);
        int recv_fd = -1;
 
        while (1) {
                if (!ctx->stack_depth)
                        ctx->pending_timer.cb(&ctx->pending_timer);
 
                if (!get_next_msg(ctx, &recv_fd))
                        break;
                ubus_process_msg(ctx, &ctx->msgbuf, recv_fd);
                if (uloop_cancelling() || ctx->cancel_poll)
                        break;
        }
 
        if (!ctx->stack_depth)
                ctx->pending_timer.cb(&ctx->pending_timer);
 
        if (u->eof)
                ctx->connection_lost(ctx);
}

Here is the call graph for this function:

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

void __hidden ubus_poll_data	(	struct ubus_context *	ctx,
		int	timeout
	)

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

{
        struct pollfd pfd = {
                .fd = ctx->sock.fd,
                .events = POLLIN | POLLERR,
        };
 
        ctx->cancel_poll = false;
        poll(&pfd, 1, timeout ? timeout : -1);
        ubus_handle_data(&ctx->sock, ULOOP_READ);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_process_msg()

void ubus_process_msg	(	struct ubus_context *	ctx,
		struct ubus_msghdr_buf *	buf,
		int	fd
	)

Definition at line 93 of file libubus.c.

{
        switch(buf->hdr.type) {
        case UBUS_MSG_STATUS:
        case UBUS_MSG_DATA:
                ubus_process_req_msg(ctx, buf, fd);
                break;
 
        case UBUS_MSG_INVOKE:
        case UBUS_MSG_UNSUBSCRIBE:
        case UBUS_MSG_NOTIFY:
                if (ctx->stack_depth) {
                        ubus_queue_msg(ctx, buf);
                        break;
                }
 
                ctx->stack_depth++;
                ubus_process_obj_msg(ctx, buf, fd);
                ctx->stack_depth--;
                break;
        case UBUS_MSG_MONITOR:
                if (ctx->monitor_cb)
                        ctx->monitor_cb(ctx, buf->hdr.seq, buf->data);
                break;
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_process_obj_msg()

void ubus_process_obj_msg	(	struct ubus_context *	ctx,
		struct ubus_msghdr_buf *	buf,
		int	fd
	)

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

{
        void (*cb)(struct ubus_context *, struct ubus_msghdr *,
                   struct ubus_object *, struct blob_attr **, int fd);
        struct ubus_msghdr *hdr = &buf->hdr;
        struct blob_attr **attrbuf;
        struct ubus_object *obj;
        uint32_t objid;
        void *prev_data = NULL;
        attrbuf = ubus_parse_msg(buf->data, blob_raw_len(buf->data));
        if (!attrbuf[UBUS_ATTR_OBJID])
                return;
 
        objid = blob_get_u32(attrbuf[UBUS_ATTR_OBJID]);
        obj = avl_find_element(&ctx->objects, &objid, obj, avl);
 
        switch (hdr->type) {
        case UBUS_MSG_INVOKE:
                cb = ubus_process_invoke;
                break;
        case UBUS_MSG_UNSUBSCRIBE:
                cb = ubus_process_unsubscribe;
                break;
        case UBUS_MSG_NOTIFY:
                cb = ubus_process_notify;
                break;
        default:
                return;
        }
 
        if (buf == &ctx->msgbuf) {
                prev_data = buf->data;
                buf->data = NULL;
        }
 
        cb(ctx, hdr, obj, attrbuf, fd);
 
        if (prev_data) {
                if (buf->data)
                        free(prev_data);
                else
                        buf->data = prev_data;
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_process_req_msg()

void ubus_process_req_msg	(	struct ubus_context *	ctx,
		struct ubus_msghdr_buf *	buf,
		int	fd
	)

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

{
        struct ubus_msghdr *hdr = &buf->hdr;
        struct ubus_request *req;
        int id = -1;
 
        switch(hdr->type) {
        case UBUS_MSG_STATUS:
                req = ubus_find_request(ctx, hdr->seq, hdr->peer, &id);
                if (!req)
                        break;
 
                if (fd >= 0) {
                        if (req->fd_cb)
                                req->fd_cb(req, fd);
                        else
                                close(fd);
                }
 
                if (id >= 0)
                        ubus_process_notify_status(req, id, buf);
                else
                        ubus_process_req_status(req, buf);
                break;
 
        case UBUS_MSG_DATA:
                req = ubus_find_request(ctx, hdr->seq, hdr->peer, &id);
                if (req && (req->data_cb || req->raw_data_cb))
                        ubus_process_req_data(req, buf);
                break;
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_send_msg()

int ubus_send_msg	(	struct ubus_context *	ctx,
		uint32_t	seq,
		struct blob_attr *	msg,
		int	cmd,
		uint32_t	peer,
		int	fd
	)

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

{
        struct ubus_msghdr hdr;
        struct iovec iov[2] = {
                STATIC_IOV(hdr)
        };
        int ret;
 
        hdr.version = 0;
        hdr.type = cmd;
        hdr.seq = cpu_to_be16(seq);
        hdr.peer = cpu_to_be32(peer);
 
        if (!msg) {
                blob_buf_init(&b, 0);
                msg = b.head;
        }
 
        iov[1].iov_base = (char *) msg;
        iov[1].iov_len = blob_raw_len(msg);
 
        ret = writev_retry(ctx->sock.fd, iov, ARRAY_SIZE(iov), fd);
        if (ret < 0)
                ctx->sock.eof = true;
 
        if (fd >= 0)
                close(fd);
 
        return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_start_request()

int __hidden ubus_start_request	(	struct ubus_context *	ctx,
		struct ubus_request *	req,
		struct blob_attr *	msg,
		int	cmd,
		uint32_t	peer
	)

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

{
        memset(req, 0, sizeof(*req));
 
        req->fd = -1;
 
        return __ubus_start_request(ctx, req, msg, cmd, peer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ubus_validate_hdr()

bool ubus_validate_hdr

(

struct ubus_msghdr *

hdr

)

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

{
        struct blob_attr *data = (struct blob_attr *) (hdr + 1);
 
        if (hdr->version != 0)
                return false;
 
        if (blob_raw_len(data) < sizeof(*data))
                return false;
 
        if (blob_pad_len(data) > UBUS_MAX_MSGLEN)
                return false;
 
        return true;
}

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.

watch_method

const struct ubus_method watch_method

extern