root/luci2/cbi2/cbi.c @ 5709

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <assert.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <glob.h>
#include <libgen.h>

#include "lucic.h"
#include "list.h"
#include "blob.h"
#include "cbi.h"
#include "json.h"

struct list_head cbi_widgets;
int cbi_widget_init = 0;

void cbi_widget_register(char *name, struct cbi_widget *w)
{
    if(!cbi_widget_init)
    {
        INIT_LIST_HEAD(&cbi_widgets);
        cbi_widget_init = 1;
    }
    list_add_tail(&w->list, &cbi_widgets);
}

struct cbi_widget* cbi_widget_find(const char *name)
{
    struct list_head *p;
    list_for_each(p, &cbi_widgets)
    {
        struct cbi_widget *w = container_of(p, struct cbi_widget, list);
        if(!strcmp(w->name, name))
            return w;
    }
    return 0;
}

struct cbi_ctx* cbi_alloc_ctx(void)
{
    struct cbi_ctx *ctx = malloc(sizeof(struct cbi_ctx));

    assert(ctx != NULL);
    memset(ctx, 0, sizeof(struct cbi_ctx));
    INIT_LIST_HEAD(&ctx->files);
    INIT_LIST_HEAD(&ctx->pages);
    INIT_LIST_HEAD(&ctx->globals);
    INIT_LIST_HEAD(&ctx->menus);
    INIT_LIST_HEAD(&ctx->elements);

    return ctx;
}

struct cbi_property* cbi_parse_properties(struct blob_attr *prop)
{
    int rem = blob_len(prop);
    struct cbi_property *p = malloc(sizeof(struct cbi_property));

    assert(p != NULL);
    memset(p, 0, sizeof(struct cbi_property));
    prop = blob_data(prop);
    assert(blob_id(prop) == CBI_KEY);
    assert(blob_pad_len(prop) < rem);
    p->key = strdup(blob_get_string(prop));
    rem -= blob_pad_len(prop);
    prop = blob_next(prop);
    assert(blob_id(prop) == CBI_VALUE);
    assert(blob_pad_len(prop) == rem);
    p->value = strdup(blob_get_string(prop));
    p->generated = 0;
    return p;
}

void cbi_add_property(struct cbi_element *e, const char *name, const char *val, int generated)
{
    struct cbi_property *p = malloc(sizeof(struct cbi_property));

    memset(p, 0, sizeof(struct cbi_property));
    p->key = strdup(name);
    p->value = strdup(val);
    p->generated = generated;
    list_add_tail(&p->list, &e->properties);
}

const char* cbi_find_prop(struct cbi_element *e, const char *key)
{
    struct list_head *q;

    list_for_each(q, &e->properties)
    {
        struct cbi_property *p = container_of(q, struct cbi_property, list);
        if(!strcmp(p->key, key))
            return p->value;
    }
    return 0;
}

int cbi_find_prop_int(struct cbi_element *e, char *key, int def)
{
    const char *c = cbi_find_prop(e, key);
    if(c)
        return atoi(c);
    return def;
}

void cbi_get_element_id(struct cbi_element *e, char *buffer, int file)
{
    const char *id;
    if(!e)
        return;
    cbi_get_element_id(e->parent, buffer, file);
    id = cbi_find_prop(e, "id");
    if(!id && (CAPS(e) & CAP_DATA))
        id = cbi_find_prop(e, "src");
    if(!id)
        return;
    if(e->parent)
    {   if(e->parent->parent)
            strcat(buffer, ".");
        else
            strcat(buffer, ":");
    }
    strcat(buffer, id);
}

void cbi_gen_default_id(struct cbi_element *e, int *count)
{
    char tmp[128];
    char buffer[256];
    const char *id = cbi_find_prop(e, "id");
    if(id)
        return;
    if(e->w)
        if(e->w->caps & CAP_DATA)
            id = cbi_find_prop(e, "src");
    if(!id)
        id = cbi_find_prop(e, "name");
    if(id)
    {
        const char *a, *b;
        a = b = id;
        while((a = strstr(b, ".")))
            b = ++a;
        if(*b == '@')
            b++;
        cbi_add_property(e, "id", b, 1);
        return;
    }
    snprintf(tmp, 127, "%s%d", e->widget, *count);
    tmp[127] = '\0';
    cbi_add_property(e, "id", tmp, 1);
    *buffer = 0;
    cbi_get_element_id(e->parent, buffer, 1);
    LOG("generating id for %s\n", tmp);
    (*count)++;
}

