labels.c

#include <stdbool.h>
#include <stdint.h>

#include "internal/internal.h"

#define MAX_BITS 1024

#define CONNLABEL_CFG "/etc/xtables/connlabel.conf"
#define HASH_SIZE 64

struct labelmap_bucket {
        char *name;
        unsigned int bit;
        struct labelmap_bucket *next;
};

struct nfct_labelmap {
        struct labelmap_bucket *map_name[HASH_SIZE];
        unsigned int namecount;
        char **bit_to_name;
};

static struct labelmap_bucket* label_map_bucket_alloc(const char *n, unsigned int b)
{
        struct labelmap_bucket *bucket;
        char *name = strdup(n);

        if (!name)
                return NULL;

        bucket = malloc(sizeof(*bucket));
        if (!bucket) {
                free(name);
                return NULL;
        }
        bucket->name = name;
        bucket->bit = b;
        return bucket;
}

static unsigned int hash_name(const char *name)
{
        unsigned int hash = 0;

        while (*name) {
                hash = (hash << 5) - hash + *name;
                name++;
        }
        return hash & (HASH_SIZE - 1);
}

int __labelmap_get_bit(struct nfct_labelmap *m, const char *name)
{
        unsigned int i = hash_name(name);
        struct labelmap_bucket *list = m->map_name[i];

        while (list) {
                if (strcmp(name, list->name) == 0)
                        return list->bit;
                list = list->next;
        }
        return -1;
}

const char *__labelmap_get_name(struct nfct_labelmap *m, unsigned int bit)
{
        if (bit < m->namecount)
                return m->bit_to_name[bit] ? m->bit_to_name[bit] : "";
        return NULL;
}

static int map_insert(struct nfct_labelmap *m, const char *n, unsigned int b)
{
        unsigned int i = hash_name(n);
        struct labelmap_bucket *list = m->map_name[i];

        while (list) {
                if (strcmp(list->name, n) == 0)
                        return -1;
                list = list->next;
        }

        list = label_map_bucket_alloc(n, b);
        if (!list)
                return -1;

        if (m->map_name[i])
                list->next = m->map_name[i];
        else
                list->next = NULL;
        m->map_name[i] = list;
        return 0;
}

static int is_space_posix(int c)
{
        return c == ' ' || c == '\f' || c == '\r' || c == '\t' || c == '\v';
}

static char *trim_label(char *label)
{
        char *end;

        while (is_space_posix(*label))
                label++;
        end = strchr(label, '\n');
        if (end)
                *end = 0;
        else
                end = strchr(label, '\0');
        end--;

        while (end > label && is_space_posix(*end)) {
                *end = 0;
                end--;
        }

        return *label ? label : NULL;
}

static int
xtables_parse_connlabel_numerical(const char *s, char **end)
{
        unsigned long value;

        value = strtoul(s, end, 0);
        if (value == 0 && s == *end)
                return -1;
        if (value >= MAX_BITS)
                return -1;
        return value;
}

static void free_list(struct labelmap_bucket *b)
{
        struct labelmap_bucket *tmp;

        while (b) {
                free(b->name);

                tmp = b;
                b = b->next;

                free(tmp);
        }
}

void __labelmap_destroy(struct nfct_labelmap *map)
{
        unsigned int i;
        struct labelmap_bucket *b;

        for (i = 0; i < HASH_SIZE; i++) {
                b = map->map_name[i];
                free_list(b);
        }

        free(map->bit_to_name);
        free(map);
}

static void make_name_table(struct nfct_labelmap *m)
{
        struct labelmap_bucket *b;
        unsigned int i;

        for (i = 0; i < HASH_SIZE; i++) {
                b = m->map_name[i];
                while (b) {
                        m->bit_to_name[b->bit] = b->name;
                        b = b->next;
                }
        }
}

static struct nfct_labelmap *map_alloc(void)
{
        struct nfct_labelmap *map = malloc(sizeof(*map));
        if (map) {
                unsigned int i;
                for (i = 0; i < HASH_SIZE; i++)
                        map->map_name[i] = NULL;
                map->bit_to_name = NULL;
        }
        return map;
}

/*
 * We will only accept alpha numerical labels; else
 * parses might choke on output when label named
 * "foo;<&bar" exists.  ASCII machines only.
 *
 * Avoids libc isalnum() etc. to avoid issues with locale
 * settings.
 */
static bool label_is_sane(const char *label)
{
        for (;*label; label++) {
                if (*label >= 'a' && *label <= 'z')
                        continue;
                if (*label >= 'A' && *label <= 'Z')
                        continue;
                if (*label >= '0' && *label <= '9')
                        continue;
                if (*label == ' ' || *label == '-')
                        continue;
                return false;
        }
        return true;
}

const char *__labels_get_path(void)
{
        return CONNLABEL_CFG;
}

struct nfct_labelmap *__labelmap_new(const char *name)
{
        struct nfct_labelmap *map;
        char label[1024];
        char *end;
        FILE *fp;
        int added = 0;
        unsigned int maxbit = 0;
        uint32_t bits_seen[MAX_BITS/32];

        fp = fopen(name ? name : CONNLABEL_CFG, "re");
        if (!fp)
                return NULL;

        memset(bits_seen, 0, sizeof(bits_seen));

        map = map_alloc();
        if (!map) {
                fclose(fp);
                return NULL;
        }

        while (fgets(label, sizeof(label), fp)) {
                int bit;

                if (label[0] == '#')
                        continue;

                bit = xtables_parse_connlabel_numerical(label, &end);
                if (bit < 0 || test_bit(bit, bits_seen))
                        continue;

                end = trim_label(end);
                if (!end)
                        continue;

                if (label_is_sane(end) && map_insert(map, end, bit) == 0) {
                        added++;
                        if (maxbit < bit)
                                maxbit = bit;
                        set_bit(bit, bits_seen);
                }
        }

        fclose(fp);

        if (added) {
                map->namecount = maxbit + 1;
                map->bit_to_name = calloc(sizeof(char *), map->namecount);
                if (!map->bit_to_name)
                        goto err;
                make_name_table(map);
                return map;
        } else {
                errno = 0;
        }
 err:
        __labelmap_destroy(map);
        return NULL;
}