Unix Ricing - Printable Version

Code:
$ cat ndb.c

#include "ndb.h"



#include <assert.h>

#include <errno.h>

#include <fcntl.h>

#include <fnmatch.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <dirent.h>

#include <ctype.h>



/*

 * The Network Datbase: a simple text-based key-value entrys file format:

 * http://code.9front.org/hg/plan9front/file/c4896008f196/sys/src/libndb

 *

 * This implementation uses a singly linked list for the entire database,

 * with all lines and entries chained on the same linked list, with an

 * aditionnal pointer to the begining of the line, and another to the

 * begining of the tuple:

 */



#include "log.h"



static void *

ndb_new(struct ndb **entry)

{

    struct ndb *np;



    if ((np = calloc(sizeof(struct ndb), 1)) == NULL)

        return (NULL);

    np->entry = *entry = *entry ? *entry : np;

    return (np);

}



void

ndb_free(struct ndb *np)

{

    if (np)

        ndb_free(np->next);

    free(np);

}



/*

 * key = 1*keychar

 * keychar = ( '0'..'9' | 'a'..'z' | 'A'..'Z' | '_' | '-' )

 */

static char *

ndb_parse_key(char *s, struct ndb *new)

{

    char *key;

    size_t len;



    key = s;

    while (*s != '\0' && (isalnum(*s) || strchr("_-", *s)))

        s++;

    if (s == key)

        return (NULL);

    len = s-key;



    if (len >= sizeof(new->key))

        return (errno=ENAMETOOLONG, NULL);

    memcpy(new->key, key, len);

    return (s);

}



/*

 * val = ( '"' *quotedchar '"' | *unquotchar )

 * quotedchar = ( 0x20..0x21 | 0x23..0x7E | 0x80..0xFF)

 * unquotchar = ( 0x21 | 0x24..0x26 | 0x5D..0x7E | 0x80..0xFF)

 */

static char *

ndb_parse_val(char *s, struct ndb *new)

{

    char *val;

    size_t len;



    if (*s == '"') {

        s++;

        val = s;

        while (*s >= 0x20 && *s != '"' && *s != 0x7f)

            s++;

        len = s-val;

        if (*s++ != '"')

            return (NULL);

    } else {

        val = s;

        while (*s >= 0x21 && *s != '"' && *s != 0x7f)

            s++;

        len = s-val;

    }



    if (len >= sizeof(new->val))

        return (errno=ENAMETOOLONG, NULL);

    memcpy(new->val, val, len);

    return (s);

}



/*

 * tuple = key '=' val

 */

static char *

ndb_parse_tuple(char *s, struct ndb **entry, struct ndb **last)

{

    struct ndb *new;



    if ((new = ndb_new(entry)) == NULL)

        return (NULL);



    if ((s = ndb_parse_key(s, new)) == NULL)

        goto err;



    if (*s++ != '=')

        goto err;



    if ((s = ndb_parse_val(s, new)) == NULL)

        goto err;



    if (*last != NULL)

        (*last)->next = new;

    *last = new;

    return (s);

err:

    free(new);

    return (NULL);

}



/*

 * ws = ( '\t' | '\r' | ' ' )

 */

static char *

ndb_parse_ws(char *s)

{

    if (!isblank(*s) && *s != '\r')

        return (NULL);

    while (isblank(*s) || *s == '\r')

        s++;

    return (s);

}



/*

 * nl = 1*( [ ws ] [ '#' *non-nl ] '\n' )

 */

static char *

ndb_parse_nl(char *s, size_t *nl)

{

    char *beg;

    size_t n;



    for (n = 0 ;; n++, (*nl)++) {

        beg = s;

        if ((s = ndb_parse_ws(s)) == NULL)

            s = beg;

        if (*s == '#') {

            while (*s != '\0' && *s != '\n')

                s++;

        }

        if (*s != '\n') {

            s = beg;

            break;

        }

        s++;

    }

    if (n == 0)

        return (NULL);

    return (s);

}



/*

 * line = tuple *( 1*ws tuple ) nl

 */

static char *

ndb_parse_line(char *s, struct ndb **entry, struct ndb **last, size_t *nl)

{

    char *cp;



    if ((s = ndb_parse_tuple(s, entry, last)) == NULL)

        return (NULL);



    while ((cp = ndb_parse_ws(s))) {

        s = cp;



        if ((cp = ndb_parse_tuple(s, entry, last)) == NULL)

            break;

        s = cp;

    }



    return (ndb_parse_nl(s, nl));

}



/*

 * entry = line *( 1*ws line )

 */

static char *

ndb_parse_entry(char *s, struct ndb **last, size_t *nl)

{

    struct ndb *entry = NULL;

    char *cp;



    if ((cp = ndb_parse_line(s, &entry, last, nl)) == NULL)

        return (NULL);

    s = cp;



    while ((cp = ndb_parse_ws(s))) {

        s = cp;



        if ((cp = ndb_parse_line(s, &entry, last, nl)) == NULL)

            break;

        s = cp;

    }

    return (errno ? NULL : s);

}