int cbi_init_element(struct cbi_ctx *ctx, struct cbi_element *e, int *count)
{
    e->w = cbi_widget_find(e->widget);
    if(!(e->w))
        return 1;
    list_add_tail(&e->widget_ref, &e->w->refs);
    if(widget_find_prop(e->w, "id"))
        cbi_gen_default_id(e, count);
    if(e->w->init)
        if(e->w->init(ctx, e))
            return 1;
    return 0;
}

struct cbi_element* cbi_find_element(struct cbi_element *e, const char *id)
{
    struct list_head *p;
    list_for_each(p, &e->elements)
    {
        struct cbi_element *e = container_of(p, struct cbi_element, list);
        const char *id2 = cbi_find_prop(e, "id");
        if(id2)
        {
            if(!strcmp(id, id2))
                return e;
        }
    }
    return 0;
}

struct cbi_element* cbi_parse_element(struct cbi_ctx *ctx, struct blob_attr *attr, int *count, struct cbi_element *parent)
{
    struct blob_attr *element, *element2;
    int rem = blob_len(attr), rem2;
    struct cbi_element *e = malloc(sizeof(struct cbi_element));
    int sub_count = 0;
    assert(e != NULL);
    memset(e, 0, sizeof(struct cbi_element));
    INIT_LIST_HEAD(&e->properties);
    INIT_LIST_HEAD(&e->elements);

    attr = blob_data(attr);
    assert(blob_id(attr) == CBI_NAMESPACE);
    e->namespace = strdup(blob_get_string(attr));
    assert(blob_pad_len(attr) < rem);
    rem -= blob_pad_len(attr);
    attr = blob_next(attr);
    assert(blob_id(attr) == CBI_WIDGET);
    e->widget = strdup(blob_get_string(attr));
    assert(blob_pad_len(attr) <= rem);
    e->parent = parent;
    rem -= blob_pad_len(attr);
    rem2 = rem;
    element2 = element = blob_next(attr);
    for(;
        (blob_pad_len(element) <= rem) && (blob_pad_len(element) >= sizeof(struct blob_attr));
        rem -= blob_pad_len(element), element = blob_next(element))
    {
        struct cbi_property *p;
        switch(blob_id(element))
        {
        case CBI_VALUE:
            e->value = strdup(blob_get_string(element));
            break;
        case CBI_PROPERTY:
            p = cbi_parse_properties(element);
            list_add_tail(&p->list, &e->properties);
            break;
        case CBI_ELEMENT:
            break;
        default:
            LOG("unknown blob_id %d unknown\n", blob_id(element));
            abort();
            break;
        }
    }
    if(cbi_init_element(ctx, e, count))
    {
        LOG("unknown widget type %s\n", e->widget);
        free(e);
        return 0;
    }
    element = element2;
    rem = rem2;
    for(;
        (blob_pad_len(element2) <= rem2) && (blob_pad_len(element2) >= sizeof(struct blob_attr));
        rem2 -= blob_pad_len(element2), element2 = blob_next(element2))
    {
        struct cbi_element *sub_e;
        switch(blob_id(element2))
        {
        case CBI_PROPERTY:
        case CBI_VALUE:
            break;
        case CBI_ELEMENT:
            sub_e = cbi_parse_element(ctx, element2, &sub_count, e);
            if(sub_e)
                list_add_tail(&sub_e->list, &e->elements);
            break;
        default:
            LOG("unknown blob_id %d unknown\n", blob_id(element2));
            abort();
            break;
        }
    }
    if(e->w->caps & CAP_TEMPLATE)
    {
        e->blob = (struct cbi_blob*)malloc(sizeof(struct cbi_blob));
        e->blob->rem = rem;
        e->blob->blob = malloc(rem);
        memcpy(e->blob->blob, element, rem);
    }
    return e;
}

