From 373efaf24d3600fe4dadf6bfaaee8d19e2ec32d7 Mon Sep 17 00:00:00 2001 From: dimitri staessens Date: Mon, 6 Feb 2017 16:05:44 +0100 Subject: ipcpd, lib: Revise normal IPCP This PR updates the normal IPCP to use the new RIB. The old ribmgr is removed and replaced by a stub that needs to be implemented. All components (dir, fmgr, frct) were adapted to the new RIB API. A lot of functionality was moved outside of the ribmgr, such as the addr_auth, which is now a component of the IPCP. The address is also stored to the ipcpi struct. The irm tool has an option to set the gam policy of the rib manager. --- src/lib/dif_config.proto | 16 ++++++++-------- src/lib/irm.c | 4 ++-- 2 files changed, 10 insertions(+), 10 deletions(-) (limited to 'src/lib') diff --git a/src/lib/dif_config.proto b/src/lib/dif_config.proto index f1f8747b..d47af049 100644 --- a/src/lib/dif_config.proto +++ b/src/lib/dif_config.proto @@ -30,14 +30,14 @@ message dif_config_msg { optional uint32 addr_size = 3; optional uint32 cep_id_size = 4; optional uint32 pdu_length_size = 5; - optional uint32 qos_id_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 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; // Config for shim UDP optional uint32 ip_addr = 14; optional uint32 dns_addr = 15; diff --git a/src/lib/irm.c b/src/lib/irm.c index ade38b6f..8b312833 100644 --- a/src/lib/irm.c +++ b/src/lib/irm.c @@ -113,7 +113,6 @@ int irm_bootstrap_ipcp(pid_t api, config.has_addr_size = true; config.has_cep_id_size = true; config.has_pdu_length_size = true; - config.has_qos_id_size = true; config.has_seqno_size = true; config.has_has_ttl = true; config.has_has_chk = true; @@ -121,11 +120,11 @@ int irm_bootstrap_ipcp(pid_t api, config.has_max_pdu_size = true; config.has_addr_auth_type = true; config.has_dt_gam_type = true; + config.has_rm_gam_type = true; config.addr_size = conf->addr_size; config.cep_id_size = conf->cep_id_size; config.pdu_length_size = conf->pdu_length_size; - config.qos_id_size = conf->qos_id_size; config.seqno_size = conf->seqno_size; config.has_ttl = conf->has_ttl; config.has_chk = conf->has_chk; @@ -133,6 +132,7 @@ int irm_bootstrap_ipcp(pid_t api, config.max_pdu_size = conf->max_pdu_size; config.addr_auth_type = conf->addr_auth_type; config.dt_gam_type = conf->dt_gam_type; + config.rm_gam_type = conf->rm_gam_type; break; case IPCP_SHIM_UDP: config.has_ip_addr = true; -- cgit v1.2.3 From d64f05e8bf1277132b648bda2e1175ad8c1d2d5c Mon Sep 17 00:00:00 2001 From: dimitri staessens Date: Mon, 6 Feb 2017 21:48:00 +0100 Subject: ipcpd: Revise PCI manipulation in normal The pci function will store offsets to avoid having to recalculate them every time. TTL handling is removed from the fmgr, the TTL is automatically decreased when deserializing the PCI (or set to 1 if there is no TTL present so the PDU will be forwarded). The deserialisation function now takes a pointer to a struct pci as input to avoid memory allocation and release each time a PDU is processed. Some checks have been replaced with assert() and return values replaced with void where it makes sense. --- include/ouroboros/shm_rdrbuff.h | 4 +- src/ipcpd/normal/fmgr.c | 42 +++------- src/ipcpd/normal/shm_pci.c | 175 ++++++++++++++++++---------------------- src/ipcpd/normal/shm_pci.h | 9 +-- src/lib/shm_rdrbuff.c | 20 ++--- 5 files changed, 100 insertions(+), 150 deletions(-) (limited to 'src/lib') diff --git a/include/ouroboros/shm_rdrbuff.h b/include/ouroboros/shm_rdrbuff.h index cdac51f0..2e23381b 100644 --- a/include/ouroboros/shm_rdrbuff.h +++ b/include/ouroboros/shm_rdrbuff.h @@ -78,9 +78,9 @@ uint8_t * shm_du_buff_head_alloc(struct shm_du_buff * sdb, uint8_t * shm_du_buff_tail_alloc(struct shm_du_buff * sdb, size_t size); -int shm_du_buff_head_release(struct shm_du_buff * sdb, +void shm_du_buff_head_release(struct shm_du_buff * sdb, size_t size); -int shm_du_buff_tail_release(struct shm_du_buff * sdb, +void shm_du_buff_tail_release(struct shm_du_buff * sdb, size_t size); #endif /* OUROBOROS_SHM_RDRBUFF_H */ diff --git a/src/ipcpd/normal/fmgr.c b/src/ipcpd/normal/fmgr.c index 6b21cdbf..b79d20b4 100644 --- a/src/ipcpd/normal/fmgr.c +++ b/src/ipcpd/normal/fmgr.c @@ -129,13 +129,15 @@ void * fmgr_nm1_sdu_reader(void * o) { struct timespec timeout = {0, FD_UPDATE_TIMEOUT}; struct shm_du_buff * sdb; - struct pci * pci; + struct pci pci; int fd; int i = 0; int ret; (void) o; + memset(&pci, 0, sizeof(pci)); + while (true) { /* FIXME: replace with scheduling policy call */ i = (i + 1) % QOS_CUBE_MAX; @@ -157,30 +159,15 @@ void * fmgr_nm1_sdu_reader(void * o) continue; } - pci = shm_pci_des(sdb); - if (pci == NULL) { - LOG_ERR("Failed to get PCI."); - ipcp_flow_del(sdb); - continue; - } + shm_pci_des(sdb, &pci); - if (pci->dst_addr != ipcpi.address) { + if (pci.dst_addr != ipcpi.address) { LOG_DBG("PDU needs to be forwarded."); - if (pci->has_ttl) { - if (pci->ttl == 0) { - LOG_DBG("TTL was zero."); - ipcp_flow_del(sdb); - free(pci); - continue; - } - - if (shm_pci_dec_ttl(sdb)) { - LOG_ERR("Failed to dec TTL."); - ipcp_flow_del(sdb); - free(pci); - continue; - } + if (pci.ttl == 0) { + LOG_DBG("TTL was zero."); + ipcp_flow_del(sdb); + continue; } /* @@ -188,21 +175,14 @@ void * fmgr_nm1_sdu_reader(void * o) * we don't have a PFF yet */ ipcp_flow_del(sdb); - free(pci); continue; } - if (shm_pci_shrink(sdb)) { - LOG_ERR("Failed to shrink PDU."); - ipcp_flow_del(sdb); - free(pci); - continue; - } + shm_pci_shrink(sdb); - if (frct_nm1_post_sdu(pci, sdb)) { + if (frct_nm1_post_sdu(&pci, sdb)) { LOG_ERR("Failed to hand PDU to FRCT."); ipcp_flow_del(sdb); - free(pci); continue; } } diff --git a/src/ipcpd/normal/shm_pci.c b/src/ipcpd/normal/shm_pci.c index 735bdee1..1c2cee54 100644 --- a/src/ipcpd/normal/shm_pci.c +++ b/src/ipcpd/normal/shm_pci.c @@ -20,10 +20,7 @@ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -#define OUROBOROS_PREFIX "shm-pci" - #include -#include #include #include #include @@ -33,6 +30,7 @@ #include #include +#include #define PDU_TYPE_SIZE 1 #define QOS_ID_SIZE 1 @@ -46,33 +44,44 @@ struct { struct dt_const dtc; size_t head_size; size_t tail_size; + + /* offsets */ + size_t dst_addr_o; + size_t src_addr_o; + size_t dst_cep_id_o; + size_t src_cep_id_o; + size_t pdu_length_o; + size_t seqno_o; + size_t qos_id_o; + size_t ttl_o; } pci_info; static void ser_pci_head(uint8_t * head, struct pci * pci) { - int offset = 0; uint8_t ttl = DEFAULT_TTL; + assert(head); + assert(pci); + + /* FIXME: Add check and operations for Big Endian machines */ memcpy(head, &pci->pdu_type, PDU_TYPE_SIZE); - offset += PDU_TYPE_SIZE; - memcpy(head + offset, &pci->dst_addr, pci_info.dtc.addr_size); - offset += pci_info.dtc.addr_size; - memcpy(head + offset, &pci->src_addr, pci_info.dtc.addr_size); - offset += pci_info.dtc.addr_size; - memcpy(head + offset, &pci->dst_cep_id, pci_info.dtc.cep_id_size); - offset += pci_info.dtc.cep_id_size; - memcpy(head + offset, &pci->src_cep_id, pci_info.dtc.cep_id_size); - offset += pci_info.dtc.cep_id_size; - memcpy(head + offset, &pci->pdu_length, pci_info.dtc.pdu_length_size); - offset += pci_info.dtc.pdu_length_size; - memcpy(head + offset, &pci->seqno, pci_info.dtc.seqno_size); - offset += pci_info.dtc.seqno_size; - memcpy(head + offset, &pci->qos_id, QOS_ID_SIZE); - offset += QOS_ID_SIZE; + memcpy(head + pci_info.dst_addr_o, &pci->dst_addr, + pci_info.dtc.addr_size); + memcpy(head + pci_info.src_addr_o, &pci->src_addr, + pci_info.dtc.addr_size); + memcpy(head + pci_info.dst_cep_id_o, &pci->dst_cep_id, + pci_info.dtc.cep_id_size); + memcpy(head + pci_info.src_cep_id_o, &pci->src_cep_id, + pci_info.dtc.cep_id_size); + memcpy(head + pci_info.pdu_length_o, &pci->pdu_length, + pci_info.dtc.pdu_length_size); + memcpy(head + pci_info.seqno_o, &pci->seqno, + pci_info.dtc.seqno_size); + memcpy(head + pci_info.qos_id_o, &pci->qos_id, QOS_ID_SIZE); if (pci_info.dtc.has_ttl) - memcpy(head + offset, &ttl, TTL_SIZE); + memcpy(head + pci_info.ttl_o, &ttl, TTL_SIZE); } int shm_pci_init(void) @@ -101,9 +110,19 @@ int shm_pci_init(void) sizeof(pci_info.dtc.max_pdu_size))) return -1; - pci_info.head_size = PDU_TYPE_SIZE + pci_info.dtc.addr_size * 2 + - pci_info.dtc.cep_id_size * 2 + pci_info.dtc.pdu_length_size + - pci_info.dtc.seqno_size + QOS_ID_SIZE; + pci_info.dst_addr_o = PDU_TYPE_SIZE; + pci_info.src_addr_o = pci_info.dst_addr_o + pci_info.dtc.addr_size; + pci_info.dst_cep_id_o = pci_info.dst_addr_o + pci_info.dtc.addr_size; + pci_info.dst_cep_id_o = pci_info.src_addr_o + pci_info.dtc.addr_size; + pci_info.src_cep_id_o = pci_info.dst_cep_id_o + + pci_info.dtc.cep_id_size; + pci_info.pdu_length_o = pci_info.src_cep_id_o + + pci_info.dtc.cep_id_size; + pci_info.seqno_o = pci_info.pdu_length_o + pci_info.dtc.pdu_length_size; + pci_info.qos_id_o = pci_info.seqno_o + pci_info.dtc.seqno_size; + pci_info.ttl_o = pci_info.qos_id_o + QOS_ID_SIZE; + + pci_info.head_size = pci_info.ttl_o; if (pci_info.dtc.has_ttl) pci_info.head_size += TTL_SIZE; @@ -118,14 +137,17 @@ void shm_pci_fini(void) { } int shm_pci_ser(struct shm_du_buff * sdb, - struct pci * pci) + struct pci * pci) { uint8_t * head; uint8_t * tail; + assert(sdb); + assert(pci); + head = shm_du_buff_head_alloc(sdb, pci_info.head_size); if (head == NULL) - return -1; + return -EPERM; ser_pci_head(head, pci); @@ -133,7 +155,7 @@ int shm_pci_ser(struct shm_du_buff * sdb, tail = shm_du_buff_tail_alloc(sdb, pci_info.tail_size); if (tail == NULL) { shm_du_buff_head_release(sdb, pci_info.head_size); - return -1; + return -EPERM; } crc32((uint32_t *) tail, head, tail - head); @@ -147,8 +169,8 @@ buffer_t * shm_pci_ser_buf(buffer_t * buf, { buffer_t * buffer; - if (buf == NULL || pci == NULL) - return NULL; + assert(buf); + assert(pci); buffer = malloc(sizeof(*buffer)); if (buffer == NULL) @@ -178,85 +200,44 @@ buffer_t * shm_pci_ser_buf(buffer_t * buf, return buffer; } -struct pci * shm_pci_des(struct shm_du_buff * sdb) +void shm_pci_des(struct shm_du_buff * sdb, + struct pci * pci) { uint8_t * head; - struct pci * pci; - int offset = 0; - if (sdb == NULL) - return NULL; + assert(sdb); + assert(pci); head = shm_du_buff_head(sdb); - pci = malloc(sizeof(*pci)); - if (pci == NULL) - return NULL; - + /* FIXME: Add check and operations for Big Endian machines */ memcpy(&pci->pdu_type, head, PDU_TYPE_SIZE); - offset += PDU_TYPE_SIZE; - memcpy(&pci->dst_addr, head + offset, pci_info.dtc.addr_size); - offset += pci_info.dtc.addr_size; - memcpy(&pci->src_addr, head + offset, pci_info.dtc.addr_size); - offset += pci_info.dtc.addr_size; - memcpy(&pci->dst_cep_id, head + offset, pci_info.dtc.cep_id_size); - offset += pci_info.dtc.cep_id_size; - memcpy(&pci->src_cep_id, head + offset, pci_info.dtc.cep_id_size); - offset += pci_info.dtc.cep_id_size; - memcpy(&pci->pdu_length, head + offset, pci_info.dtc.pdu_length_size); - offset += pci_info.dtc.pdu_length_size; - memcpy(&pci->seqno, head + offset, pci_info.dtc.seqno_size); - offset += pci_info.dtc.seqno_size; - memcpy(&pci->qos_id, head + offset, QOS_ID_SIZE); - offset += QOS_ID_SIZE; - pci->has_ttl = pci_info.dtc.has_ttl; - if (pci_info.dtc.has_ttl) - memcpy(&pci->ttl, head + offset, TTL_SIZE); - - return pci; -} - -int shm_pci_shrink(struct shm_du_buff * sdb) -{ - if (sdb == NULL) - return -1; - - if (shm_du_buff_head_release(sdb, pci_info.head_size)) { - LOG_ERR("Failed to shrink head."); - return -1; - } - - if (shm_du_buff_tail_release(sdb, pci_info.tail_size)) { - LOG_ERR("Failed to shrink tail."); - return -1; + memcpy(&pci->dst_addr, head + pci_info.dst_addr_o, + pci_info.dtc.addr_size); + memcpy(&pci->src_addr, head + pci_info.src_addr_o, + pci_info.dtc.addr_size); + memcpy(&pci->dst_cep_id, head + pci_info.dst_cep_id_o, + pci_info.dtc.cep_id_size); + memcpy(&pci->src_cep_id, head + pci_info.src_cep_id_o, + pci_info.dtc.cep_id_size); + memcpy(&pci->pdu_length, head + pci_info.pdu_length_o, + pci_info.dtc.pdu_length_size); + memcpy(&pci->seqno, head + pci_info.seqno_o, + pci_info.dtc.seqno_size); + memcpy(&pci->qos_id, head + pci_info.qos_id_o, QOS_ID_SIZE); + + if (pci_info.dtc.has_ttl) { + --*(head + pci_info.ttl_o); /* decrease TTL */ + memcpy(&pci->ttl, head + pci_info.ttl_o, TTL_SIZE); + } else { + pci->ttl = 1; } - - return 0; } -int shm_pci_dec_ttl(struct shm_du_buff * sdb) +void shm_pci_shrink(struct shm_du_buff * sdb) { - uint8_t * head; - uint8_t * tail; - - if (pci_info.dtc.has_ttl == false) - return 0; + assert(sdb); - head = shm_du_buff_head(sdb); - if (head == NULL) - return -1; - - head[pci_info.head_size - TTL_SIZE]--; - - if (pci_info.dtc.has_chk) { - tail = shm_du_buff_tail(sdb); - if (tail == NULL) - return -1; - - tail -= CHK_SIZE; - - crc32((uint32_t *) tail, head, tail - head); - } - - return 0; + shm_du_buff_head_release(sdb, pci_info.head_size); + shm_du_buff_tail_release(sdb, pci_info.tail_size); } diff --git a/src/ipcpd/normal/shm_pci.h b/src/ipcpd/normal/shm_pci.h index 9fe3d9aa..17ce5cdd 100644 --- a/src/ipcpd/normal/shm_pci.h +++ b/src/ipcpd/normal/shm_pci.h @@ -44,8 +44,6 @@ struct pci { uint32_t pdu_length; uint64_t seqno; uint8_t ttl; - /* FIXME: Deprecate this and the dec_ttl call */ - int has_ttl; }; int shm_pci_init(void); @@ -58,10 +56,9 @@ int shm_pci_ser(struct shm_du_buff * sdb, buffer_t * shm_pci_ser_buf(buffer_t * buf, struct pci * pci); -struct pci * shm_pci_des(struct shm_du_buff * sdb); - -int shm_pci_shrink(struct shm_du_buff * sdb); +void shm_pci_des(struct shm_du_buff * sdb, + struct pci * pci); -int shm_pci_dec_ttl(struct shm_du_buff * sdb); +void shm_pci_shrink(struct shm_du_buff * sdb); #endif /* OUROBOROS_IPCPD_NORMAL_SHM_PCI_H */ diff --git a/src/lib/shm_rdrbuff.c b/src/lib/shm_rdrbuff.c index ce81d171..55047aa5 100644 --- a/src/lib/shm_rdrbuff.c +++ b/src/lib/shm_rdrbuff.c @@ -619,28 +619,20 @@ uint8_t * shm_du_buff_tail_alloc(struct shm_du_buff * sdb, return buf; } -int shm_du_buff_head_release(struct shm_du_buff * sdb, - size_t size) +void shm_du_buff_head_release(struct shm_du_buff * sdb, + size_t size) { assert(sdb); - - if (size > sdb->du_tail - sdb->du_head) - return -EOVERFLOW; + assert(!(size > sdb->du_tail - sdb->du_head)); sdb->du_head += size; - - return 0; } -int shm_du_buff_tail_release(struct shm_du_buff * sdb, - size_t size) +void shm_du_buff_tail_release(struct shm_du_buff * sdb, + size_t size) { assert(sdb); - - if (size > sdb->du_tail - sdb->du_head) - return -EOVERFLOW; + assert(!(size > sdb->du_tail - sdb->du_head)); sdb->du_tail -= size; - - return 0; } -- cgit v1.2.3