From f6071ecf0cd3768eaed9a847f676433c120ea89e Mon Sep 17 00:00:00 2001 From: Sander Vrijders Date: Thu, 21 Sep 2017 14:26:51 +0200 Subject: ipcpd: normal: Add alternate hop PFF This adds a PFF that returns an alternate hop as next hop in case the hop that would have been returned is down. --- include/ouroboros/hashtable.h | 9 +- include/ouroboros/ipcp.h | 7 +- src/ipcpd/normal/CMakeLists.txt | 1 + src/ipcpd/normal/addr_auth.c | 2 +- src/ipcpd/normal/pff.c | 13 +- src/ipcpd/normal/pol/alternate_pff.c | 402 +++++++++++++++++++++++++++++++++++ src/ipcpd/normal/pol/alternate_pff.h | 61 ++++++ src/ipcpd/normal/pol/simple_pff.c | 14 +- src/ipcpd/normal/routing.c | 2 +- src/lib/hashtable.c | 46 ++-- src/lib/tests/hashtable_test.c | 23 +- src/tools/irm/irm_ipcp_bootstrap.c | 76 ++++--- 12 files changed, 579 insertions(+), 77 deletions(-) create mode 100644 src/ipcpd/normal/pol/alternate_pff.c create mode 100644 src/ipcpd/normal/pol/alternate_pff.h diff --git a/include/ouroboros/hashtable.h b/include/ouroboros/hashtable.h index 35fa202f..b5777e2f 100644 --- a/include/ouroboros/hashtable.h +++ b/include/ouroboros/hashtable.h @@ -40,11 +40,14 @@ void htable_flush(struct htable * table); /* Passes ownership of the block of memory */ int htable_insert(struct htable * table, uint64_t key, - void * val); + void * val, + size_t len); /* The block of memory returned is no copy */ -void * htable_lookup(struct htable * table, - uint64_t key); +int htable_lookup(struct htable * table, + uint64_t key, + void ** val, + size_t * len); int htable_delete(struct htable * table, uint64_t key); diff --git a/include/ouroboros/ipcp.h b/include/ouroboros/ipcp.h index de435e08..1b578fa2 100644 --- a/include/ouroboros/ipcp.h +++ b/include/ouroboros/ipcp.h @@ -42,15 +42,16 @@ enum ipcp_type { /* Normal IPCP policies */ enum pol_addr_auth { - FLAT_RANDOM = 0 + ADDR_AUTH_FLAT_RANDOM = 0 }; enum pol_routing { - LINK_STATE = 0 + ROUTING_LINK_STATE = 0 }; enum pol_pff { - SIMPLE_PFF = 0 + PFF_SIMPLE = 0, + PFF_ALTERNATE }; enum pol_dir_hash { diff --git a/src/ipcpd/normal/CMakeLists.txt b/src/ipcpd/normal/CMakeLists.txt index ebb413a8..8dbe4820 100644 --- a/src/ipcpd/normal/CMakeLists.txt +++ b/src/ipcpd/normal/CMakeLists.txt @@ -41,6 +41,7 @@ set(SOURCE_FILES routing.c sdu_sched.c # Add policies last + pol/alternate_pff.c pol/flat.c pol/link_state.c pol/graph.c diff --git a/src/ipcpd/normal/addr_auth.c b/src/ipcpd/normal/addr_auth.c index c7c744c7..d438f98f 100644 --- a/src/ipcpd/normal/addr_auth.c +++ b/src/ipcpd/normal/addr_auth.c @@ -36,7 +36,7 @@ int addr_auth_init(enum pol_addr_auth type, const void * info) { switch (type) { - case FLAT_RANDOM: + case ADDR_AUTH_FLAT_RANDOM: ops = &flat_ops; break; default: diff --git a/src/ipcpd/normal/pff.c b/src/ipcpd/normal/pff.c index 27ff17f7..3d114aa1 100644 --- a/src/ipcpd/normal/pff.c +++ b/src/ipcpd/normal/pff.c @@ -24,6 +24,7 @@ #include "pff.h" #include "pol-pff-ops.h" +#include "pol/alternate_pff.h" #include "pol/simple_pff.h" struct pff { @@ -40,16 +41,20 @@ struct pff * pff_create(enum pol_pff pol) return NULL; switch (pol) { - case SIMPLE_PFF: + case PFF_ALTERNATE: + pff->ops = &alternate_pff_ops; + break; + case PFF_SIMPLE: pff->ops = &simple_pff_ops; - pff->pff_i = pff->ops->create(); - if (pff->pff_i == NULL) - goto err; break; default: goto err; } + pff->pff_i = pff->ops->create(); + if (pff->pff_i == NULL) + goto err; + return pff; err: free(pff); diff --git a/src/ipcpd/normal/pol/alternate_pff.c b/src/ipcpd/normal/pol/alternate_pff.c new file mode 100644 index 00000000..3952bc82 --- /dev/null +++ b/src/ipcpd/normal/pol/alternate_pff.c @@ -0,0 +1,402 @@ +/* + * Ouroboros - Copyright (C) 2016 - 2017 + * + * Policy for PFF with alternate next hops + * + * Dimitri Staessens + * Sander Vrijders + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., http://www.fsf.org/about/contact/. + */ + +#define _POSIX_C_SOURCE 200112L + +#include "config.h" + +#include +#include +#include + +#include +#include +#include + +#include "alternate_pff.h" + +struct nhop { + struct list_head next; + int fd; +}; + +struct addr { + struct list_head next; + uint64_t addr; +}; + +struct pff_i { + struct htable * table; + + struct list_head addrs; + + struct list_head nhops_down; + + pthread_rwlock_t lock; +}; + +struct pol_pff_ops alternate_pff_ops = { + .create = alternate_pff_create, + .destroy = alternate_pff_destroy, + .lock = alternate_pff_lock, + .unlock = alternate_pff_unlock, + .add = alternate_pff_add, + .update = alternate_pff_update, + .del = alternate_pff_del, + .flush = alternate_pff_flush, + .nhop = alternate_pff_nhop, + .flow_state_change = alternate_flow_state_change +}; + +static int add_addr(struct pff_i * pff_i, + uint64_t addr) +{ + struct addr * a; + + a = malloc(sizeof(*a)); + if (a == NULL) + return -1; + + a->addr = addr; + + list_add(&a->next, &(pff_i->addrs)); + + return 0; +} + +static void del_addr(struct pff_i * pff_i, + uint64_t addr) +{ + struct list_head * pos = NULL; + struct list_head * n = NULL; + + list_for_each_safe(pos, n, &(pff_i->addrs)) { + struct addr * e = list_entry(pos, struct addr, next); + if (e->addr == addr) { + list_del(&e->next); + free(e); + return; + } + } +} + +static void del_addrs(struct pff_i * pff_i) +{ + struct list_head * pos = NULL; + struct list_head * n = NULL; + + list_for_each_safe(pos, n, &(pff_i->addrs)) { + struct addr * e = list_entry(pos, struct addr, next); + list_del(&e->next); + free(e); + } +} + +static void del_nhops_down(struct pff_i * pff_i) +{ + struct list_head * pos = NULL; + struct list_head * n = NULL; + + list_for_each_safe(pos, n, &(pff_i->nhops_down)) { + struct nhop * e = list_entry(pos, struct nhop, next); + list_del(&e->next); + free(e); + } +} + +static int del_nhop_down(struct pff_i * pff_i, + int fd) +{ + struct list_head * pos = NULL; + struct list_head * n = NULL; + + list_for_each_safe(pos, n, &(pff_i->nhops_down)) { + struct nhop * e = list_entry(pos, struct nhop, next); + if (e->fd == fd) { + list_del(&e->next); + free(e); + return 0; + } + } + + return -1; +} + +static int add_nhop_down(struct pff_i * pff_i, + int fd) +{ + struct nhop * nhop; + + nhop = malloc(sizeof(*nhop)); + if (nhop == NULL) + return -1; + + nhop->fd = fd; + + list_add(&nhop->next, &(pff_i->nhops_down)); + + return 0; +} + +static bool nhops_down_has(struct pff_i * pff_i, + int fd) +{ + struct list_head * pos = NULL; + + list_for_each(pos, &pff_i->nhops_down) { + struct nhop * e = list_entry(pos, struct nhop, next); + if (e->fd == fd) + return true; + } + + return false; +} + +static int add_to_htable(struct pff_i * pff_i, + uint64_t addr, + int * fd, + size_t len) +{ + int * val; + + assert(pff_i); + assert(len > 0); + + val = malloc(sizeof(*val) * (len + 1)); + if (val == NULL) + goto fail_malloc; + + memcpy(val, fd, len * sizeof(*val)); + /* Put primary hop again at the end */ + val[len] = val[0]; + + if (htable_insert(pff_i->table, addr, val, len)) + goto fail_insert; + + return 0; + + fail_insert: + free(val); + fail_malloc: + return -1; +} + +struct pff_i * alternate_pff_create(void) +{ + struct pff_i * tmp; + + tmp = malloc(sizeof(*tmp)); + if (tmp == NULL) + goto fail_malloc; + + if (pthread_rwlock_init(&tmp->lock, NULL)) + goto fail_lock; + + tmp->table = htable_create(PFT_SIZE, false); + if (tmp->table == NULL) + goto fail_table; + + list_head_init(&tmp->nhops_down); + list_head_init(&tmp->addrs); + + return tmp; + + fail_table: + pthread_rwlock_destroy(&tmp->lock); + fail_lock: + free(tmp); + fail_malloc: + return NULL; +} + +void alternate_pff_destroy(struct pff_i * pff_i) +{ + assert(pff_i); + + htable_destroy(pff_i->table); + del_nhops_down(pff_i); + pthread_rwlock_destroy(&pff_i->lock); + free(pff_i); +} + +void alternate_pff_lock(struct pff_i * pff_i) +{ + pthread_rwlock_wrlock(&pff_i->lock); +} + +void alternate_pff_unlock(struct pff_i * pff_i) +{ + pthread_rwlock_unlock(&pff_i->lock); +} + +int alternate_pff_add(struct pff_i * pff_i, + uint64_t addr, + int * fd, + size_t len) +{ + assert(pff_i); + assert(len > 0); + + if (add_to_htable(pff_i, addr, fd, len)) + return -1; + + if (add_addr(pff_i, addr)) { + htable_delete(pff_i->table, addr); + return -1; + } + + return 0; +} + +int alternate_pff_update(struct pff_i * pff_i, + uint64_t addr, + int * fd, + size_t len) +{ + assert(pff_i); + assert(len > 0); + + if (htable_delete(pff_i->table, addr)) + return -1; + + if (add_to_htable(pff_i, addr, fd, len)) + return -1; + + return 0; +} + +int alternate_pff_del(struct pff_i * pff_i, + uint64_t addr) +{ + assert(pff_i); + + del_addr(pff_i, addr); + + if (htable_delete(pff_i->table, addr)) + return -1; + + return 0; +} + +void alternate_pff_flush(struct pff_i * pff_i) +{ + assert(pff_i); + + htable_flush(pff_i->table); + + del_nhops_down(pff_i); + + del_addrs(pff_i); +} + +int alternate_pff_nhop(struct pff_i * pff_i, + uint64_t addr) +{ + int fd = -1; + size_t len; + void * el; + + assert(pff_i); + + pthread_rwlock_rdlock(&pff_i->lock); + + if (htable_lookup(pff_i->table, addr, &el, &len)) { + pthread_rwlock_unlock(&pff_i->lock); + return -1; + } + + fd = *((int *) el); + + pthread_rwlock_unlock(&pff_i->lock); + + return fd; +} + +int alternate_flow_state_change(struct pff_i * pff_i, + int fd, + bool up) +{ + struct list_head * pos = NULL; + size_t len; + void * el; + int * fds; + size_t i; + int tmp; + + assert(pff_i); + + pthread_rwlock_wrlock(&pff_i->lock); + + if (up) { + if (del_nhop_down(pff_i, fd)) { + pthread_rwlock_unlock(&pff_i->lock); + return -1; + } + } else { + if (add_nhop_down(pff_i, fd)) { + pthread_rwlock_unlock(&pff_i->lock); + return -1; + } + } + + list_for_each(pos, &pff_i->addrs) { + struct addr * e = list_entry(pos, struct addr, next); + if (htable_lookup(pff_i->table, e->addr, &el, &len)) { + pthread_rwlock_unlock(&pff_i->lock); + return -1; + } + + fds = (int *) el; + + if (up) { + /* It is using an alternate */ + if (fds[len] == fd && fds[0] != fd) { + for (i = 0 ; i < len; i++) { + /* Found the primary */ + if (fds[i] == fd) { + tmp = fds[0]; + fds[0] = fds[i]; + fds[i] = tmp; + break; + } + } + } + } else { + /* Need to switch to a (different) alternate */ + if (fds[0] == fd) { + for (i = 0 ; i < len; i++) { + /* Usable alternate */ + if (!nhops_down_has(pff_i, fds[i])) { + tmp = fds[0]; + fds[0] = fds[i]; + fds[i] = tmp; + break; + } + } + } + } + } + + pthread_rwlock_unlock(&pff_i->lock); + + return 0; +} diff --git a/src/ipcpd/normal/pol/alternate_pff.h b/src/ipcpd/normal/pol/alternate_pff.h new file mode 100644 index 00000000..8fa2d514 --- /dev/null +++ b/src/ipcpd/normal/pol/alternate_pff.h @@ -0,0 +1,61 @@ +/* + * Ouroboros - Copyright (C) 2016 - 2017 + * + * Policy for PFF with alternate next hops + * + * Dimitri Staessens + * Sander Vrijders + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., http://www.fsf.org/about/contact/. + */ + +#ifndef OUROBOROS_IPCPD_NORMAL_ALTERNATE_PFF_H +#define OUROBOROS_IPCPD_NORMAL_ALTERNATE_PFF_H + +#include "pol-pff-ops.h" + +struct pff_i * alternate_pff_create(void); + +void alternate_pff_destroy(struct pff_i * pff_i); + +void alternate_pff_lock(struct pff_i * pff_i); + +void alternate_pff_unlock(struct pff_i * pff_i); + +int alternate_pff_add(struct pff_i * pff_i, + uint64_t addr, + int * fd, + size_t len); + +int alternate_pff_update(struct pff_i * pff_i, + uint64_t addr, + int * fd, + size_t len); + +int alternate_pff_del(struct pff_i * pff_i, + uint64_t addr); + +void alternate_pff_flush(struct pff_i * pff_i); + +/* Returns fd towards next hop */ +int alternate_pff_nhop(struct pff_i * pff_i, + uint64_t addr); + +int alternate_flow_state_change(struct pff_i * pff_i, + int fd, + bool up); + +struct pol_pff_ops alternate_pff_ops; + +#endif /* OUROBOROS_IPCPD_NORMAL_ALTERNATE_PFF_H */ diff --git a/src/ipcpd/normal/pol/simple_pff.c b/src/ipcpd/normal/pol/simple_pff.c index 28f7aa2e..7af4663c 100644 --- a/src/ipcpd/normal/pol/simple_pff.c +++ b/src/ipcpd/normal/pol/simple_pff.c @@ -109,7 +109,7 @@ int simple_pff_add(struct pff_i * pff_i, *val = fd[0]; - if (htable_insert(pff_i->table, addr, val)) { + if (htable_insert(pff_i->table, addr, val, 1)) { free(val); return -1; } @@ -137,7 +137,7 @@ int simple_pff_update(struct pff_i * pff_i, return -1; } - if (htable_insert(pff_i->table, addr, val)) { + if (htable_insert(pff_i->table, addr, val, 1)) { free(val); return -1; } @@ -166,16 +166,16 @@ void simple_pff_flush(struct pff_i * pff_i) int simple_pff_nhop(struct pff_i * pff_i, uint64_t addr) { - int * j; - int fd = -1; + void * j; + size_t len; + int fd = -1; assert(pff_i); pthread_rwlock_rdlock(&pff_i->lock); - j = (int *) htable_lookup(pff_i->table, addr); - if (j != NULL) - fd = *j; + if (!htable_lookup(pff_i->table, addr, &j, &len)) + fd = *((int *) j); pthread_rwlock_unlock(&pff_i->lock); diff --git a/src/ipcpd/normal/routing.c b/src/ipcpd/normal/routing.c index 47ce3518..afef23a2 100644 --- a/src/ipcpd/normal/routing.c +++ b/src/ipcpd/normal/routing.c @@ -32,7 +32,7 @@ struct pol_routing_ops * r_ops; int routing_init(enum pol_routing pr) { switch (pr) { - case LINK_STATE: + case ROUTING_LINK_STATE: r_ops = &link_state_ops; break; default: diff --git a/src/lib/hashtable.c b/src/lib/hashtable.c index 2aa248ba..d0d46598 100644 --- a/src/lib/hashtable.c +++ b/src/lib/hashtable.c @@ -23,6 +23,7 @@ #include #include #include +#include #include @@ -30,6 +31,7 @@ struct htable_entry { struct list_head next; uint64_t key; void * val; + size_t len; }; struct htable { @@ -104,16 +106,25 @@ void htable_flush(struct htable * table) } } -static uint64_t hash(uint64_t x) +static uint64_t hash(uint64_t key) { - x = (x ^ (x >> 30)) * UINT64_C(0xbf58476d1ce4e5b9); - x = (x ^ (x >> 27)) * UINT64_C(0x94d049bb133111eb); - x = x ^ (x >> 31); + void * res; + uint64_t ret; + uint8_t keys[4]; - return x; + memcpy(keys, &key, 4); + + mem_hash(HASH_MD5, &res, keys, 4); + + ret = (* (uint64_t *) res); + + free(res); + + return ret; } -static uint64_t calc_key(struct htable * table, uint64_t key) +static uint64_t calc_key(struct htable * table, + uint64_t key) { if (table->hash_key == true) key = hash(key); @@ -121,7 +132,10 @@ static uint64_t calc_key(struct htable * table, uint64_t key) return (key & (table->buckets_size - 1)); } -int htable_insert(struct htable * table, uint64_t key, void * val) +int htable_insert(struct htable * table, + uint64_t key, + void * val, + size_t len) { struct htable_entry * entry; uint64_t lookup_key; @@ -143,6 +157,7 @@ int htable_insert(struct htable * table, uint64_t key, void * val) entry->key = key; entry->val = val; + entry->len = len; list_head_init(&entry->next); list_add(&entry->next, &(table->buckets[lookup_key])); @@ -150,7 +165,10 @@ int htable_insert(struct htable * table, uint64_t key, void * val) return 0; } -void * htable_lookup(struct htable * table, uint64_t key) +int htable_lookup(struct htable * table, + uint64_t key, + void ** val, + size_t * len) { struct htable_entry * entry; struct list_head * pos = NULL; @@ -162,14 +180,18 @@ void * htable_lookup(struct htable * table, uint64_t key) list_for_each(pos, &(table->buckets[lookup_key])) { entry = list_entry(pos, struct htable_entry, next); - if (entry->key == key) - return entry->val; + if (entry->key == key) { + *val = entry->val; + *len = entry->len; + return 0; + } } - return NULL; + return -1; } -int htable_delete(struct htable * table, uint64_t key) +int htable_delete(struct htable * table, + uint64_t key) { struct htable_entry * entry; uint64_t lookup_key; diff --git a/src/lib/tests/hashtable_test.c b/src/lib/tests/hashtable_test.c index 9d5917f4..36f68ebf 100644 --- a/src/lib/tests/hashtable_test.c +++ b/src/lib/tests/hashtable_test.c @@ -30,8 +30,10 @@ int hashtable_test(int argc, char ** argv) { struct htable * table; - int i; - int * j; + int i; + int * j; + void * el; + size_t len; (void) argc; (void) argv; @@ -59,20 +61,20 @@ int hashtable_test(int argc, char ** argv) } *j = i; - if (htable_insert(table, i, (void *) j)) { + if (htable_insert(table, i, (void *) j, 1)) { printf("Failed to insert.\n"); htable_destroy(table); return -1; } } - j = (int *) htable_lookup(table, INT_TEST); - if (j == NULL) { + if (htable_lookup(table, INT_TEST, &el, &len)) { printf("Failed to lookup.\n"); htable_destroy(table); return -1; } + j = (int *) el; if (*j != INT_TEST) { printf("Lookup returned wrong value (%d != %d).\n", INT_TEST, *j); @@ -80,13 +82,13 @@ int hashtable_test(int argc, char ** argv) return -1; } - j = (int *) htable_lookup(table, HASHTABLE_SIZE + INT_TEST); - if (j == NULL) { + if (htable_lookup(table, HASHTABLE_SIZE + INT_TEST, &el, &len)) { printf("Failed to lookup.\n"); htable_destroy(table); return -1; } + j = (int *) el; if (*j != HASHTABLE_SIZE + INT_TEST) { printf("Lookup returned wrong value (%d != %d).\n", INT_TEST, *j); @@ -100,20 +102,19 @@ int hashtable_test(int argc, char ** argv) return -1; } - j = (int *) htable_lookup(table, INT_TEST); - if (j != NULL) { + if (htable_lookup(table, INT_TEST, &el, &len) == 0) { printf("Failed to delete properly.\n"); htable_destroy(table); return -1; } - j = (int *) htable_lookup(table, HASHTABLE_SIZE + INT_TEST); - if (j == NULL) { + if (htable_lookup(table, HASHTABLE_SIZE + INT_TEST, &el, &len)) { printf("Failed to lookup after deletion.\n"); htable_destroy(table); return -1; } + j = (int *) el; if (*j != HASHTABLE_SIZE + INT_TEST) { printf("Lookup returned wrong value (%d != %d).\n", INT_TEST, *j); diff --git a/src/tools/irm/irm_ipcp_bootstrap.c b/src/tools/irm/irm_ipcp_bootstrap.c index 07a0fabb..9812f860 100644 --- a/src/tools/irm/irm_ipcp_bootstrap.c +++ b/src/tools/irm/irm_ipcp_bootstrap.c @@ -33,27 +33,28 @@ #include "irm_ops.h" #include "irm_utils.h" -#define NORMAL "normal" -#define SHIM_UDP "shim-udp" -#define SHIM_ETH_LLC "shim-eth-llc" -#define LOCAL "local" - -#define MD5 "MD5" -#define SHA3_224 "SHA3_224" -#define SHA3_256 "SHA3_256" -#define SHA3_384 "SHA3_384" -#define SHA3_512 "SHA3_512" - -#define DEFAULT_ADDR_SIZE 4 -#define DEFAULT_FD_SIZE 2 -#define DEFAULT_DDNS 0 -#define DEFAULT_ADDR_AUTH FLAT_RANDOM -#define DEFAULT_ROUTING LINK_STATE -#define DEFAULT_PFF SIMPLE_PFF -#define DEFAULT_HASH_ALGO DIR_HASH_SHA3_256 -#define ADDR_AUTH_FLAT "flat" -#define ROUTING_LINK_STATE "link_state" -#define PFF_SIMPLE_PFF "simple_pff" +#define NORMAL "normal" +#define SHIM_UDP "shim-udp" +#define SHIM_ETH_LLC "shim-eth-llc" +#define LOCAL "local" + +#define MD5 "MD5" +#define SHA3_224 "SHA3_224" +#define SHA3_256 "SHA3_256" +#define SHA3_384 "SHA3_384" +#define SHA3_512 "SHA3_512" + +#define DEFAULT_ADDR_SIZE 4 +#define DEFAULT_FD_SIZE 2 +#define DEFAULT_DDNS 0 +#define DEFAULT_ADDR_AUTH ADDR_AUTH_FLAT_RANDOM +#define DEFAULT_ROUTING ROUTING_LINK_STATE +#define DEFAULT_PFF PFF_SIMPLE +#define DEFAULT_HASH_ALGO DIR_HASH_SHA3_256 +#define FLAT_RANDOM_ADDR_AUTH "flat" +#define LINK_STATE_ROUTING "link_state" +#define SIMPLE_PFF "simple" +#define ALTERNATE_PFF "alternate" static void usage(void) { @@ -68,20 +69,23 @@ static void usage(void) " [addr
(default: %d)]\n" " [fd (default: %d)]\n" " [ttl (add time to live value in the PCI)]\n" - " [addr_auth
(default: %s)]\n" - " [routing (default: %s)]\n" - " [pff (default: %s)]\n" + " [addr_auth (default: %s)]\n" + " [routing (default: %s)]\n" + " [pff [PFF_POLICY] (default: %s)]\n" " [hash [ALGORITHM] (default: %s)]\n" - "where ALGORITHM = {" SHA3_224 " " SHA3_256 " " - SHA3_384 " " SHA3_512 "}\n" + "where ADDRESS_POLICY = {"FLAT_RANDOM_ADDR_AUTH"}\n" + " ROUTING_POLICY = {"LINK_STATE_ROUTING"}\n" + " PFF_POLICY = {" SIMPLE_PFF " " ALTERNATE_PFF "}\n" + " ALGORITHM = {" SHA3_224 " " SHA3_256 " " + SHA3_384 " " SHA3_512 "}\n\n" "if TYPE == " SHIM_UDP "\n" " ip \n" " [dns " - " (default: none)]\n" + " (default: none)]\n\n" "if TYPE == " SHIM_ETH_LLC "\n" " if_name \n", - DEFAULT_ADDR_SIZE, DEFAULT_FD_SIZE, ADDR_AUTH_FLAT, - ROUTING_LINK_STATE, PFF_SIMPLE_PFF, SHA3_256); + DEFAULT_ADDR_SIZE, DEFAULT_FD_SIZE, FLAT_RANDOM_ADDR_AUTH, + LINK_STATE_ROUTING, SIMPLE_PFF, SHA3_256); } int do_bootstrap_ipcp(int argc, char ** argv) @@ -140,18 +144,20 @@ int do_bootstrap_ipcp(int argc, char ** argv) argc++; argv--; } else if (matches(*argv, "addr_auth") == 0) { - if (strcmp(ADDR_AUTH_FLAT, *(argv + 1)) == 0) - addr_auth_type = FLAT_RANDOM; + if (strcmp(FLAT_RANDOM_ADDR_AUTH, *(argv + 1)) == 0) + addr_auth_type = ADDR_AUTH_FLAT_RANDOM; else goto unknown_param; } else if (matches(*argv, "routing") == 0) { - if (strcmp(ROUTING_LINK_STATE, *(argv + 1)) == 0) - routing_type = LINK_STATE; + if (strcmp(LINK_STATE_ROUTING, *(argv + 1)) == 0) + routing_type = ROUTING_LINK_STATE; else goto unknown_param; } else if (matches(*argv, "pff") == 0) { - if (strcmp(PFF_SIMPLE_PFF, *(argv + 1)) == 0) - pff_type = SIMPLE_PFF; + if (strcmp(SIMPLE_PFF, *(argv + 1)) == 0) + pff_type = PFF_SIMPLE; + else if (strcmp(ALTERNATE_PFF, *(argv + 1)) == 0) + pff_type = PFF_ALTERNATE; else goto unknown_param; } else { -- cgit v1.2.3