void cbi_create_instance(struct cbi_ctx *ctx, struct cbi_element *e1, struct cbi_element *e2)
{
    struct blob_attr *element;
    int rem;
    int sub_count = 0;
    if(!e2->blob)
    {
        CBILOG(e2, "failed to create instance\n");
        return;
    }
    element = (struct blob_attr*)e2->blob->blob;
    rem = e2->blob->rem;
    for(;
        (blob_pad_len(element) <= rem) && (blob_pad_len(element) >= sizeof(struct blob_attr));
        rem -= blob_pad_len(element), element = blob_next(element))
    {
        struct cbi_element *sub_e;
        switch(blob_id(element))
        {
        case CBI_PROPERTY:
        case CBI_VALUE:
            break;
        case CBI_ELEMENT:
            sub_e = cbi_parse_element(ctx, element, &sub_count, e1);
            if(sub_e)
                list_add_tail(&sub_e->list, &e1->elements);
            break;
        default:
            LOG("unknown blob_id %d unknown\n", blob_id(element));
            abort();
            break;
        }
    }
}

struct cbi_file* cbi_find_file(struct cbi_ctx *ctx, const char *name)
{
    struct list_head *p;

    list_for_each(p, &ctx->files)
    {
        struct cbi_file *f = container_of(p, struct cbi_file, list);
        if(!strcmp(f->file, name))
            return f;
    }
    return 0;
}

static struct cbi_element* cbi_resolv_element(struct cbi_element *e, char *ref)
{
    char *tok;
    struct cbi_element *next;
    tok = strstr(ref, ".");
    if(!tok)
    {
        const char *id = cbi_find_prop(e, "id");
        if(!strcmp(id, ref))
            return e;
        else
            return 0;
    }
    *tok = '\0';
    tok++;
    next = cbi_find_element(e, tok);
    if(next)
        return cbi_resolv_element(next, tok);
    return 0;
}

struct cbi_element* cbi_resolv(struct cbi_ctx *ctx, const char *ref)
{
    struct cbi_element *ret = 0;
    struct list_head *p;
    list_for_each(p, &ctx->elements)
    {
        struct cbi_element *e2 = container_of(p, struct cbi_element, list);
        char *buf = strdup(ref);
        ret = cbi_resolv_element(e2, buf);
        free(buf);
        if(ret)
            break;
    }
    return ret;
}

void cbi_index_verify(struct cbi_ctx *ctx, struct cbi_element *e)
{
    struct list_head *p;
    if(e->w->caps & CAP_TEMPLATE)
        return;
    widget_verify(ctx, e);
    if(e->broken)
        return;
    list_for_each(p, &e->elements)
    {
        struct cbi_element *e = container_of(p, struct cbi_element, list);
        cbi_index_verify(ctx, e);
    }
}

void cbi_index_add(struct cbi_ctx *ctx, struct cbi_file *f)
{
    struct list_head *p;
    LOG("indexing %s\n", f->name);
    list_for_each(p, &f->e->elements)
    {
        struct cbi_element *e = container_of(p, struct cbi_element, list);
        cbi_index_verify(ctx, e);
        if(CAPS(e) & CAP_PAGE)
        {
            list_add_tail(&e->index, &ctx->pages);
        } else {
            list_add_tail(&e->index, &ctx->globals);
        }
    }
}

void cbi_index(struct cbi_ctx *ctx)
{
    struct list_head *p;
    list_for_each(p, &ctx->files)
    {
        struct cbi_file *f = container_of(p, struct cbi_file, list);
        cbi_index_add(ctx, f);
    }
}

void cbi_index_remove(struct cbi_file *f)
{
    struct list_head *p;
    LOG("unindexing %s\n", f->name);
    list_for_each(p, &f->e->elements)
    {
        struct cbi_element *e = container_of(p, struct cbi_element, list);
        list_del(&e->index);
    }
}

void cbi_free_property(struct cbi_property *prop)
{
    free(prop->key);
    free(prop->value);
    list_del(&prop->list);
    free(prop);
}

void cbi_free_element(struct cbi_element *element)
{
    struct list_head *p, *q;
    list_for_each_safe(p, q, &element->elements)
    {
        struct cbi_element *e = container_of(p, struct cbi_element, list);
        cbi_free_element(e);
    }
    list_for_each_safe(p, q, &element->properties)
    {
        struct cbi_property *r = container_of(p, struct cbi_property, list);
        cbi_free_property(r);
    }
    free(element->namespace);
    free(element->widget);
    if(element->value)
        free(element->value);
    list_del(&element->list);
    free(element);
}

void cbi_free_file(struct cbi_ctx *ctx, struct cbi_file *file)
{
    struct list_head *p, *q;
    cbi_index_remove(file);
    LOG("dropping %s\n", file->name);
    list_for_each_safe(p, q, &file->e->elements)
    {
        struct cbi_element *e = container_of(p, struct cbi_element, list);
        cbi_free_element(e);
    }
    free(file->name);
    free(file->file);
    list_del(&file->list);
    list_del(&file->e->list);
    free(file);
}