/*

 * base = *nl *( tuple *nl )

 */

static char *

ndb_parse_db(char *s, struct ndb **db, struct ndb **last, size_t *nl)

{

    char *cp;



    while ((cp = ndb_parse_nl(s, nl)))

        s = cp;



    *db = NULL;

    while ((cp = ndb_parse_entry(s, last, nl))) {

        s = cp;



        if (*db == NULL)

            *db = (*last)->entry;



        while ((cp = ndb_parse_nl(s, nl)))

            s = cp;

    }

    return (errno ? NULL : s);

}



static ssize_t

readfile(char const *path, char **s)

{

    ssize_t r, n;

    void *v;

    int fd;



    if ((fd = (path == NULL) ? 0 : open(path, O_RDONLY)) == -1)

        return (-1);



    r = n = 0;

    *s = NULL;

    do {

        n += r;

        if ((v = realloc(*s, n + 2048 + 1)) == NULL) {

            r = -1;

            goto err;

        }

        *s = v;

    } while ((r = read(fd, *s + n, 2048)) > 0);

    (*s)[n] = '\0';

err:

    if (fd > 0)

        close(fd);

    if (r == -1) {

        free(*s);

        *s = NULL;

    }

    return (r);

}



struct ndb *

ndb_parse_file(char const *path, size_t *nl, struct ndb **last)

{

    struct ndb *db;

    ssize_t r;

    char *s;



    *nl = 0;

    db = NULL;



    if ((r = readfile(path, &s)) == -1)

        return (NULL);

    if (memchr(s, '\0', r)) {

        errno = EBADMSG;

        return (NULL);

    }



    *nl = 1;

    if (ndb_parse_db(s, &db, last, nl) < s + r) {

        errno = EBADMSG;

        ndb_free(db);

        db = NULL;

    }

    free(s);

    return (db);

}



struct ndb *

ndb_open(char const **path, size_t *nl)

{

    struct ndb *db, *last, *np, *entry, *file;



    last = NULL;



    if ((db = np = ndb_parse_file(*path, nl, &last)) == NULL)

        return (NULL);



    if ((np = ndb_search(&np, NULL, "database", "")) == NULL)

        return (db);



    entry = np = np->entry;

    while ((file = ndb_search(&np, entry, "file", NULL))) {

        if (ndb_parse_file(file->val, nl, &last) == NULL) {

            *path = strdup(file->val);

            ndb_free(db);

            return (NULL);

        }

    }

    return (db);

}



struct ndb *

ndb_search(struct ndb **npp, struct ndb *entry, char const *key, char const *val)

{

    for (struct ndb *np = *npp; np; np = np->next) {

        if (entry && np->entry != entry->entry)

            break;

        if (strcmp(np->key, key) == 0) {

            if (!val || fnmatch(val, np->val, 0) == 0) {

                *npp = np->next;

                return (np);

            }

        }

    }

    return (NULL);

}



struct ndb *

ndb_related(struct ndb *this, char const *key)

{

    struct ndb *np, *entry;



    entry = this->entry;

    for (np = entry; np && np->entry == entry; np = np->next)

        if (strcmp(np->key, key) == 0)

            return ( np);

    return (NULL);

}



void

ndb_put_tuple(FILE *fp, struct ndb *np)

{

    char *fmt;



    fmt = np->val[strcspn(np->val, " \t")] == '\0' ? "%s=%s" : "%s=\"%s\"";

    fprintf(fp, fmt, np->key, np->val);

}



void

ndb_put_entry(FILE *fp, struct ndb *np, int nl)

{

    struct ndb *entry;

    int first;



    first = 1;

    for (np = entry = np->entry; np && np->entry == entry; np = np->next) {

        if (!first)

            fprintf(fp, nl ? "\n\t" : " ");

        ndb_put_tuple(fp, np);

        first = 0;

    }

}

$ cat ndb.h

#ifndef NDB_H

#define NDB_H



#include <time.h>

#include <stdint.h>

#include <stdio.h>



struct ndb {

    char        key[32];

    char        val[128];

    struct ndb    *next;        /* across multiple lines or tuples */

    struct ndb    *entry;        /* start of this entry */

};



/**/

void        ndb_free        (struct ndb *);

struct ndb *    ndb_search        (struct ndb **, struct ndb *, char const *, char const *);

struct ndb *    ndb_related        (struct ndb *, char const *);

struct ndb *    ndb_parse_file        (char const *, size_t *, struct ndb **);

struct ndb *    ndb_open        (char const **, size_t *);

void        ndb_put_tuple        (FILE *, struct ndb *);

void        ndb_put_entry        (FILE *, struct ndb *, int);



#endif