lib, irmd, tools: Support to create IPCPs

Provides the initial support to create IPCPs via a command-line
tool. It extends the socket layer with a message that is sent over a
socket to the irmd when the irm_create_ipcp library function is called
from a program.

7 files changed, 258 insertions, 16 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 84a42eb9..99750b00 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -54,6 +54,7 @@ if (CMAKE_BUILD_TYPE MATCHES Debug)
    MACRO_ADD_COMPILE_FLAGS(irmd -DCONFIG_OUROBOROS_DEBUG)
    MACRO_ADD_COMPILE_FLAGS(dad -DCONFIG_OUROBOROS_DEBUG)
    MACRO_ADD_COMPILE_FLAGS(irm -DCONFIG_OUROBOROS_DEBUG)
+   MACRO_ADD_COMPILE_FLAGS(ouroboros -DCONFIG_OUROBOROS_DEBUG)
 endif (CMAKE_BUILD_TYPE MATCHES Debug)
 
 #include(FeatureSummary)
diff --git a/include/ouroboros/common.h b/include/ouroboros/common.h
index 09900a1f..02361f20 100644
--- a/include/ouroboros/common.h
+++ b/include/ouroboros/common.h
@@ -30,9 +30,8 @@
 
 typedef uint32_t port_id_t;
 
-/* FIXME: To be moved into a separate file */
 typedef struct {
-        char * data;
+        uint8_t * data;
         size_t size;
 } buffer_t;
 
diff --git a/include/ouroboros/sockets.h b/include/ouroboros/sockets.h
index fb2fa7db..ad9bd408 100644
--- a/include/ouroboros/sockets.h
+++ b/include/ouroboros/sockets.h
@@ -32,15 +32,18 @@ enum irm_msg_code {
         IRM_LIST_IPCPS
 };
 
-struct irm_msg_sock {
+struct irm_msg {
         enum irm_msg_code code;
         union {
                 struct {
-                        rina_name_t name;
+                        rina_name_t * name;
                         char * ipcp_type;
                 } create_ipcp;
-        } irm_msg;
+        } msgs;
 };
 
-int client_socket_open(char * file_name);
-int server_socket_open(char * file_name);
+int              client_socket_open(char * file_name);
+int              server_socket_open(char * file_name);
+
+buffer_t *       serialize_irm_msg(struct irm_msg * msg);
+struct irm_msg * deserialize_irm_msg(buffer_t * data);
diff --git a/src/irmd/main.c b/src/irmd/main.c
index b4e43534..d2aa6cd9 100644
--- a/src/irmd/main.c
+++ b/src/irmd/main.c
@@ -28,22 +28,44 @@
 #include <ouroboros/irm.h>
 #include <sys/socket.h>
 #include <sys/un.h>
+#include <stdlib.h>
 
 #define BUF_SIZE 256
 