void cbi_free_context(struct cbi_ctx *ctx)
{
    struct list_head *p, *q;
    list_for_each_safe(p, q, &ctx->files)
    {
        struct cbi_file *f = container_of(p, struct cbi_file, list);
        cbi_free_file(ctx, f);
    }
    free(ctx);
}

void cbi_index_flush(struct cbi_ctx *ctx)
{
    INIT_LIST_HEAD(&ctx->pages);
    INIT_LIST_HEAD(&ctx->globals);
    INIT_LIST_HEAD(&ctx->menus);
}

int cbi_add_file(struct cbi_ctx *ctx, char *filename, int index)
{
    struct stat st;
    int fd, err, rem;
    void *map = NULL;
    struct cbi_file *f;
    struct blob_attr *pos;
    struct stat s;
    int count = 0;
    assert(ctx != NULL);
    f = cbi_find_file(ctx, filename);
    if(f)
    {
        if(!stat(filename, &s))
        {
            if(f->mtime == s.st_mtime)
                return 0;
            cbi_free_file(ctx, f);
            f = 0;
        }
    }
    LOG("loading %s\n", filename);
    fd = open(filename, O_RDONLY);
    if(fd < 0)
        return fd;
    err = fstat(fd, &st);
    if (err < 0)
        goto error;
    err = -EINVAL;
    if (st.st_size == 0)
        goto error;
    map = mmap(NULL, st.st_size, PROT_READ, MAP_FILE | MAP_PRIVATE, fd, 0);
    if (map == MAP_FAILED)
        goto error;
    if (blob_pad_len(map) > st.st_size)
        goto error;
    err = -ENOMEM;
    f = malloc(sizeof(struct cbi_file));
    assert(f != NULL);
    memset(f, 0, sizeof(struct cbi_file));
    f->file = strdup(filename);
    f->name = strdup(basename(filename));
    f->name[strlen(f->name) - 5] = '\0';
    f->mtime = st.st_mtime;
    f->e = malloc(sizeof(struct cbi_element));
    memset(f->e, 0, sizeof(struct cbi_element));
    INIT_LIST_HEAD(&f->e->elements);
    INIT_LIST_HEAD(&f->e->properties);
    f->e->namespace = strdup("luci");
    f->e->widget = strdup("file");
    f->e->w = cbi_widget_find("file");
    cbi_add_property(f->e, "src", f->name, 1);
    cbi_add_property(f->e, "id", f->name, 1);
    blob_for_each_attr(pos, map, rem)
    {
        struct cbi_element *e;
        if(blob_id(pos) != CBI_ELEMENT)
            continue;
        e = cbi_parse_element(ctx, pos, &count, 0);
        if(e)
            list_add_tail(&e->list, &f->e->elements);
    }
    list_add_tail(&f->e->list, &ctx->elements);
    list_add_tail(&f->list, &ctx->files);
    if(index)
        cbi_index_add(ctx, f);
    return 0;

error:
    return err;
}

static inline void print_spaces(int d)
{
    while(d--)
        printf("\t");
}

void cbi_dump_element(struct cbi_element *e, int depth)
{
    struct list_head *p;
    char nl = (!list_empty(&e->elements))?('\n'):('\0');
    if(e->broken)
        return;
    if(e->w->caps & CAP_TEMPLATE)
        return;
    print_spaces(depth);
    printf("<%s:%s", e->namespace, e->widget);
    list_for_each(p, &e->properties)
    {
        struct cbi_property *q = container_of(p, struct cbi_property, list);
        printf(" %s=\"%s\"", q->key, q->value);
    }
    if(!nl && !e->value)
        printf("/");
    printf(">%c", nl);
    if(e->value)
    {
        if(nl)
            print_spaces(depth + 1);
        printf("%s%c", e->value, nl);
    }
    list_for_each(p, &e->elements)
    {
        struct cbi_element *e = container_of(p, struct cbi_element, list);
        cbi_dump_element(e, depth + 1);
    }
    if(nl)
        print_spaces(depth);
    if(nl || e->value)
        printf("</%s:%s>\n", e->namespace, e->widget);
    else
        printf("\n");
}

void cbi_dump_list(struct list_head *h)
{
    struct list_head *p;
    list_for_each(p, h)
    {
        struct cbi_element *e = container_of(p, struct cbi_element, index);
        const char *id = cbi_find_prop(e, "id");
        if(id)
            printf("%s -> %s\n", e->widget, id);
    }
}

