107 lines
2.9 KiB
C
107 lines
2.9 KiB
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;
|
|
} |