root/luci2/ubus/libubus.c @ 5993

/*
 *   ubus - openwrt interconnect
 *   Copyright (C) 2010 John Crispin <blogic@openwrt.org>
 *   Copyright (C) 2010 Steven Barth <steven@midlink.org>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#define __USE_GNU
#include <poll.h>
#undef __USE_GNU
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>

#include <ulog.h>
#include "libubus.h"
#include "ubus_tree.h"
#include "ubus_msg.h"
#include "ubus_constants.h"
#include "hash.h"

struct ubus_ctx
{
    int s;
    char *name;
    char *type;
};

#define HOOK_STRING         0x01
#define HOOK_BLOB           0x02
#define HOOK_JSON           0x04
typedef void (*_ubus_hook_generic)(char *node, json_object *payload);

struct ubus_hook
{
    struct list_head list;
    struct list_head tree;
    void *node;
    char *cnode;
    int cnode_len;
    uint32_t hash;
    int wildcard;
    int type;
    _ubus_hook_generic cb;
};

static struct list_head tree;
static struct list_head hooks;

static bool buffer_grow(struct blob_buf *buf, int minlen)
{
    int l = buf->buflen;
    buf->buflen += ((minlen / 256) + 1) * 256;
    buf->buf = realloc(buf->buf, buf->buflen);
    memset(&((char*)buf->buf)[l], 0, buf->buflen - l);
    return !!buf->buf;
}

static struct blob_buf bbuf = {
    .grow = buffer_grow
};

static struct blob_buf lbuf = {
    .grow = buffer_grow
};

int ubus_get_sock(struct ubus_ctx *ctx)
{
    return ctx->s;
}

static struct ubus_hook* ubus_hook_alloc(void *buf, int wildcard, const char *node, int type, _ubus_hook_generic cb)
{
    struct ubus_hook *h = (struct ubus_hook*)malloc(sizeof(struct ubus_hook));
    int l;
    memset(h, 0, sizeof(struct ubus_hook));
    h->wildcard = wildcard;
    h->cb = cb;
    l = blob_pad_len(buf);
    h->node = malloc(l);
    memcpy(h->node, buf, l);
    h->hash = sfh_hash(node, strlen(node));
    h->cnode = strdup(node);
    h->cnode_len = strlen(node);
    h->type = type;
    list_add(&h->list, &hooks);
    return h;
}

static void usb_hook_free(struct ubus_hook *h)
{
    free(h->node);
    free(h->cnode);
    list_del(&h->tree);
    list_del(&h->list);
    free(h);
}

static void ubus_hook_call(struct ubus_hook *h, const char *node, int len, void *payload)
{
    json_object *j;
    struct blob_attr *b = 0;
    const char *n = node;
    if(!h->cb)
        return;
    if(len != h->cnode_len || h->wildcard)
        n = &node[h->cnode_len - 1];
    switch(h->type)
    {
    case HOOK_STRING:
        ((_ubus_hook_string)h->cb)(n, (payload)?(blob_get_string(payload)):(0));
        break;
    case HOOK_JSON:
        j = json_tokener_parse(blob_get_string(payload));
        if(!is_error(j))
            ((_ubus_hook_json)h->cb)(n, j);
        else
            printf("%s:%s[%d] incoming json is invalid\n", __FILE__, __func__, __LINE__);
        break;
    case HOOK_BLOB:
        if(payload)
            b = blob_data(payload);
        ((_ubus_hook_blob)h->cb)(n, b);
        break;
    default:
        break;
    }
}

static struct ubus_hook* ubus_hook_find(const char *node)
{
    struct list_head *p;
    uint32_t hash = sfh_hash(node, strlen(node));
    list_for_each(p, &hooks)
    {
        struct ubus_hook *h = container_of(p, struct ubus_hook, list);
        if(h->hash == hash)
            return h;
    }
    return 0;
}

struct ubus_ctx* ubus_ctx_alloc(const char *type, const char *name)
{
    struct ubus_ctx *ctx =(struct ubus_ctx*)malloc(sizeof(struct ubus_ctx));
    memset(ctx, 0, sizeof(struct ubus_ctx));
    if(name)
        ctx->name = strdup(name);
    if(type)
        ctx->type = strdup(type);
    if(!type && name)
        ctx->type = strdup(name);
    INIT_LIST_HEAD(&tree);
    INIT_LIST_HEAD(&hooks);
    blob_buf_init(&lbuf, 0);
    blob_buf_init(&bbuf, 0);
    return ctx;
}

void ubus_ctx_free(struct ubus_ctx *ctx)
{
    if(!ctx)
        return;
    if(ctx->name)
        free(ctx->name);
    if(ctx->type)
        free(ctx->type);
    if(ctx->s)
        close(ctx->s);
    if(bbuf.buf)
        free(bbuf.buf);
    if(lbuf.buf)
        free(lbuf.buf);
}

static int ubus_send_blob(struct ubus_ctx *ctx, void *buf)
{
    int l, k;
    if(!ctx->s && !buf)
        return -1;
    l = blob_pad_len(buf);
    if(l > 4096)
    {
        LOG("message is bigger than 4096\n");
        return -1;
    }
    k = send(ctx->s, buf, l, 0);
    return k;
}

static int ubus_recv_blob(struct ubus_ctx *ctx, char *buf, int l)
{
    if(!ctx->s && !buf)
        return -1;
    return recv(ctx->s, buf, l, 0);
}

static int ubus_msg_hello(struct ubus_ctx *ctx)
{
    char *buf = 0;
    int l = 0;
    if(ctx->type)
        l += strlen(ctx->type);
    if(ctx->type && ctx->name)
        l += strlen(ctx->name);
    if(l)
    {
        l += 8;
        buf = malloc(l);
        memset(buf, 0, l);
        *buf = 0;
        strcat(buf, "hello.");
        strcat(buf, ctx->type);
        if(ctx->name)
        {
            strcat(buf, ".");
            strcat(buf, ctx->name);
        }
        ubus_msg_encode(UBUS_MSG_CONTROL, buf, 0, 0, 0, 0, &bbuf);
        free(buf);
        return ubus_send_blob(ctx, bbuf.buf);
    }
    return 0;
}

static void ubus_reregister_events(struct ubus_ctx *ctx)
{
    struct list_head *p;
    if(list_empty(&hooks))
        return;
    list_for_each(p, &hooks)
    {
        struct ubus_hook *h = container_of(p, struct ubus_hook, list);
        ubus_msg_encode(UBUS_MSG_ADD, h->cnode, 0, 0, 0, 0, &bbuf);
        ubus_send_blob(ctx, bbuf.buf);
    }
}

int ubus_connect(struct ubus_ctx *ctx)
{
    int s, len;
    struct sockaddr_un remote;
    if(ctx->s)
        return 0;

    if((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
    {
        perror("socket");
        return -1;
    }

    remote.sun_family = AF_UNIX;
    strcpy(remote.sun_path, UBUS_SOCK_PATH);
    len = strlen(remote.sun_path) + sizeof(remote.sun_family);

    if(connect(s, (struct sockaddr *)&remote, len) == -1)
    {
        close(s);
        return -2;
    }
    ctx->s = s;
    LOG("connected to ubus\n");
    ubus_msg_hello(ctx);
    ubus_reregister_events(ctx);
    return ctx->s;
}

static int ubus_event_dispatch_list(struct list_head *l, const char *node, int len, void *buf)
{
    struct list_head *p;
    list_for_each(p, l)
    {
        struct ubus_hook *h = container_of(p, struct ubus_hook, tree);
        if(h->cb)
        {
            ubus_hook_call(h, node, len, buf);
            return 0;
        }
    }
    return 1;
}

static void ubus_event_dispatch(const char *cnode, int len, struct blob_attr *node, void *payload)
{
    struct blob_attr *pos;
    int rem;
    struct list_head *t = &tree;
    struct ubus_tree *n = 0;
    struct ubus_hook *h = ubus_hook_find(cnode);
    if(h)
    {
        if(h->cb)
            ubus_hook_call(h, cnode, len, payload);
        return;
    }
    blob_for_each_attr(pos, node, rem)
    {
        if(blob_id(pos) != UBUS_ITEM)
            return;
        n = ubus_tree_find_child(t, blob_get_string(pos));
        if(!n)
            return;
        if(!ubus_event_dispatch_list(&n->wildcards, cnode, len, payload))
            return;
        t = &n->childs;
    }
}

static void ubus_event_incoming(void *buf)
{
    struct blob_attr *node, *origin = 0, *payload = 0;
    int type, flags = 0;
    const char *cnode;
    type = ubus_msg_decode(&node, &origin, &payload, &flags, buf);
    cnode = ubus_to_string(node);
    switch(type)
    {
    case UBUS_MSG_EVENT:
        ubus_event_dispatch(cnode, strlen(cnode), node, payload);
        break;
    default:
        LOG("unhandled ubus message type\n");
        break;
    }
}

void ubus_recv(struct ubus_ctx *ctx)
{
    char reply[4096];
    char *t = reply;
    int r;
    *reply = 0;
    reply[4095] = 0;
    r = ubus_recv_blob(ctx, reply, 4095);
    while(r && (r >= blob_pad_len((void*)t)))
    {
        int l = blob_pad_len((void*)t);
        ubus_event_incoming(t);
        t += l;
        r -= l;
    }
}

void ubus_poll(struct ubus_ctx *ctx, int timeout)
{
    struct pollfd fd;
    if(!ctx->s)
        ubus_connect(ctx);
    if(!ctx->s)
        return;
    fd.fd = ctx->s;
    fd.events = POLLIN | POLLRDHUP;
    if(poll(&fd, 1, timeout) < 1)
        return;
    if(fd.revents & POLLRDHUP)
    {
        close(ctx->s);
        ctx->s = 0;
        LOG("lost connection to ubus\n");
    } else if(fd.revents & POLLIN)
    {
        ubus_recv(ctx);
    }
}

static void _ubus_event_add(struct ubus_ctx *ctx, char *node, int type, _ubus_hook_generic cb)
{
    struct blob_attr *n;
    struct ubus_tree *t;
    struct ubus_hook *h;
    int flags;
    ubus_msg_encode(UBUS_MSG_ADD, node, 0, 0, 0, 0, &bbuf);
    ubus_msg_decode(&n, 0, 0, &flags, bbuf.buf);
    t = ubus_tree_find(&tree, n, 1);
    h = ubus_hook_alloc(n, flags & FLAG_WILDCARD, node, type, cb);
    if(flags & FLAG_WILDCARD)
        list_add(&h->tree, &t->wildcards);
    else
        list_add(&h->tree, &t->events);
    ubus_send_blob(ctx, bbuf.buf);
}

void ubus_event_add(struct ubus_ctx *ctx, char *node, _ubus_hook_string cb)
{
    _ubus_event_add(ctx, node, HOOK_STRING, (_ubus_hook_generic)cb);
}

void ubus_event_add_blob(struct ubus_ctx *ctx, char *node, _ubus_hook_blob cb)
{
    _ubus_event_add(ctx, node, HOOK_BLOB, (_ubus_hook_generic)cb);
}

void ubus_event_add_json(struct ubus_ctx *ctx, char *node, _ubus_hook_json cb)
{
    _ubus_event_add(ctx, node, HOOK_JSON, (_ubus_hook_generic)cb);
}

void ubus_event_del(struct ubus_ctx *ctx, const char *node)
{
    struct ubus_hook *h = ubus_hook_find(node);
    if(!h)
        return;
    ubus_msg_encode(UBUS_MSG_DEL, node, 0, 0, 0, 0, &bbuf);
    ubus_send_blob(ctx, bbuf.buf);
    usb_hook_free(h);
}

void ubus_event_send(struct ubus_ctx *ctx, const char *node, const char *payload)
{
    if(strstr(node, "*"))
        return;
    ubus_msg_encode(UBUS_MSG_EVENT, node, 0, payload, (payload)?(strlen(payload) + 1):(0) , 0, &bbuf);
    ubus_send_blob(ctx, bbuf.buf);
}

void ubus_event_send_blob(struct ubus_ctx *ctx, const char *node, void *buf)
{
    if(strstr(node, "*"))
        return;
    ubus_msg_encode(UBUS_MSG_EVENT, node, 0, buf, blob_pad_len(buf), 0, &bbuf);
    ubus_send_blob(ctx, bbuf.buf);
}

void ubus_list_flush(void)
{
    blob_buf_init(&lbuf, BLOB_LIST);
}

void ubus_list_add(const char *key, const char *val)
{
    void *nest;
    if(!key || !val)
        return;
    nest = blob_nest_start(&lbuf, LIST_ITEM);
    blob_put_string(&lbuf, LIST_KEY, key);
    blob_put_string(&lbuf, LIST_VAL, val);
    blob_nest_end(&lbuf, nest);
}

void ubus_event_send_list(struct ubus_ctx *ctx, const char *node)
{
    ubus_event_send_blob(ctx, node, lbuf.buf);
}

const char* ubus_list_get(void *blob, const char *key)
{
    struct blob_attr *pos;
    int rem;
    if(!blob)
        return 0;
    blob_for_each_attr(pos, blob, rem)
    {
        struct blob_attr *a;
        const char *k, *v;
        if(blob_id(pos) != LIST_ITEM)
            continue;
        a = blob_data(pos);
        if(!a)
            continue;
        if(blob_id(a) != LIST_KEY)
            continue;
        k = blob_get_string(a);
        if(strcmp(key, k))
            continue;
        a = blob_next(a);
        if(!a)
            continue;
        if(blob_id(a) != LIST_VAL)
            continue;
        v = blob_get_string(a);
        if(!k || !v)
            continue;
        return v;
    }
    return 0;
}

void ubus_list_dump(void *blob)
{
    struct blob_attr *pos;
    int rem;
    if(!blob)
        return;
    blob_for_each_attr(pos, blob, rem)
    {
        struct blob_attr *a;
        const char *key, *val;
        if(blob_id(pos) != LIST_ITEM)
            continue;
        a = blob_data(pos);
        if(!a)
            continue;
        if(blob_id(a) != LIST_KEY)
            continue;
        key = blob_get_string(a);
        a = blob_next(a);
        if(!a)
            continue;
        if(blob_id(a) != LIST_VAL)
            continue;
        val = blob_get_string(a);
        if(!key || !val)
            continue;
        printf("%s -> %s\n", key, val);
    }
}