void cbi_dump(struct cbi_ctx *ctx)
{
    struct list_head *p;

    list_for_each(p, &ctx->elements)
    {
        struct cbi_element *e = container_of(p, struct cbi_element, list);
        cbi_dump_element(e, 0);
    }
}

const char* cbi_virt_path(struct cbi_ctx *ctx, const char *path, const char *file)
{
    static char buf[256];
    buf[255] = '\0';
    snprintf(buf, 255, "%s%s%s", (ctx->vroot)?(ctx->vroot):(""), path, (file)?(file):(""));
    return buf;
}

struct cbi_ctx* cbi_load_files(struct cbi_ctx *ctx)
{
    glob_t gl;
    int gl_flags = GLOB_NOESCAPE | GLOB_NOSORT | GLOB_MARK;
    if(glob(cbi_virt_path(ctx, ctx->path, "*.lucio"), gl_flags, NULL, &gl) >= 0)
    {
        int i;
        for(i = 0; i < gl.gl_pathc; i++)
            cbi_add_file(ctx, gl.gl_pathv[i], 0);
        globfree(&gl);
    }
    return ctx;
}

void cbi_check_old_files(struct cbi_ctx *ctx)
{
    struct list_head *p, *q;

    list_for_each_safe(p, q, &ctx->files)
    {
        struct cbi_file *f = container_of(p, struct cbi_file, list);
        struct stat s;
        if(stat(f->file, &s))
            cbi_free_file(ctx, f);
    }
}

void cbi_check_new_files(struct cbi_ctx *ctx)
{
    glob_t gl;
    int gl_flags = GLOB_NOESCAPE | GLOB_NOSORT | GLOB_MARK;
    if(glob(cbi_virt_path(ctx, ctx->path, "*.luco"), gl_flags, NULL, &gl) >= 0)
    {
        int i;
        for(i = 0; i < gl.gl_pathc; i++)
            cbi_add_file(ctx, gl.gl_pathv[i], 1);
        globfree(&gl);
    }
}

void cbi_check_new_files_src(struct cbi_ctx *ctx)
{
    glob_t gl;
    int gl_flags = GLOB_NOESCAPE | GLOB_NOSORT | GLOB_MARK;
    if(glob(cbi_virt_path(ctx, ctx->path, "*.luci"), gl_flags, NULL, &gl) >= 0)
    {
        int i;
        for(i = 0; i < gl.gl_pathc; i++)
        {
            char *out = strdup(gl.gl_pathv[i]);
            out[strlen(out) - 1] = 'o';
            LOG("compiling %s -> %s\n", gl.gl_pathv[i], out);
            if(!lucic_main(gl.gl_pathv[i], out))
            {
                LOG("deleting %s\n", gl.gl_pathv[i]);
                unlink(gl.gl_pathv[i]);
            } else {
                LOG("failed\n");
            }
        }
        globfree(&gl);
    }
}

void cbi_reindex(struct cbi_ctx *ctx)
{
    cbi_check_old_files(ctx);
    cbi_check_new_files_src(ctx);
    cbi_check_new_files(ctx);
}

int cbi_dump_blob(char *file)
{
    struct cbi_ctx *ctx = cbi_alloc_ctx();
    cbi_add_file(ctx, file, 0);
    cbi_index(ctx);
    cbi_dump(ctx);
    cbi_free_context(ctx);
    return 0;
}

struct cbi_ctx* cbi_init(const char *vroot, const char *path)
{
    struct cbi_ctx *ctx = cbi_alloc_ctx();
    if(!path)
        ctx->path = strdup("/lib/luci2/");
    else
        ctx->path = strdup(path);
    if(vroot)
        ctx->vroot = strdup(vroot);
    else
        ctx->vroot = 0;
    validate_init(ctx);
    cbi_load_files(ctx);
    cbi_index(ctx);
    cbi_reindex(ctx);
    return ctx;
}

void cbi_request(struct cbi_ctx *ctx, char *request)
{
    json_object *out, *in = json_tokener_parse(request);
    if(is_error(in))
    {
        printf("bad json\n");
        return;
    }
    out = json_request(ctx, in);
    if(out)
    {
        printf("res -> %s\n", json_object_to_json_string(out));
        json_object_put(out);
    }
    json_object_put(in);
}