diff options
Diffstat (limited to 'src')
46 files changed, 934 insertions, 1145 deletions
diff --git a/src/ipcpd/ipcp.c b/src/ipcpd/ipcp.c index 587d70c5..795ce42c 100644 --- a/src/ipcpd/ipcp.c +++ b/src/ipcpd/ipcp.c @@ -38,6 +38,54 @@ #include <sys/socket.h> #include <stdlib.h> +void ipcp_sig_handler(int sig, + siginfo_t * info, + void * c) +{ + (void) c; + + switch(sig) { + case SIGINT: + case SIGTERM: + case SIGHUP: + case SIGQUIT: + if (info->si_pid == ipcpi.irmd_api) { + if (ipcp_get_state() == IPCP_INIT) + ipcp_set_state(IPCP_NULL); + + if (ipcp_get_state() == IPCP_OPERATIONAL) + ipcp_set_state(IPCP_SHUTDOWN); + } + default: + return; + } +} + +uint8_t * ipcp_hash_dup(const uint8_t * hash) +{ + uint8_t * dup = malloc(ipcpi.dir_hash_len); + if (dup == NULL) + return NULL; + + memcpy(dup, hash, ipcpi.dir_hash_len); + + return dup; +} + +void ipcp_hash_str(char buf[DIR_HASH_STRLEN + 1], + const uint8_t * hash) +{ + size_t i; + + char * HEX = "0123456789abcdef"; + + for (i = 0; i < ipcpi.dir_hash_len; ++i) { + buf[i * 2] = HEX[(hash[i] & 0xF0) >> 4]; + buf[i * 2 + 1] = HEX[hash[i] & 0x0F]; + } + + buf[2 * i] = '\0'; +} static void thread_inc(void) { @@ -93,8 +141,8 @@ static void * ipcp_main_loop(void * o) buffer_t buffer; ipcp_msg_t ret_msg = IPCP_MSG__INIT; - dif_config_msg_t * conf_msg; - struct dif_config conf; + ipcp_config_msg_t * conf_msg; + struct ipcp_config conf; struct timeval ltv = {(SOCKET_TIMEOUT / 1000), (SOCKET_TIMEOUT % 1000) * 1000}; @@ -109,18 +157,13 @@ static void * ipcp_main_loop(void * o) #endif int fd = -1; - pthread_rwlock_rdlock(&ipcpi.state_lock); - if (ipcp_get_state() == IPCP_SHUTDOWN || ipcp_get_state() == IPCP_NULL || thread_check()) { thread_exit(id); - pthread_rwlock_unlock(&ipcpi.state_lock); break; } - pthread_rwlock_unlock(&ipcpi.state_lock); - ret_msg.code = IPCP_MSG_CODE__IPCP_REPLY; #ifdef __FreeBSD__ FD_ZERO(&fds); @@ -153,12 +196,23 @@ static void * ipcp_main_loop(void * o) switch (msg->code) { case IPCP_MSG_CODE__IPCP_BOOTSTRAP: + ret_msg.has_result = true; + if (ipcpi.ops->ipcp_bootstrap == NULL) { log_err("Bootstrap unsupported."); + ret_msg.result = -ENOTSUP; break; } + + if (ipcp_get_state() != IPCP_INIT) { + log_err("IPCP in wrong state."); + ret_msg.result = -EIPCPSTATE; + break; + } + conf_msg = msg->conf; conf.type = conf_msg->ipcp_type; + conf.dir_hash_len = conf_msg->dir_hash_len; conf.dif_name = conf_msg->dif_name; if (conf.dif_name == NULL) { ret_msg.has_result = true; @@ -179,74 +233,123 @@ static void * ipcp_main_loop(void * o) conf.dt_gam_type = conf_msg->dt_gam_type; conf.rm_gam_type = conf_msg->rm_gam_type; } + if (conf_msg->ipcp_type == IPCP_SHIM_UDP) { conf.ip_addr = conf_msg->ip_addr; conf.dns_addr = conf_msg->dns_addr; } + if (conf_msg->ipcp_type == IPCP_SHIM_ETH_LLC) conf.if_name = conf_msg->if_name; - ret_msg.has_result = true; ret_msg.result = ipcpi.ops->ipcp_bootstrap(&conf); break; case IPCP_MSG_CODE__IPCP_ENROLL: + ret_msg.has_result = true; + if (ipcpi.ops->ipcp_enroll == NULL) { log_err("Enroll unsupported."); + ret_msg.result = -ENOTSUP; break; } - ret_msg.has_result = true; - ret_msg.result = ipcpi.ops->ipcp_enroll(msg->dif_name); - break; - case IPCP_MSG_CODE__IPCP_NAME_REG: - if (ipcpi.ops->ipcp_name_reg == NULL) { - log_err("Ap_reg unsupported."); + + if (ipcp_get_state() != IPCP_INIT) { + log_err("IPCP in wrong state."); + ret_msg.result = -EIPCPSTATE; break; } + + ret_msg.result = ipcpi.ops->ipcp_enroll(msg->dst_name); + break; + case IPCP_MSG_CODE__IPCP_REG: ret_msg.has_result = true; + + if (ipcpi.ops->ipcp_reg == NULL) { + log_err("Registration unsupported."); + ret_msg.result = -ENOTSUP; + break; + } + + assert(msg->hash.len == ipcpi.dir_hash_len); + ret_msg.result = - ipcpi.ops->ipcp_name_reg(msg->name); + ipcpi.ops->ipcp_reg(msg->hash.data); break; - case IPCP_MSG_CODE__IPCP_NAME_UNREG: - if (ipcpi.ops->ipcp_name_unreg == NULL) { - log_err("Ap_unreg unsupported."); + case IPCP_MSG_CODE__IPCP_UNREG: + ret_msg.has_result = true; + + if (ipcpi.ops->ipcp_unreg == NULL) { + log_err("Unregistration unsupported."); + ret_msg.result = -ENOTSUP; break; } - ret_msg.has_result = true; + + assert(msg->hash.len == ipcpi.dir_hash_len); + ret_msg.result = - ipcpi.ops->ipcp_name_unreg(msg->name); + ipcpi.ops->ipcp_unreg(msg->hash.data); break; - case IPCP_MSG_CODE__IPCP_NAME_QUERY: - if (ipcpi.ops->ipcp_name_query == NULL) { - log_err("Ap_query unsupported."); + case IPCP_MSG_CODE__IPCP_QUERY: + ret_msg.has_result = true; + + if (ipcpi.ops->ipcp_query == NULL) { + log_err("Directory query unsupported."); + ret_msg.result = -ENOTSUP; break; } - ret_msg.has_result = true; + + assert(msg->hash.len == ipcpi.dir_hash_len); + + if (ipcp_get_state() != IPCP_OPERATIONAL) { + log_err("IPCP in wrong state."); + ret_msg.result = -EIPCPSTATE; + break; + } + ret_msg.result = - ipcpi.ops->ipcp_name_query(msg->name); + ipcpi.ops->ipcp_query(msg->hash.data); break; case IPCP_MSG_CODE__IPCP_FLOW_ALLOC: + ret_msg.has_result = true; + if (ipcpi.ops->ipcp_flow_alloc == NULL) { - log_err("Flow_alloc unsupported."); + log_err("Flow allocation unsupported."); + ret_msg.result = -ENOTSUP; + break; + } + + assert(msg->hash.len == ipcpi.dir_hash_len); + + if (ipcp_get_state() != IPCP_OPERATIONAL) { + log_err("IPCP in wrong state."); + ret_msg.result = -EIPCPSTATE; break; } + fd = np1_flow_alloc(msg->api, msg->port_id); if (fd < 0) { log_err("Failed allocating fd on port_id %d.", msg->port_id); - ret_msg.has_result = true; ret_msg.result = -1; break; } - ret_msg.has_result = true; ret_msg.result = ipcpi.ops->ipcp_flow_alloc(fd, - msg->dst_name, + msg->hash.data, msg->qoscube); break; case IPCP_MSG_CODE__IPCP_FLOW_ALLOC_RESP: + ret_msg.has_result = true; if (ipcpi.ops->ipcp_flow_alloc_resp == NULL) { log_err("Flow_alloc_resp unsupported."); + ret_msg.result = -ENOTSUP; + break; + } + + if (ipcp_get_state() != IPCP_OPERATIONAL) { + log_err("IPCP in wrong state."); + ret_msg.result = -EIPCPSTATE; break; } @@ -255,20 +358,26 @@ static void * ipcp_main_loop(void * o) if (fd < 0) { log_warn("Port_id %d is not known.", msg->port_id); - ret_msg.has_result = true; ret_msg.result = -1; break; } } - ret_msg.has_result = true; ret_msg.result = ipcpi.ops->ipcp_flow_alloc_resp(fd, msg->response); break; case IPCP_MSG_CODE__IPCP_FLOW_DEALLOC: + ret_msg.has_result = true; if (ipcpi.ops->ipcp_flow_dealloc == NULL) { - log_err("Flow_dealloc unsupported."); + log_err("Flow deallocation unsupported."); + ret_msg.result = -ENOTSUP; + break; + } + + if (ipcp_get_state() != IPCP_OPERATIONAL) { + log_err("IPCP in wrong state."); + ret_msg.result = -EIPCPSTATE; break; } @@ -276,12 +385,10 @@ static void * ipcp_main_loop(void * o) if (fd < 0) { log_warn("Could not deallocate port_id %d.", msg->port_id); - ret_msg.has_result = true; ret_msg.result = -1; break; } - ret_msg.has_result = true; ret_msg.result = ipcpi.ops->ipcp_flow_dealloc(fd); break; @@ -409,11 +516,6 @@ int ipcp_init(int argc, ipcpi.ops = ops; - if (pthread_rwlock_init(&ipcpi.state_lock, NULL)) { - log_err("Could not create rwlock."); - goto fail_state_rwlock; - } - if (pthread_mutex_init(&ipcpi.state_mtx, NULL)) { log_err("Could not create mutex."); goto fail_state_mtx; @@ -492,8 +594,6 @@ int ipcp_init(int argc, fail_thread_lock: pthread_mutex_destroy(&ipcpi.state_mtx); fail_state_mtx: - pthread_rwlock_destroy(&ipcpi.state_lock); - fail_state_rwlock: close(ipcpi.sockfd); fail_serv_sock: free(ipcpi.sock_path); @@ -522,10 +622,8 @@ void * threadpoolmgr(void * o) clock_gettime(PTHREAD_COND_CLOCK, &dl); ts_add(&dl, &to, &dl); - pthread_rwlock_rdlock(&ipcpi.state_lock); if (ipcp_get_state() == IPCP_SHUTDOWN || ipcp_get_state() == IPCP_NULL) { - pthread_rwlock_unlock(&ipcpi.state_lock); pthread_attr_destroy(&pattr); log_dbg("Waiting for threads to exit."); pthread_mutex_lock(&ipcpi.threads_lock); @@ -538,8 +636,6 @@ void * threadpoolmgr(void * o) break; } - pthread_rwlock_unlock(&ipcpi.state_lock); - pthread_mutex_lock(&ipcpi.threads_lock); if (ipcpi.threads < IPCP_MIN_AV_THREADS) { @@ -576,10 +672,34 @@ void * threadpoolmgr(void * o) int ipcp_boot() { + struct sigaction sig_act; + sigset_t sigset; + sigemptyset(&sigset); + sigaddset(&sigset, SIGINT); + sigaddset(&sigset, SIGQUIT); + sigaddset(&sigset, SIGHUP); + sigaddset(&sigset, SIGPIPE); + + /* init sig_act */ + memset(&sig_act, 0, sizeof(sig_act)); + + /* install signal traps */ + sig_act.sa_sigaction = &ipcp_sig_handler; + sig_act.sa_flags = SA_SIGINFO; + + sigaction(SIGINT, &sig_act, NULL); + sigaction(SIGTERM, &sig_act, NULL); + sigaction(SIGHUP, &sig_act, NULL); + sigaction(SIGPIPE, &sig_act, NULL); + + pthread_sigmask(SIG_BLOCK, &sigset, NULL); + ipcp_set_state(IPCP_INIT); pthread_create(&ipcpi.tpm, NULL, threadpoolmgr, NULL); + pthread_sigmask(SIG_UNBLOCK, &sigset, NULL); + return 0; } @@ -607,7 +727,6 @@ void ipcp_fini() pthread_cond_destroy(&ipcpi.threads_cond); pthread_mutex_destroy(&ipcpi.threads_lock); pthread_mutex_destroy(&ipcpi.state_mtx); - pthread_rwlock_destroy(&ipcpi.state_lock); pthread_cond_destroy(&ipcpi.alloc_cond); pthread_mutex_destroy(&ipcpi.alloc_lock); diff --git a/src/ipcpd/ipcp.h b/src/ipcpd/ipcp.h index e5c4b9af..d6e2aa7c 100644 --- a/src/ipcpd/ipcp.h +++ b/src/ipcpd/ipcp.h @@ -24,12 +24,13 @@ #define IPCPD_IPCP_H #include <ouroboros/config.h> -#include <ouroboros/irm_config.h> +#include <ouroboros/ipcp.h> #include "shim-data.h" #include <pthread.h> #include <time.h> +#include <signal.h> enum ipcp_state { IPCP_NULL = 0, @@ -39,19 +40,19 @@ enum ipcp_state { }; struct ipcp_ops { - int (* ipcp_bootstrap)(struct dif_config * conf); + int (* ipcp_bootstrap)(const struct ipcp_config * conf); - int (* ipcp_enroll)(char * dif_name); + int (* ipcp_enroll)(const char * dst); - int (* ipcp_name_reg)(char * name); + int (* ipcp_reg)(const uint8_t * hash); - int (* ipcp_name_unreg)(char * name); + int (* ipcp_unreg)(const uint8_t * hash); - int (* ipcp_name_query)(char * name); + int (* ipcp_query)(const uint8_t * hash); - int (* ipcp_flow_alloc)(int fd, - char * dst_ap_name, - qoscube_t qos); + int (* ipcp_flow_alloc)(int fd, + const uint8_t * dst, + qoscube_t qos); int (* ipcp_flow_alloc_resp)(int fd, int response); @@ -59,6 +60,8 @@ struct ipcp_ops { int (* ipcp_flow_dealloc)(int fd); }; +#define DIR_HASH_STRLEN (ipcpi.dir_hash_len * 2) + struct ipcp { int irmd_api; char * name; @@ -67,6 +70,7 @@ struct ipcp { char * dif_name; uint64_t dt_addr; + uint16_t dir_hash_len; struct ipcp_ops * ops; int irmd_fd; @@ -117,4 +121,15 @@ int ipcp_wait_state(enum ipcp_state state, int ipcp_parse_arg(int argc, char * argv[]); +/* Handle shutdown of IPCP */ +void ipcp_sig_handler(int sig, + siginfo_t * info, + void * c); + +/* Helper functions for directory entries, could be moved */ +uint8_t * ipcp_hash_dup(const uint8_t * hash); + +void ipcp_hash_str(char buf[], + const uint8_t * hash); + #endif diff --git a/src/ipcpd/local/main.c b/src/ipcpd/local/main.c index 897ec3a0..21ca7400 100644 --- a/src/ipcpd/local/main.c +++ b/src/ipcpd/local/main.c @@ -27,13 +27,14 @@ #include <ouroboros/errno.h> #include <ouroboros/dev.h> #include <ouroboros/fqueue.h> +#include <ouroboros/ipcp.h> #include <ouroboros/ipcp-dev.h> #include <ouroboros/local-dev.h> +#include <ouroboros/hash.h> #include "ipcp.h" #include <string.h> -#include <signal.h> #include <stdlib.h> #include <pthread.h> #include <sys/wait.h> @@ -113,110 +114,74 @@ static void * ipcp_local_sdu_loop(void * o) return (void *) 0; } -void ipcp_sig_handler(int sig, - siginfo_t * info, - void * c) +static int ipcp_local_bootstrap(const struct ipcp_config * conf) { - (void) c; - - switch(sig) { - case SIGINT: - case SIGTERM: - case SIGHUP: - case SIGQUIT: - if (info->si_pid == ipcpi.irmd_api) { - if (ipcp_get_state() == IPCP_INIT) - ipcp_set_state(IPCP_NULL); - - if (ipcp_get_state() == IPCP_OPERATIONAL) - ipcp_set_state(IPCP_SHUTDOWN); - } - default: - return; - } -} - -static int ipcp_local_bootstrap(struct dif_config * conf) -{ - (void) conf; - assert(conf); assert(conf->type == THIS_TYPE); - if (ipcp_get_state() != IPCP_INIT) { - log_err("IPCP in wrong state."); - return -1; - } + ipcpi.dir_hash_len = conf->dir_hash_len; ipcp_set_state(IPCP_OPERATIONAL); - pthread_create(&local_data.sduloop, NULL, ipcp_local_sdu_loop, NULL); + if (pthread_create(&local_data.sduloop, NULL, + ipcp_local_sdu_loop, NULL)) { + ipcp_set_state(IPCP_INIT); + return -1; + } log_info("Bootstrapped local IPCP with api %d.", getpid()); return 0; } -static int ipcp_local_name_reg(char * name) +static int ipcp_local_reg(const uint8_t * hash) { - char * name_dup = strdup(name); - if (name_dup == NULL) { - log_err("Failed to duplicate name."); + uint8_t * hash_dup = ipcp_hash_dup(hash); + if (hash_dup == NULL) { + log_err("Failed to duplicate hash."); return -ENOMEM; } - pthread_rwlock_rdlock(&ipcpi.state_lock); - - if (shim_data_reg_add_entry(ipcpi.shim_data, name_dup)) { - pthread_rwlock_unlock(&ipcpi.state_lock); - log_dbg("Failed to add %s to local registry.", name); - free(name_dup); + if (shim_data_reg_add_entry(ipcpi.shim_data, hash_dup)) { + log_dbg("Failed to add " HASH_FMT " to local registry.", + HASH_VAL(hash)); + free(hash_dup); return -1; } - pthread_rwlock_unlock(&ipcpi.state_lock); - - log_info("Registered %s.", name); + log_info("Registered " HASH_FMT ".", HASH_VAL(hash)); return 0; } -static int ipcp_local_name_unreg(char * name) +static int ipcp_local_unreg(const uint8_t * hash) { - pthread_rwlock_rdlock(&ipcpi.state_lock); - - shim_data_reg_del_entry(ipcpi.shim_data, name); + shim_data_reg_del_entry(ipcpi.shim_data, hash); - pthread_rwlock_unlock(&ipcpi.state_lock); - - log_info("Unregistered %s.", name); + log_info("Unregistered " HASH_FMT ".", HASH_VAL(hash)); return 0; } -static int ipcp_local_name_query(char * name) +static int ipcp_local_query(const uint8_t * hash) { int ret; - pthread_rwlock_rdlock(&ipcpi.state_lock); - - ret = (shim_data_reg_has(ipcpi.shim_data, name) ? 0 : -1); - - pthread_rwlock_unlock(&ipcpi.state_lock); + ret = (shim_data_reg_has(ipcpi.shim_data, hash) ? 0 : -1); return ret; } -static int ipcp_local_flow_alloc(int fd, - char * dst_name, - qoscube_t cube) +static int ipcp_local_flow_alloc(int fd, + const uint8_t * dst, + qoscube_t cube) { struct timespec ts = {0, EVENT_WAIT_TIMEOUT * 1000}; int out_fd = -1; - log_dbg("Allocating flow to %s on fd %d.", dst_name, fd); + log_dbg("Allocating flow to " HASH_FMT " on fd %d.", HASH_VAL(dst), fd); - assert(dst_name); + assert(dst); pthread_mutex_lock(&ipcpi.alloc_lock); @@ -233,7 +198,7 @@ static int ipcp_local_flow_alloc(int fd, assert(ipcpi.alloc_id == -1); - out_fd = ipcp_flow_req_arr(getpid(), dst_name, cube); + out_fd = ipcp_flow_req_arr(getpid(), dst, ipcpi.dir_hash_len, cube); if (out_fd < 0) { pthread_mutex_unlock(&ipcpi.alloc_lock); log_dbg("Flow allocation failed: %d", out_fd); @@ -335,9 +300,9 @@ static int ipcp_local_flow_dealloc(int fd) static struct ipcp_ops local_ops = { .ipcp_bootstrap = ipcp_local_bootstrap, .ipcp_enroll = NULL, /* shim */ - .ipcp_name_reg = ipcp_local_name_reg, - .ipcp_name_unreg = ipcp_local_name_unreg, - .ipcp_name_query = ipcp_local_name_query, + .ipcp_reg = ipcp_local_reg, + .ipcp_unreg = ipcp_local_unreg, + .ipcp_query = ipcp_local_query, .ipcp_flow_alloc = ipcp_local_flow_alloc, .ipcp_flow_alloc_resp = ipcp_local_flow_alloc_resp, .ipcp_flow_dealloc = ipcp_local_flow_dealloc @@ -346,26 +311,6 @@ static struct ipcp_ops local_ops = { int main(int argc, char * argv[]) { - struct sigaction sig_act; - sigset_t sigset; - sigemptyset(&sigset); - sigaddset(&sigset, SIGINT); - sigaddset(&sigset, SIGQUIT); - sigaddset(&sigset, SIGHUP); - sigaddset(&sigset, SIGPIPE); - - /* init sig_act */ - memset(&sig_act, 0, sizeof(sig_act)); - - /* install signal traps */ - sig_act.sa_sigaction = &ipcp_sig_handler; - sig_act.sa_flags = SA_SIGINFO; - - sigaction(SIGINT, &sig_act, NULL); - sigaction(SIGTERM, &sig_act, NULL); - sigaction(SIGHUP, &sig_act, NULL); - sigaction(SIGPIPE, &sig_act, NULL); - if (ipcp_init(argc, argv, THIS_TYPE, &local_ops) < 0) { ipcp_create_r(getpid(), -1); exit(EXIT_FAILURE); @@ -378,8 +323,6 @@ int main(int argc, exit(EXIT_FAILURE); } - pthread_sigmask(SIG_BLOCK, &sigset, NULL); - if (ipcp_boot() < 0) { log_err("Failed to boot IPCP."); ipcp_create_r(getpid(), -1); @@ -388,8 +331,6 @@ int main(int argc, exit(EXIT_FAILURE); } - pthread_sigmask(SIG_UNBLOCK, &sigset, NULL); - if (ipcp_create_r(getpid(), 0)) { log_err("Failed to notify IRMd we are initialized."); ipcp_set_state(IPCP_NULL); diff --git a/src/ipcpd/normal/addr_auth.h b/src/ipcpd/normal/addr_auth.h index fbe7d790..6883b4b3 100644 --- a/src/ipcpd/normal/addr_auth.h +++ b/src/ipcpd/normal/addr_auth.h @@ -23,7 +23,7 @@ #ifndef OUROBOROS_IPCPD_NORMAL_ADDR_AUTH_H #define OUROBOROS_IPCPD_NORMAL_ADDR_AUTH_H -#include <ouroboros/irm_config.h> +#include <ouroboros/ipcp.h> #include <stdint.h> diff --git a/src/ipcpd/normal/connmgr.c b/src/ipcpd/normal/connmgr.c index 8068d173..421bc5b0 100644 --- a/src/ipcpd/normal/connmgr.c +++ b/src/ipcpd/normal/connmgr.c @@ -116,16 +116,11 @@ static void * flow_acceptor(void * o) memset(&fail_info, 0, sizeof(fail_info)); while (true) { - pthread_rwlock_rdlock(&ipcpi.state_lock); - if (ipcp_get_state() != IPCP_OPERATIONAL) { - pthread_rwlock_unlock(&ipcpi.state_lock); log_info("Shutting down flow acceptor."); return 0; } - pthread_rwlock_unlock(&ipcpi.state_lock); - fd = flow_accept(&qs, NULL); if (fd < 0) { if (fd != -EIRMD) @@ -271,7 +266,7 @@ void connmgr_ae_destroy(struct ae * ae) } int connmgr_alloc(struct ae * ae, - char * dst_name, + const char * dst_name, qosspec_t * qs, struct conn * conn) { diff --git a/src/ipcpd/normal/connmgr.h b/src/ipcpd/normal/connmgr.h index c0356f6d..12992ef6 100644 --- a/src/ipcpd/normal/connmgr.h +++ b/src/ipcpd/normal/connmgr.h @@ -47,7 +47,7 @@ struct ae * connmgr_ae_create(struct conn_info info); void connmgr_ae_destroy(struct ae * ae); int connmgr_alloc(struct ae * ae, - char * dst_name, + const char * dst, qosspec_t * qs, struct conn * conn); diff --git a/src/ipcpd/normal/dir.c b/src/ipcpd/normal/dir.c index ae9793c6..cbc50ba4 100644 --- a/src/ipcpd/normal/dir.c +++ b/src/ipcpd/normal/dir.c @@ -60,22 +60,23 @@ int dir_fini(void) return 0; } -int dir_name_reg(char * name) +int dir_reg(const uint8_t * hash) { + char hashstr[DIR_HASH_STRLEN + 1]; int ret; - assert(name); - - if (ipcp_get_state() != IPCP_OPERATIONAL) - return -EPERM; + assert(hash); dir_path_reset(); - ret = rib_add(dir_path, name); + ipcp_hash_str(hashstr, hash); + + ret = rib_add(dir_path, hashstr); if (ret == -ENOMEM) - return -ENOMEM; + return -ENOMEM; + + rib_path_append(dir_path, hashstr); - rib_path_append(dir_path, name); ret = rib_add(dir_path, ipcpi.name); if (ret == -EPERM) return -EPERM; @@ -88,18 +89,16 @@ int dir_name_reg(char * name) return 0; } -int dir_name_unreg(char * name) +int dir_unreg(const uint8_t * hash) { + char hashstr[DIR_HASH_STRLEN + 1]; size_t len; - assert(name); - - if (ipcp_get_state() != IPCP_OPERATIONAL) - return -EPERM; + assert(hash); dir_path_reset(); - rib_path_append(dir_path, name); + rib_path_append(dir_path, hashstr); if (!rib_has(dir_path)) return 0; @@ -118,16 +117,16 @@ int dir_name_unreg(char * name) return 0; } -int dir_name_query(char * name) +int dir_query(const uint8_t * hash) { + char hashstr[DIR_HASH_STRLEN + 1]; size_t len; - if (ipcp_get_state() != IPCP_OPERATIONAL) - return -EPERM; - dir_path_reset(); - rib_path_append(dir_path, name); + ipcp_hash_str(hashstr, hash); + + rib_path_append(dir_path, hashstr); if (!rib_has(dir_path)) return -1; diff --git a/src/ipcpd/normal/dir.h b/src/ipcpd/normal/dir.h index 04e722f3..1b28a5c0 100644 --- a/src/ipcpd/normal/dir.h +++ b/src/ipcpd/normal/dir.h @@ -27,10 +27,10 @@ int dir_init(void); int dir_fini(void); -int dir_name_reg(char * name); +int dir_reg(const uint8_t * hash); -int dir_name_unreg(char * name); +int dir_unreg(const uint8_t * hash); -int dir_name_query(char * name); +int dir_query(const uint8_t * hash); #endif /* OUROBOROS_IPCPD_NORMAL_DIR_H */ diff --git a/src/ipcpd/normal/enroll.c b/src/ipcpd/normal/enroll.c index 3e6a0197..f1f804c6 100644 --- a/src/ipcpd/normal/enroll.c +++ b/src/ipcpd/normal/enroll.c @@ -65,11 +65,9 @@ static void * enroll_handle(void * o) bool boot_r = false; bool members_r = false; - bool dif_name_r = false; char * boot_ro = BOOT_PATH; char * members_ro = MEMBERS_PATH; - char * dif_ro = DIF_PATH; cdap = (struct cdap *) o; @@ -87,7 +85,7 @@ static void * enroll_handle(void * o) continue; } - while (!(boot_r && members_r && dif_name_r)) { + while (!(boot_r && members_r)) { key = cdap_request_wait(cdap, &oc, &name, &data, (size_t *) &len , &flags); assert(key >= 0); @@ -109,8 +107,6 @@ static void * enroll_handle(void * o) boot_r = true; } else if (strcmp(name, members_ro) == 0) { members_r = true; - } else if (strcmp(name, dif_ro) == 0) { - dif_name_r = true; } else if (strcmp(name, TIME_PATH) == 0) { struct timespec t; uint64_t buf[2]; @@ -153,13 +149,13 @@ static void * enroll_handle(void * o) cdap_del_flow(cdap, conn.flow_info.fd); flow_dealloc(conn.flow_info.fd); - boot_r = members_r = dif_name_r = false; + boot_r = members_r = false; } return 0; } -int enroll_boot(char * dst_name) +int enroll_boot(const char * dst) { struct cdap * cdap; cdap_key_t * key; @@ -174,7 +170,6 @@ int enroll_boot(char * dst_name) char * boot_ro = BOOT_PATH; char * members_ro = MEMBERS_PATH; - char * dif_ro = DIF_PATH; cdap = cdap_create(); if (cdap == NULL) { @@ -182,7 +177,7 @@ int enroll_boot(char * dst_name) return -1; } - if (connmgr_alloc(enroll.ae, dst_name, NULL, &conn)) { + if (connmgr_alloc(enroll.ae, dst, NULL, &conn)) { log_err("Failed to get connection."); cdap_destroy(cdap); return -1; @@ -195,7 +190,7 @@ int enroll_boot(char * dst_name) return -1; } - log_dbg("Getting boot information from %s.", dst_name); + log_dbg("Getting boot information from %s.", dst); clock_gettime(CLOCK_REALTIME, &t0); @@ -293,37 +288,6 @@ int enroll_boot(char * dst_name) log_dbg("Packed information inserted into RIB."); - key = cdap_request_send(cdap, CDAP_READ, dif_ro, NULL, 0, 0); - if (key == NULL || key[0] == INVALID_CDAP_KEY) { - log_err("Failed to send CDAP request."); - cdap_destroy(cdap); - flow_dealloc(conn.flow_info.fd); - return -1; - } - - if (cdap_reply_wait(cdap, key[0], &data, &len)) { - log_err("Failed to get CDAP reply."); - free(key); - cdap_destroy(cdap); - flow_dealloc(conn.flow_info.fd); - return -1; - } - - free(key); - - log_dbg("Packed information received (%zu bytes).", len); - - if (rib_unpack(data, len, UNPACK_CREATE)) { - log_warn("Error unpacking RIB data."); - rib_del(boot_ro); - free(data); - cdap_destroy(cdap); - flow_dealloc(conn.flow_info.fd); - return -1; - } - - log_dbg("Packed information inserted into RIB."); - cdap_destroy(cdap); flow_dealloc(conn.flow_info.fd); diff --git a/src/ipcpd/normal/enroll.h b/src/ipcpd/normal/enroll.h index 05f950ba..bed4bf9f 100644 --- a/src/ipcpd/normal/enroll.h +++ b/src/ipcpd/normal/enroll.h @@ -31,6 +31,6 @@ int enroll_start(void); void enroll_stop(void); -int enroll_boot(char * dst_name); +int enroll_boot(const char * dst); #endif /* OUROBOROS_IPCPD_NORMAL_ENROLL_H */ diff --git a/src/ipcpd/normal/flow_alloc.proto b/src/ipcpd/normal/flow_alloc.proto index 3b08f047..35624799 100644 --- a/src/ipcpd/normal/flow_alloc.proto +++ b/src/ipcpd/normal/flow_alloc.proto @@ -30,7 +30,7 @@ enum flow_alloc_code { message flow_alloc_msg { required flow_alloc_code code = 1; - optional string dst_name = 2; + optional bytes hash = 2; optional uint32 qoscube = 3; optional sint32 response = 4; }; diff --git a/src/ipcpd/normal/fmgr.c b/src/ipcpd/normal/fmgr.c index 19c329af..5166cc5d 100644 --- a/src/ipcpd/normal/fmgr.c +++ b/src/ipcpd/normal/fmgr.c @@ -427,9 +427,9 @@ void fmgr_stop(void) gam_destroy(fmgr.gam); } -int fmgr_np1_alloc(int fd, - char * dst_ap_name, - qoscube_t cube) +int fmgr_np1_alloc(int fd, + const uint8_t * dst, + qoscube_t cube) { cep_id_t cep_id; buffer_t buf; @@ -439,14 +439,17 @@ int fmgr_np1_alloc(int fd, ssize_t ch; ssize_t i; char ** children; + char hashstr[DIR_HASH_STRLEN + 1]; char * dst_ipcp = NULL; - assert(strlen(dst_ap_name) + strlen("/" DIR_NAME) + 1 + ipcp_hash_str(hashstr, dst); + + assert(strlen(hashstr) + strlen(DIR_PATH) + 1 < RIB_MAX_PATH_LEN); strcpy(path, DIR_PATH); - rib_path_append(path, dst_ap_name); + rib_path_append(path, hashstr); ch = rib_children(path, &children); if (ch <= 0) @@ -463,7 +466,7 @@ int fmgr_np1_alloc(int fd, if (dst_ipcp == NULL) return -1; - strcpy(path, "/" MEMBERS_NAME); + strcpy(path, MEMBERS_PATH); rib_path_append(path, dst_ipcp); @@ -472,10 +475,12 @@ int fmgr_np1_alloc(int fd, if (rib_read(path, &addr, sizeof(addr)) < 0) return -1; - msg.code = FLOW_ALLOC_CODE__FLOW_REQ; - msg.dst_name = dst_ap_name; + msg.code = FLOW_ALLOC_CODE__FLOW_REQ; + msg.has_hash = true; + msg.hash.len = ipcpi.dir_hash_len; + msg.hash.data = (uint8_t *) dst; msg.has_qoscube = true; - msg.qoscube = cube; + msg.qoscube = cube; buf.len = flow_alloc_msg__get_packed_size(&msg); if (buf.len == 0) @@ -637,6 +642,11 @@ int fmgr_np1_post_buf(cep_id_t cep_id, case FLOW_ALLOC_CODE__FLOW_REQ: pthread_mutex_lock(&ipcpi.alloc_lock); + if (!msg->has_hash) { + log_err("Bad flow request."); + return -1; + } + while (ipcpi.alloc_id != -1 && ipcp_get_state() == IPCP_OPERATIONAL) pthread_cond_timedwait(&ipcpi.alloc_cond, @@ -652,7 +662,8 @@ int fmgr_np1_post_buf(cep_id_t cep_id, assert(ipcpi.alloc_id == -1); fd = ipcp_flow_req_arr(getpid(), - msg->dst_name, + msg->hash.data, + ipcpi.dir_hash_len, msg->qoscube); if (fd < 0) { pthread_mutex_unlock(&ipcpi.alloc_lock); diff --git a/src/ipcpd/normal/fmgr.h b/src/ipcpd/normal/fmgr.h index b4d0b65a..c59c0875 100644 --- a/src/ipcpd/normal/fmgr.h +++ b/src/ipcpd/normal/fmgr.h @@ -37,9 +37,9 @@ int fmgr_start(void); void fmgr_stop(void); -int fmgr_np1_alloc(int fd, - char * dst_ap_name, - qoscube_t qos); +int fmgr_np1_alloc(int fd, + const uint8_t * dst, + qoscube_t qos); int fmgr_np1_alloc_resp(int fd, int response); diff --git a/src/ipcpd/normal/gam.h b/src/ipcpd/normal/gam.h index 4ae0b1b3..752d8e37 100644 --- a/src/ipcpd/normal/gam.h +++ b/src/ipcpd/normal/gam.h @@ -23,8 +23,8 @@ #ifndef OUROBOROS_IPCPD_NORMAL_GAM_H #define OUROBOROS_IPCPD_NORMAL_GAM_H +#include <ouroboros/ipcp.h> #include <ouroboros/cacep.h> -#include <ouroboros/irm_config.h> #include "neighbors.h" diff --git a/src/ipcpd/normal/main.c b/src/ipcpd/normal/main.c index ef7f07cf..e37a0fbc 100644 --- a/src/ipcpd/normal/main.c +++ b/src/ipcpd/normal/main.c @@ -23,12 +23,13 @@ #define OUROBOROS_PREFIX "normal-ipcp" #include <ouroboros/config.h> +#include <ouroboros/endian.h> #include <ouroboros/logs.h> #include <ouroboros/ipcp-dev.h> #include <ouroboros/time_utils.h> #include <ouroboros/irm.h> #include <ouroboros/rib.h> -#include <ouroboros/irm_config.h> +#include <ouroboros/hash.h> #include <ouroboros/errno.h> #include "addr_auth.h" @@ -49,37 +50,6 @@ #define THIS_TYPE IPCP_NORMAL -void ipcp_sig_handler(int sig, - siginfo_t * info, - void * c) -{ - (void) c; - - switch(sig) { - case SIGINT: - case SIGTERM: - case SIGHUP: - if (info->si_pid == ipcpi.irmd_api) { - pthread_rwlock_wrlock(&ipcpi.state_lock); - - if (ipcp_get_state() == IPCP_INIT) - ipcp_set_state(IPCP_NULL); - - if (ipcp_get_state() == IPCP_OPERATIONAL) - ipcp_set_state(IPCP_SHUTDOWN); - - pthread_rwlock_unlock(&ipcpi.state_lock); - } - default: - return; - } -} - -/* - * Boots the IPCP off information in the rib. - * Common function after bootstrap or enroll. - * Call under ipcpi.state_lock - */ static int boot_components(void) { char buf[256]; @@ -87,7 +57,7 @@ static int boot_components(void) enum pol_addr_auth pa; char path[RIB_MAX_PATH_LEN + 1]; - len = rib_read(DIF_PATH, &buf, 256); + len = rib_read(BOOT_PATH "/general/dif_name", buf, 256); if (len < 0) { log_err("Failed to read DIF name: %zd.", len); return -1; @@ -99,6 +69,17 @@ static int boot_components(void) return -1; } + len = rib_read(BOOT_PATH "/general/dir_hash_len", + &ipcpi.dir_hash_len, sizeof(ipcpi.dir_hash_len)); + if (len < 0) { + log_err("Failed to read hash length: %zd.", len); + return -1; + } + + ipcpi.dir_hash_len = ntoh16(ipcpi.dir_hash_len); + + assert(ipcpi.dir_hash_len != 0); + if (rib_add(MEMBERS_PATH, ipcpi.name)) { log_err("Failed to add name to " MEMBERS_PATH); return -1; @@ -160,12 +141,11 @@ static int boot_components(void) } if (fmgr_init()) { - log_err("Failed to initialize flow manager component."); frct_fini(); dir_fini(); ribmgr_fini(); addr_auth_fini(); - log_err("Failed to start flow manager."); + log_err("Failed to initialize flow manager component."); return -1; } @@ -229,38 +209,25 @@ void shutdown_components(void) free(ipcpi.dif_name); } -static int normal_ipcp_enroll(char * dst_name) +static int normal_ipcp_enroll(const char * dst) { - pthread_rwlock_wrlock(&ipcpi.state_lock); - - if (ipcp_get_state() != IPCP_INIT) { - pthread_rwlock_unlock(&ipcpi.state_lock); - log_err("IPCP in wrong state."); - return -1; /* -ENOTINIT */ - } - if (rib_add(RIB_ROOT, MEMBERS_NAME)) { - pthread_rwlock_unlock(&ipcpi.state_lock); log_err("Failed to create members."); return -1; } /* Get boot state from peer */ - if (enroll_boot(dst_name)) { - pthread_rwlock_unlock(&ipcpi.state_lock); + if (enroll_boot(dst)) { log_err("Failed to boot IPCP components."); return -1; } if (boot_components()) { - pthread_rwlock_unlock(&ipcpi.state_lock); log_err("Failed to boot IPCP components."); return -1; } - pthread_rwlock_unlock(&ipcpi.state_lock); - - log_dbg("Enrolled with %s.", dst_name); + log_dbg("Enrolled with " HASH_FMT, HASH_VAL(dst)); return 0; } @@ -269,12 +236,17 @@ const struct ros { char * parent; char * child; } ros[] = { - /* GENERAL IPCP INFO */ - {RIB_ROOT, DIF_NAME}, /* BOOT INFO */ {RIB_ROOT, BOOT_NAME}, /* OTHER RIB STRUCTURES */ {RIB_ROOT, MEMBERS_NAME}, + + /* GENERAL IPCP INFO */ + {BOOT_PATH, "general"}, + + {BOOT_PATH "/general", "dif_name"}, + {BOOT_PATH "/general", "dir_hash_len"}, + /* DT COMPONENT */ {BOOT_PATH, "dt"}, @@ -319,28 +291,28 @@ int normal_rib_init(void) return 0; } -static int normal_ipcp_bootstrap(struct dif_config * conf) +static int normal_ipcp_bootstrap(const struct ipcp_config * conf) { + uint16_t hash_len; + assert(conf); assert(conf->type == THIS_TYPE); - pthread_rwlock_wrlock(&ipcpi.state_lock); + hash_len = hton16((uint16_t) conf->dir_hash_len); - if (ipcp_get_state() != IPCP_INIT) { - pthread_rwlock_unlock(&ipcpi.state_lock); - log_err("IPCP in wrong state."); - return -1; /* -ENOTINIT */ - } + assert(ntoh16(hash_len) != 0); if (normal_rib_init()) { - pthread_rwlock_unlock(&ipcpi.state_lock); log_err("Failed to write initial structure to the RIB."); return -1; } - if (rib_write(DIF_PATH, + if (rib_write(BOOT_PATH "/general/dif_name", conf->dif_name, strlen(conf->dif_name) + 1) || + rib_write(BOOT_PATH "/general/dir_hash_len", + &hash_len, + sizeof(hash_len)) || rib_write(BOOT_PATH "/dt/const/addr_size", &conf->addr_size, sizeof(conf->addr_size)) || @@ -375,18 +347,14 @@ static int normal_ipcp_bootstrap(struct dif_config * conf) &conf->addr_auth_type, sizeof(conf->addr_auth_type))) { log_err("Failed to write boot info to RIB."); - pthread_rwlock_unlock(&ipcpi.state_lock); return -1; } if (boot_components()) { log_err("Failed to boot IPCP components."); - pthread_rwlock_unlock(&ipcpi.state_lock); return -1; } - pthread_rwlock_unlock(&ipcpi.state_lock); - log_dbg("Bootstrapped in DIF %s.", conf->dif_name); return 0; @@ -395,9 +363,9 @@ static int normal_ipcp_bootstrap(struct dif_config * conf) static struct ipcp_ops normal_ops = { .ipcp_bootstrap = normal_ipcp_bootstrap, .ipcp_enroll = normal_ipcp_enroll, - .ipcp_name_reg = dir_name_reg, - .ipcp_name_unreg = dir_name_unreg, - .ipcp_name_query = dir_name_query, + .ipcp_reg = dir_reg, + .ipcp_unreg = dir_unreg, + .ipcp_query = dir_query, .ipcp_flow_alloc = fmgr_np1_alloc, .ipcp_flow_alloc_resp = fmgr_np1_alloc_resp, .ipcp_flow_dealloc = fmgr_np1_dealloc @@ -406,27 +374,6 @@ static struct ipcp_ops normal_ops = { int main(int argc, char * argv[]) { - struct sigaction sig_act; - sigset_t sigset; - - sigemptyset(&sigset); - sigaddset(&sigset, SIGINT); - sigaddset(&sigset, SIGQUIT); - sigaddset(&sigset, SIGHUP); - sigaddset(&sigset, SIGPIPE); - - /* init sig_act */ - memset(&sig_act, 0, sizeof(sig_act)); - - /* install signal traps */ - sig_act.sa_sigaction = &ipcp_sig_handler; - sig_act.sa_flags = SA_SIGINFO; - - sigaction(SIGINT, &sig_act, NULL); - sigaction(SIGTERM, &sig_act, NULL); - sigaction(SIGHUP, &sig_act, NULL); - sigaction(SIGPIPE, &sig_act, NULL); - if (ipcp_init(argc, argv, THIS_TYPE, &normal_ops) < 0) { ipcp_create_r(getpid(), -1); exit(EXIT_FAILURE); @@ -466,7 +413,6 @@ int main(int argc, exit(EXIT_FAILURE); } - pthread_sigmask(SIG_BLOCK, &sigset, NULL); if (ipcp_boot() < 0) { log_err("Failed to boot IPCP."); @@ -479,8 +425,6 @@ int main(int argc, exit(EXIT_FAILURE); } - pthread_sigmask(SIG_UNBLOCK, &sigset, NULL); - if (ipcp_create_r(getpid(), 0)) { log_err("Failed to notify IRMd we are initialized."); ipcp_set_state(IPCP_NULL); diff --git a/src/ipcpd/normal/neighbors.h b/src/ipcpd/normal/neighbors.h index 8714a9aa..c958affc 100644 --- a/src/ipcpd/normal/neighbors.h +++ b/src/ipcpd/normal/neighbors.h @@ -23,7 +23,7 @@ #ifndef OUROBOROS_IPCPD_NORMAL_NEIGHBORS_H #define OUROBOROS_IPCPD_NORMAL_NEIGHBORS_H -#include <ouroboros/irm_config.h> +#include <ouroboros/ipcp.h> #include <ouroboros/list.h> #include <ouroboros/qos.h> #include <ouroboros/fqueue.h> diff --git a/src/ipcpd/normal/pol/complete.h b/src/ipcpd/normal/pol/complete.h index 46a535c2..230fecb9 100644 --- a/src/ipcpd/normal/pol/complete.h +++ b/src/ipcpd/normal/pol/complete.h @@ -23,7 +23,7 @@ #ifndef OUROBOROS_IPCPD_NORMAL_POL_COMPLETE_H #define OUROBOROS_IPCPD_NORMAL_POL_COMPLETE_H -#include <ouroboros/irm_config.h> +#include <ouroboros/ipcp.h> #include <ouroboros/qos.h> #include "pol-gam-ops.h" diff --git a/src/ipcpd/normal/ribconfig.h b/src/ipcpd/normal/ribconfig.h index 5ecdaab3..2f5daf72 100644 --- a/src/ipcpd/normal/ribconfig.h +++ b/src/ipcpd/normal/ribconfig.h @@ -29,10 +29,8 @@ #define DLR "/" #define BOOT_NAME "boot" #define MEMBERS_NAME "members" -#define DIF_NAME "dif_name" #define DIR_NAME "directory" #define ROUTING_NAME "fsdb" -#define DIF_PATH DLR DIF_NAME #define DIR_PATH DLR DIR_NAME #define BOOT_PATH DLR BOOT_NAME #define MEMBERS_PATH DLR MEMBERS_NAME diff --git a/src/ipcpd/normal/ribmgr.h b/src/ipcpd/normal/ribmgr.h index 8922688a..83d5ec3a 100644 --- a/src/ipcpd/normal/ribmgr.h +++ b/src/ipcpd/normal/ribmgr.h @@ -23,7 +23,7 @@ #ifndef OUROBOROS_IPCPD_NORMAL_RIBMGR_H #define OUROBOROS_IPCPD_NORMAL_RIBMGR_H -#include <ouroboros/irm_config.h> +#include <ouroboros/ipcp.h> #include <ouroboros/utils.h> #include <ouroboros/qos.h> diff --git a/src/ipcpd/shim-data.c b/src/ipcpd/shim-data.c index eb4ec33f..4459837d 100644 --- a/src/ipcpd/shim-data.c +++ b/src/ipcpd/shim-data.c @@ -34,26 +34,24 @@ struct reg_entry { struct list_head list; - char * name; + uint8_t * hash; }; struct dir_entry { struct list_head list; - char * name; + uint8_t * hash; uint64_t addr; }; -static struct reg_entry * reg_entry_create(char * name) +static struct reg_entry * reg_entry_create(uint8_t * hash) { struct reg_entry * entry = malloc(sizeof(*entry)); if (entry == NULL) return NULL; - assert(name); + assert(hash); - entry->name = name; - if (entry->name == NULL) - return NULL; + entry->hash = hash; return entry; } @@ -62,25 +60,23 @@ static void reg_entry_destroy(struct reg_entry * entry) { assert(entry); - if (entry->name != NULL) - free(entry->name); + if (entry->hash != NULL) + free(entry->hash); free(entry); } -static struct dir_entry * dir_entry_create(char * name, - uint64_t addr) +static struct dir_entry * dir_entry_create(uint8_t * hash, + uint64_t addr) { struct dir_entry * entry = malloc(sizeof(*entry)); if (entry == NULL) return NULL; - assert(name); + assert(hash); - entry->addr = addr; - entry->name = name; - if (entry->name == NULL) - return NULL; + entry->addr = addr; + entry->hash = hash; return entry; } @@ -89,8 +85,8 @@ static void dir_entry_destroy(struct dir_entry * entry) { assert(entry); - if (entry->name != NULL) - free(entry->name); + if (entry->hash != NULL) + free(entry->hash); free(entry); } @@ -181,17 +177,17 @@ void shim_data_destroy(struct shim_data * data) free(data); } -static struct reg_entry * find_reg_entry_by_name(struct shim_data * data, - const char * name) +static struct reg_entry * find_reg_entry_by_hash(struct shim_data * data, + const uint8_t * hash) { struct list_head * h; assert(data); - assert(name); + assert(hash); list_for_each(h, &data->registry) { struct reg_entry * e = list_entry(h, struct reg_entry, list); - if (!strcmp(e->name, name)) + if (!memcmp(e->hash, hash, ipcpi.dir_hash_len)) return e; } @@ -199,13 +195,14 @@ static struct reg_entry * find_reg_entry_by_name(struct shim_data * data, } static struct dir_entry * find_dir_entry(struct shim_data * data, - const char * name, + const uint8_t * hash, uint64_t addr) { struct list_head * h; list_for_each(h, &data->directory) { struct dir_entry * e = list_entry(h, struct dir_entry, list); - if (e->addr == addr && !strcmp(e->name, name)) + if (e->addr == addr && + !memcmp(e->hash, hash, ipcpi.dir_hash_len)) return e; } @@ -213,12 +210,12 @@ static struct dir_entry * find_dir_entry(struct shim_data * data, } static struct dir_entry * find_dir_entry_any(struct shim_data * data, - const char * name) + const uint8_t * hash) { struct list_head * h; list_for_each(h, &data->directory) { struct dir_entry * e = list_entry(h, struct dir_entry, list); - if (!strcmp(e->name, name)) + if (!memcmp(e->hash, hash, ipcpi.dir_hash_len)) return e; } @@ -226,21 +223,21 @@ static struct dir_entry * find_dir_entry_any(struct shim_data * data, } int shim_data_reg_add_entry(struct shim_data * data, - char * name) + uint8_t * hash) { struct reg_entry * entry; - if (data == NULL || name == NULL) - return -1; + assert(data); + assert(hash); pthread_rwlock_wrlock(&data->reg_lock); - if (find_reg_entry_by_name(data, name)) { + if (find_reg_entry_by_hash(data, hash)) { pthread_rwlock_unlock(&data->reg_lock); return -1; } - entry = reg_entry_create(name); + entry = reg_entry_create(hash); if (entry == NULL) { pthread_rwlock_unlock(&data->reg_lock); return -1; @@ -254,7 +251,7 @@ int shim_data_reg_add_entry(struct shim_data * data, } int shim_data_reg_del_entry(struct shim_data * data, - const char * name) + const uint8_t * hash) { struct reg_entry * e; if (data == NULL) @@ -262,7 +259,7 @@ int shim_data_reg_del_entry(struct shim_data * data, pthread_rwlock_wrlock(&data->reg_lock); - e = find_reg_entry_by_name(data, name); + e = find_reg_entry_by_hash(data, hash); if (e == NULL) { pthread_rwlock_unlock(&data->reg_lock); return 0; /* nothing to do */ @@ -278,16 +275,16 @@ int shim_data_reg_del_entry(struct shim_data * data, } bool shim_data_reg_has(struct shim_data * data, - const char * name) + const uint8_t * hash) { bool ret = false; - if (data == NULL || name == NULL) - return false; + assert(data); + assert(hash); pthread_rwlock_rdlock(&data->reg_lock); - ret = (find_reg_entry_by_name(data, name) != NULL); + ret = (find_reg_entry_by_hash(data, hash) != NULL); pthread_rwlock_unlock(&data->reg_lock); @@ -295,29 +292,29 @@ bool shim_data_reg_has(struct shim_data * data, } int shim_data_dir_add_entry(struct shim_data * data, - char * name, + const uint8_t * hash, uint64_t addr) { struct dir_entry * entry; - char * entry_name; + uint8_t * entry_hash; - if (data == NULL || name == NULL) - return -1; + assert(data); + assert(hash); pthread_rwlock_wrlock(&data->dir_lock); - if (find_dir_entry(data, name, addr) != NULL) { + if (find_dir_entry(data, hash, addr) != NULL) { pthread_rwlock_unlock(&data->dir_lock); return -1; } - entry_name = strdup(name); - if (entry_name == NULL) { + entry_hash = ipcp_hash_dup(hash); + if (entry_hash == NULL) { pthread_rwlock_unlock(&data->dir_lock); return -1; } - entry = dir_entry_create(entry_name, addr); + entry = dir_entry_create(entry_hash, addr); if (entry == NULL) { pthread_rwlock_unlock(&data->dir_lock); return -1; @@ -331,7 +328,7 @@ int shim_data_dir_add_entry(struct shim_data * data, } int shim_data_dir_del_entry(struct shim_data * data, - const char * name, + const uint8_t * hash, uint64_t addr) { struct dir_entry * e; @@ -340,7 +337,7 @@ int shim_data_dir_del_entry(struct shim_data * data, pthread_rwlock_wrlock(&data->dir_lock); - e = find_dir_entry(data, name, addr); + e = find_dir_entry(data, hash, addr); if (e == NULL) { pthread_rwlock_unlock(&data->dir_lock); return 0; /* nothing to do */ @@ -356,13 +353,13 @@ int shim_data_dir_del_entry(struct shim_data * data, } bool shim_data_dir_has(struct shim_data * data, - const char * name) + const uint8_t * hash) { bool ret = false; pthread_rwlock_rdlock(&data->dir_lock); - ret = (find_dir_entry_any(data, name) != NULL); + ret = (find_dir_entry_any(data, hash) != NULL); pthread_rwlock_unlock(&data->dir_lock); @@ -370,14 +367,14 @@ bool shim_data_dir_has(struct shim_data * data, } uint64_t shim_data_dir_get_addr(struct shim_data * data, - const char * name) + const uint8_t * hash) { struct dir_entry * entry; uint64_t addr; pthread_rwlock_rdlock(&data->dir_lock); - entry = find_dir_entry_any(data, name); + entry = find_dir_entry_any(data, hash); if (entry == NULL) { pthread_rwlock_unlock(&data->dir_lock); @@ -391,7 +388,7 @@ uint64_t shim_data_dir_get_addr(struct shim_data * data, return addr; } -struct dir_query * shim_data_dir_query_create(char * name) +struct dir_query * shim_data_dir_query_create(const uint8_t * hash) { struct dir_query * query; pthread_condattr_t cattr; @@ -400,8 +397,8 @@ struct dir_query * shim_data_dir_query_create(char * name) if (query == NULL) return NULL; - query->name = strdup(name); - if (query->name == NULL) { + query->hash = ipcp_hash_dup(hash); + if (query->hash == NULL) { free(query); return NULL; } @@ -467,7 +464,7 @@ void shim_data_dir_query_destroy(struct dir_query * query) pthread_cond_destroy(&query->cond); pthread_mutex_destroy(&query->lock); - free(query->name); + free(query->hash); free(query); } diff --git a/src/ipcpd/shim-data.h b/src/ipcpd/shim-data.h index ac670b43..d53373df 100644 --- a/src/ipcpd/shim-data.h +++ b/src/ipcpd/shim-data.h @@ -30,7 +30,6 @@ #include <pthread.h> #include <stdint.h> - enum dir_query_state { QUERY_INIT = 0, QUERY_PENDING, @@ -41,7 +40,7 @@ enum dir_query_state { struct dir_query { struct list_head next; - char * name; + uint8_t * hash; enum dir_query_state state; pthread_mutex_t lock; @@ -49,14 +48,14 @@ struct dir_query { }; struct shim_data { - struct list_head registry; - pthread_rwlock_t reg_lock; + struct list_head registry; + pthread_rwlock_t reg_lock; - struct list_head directory; - pthread_rwlock_t dir_lock; + struct list_head directory; + pthread_rwlock_t dir_lock; - struct list_head dir_queries; - pthread_mutex_t dir_queries_lock; + struct list_head dir_queries; + pthread_mutex_t dir_queries_lock; }; struct shim_data * shim_data_create(void); @@ -64,29 +63,29 @@ struct shim_data * shim_data_create(void); void shim_data_destroy(struct shim_data * data); int shim_data_reg_add_entry(struct shim_data * data, - char * name); + uint8_t * hash); int shim_data_reg_del_entry(struct shim_data * data, - const char * name); + const uint8_t * hash); bool shim_data_reg_has(struct shim_data * data, - const char * name); + const uint8_t * hash); int shim_data_dir_add_entry(struct shim_data * data, - char * name, + const uint8_t * hash, uint64_t addr); int shim_data_dir_del_entry(struct shim_data * data, - const char * name, + const uint8_t * hash, uint64_t addr); bool shim_data_dir_has(struct shim_data * data, - const char * name); + const uint8_t * hash); uint64_t shim_data_dir_get_addr(struct shim_data * data, - const char * name); + const uint8_t * hash); -struct dir_query * shim_data_dir_query_create(char * name); +struct dir_query * shim_data_dir_query_create(const uint8_t * hash); void shim_data_dir_query_respond(struct dir_query * query); diff --git a/src/ipcpd/shim-eth-llc/main.c b/src/ipcpd/shim-eth-llc/main.c index 27456eb7..9a9e11b5 100644 --- a/src/ipcpd/shim-eth-llc/main.c +++ b/src/ipcpd/shim-eth-llc/main.c @@ -34,6 +34,7 @@ #include <ouroboros/fqueue.h> #include <ouroboros/logs.h> #include <ouroboros/time_utils.h> +#include <ouroboros/hash.h> #include "ipcp.h" #include "shim_eth_llc_messages.pb-c.h" @@ -248,11 +249,11 @@ static uint8_t reverse_bits(uint8_t b) return b; } -static int eth_llc_ipcp_send_frame(uint8_t * dst_addr, - uint8_t dsap, - uint8_t ssap, - uint8_t * payload, - size_t len) +static int eth_llc_ipcp_send_frame(const uint8_t * dst_addr, + uint8_t dsap, + uint8_t ssap, + const uint8_t * payload, + size_t len) { uint32_t frame_len = 0; uint8_t cf = 0x03; @@ -311,7 +312,7 @@ static int eth_llc_ipcp_send_frame(uint8_t * dst_addr, } static int eth_llc_ipcp_send_mgmt_frame(shim_eth_llc_msg_t * msg, - uint8_t * dst_addr) + const uint8_t * dst_addr) { size_t len; uint8_t * buf; @@ -338,17 +339,19 @@ static int eth_llc_ipcp_send_mgmt_frame(shim_eth_llc_msg_t * msg, return 0; } -static int eth_llc_ipcp_sap_alloc(uint8_t * dst_addr, - uint8_t ssap, - char * dst_name, - qoscube_t cube) +static int eth_llc_ipcp_sap_alloc(const uint8_t * dst_addr, + uint8_t ssap, + const uint8_t * hash, + qoscube_t cube) { shim_eth_llc_msg_t msg = SHIM_ETH_LLC_MSG__INIT; msg.code = SHIM_ETH_LLC_MSG_CODE__FLOW_REQ; msg.has_ssap = true; msg.ssap = ssap; - msg.dst_name = dst_name; + msg.has_hash = true; + msg.hash.len = ipcpi.dir_hash_len; + msg.hash.data = (uint8_t *) hash; msg.has_qoscube = true; msg.qoscube = cube; @@ -373,10 +376,10 @@ static int eth_llc_ipcp_sap_alloc_resp(uint8_t * dst_addr, return eth_llc_ipcp_send_mgmt_frame(&msg, dst_addr); } -static int eth_llc_ipcp_sap_req(uint8_t r_sap, - uint8_t * r_addr, - char * dst_name, - qoscube_t cube) +static int eth_llc_ipcp_sap_req(uint8_t r_sap, + uint8_t * r_addr, + const uint8_t * dst, + qoscube_t cube) { struct timespec ts = {0, EVENT_WAIT_TIMEOUT * 1000}; int fd; @@ -395,7 +398,7 @@ static int eth_llc_ipcp_sap_req(uint8_t r_sap, } /* reply to IRM, called under lock to prevent race */ - fd = ipcp_flow_req_arr(getpid(), dst_name, cube); + fd = ipcp_flow_req_arr(getpid(), dst, ipcpi.dir_hash_len, cube); if (fd < 0) { pthread_mutex_unlock(&ipcpi.alloc_lock); log_err("Could not get new flow from IRMd."); @@ -453,14 +456,16 @@ static int eth_llc_ipcp_sap_alloc_reply(uint8_t ssap, } -static int eth_llc_ipcp_name_query_req(char * name, - uint8_t * r_addr) +static int eth_llc_ipcp_name_query_req(const uint8_t * hash, + uint8_t * r_addr) { shim_eth_llc_msg_t msg = SHIM_ETH_LLC_MSG__INIT; - if (shim_data_reg_has(ipcpi.shim_data, name)) { - msg.code = SHIM_ETH_LLC_MSG_CODE__NAME_QUERY_REPLY; - msg.dst_name = name; + if (shim_data_reg_has(ipcpi.shim_data, hash)) { + msg.code = SHIM_ETH_LLC_MSG_CODE__NAME_QUERY_REPLY; + msg.has_hash = true; + msg.hash.len = ipcpi.dir_hash_len; + msg.hash.data = (uint8_t *) hash; eth_llc_ipcp_send_mgmt_frame(&msg, r_addr); } @@ -468,21 +473,21 @@ static int eth_llc_ipcp_name_query_req(char * name, return 0; } -static int eth_llc_ipcp_name_query_reply(char * name, - uint8_t * r_addr) +static int eth_llc_ipcp_name_query_reply(const uint8_t * hash, + uint8_t * r_addr) { uint64_t address = 0; struct list_head * pos; memcpy(&address, r_addr, MAC_SIZE); - shim_data_dir_add_entry(ipcpi.shim_data, name, address); + shim_data_dir_add_entry(ipcpi.shim_data, hash, address); pthread_mutex_lock(&ipcpi.shim_data->dir_queries_lock); list_for_each(pos, &ipcpi.shim_data->dir_queries) { struct dir_query * e = list_entry(pos, struct dir_query, next); - if (strcmp(e->name, name) == 0) { + if (memcmp(e->hash, hash, ipcpi.dir_hash_len) == 0) { shim_data_dir_query_respond(e); } } @@ -491,9 +496,9 @@ static int eth_llc_ipcp_name_query_reply(char * name, return 0; } -static int eth_llc_ipcp_mgmt_frame(uint8_t * buf, - size_t len, - uint8_t * r_addr) +static int eth_llc_ipcp_mgmt_frame(const uint8_t * buf, + size_t len, + uint8_t * r_addr) { shim_eth_llc_msg_t * msg; @@ -505,10 +510,10 @@ static int eth_llc_ipcp_mgmt_frame(uint8_t * buf, switch (msg->code) { case SHIM_ETH_LLC_MSG_CODE__FLOW_REQ: - if (shim_data_reg_has(ipcpi.shim_data, msg->dst_name)) { + if (shim_data_reg_has(ipcpi.shim_data, msg->hash.data)) { eth_llc_ipcp_sap_req(msg->ssap, r_addr, - msg->dst_name, + msg->hash.data, msg->qoscube); } break; @@ -519,10 +524,10 @@ static int eth_llc_ipcp_mgmt_frame(uint8_t * buf, msg->response); break; case SHIM_ETH_LLC_MSG_CODE__NAME_QUERY_REQ: - eth_llc_ipcp_name_query_req(msg->dst_name, r_addr); + eth_llc_ipcp_name_query_req(msg->hash.data, r_addr); break; case SHIM_ETH_LLC_MSG_CODE__NAME_QUERY_REPLY: - eth_llc_ipcp_name_query_reply(msg->dst_name, r_addr); + eth_llc_ipcp_name_query_reply(msg->hash.data, r_addr); break; default: log_err("Unknown message received %d.", msg->code); @@ -734,29 +739,7 @@ static void * eth_llc_ipcp_sdu_writer(void * o) return (void *) 1; } -void ipcp_sig_handler(int sig, - siginfo_t * info, - void * c) -{ - (void) c; - - switch(sig) { - case SIGINT: - case SIGTERM: - case SIGHUP: - if (info->si_pid == ipcpi.irmd_api) { - if (ipcp_get_state() == IPCP_INIT) - ipcp_set_state(IPCP_NULL); - - if (ipcp_get_state() == IPCP_OPERATIONAL) - ipcp_set_state(IPCP_SHUTDOWN); - } - default: - return; - } -} - -static int eth_llc_ipcp_bootstrap(struct dif_config * conf) +static int eth_llc_ipcp_bootstrap(const struct ipcp_config * conf) { int idx; struct ifreq ifr; @@ -777,10 +760,7 @@ static int eth_llc_ipcp_bootstrap(struct dif_config * conf) assert(conf); assert(conf->type == THIS_TYPE); - if (ipcp_get_state() != IPCP_INIT) { - log_err("IPCP in wrong state."); - return -1; - } + ipcpi.dir_hash_len = conf->dir_hash_len; if (conf->if_name == NULL) { log_err("Interface name is NULL."); @@ -921,35 +901,36 @@ static int eth_llc_ipcp_bootstrap(struct dif_config * conf) return 0; } -static int eth_llc_ipcp_name_reg(char * name) +static int eth_llc_ipcp_reg(const uint8_t * hash) { - char * name_dup; + uint8_t * hash_dup; - name_dup = strdup(name); - if (name_dup == NULL) { - log_err("Failed to duplicate name."); + hash_dup = ipcp_hash_dup(hash); + if (hash_dup == NULL) { + log_err("Failed to duplicate hash."); return -ENOMEM; } - if (shim_data_reg_add_entry(ipcpi.shim_data, name_dup)) { - log_err("Failed to add %s to local registry.", name); - free(name_dup); + if (shim_data_reg_add_entry(ipcpi.shim_data, hash_dup)) { + log_err("Failed to add " HASH_FMT " to local registry.", + HASH_VAL(hash)); + free(hash_dup); return -1; } - log_dbg("Registered %s.", name); + log_dbg("Registered " HASH_FMT ".", HASH_VAL(hash)); return 0; } -static int eth_llc_ipcp_name_unreg(char * name) +static int eth_llc_ipcp_unreg(const uint8_t * hash) { - shim_data_reg_del_entry(ipcpi.shim_data, name); + shim_data_reg_del_entry(ipcpi.shim_data, hash); return 0; } -static int eth_llc_ipcp_name_query(char * name) +static int eth_llc_ipcp_query(const uint8_t * hash) { uint8_t r_addr[MAC_SIZE]; struct timespec timeout = {(NAME_QUERY_TIMEOUT / 1000), @@ -958,15 +939,17 @@ static int eth_llc_ipcp_name_query(char * name) struct dir_query * query; int ret; - if (shim_data_dir_has(ipcpi.shim_data, name)) + if (shim_data_dir_has(ipcpi.shim_data, hash)) return 0; - msg.code = SHIM_ETH_LLC_MSG_CODE__NAME_QUERY_REQ; - msg.dst_name = name; + msg.code = SHIM_ETH_LLC_MSG_CODE__NAME_QUERY_REQ; + msg.has_hash = true; + msg.hash.len = ipcpi.dir_hash_len; + msg.hash.data = (uint8_t *) hash; memset(r_addr, 0xff, MAC_SIZE); - query = shim_data_dir_query_create(name); + query = shim_data_dir_query_create(hash); if (query == NULL) return -1; @@ -986,34 +969,28 @@ static int eth_llc_ipcp_name_query(char * name) return ret; } -static int eth_llc_ipcp_flow_alloc(int fd, - char * dst_name, - qoscube_t cube) +static int eth_llc_ipcp_flow_alloc(int fd, + const uint8_t * hash, + qoscube_t cube) { uint8_t ssap = 0; uint8_t r_addr[MAC_SIZE]; uint64_t addr = 0; - log_dbg("Allocating flow to %s.", dst_name); + log_dbg("Allocating flow to " HASH_FMT ".", HASH_VAL(hash)); - if (dst_name == NULL) - return -1; + assert(hash); if (cube != QOS_CUBE_BE && cube != QOS_CUBE_FRC) { log_dbg("Unsupported QoS requested."); return -1; } - if (ipcp_get_state() != IPCP_OPERATIONAL) { - log_dbg("Won't allocate flow with non-enrolled IPCP."); - return -1; /* -ENOTENROLLED */ - } - - if (!shim_data_dir_has(ipcpi.shim_data, dst_name)) { + if (!shim_data_dir_has(ipcpi.shim_data, hash)) { log_err("Destination unreachable."); return -1; } - addr = shim_data_dir_get_addr(ipcpi.shim_data, dst_name); + addr = shim_data_dir_get_addr(ipcpi.shim_data, hash); pthread_rwlock_wrlock(ð_llc_data.flows_lock); @@ -1030,7 +1007,7 @@ static int eth_llc_ipcp_flow_alloc(int fd, memcpy(r_addr, &addr, MAC_SIZE); - if (eth_llc_ipcp_sap_alloc(r_addr, ssap, dst_name, cube) < 0) { + if (eth_llc_ipcp_sap_alloc(r_addr, ssap, hash, cube) < 0) { pthread_rwlock_wrlock(ð_llc_data.flows_lock); bmp_release(eth_llc_data.saps, eth_llc_data.fd_to_ef[fd].sap); eth_llc_data.fd_to_ef[fd].sap = -1; @@ -1107,11 +1084,6 @@ static int eth_llc_ipcp_flow_dealloc(int fd) ipcp_flow_fini(fd); - if (ipcp_get_state() != IPCP_OPERATIONAL) { - log_dbg("Won't register with non-enrolled IPCP."); - return -1; /* -ENOTENROLLED */ - } - pthread_rwlock_wrlock(ð_llc_data.flows_lock); flow_set_del(eth_llc_data.np1_flows, fd); @@ -1137,9 +1109,9 @@ static int eth_llc_ipcp_flow_dealloc(int fd) static struct ipcp_ops eth_llc_ops = { .ipcp_bootstrap = eth_llc_ipcp_bootstrap, .ipcp_enroll = NULL, - .ipcp_name_reg = eth_llc_ipcp_name_reg, - .ipcp_name_unreg = eth_llc_ipcp_name_unreg, - .ipcp_name_query = eth_llc_ipcp_name_query, + .ipcp_reg = eth_llc_ipcp_reg, + .ipcp_unreg = eth_llc_ipcp_unreg, + .ipcp_query = eth_llc_ipcp_query, .ipcp_flow_alloc = eth_llc_ipcp_flow_alloc, .ipcp_flow_alloc_resp = eth_llc_ipcp_flow_alloc_resp, .ipcp_flow_dealloc = eth_llc_ipcp_flow_dealloc @@ -1148,27 +1120,6 @@ static struct ipcp_ops eth_llc_ops = { int main(int argc, char * argv[]) { - struct sigaction sig_act; - sigset_t sigset; - - sigemptyset(&sigset); - sigaddset(&sigset, SIGINT); - sigaddset(&sigset, SIGQUIT); - sigaddset(&sigset, SIGHUP); - sigaddset(&sigset, SIGPIPE); - - /* init sig_act */ - memset(&sig_act, 0, sizeof(sig_act)); - - /* install signal traps */ - sig_act.sa_sigaction = &ipcp_sig_handler; - sig_act.sa_flags = SA_SIGINFO; - - sigaction(SIGINT, &sig_act, NULL); - sigaction(SIGTERM, &sig_act, NULL); - sigaction(SIGHUP, &sig_act, NULL); - sigaction(SIGPIPE, &sig_act, NULL); - if (ipcp_init(argc, argv, THIS_TYPE, ð_llc_ops) < 0) { ipcp_create_r(getpid(), -1); exit(EXIT_FAILURE); @@ -1181,9 +1132,6 @@ int main(int argc, exit(EXIT_FAILURE); } - - pthread_sigmask(SIG_BLOCK, &sigset, NULL); - if (ipcp_boot() < 0) { log_err("Failed to boot IPCP."); ipcp_create_r(getpid(), -1); @@ -1192,8 +1140,6 @@ int main(int argc, exit(EXIT_FAILURE); } - pthread_sigmask(SIG_UNBLOCK, &sigset, NULL); - if (ipcp_create_r(getpid(), 0)) { log_err("Failed to notify IRMd we are initialized."); ipcp_set_state(IPCP_NULL); diff --git a/src/ipcpd/shim-eth-llc/shim_eth_llc_messages.proto b/src/ipcpd/shim-eth-llc/shim_eth_llc_messages.proto index 2d66428c..09281698 100644 --- a/src/ipcpd/shim-eth-llc/shim_eth_llc_messages.proto +++ b/src/ipcpd/shim-eth-llc/shim_eth_llc_messages.proto @@ -31,7 +31,7 @@ enum shim_eth_llc_msg_code { message shim_eth_llc_msg { required shim_eth_llc_msg_code code = 1; - optional string dst_name = 2; + optional bytes hash = 2; optional uint32 ssap = 3; optional uint32 dsap = 4; optional uint32 qoscube = 5; diff --git a/src/ipcpd/shim-udp/main.c b/src/ipcpd/shim-udp/main.c index b1a88fae..e1fe5c7c 100644 --- a/src/ipcpd/shim-udp/main.c +++ b/src/ipcpd/shim-udp/main.c @@ -30,6 +30,7 @@ #include <ouroboros/fqueue.h> #include <ouroboros/errno.h> #include <ouroboros/logs.h> +#include <ouroboros/hash.h> #include "shim_udp_messages.pb-c.h" #include "ipcp.h" @@ -197,14 +198,16 @@ static int send_shim_udp_msg(shim_udp_msg_t * msg, static int ipcp_udp_port_alloc(uint32_t dst_ip_addr, uint16_t src_udp_port, - char * dst_name, + const uint8_t * dst, qoscube_t cube) { shim_udp_msg_t msg = SHIM_UDP_MSG__INIT; msg.code = SHIM_UDP_MSG_CODE__FLOW_REQ; msg.src_udp_port = src_udp_port; - msg.dst_name = dst_name; + msg.has_hash = true; + msg.hash.len = ipcpi.dir_hash_len; + msg.hash.data = (uint8_t *) dst; msg.has_qoscube = true; msg.qoscube = cube; @@ -229,7 +232,7 @@ static int ipcp_udp_port_alloc_resp(uint32_t dst_ip_addr, } static int ipcp_udp_port_req(struct sockaddr_in * c_saddr, - char * dst_name, + const uint8_t * dst, qoscube_t cube) { struct timespec ts = {0, FD_UPDATE_TIMEOUT * 1000}; @@ -283,7 +286,7 @@ static int ipcp_udp_port_req(struct sockaddr_in * c_saddr, } /* reply to IRM */ - fd = ipcp_flow_req_arr(getpid(), dst_name, cube); + fd = ipcp_flow_req_arr(getpid(), dst, ipcpi.dir_hash_len, cube); if (fd < 0) { pthread_mutex_unlock(&ipcpi.alloc_lock); log_err("Could not get new flow from IRMd."); @@ -291,7 +294,6 @@ static int ipcp_udp_port_req(struct sockaddr_in * c_saddr, return -1; } - pthread_rwlock_rdlock(&ipcpi.state_lock); pthread_rwlock_wrlock(&udp_data.flows_lock); udp_data.uf_to_fd[skfd] = fd; @@ -299,7 +301,6 @@ static int ipcp_udp_port_req(struct sockaddr_in * c_saddr, udp_data.fd_to_uf[fd].udp = f_saddr.sin_port; pthread_rwlock_unlock(&udp_data.flows_lock); - pthread_rwlock_unlock(&ipcpi.state_lock); pthread_mutex_unlock(&ipcpi.alloc_lock); ipcpi.alloc_id = fd; @@ -337,14 +338,12 @@ static int ipcp_udp_port_alloc_reply(uint16_t src_udp_port, log_dbg("Received reply for flow on udp port %d.", ntohs(dst_udp_port)); - pthread_rwlock_rdlock(&ipcpi.state_lock); pthread_rwlock_rdlock(&udp_data.flows_lock); fd = udp_port_to_fd(dst_udp_port); skfd = udp_data.fd_to_uf[fd].skfd; pthread_rwlock_unlock(&udp_data.flows_lock); - pthread_rwlock_unlock(&ipcpi.state_lock); /* get the original address with the LISTEN PORT */ if (getpeername(skfd, (struct sockaddr *) &t_saddr, &t_saddr_len) < 0) { @@ -360,13 +359,11 @@ static int ipcp_udp_port_alloc_reply(uint16_t src_udp_port, return -1; } - pthread_rwlock_rdlock(&ipcpi.state_lock); pthread_rwlock_rdlock(&udp_data.flows_lock); set_fd(skfd); pthread_rwlock_unlock(&udp_data.flows_lock); - pthread_rwlock_unlock(&ipcpi.state_lock); if (ipcp_flow_alloc_reply(fd, response) < 0) return -1; @@ -410,7 +407,7 @@ static void * ipcp_udp_listener(void * o) case SHIM_UDP_MSG_CODE__FLOW_REQ: c_saddr.sin_port = msg->src_udp_port; ipcp_udp_port_req(&c_saddr, - msg->dst_name, + msg->hash.data, msg->qoscube); break; case SHIM_UDP_MSG_CODE__FLOW_REPLY: @@ -447,7 +444,6 @@ static void * ipcp_udp_sdu_reader(void * o) (void) o; while (true) { - pthread_rwlock_rdlock(&ipcpi.state_lock); pthread_rwlock_rdlock(&udp_data.flows_lock); pthread_mutex_lock(&udp_data.fd_set_lock); @@ -457,7 +453,6 @@ static void * ipcp_udp_sdu_reader(void * o) pthread_mutex_unlock(&udp_data.fd_set_lock); pthread_rwlock_unlock(&udp_data.flows_lock); - pthread_rwlock_unlock(&ipcpi.state_lock); if (select(FD_SETSIZE, &read_fds, NULL, NULL, &tv) <= 0) continue; @@ -476,13 +471,11 @@ static void * ipcp_udp_sdu_reader(void * o) (unsigned *) &n)) <= 0) continue; - pthread_rwlock_rdlock(&ipcpi.state_lock); pthread_rwlock_rdlock(&udp_data.flows_lock); fd = udp_data.uf_to_fd[skfd]; pthread_rwlock_unlock(&udp_data.flows_lock); - pthread_rwlock_unlock(&ipcpi.state_lock); flow_write(fd, buf, n); } @@ -506,12 +499,10 @@ static void * ipcp_udp_sdu_loop(void * o) continue; } - pthread_rwlock_rdlock(&ipcpi.state_lock); if (ipcp_get_state() != IPCP_OPERATIONAL) { - pthread_rwlock_unlock(&ipcpi.state_lock); ipcp_flow_del(sdb); - return (void *) -1; /* -ENOTENROLLED */ + return (void *) 0; /* -ENOTENROLLED */ } pthread_rwlock_rdlock(&udp_data.flows_lock); @@ -519,7 +510,6 @@ static void * ipcp_udp_sdu_loop(void * o) fd = udp_data.fd_to_uf[fd].skfd; pthread_rwlock_unlock(&udp_data.flows_lock); - pthread_rwlock_unlock(&ipcpi.state_lock); if (send(fd, shm_du_buff_head(sdb), shm_du_buff_tail(sdb) - shm_du_buff_head(sdb), @@ -533,33 +523,7 @@ static void * ipcp_udp_sdu_loop(void * o) return (void *) 1; } -void ipcp_sig_handler(int sig, - siginfo_t * info, - void * c) -{ - (void) c; - - switch(sig) { - case SIGINT: - case SIGTERM: - case SIGHUP: - if (info->si_pid == ipcpi.irmd_api) { - pthread_rwlock_wrlock(&ipcpi.state_lock); - - if (ipcp_get_state() == IPCP_INIT) - ipcp_set_state(IPCP_NULL); - - if (ipcp_get_state() == IPCP_OPERATIONAL) - ipcp_set_state(IPCP_SHUTDOWN); - - pthread_rwlock_unlock(&ipcpi.state_lock); - } - default: - return; - } -} - -static int ipcp_udp_bootstrap(struct dif_config * conf) +static int ipcp_udp_bootstrap(const struct ipcp_config * conf) { struct sockaddr_in s_saddr; char ipstr[INET_ADDRSTRLEN]; @@ -570,6 +534,8 @@ static int ipcp_udp_bootstrap(struct dif_config * conf) assert(conf); assert(conf->type == THIS_TYPE); + ipcpi.dir_hash_len = conf->dir_hash_len; + if (inet_ntop(AF_INET, &conf->ip_addr, ipstr, @@ -619,15 +585,6 @@ static int ipcp_udp_bootstrap(struct dif_config * conf) return -1; } - pthread_rwlock_wrlock(&ipcpi.state_lock); - - if (ipcp_get_state() != IPCP_INIT) { - pthread_rwlock_unlock(&ipcpi.state_lock); - log_err("IPCP in wrong state."); - close(fd); - return -1; - } - udp_data.s_fd = fd; udp_data.ip_addr = conf->ip_addr; udp_data.dns_addr = conf->dns_addr; @@ -650,8 +607,6 @@ static int ipcp_udp_bootstrap(struct dif_config * conf) ipcp_udp_sdu_loop, NULL); - pthread_rwlock_unlock(&ipcpi.state_lock); - log_dbg("Bootstrapped shim IPCP over UDP with api %d.", getpid()); log_dbg("Bound to IP address %s.", ipstr); log_dbg("DNS server address is %s.", dnsstr); @@ -784,7 +739,7 @@ static uint32_t ddns_resolve(char * name, } #endif -static int ipcp_udp_name_reg(char * name) +static int ipcp_udp_reg(const uint8_t * hash) { #ifdef CONFIG_OUROBOROS_ENABLE_DNS char ipstr[INET_ADDRSTRLEN]; @@ -794,25 +749,23 @@ static int ipcp_udp_name_reg(char * name) uint32_t dns_addr; uint32_t ip_addr; #endif - char * name_dup; + char hashstr[DIR_HASH_STRLEN + 1]; + uint8_t * hash_dup; - if (strlen(name) > 24) { - log_err("DNS names cannot be longer than 24 chars."); - return -1; - } + assert(hash); - name_dup = strdup(name); - if (name_dup == NULL) { - log_err("Failed to duplicate name."); + ipcp_hash_str(hashstr, hash); + + hash_dup = ipcp_hash_dup(hash); + if (hash_dup == NULL) { + log_err("Failed to duplicate hash."); return -ENOMEM; } - pthread_rwlock_rdlock(&ipcpi.state_lock); - - if (shim_data_reg_add_entry(ipcpi.shim_data, name_dup)) { - pthread_rwlock_unlock(&ipcpi.state_lock); - log_err("Failed to add %s to local registry.", name); - free(name_dup); + if (shim_data_reg_add_entry(ipcpi.shim_data, hash_dup)) { + log_err("Failed to add " HASH_FMT " to local registry.", + HASH_VAL(hash)); + free(hash_dup); return -1; } @@ -821,8 +774,6 @@ static int ipcp_udp_name_reg(char * name) dns_addr = udp_data.dns_addr; - pthread_rwlock_unlock(&ipcpi.state_lock); - if (dns_addr != 0) { ip_addr = udp_data.ip_addr; @@ -837,24 +788,20 @@ static int ipcp_udp_name_reg(char * name) } sprintf(cmd, "server %s\nupdate add %s %d A %s\nsend\nquit\n", - dnsstr, name, DNS_TTL, ipstr); + dnsstr, hashstr, DNS_TTL, ipstr); if (ddns_send(cmd)) { - pthread_rwlock_rdlock(&ipcpi.state_lock); - shim_data_reg_del_entry(ipcpi.shim_data, name); - pthread_rwlock_unlock(&ipcpi.state_lock); + shim_data_reg_del_entry(ipcpi.shim_data, hash_dup); return -1; } } -#else - pthread_rwlock_unlock(&ipcpi.state_lock); #endif - log_dbg("Registered %s.", name); + log_dbg("Registered " HASH_FMT ".", HASH_VAL(hash)); return 0; } -static int ipcp_udp_name_unreg(char * name) +static int ipcp_udp_unreg(const uint8_t * hash) { #ifdef CONFIG_OUROBOROS_ENABLE_DNS char dnsstr[INET_ADDRSTRLEN]; @@ -862,94 +809,66 @@ static int ipcp_udp_name_unreg(char * name) char cmd[100]; uint32_t dns_addr; #endif - if (strlen(name) > 24) { - log_err("DNS names cannot be longer than 24 chars."); - return -1; - } + char hashstr[DIR_HASH_STRLEN + 1]; + + assert(hash); + + ipcp_hash_str(hashstr, hash); #ifdef CONFIG_OUROBOROS_ENABLE_DNS /* unregister application with DNS server */ - pthread_rwlock_rdlock(&ipcpi.state_lock); - dns_addr = udp_data.dns_addr; - pthread_rwlock_unlock(&ipcpi.state_lock); - if (dns_addr != 0) { if (inet_ntop(AF_INET, &dns_addr, dnsstr, INET_ADDRSTRLEN) == NULL) { return -1; } sprintf(cmd, "server %s\nupdate delete %s A\nsend\nquit\n", - dnsstr, name); + dnsstr, hashstr); ddns_send(cmd); } #endif - pthread_rwlock_rdlock(&ipcpi.state_lock); - - shim_data_reg_del_entry(ipcpi.shim_data, name); + shim_data_reg_del_entry(ipcpi.shim_data, hash); - pthread_rwlock_unlock(&ipcpi.state_lock); + log_dbg("Unregistered " HASH_FMT ".", HASH_VAL(hash)); return 0; } -static int ipcp_udp_name_query(char * name) +static int ipcp_udp_query(const uint8_t * hash) { uint32_t ip_addr = 0; struct hostent * h; #ifdef CONFIG_OUROBOROS_ENABLE_DNS uint32_t dns_addr = 0; #endif + char hashstr[DIR_HASH_STRLEN + 1]; - assert(name); - - if (strlen(name) > 24) { - log_err("DNS names cannot be longer than 24 chars."); - return -1; - } - - pthread_rwlock_rdlock(&ipcpi.state_lock); + assert(hash); - if (ipcp_get_state() != IPCP_OPERATIONAL) { - pthread_rwlock_unlock(&ipcpi.state_lock); - log_dbg("Won't query a name on a non-enrolled IPCP."); - return -1; /* -ENOTENROLLED */ - } + ipcp_hash_str(hashstr, hash); - if (shim_data_dir_has(ipcpi.shim_data, name)) { - pthread_rwlock_unlock(&ipcpi.state_lock); + if (shim_data_dir_has(ipcpi.shim_data, hash)) return 0; - } #ifdef CONFIG_OUROBOROS_ENABLE_DNS dns_addr = udp_data.dns_addr; if (dns_addr != 0) { - pthread_rwlock_unlock(&ipcpi.state_lock); - - ip_addr = ddns_resolve(name, dns_addr); + ip_addr = ddns_resolve(hashstr, dns_addr); if (ip_addr == 0) { - log_dbg("Could not resolve %s.", name); + log_dbg("Could not resolve %s.", hashstr); return -1; } - - pthread_rwlock_rdlock(&ipcpi.state_lock); - - if (ipcp_get_state() != IPCP_OPERATIONAL) { - pthread_rwlock_unlock(&ipcpi.state_lock); - log_dbg("Won't add name to the directory."); - return -1; /* -ENOTENROLLED */ - } } else { #endif - h = gethostbyname(name); + h = gethostbyname(hashstr); if (h == NULL) { - pthread_rwlock_unlock(&ipcpi.state_lock); - log_dbg("Could not resolve %s.", name); + log_dbg("Could not resolve %s.", hashstr); return -1; } @@ -958,20 +877,17 @@ static int ipcp_udp_name_query(char * name) } #endif - if (shim_data_dir_add_entry(ipcpi.shim_data, name, ip_addr)) { - pthread_rwlock_unlock(&ipcpi.state_lock); + if (shim_data_dir_add_entry(ipcpi.shim_data, hash, ip_addr)) { log_err("Failed to add directory entry."); return -1; } - pthread_rwlock_unlock(&ipcpi.state_lock); - return 0; } -static int ipcp_udp_flow_alloc(int fd, - char * dst_name, - qoscube_t cube) +static int ipcp_udp_flow_alloc(int fd, + const uint8_t * dst, + qoscube_t cube) { struct sockaddr_in r_saddr; /* server address */ struct sockaddr_in f_saddr; /* flow */ @@ -979,14 +895,9 @@ static int ipcp_udp_flow_alloc(int fd, int skfd; uint32_t ip_addr = 0; - log_dbg("Allocating flow to %s.", dst_name); + log_dbg("Allocating flow to " HASH_FMT ".", HASH_VAL(dst)); - assert(dst_name); - - if (strlen(dst_name) > 255) { - log_err("Name too long for this shim."); - return -1; - } + assert(dst); if (cube != QOS_CUBE_BE && cube != QOS_CUBE_FRC) { log_dbg("Unsupported QoS requested."); @@ -1012,22 +923,13 @@ static int ipcp_udp_flow_alloc(int fd, return -1; } - pthread_rwlock_rdlock(&ipcpi.state_lock); - if (ipcp_get_state() != IPCP_OPERATIONAL) { - pthread_rwlock_unlock(&ipcpi.state_lock); - log_dbg("Won't allocate flow with non-enrolled IPCP."); - close(skfd); - return -1; /* -ENOTENROLLED */ - } - - if (!shim_data_dir_has(ipcpi.shim_data, dst_name)) { - pthread_rwlock_unlock(&ipcpi.state_lock); + if (!shim_data_dir_has(ipcpi.shim_data, dst)) { log_dbg("Could not resolve destination."); close(skfd); return -1; } - ip_addr = (uint32_t) shim_data_dir_get_addr(ipcpi.shim_data, dst_name); + ip_addr = (uint32_t) shim_data_dir_get_addr(ipcpi.shim_data, dst); /* connect to server (store the remote IP address in the fd) */ memset((char *) &r_saddr, 0, sizeof(r_saddr)); @@ -1049,13 +951,11 @@ static int ipcp_udp_flow_alloc(int fd, flow_set_add(udp_data.np1_flows, fd); pthread_rwlock_unlock(&udp_data.flows_lock); - pthread_rwlock_unlock(&ipcpi.state_lock); if (ipcp_udp_port_alloc(ip_addr, f_saddr.sin_port, - dst_name, + dst, cube) < 0) { - pthread_rwlock_rdlock(&ipcpi.state_lock); pthread_rwlock_wrlock(&udp_data.flows_lock); udp_data.fd_to_uf[fd].udp = -1; @@ -1063,7 +963,6 @@ static int ipcp_udp_flow_alloc(int fd, udp_data.uf_to_fd[skfd] = -1; pthread_rwlock_unlock(&udp_data.flows_lock); - pthread_rwlock_unlock(&ipcpi.state_lock); close(skfd); return -1; } @@ -1103,11 +1002,12 @@ static int ipcp_udp_flow_alloc_resp(int fd, pthread_mutex_unlock(&ipcpi.alloc_lock); - pthread_rwlock_rdlock(&ipcpi.state_lock); - pthread_rwlock_wrlock(&udp_data.flows_lock); + pthread_rwlock_rdlock(&udp_data.flows_lock); skfd = udp_data.fd_to_uf[fd].skfd; + pthread_rwlock_unlock(&udp_data.flows_lock); + if (getsockname(skfd, (struct sockaddr *) &f_saddr, &len) < 0) { log_dbg("Socket with fd %d has no address.", skfd); return -1; @@ -1118,7 +1018,6 @@ static int ipcp_udp_flow_alloc_resp(int fd, return -1; } - pthread_rwlock_unlock(&udp_data.flows_lock); pthread_rwlock_rdlock(&udp_data.flows_lock); set_fd(skfd); @@ -1126,18 +1025,12 @@ static int ipcp_udp_flow_alloc_resp(int fd, flow_set_add(udp_data.np1_flows, fd); pthread_rwlock_unlock(&udp_data.flows_lock); - pthread_rwlock_unlock(&ipcpi.state_lock); - if (ipcp_udp_port_alloc_resp(r_saddr.sin_addr.s_addr, - f_saddr.sin_port, - r_saddr.sin_port, - response) < 0) { - pthread_rwlock_rdlock(&ipcpi.state_lock); + if (ipcp_udp_port_alloc_resp(r_saddr.sin_addr.s_addr, f_saddr.sin_port, + r_saddr.sin_port, response) < 0) { pthread_rwlock_rdlock(&udp_data.flows_lock); clr_fd(skfd); pthread_rwlock_unlock(&udp_data.flows_lock); - pthread_rwlock_unlock(&ipcpi.state_lock); - return -1; } @@ -1153,14 +1046,6 @@ static int ipcp_udp_flow_dealloc(int fd) ipcp_flow_fini(fd); - pthread_rwlock_rdlock(&ipcpi.state_lock); - - if (ipcp_get_state() != IPCP_OPERATIONAL) { - pthread_rwlock_unlock(&ipcpi.state_lock); - log_dbg("Won't register with non-enrolled IPCP."); - return -1; /* -ENOTENROLLED */ - } - pthread_rwlock_wrlock(&udp_data.flows_lock); flow_set_del(udp_data.np1_flows, fd); @@ -1179,7 +1064,6 @@ static int ipcp_udp_flow_dealloc(int fd) clr_fd(skfd); pthread_rwlock_unlock(&udp_data.flows_lock); - pthread_rwlock_unlock(&ipcpi.state_lock); flow_dealloc(fd); @@ -1191,9 +1075,9 @@ static int ipcp_udp_flow_dealloc(int fd) static struct ipcp_ops udp_ops = { .ipcp_bootstrap = ipcp_udp_bootstrap, .ipcp_enroll = NULL, /* shim */ - .ipcp_name_reg = ipcp_udp_name_reg, - .ipcp_name_unreg = ipcp_udp_name_unreg, - .ipcp_name_query = ipcp_udp_name_query, + .ipcp_reg = ipcp_udp_reg, + .ipcp_unreg = ipcp_udp_unreg, + .ipcp_query = ipcp_udp_query, .ipcp_flow_alloc = ipcp_udp_flow_alloc, .ipcp_flow_alloc_resp = ipcp_udp_flow_alloc_resp, .ipcp_flow_dealloc = ipcp_udp_flow_dealloc @@ -1202,26 +1086,6 @@ static struct ipcp_ops udp_ops = { int main(int argc, char * argv[]) { - struct sigaction sig_act; - sigset_t sigset; - sigemptyset(&sigset); - sigaddset(&sigset, SIGINT); - sigaddset(&sigset, SIGQUIT); - sigaddset(&sigset, SIGHUP); - sigaddset(&sigset, SIGPIPE); - - /* init sig_act */ - memset(&sig_act, 0, sizeof(sig_act)); - - /* install signal traps */ - sig_act.sa_sigaction = &ipcp_sig_handler; - sig_act.sa_flags = SA_SIGINFO; - - sigaction(SIGINT, &sig_act, NULL); - sigaction(SIGTERM, &sig_act, NULL); - sigaction(SIGHUP, &sig_act, NULL); - sigaction(SIGPIPE, &sig_act, NULL); - if (ipcp_init(argc, argv, THIS_TYPE, &udp_ops) < 0) { ipcp_create_r(getpid(), -1); exit(EXIT_FAILURE); @@ -1234,9 +1098,6 @@ int main(int argc, exit(EXIT_FAILURE); } - - pthread_sigmask(SIG_BLOCK, &sigset, NULL); - if (ipcp_boot() < 0) { log_err("Failed to boot IPCP."); ipcp_create_r(getpid(), -1); @@ -1245,8 +1106,6 @@ int main(int argc, exit(EXIT_FAILURE); } - pthread_sigmask(SIG_UNBLOCK, &sigset, NULL); - if (ipcp_create_r(getpid(), 0)) { log_err("Failed to notify IRMd we are initialized."); ipcp_set_state(IPCP_NULL); diff --git a/src/ipcpd/shim-udp/shim_udp_messages.proto b/src/ipcpd/shim-udp/shim_udp_messages.proto index 75f0cb64..ae89a119 100644 --- a/src/ipcpd/shim-udp/shim_udp_messages.proto +++ b/src/ipcpd/shim-udp/shim_udp_messages.proto @@ -29,10 +29,9 @@ enum shim_udp_msg_code { message shim_udp_msg { required shim_udp_msg_code code = 1; - optional string dst_name = 2; - optional string src_ae_name = 4; - required uint32 src_udp_port = 5; - optional uint32 dst_udp_port = 6; - optional uint32 qoscube = 7; - optional sint32 response = 8; + optional bytes hash = 2; + required uint32 src_udp_port = 3; + optional uint32 dst_udp_port = 4; + optional uint32 qoscube = 5; + optional sint32 response = 6; }; diff --git a/src/ipcpd/shim-udp/tests/shim_udp_test.c b/src/ipcpd/shim-udp/tests/shim_udp_test.c index d7bd0bb7..015bb49f 100644 --- a/src/ipcpd/shim-udp/tests/shim_udp_test.c +++ b/src/ipcpd/shim-udp/tests/shim_udp_test.c @@ -21,7 +21,7 @@ */ #include <ouroboros/config.h> -#include <ouroboros/dif_config.h> +#include <ouroboros/ipcp.h> #include <ouroboros/utils.h> #include <ouroboros/shm_du_map.h> #include <sys/types.h> @@ -41,7 +41,7 @@ int shim_udp_test(int argc, char ** argv) char bogus[16]; memset(&bogus, 0, 16); - struct dif_config conf; + struct ipcp_config conf; memset(&conf, 0, sizeof conf); conf.dif_name = strdup("test-dif"); conf.type = IPCP_SHIM_UDP; diff --git a/src/irmd/apn_table.c b/src/irmd/apn_table.c index d265e2f0..c77e7128 100644 --- a/src/irmd/apn_table.c +++ b/src/irmd/apn_table.c @@ -21,7 +21,7 @@ */ #include <ouroboros/errno.h> -#include <ouroboros/irm_config.h> +#include <ouroboros/irm.h> #include "apn_table.h" #include "utils.h" diff --git a/src/irmd/ipcp.c b/src/irmd/ipcp.c index eb0c2de0..f0e57dc8 100644 --- a/src/irmd/ipcp.c +++ b/src/irmd/ipcp.c @@ -104,15 +104,15 @@ ipcp_msg_t * send_recv_ipcp_msg(pid_t api, return recv_msg; } -pid_t ipcp_create(char * name, +pid_t ipcp_create(const char * name, enum ipcp_type ipcp_type) { - pid_t api = -1; - char irmd_api[10]; - size_t len = 0; - char * ipcp_dir = "/sbin/"; + pid_t api = -1; + size_t len = 0; + char * ipcp_dir = "/sbin/"; char * full_name = NULL; char * exec_name = NULL; + char irmd_api[10]; char * argv[5]; sprintf(irmd_api, "%u", getpid()); @@ -157,13 +157,11 @@ pid_t ipcp_create(char * name, /* log_file to be placed at the end */ argv[0] = full_name; argv[1] = irmd_api; - argv[2] = name; - if (log_syslog) { + argv[2] = (char *) name; + if (log_syslog) argv[3] = "1"; - argv[4] = NULL; - } else { + else argv[3] = NULL; - } argv[4] = NULL; @@ -187,7 +185,7 @@ int ipcp_destroy(pid_t api) } int ipcp_bootstrap(pid_t api, - dif_config_msg_t * conf) + ipcp_config_msg_t * conf) { ipcp_msg_t msg = IPCP_MSG__INIT; ipcp_msg_t * recv_msg = NULL; @@ -201,11 +199,11 @@ int ipcp_bootstrap(pid_t api, recv_msg = send_recv_ipcp_msg(api, &msg); if (recv_msg == NULL) - return -1; + return -EIPCP; if (recv_msg->has_result == false) { ipcp_msg__free_unpacked(recv_msg, NULL); - return -1; + return -EIPCP; } ret = recv_msg->result; @@ -214,26 +212,26 @@ int ipcp_bootstrap(pid_t api, return ret; } -int ipcp_enroll(pid_t api, - char * dif_name) +int ipcp_enroll(pid_t api, + const char * dst) { ipcp_msg_t msg = IPCP_MSG__INIT; ipcp_msg_t * recv_msg = NULL; int ret = -1; - if (dif_name == NULL) + if (dst == NULL) return -EINVAL; - msg.code = IPCP_MSG_CODE__IPCP_ENROLL; - msg.dif_name = dif_name; + msg.code = IPCP_MSG_CODE__IPCP_ENROLL; + msg.dst_name = (char *) dst; recv_msg = send_recv_ipcp_msg(api, &msg); if (recv_msg == NULL) - return -1; + return -EIPCP; if (recv_msg->has_result == false) { ipcp_msg__free_unpacked(recv_msg, NULL); - return -1; + return -EIPCP; } ret = recv_msg->result; @@ -242,26 +240,28 @@ int ipcp_enroll(pid_t api, return ret; } -int ipcp_name_reg(pid_t api, - char * name) +int ipcp_reg(pid_t api, + const uint8_t * hash, + size_t len) { ipcp_msg_t msg = IPCP_MSG__INIT; ipcp_msg_t * recv_msg = NULL; int ret = -1; - if (name == NULL) - return -1; + assert(hash); - msg.code = IPCP_MSG_CODE__IPCP_NAME_REG; - msg.name = name; + msg.code = IPCP_MSG_CODE__IPCP_REG; + msg.has_hash = true; + msg.hash.len = len; + msg.hash.data = (uint8_t *)hash; recv_msg = send_recv_ipcp_msg(api, &msg); if (recv_msg == NULL) - return -1; + return -EIPCP; if (recv_msg->has_result == false) { ipcp_msg__free_unpacked(recv_msg, NULL); - return -1; + return -EIPCP; } ret = recv_msg->result; @@ -270,23 +270,26 @@ int ipcp_name_reg(pid_t api, return ret; } -int ipcp_name_unreg(pid_t api, - char * name) +int ipcp_unreg(pid_t api, + const uint8_t * hash, + size_t len) { ipcp_msg_t msg = IPCP_MSG__INIT; ipcp_msg_t * recv_msg = NULL; int ret = -1; - msg.code = IPCP_MSG_CODE__IPCP_NAME_UNREG; - msg.name = name; + msg.code = IPCP_MSG_CODE__IPCP_UNREG; + msg.has_hash = true; + msg.hash.len = len; + msg.hash.data = (uint8_t *) hash; recv_msg = send_recv_ipcp_msg(api, &msg); if (recv_msg == NULL) - return -1; + return -EIPCP; if (recv_msg->has_result == false) { ipcp_msg__free_unpacked(recv_msg, NULL); - return -1; + return -EIPCP; } ret = recv_msg->result; @@ -295,23 +298,26 @@ int ipcp_name_unreg(pid_t api, return ret; } -int ipcp_name_query(pid_t api, - char * name) +int ipcp_query(pid_t api, + const uint8_t * hash, + size_t len) { ipcp_msg_t msg = IPCP_MSG__INIT; ipcp_msg_t * recv_msg = NULL; int ret = -1; - msg.code = IPCP_MSG_CODE__IPCP_NAME_QUERY; - msg.name = name; + msg.code = IPCP_MSG_CODE__IPCP_QUERY; + msg.has_hash = true; + msg.hash.len = len; + msg.hash.data = (uint8_t *) hash; recv_msg = send_recv_ipcp_msg(api, &msg); if (recv_msg == NULL) - return -1; + return -EIPCP; if (recv_msg->has_result == false) { ipcp_msg__free_unpacked(recv_msg, NULL); - return -1; + return -EIPCP; } ret = recv_msg->result; @@ -320,35 +326,37 @@ int ipcp_name_query(pid_t api, return ret; } -int ipcp_flow_alloc(pid_t api, - int port_id, - pid_t n_api, - char * dst_name, - qoscube_t cube) +int ipcp_flow_alloc(pid_t api, + int port_id, + pid_t n_api, + const uint8_t * dst, + size_t len, + qoscube_t cube) { ipcp_msg_t msg = IPCP_MSG__INIT; ipcp_msg_t * recv_msg = NULL; int ret = -1; - if (dst_name == NULL) - return -EINVAL; + assert(dst); msg.code = IPCP_MSG_CODE__IPCP_FLOW_ALLOC; msg.has_port_id = true; msg.port_id = port_id; msg.has_api = true; msg.api = n_api; - msg.dst_name = dst_name; + msg.has_hash = true; + msg.hash.len = len; + msg.hash.data = (uint8_t *) dst; msg.has_qoscube = true; msg.qoscube = cube; recv_msg = send_recv_ipcp_msg(api, &msg); if (recv_msg == NULL) - return -1; + return -EIPCP; if (!recv_msg->has_result) { ipcp_msg__free_unpacked(recv_msg, NULL); - return -1; + return -EIPCP; } ret = recv_msg->result; @@ -376,11 +384,11 @@ int ipcp_flow_alloc_resp(pid_t api, recv_msg = send_recv_ipcp_msg(api, &msg); if (recv_msg == NULL) - return -1; + return -EIPCP; if (recv_msg->has_result == false) { ipcp_msg__free_unpacked(recv_msg, NULL); - return -1; + return -EIPCP; } ret = recv_msg->result; @@ -392,7 +400,6 @@ int ipcp_flow_alloc_resp(pid_t api, int ipcp_flow_dealloc(pid_t api, int port_id) { - ipcp_msg_t msg = IPCP_MSG__INIT; ipcp_msg_t * recv_msg = NULL; int ret = -1; diff --git a/src/irmd/ipcp.h b/src/irmd/ipcp.h index bb868191..11adad7d 100644 --- a/src/irmd/ipcp.h +++ b/src/irmd/ipcp.h @@ -20,40 +20,44 @@ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -#include <ouroboros/irm_config.h> +#include <ouroboros/ipcp.h> #include <ouroboros/sockets.h> #include <ouroboros/shared.h> #include <sys/types.h> -#ifndef OUROBOROS_IPCP_H -#define OUROBOROS_IPCP_H +#ifndef OUROBOROS_IRMD_IPCP_H +#define OUROBOROS_IRMD_IPCP_H -pid_t ipcp_create(char * name, +pid_t ipcp_create(const char * name, enum ipcp_type ipcp_type); int ipcp_destroy(pid_t api); -int ipcp_enroll(pid_t api, - char * dif_name); +int ipcp_enroll(pid_t api, + const char * dst); int ipcp_bootstrap(pid_t api, - dif_config_msg_t * conf); + ipcp_config_msg_t * conf); -int ipcp_name_reg(pid_t api, - char * name); +int ipcp_reg(pid_t api, + const uint8_t * hash, + size_t len); -int ipcp_name_unreg(pid_t api, - char * name); +int ipcp_unreg(pid_t api, + const uint8_t * hash, + size_t len); -int ipcp_name_query(pid_t api, - char * name); +int ipcp_query(pid_t api, + const uint8_t * hash, + size_t len); -int ipcp_flow_alloc(pid_t api, - int port_id, - pid_t n_api, - char * dst_name, - qoscube_t qos); +int ipcp_flow_alloc(pid_t api, + int port_id, + pid_t n_api, + const uint8_t * dst, + size_t len, + qoscube_t qos); int ipcp_flow_alloc_resp(pid_t api, int port_id, @@ -63,4 +67,4 @@ int ipcp_flow_alloc_resp(pid_t api, int ipcp_flow_dealloc(pid_t api, int port_id); -#endif /* OUROBOROS_IPCP_H */ +#endif /* OUROBOROS_IRMD_IPCP_H */ diff --git a/src/irmd/main.c b/src/irmd/main.c index 23acfcee..d24c0ba1 100644 --- a/src/irmd/main.c +++ b/src/irmd/main.c @@ -27,7 +27,8 @@ #include <ouroboros/sockets.h> #include <ouroboros/list.h> #include <ouroboros/utils.h> -#include <ouroboros/irm_config.h> +#include <ouroboros/hash.h> +#include <ouroboros/irm.h> #include <ouroboros/lockfile.h> #include <ouroboros/shm_flow_set.h> #include <ouroboros/shm_rbuff.h> @@ -36,6 +37,7 @@ #include <ouroboros/qos.h> #include <ouroboros/time_utils.h> #include <ouroboros/logs.h> +#include <ouroboros/sha3.h> #include "utils.h" #include "registry.h" @@ -62,6 +64,8 @@ struct ipcp_entry { char * name; pid_t api; enum ipcp_type type; + uint16_t dir_hash_len; + /* FIXME: add an enum to specify hash algo */ char * dif_name; pthread_cond_t init_cond; @@ -223,48 +227,33 @@ static struct ipcp_entry * get_ipcp_entry_by_name(const char * name) return NULL; } -/* Check if the name exists anywhere in a DIF. */ -static pid_t get_ipcp_by_dst_name(char * dst_name) +/* + * Check if the hash is reachable anywhere in a DIF. + * FIXME: specify algorithm used + */ +static struct ipcp_entry * get_ipcp_by_dst_name(const char * name) { struct list_head * p = NULL; + uint8_t * hash; list_for_each(p, &irmd.ipcps) { struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); - if (e->type == IPCP_LOCAL) { - if (ipcp_name_query(e->api, dst_name) == 0) - return e->api; - } - } + hash = malloc(e->dir_hash_len); + if (hash == NULL) + return NULL; - list_for_each(p, &irmd.ipcps) { - struct ipcp_entry * e = - list_entry(p, struct ipcp_entry, next); - if (e->type == IPCP_NORMAL) { - if (ipcp_name_query(e->api, dst_name) == 0) - return e->api; - } - } + get_hash(hash, name); - list_for_each(p, &irmd.ipcps) { - struct ipcp_entry * e = - list_entry(p, struct ipcp_entry, next); - if (e->type == IPCP_SHIM_ETH_LLC) { - if (ipcp_name_query(e->api, dst_name) == 0) - return e->api; + if (ipcp_query(e->api, hash, e->dir_hash_len) == 0) { + free(hash); + return e; } - } - list_for_each(p, &irmd.ipcps) { - struct ipcp_entry * e = - list_entry(p, struct ipcp_entry, next); - if (e->type == IPCP_SHIM_UDP) { - if (ipcp_name_query(e->api, dst_name) == 0) - return e->api; - } + free(hash); } - return -1; + return NULL; } static pid_t create_ipcp(char * name, @@ -317,14 +306,16 @@ static pid_t create_ipcp(char * name, tmp->dif_name = NULL; tmp->type = ipcp_type; tmp->init = false; + /* FIXME: ipcp dir_hash_len should be configurable */ + tmp->dir_hash_len = SHA3_256_HASH_LEN; list_for_each(p, &irmd.ipcps) { struct ipcp_entry * e = list_entry(p, struct ipcp_entry, next); - if (e->type < ipcp_type) + if (e->type > ipcp_type) break; } - list_add(&tmp->next, &irmd.ipcps); + list_add_tail(&tmp->next, &irmd.ipcps); list_add(&api->next, &irmd.spawned_apis); @@ -411,7 +402,7 @@ static int destroy_ipcp(pid_t api) } static int bootstrap_ipcp(pid_t api, - dif_config_msg_t * conf) + ipcp_config_msg_t * conf) { struct ipcp_entry * entry = NULL; @@ -709,16 +700,18 @@ static ssize_t list_ipcps(char * name, return count; } -static int name_reg(char * name, - char ** difs, - size_t len) +static int name_reg(const char * name, + char ** difs, + size_t len) { size_t i; int ret = 0; struct list_head * p = NULL; - if (name == NULL || difs == NULL || len == 0 || difs[0] == NULL) - return -EINVAL; + assert(name); + assert(len); + assert(difs); + assert(difs[0]); pthread_rwlock_wrlock(&irmd.reg_lock); @@ -729,7 +722,7 @@ static int name_reg(char * name, if (!registry_has_name(&irmd.registry, name)) { struct reg_entry * re = - registry_add_name(&irmd.registry, strdup(name)); + registry_add_name(&irmd.registry, name); if (re == NULL) { log_err("Failed creating registry entry for %s.", name); pthread_rwlock_unlock(&irmd.reg_lock); @@ -768,12 +761,21 @@ static int name_reg(char * name, continue; for (i = 0; i < len; ++i) { + uint8_t * hash; + if (wildcard_match(difs[i], e->dif_name)) continue; - if (ipcp_name_reg(e->api, name)) { - log_err("Could not register %s in DIF %s.", - name, e->dif_name); + hash = malloc(e->dir_hash_len); + if (hash == NULL) + break; + + get_hash(hash, name); + + if (ipcp_reg(e->api, hash, e->dir_hash_len)) { + log_err("Could not register " HASH_FMT + " in DIF %s.", + HASH_VAL(hash), e->dif_name); } else { if (registry_add_name_to_dif(&irmd.registry, name, @@ -782,10 +784,12 @@ static int name_reg(char * name, log_warn("Registered unbound name %s. " "Registry may be corrupt.", name); - log_info("Registered %s in %s as %s.", - name, e->dif_name, name); + log_info("Registered %s in %s as " HASH_FMT ".", + name, e->dif_name, HASH_VAL(hash)); ++ret; } + + free(hash); } } @@ -794,16 +798,18 @@ static int name_reg(char * name, return (ret > 0 ? 0 : -1); } -static int name_unreg(char * name, - char ** difs, - size_t len) +static int name_unreg(const char * name, + char ** difs, + size_t len) { size_t i; int ret = 0; struct list_head * pos = NULL; - if (name == NULL || len == 0 || difs == NULL || difs[0] == NULL) - return -1; + assert(name); + assert(len); + assert(difs); + assert(difs[0]); pthread_rwlock_wrlock(&irmd.reg_lock); @@ -815,10 +821,18 @@ static int name_unreg(char * name, continue; for (i = 0; i < len; ++i) { + uint8_t * hash; + if (wildcard_match(difs[i], e->dif_name)) continue; - if (ipcp_name_unreg(e->api, name)) { + hash = malloc(e->dir_hash_len); + if (hash == NULL) + break; + + get_hash(hash, name); + + if (ipcp_unreg(e->api, hash, e->dir_hash_len)) { log_err("Could not unregister %s in DIF %s.", name, e->dif_name); } else { @@ -829,6 +843,8 @@ static int name_unreg(char * name, name, e->dif_name); ++ret; } + + free(hash); } } @@ -1038,22 +1054,23 @@ static int flow_accept(pid_t api, } static int flow_alloc(pid_t api, - char * dst_name, + const char * dst, qoscube_t cube, struct timespec * timeo, struct irm_flow ** e) { - struct irm_flow * f; - pid_t ipcp; - int port_id; - int state; + struct irm_flow * f; + struct ipcp_entry * ipcp; + int port_id; + int state; + uint8_t * hash; pthread_rwlock_rdlock(&irmd.reg_lock); - ipcp = get_ipcp_by_dst_name(dst_name); - if (ipcp == -1) { + ipcp = get_ipcp_by_dst_name(dst); + if (ipcp == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); - log_info("Destination unreachable."); + log_info("Destination %s unreachable.", dst); return -1; } @@ -1066,7 +1083,7 @@ static int flow_alloc(pid_t api, return -EBADF; } - f = irm_flow_create(api, ipcp, port_id, cube); + f = irm_flow_create(api, ipcp->api, port_id, cube); if (f == NULL) { bmp_release(irmd.port_ids, port_id); pthread_rwlock_unlock(&irmd.flows_lock); @@ -1080,12 +1097,24 @@ static int flow_alloc(pid_t api, assert(irm_flow_get_state(f) == FLOW_ALLOC_PENDING); - if (ipcp_flow_alloc(ipcp, port_id, api, dst_name, cube)) { + hash = malloc(ipcp->dir_hash_len); + if (hash == NULL) { + /* sanitizer cleans this */ + return -ENOMEM; + } + + get_hash(hash, dst); + + if (ipcp_flow_alloc(ipcp->api, port_id, api, hash, + ipcp->dir_hash_len, cube)) { /* sanitizer cleans this */ log_info("Flow_allocation failed."); + free(hash); return -EAGAIN; } + free(hash); + state = irm_flow_wait_state(f, FLOW_ALLOCATED, timeo); if (state != FLOW_ALLOCATED) { if (state == -ETIMEDOUT) { @@ -1093,7 +1122,7 @@ static int flow_alloc(pid_t api, return -ETIMEDOUT; } - log_info("Pending flow to %s torn down.", dst_name); + log_info("Pending flow to %s torn down.", dst); return -EPIPE; } @@ -1191,38 +1220,49 @@ static pid_t auto_execute(char ** argv) exit(EXIT_FAILURE); } -static struct irm_flow * flow_req_arr(pid_t api, - char * dst_name, - qoscube_t cube) +static struct irm_flow * flow_req_arr(pid_t api, + const uint8_t * hash, + qoscube_t cube) { struct reg_entry * re = NULL; struct apn_entry * a = NULL; struct api_entry * e = NULL; struct irm_flow * f = NULL; - struct pid_el * c_api; - pid_t h_api = -1; - int port_id = -1; + struct pid_el * c_api; + struct ipcp_entry * ipcp; + pid_t h_api = -1; + int port_id = -1; struct timespec wt = {IRMD_REQ_ARR_TIMEOUT / 1000, (IRMD_REQ_ARR_TIMEOUT % 1000) * MILLION}; - log_dbg("Flow req arrived from IPCP %d for %s.", api, dst_name); + log_dbg("Flow req arrived from IPCP %d for " HASH_FMT ".", + api, HASH_VAL(hash)); pthread_rwlock_rdlock(&irmd.reg_lock); - re = registry_get_entry(&irmd.registry, dst_name); + ipcp = get_ipcp_entry_by_api(api); + if (ipcp == NULL) { + log_err("IPCP died."); + return NULL; + } + + re = registry_get_entry_by_hash(&irmd.registry, hash, + ipcp->dir_hash_len); if (re == NULL) { pthread_rwlock_unlock(&irmd.reg_lock); - log_err("Unknown name: %s.", dst_name); + log_err("Unknown hash: " HASH_FMT ".", HASH_VAL(hash)); return NULL; } + log_info("Flow request arrived for %s.", re->name); + pthread_rwlock_unlock(&irmd.reg_lock); /* Give the AP a bit of slop time to call accept */ if (reg_entry_leave_state(re, REG_NAME_IDLE, &wt) == -1) { - log_err("No APs for %s.", dst_name); + log_err("No APs for " HASH_FMT ".", HASH_VAL(hash)); return NULL; } @@ -1231,7 +1271,7 @@ static struct irm_flow * flow_req_arr(pid_t api, switch (reg_entry_get_state(re)) { case REG_NAME_IDLE: pthread_rwlock_unlock(&irmd.reg_lock); - log_err("No APs for %s.", dst_name); + log_err("No APs for " HASH_FMT ".", HASH_VAL(hash)); return NULL; case REG_NAME_AUTO_ACCEPT: c_api = malloc(sizeof(*c_api)); @@ -1830,7 +1870,7 @@ void * mainloop(void * o) break; case IRM_MSG_CODE__IPCP_FLOW_REQ_ARR: e = flow_req_arr(msg->api, - msg->dst_name, + msg->hash.data, msg->qoscube); ret_msg.has_result = true; if (e == NULL) { diff --git a/src/irmd/registry.c b/src/irmd/registry.c index 53be77cd..71e6ea8a 100644 --- a/src/irmd/registry.c +++ b/src/irmd/registry.c @@ -25,8 +25,9 @@ #include <ouroboros/config.h> #include <ouroboros/errno.h> #include <ouroboros/logs.h> -#include <ouroboros/irm_config.h> +#include <ouroboros/irm.h> #include <ouroboros/time_utils.h> +#include <ouroboros/hash.h> #include "registry.h" #include "utils.h" @@ -145,7 +146,8 @@ static void reg_entry_destroy(struct reg_entry * e) free(e); } -static bool reg_entry_is_local_in_dif(struct reg_entry * e, char * dif_name) +static bool reg_entry_is_local_in_dif(struct reg_entry * e, + const char * dif_name) { struct list_head * p = NULL; @@ -159,7 +161,7 @@ static bool reg_entry_is_local_in_dif(struct reg_entry * e, char * dif_name) } static int reg_entry_add_local_in_dif(struct reg_entry * e, - char * dif_name, + const char * dif_name, enum ipcp_type type) { if (!reg_entry_is_local_in_dif(e, dif_name)) { @@ -176,7 +178,7 @@ static int reg_entry_add_local_in_dif(struct reg_entry * e, } static void reg_entry_del_local_from_dif(struct reg_entry * e, - char * dif_name) + const char * dif_name) { struct list_head * p = NULL; struct list_head * h = NULL; @@ -192,7 +194,7 @@ static void reg_entry_del_local_from_dif(struct reg_entry * e, } static bool reg_entry_has_apn(struct reg_entry * e, - char * apn) + const char * apn) { struct list_head * p; @@ -242,7 +244,7 @@ int reg_entry_add_apn(struct reg_entry * e, } void reg_entry_del_apn(struct reg_entry * e, - char * apn) + const char * apn) { struct list_head * p = NULL; struct list_head * h = NULL; @@ -504,9 +506,9 @@ int reg_entry_wait_state(struct reg_entry * e, } struct reg_entry * registry_get_entry(struct list_head * registry, - char * name) + const char * name) { - struct list_head * p = NULL; + struct list_head * p = NULL; assert(registry); @@ -519,8 +521,33 @@ struct reg_entry * registry_get_entry(struct list_head * registry, return NULL; } +struct reg_entry * registry_get_entry_by_hash(struct list_head * registry, + const uint8_t * hash, + size_t len) +{ + struct list_head * p = NULL; + uint8_t * thash; + + thash = malloc(len); + if (thash == NULL) + return NULL; + + assert(registry); + + list_for_each(p, registry) { + struct reg_entry * e = list_entry(p, struct reg_entry, next); + get_hash(thash, e->name); + if (memcmp(thash, hash, len) == 0) { + free(thash); + return e; + } + } + + return NULL; +} + struct reg_entry * registry_add_name(struct list_head * registry, - char * name) + const char * name) { struct reg_entry * e = NULL; @@ -538,7 +565,7 @@ struct reg_entry * registry_add_name(struct list_head * registry, return NULL; } - e = reg_entry_init(e, name); + e = reg_entry_init(e, strdup(name)); if (e == NULL) { log_dbg("Could not initialize registry entry."); reg_entry_destroy(e); @@ -551,7 +578,7 @@ struct reg_entry * registry_add_name(struct list_head * registry, } void registry_del_name(struct list_head * registry, - char * name) + const char * name) { struct reg_entry * e = registry_get_entry(registry, name); if (e == NULL) @@ -583,8 +610,8 @@ void registry_del_api(struct list_head * registry, } int registry_add_name_to_dif(struct list_head * registry, - char * name, - char * dif_name, + const char * name, + const char * dif_name, enum ipcp_type type) { struct reg_entry * re = registry_get_entry(registry, name); @@ -595,8 +622,8 @@ int registry_add_name_to_dif(struct list_head * registry, } void registry_del_name_from_dif(struct list_head * registry, - char * name, - char * dif_name) + const char * name, + const char * dif_name) { struct reg_entry * re = registry_get_entry(registry, name); if (re == NULL) diff --git a/src/irmd/registry.h b/src/irmd/registry.h index 08e78019..771ca83c 100644 --- a/src/irmd/registry.h +++ b/src/irmd/registry.h @@ -24,8 +24,8 @@ #define OUROBOROS_IRMD_REGISTRY_H #include <ouroboros/config.h> +#include <ouroboros/ipcp.h> #include <ouroboros/list.h> -#include <ouroboros/irm_config.h> #include <ouroboros/shared.h> #include "api_table.h" @@ -71,7 +71,7 @@ int reg_entry_add_apn(struct reg_entry * e, struct apn_entry * a); void reg_entry_del_apn(struct reg_entry * e, - char * apn); + const char * apn); char * reg_entry_get_apn(struct reg_entry * e); @@ -101,10 +101,10 @@ int reg_entry_wait_state(struct reg_entry * e, struct timespec * timeout); struct reg_entry * registry_add_name(struct list_head * registry, - char * name); + const char * name); void registry_del_name(struct list_head * registry, - char * name); + const char * name); void registry_del_api(struct list_head * registry, pid_t api); @@ -112,16 +112,20 @@ void registry_del_api(struct list_head * registry, void registry_sanitize_apis(struct list_head * registry); struct reg_entry * registry_get_entry(struct list_head * registry, - char * name); + const char * name); + +struct reg_entry * registry_get_entry_by_hash(struct list_head * registry, + const uint8_t * hash, + size_t len); int registry_add_name_to_dif(struct list_head * registry, - char * name, - char * dif_name, + const char * name, + const char * dif_name, enum ipcp_type type); void registry_del_name_from_dif(struct list_head * registry, - char * name, - char * dif_name); + const char * name, + const char * dif_name); void registry_destroy(struct list_head * registry); diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt index f6a30ef7..cb94ef53 100644 --- a/src/lib/CMakeLists.txt +++ b/src/lib/CMakeLists.txt @@ -7,7 +7,7 @@ include_directories(${CMAKE_BINARY_DIR}/include) protobuf_generate_c(IRM_PROTO_SRCS IRM_PROTO_HDRS irmd_messages.proto) protobuf_generate_c(IPCP_PROTO_SRCS IPCP_PROTO_HDRS ipcpd_messages.proto) protobuf_generate_c(DIF_CONFIG_PROTO_SRCS DIF_CONFIG_PROTO_HDRS - dif_config.proto) + ipcp_config.proto) protobuf_generate_c(CDAP_PROTO_SRCS CDAP_PROTO_HDRS cdap.proto) protobuf_generate_c(RO_PROTO_SRCS RO_PROTO_HDRS ro.proto) protobuf_generate_c(CACEP_PROTO_SRCS CACEP_PROTO_HDRS cacep.proto) @@ -35,6 +35,7 @@ set(SOURCE_FILES cdap_req.c crc32.c dev.c + hash.c hashtable.c irm.c list.c diff --git a/src/lib/btree.c b/src/lib/btree.c index 48df8e39..03047a18 100644 --- a/src/lib/btree.c +++ b/src/lib/btree.c @@ -22,8 +22,7 @@ */ #include <ouroboros/errno.h> - -#include "btree.h" +#include <ouroboros/btree.h> #include <stdlib.h> #include <stdbool.h> diff --git a/src/lib/dev.c b/src/lib/dev.c index 18890234..d68fb471 100644 --- a/src/lib/dev.c +++ b/src/lib/dev.c @@ -1210,7 +1210,8 @@ int ipcp_create_r(pid_t api, } int ipcp_flow_req_arr(pid_t api, - char * dst_name, + uint8_t * dst, + size_t len, qoscube_t cube) { irm_msg_t msg = IRM_MSG__INIT; @@ -1218,13 +1219,15 @@ int ipcp_flow_req_arr(pid_t api, int port_id = -1; int fd = -1; - if (dst_name == NULL) + if (dst == NULL) return -EINVAL; msg.code = IRM_MSG_CODE__IPCP_FLOW_REQ_ARR; msg.has_api = true; msg.api = api; - msg.dst_name = dst_name; + msg.has_hash = true; + msg.hash.len = len; + msg.hash.data = dst; msg.has_qoscube = true; msg.qoscube = cube; diff --git a/src/lib/btree.h b/src/lib/hash.c index f7c293c5..f4fd75ea 100644 --- a/src/lib/btree.h +++ b/src/lib/hash.c @@ -1,11 +1,14 @@ /* * Ouroboros - Copyright (C) 2016 - 2017 * - * B-trees + * Hashing * * Dimitri Staessens <dimitri.staessens@ugent.be> * Sander Vrijders <sander.vrijders@ugent.be> * + * This implementation is adapted and redistributed from the RHASH + * project + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * version 2.1 as published by the Free Software Foundation. @@ -21,27 +24,20 @@ * 02110-1301 USA */ -#ifndef OUROBOROS_LIB_BTREE_H -#define OUROBOROS_LIB_BTREE_H - -#include <stddef.h> -#include <stdint.h> - -struct btree; - -/* Create a B-tree of order k */ -struct btree * btree_create(size_t k); +#include <ouroboros/config.h> +#include <ouroboros/hash.h> -void btree_destroy(struct btree * tree); +#include <string.h> -int btree_insert(struct btree * tree, - uint32_t key, - void * val); +void get_hash(uint8_t buf[], + const char * name) +{ + /* currently we only support 256 bit SHA-3 */ + struct sha3_ctx ctx; -int btree_remove(struct btree * tree, - uint32_t key); + rhash_sha3_256_init(&ctx); -void * btree_search(struct btree * tree, - uint32_t key); + rhash_sha3_update(&ctx, name, strlen(name)); -#endif /* OUROBOROS_LIB_BTREE_H */ + rhash_sha3_final(&ctx, buf); +} diff --git a/src/lib/dif_config.proto b/src/lib/ipcp_config.proto index d47af049..a0c14c41 100644 --- a/src/lib/dif_config.proto +++ b/src/lib/ipcp_config.proto @@ -23,24 +23,25 @@ syntax = "proto2"; -message dif_config_msg { +message ipcp_config_msg { required string dif_name = 1; - required int32 ipcp_type = 2; + required uint32 dir_hash_len = 2; + required int32 ipcp_type = 3; // Config for normal IPCP - optional uint32 addr_size = 3; - optional uint32 cep_id_size = 4; - optional uint32 pdu_length_size = 5; - optional uint32 seqno_size = 6; - optional bool has_ttl = 7; - optional bool has_chk = 8; - optional uint32 min_pdu_size = 9; - optional uint32 max_pdu_size = 10; - optional uint32 addr_auth_type = 11; - optional uint32 dt_gam_type = 12; - optional uint32 rm_gam_type = 13; + optional uint32 addr_size = 4; + optional uint32 cep_id_size = 5; + optional uint32 pdu_length_size = 6; + optional uint32 seqno_size = 7; + optional bool has_ttl = 8; + optional bool has_chk = 9; + optional uint32 min_pdu_size = 10; + optional uint32 max_pdu_size = 11; + optional uint32 addr_auth_type = 12; + optional uint32 dt_gam_type = 13; + optional uint32 rm_gam_type = 14; // Config for shim UDP - optional uint32 ip_addr = 14; - optional uint32 dns_addr = 15; + optional uint32 ip_addr = 15; + optional uint32 dns_addr = 16; // Config for the shim Ethernet LLC - optional string if_name = 16; + optional string if_name = 17; }
\ No newline at end of file diff --git a/src/lib/ipcpd_messages.proto b/src/lib/ipcpd_messages.proto index da817944..bd71d3f3 100644 --- a/src/lib/ipcpd_messages.proto +++ b/src/lib/ipcpd_messages.proto @@ -23,14 +23,14 @@ syntax = "proto2"; -import "dif_config.proto"; +import "ipcp_config.proto"; enum ipcp_msg_code { IPCP_BOOTSTRAP = 1; IPCP_ENROLL = 2; - IPCP_NAME_REG = 3; - IPCP_NAME_UNREG = 4; - IPCP_NAME_QUERY = 5; + IPCP_REG = 3; + IPCP_UNREG = 4; + IPCP_QUERY = 5; IPCP_FLOW_ALLOC = 6; IPCP_FLOW_ALLOC_RESP = 7; IPCP_FLOW_DEALLOC = 8; @@ -38,17 +38,14 @@ enum ipcp_msg_code { }; message ipcp_msg { - required ipcp_msg_code code = 1; - optional string dif_name = 2; - repeated string dif_names = 3; - optional int32 len = 4; - optional string name = 5; - optional sint32 port_id = 6; - optional string dst_name = 7; - optional sint32 qoscube = 8; - optional dif_config_msg conf = 9; - optional sint32 fd = 10; - optional sint32 api = 11; - optional sint32 response = 12; - optional sint32 result = 13; + required ipcp_msg_code code = 1; + optional string name = 2; + optional bytes hash = 3; + optional int32 port_id = 4; + optional string dst_name = 5; + optional uint32 qoscube = 6; + optional ipcp_config_msg conf = 7; + optional int32 api = 8; + optional int32 response = 9; + optional int32 result = 10; }; diff --git a/src/lib/irm.c b/src/lib/irm.c index 57e09369..a2fd5d0b 100644 --- a/src/lib/irm.c +++ b/src/lib/irm.c @@ -87,13 +87,13 @@ int irm_destroy_ipcp(pid_t api) return ret; } -int irm_bootstrap_ipcp(pid_t api, - const struct dif_config * conf) +int irm_bootstrap_ipcp(pid_t api, + const struct ipcp_config * conf) { - irm_msg_t msg = IRM_MSG__INIT; - dif_config_msg_t config = DIF_CONFIG_MSG__INIT; - irm_msg_t * recv_msg = NULL; - int ret = -1; + irm_msg_t msg = IRM_MSG__INIT; + ipcp_config_msg_t config = IPCP_CONFIG_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int ret = -1; if (api == -1 || conf == NULL) return -EINVAL; @@ -105,6 +105,7 @@ int irm_bootstrap_ipcp(pid_t api, msg.conf = &config; config.dif_name = conf->dif_name; config.ipcp_type = conf->type; + config.dir_hash_len = (uint16_t) conf->dir_hash_len; switch (conf->type) { case IPCP_NORMAL: diff --git a/src/lib/irmd_messages.proto b/src/lib/irmd_messages.proto index e218f6f6..138810da 100644 --- a/src/lib/irmd_messages.proto +++ b/src/lib/irmd_messages.proto @@ -23,7 +23,7 @@ syntax = "proto2"; -import "dif_config.proto"; +import "ipcp_config.proto"; enum irm_msg_code { IRM_CREATE_IPCP = 1; @@ -48,20 +48,21 @@ enum irm_msg_code { }; message irm_msg { - required irm_msg_code code = 1; - optional string ap_name = 2; - optional sint32 api = 3; - optional uint32 ipcp_type = 4; - repeated string dif_name = 5; - repeated string args = 6; - optional sint32 response = 7; - optional string dst_name = 8; - optional sint32 port_id = 9; - optional sint32 qoscube = 10; - optional dif_config_msg conf = 11; - optional uint32 opts = 12; - repeated sint32 apis = 13; - optional uint32 timeo_sec = 14; - optional uint32 timeo_nsec = 15; - optional sint32 result = 16; + required irm_msg_code code = 1; + optional string ap_name = 2; + optional sint32 api = 3; + optional uint32 ipcp_type = 4; + repeated string dif_name = 5; + repeated string args = 6; + optional sint32 response = 7; + optional string dst_name = 8; + optional bytes hash = 9; + optional sint32 port_id = 10; + optional sint32 qoscube = 11; + optional ipcp_config_msg conf = 12; + optional uint32 opts = 13; + repeated sint32 apis = 14; + optional uint32 timeo_sec = 15; + optional uint32 timeo_nsec = 16; + optional sint32 result = 17; }; diff --git a/src/lib/rib.c b/src/lib/rib.c index d39a17d2..2645e90b 100644 --- a/src/lib/rib.c +++ b/src/lib/rib.c @@ -29,9 +29,8 @@ #include <ouroboros/bitmap.h> #include <ouroboros/crc32.h> #include <ouroboros/time_utils.h> - -#include "sha3.h" -#include "btree.h" +#include <ouroboros/sha3.h> +#include <ouroboros/btree.h> #include "ro.pb-c.h" typedef RoMsg ro_msg_t; @@ -94,7 +93,7 @@ struct rnode { uint8_t * data; size_t len; - uint8_t sha3[sha3_256_hash_size]; + uint8_t sha3[SHA3_256_HASH_LEN]; struct rnode * parent; @@ -142,7 +141,7 @@ static void rnode_hash(struct rnode * node) list_for_each(p, &node->children) { struct child * c = list_entry(p, struct child, next); - rhash_sha3_update(&ctx, c->node->sha3, sha3_256_hash_size); + rhash_sha3_update(&ctx, c->node->sha3, SHA3_256_HASH_LEN); } rhash_sha3_final(&ctx, node->sha3); @@ -654,7 +653,7 @@ int rib_write(const char * path, uint8_t * cdata; - if (path == NULL) + if (path == NULL || data == NULL || len == 0) return -EINVAL; cdata = malloc(len); @@ -666,8 +665,13 @@ int rib_write(const char * path, pthread_rwlock_rdlock(&rib.lock); node = find_rnode_by_path(path); - if (node != NULL) - rnode_update(node, cdata, len); + if (node == NULL) { + pthread_rwlock_unlock(&rib.lock); + free(cdata); + return -1; + } + + rnode_update(node, cdata, len); pthread_rwlock_unlock(&rib.lock); @@ -1226,7 +1230,7 @@ static ro_msg_t * rnode_pack(struct rnode * node, (flags & PACK_HASH_ALL)) { msg->has_hash = true; msg->hash.data = node->sha3; - msg->hash.len = sha3_256_hash_size; + msg->hash.len = SHA3_256_HASH_LEN; } if (node->data != NULL) { @@ -1407,7 +1411,7 @@ int rib_unpack(uint8_t * packed, if (ret == 0 && msg->has_hash) { root = rnode_get_child(root, msg->name); - if (memcmp(msg->hash.data, root->sha3, sha3_256_hash_size)) { + if (memcmp(msg->hash.data, root->sha3, SHA3_256_HASH_LEN)) { ro_msg__free_unpacked(msg, NULL); return -EFAULT; } diff --git a/src/lib/sha3.c b/src/lib/sha3.c index 750038f2..f80cc4bd 100644 --- a/src/lib/sha3.c +++ b/src/lib/sha3.c @@ -44,12 +44,11 @@ */ #include <ouroboros/endian.h> +#include <ouroboros/sha3.h> #include <assert.h> #include <string.h> -#include "sha3.h" - #define IS_ALIGNED_64(p) (0 == (7 & ((const uint8_t *) (p) \ - (const uint8_t *) 0))) #define I64(x) x##LL @@ -262,11 +261,12 @@ static void rhash_sha3_process_block(uint64_t hash[25], #define SHA3_FINALIZED 0x80000000 void rhash_sha3_update(struct sha3_ctx * ctx, - const uint8_t * msg, + const void * pmsg, size_t size) { size_t idx = (size_t) ctx->rest; size_t block_size = (size_t) ctx->block_size; + uint8_t * msg = (uint8_t *) pmsg; if (ctx->rest & SHA3_FINALIZED) return; ctx->rest = (unsigned) ((ctx->rest + size) % block_size); diff --git a/src/lib/sha3.h b/src/lib/sha3.h deleted file mode 100644 index 6ce67482..00000000 --- a/src/lib/sha3.h +++ /dev/null @@ -1,86 +0,0 @@ -/* - * Ouroboros - Copyright (C) 2016 - 2017 - * - * SHA3 algorithm - * - * Dimitri Staessens <dimitri.staessens@ugent.be> - * Sander Vrijders <sander.vrijders@ugent.be> - * - * This implementation is adapted and redistributed from the RHASH - * project implementation of the sha3 algorithm - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public License - * version 2.1 as published by the Free Software Foundation. - * - * This library 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA - * 02110-1301 USA - * - * -- original license - * - * sha3.c - an implementation of Secure Hash Algorithm 3 (Keccak). - * based on the - * The Keccak SHA-3 submission. Submission to NIST (Round 3), 2011 - * by Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles Van Assche - * - * Copyright: 2013 Aleksey Kravchenko <rhash.admin@gmail.com> - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so. - * - * 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. Use this program at your own risk! - */ - -#ifndef OUROBOROS_LIB_SHA3_H -#define OUROBOROS_LIB_SHA3_H - -#include <unistd.h> -#include <stdint.h> - -#define sha3_224_hash_size 28 -#define sha3_256_hash_size 32 -#define sha3_384_hash_size 48 -#define sha3_512_hash_size 64 -#define sha3_max_permutation_size 25 -#define sha3_max_rate_in_qwords 24 - -struct sha3_ctx { - /* 1600 bits algorithm hashing state */ - uint64_t hash[sha3_max_permutation_size]; - /* 1536-bit buffer for leftovers */ - uint64_t message[sha3_max_rate_in_qwords]; - /* count of bytes in the message[] buffer */ - unsigned rest; - /* size of a message block processed at once */ - unsigned block_size; -}; - -void rhash_sha3_224_init(struct sha3_ctx * ctx); - -void rhash_sha3_256_init(struct sha3_ctx * ctx); - -void rhash_sha3_384_init(struct sha3_ctx * ctx); - -void rhash_sha3_512_init(struct sha3_ctx * ctx); - -void rhash_sha3_update(struct sha3_ctx * ctx, - const uint8_t * msg, - size_t size); - -void rhash_sha3_final(struct sha3_ctx * ctx, - uint8_t * res); - -#endif /* OUROBOROS_LIB_SHA3_H */ diff --git a/src/lib/tests/btree_test.c b/src/lib/tests/btree_test.c index a6344060..83fafabd 100644 --- a/src/lib/tests/btree_test.c +++ b/src/lib/tests/btree_test.c @@ -21,7 +21,7 @@ */ -#include "btree.h" +#include <ouroboros/btree.h> #include <stdio.h> #include <stdlib.h> diff --git a/src/lib/tests/sha3_test.c b/src/lib/tests/sha3_test.c index 212452ef..8f1bce05 100644 --- a/src/lib/tests/sha3_test.c +++ b/src/lib/tests/sha3_test.c @@ -20,7 +20,7 @@ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -#include "sha3.h" +#include <ouroboros/sha3.h> #include <stdlib.h> #include <stdint.h> @@ -84,7 +84,7 @@ int sha3_test(int argc, struct sha3_ctx ctx; /* Storage for result. */ - uint8_t res[sha3_512_hash_size]; + uint8_t res[SHA3_512_HASH_LEN]; /* SHA3 test vectors */ char * str1_inp = "abc"; @@ -172,124 +172,124 @@ int sha3_test(int argc, printf("test: %s.\n\n", str1_inp); rhash_sha3_224_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str1_inp, strlen(str1_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str1_inp, strlen(str1_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str1_224, res, sha3_224_hash_size)) + if (check_hash(str1_224, res, SHA3_224_HASH_LEN)) return -1; rhash_sha3_256_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str1_inp, strlen(str1_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str1_inp, strlen(str1_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str1_256, res, sha3_256_hash_size)) + if (check_hash(str1_256, res, SHA3_256_HASH_LEN)) return -1; rhash_sha3_384_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str1_inp, strlen(str1_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str1_inp, strlen(str1_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str1_384, res, sha3_384_hash_size)) + if (check_hash(str1_384, res, SHA3_384_HASH_LEN)) return -1; rhash_sha3_512_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str1_inp, strlen(str1_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str1_inp, strlen(str1_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str1_512, res, sha3_512_hash_size)) + if (check_hash(str1_512, res, SHA3_512_HASH_LEN)) return -1; /* 2nd input string. */ printf("test: <empty string>.\n\n"); rhash_sha3_224_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str2_inp, strlen(str2_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str2_inp, strlen(str2_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str2_224, res, sha3_224_hash_size)) + if (check_hash(str2_224, res, SHA3_224_HASH_LEN)) return -1; rhash_sha3_256_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str2_inp, strlen(str2_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str2_inp, strlen(str2_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str2_256, res, sha3_256_hash_size)) + if (check_hash(str2_256, res, SHA3_256_HASH_LEN)) return -1; rhash_sha3_384_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str2_inp, strlen(str2_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str2_inp, strlen(str2_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str2_384, res, sha3_384_hash_size)) + if (check_hash(str2_384, res, SHA3_384_HASH_LEN)) return -1; rhash_sha3_512_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str2_inp, strlen(str2_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str2_inp, strlen(str2_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str2_512, res, sha3_512_hash_size)) + if (check_hash(str2_512, res, SHA3_512_HASH_LEN)) return -1; /* 3rd input string */ printf("test: %s.\n\n", str3_inp); rhash_sha3_224_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str3_inp, strlen(str3_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str3_inp, strlen(str3_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str3_224, res, sha3_224_hash_size)) + if (check_hash(str3_224, res, SHA3_224_HASH_LEN)) return -1; rhash_sha3_256_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str3_inp, strlen(str3_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str3_inp, strlen(str3_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str3_256, res, sha3_256_hash_size)) + if (check_hash(str3_256, res, SHA3_256_HASH_LEN)) return -1; rhash_sha3_384_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str3_inp, strlen(str3_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str3_inp, strlen(str3_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str3_384, res, sha3_384_hash_size)) + if (check_hash(str3_384, res, SHA3_384_HASH_LEN)) return -1; rhash_sha3_512_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str3_inp, strlen(str3_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str3_inp, strlen(str3_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str3_512, res, sha3_512_hash_size)) + if (check_hash(str3_512, res, SHA3_512_HASH_LEN)) return -1; /* 4th input string. */ printf("test: %s.\n\n", str4_inp); rhash_sha3_224_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str4_inp, strlen(str4_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str4_inp, strlen(str4_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str4_224, res, sha3_224_hash_size)) + if (check_hash(str4_224, res, SHA3_224_HASH_LEN)) return -1; rhash_sha3_256_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str4_inp, strlen(str4_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str4_inp, strlen(str4_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str4_256, res, sha3_256_hash_size)) + if (check_hash(str4_256, res, SHA3_256_HASH_LEN)) return -1; rhash_sha3_384_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str4_inp, strlen(str4_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str4_inp, strlen(str4_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str4_384, res, sha3_384_hash_size)) + if (check_hash(str4_384, res, SHA3_384_HASH_LEN)) return -1; rhash_sha3_512_init(&ctx); - rhash_sha3_update(&ctx, (uint8_t *) str4_inp, strlen(str4_inp)); - rhash_sha3_final(&ctx, (uint8_t *) res); + rhash_sha3_update(&ctx, str4_inp, strlen(str4_inp)); + rhash_sha3_final(&ctx, res); - if (check_hash(str4_512, res, sha3_512_hash_size)) + if (check_hash(str4_512, res, SHA3_512_HASH_LEN)) return -1; return 0; diff --git a/src/tools/irm/irm_ipcp_bootstrap.c b/src/tools/irm/irm_ipcp_bootstrap.c index ac52c6c1..489f98b9 100644 --- a/src/tools/irm/irm_ipcp_bootstrap.c +++ b/src/tools/irm/irm_ipcp_bootstrap.c @@ -28,7 +28,8 @@ #include <sys/socket.h> #endif #include <ouroboros/irm.h> -#include <ouroboros/irm_config.h> +#include <ouroboros/ipcp.h> +#include <ouroboros/hash.h> #include "irm_ops.h" #include "irm_utils.h" @@ -55,11 +56,12 @@ static void usage(void) { - /* FIXME: Add dif_config stuff */ + /* FIXME: Add ipcp_config stuff */ printf("Usage: irm ipcp bootstrap\n" " name <ipcp name>\n" " dif <DIF name>\n" - " type [TYPE]\n\n" + " type [TYPE]\n" +/* FIXME: add option to set hash algorithm and length for directory */ "where TYPE = {" NORMAL " " LOCAL " " SHIM_UDP " " SHIM_ETH_LLC"}\n\n" "if TYPE == " NORMAL "\n" @@ -92,7 +94,7 @@ int do_bootstrap_ipcp(int argc, char ** argv) { char * name = NULL; pid_t api; - struct dif_config conf; + struct ipcp_config conf; uint8_t addr_size = DEFAULT_ADDR_SIZE; uint8_t cep_id_size = DEFAULT_CEP_ID_SIZE; uint8_t pdu_length_size = DEFAULT_PDU_LEN_SIZE; @@ -112,6 +114,7 @@ int do_bootstrap_ipcp(int argc, char ** argv) pid_t * apis = NULL; ssize_t len = 0; int i = 0; + uint16_t dir_hash_len = SHA3_256_HASH_LEN; while (argc > 0) { if (matches(*argv, "type") == 0) { @@ -177,6 +180,7 @@ int do_bootstrap_ipcp(int argc, char ** argv) } conf.dif_name = dif_name; + conf.dir_hash_len = dir_hash_len; if (strcmp(ipcp_type, NORMAL) == 0) { conf.type = IPCP_NORMAL; |