From d37add0f20c93432c0b4c12866810c124a7a18ec Mon Sep 17 00:00:00 2001 From: Sander Vrijders Date: Fri, 25 Mar 2016 19:13:32 +0100 Subject: build: Add protobuf-c commands for cmake This adds a cmake file so that the build can ask to generate protobuf-c files from .proto files. The messages between the IRM and the library are compiled into the library. --- src/lib/irmd_messages.proto | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 src/lib/irmd_messages.proto (limited to 'src/lib/irmd_messages.proto') diff --git a/src/lib/irmd_messages.proto b/src/lib/irmd_messages.proto new file mode 100644 index 00000000..c61d1b6d --- /dev/null +++ b/src/lib/irmd_messages.proto @@ -0,0 +1,37 @@ +enum irm_msg_code { + IRM_CREATE_IPCP = 1; + IRM_DESTROY_IPCP = 2; + IRM_BOOTSTRAP_IPCP = 3; + IRM_ENROLL_IPCP = 4; + IRM_REG_IPCP = 5; + IRM_UNREG_IPCP = 6; + IRM_AP_REG = 7; + IRM_AP_REG_R = 8; + IRM_AP_UNREG = 9; + IRM_FLOW_ACCEPT = 10; + IRM_FLOW_ACCEPT_R = 11; + IRM_FLOW_ALLOC_RESP = 12; + IRM_FLOW_ALLOC = 13; + IRM_FLOW_ALLOC_R = 14; + IRM_FLOW_ALLOC_RES = 15; + IRM_FLOW_ALLOC_RES_R = 16; + IRM_FLOW_DEALLOC = 17; + IRM_FLOW_CONTROL = 18; + IRM_FLOW_WRITE = 19; + IRM_FLOW_READ = 20; +}; + +message irm_msg { + required irm_msg_code code = 1; + optional string ap_name = 2; + optional uint32 api_id = 3; + optional string ae_name = 4; + optional string ipcp_type = 5; + // Missing dif_config field here + repeated string dif_name = 7; + optional int32 fd = 8; + optional int32 result = 9; + // Missing qos_spec here + optional int32 oflags = 10; + optional string dst_ap_name = 11; +}; -- cgit v1.2.3 From 08941177f030b77fb44238a7e589322d2e0fcaa2 Mon Sep 17 00:00:00 2001 From: Sander Vrijders Date: Wed, 30 Mar 2016 17:25:30 +0200 Subject: lib, irmd: Update communication with IRMd All messages sent to the IRMd now also get a reply back with the result of the operation. --- include/ouroboros/config.h.in | 9 +- include/ouroboros/shm_du_map.h | 4 - include/ouroboros/sockets.h | 1 - src/irmd/main.c | 311 +++++++++++++++++++++++++++++----------- src/lib/dev.c | 78 +++++++--- src/lib/ipcp.c | 8 +- src/lib/irm.c | 92 +++++++++--- src/lib/irmd_messages.proto | 23 ++- src/lib/sockets.c | 35 ----- src/lib/tests/shm_du_map_test.c | 1 + 10 files changed, 379 insertions(+), 183 deletions(-) (limited to 'src/lib/irmd_messages.proto') diff --git a/include/ouroboros/config.h.in b/include/ouroboros/config.h.in index 0f5c2131..01d7888e 100644 --- a/include/ouroboros/config.h.in +++ b/include/ouroboros/config.h.in @@ -23,9 +23,10 @@ #ifndef OUROBOROS_CONFIG #define OUROBOROS_CONFIG -#define PROJECT_NAME "@CMAKE_PROJECT_NAME@" -#define PROJECT_VERSION "@PACKAGE_VERSION@" -#define INSTALL_DIR "@CMAKE_INSTALL_PREFIX@" -#define BUILD_TYPE "@CMAKE_BUILD_TYPE@" +#define PROJECT_NAME "@CMAKE_PROJECT_NAME@" +#define PROJECT_VERSION "@PACKAGE_VERSION@" +#define INSTALL_DIR "@CMAKE_INSTALL_PREFIX@" +#define BUILD_TYPE "@CMAKE_BUILD_TYPE@" +#define _POSIX_C_SOURCE 199506L #endif diff --git a/include/ouroboros/shm_du_map.h b/include/ouroboros/shm_du_map.h index 68492a91..fb51768d 100644 --- a/include/ouroboros/shm_du_map.h +++ b/include/ouroboros/shm_du_map.h @@ -24,10 +24,6 @@ #ifndef OUROBOROS_SHM_DU_MAP_H #define OUROBOROS_SHM_DU_MAP_H -#ifndef _POSIX_C_SOURCE -#define _POSIX_C_SOURCE 199506L -#endif - #ifndef SHM_DU_BUFF_BLOCK_SIZE #define SHM_DU_BUFF_BLOCK_SIZE sysconf(_SC_PAGESIZE) #endif diff --git a/include/ouroboros/sockets.h b/include/ouroboros/sockets.h index 4c736de2..9904eecd 100644 --- a/include/ouroboros/sockets.h +++ b/include/ouroboros/sockets.h @@ -45,7 +45,6 @@ char * ipcp_sock_path(pid_t pid); int server_socket_open(char * file_name); int client_socket_open(char * file_name); -int send_irm_msg(irm_msg_t * msg); irm_msg_t * send_recv_irm_msg(irm_msg_t * msg); #endif diff --git a/src/irmd/main.c b/src/irmd/main.c index 547286e8..af0f85e2 100644 --- a/src/irmd/main.c +++ b/src/irmd/main.c @@ -46,8 +46,9 @@ struct irm { struct list_head name_to_pid; }; -static pid_t find_pid_by_name(struct irm * instance, - instance_name_t * api) +struct irm * instance = NULL; + +static pid_t find_pid_by_name(instance_name_t * api) { struct list_head * pos; @@ -64,9 +65,8 @@ static pid_t find_pid_by_name(struct irm * instance, return 0; } -static void create_ipcp(struct irm * instance, - instance_name_t * api, - char * ipcp_type) +static int create_ipcp(instance_name_t * api, + char * ipcp_type) { pid_t pid; struct name_to_pid_entry * tmp; @@ -74,12 +74,12 @@ static void create_ipcp(struct irm * instance, pid = ipcp_create(api, ipcp_type); if (pid == -1) { LOG_ERR("Failed to create IPCP"); - return; + return -1; } tmp = malloc(sizeof(*tmp)); if (tmp == NULL) - return; + return -1; INIT_LIST_HEAD(&tmp->next); @@ -87,25 +87,25 @@ static void create_ipcp(struct irm * instance, tmp->api = instance_name_dup(api); if (tmp->api == NULL) { free(tmp); - return; + return -1; } LOG_DBG("Created IPC process with pid %d", pid); list_add(&tmp->next, &instance->name_to_pid); + return 0; } -static void destroy_ipcp(struct irm * instance, - instance_name_t * api) +static int destroy_ipcp(instance_name_t * api) { pid_t pid = 0; struct list_head * pos; struct list_head * n; - pid = find_pid_by_name(instance, api); + pid = find_pid_by_name(api); if (pid == 0) { LOG_ERR("No such IPCP"); - return; + return -1; } LOG_DBG("Destroying ipcp with pid %d", pid); @@ -120,92 +120,159 @@ static void destroy_ipcp(struct irm * instance, if (instance_name_cmp(api, tmp->api) == 0) list_del(&tmp->next); } + + return 0; } -static void bootstrap_ipcp(struct irm * instance, - instance_name_t * api, - struct dif_config * conf) +static int bootstrap_ipcp(instance_name_t * api, + struct dif_config * conf) { pid_t pid = 0; - pid = find_pid_by_name(instance, api); + pid = find_pid_by_name(api); if (pid == 0) { LOG_ERR("No such IPCP"); - return; + return -1; } - if (ipcp_bootstrap(pid, conf)) + if (ipcp_bootstrap(pid, conf)) { LOG_ERR("Could not bootstrap IPCP"); + return -1; + } + + return 0; } -static void enroll_ipcp(struct irm * instance, - instance_name_t * api, - char * dif_name) +static int enroll_ipcp(instance_name_t * api, + char * dif_name) { pid_t pid = 0; char * member; char ** n_1_difs = NULL; ssize_t n_1_difs_size = 0; - pid = find_pid_by_name(instance, api); + pid = find_pid_by_name(api); if (pid == 0) { LOG_ERR("No such IPCP"); - return; + return -1; } member = da_resolve_daf(dif_name); if (member == NULL) { LOG_ERR("Could not find a member of that DIF"); - return; + return -1; } n_1_difs_size = da_resolve_dap(member, n_1_difs); if (n_1_difs_size != 0) if (ipcp_enroll(pid, dif_name, member, - n_1_difs, n_1_difs_size)) + n_1_difs, n_1_difs_size)) { LOG_ERR("Could not enroll IPCP"); + return -1; + } + + return 0; } -static void reg_ipcp(struct irm * instance, - instance_name_t * api, - char ** difs, - size_t difs_size) +static int reg_ipcp(instance_name_t * api, + char ** difs, + size_t difs_size) { pid_t pid = 0; - pid = find_pid_by_name(instance, api); + pid = find_pid_by_name(api); if (pid == 0) { LOG_ERR("No such IPCP"); - return; + return -1; } - if (ipcp_reg(pid, difs, difs_size)) + if (ipcp_reg(pid, difs, difs_size)) { LOG_ERR("Could not register IPCP to N-1 DIF(s)"); + return -1; + } + + return 0; } -static void unreg_ipcp(struct irm * instance, - instance_name_t * api, - char ** difs, - size_t difs_size) +static int unreg_ipcp(instance_name_t * api, + char ** difs, + size_t difs_size) { pid_t pid = 0; - pid = find_pid_by_name(instance, api); + pid = find_pid_by_name(api); if (pid == 0) { LOG_ERR("No such IPCP"); - return; + return -1; } - if (ipcp_unreg(pid, difs, difs_size)) + if (ipcp_unreg(pid, difs, difs_size)) { LOG_ERR("Could not unregister IPCP from N-1 DIF(s)"); + return -1; + } + + return 0; +} + +static int ap_reg(char * ap_name, + char ** difs, + size_t difs_size) +{ + return -1; +} + +static int ap_unreg(char * ap_name, + char ** difs, + size_t difs_size) +{ + return -1; +} + +static int flow_accept(int fd, + char * ap_name, + char * ae_name) +{ + return -1; +} + +static int flow_alloc_resp(int fd, + int result) +{ + + return -1; +} + +static int flow_alloc(char * dst_ap_name, + char * src_ap_name, + char * src_ae_name, + struct qos_spec * qos, + int oflags) +{ + return -1; +} + +static int flow_alloc_res(int fd) +{ + + return -1; +} + +static int flow_dealloc(int fd) +{ + return -1; +} + +static int flow_cntl(int fd, + int oflags) +{ + return -1; } /* FIXME: Close sockfd on closing and release irm */ int main() { - struct irm * instance = NULL; - int sockfd; - uint8_t buf[IRM_MSG_BUF_SIZE]; + int sockfd; + uint8_t buf[IRM_MSG_BUF_SIZE]; instance = malloc(sizeof(*instance)); if (instance == NULL) @@ -222,6 +289,10 @@ int main() irm_msg_t * msg; ssize_t count; instance_name_t api; + buffer_t buffer; + irm_msg_t ret_msg = IRM_MSG__INIT; + + ret_msg.code = IRM_MSG_CODE__IRM_REPLY; cli_sockfd = accept(sockfd, 0, 0); if (cli_sockfd < 0) { @@ -230,47 +301,125 @@ int main() } count = read(cli_sockfd, buf, IRM_MSG_BUF_SIZE); - if (count > 0) { - msg = irm_msg__unpack(NULL, count, buf); - if (msg == NULL) - continue; - - api.name = msg->ap_name; - api.id = msg->api_id; - - switch (msg->code) { - case IRM_MSG_CODE__IRM_CREATE_IPCP: - create_ipcp(instance, &api, msg->ipcp_type); - break; - case IRM_MSG_CODE__IRM_DESTROY_IPCP: - destroy_ipcp(instance, &api); - break; - case IRM_MSG_CODE__IRM_BOOTSTRAP_IPCP: - bootstrap_ipcp(instance, &api, NULL); - break; - case IRM_MSG_CODE__IRM_ENROLL_IPCP: - if (msg->n_dif_name != 1) - continue; - enroll_ipcp(instance, &api, msg->dif_name[0]); - break; - case IRM_MSG_CODE__IRM_REG_IPCP: - reg_ipcp(instance, &api, - msg->dif_name, - msg->n_dif_name); - break; - case IRM_MSG_CODE__IRM_UNREG_IPCP: - unreg_ipcp(instance, &api, - msg->dif_name, - msg->n_dif_name); - break; - default: - LOG_ERR("Don't know that message code"); - break; - } - - irm_msg__free_unpacked(msg, NULL); + if (count <= 0) { + LOG_ERR("Failed to read from socket"); + close(cli_sockfd); + continue; + } + + msg = irm_msg__unpack(NULL, count, buf); + if (msg == NULL) { + close(cli_sockfd); + continue; + } + + api.name = msg->ap_name; + api.id = msg->api_id; + + switch (msg->code) { + case IRM_MSG_CODE__IRM_CREATE_IPCP: + ret_msg.has_result = true; + ret_msg.result = create_ipcp(&api, + msg->ipcp_type); + break; + case IRM_MSG_CODE__IRM_DESTROY_IPCP: + ret_msg.has_result = true; + ret_msg.result = destroy_ipcp(&api); + break; + case IRM_MSG_CODE__IRM_BOOTSTRAP_IPCP: + ret_msg.has_result = true; + ret_msg.result = bootstrap_ipcp(&api, NULL); + break; + case IRM_MSG_CODE__IRM_ENROLL_IPCP: + ret_msg.has_result = true; + ret_msg.result = enroll_ipcp(&api, + msg->dif_name[0]); + break; + case IRM_MSG_CODE__IRM_REG_IPCP: + ret_msg.has_result = true; + ret_msg.result = reg_ipcp(&api, + msg->dif_name, + msg->n_dif_name); + break; + case IRM_MSG_CODE__IRM_UNREG_IPCP: + ret_msg.has_result = true; + ret_msg.result = unreg_ipcp(&api, + msg->dif_name, + msg->n_dif_name); + break; + case IRM_MSG_CODE__IRM_AP_REG: + ret_msg.has_fd = true; + ret_msg.fd = ap_reg(msg->ap_name, + msg->dif_name, + msg->n_dif_name); + break; + case IRM_MSG_CODE__IRM_AP_UNREG: + ret_msg.has_result = true; + ret_msg.result = ap_unreg(msg->ap_name, + msg->dif_name, + msg->n_dif_name); + break; + case IRM_MSG_CODE__IRM_FLOW_ACCEPT: + ret_msg.has_fd = true; + ret_msg.fd = flow_accept(msg->fd, + ret_msg.ap_name, + ret_msg.ae_name); + break; + case IRM_MSG_CODE__IRM_FLOW_ALLOC_RESP: + ret_msg.has_result = true; + ret_msg.result = flow_alloc_resp(msg->fd, + msg->result); + break; + case IRM_MSG_CODE__IRM_FLOW_ALLOC: + ret_msg.has_fd = true; + ret_msg.fd = flow_alloc(msg->dst_ap_name, + msg->ap_name, + msg->ae_name, + NULL, + msg->oflags); + break; + case IRM_MSG_CODE__IRM_FLOW_ALLOC_RES: + ret_msg.has_result = true; + ret_msg.result = flow_alloc_res(msg->fd); + break; + case IRM_MSG_CODE__IRM_FLOW_DEALLOC: + ret_msg.has_result = true; + ret_msg.result = flow_dealloc(msg->fd); + break; + case IRM_MSG_CODE__IRM_FLOW_CONTROL: + ret_msg.has_result = true; + ret_msg.result = flow_cntl(msg->fd, + msg->oflags); + break; + default: + LOG_ERR("Don't know that message code"); + break; + } + + irm_msg__free_unpacked(msg, NULL); + + buffer.size = irm_msg__get_packed_size(&ret_msg); + if (buffer.size == 0) { + LOG_ERR("Failed to send reply message"); + close(cli_sockfd); + continue; + } + + buffer.data = malloc(buffer.size); + if (buffer.data == NULL) { + close(cli_sockfd); + continue; + } + + irm_msg__pack(&ret_msg, buffer.data); + + if (write(cli_sockfd, buffer.data, buffer.size) == -1) { + free(buffer.data); + close(cli_sockfd); + continue; } + free(buffer.data); close(cli_sockfd); } diff --git a/src/lib/dev.c b/src/lib/dev.c index 5c11d8bf..c138b009 100644 --- a/src/lib/dev.c +++ b/src/lib/dev.c @@ -49,7 +49,11 @@ int ap_reg(char * ap_name, msg.n_dif_name = difs_size; recv_msg = send_recv_irm_msg(&msg); - if (recv_msg == NULL) { + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_fd == false) { + irm_msg__free_unpacked(recv_msg, NULL); return -1; } @@ -64,6 +68,8 @@ int ap_unreg(char * ap_name, size_t difs_size) { irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int ret = -1; if (ap_name == NULL || difs == NULL || @@ -77,12 +83,19 @@ int ap_unreg(char * ap_name, msg.dif_name = difs; msg.n_dif_name = difs_size; - if (send_irm_msg(&msg)) { - LOG_ERR("Failed to send message to daemon"); + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + irm_msg__free_unpacked(recv_msg, NULL); return -1; } - return 0; + ret = recv_msg->result; + irm_msg__free_unpacked(recv_msg, NULL); + + return ret; } int flow_accept(int fd, @@ -102,9 +115,8 @@ int flow_accept(int fd, msg.fd = fd; recv_msg = send_recv_irm_msg(&msg); - if (recv_msg == NULL) { + if (recv_msg == NULL) return -1; - } if (recv_msg->has_fd == false) { irm_msg__free_unpacked(recv_msg, NULL); @@ -122,6 +134,8 @@ int flow_alloc_resp(int fd, int result) { irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int ret = -1; msg.code = IRM_MSG_CODE__IRM_FLOW_ALLOC_RESP; msg.has_fd = true; @@ -129,12 +143,19 @@ int flow_alloc_resp(int fd, msg.has_result = true; msg.result = result; - if (send_irm_msg(&msg)) { - LOG_ERR("Failed to send message to daemon"); + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + irm_msg__free_unpacked(recv_msg, NULL); return -1; } - return 0; + ret = recv_msg->result; + irm_msg__free_unpacked(recv_msg, NULL); + + return ret; } int flow_alloc(char * dst_ap_name, @@ -150,8 +171,7 @@ int flow_alloc(char * dst_ap_name, if (dst_ap_name == NULL || src_ap_name == NULL || qos == NULL) { - LOG_ERR("Invalid arguments"); - return -1; + return -EINVAL; } msg.code = IRM_MSG_CODE__IRM_FLOW_ALLOC; @@ -162,9 +182,8 @@ int flow_alloc(char * dst_ap_name, msg.oflags = oflags; recv_msg = send_recv_irm_msg(&msg); - if (recv_msg == NULL) { + if (recv_msg == NULL) return -1; - } if (recv_msg->has_fd == false) { irm_msg__free_unpacked(recv_msg, NULL); @@ -187,9 +206,8 @@ int flow_alloc_res(int fd) msg.fd = fd; recv_msg = send_recv_irm_msg(&msg); - if (recv_msg == NULL) { + if (recv_msg == NULL) return -1; - } if (recv_msg->has_result == false) { irm_msg__free_unpacked(recv_msg, NULL); @@ -205,33 +223,51 @@ int flow_alloc_res(int fd) int flow_dealloc(int fd) { irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int ret = -1; msg.code = IRM_MSG_CODE__IRM_FLOW_DEALLOC; msg.has_fd = true; msg.fd = fd; - if (send_irm_msg(&msg)) { - LOG_ERR("Failed to send message to daemon"); + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + irm_msg__free_unpacked(recv_msg, NULL); return -1; } - return 0; + ret = recv_msg->result; + irm_msg__free_unpacked(recv_msg, NULL); + + return ret; } int flow_cntl(int fd, int oflags) { irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int ret = -1; msg.has_fd = true; msg.fd = fd; msg.oflags = oflags; - if (send_irm_msg(&msg)) { - LOG_ERR("Failed to send message to daemon"); + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + irm_msg__free_unpacked(recv_msg, NULL); return -1; } - return 0; + ret = recv_msg->result; + irm_msg__free_unpacked(recv_msg, NULL); + + return ret; } ssize_t flow_write(int fd, diff --git a/src/lib/ipcp.c b/src/lib/ipcp.c index 60d5879e..2caeaad3 100644 --- a/src/lib/ipcp.c +++ b/src/lib/ipcp.c @@ -22,14 +22,10 @@ #define OUROBOROS_PREFIX "lib-ipcp" -#ifndef _POSIX_C_SOURCE -#define _POSIX_C_SOURCE 199506L -#endif - +#include #include #include #include -#include #include #include @@ -97,6 +93,8 @@ pid_t ipcp_create(instance_name_t * api, if (ipcp_type == NULL) return -1; + LOG_DBG("%lu", _POSIX_C_SOURCE); + pid = fork(); if (pid == -1) { LOG_ERR("Failed to fork"); diff --git a/src/lib/irm.c b/src/lib/irm.c index 644e1113..7c187be1 100644 --- a/src/lib/irm.c +++ b/src/lib/irm.c @@ -34,6 +34,8 @@ int irm_create_ipcp(instance_name_t * api, char * ipcp_type) { irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int ret = -1; if (api == NULL || ipcp_type == NULL || api->name == NULL) return -EINVAL; @@ -44,17 +46,26 @@ int irm_create_ipcp(instance_name_t * api, msg.api_id = api->id; msg.ipcp_type = ipcp_type; - if (send_irm_msg(&msg)) { - LOG_ERR("Failed to send message to daemon"); + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + irm_msg__free_unpacked(recv_msg, NULL); return -1; } - return 0; + ret = recv_msg->result; + irm_msg__free_unpacked(recv_msg, NULL); + + return ret; } int irm_destroy_ipcp(instance_name_t * api) { irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int ret = -1; if (api == NULL || api->name == NULL) return -EINVAL; @@ -64,18 +75,27 @@ int irm_destroy_ipcp(instance_name_t * api) msg.has_api_id = true; msg.api_id = api->id; - if (send_irm_msg(&msg)) { - LOG_ERR("Failed to send message to daemon"); + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + irm_msg__free_unpacked(recv_msg, NULL); return -1; } - return 0; + ret = recv_msg->result; + irm_msg__free_unpacked(recv_msg, NULL); + + return ret; } int irm_bootstrap_ipcp(instance_name_t * api, struct dif_config * conf) { irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int ret = -1; if (api == NULL || api->name == NULL || conf == NULL) return -EINVAL; @@ -85,18 +105,27 @@ int irm_bootstrap_ipcp(instance_name_t * api, msg.has_api_id = true; msg.api_id = api->id; - if (send_irm_msg(&msg)) { - LOG_ERR("Failed to send message to daemon"); + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + irm_msg__free_unpacked(recv_msg, NULL); return -1; } - return 0; + ret = recv_msg->result; + irm_msg__free_unpacked(recv_msg, NULL); + + return ret; } int irm_enroll_ipcp(instance_name_t * api, char * dif_name) { irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int ret = -1; if (api == NULL || api->name == NULL || dif_name == NULL) return -EINVAL; @@ -113,15 +142,22 @@ int irm_enroll_ipcp(instance_name_t * api, } msg.dif_name[0] = dif_name; - if (send_irm_msg(&msg)) { - LOG_ERR("Failed to send message to daemon"); + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) { free(msg.dif_name); return -1; } - free(msg.dif_name); + if (recv_msg->has_result == false) { + irm_msg__free_unpacked(recv_msg, NULL); + return -1; + } + + ret = recv_msg->result; + irm_msg__free_unpacked(recv_msg, NULL); - return 0; + free(msg.dif_name); + return ret; } int irm_reg_ipcp(instance_name_t * api, @@ -129,6 +165,8 @@ int irm_reg_ipcp(instance_name_t * api, size_t difs_size) { irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int ret = -1; if (api->name == NULL || difs == NULL || @@ -144,12 +182,19 @@ int irm_reg_ipcp(instance_name_t * api, msg.dif_name = difs; msg.n_dif_name = difs_size; - if (send_irm_msg(&msg)) { - LOG_ERR("Failed to send message to daemon"); + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + irm_msg__free_unpacked(recv_msg, NULL); return -1; } - return 0; + ret = recv_msg->result; + irm_msg__free_unpacked(recv_msg, NULL); + + return ret; } int irm_unreg_ipcp(const instance_name_t * api, @@ -157,6 +202,8 @@ int irm_unreg_ipcp(const instance_name_t * api, size_t difs_size) { irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int ret = -1; if (api == NULL || api->name == NULL || @@ -173,10 +220,17 @@ int irm_unreg_ipcp(const instance_name_t * api, msg.dif_name = difs; msg.n_dif_name = difs_size; - if (send_irm_msg(&msg)) { - LOG_ERR("Failed to send message to daemon"); + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + irm_msg__free_unpacked(recv_msg, NULL); return -1; } - return 0; + ret = recv_msg->result; + irm_msg__free_unpacked(recv_msg, NULL); + + return ret; } diff --git a/src/lib/irmd_messages.proto b/src/lib/irmd_messages.proto index c61d1b6d..a524a7fb 100644 --- a/src/lib/irmd_messages.proto +++ b/src/lib/irmd_messages.proto @@ -6,19 +6,16 @@ enum irm_msg_code { IRM_REG_IPCP = 5; IRM_UNREG_IPCP = 6; IRM_AP_REG = 7; - IRM_AP_REG_R = 8; - IRM_AP_UNREG = 9; - IRM_FLOW_ACCEPT = 10; - IRM_FLOW_ACCEPT_R = 11; - IRM_FLOW_ALLOC_RESP = 12; - IRM_FLOW_ALLOC = 13; - IRM_FLOW_ALLOC_R = 14; - IRM_FLOW_ALLOC_RES = 15; - IRM_FLOW_ALLOC_RES_R = 16; - IRM_FLOW_DEALLOC = 17; - IRM_FLOW_CONTROL = 18; - IRM_FLOW_WRITE = 19; - IRM_FLOW_READ = 20; + IRM_AP_UNREG = 8; + IRM_FLOW_ACCEPT = 9; + IRM_FLOW_ALLOC_RESP = 10; + IRM_FLOW_ALLOC = 11; + IRM_FLOW_ALLOC_RES = 12; + IRM_FLOW_DEALLOC = 13; + IRM_FLOW_CONTROL = 14; + IRM_FLOW_WRITE = 15; + IRM_FLOW_READ = 16; + IRM_REPLY = 17; }; message irm_msg { diff --git a/src/lib/sockets.c b/src/lib/sockets.c index a699206d..f9024f70 100644 --- a/src/lib/sockets.c +++ b/src/lib/sockets.c @@ -96,41 +96,6 @@ int server_socket_open(char * file_name) return sockfd; } -int send_irm_msg(irm_msg_t * msg) -{ - int sockfd; - buffer_t buf; - - sockfd = client_socket_open(IRM_SOCK_PATH); - if (sockfd < 0) - return -1; - - buf.size = irm_msg__get_packed_size(msg); - if (buf.size == 0) { - close(sockfd); - return -1; - } - - buf.data = malloc(buf.size); - if (buf.data == NULL) { - close(sockfd); - return -ENOMEM; - } - - irm_msg__pack(msg, buf.data); - - if (write(sockfd, buf.data, buf.size) == -1) { - free(buf.data); - close(sockfd); - return -1; - } - - free(buf.data); - - close(sockfd); - return 0; -} - irm_msg_t * send_recv_irm_msg(irm_msg_t * msg) { int sockfd; diff --git a/src/lib/tests/shm_du_map_test.c b/src/lib/tests/shm_du_map_test.c index f636c941..85a82e4d 100644 --- a/src/lib/tests/shm_du_map_test.c +++ b/src/lib/tests/shm_du_map_test.c @@ -20,6 +20,7 @@ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +#include #include #include #include -- cgit v1.2.3 From 151adbc851c9b2a218f2be9409199c1baa62bd8d Mon Sep 17 00:00:00 2001 From: Sander Vrijders Date: Thu, 31 Mar 2016 18:32:28 +0200 Subject: lib: Implementation of flow related ops This adds the messages that are sent to the IPCPs related to flows. Some messages are also sent to the IRMd (e.g. when a new flow arrives). --- include/ouroboros/ipcp.h | 18 +-- include/ouroboros/sockets.h | 2 +- src/irmd/main.c | 36 ++++- src/lib/ipcp.c | 349 +++++++++++++++++++++++++++++++++++++++---- src/lib/ipcpd_messages.proto | 11 +- src/lib/irmd_messages.proto | 7 +- 6 files changed, 376 insertions(+), 47 deletions(-) (limited to 'src/lib/irmd_messages.proto') diff --git a/include/ouroboros/ipcp.h b/include/ouroboros/ipcp.h index b39a6b0d..fdaf5c4a 100644 --- a/include/ouroboros/ipcp.h +++ b/include/ouroboros/ipcp.h @@ -23,10 +23,10 @@ #ifndef OUROBOROS_IPCP_H #define OUROBOROS_IPCP_H -#include +#include +#include -#include "common.h" -#include "instance_name.h" +#include struct ipcp; @@ -44,19 +44,17 @@ int ipcp_unreg(pid_t pid, int ipcp_bootstrap(pid_t pid, struct dif_config * conf); -int ipcp_enroll(pid_t pid, - char * dif_name, - char * member_name, - char ** n_1_difs, - ssize_t n_1_difs_size); +int ipcp_enroll(pid_t pid, + char * member_name, + char * n_1_dif); /* Flow related ops, these go from IRMd to IPCP */ int ipcp_ap_reg(pid_t pid, uint32_t reg_api_id, char * ap_name); -int ipcp_ap_unreg(pid_t pid, - char * ap_name); +int ipcp_ap_unreg(pid_t pid, + uint32_t reg_api_id); int ipcp_flow_alloc(pid_t pid, uint32_t port_id, diff --git a/include/ouroboros/sockets.h b/include/ouroboros/sockets.h index 9904eecd..0c517bd4 100644 --- a/include/ouroboros/sockets.h +++ b/include/ouroboros/sockets.h @@ -37,7 +37,7 @@ typedef IpcpMsg ipcp_msg_t; #define IRM_MSG_BUF_SIZE 256 #define IPCP_SOCK_PATH_PREFIX "/tmp/ipcp_sock" -#define IPCP_MSG_BUFS_SIZE IRM_MSG_BUF_SIZE +#define IPCP_MSG_BUF_SIZE IRM_MSG_BUF_SIZE /* Returns the full socket path of an IPCP */ char * ipcp_sock_path(pid_t pid); diff --git a/src/irmd/main.c b/src/irmd/main.c index af0f85e2..0256248b 100644 --- a/src/irmd/main.c +++ b/src/irmd/main.c @@ -165,8 +165,7 @@ static int enroll_ipcp(instance_name_t * api, n_1_difs_size = da_resolve_dap(member, n_1_difs); if (n_1_difs_size != 0) - if (ipcp_enroll(pid, dif_name, member, - n_1_difs, n_1_difs_size)) { + if (ipcp_enroll(pid, member, n_1_difs[0])) { LOG_ERR("Could not enroll IPCP"); return -1; } @@ -268,6 +267,24 @@ static int flow_cntl(int fd, return -1; } +static int flow_req_arr(uint32_t reg_api_id, + char * ap_name, + char * ae_name) +{ + return -1; +} + +static int flow_alloc_reply(uint32_t port_id, + int result) +{ + return -1; +} + +static int flow_dealloc_ipcp(uint32_t port_id) +{ + return -1; +} + /* FIXME: Close sockfd on closing and release irm */ int main() { @@ -391,6 +408,21 @@ int main() ret_msg.result = flow_cntl(msg->fd, msg->oflags); break; + case IRM_MSG_CODE__IPCP_FLOW_REQ_ARR: + ret_msg.has_fd = true; + ret_msg.fd = flow_req_arr(msg->port_id, + msg->ap_name, + msg->ae_name); + break; + case IRM_MSG_CODE__IPCP_FLOW_ALLOC_REPLY: + ret_msg.has_result = true; + ret_msg.result = flow_alloc_reply(msg->port_id, + msg->result); + break; + case IRM_MSG_CODE__IPCP_FLOW_DEALLOC: + ret_msg.has_result = true; + ret_msg.result = flow_dealloc_ipcp(msg->port_id); + break; default: LOG_ERR("Don't know that message code"); break; diff --git a/src/lib/ipcp.c b/src/lib/ipcp.c index 2caeaad3..d61fcb50 100644 --- a/src/lib/ipcp.c +++ b/src/lib/ipcp.c @@ -35,35 +35,37 @@ #include #include -static int send_ipcp_msg(pid_t pid, - ipcp_msg_t * msg) +static ipcp_msg_t * send_recv_ipcp_msg(pid_t pid, + ipcp_msg_t * msg) { int sockfd = 0; buffer_t buf; - char * sock_path; + char * sock_path = NULL; + ssize_t count = 0; + ipcp_msg_t * recv_msg = NULL; sock_path = ipcp_sock_path(pid); if (sock_path == NULL) - return -1; + return NULL; sockfd = client_socket_open(sock_path); if (sockfd < 0) { free(sock_path); - return -1; + return NULL; } buf.size = ipcp_msg__get_packed_size(msg); if (buf.size == 0) { close(sockfd); free(sock_path); - return -1; + return NULL; } buf.data = malloc(buf.size); if (buf.data == NULL) { close(sockfd); free(sock_path); - return -ENOMEM; + return NULL; } ipcp_msg__pack(msg, buf.data); @@ -72,13 +74,29 @@ static int send_ipcp_msg(pid_t pid, free(sock_path); free(buf.data); close(sockfd); - return -1; + return NULL; + } + + count = read(sockfd, buf.data, IPCP_MSG_BUF_SIZE); + if (count <= 0) { + free(sock_path); + free(buf.data); + close(sockfd); + return NULL; + } + + recv_msg = ipcp_msg__unpack(NULL, count, buf.data); + if (recv_msg == NULL) { + free(sock_path); + free(buf.data); + close(sockfd); + return NULL; } free(buf.data); free(sock_path); close(sockfd); - return 0; + return recv_msg; } pid_t ipcp_create(instance_name_t * api, @@ -164,6 +182,8 @@ int ipcp_reg(pid_t pid, size_t difs_size) { ipcp_msg_t msg = IPCP_MSG__INIT; + ipcp_msg_t * recv_msg = NULL; + int ret = -1; if (difs == NULL || difs_size == 0 || @@ -174,12 +194,19 @@ int ipcp_reg(pid_t pid, msg.dif_name = difs; msg.n_dif_name = difs_size; - if (send_ipcp_msg(pid, &msg)) { - LOG_ERR("Failed to send message to daemon"); + recv_msg = send_recv_ipcp_msg(pid, &msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + ipcp_msg__free_unpacked(recv_msg, NULL); return -1; } - return 0; + ret = recv_msg->result; + ipcp_msg__free_unpacked(recv_msg, NULL); + + return ret; } int ipcp_unreg(pid_t pid, @@ -187,6 +214,8 @@ int ipcp_unreg(pid_t pid, size_t difs_size) { ipcp_msg_t msg = IPCP_MSG__INIT; + ipcp_msg_t * recv_msg = NULL; + int ret = -1; if (difs == NULL || difs_size == 0 || @@ -197,42 +226,54 @@ int ipcp_unreg(pid_t pid, msg.dif_name = difs; msg.n_dif_name = difs_size; - if (send_ipcp_msg(pid, &msg)) { - LOG_ERR("Failed to send message to daemon"); + recv_msg = send_recv_ipcp_msg(pid, &msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + ipcp_msg__free_unpacked(recv_msg, NULL); return -1; } - return 0; + ret = recv_msg->result; + ipcp_msg__free_unpacked(recv_msg, NULL); + + return ret; } int ipcp_bootstrap(pid_t pid, struct dif_config * conf) { ipcp_msg_t msg = IPCP_MSG__INIT; + ipcp_msg_t * recv_msg = NULL; + int ret = -1; msg.code = IPCP_MSG_CODE__IPCP_BOOTSTRAP; - if (send_ipcp_msg(pid, &msg)) { - LOG_ERR("Failed to send message to daemon"); + recv_msg = send_recv_ipcp_msg(pid, &msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + ipcp_msg__free_unpacked(recv_msg, NULL); return -1; } - return 0; + ret = recv_msg->result; + ipcp_msg__free_unpacked(recv_msg, NULL); + + return ret; } int ipcp_enroll(pid_t pid, - char * dif_name, char * member_name, - char ** n_1_difs, - ssize_t n_1_difs_size) + char * n_1_dif) { ipcp_msg_t msg = IPCP_MSG__INIT; + ipcp_msg_t * recv_msg = NULL; + int ret = -1; - if (n_1_difs == NULL || - n_1_difs_size == 0 || - n_1_difs[0] == NULL || - dif_name == NULL || - member_name == NULL) + if (n_1_dif == NULL || member_name == NULL) return -EINVAL; msg.code = IPCP_MSG_CODE__IPCP_ENROLL; @@ -241,17 +282,261 @@ int ipcp_enroll(pid_t pid, LOG_ERR("Failed to malloc"); return -1; } - msg.dif_name[0] = dif_name; + msg.dif_name[0] = n_1_dif; msg.ap_name = member_name; - msg.n_1_dif_name = n_1_difs; - msg.n_n_1_dif_name = n_1_difs_size; - if (send_ipcp_msg(pid, &msg)) { - LOG_ERR("Failed to send message to daemon"); + recv_msg = send_recv_ipcp_msg(pid, &msg); + if (recv_msg == NULL) { free(msg.dif_name); return -1; } + if (recv_msg->has_result == false) { + ipcp_msg__free_unpacked(recv_msg, NULL); + free(msg.dif_name); + return -1; + } + + ret = recv_msg->result; + ipcp_msg__free_unpacked(recv_msg, NULL); free(msg.dif_name); - return 0; + + return ret; +} + +int ipcp_ap_reg(pid_t pid, + uint32_t reg_api_id, + char * ap_name) +{ + ipcp_msg_t msg = IPCP_MSG__INIT; + ipcp_msg_t * recv_msg = NULL; + int ret = -1; + + if (ap_name == NULL) + return -1; + + msg.code = IPCP_MSG_CODE__IPCP_AP_REG; + msg.ap_name = ap_name; + msg.has_port_id = true; + msg.port_id = reg_api_id; + + recv_msg = send_recv_ipcp_msg(pid, &msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + ipcp_msg__free_unpacked(recv_msg, NULL); + return -1; + } + + ret = recv_msg->result; + ipcp_msg__free_unpacked(recv_msg, NULL); + + return ret; +} + +int ipcp_ap_unreg(pid_t pid, + uint32_t reg_api_id) +{ + ipcp_msg_t msg = IPCP_MSG__INIT; + ipcp_msg_t * recv_msg = NULL; + int ret = -1; + + msg.code = IPCP_MSG_CODE__IPCP_AP_UNREG; + msg.has_port_id = true; + msg.port_id = reg_api_id; + + recv_msg = send_recv_ipcp_msg(pid, &msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + ipcp_msg__free_unpacked(recv_msg, NULL); + return -1; + } + + ret = recv_msg->result; + ipcp_msg__free_unpacked(recv_msg, NULL); + + return ret; +} + +int ipcp_flow_alloc(pid_t pid, + uint32_t port_id, + char * dst_ap_name, + char * src_ap_name, + char * src_ae_name, + struct qos_spec * qos) +{ + ipcp_msg_t msg = IPCP_MSG__INIT; + ipcp_msg_t * recv_msg = NULL; + int ret = -1; + + if (dst_ap_name == NULL || src_ap_name == NULL || src_ae_name == NULL) + return -EINVAL; + + msg.code = IPCP_MSG_CODE__IPCP_FLOW_ALLOC; + msg.ap_name = src_ap_name; + msg.ae_name = src_ae_name; + msg.dst_ap_name = dst_ap_name; + msg.has_port_id = true; + msg.port_id = port_id; + + recv_msg = send_recv_ipcp_msg(pid, &msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + ipcp_msg__free_unpacked(recv_msg, NULL); + return -1; + } + + ret = recv_msg->result; + ipcp_msg__free_unpacked(recv_msg, NULL); + + return ret; +} + +int ipcp_flow_alloc_resp(pid_t pid, + uint32_t port_id, + int result) +{ + ipcp_msg_t msg = IPCP_MSG__INIT; + ipcp_msg_t * recv_msg = NULL; + int ret = -1; + + msg.code = IPCP_MSG_CODE__IPCP_FLOW_ALLOC_RESP; + msg.has_port_id = true; + msg.port_id = port_id; + msg.has_result = true; + msg.result = result; + + recv_msg = send_recv_ipcp_msg(pid, &msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + ipcp_msg__free_unpacked(recv_msg, NULL); + return -1; + } + + ret = recv_msg->result; + ipcp_msg__free_unpacked(recv_msg, NULL); + + return ret; +} + +int ipcp_flow_req_arr(pid_t pid, + uint32_t reg_api_id, + char * ap_name, + char * ae_name) +{ + irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int fd = -1; + + if (ap_name == NULL || ae_name == NULL) + return -EINVAL; + + msg.code = IRM_MSG_CODE__IPCP_FLOW_REQ_ARR; + msg.ap_name = ap_name; + msg.ae_name = ae_name; + msg.port_id = reg_api_id; + msg.has_port_id = true; + msg.pid = pid; + msg.has_pid = true; + + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_fd == false) { + irm_msg__free_unpacked(recv_msg, NULL); + return -1; + } + + fd = recv_msg->fd; + irm_msg__free_unpacked(recv_msg, NULL); + + return fd; +} + +int ipcp_flow_alloc_reply(pid_t pid, + uint32_t port_id, + int result) +{ + irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int ret = -1; + + msg.code = IRM_MSG_CODE__IPCP_FLOW_ALLOC_REPLY; + msg.port_id = port_id; + msg.has_port_id = true; + msg.result = result; + msg.has_result = true; + + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + irm_msg__free_unpacked(recv_msg, NULL); + return -1; + } + + ret = recv_msg->result; + irm_msg__free_unpacked(recv_msg, NULL); + + return ret; +} + + +int ipcp_flow_dealloc(pid_t pid, + uint32_t port_id) +{ + if (pid != 0) { + ipcp_msg_t msg = IPCP_MSG__INIT; + ipcp_msg_t * recv_msg = NULL; + int ret = -1; + + msg.code = IPCP_MSG_CODE__IPCP_FLOW_DEALLOC; + msg.has_port_id = true; + msg.port_id = port_id; + + recv_msg = send_recv_ipcp_msg(pid, &msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + ipcp_msg__free_unpacked(recv_msg, NULL); + return -1; + } + + ret = recv_msg->result; + ipcp_msg__free_unpacked(recv_msg, NULL); + + return ret; + } else { + irm_msg_t msg = IRM_MSG__INIT; + irm_msg_t * recv_msg = NULL; + int ret = -1; + + msg.code = IRM_MSG_CODE__IPCP_FLOW_DEALLOC; + msg.has_port_id = true; + msg.port_id = port_id; + + recv_msg = send_recv_irm_msg(&msg); + if (recv_msg == NULL) + return -1; + + if (recv_msg->has_result == false) { + irm_msg__free_unpacked(recv_msg, NULL); + return -1; + } + + ret = recv_msg->result; + irm_msg__free_unpacked(recv_msg, NULL); + + return ret; + } } diff --git a/src/lib/ipcpd_messages.proto b/src/lib/ipcpd_messages.proto index 0715fbe0..bcdd54ae 100644 --- a/src/lib/ipcpd_messages.proto +++ b/src/lib/ipcpd_messages.proto @@ -3,6 +3,12 @@ enum ipcp_msg_code { IPCP_ENROLL = 2; IPCP_REG = 3; IPCP_UNREG = 4; + IPCP_AP_REG = 5; + IPCP_AP_UNREG = 6; + IPCP_FLOW_ALLOC = 7; + IPCP_FLOW_ALLOC_RESP = 8; + IPCP_FLOW_DEALLOC = 9; + IPCP_REPLY = 10; }; message ipcp_msg { @@ -10,5 +16,8 @@ message ipcp_msg { optional string ap_name = 2; // Missing dif_config field here repeated string dif_name = 4; - repeated string n_1_dif_name = 5; + optional int32 result = 5; + optional uint32 port_id = 6; + optional string ae_name = 7; + optional string dst_ap_name = 8; }; diff --git a/src/lib/irmd_messages.proto b/src/lib/irmd_messages.proto index a524a7fb..44070755 100644 --- a/src/lib/irmd_messages.proto +++ b/src/lib/irmd_messages.proto @@ -15,7 +15,10 @@ enum irm_msg_code { IRM_FLOW_CONTROL = 14; IRM_FLOW_WRITE = 15; IRM_FLOW_READ = 16; - IRM_REPLY = 17; + IPCP_FLOW_REQ_ARR = 17; + IPCP_FLOW_ALLOC_REPLY = 18; + IPCP_FLOW_DEALLOC = 19; + IRM_REPLY = 20; }; message irm_msg { @@ -31,4 +34,6 @@ message irm_msg { // Missing qos_spec here optional int32 oflags = 10; optional string dst_ap_name = 11; + optional uint32 port_id = 12; + optional int32 pid = 13; }; -- cgit v1.2.3