rules_db.h

 
/*
 * SPDX-License-Identifier: BSD-2-Clause
 * SPDX-FileCopyrightText: Copyright 2020 Rick van Rein <rick@openfortress.nl>
 */
 
 
#ifndef ARPA2_RULES_DB_H
#define ARPA2_RULES_DB_H
 
 
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
 
#include <lmdb.h>
 
#include <arpa2/digest.h>
#include <arpa2/identity.h>
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
// A few good sources on LMDB knowledge:
//
// https://blogs.kolabnow.com/2018/06/07/a-short-guide-to-lmdb
// http://www.lmdb.tech/doc/starting.html
// https://github.com/LMDB/lmdb/blob/mdb.master/libraries/liblmdb/lmdb.h
 
 
#ifdef RULES_TIGHT_LMDBKEY
        typedef unsigned int rules_dbkey_lmdbkey;
        typedef uint8_t rules_dbkey [A2MD_OUTPUT_SIZE]
                __attribute__((__aligned__(4)));
#else /* !RULES_TIGHT_LMDBKEY */
        typedef size_t rules_dbkey_lmdbkey;
        typedef uint8_t rules_dbkey [A2MD_OUTPUT_SIZE]
                __attribute__((__aligned__(8)));
#endif /* RULES_TIGHT_LMDBKEY */
 
#define RULES_LMDBKEY_SIZE (sizeof (rules_dbkey_lmdbkey))
#define RULES_RESTKEY_SIZE (A2MD_OUTPUT_SIZE - RULES_LMDBKEY_SIZE)
 
#define digest2lmdbkey(digest) ((rules_dbkey_lmdbkey *) ((uint8_t *) digest))
#define digest2restkey(digest) (((uint8_t *) digest) + RULES_LMDBKEY_SIZE)
 
 
#ifndef RULES_ENVIRONMENT_PATH
#define RULES_ENVIRONMENT_PATH "/var/lib/arpa2/rules/"
#endif
 
#ifndef RULES_DATABASE_NAME
#define RULES_DATABASE_NAME "RuleDB"
#endif
 
#ifndef RULES_DATABASE_SIZE
#define RULES_DATABASE_SIZE 1048576000L
#endif
 
#ifndef RULES_DATABASE_COUNT_MAX
#define RULES_DATABASE_COUNT_MAX 10
#endif
 
 
 
//TODO//TESTPROGRAM// assert (sizeof (rules_dbkey) == A2MD_OUTPUT_SIZE);
 
 
#define RULES_TRUNK_ANY  0
#define RULES_TRUNK_MIN  1
#define RULES_TRUNK_MAX  4294967295
#define RULES_TRUNK_SIZE 4
 
 
typedef union {
        uint8_t netbytes [RULES_TRUNK_SIZE];
        uint32_t netint32;
} rules_trunk;
 
 
struct rules_db {
        MDB_env    *env;
        MDB_txn    *txn;
        MDB_dbi     dbi;
        MDB_cursor *crs;
        rules_dbkey dig;
        bool        got;
        rules_trunk trk;
};
 
 
// And another... probably due to upsetting __attribute__((__aligned__())) above
bool rules_dbrollback (struct rules_db *ruledb);
 
 
bool rules_dbcommit (struct rules_db *ruledb);
 
 
bool rules_dbsuspend (struct rules_db *ruledb);
 
 
bool rules_dbresume (struct rules_db *ruledb);
 
 
bool rules_dbopen (struct rules_db *ruledb, bool rdonly, uint32_t trunk);
 
 
static inline bool rules_dbopen_rdonly (struct rules_db *ruledb) {
        return rules_dbopen (ruledb, true, RULES_TRUNK_ANY);
}
 
 
bool rules_dbclose (struct rules_db *ruledb);
 
 
static inline bool rules_dbnext (const MDB_val *dbdata, char **rule) {
        *rule += strlen (*rule) + 1;
        return ((*rule) < ((char *) dbdata->mv_data) + dbdata->mv_size);
}
static inline bool rules_dbloop (const MDB_val *dbdata, char **rule) {
        *rule = (char *) dbdata->mv_data;
        return (dbdata->mv_size > 0);
}
static inline bool rules_dbcutnext (MDB_val *dbdata, char **rule, bool cutrule) {
        if (!cutrule) {
                return rules_dbnext (dbdata, rule);
        }
        unsigned rulelen = strlen (*rule) + 1;
        char *tail = *rule + rulelen;
        unsigned taillen = ((char *) dbdata->mv_data) + dbdata->mv_size - tail;
        if (taillen > 0) {
                memmove (*rule, tail, taillen);
        }
        dbdata->mv_size -= rulelen;
        return (taillen > 0);
}
 
 
bool rules_dbget (struct rules_db *ruledb, rules_dbkey digkey, MDB_val *out_dbdata);
 
 
typedef enum { do_add, do_del } changerules_what;
//
bool rules_edit_generic (rules_dbkey svckey, unsigned svckeylen,
                        char *xsname,
                        char *rules, unsigned ruleslen,
                        changerules_what whattodo,
                        a2sel_t *opt_selector, struct rules_db *opt_nested);
 
 
static inline bool rules_dbadd (rules_dbkey prekey, unsigned prekeylen,
                        char *xskey,
                        char *rules, unsigned ruleslen, a2sel_t *opt_selector) {
        return rules_edit_generic (prekey, prekeylen, xskey, rules, ruleslen,
                        do_add, opt_selector, NULL);
}
 
 
static inline bool rules_dbdel (rules_dbkey prekey, unsigned prekeylen,
                        char *xskey,
                        char *rules, unsigned ruleslen, a2sel_t *opt_selector) {
        return rules_edit_generic (prekey, prekeylen, xskey, rules, ruleslen,
                        do_del, opt_selector, NULL);
}
 
 
bool rules_dbset (struct rules_db *ruledb, MDB_val *in0_dbdata, MDB_val *in1_dbdata);
 
 
bool rules_dbkey_domain (rules_dbkey domkey,
                        const uint8_t *opt_dbkey, int dbkeylen,
                        const char *xsdomain);
 
 
bool rules_dbkey_service (rules_dbkey svckey,
                        const uint8_t *domkey, unsigned domkeylen,
                        const uint8_t xstype [16]);
 
 
bool rules_dbkey_selector (rules_dbkey reqkey,
                        const uint8_t *svckey, unsigned svckeylen,
                        const char *xsname,
                        const a2sel_t *selector);
 
 
bool rules_dbkey_parse (rules_dbkey outkey,
                        const char *hexkey, int hexkeylen);
 
 
#ifdef __cplusplus
}
#endif
 
#endif /* ARPA2_RULES_DB_H */