CDN_DNS/trie/trie.c

#include "trie.h"

#define INPUT_FILE "../data/routing-data"
#define READ_MODE "r"
#define GET_BIT(key, bit) (( key[ bit / (sizeof(unsigned) * 8) ] & (1 << ((sizeof(unsigned) * 8 - 1) - (bit % (sizeof(unsigned) * 8)))) ) != 0 )


trie_node_t create_node() {
    trie_node_t ret = calloc(1, sizeof(struct trie_node)); /* sets null childs and invalid */
    return ret;
}

trie_holder_t create_holder() {
    trie_holder_t ret = malloc(sizeof(struct trie_holder));
    ret->_size = 0;
    ret->_root = create_node();
    return ret;
}

int trie_insert(trie_holder_t t, const unsigned key[4], int val, int mask) {
    trie_node_t iter = t->_root;
    trie_node_t* next = &t->_root;
    int i = 0;
    
    for (;i <= 128 - mask; ++i) {
        if (!*(next = GET_BIT(key, i) ? &iter->_l : &iter->_r))
            *next = create_node();
        
        iter = *next;
    }
    
    if (iter->_rule_valid == VALID_RULE) {
        printf("WARNING: conflicting rule %x:%x:%x:%x", key[0], key[1], key[2], key[3]);
        printf("/%d %d\n", mask, val);
        return 0;
    }

    iter->_rule_valid = VALID_RULE;
    iter->_rule = val;

    /* printf("inserted rule: %x:%x:%x:%x", key[0], key[1], key[2], key[3]); */
    /* printf("/%d %d\n", mask, val); */
    return 1;
}

int trie_search(trie_holder_t t, const unsigned key[4]) {
    return 0;
}


/*------------------------------------------------------------*/


int parse_line(unsigned key[4], int* val, int* mask, FILE* f) { /*! assumes only good input */
    
    unsigned short* tmp = (unsigned short*)key;
    memset(tmp, 0, sizeof(short[8]));

    fscanf(f, "%hx:%hx:%hx:%hx:%hx:%hx:%hx:%hx", &tmp[0], &tmp[1], &tmp[2], &tmp[3], &tmp[4], &tmp[5], &tmp[6], &tmp[7]);
    if (feof(f)) return 0; /* ends with newline */
    while (fgetc(f) != '/');
    
    fscanf(f, "%d %d", mask, val);

    /* printf("Loaded address: %x:%x:%x:%x", key[0], key[1], key[2], key[3]); */
    /* printf("/%d %d\n", *mask, *val); */

    return !feof(f);
}

int load_input(trie_holder_t t) {
    int val;
    int mask;
    unsigned key[4];

    FILE* f;
    int cnt = 0;
    
    if (!(f = fopen(INPUT_FILE, READ_MODE)))
        perror("cant open input file");
    
    while (parse_line(key, &val, &mask, f)) {
        trie_insert(t, key, val, mask);
        ++cnt;
    }
    return cnt;
}

int main() {
    trie_holder_t t = create_holder();

    /*
    unsigned key[4] = {8927349, 9872346, 898097878, 928398629};
    int i;
       00000000100010000011100001110101 00000000100101101010001111011010 00110101100001111110001011010110 00110111010101100011110100100101
       00000000100010000011100001110101 00000000100101101010001111011010 00110101100001111110001011010110 00110111010101100011110100100101
    
    for (i = 0; i < 128; ++i) {
        printf("%d", GET_BIT(key, i));
    }
    printf("\n");
    return 0;
    */

    printf("Loaded %d rules\n", load_input(t) );
    return 0;
}