+
+static void create_ipcp(rina_name_t * name,
+                        char * ipcp_type)
+{
+        LOG_DBG("AP name is %s", name->ap_name);
+        LOG_DBG("AP instance id is %d", name->api_id);
+        LOG_DBG("AE name is %s", name->ae_name);
+        LOG_DBG("AE instance id is %d", name->aei_id);
+
+        LOG_DBG("IPCP type is %s", ipcp_type);
+
+        LOG_MISSING;
+}
+
 int main()
 {
         int sockfd;
+        uint8_t * buf;
 
         sockfd = server_socket_open(IRM_SOCK_PATH);
         if (sockfd < 0)
                 return -1;
 
+        buf = malloc(sizeof(buf) * BUF_SIZE);
+        if (!buf) {
+                LOG_ERR("Cannot allocate memory");
+                return -1;
+        }
+
         while (true) {
-                int     cli_sockfd;
-                struct irm_msg_sock msg;
+                int cli_sockfd;
+                struct irm_msg * msg;
                 ssize_t count;
-                char    buf[BUF_SIZE];
+                buffer_t buffer;
 
                 cli_sockfd = accept(sockfd, 0, 0);
                 if (cli_sockfd < 0) {
@@ -52,12 +74,28 @@ int main()
 
                 count = read(cli_sockfd, buf, BUF_SIZE);
                 if (count) {
-                        msg = (struct struct irm_msg_sock) buf;
-                        LOG_INFO("Got message code %d", buf.code);
+                        buffer.size = count;
+                        buffer.data = buf;
+                        msg = deserialize_irm_msg(&buffer);
+                        if (!msg)
+                                continue;
+
+                        LOG_DBG("Got message code %d", msg->code);
+                        switch (msg->code) {
+                        case IRM_CREATE_IPCP:
+                                create_ipcp(msg->msgs.create_ipcp.name,
+                                            msg->msgs.create_ipcp.ipcp_type);
+                                break;
+                        default:
+                                LOG_ERR("Don't know that message code");
+                                break;
+                        }
                 }
 
                 close(cli_sockfd);
         }
 
+        free(buf);
+
         return 0;
 }
diff --git a/src/lib/irm.c b/src/lib/irm.c
index da229d3e..1af8ed2c 100644
--- a/src/lib/irm.c
+++ b/src/lib/irm.c
@@ -31,7 +31,8 @@ int irm_create_ipcp(rina_name_t name,
                     char * ipcp_type)
 {
         int sockfd;
-        struct irm_msg_sock msg;
+        struct irm_msg msg;
+        buffer_t * buf;
 
         if (!ipcp_type)
                 return -1;
@@ -41,10 +42,15 @@ int irm_create_ipcp(rina_name_t name,
                 return -1;
 
         msg.code = IRM_CREATE_IPCP;
-        msg.irm_msg.create_ipcp.name = name;
-        msg.irm_msg.create_ipcp.ipcp_type = ipcp_type;
+        msg.msgs.create_ipcp.name = &name;
+        msg.msgs.create_ipcp.ipcp_type = ipcp_type;
+
+        buf = serialize_irm_msg(&msg);
+        if (!buf)
+                return -1;
+
+        write(sockfd, buf->data, buf->size);
 
-        write(sockfd, &msg, sizeof(msg));
         close(sockfd);
 
         return 0;
diff --git a/src/lib/sockets.c b/src/lib/sockets.c
index 8917f55a..9985cd56 100644
--- a/src/lib/sockets.c
+++ b/src/lib/sockets.c
@@ -29,6 +29,9 @@
 #include <sys/un.h>
 #include <sys/stat.h>
 #include <string.h>
+#include <malloc.h>
+
+#define BUFFER_SIZE 256
 
 int client_socket_open(char * file_name)
 {
@@ -92,3 +95,193 @@ int server_socket_open(char * file_name)
 
         return sockfd;
 }
+
+static int serialized_string_len(uint8_t * data)
+{
+        uint8_t * seek = data;
+
+        while (*seek != '\0')
+                seek++;
+
+        return seek - data + 1;
+}
+
+static void ser_copy_value(size_t flen,
+                           void * dst,
+                           void * src,
+                           int * offset)
+{
+        memcpy(dst + *offset, src, flen);
+        *offset += flen;
+}
+
+static void deser_copy_value(size_t flen,
+                             void * dst,
+                             void * src,
+                             int * offset)
+{
+        memcpy(dst, src + *offset, flen);
+        *offset += flen;
+}
+
+static void deser_copy_string(uint8_t * data,
+                              char ** dst,
+                              int * offset)
+{
+        size_t flen;
+
+        flen = serialized_string_len(data + *offset);
+        *dst = malloc(flen + 1);
+        deser_copy_value(flen, *dst, data, offset);
+}
+
+static void deser_copy_int(uint8_t * data,
+                           int * dst,
+                           int * offset)
+{
+        *dst = 0;
+        deser_copy_value(sizeof(int), dst, data, offset);
+}
+
+static void deser_copy_enum(uint8_t * data,
+                            enum irm_msg_code * dst,
+                            int * offset)
+{
+        *dst = 0;
+        deser_copy_value(sizeof(enum irm_msg_code), dst, data, offset);
+}
+
+buffer_t * serialize_irm_msg(struct irm_msg * msg)
+{
+        buffer_t * buf;
+        uint8_t * data;
+        int offset = 0;
+        int i;
+        char buffer[BUFFER_SIZE];
+
+        buf = malloc(sizeof(buf));
+        buf->data = malloc(BUFFER_SIZE);
+        data = buf->data;
+
+        ser_copy_value(sizeof(enum irm_msg_code),
+                       data,
+                       &msg->code,
+                       &offset);
+
+        switch (msg->code) {
+        case IRM_CREATE_IPCP:
+                if (!msg->msgs.create_ipcp.name ||
+                    !msg->msgs.create_ipcp.name->ap_name ||
+                    !msg->msgs.create_ipcp.name->ae_name ||
+                    !msg->msgs.create_ipcp.ipcp_type) {
+                        LOG_ERR("Null pointer passed");
+                        free(buf->data);
+                        free(buf);
+                        return NULL;
+                }
+
+                ser_copy_value(strlen(msg->msgs.create_ipcp.name->ap_name) + 1,
+                               data,
+                               msg->msgs.create_ipcp.name->ap_name,
+                               &offset);
+
+                ser_copy_value(sizeof(int),
+                               data,
+                               &msg->msgs.create_ipcp.name->api_id,
+                               &offset);
+
+                ser_copy_value(strlen(msg->msgs.create_ipcp.name->ae_name) + 1,
+                               data,
+                               msg->msgs.create_ipcp.name->ae_name,
+                               &offset);
+
+                ser_copy_value(sizeof(int),
+                               data,
+                               &msg->msgs.create_ipcp.name->aei_id,
+                               &offset);
+
+                ser_copy_value(strlen(msg->msgs.create_ipcp.ipcp_type) + 1,
+                               data,
+                               msg->msgs.create_ipcp.ipcp_type,
+                               &offset);
+                break;
+        default:
+                LOG_ERR("Don't know that code");
+                free(buf->data);
+                free(buf);
+                return NULL;
+        }
+
+        buf->size = offset;
+
+        for (i = 0; i < buf->size; i++) {
+                if (i > 0) sprintf(buffer + strlen(buffer), ":");
+                sprintf(buffer + strlen(buffer), "%02X", data[i]);
+        }
+        LOG_DBGF("Serialized buffer to %s", buffer);
+
+        return buf;
+}
+
+struct irm_msg * deserialize_irm_msg(buffer_t * data)
+{
+        struct irm_msg * msg;
+        char buffer[BUFFER_SIZE];
+        int i;
+        int offset = 0;
+
+        if (!data || !data->data) {
+                LOG_ERR("Got a null pointer");
+                return NULL;
+        }
+
+        memset(buffer, 0, sizeof(buffer));
+        for (i = 0; i < data->size; i++) {
+                if (i > 0) sprintf(buffer + strlen(buffer), ":");
+                sprintf(buffer + strlen(buffer), "%02X", data->data[i]);
+        }
+        LOG_DBGF("Got buffer %s", buffer);
+
+        msg = malloc(sizeof(msg));
+        if (!msg) {
+                LOG_ERR("Failed to allocate memory");
+                return NULL;
+        }
+
+        deser_copy_enum(data->data,
+                        &msg->code,
+                        &offset);
+
+        switch (msg->code) {
+        case IRM_CREATE_IPCP:
+                msg->msgs.create_ipcp.name =
+                        malloc(sizeof(msg->msgs.create_ipcp.name));
+
+                deser_copy_string(data->data,
+                                  &msg->msgs.create_ipcp.name->ap_name,
+                                  &offset);
+
+                deser_copy_int(data->data,
+                               &msg->msgs.create_ipcp.name->api_id,
+                               &offset);
+
+                deser_copy_string(data->data,
+                                  &msg->msgs.create_ipcp.name->ae_name,
+                                  &offset);
+
+                deser_copy_int(data->data,
+                               &msg->msgs.create_ipcp.name->aei_id,
+                               &offset);
+
+                deser_copy_string(data->data,
+                                  &msg->msgs.create_ipcp.ipcp_type,
+                                  &offset);
+                break;
+        default:
+                LOG_ERR("Don't know that code");
+                free(msg);
+                return NULL;
+        }
+
+        return msg;
+}
diff --git a/src/tools/irm/main.c b/src/tools/irm/main.c
index 6439243c..470a8166 100644
--- a/src/tools/irm/main.c
+++ b/src/tools/irm/main.c
@@ -32,6 +32,8 @@ int main () {
         rina_name_t name;
         name.ap_name = ap_name;
         name.api_id = 1;
+        name.ae_name = "";
+        name.aei_id = 0;
 
         if (irm_create_ipcp(name, ipcp_type)) {
                 LOG_ERR("Failed to create IPCP");