Merge branch 'be' of bitbucket.org:ouroboros-rina/ouroboros into HEAD

8 files changed, 349 insertions, 825 deletions

diff --git a/src/lib/.gitignore b/src/lib/.gitignore
new file mode 100644
index 00000000..8704469b
--- /dev/null
+++ b/src/lib/.gitignore
@@ -0,0 +1 @@
+*.pb-c.[ch]
\ No newline at end of file
diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt
index 7a78bf3e..37222e58 100644
--- a/src/lib/CMakeLists.txt
+++ b/src/lib/CMakeLists.txt
@@ -4,41 +4,54 @@ include_directories(${CMAKE_CURRENT_BINARY_DIR})
 include_directories(${CMAKE_SOURCE_DIR}/include)
 include_directories(${CMAKE_BINARY_DIR}/include)
 
+find_package(ProtobufC REQUIRED)
+include_directories(${PROTOBUF_INCLUDE_DIRS})
+protobuf_generate_c(IRM_PROTO_SRCS IRM_PROTO_HDRS irmd_messages.proto)
+protobuf_generate_c(IPCP_PROTO_SRCS IPCP_PROTO_HDRS ipcpd_messages.proto)
+
 find_library(LIBRT_LIBRARIES rt)
 if(NOT LIBRT_LIBRARIES)
-       message(FATAL_ERROR "librt not found")
+  message(FATAL_ERROR "librt not found")
 endif()
 
 find_library(LIBPTHREAD_LIBRARIES pthread)
 if(NOT LIBPTHREAD_LIBRARIES)
-       message(FATAL_ERROR "libpthread not found")
+  message(FATAL_ERROR "libpthread not found")
 endif()
 
 set(SOURCE_FILES
-        # Add source files here
-        bitmap.c
-        cdap.c
-        da.c
-        dev.c
-        du_buff.c
-        flow.c
-        ipcp.c
-        irm.c
-        list.c
-        rina_name.c
-        shm_du_map.c
-        sockets.c
-        utils.c
-)
-
-add_library(ouroboros SHARED ${SOURCE_FILES})
-target_link_libraries(ouroboros ${LIBRT_LIBRARIES} ${LIBPTHREAD_LIBRARIES})
+  # Add source files here
+  bitmap.c
+  cdap.c
+  da.c
+  dev.c
+  du_buff.c
+  flow.c
+  ipcp.c
+  irm.c
+  list.c
+  rina_name.c
+  shm_du_map.c
+  sockets.c
+  utils.c
+  )
+
+install(FILES ${IRM_PROTO_HDRS} ${IPCP_PROTO_HDRS}
+  DESTINATION include/ouroboros)
+
+add_library(ouroboros SHARED ${SOURCE_FILES}
+  ${IRM_PROTO_SRCS} ${IPCP_PROTO_SRCS})
+
+target_link_libraries(ouroboros ${LIBRT_LIBRARIES}
+  ${LIBPTHREAD_LIBRARIES} ${PROTOBUF_C_LIBRARY})
 
 include(MacroAddCompileFlags)
 if (CMAKE_BUILD_TYPE MATCHES Debug)
-   MACRO_ADD_COMPILE_FLAGS(ouroboros -DCONFIG_OUROBOROS_DEBUG)
+  MACRO_ADD_COMPILE_FLAGS(ouroboros -DCONFIG_OUROBOROS_DEBUG)
 endif (CMAKE_BUILD_TYPE MATCHES Debug)
 
 install(TARGETS ouroboros LIBRARY DESTINATION lib)
 
+target_include_directories(ouroboros PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
+
 add_subdirectory(tests)
diff --git a/src/lib/dev.c b/src/lib/dev.c
index 7c0c8a15..5c11d8bf 100644
--- a/src/lib/dev.c
+++ b/src/lib/dev.c
@@ -32,30 +32,29 @@ int ap_reg(char * ap_name,
            char ** difs,
            size_t difs_size)
 {
-        struct irm_msg msg;
-        struct irm_msg * recv_msg = NULL;
+        irm_msg_t msg = IRM_MSG__INIT;
+        irm_msg_t * recv_msg = NULL;
         int fd = 0;
 
         if (ap_name == NULL ||
             difs == NULL ||
-            difs_size == 0) {
-                LOG_ERR("Invalid arguments");
-                return -1;
+            difs_size == 0 ||
+            difs[0] == NULL) {
+                return -EINVAL;
         }
 
-        msg.code = IRM_AP_REG;
+        msg.code = IRM_MSG_CODE__IRM_AP_REG;
         msg.ap_name = ap_name;
-        msg.difs = difs;
-        msg.difs_size = difs_size;
+        msg.dif_name = difs;
+        msg.n_dif_name = difs_size;
 
-        recv_msg = send_recv_irmd_msg(&msg);
+        recv_msg = send_recv_irm_msg(&msg);
         if (recv_msg == NULL) {
-                LOG_ERR("Failed to send and receive message");
                 return -1;
         }
 
         fd = recv_msg->fd;
-        free(recv_msg);
+        irm_msg__free_unpacked(recv_msg, NULL);
 
         return fd;
 }
@@ -64,21 +63,21 @@ int ap_unreg(char * ap_name,
              char ** difs,
              size_t difs_size)
 {
-        struct irm_msg msg;
+        irm_msg_t msg = IRM_MSG__INIT;
 
         if (ap_name == NULL ||
             difs == NULL ||
-            difs_size == 0) {
-                LOG_ERR("Invalid arguments");
-                return -1;
+            difs_size == 0 ||
+            difs[0] == NULL) {
+                return -EINVAL;
         }
 
-        msg.code = IRM_AP_UNREG;
+        msg.code = IRM_MSG_CODE__IRM_AP_UNREG;
         msg.ap_name = ap_name;
-        msg.difs = difs;
-        msg.difs_size = difs_size;
+        msg.dif_name = difs;
+        msg.n_dif_name = difs_size;
 
-        if (send_irmd_msg(&msg)) {
+        if (send_irm_msg(&msg)) {
                 LOG_ERR("Failed to send message to daemon");
                 return -1;
         }
@@ -90,45 +89,47 @@ int flow_accept(int fd,
                 char * ap_name,
                 char * ae_name)
 {
-        struct irm_msg msg;
-        struct irm_msg * recv_msg = NULL;
+        irm_msg_t msg = IRM_MSG__INIT;
+        irm_msg_t * recv_msg = NULL;
         int cli_fd = 0;
 
         if (ap_name == NULL) {
-                LOG_ERR("Invalid arguments");
-                return -1;
+                return -EINVAL;
         }
 
-        msg.code = IRM_FLOW_ACCEPT;
+        msg.code = IRM_MSG_CODE__IRM_FLOW_ACCEPT;
+        msg.has_fd = true;
         msg.fd = fd;
 
-        recv_msg = send_recv_irmd_msg(&msg);
+        recv_msg = send_recv_irm_msg(&msg);
         if (recv_msg == NULL) {
-                LOG_ERR("Failed to send and receive message");
                 return -1;
         }
 
+        if (recv_msg->has_fd == false) {
+                irm_msg__free_unpacked(recv_msg, NULL);
+                return -1;
+        }
         cli_fd = recv_msg->fd;
         ap_name = recv_msg->ap_name;
-        if (ae_name == NULL)
-                ae_name = "";
-        else
-                ae_name = recv_msg->ae_name;
-        free(recv_msg);
+        ae_name = recv_msg->ae_name;
 
+        irm_msg__free_unpacked(recv_msg, NULL);
         return cli_fd;
 }
 
 int flow_alloc_resp(int fd,
                     int result)
 {
-        struct irm_msg msg;
+        irm_msg_t msg = IRM_MSG__INIT;
 
-        msg.code = IRM_FLOW_ALLOC_RESP;
+        msg.code = IRM_MSG_CODE__IRM_FLOW_ALLOC_RESP;
+        msg.has_fd = true;
         msg.fd = fd;
+        msg.has_result = true;
         msg.result = result;
 
-        if (send_irmd_msg(&msg)) {
+        if (send_irm_msg(&msg)) {
                 LOG_ERR("Failed to send message to daemon");
                 return -1;
         }
@@ -142,67 +143,74 @@ int flow_alloc(char * dst_ap_name,
                struct qos_spec * qos,
                int oflags)
 {
-        struct irm_msg msg;
-        struct irm_msg * recv_msg = NULL;
+        irm_msg_t msg = IRM_MSG__INIT;
+        irm_msg_t * recv_msg = NULL;
         int fd = 0;
 
         if (dst_ap_name == NULL ||
-            src_ap_name == NULL) {
+            src_ap_name == NULL ||
+            qos == NULL) {
                 LOG_ERR("Invalid arguments");
                 return -1;
         }
 
-        msg.code = IRM_FLOW_ALLOC;
+        msg.code = IRM_MSG_CODE__IRM_FLOW_ALLOC;
         msg.dst_ap_name = dst_ap_name;
         msg.ap_name = src_ap_name;
-        if (src_ae_name == NULL)
-                msg.ae_name = "";
-        else
-                msg.ae_name = src_ae_name;
-        msg.qos = qos;
+        msg.ae_name = src_ae_name;
+        msg.has_oflags = true;
         msg.oflags = oflags;
 
-        recv_msg = send_recv_irmd_msg(&msg);
+        recv_msg = send_recv_irm_msg(&msg);
         if (recv_msg == NULL) {
-                LOG_ERR("Failed to send and receive message");
                 return -1;
         }
 
-        fd = recv_msg->fd;
-        free(recv_msg);
+        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 flow_alloc_res(int fd)
 {
-        struct irm_msg msg;
-        struct irm_msg * recv_msg = NULL;
+        irm_msg_t msg = IRM_MSG__INIT;
+        irm_msg_t * recv_msg = NULL;
         int result = 0;
 
-        msg.code = IRM_FLOW_ALLOC_RES;
+        msg.code = IRM_MSG_CODE__IRM_FLOW_ALLOC_RES;
+        msg.has_fd = true;
         msg.fd = fd;
 
-        recv_msg = send_recv_irmd_msg(&msg);
+        recv_msg = send_recv_irm_msg(&msg);
         if (recv_msg == NULL) {
-                LOG_ERR("Failed to send and receive message");
+                return -1;
+        }
+
+        if (recv_msg->has_result == false) {
+                irm_msg__free_unpacked(recv_msg, NULL);
                 return -1;
         }
 
         result = recv_msg->result;
-        free(recv_msg);
+        irm_msg__free_unpacked(recv_msg, NULL);
 
         return result;
 }
 
 int flow_dealloc(int fd)
 {
-        struct irm_msg msg;
+        irm_msg_t msg = IRM_MSG__INIT;
 
-        msg.code = IRM_FLOW_DEALLOC;
+        msg.code = IRM_MSG_CODE__IRM_FLOW_DEALLOC;
+        msg.has_fd = true;
         msg.fd = fd;
 
-        if (send_irmd_msg(&msg)) {
+        if (send_irm_msg(&msg)) {
                 LOG_ERR("Failed to send message to daemon");
                 return -1;
         }
@@ -212,12 +220,13 @@ int flow_dealloc(int fd)
 
 int flow_cntl(int fd, int oflags)
 {
-        struct irm_msg msg;
+        irm_msg_t msg = IRM_MSG__INIT;
 
+        msg.has_fd = true;
         msg.fd = fd;
         msg.oflags = oflags;
 
-        if (send_irmd_msg(&msg)) {
+        if (send_irm_msg(&msg)) {
                 LOG_ERR("Failed to send message to daemon");
                 return -1;
         }
diff --git a/src/lib/ipcp.c b/src/lib/ipcp.c
index 53d717ba..445160f0 100644
--- a/src/lib/ipcp.c
+++ b/src/lib/ipcp.c
@@ -40,10 +40,10 @@
 #include <sys/wait.h>
 
 static int send_ipcp_msg(pid_t pid,
-                         struct ipcp_msg * msg)
+                         ipcp_msg_t * msg)
 {
        int sockfd = 0;
-       buffer_t * buf = NULL;
+       buffer_t buf;
        char * sock_path;
 
        sock_path = ipcp_sock_path(pid);
@@ -56,24 +56,31 @@ static int send_ipcp_msg(pid_t pid,
                return -1;
        }
 
-       buf = serialize_ipcp_msg(msg);
-       if (buf == NULL) {
-               free(sock_path);
+       buf.size = ipcp_msg__get_packed_size(msg);
+       if (buf.size == 0) {
                close(sockfd);
+               free(sock_path);
                return -1;
        }
 
-       if (write(sockfd, buf->data, buf->size) == -1) {
+       buf.data = malloc(buf.size);
+       if (buf.data == NULL) {
+               close(sockfd);
+               free(sock_path);
+               return -ENOMEM;
+       }
+
+       ipcp_msg__pack(msg, buf.data);
+
+       if (write(sockfd, buf.data, buf.size) == -1) {
                free(sock_path);
-               free(buf->data);
-               free(buf);
+               free(buf.data);
                close(sockfd);
                return -1;
        }
 
-       free(buf->data);
-       free(buf);
-
+       free(buf.data);
+       free(sock_path);
        close(sockfd);
        return 0;
 }
@@ -158,14 +165,16 @@ int ipcp_reg(pid_t pid,
              char ** difs,
              size_t difs_size)
 {
-        struct ipcp_msg msg;
+        ipcp_msg_t msg = IPCP_MSG__INIT;
 
-        if (difs == NULL)
-                return -1;
+        if (difs == NULL ||
+            difs_size == 0 ||
+            difs[0] == NULL)
+                return -EINVAL;
 
-        msg.code = IPCP_REG;
-        msg.difs = difs;
-        msg.difs_size = difs_size;
+        msg.code = IPCP_MSG_CODE__IPCP_REG;
+        msg.dif_name = difs;
+        msg.n_dif_name = difs_size;
 
         if (send_ipcp_msg(pid, &msg)) {
                 LOG_ERR("Failed to send message to daemon");
@@ -179,14 +188,16 @@ int ipcp_unreg(pid_t pid,
                char ** difs,
                size_t difs_size)
 {
-        struct ipcp_msg msg;
+        ipcp_msg_t msg = IPCP_MSG__INIT;
 
-        if (difs == NULL)
-                return -1;
+        if (difs == NULL ||
+            difs_size == 0 ||
+            difs[0] == NULL)
+                return -EINVAL;
 
-        msg.code = IPCP_UNREG;
-        msg.difs = difs;
-        msg.difs_size = difs_size;
+        msg.code = IPCP_MSG_CODE__IPCP_UNREG;
+        msg.dif_name = difs;
+        msg.n_dif_name = difs_size;
 
         if (send_ipcp_msg(pid, &msg)) {
                 LOG_ERR("Failed to send message to daemon");
@@ -197,12 +208,11 @@ int ipcp_unreg(pid_t pid,
 }
 
 int ipcp_bootstrap(pid_t pid,
-                   struct dif_config conf)
+                   struct dif_config * conf)
 {
-        struct ipcp_msg msg;
+        ipcp_msg_t msg = IPCP_MSG__INIT;
 
-        msg.code = IPCP_BOOTSTRAP;
-        msg.conf = &conf;
+        msg.code = IPCP_MSG_CODE__IPCP_BOOTSTRAP;
 
         if (send_ipcp_msg(pid, &msg)) {
                 LOG_ERR("Failed to send message to daemon");
@@ -218,24 +228,32 @@ int ipcp_enroll(pid_t pid,
                 char ** n_1_difs,
                 ssize_t n_1_difs_size)
 {
-        struct ipcp_msg msg;
-
-        if (n_1_difs == NULL)
-                return -1;
-
-        if (dif_name == NULL)
+        ipcp_msg_t msg = IPCP_MSG__INIT;
+
+        if (n_1_difs == NULL ||
+            n_1_difs_size == 0 ||
+            n_1_difs[0] == NULL ||
+            dif_name == NULL ||
+            member_name == NULL)
+                return -EINVAL;
+
+        msg.code = IPCP_MSG_CODE__IPCP_ENROLL;
+        msg.dif_name = malloc(sizeof(*(msg.dif_name)));
+        if (msg.dif_name == NULL) {
+                LOG_ERR("Failed to malloc");
                 return -1;
-
-        msg.code = IPCP_ENROLL;
-        msg.dif_name = dif_name;
+        }
+        msg.dif_name[0] = dif_name;
         msg.ap_name = member_name;
-        msg.difs = n_1_difs;
-        msg.difs_size = n_1_difs_size;
+        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");
+                free(msg.dif_name);
                 return -1;
         }
 
+        free(msg.dif_name);
         return 0;
 }
diff --git a/src/lib/ipcpd_messages.proto b/src/lib/ipcpd_messages.proto
new file mode 100644
index 00000000..0715fbe0
--- /dev/null
+++ b/src/lib/ipcpd_messages.proto
@@ -0,0 +1,14 @@
+enum ipcp_msg_code {
+        IPCP_BOOTSTRAP = 1;
+        IPCP_ENROLL = 2;
+        IPCP_REG = 3;
+        IPCP_UNREG = 4;
+};
+
+message ipcp_msg {
+        required ipcp_msg_code code = 1;
+        optional string ap_name = 2;
+        // Missing dif_config field here
+        repeated string dif_name = 4;
+        repeated string n_1_dif_name = 5;
+};
diff --git a/src/lib/irm.c b/src/lib/irm.c
index 9fd13d52..92d8b3a5 100644
--- a/src/lib/irm.c
+++ b/src/lib/irm.c
@@ -26,26 +26,25 @@
 #include <ouroboros/common.h>
 #include <ouroboros/logs.h>
 #include <ouroboros/sockets.h>
+
 #include <stdlib.h>
 
-int irm_create_ipcp(rina_name_t name,
+int irm_create_ipcp(char * ap_name,
+                    int api_id,
                     char * ipcp_type)
 {
-        struct irm_msg msg;
+        irm_msg_t msg = IRM_MSG__INIT;
 
-        if (ipcp_type == NULL)
-                return -1;
+        if (ipcp_type == NULL || ap_name == NULL)
+                return -EINVAL;
 
-        if (!name_is_ok(&name)) {
-                LOG_ERR("Bad name");
-                return -1;
-        }
-
-        msg.code = IRM_CREATE_IPCP;
-        msg.name = &name;
+        msg.code = IRM_MSG_CODE__IRM_CREATE_IPCP;
+        msg.ap_name = ap_name;
+        msg.has_api_id = true;
+        msg.api_id = api_id;
         msg.ipcp_type = ipcp_type;
 
-        if (send_irmd_msg(&msg)) {
+        if (send_irm_msg(&msg)) {
                 LOG_ERR("Failed to send message to daemon");
                 return -1;
         }
@@ -53,19 +52,21 @@ int irm_create_ipcp(rina_name_t name,
         return 0;
 }
 
-int irm_destroy_ipcp(rina_name_t name)
+int irm_destroy_ipcp(char * ap_name,
+                     int api_id)
 {
-        struct irm_msg msg;
+        irm_msg_t msg = IRM_MSG__INIT;
 
-        if (!name_is_ok(&name)) {
-                LOG_ERR("Bad name");
-                return -1;
+        if (ap_name == NULL) {
+                return -EINVAL;
         }
 
-        msg.code = IRM_DESTROY_IPCP;
-        msg.name = &name;
+        msg.code = IRM_MSG_CODE__IRM_DESTROY_IPCP;
+        msg.ap_name = ap_name;
+        msg.has_api_id = true;
+        msg.api_id = api_id;
 
-        if (send_irmd_msg(&msg)) {
+        if (send_irm_msg(&msg)) {
                 LOG_ERR("Failed to send message to daemon");
                 return -1;
         }
@@ -73,21 +74,22 @@ int irm_destroy_ipcp(rina_name_t name)
         return 0;
 }
 
-int irm_bootstrap_ipcp(rina_name_t name,
-                       struct dif_config conf)
+int irm_bootstrap_ipcp(char * ap_name,
+                       int api_id,
+                       struct dif_config * conf)
 {
-        struct irm_msg msg;
+        irm_msg_t msg = IRM_MSG__INIT;
 
-        if (!name_is_ok(&name)) {
-                LOG_ERR("Bad name");
-                return -1;
+        if (ap_name == NULL || conf == NULL) {
+                return -EINVAL;
         }
 
-        msg.code = IRM_BOOTSTRAP_IPCP;
-        msg.name = &name;
-        msg.conf = &conf;
+        msg.code = IRM_MSG_CODE__IRM_BOOTSTRAP_IPCP;
+        msg.ap_name = ap_name;
+        msg.has_api_id = true;
+        msg.api_id = api_id;
 
-        if (send_irmd_msg(&msg)) {
+        if (send_irm_msg(&msg)) {
                 LOG_ERR("Failed to send message to daemon");
                 return -1;
         }
@@ -95,45 +97,61 @@ int irm_bootstrap_ipcp(rina_name_t name,
         return 0;
 }
 
-int irm_enroll_ipcp(rina_name_t name,
+int irm_enroll_ipcp(char * ap_name,
+                    int api_id,
                     char * dif_name)
 {
-        struct irm_msg msg;
+        irm_msg_t msg = IRM_MSG__INIT;
 
-        if (!name_is_ok(&name)) {
-                LOG_ERR("Bad name");
-                return -1;
+        if (ap_name == NULL || dif_name == NULL) {
+                return -EINVAL;
         }
 
-        msg.code = IRM_ENROLL_IPCP;
-        msg.name = &name;
-        msg.dif_name = dif_name;
+        msg.code = IRM_MSG_CODE__IRM_ENROLL_IPCP;
+        msg.ap_name = ap_name;
+        msg.has_api_id = true;
+        msg.api_id = api_id;
+        msg.n_dif_name = 1;
+        msg.dif_name = malloc(sizeof(*(msg.dif_name)));
+        if (msg.dif_name == NULL) {
+                LOG_ERR("Failed to malloc");
+                return -1;
+        }
+        msg.dif_name[0] = dif_name;
 
-        if (send_irmd_msg(&msg)) {
+        if (send_irm_msg(&msg)) {
                 LOG_ERR("Failed to send message to daemon");
+                free(msg.dif_name);
                 return -1;
         }
 
+        free(msg.dif_name);
+
         return 0;
 }
 
-int irm_reg_ipcp(rina_name_t name,
+int irm_reg_ipcp(char * ap_name,
+                 int api_id,
                  char ** difs,
                  size_t difs_size)
 {
-        struct irm_msg msg;
+        irm_msg_t msg = IRM_MSG__INIT;
 
-        if (!name_is_ok(&name)) {
-                LOG_ERR("Bad name");
-                return -1;
+        if (ap_name == NULL ||
+            difs == NULL ||
+            difs_size == 0 ||
+            difs[0] == NULL) {
+                return -EINVAL;
         }
 
-        msg.code = IRM_REG_IPCP;
-        msg.name = &name;
-        msg.difs = difs;
-        msg.difs_size = difs_size;
+        msg.code = IRM_MSG_CODE__IRM_REG_IPCP;
+        msg.ap_name = ap_name;
+        msg.has_api_id = true;
+        msg.api_id = api_id;
+        msg.dif_name = difs;
+        msg.n_dif_name = difs_size;
 
-        if (send_irmd_msg(&msg)) {
+        if (send_irm_msg(&msg)) {
                 LOG_ERR("Failed to send message to daemon");
                 return -1;
         }
@@ -141,23 +159,28 @@ int irm_reg_ipcp(rina_name_t name,
         return 0;
 }
 
-int irm_unreg_ipcp(rina_name_t name,
+int irm_unreg_ipcp(char * ap_name,
+                   int api_id,
                    char ** difs,
                    size_t difs_size)
 {
-        struct irm_msg msg;
+        irm_msg_t msg = IRM_MSG__INIT;
 
-        if (!name_is_ok(&name)) {
-                LOG_ERR("Bad name");
-                return -1;
+        if (ap_name == NULL ||
+            difs == NULL ||
+            difs_size == 0 ||
+            difs[0] == NULL) {
+                return -EINVAL;
         }
 
-        msg.code = IRM_UNREG_IPCP;
-        msg.name = &name;
-        msg.difs = difs;
-        msg.difs_size = difs_size;
+        msg.code = IRM_MSG_CODE__IRM_UNREG_IPCP;
+        msg.ap_name = ap_name;
+        msg.has_api_id = true;
+        msg.api_id = api_id;
+        msg.dif_name = difs;
+        msg.n_dif_name = difs_size;
 
-        if (send_irmd_msg(&msg)) {
+        if (send_irm_msg(&msg)) {
                 LOG_ERR("Failed to send message to daemon");
                 return -1;
         }
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;
+};
diff --git a/src/lib/sockets.c b/src/lib/sockets.c
index b157b628..a699206d 100644
--- a/src/lib/sockets.c
+++ b/src/lib/sockets.c
@@ -96,76 +96,93 @@ int server_socket_open(char * file_name)
         return sockfd;
 }
 
-int send_irmd_msg(struct irm_msg * msg)
+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 = serialize_irm_msg(msg);
-       if (buf == NULL) {
-               close(sockfd);
-               return -1;
-       }
-
-       if (write(sockfd, buf->data, buf->size) == -1) {
-               free(buf->data);
-               free(buf);
-               close(sockfd);
-               return -1;
-       }
-
-       free(buf->data);
-       free(buf);
-
-       close(sockfd);
-       return 0;
+        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;
 }
 
-struct irm_msg * send_recv_irmd_msg(struct irm_msg * msg)
+irm_msg_t * send_recv_irm_msg(irm_msg_t * msg)
 {
         int sockfd;
-        buffer_t * buf;
+        buffer_t buf;
         ssize_t count = 0;
-        struct irm_msg * recv_msg = NULL;
+        irm_msg_t * recv_msg = NULL;
 
         sockfd = client_socket_open(IRM_SOCK_PATH);
         if (sockfd < 0)
                 return NULL;
 
-        buf = serialize_irm_msg(msg);
-        if (buf == NULL) {
+        buf.size = irm_msg__get_packed_size(msg);
+        if (buf.size == 0) {
                 close(sockfd);
                 return NULL;
         }
 
-        if (write(sockfd, buf->data, buf->size) == -1) {
-                free(buf->data);
-                free(buf);
+        LOG_DBG("Size will be %lu", buf.size);
+        buf.data = malloc(buf.size);
+        if (buf.data == NULL) {
                 close(sockfd);
                 return NULL;
         }
 
-        count = read(sockfd, buf->data, IRM_MSG_BUF_SIZE);
-        if (count <= 0) {
-                free(buf->data);
-                free(buf);
+        irm_msg__pack(msg, buf.data);
+
+        if (write(sockfd, buf.data, buf.size) == -1) {
+                free(buf.data);
                 close(sockfd);
                 return NULL;
         }
 
-        recv_msg = deserialize_irm_msg(buf);
+        count = read(sockfd, buf.data, IRM_MSG_BUF_SIZE);
+        if (count <= 0) {
+                free(buf.data);
+                close(sockfd);
+                return NULL;
+        }
 
-        free(buf->data);
-        free(buf);
+        recv_msg = irm_msg__unpack(NULL, count, buf.data);
+        if (recv_msg == NULL) {
+                free(buf.data);
+                close(sockfd);
+                return NULL;
+        }
 
+        free(buf.data);
         close(sockfd);
         return recv_msg;
 }
 
+
 char * ipcp_sock_path(pid_t pid)
 {
         char * full_name = NULL;
@@ -196,611 +213,3 @@ char * ipcp_sock_path(pid_t pid)
 
         return full_name;
 }
-
-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 ser_copy_name(rina_name_t * name,
-                          uint8_t * data,
-                          int * offset)
-{
-        ser_copy_value(strlen(name->ap_name) + 1,
-                       data, name->ap_name, offset);
-        ser_copy_value(sizeof(int), data,
-                       &name->api_id, offset);
-}
-
-static void deser_copy_value(size_t flen,
-                             void * dst,
-                             void * src,
-                             int * offset)
-{
-        memcpy(dst, src + *offset, flen);
-        *offset += flen;
-}
-
-static int deser_copy_string(uint8_t * data,
-                             char ** dst,
-                             int * offset)
-{
-        size_t flen;
-
-        flen = serialized_string_len(data + *offset);
-        *dst = malloc(sizeof(**dst) * (flen + 1));
-        if (*dst == NULL)
-                return -1;
-        deser_copy_value(flen, *dst, data, offset);
-        return 0;
-}
-
-static void deser_copy_int(uint8_t * data,
-                           unsigned int * dst,
-                           int * offset)
-{
-        *dst = 0;
-        deser_copy_value(sizeof(int), dst, data, offset);
-}
-
-static void deser_copy_size_t(uint8_t * data,
-                              size_t * dst,
-                              int * offset)
-{
-        *dst = 0;
-        deser_copy_value(sizeof(size_t), dst, data, offset);
-}
-
-static rina_name_t * deser_copy_name(uint8_t * data,
-                                     int * offset)
-{
-        rina_name_t * name;
-
-        name = name_create();
-        if (name == NULL) {
-                LOG_ERR("Failed to alloc memory");
-                return NULL;
-        }
-
-        if (deser_copy_string(data, &name->ap_name, offset)) {
-                name_destroy(name);
-                return NULL;
-        }
-
-        deser_copy_int(data, &name->api_id, offset);
-
-        return name;
-}
-
-
-/* Move these to a separate file? */
-static buffer_t * buffer_create()
-{
-        buffer_t * buf;
-
-        buf = malloc(sizeof(*buf));
-        if (buf == NULL)
-                return NULL;
-
-        buf->data = malloc(IRM_MSG_BUF_SIZE);
-        if (buf->data == NULL) {
-                free(buf);
-                return NULL;
-        }
-
-        return buf;
-}
-
-static void buffer_destroy(buffer_t * buf)
-{
-        if (buf->data != NULL)
-                free(buf->data);
-
-        if (buf != NULL)
-                free(buf);
-}
-
-buffer_t * serialize_irm_msg(struct irm_msg * msg)
-{
-        buffer_t * buf;
-        uint8_t * data;
-        int offset = 0;
-        int i;
-        char ** pos;
-
-        if (msg == NULL)
-                return NULL;
-
-        buf = buffer_create();
-        if (buf == NULL)
-                return NULL;
-
-        data = buf->data;
-
-        ser_copy_value(sizeof(enum irm_msg_code), data, &msg->code, &offset);
-
-        ser_copy_name(msg->name, data, &offset);
-
-        switch (msg->code) {
-        case IRM_CREATE_IPCP:
-                if (msg->ipcp_type == NULL ||
-                    !name_is_ok(msg->name)) {
-                        LOG_ERR("Null pointer passed");
-                        buffer_destroy(buf);
-                        return NULL;
-                }
-                ser_copy_name(msg->name, data, &offset);
-                ser_copy_value(strlen(msg->ipcp_type) + 1, data,
-                               msg->ipcp_type, &offset);
-                break;
-        case IRM_DESTROY_IPCP:
-                if (!name_is_ok(msg->name)) {
-                        LOG_ERR("Null pointer passed");
-                        buffer_destroy(buf);
-                        return NULL;
-                }
-                ser_copy_name(msg->name, data, &offset);
-                break;
-        case IRM_BOOTSTRAP_IPCP:
-                if (!name_is_ok(msg->name)) {
-                        LOG_ERR("Null pointer passed");
-                        buffer_destroy(buf);
-                        return NULL;
-                }
-                ser_copy_name(msg->name, data, &offset);
-                /* FIXME: Fields missing, need to define dif_conf properly */
-                break;
-        case IRM_ENROLL_IPCP:
-                if (msg->dif_name == NULL ||
-                    !name_is_ok(msg->name)) {
-                        buffer_destroy(buf);
-                        return NULL;
-                }
-
-                ser_copy_name(msg->name, data, &offset);
-                ser_copy_value(strlen(msg->dif_name) + 1, data,
-                               msg->dif_name, &offset);
-
-                break;
-        case IRM_REG_IPCP:
-        case IRM_UNREG_IPCP:
-                if (msg->difs == NULL ||
-                    msg->difs[0] == NULL ||
-                    !name_is_ok(msg->name)) {
-                        buffer_destroy(buf);
-                        return NULL;
-                }
-
-                ser_copy_name(msg->name, data, &offset);
-
-                ser_copy_value(sizeof(size_t), data, &msg->difs_size, &offset);
-
-                pos = msg->difs;
-                for (i = 0; i < msg->difs_size; i++) {
-                        ser_copy_value(strlen(*pos) + 1, data, *pos, &offset);
-                        pos++;
-                }
-
-                break;
-        case IRM_AP_REG:
-        case IRM_AP_UNREG:
-                if (msg->ap_name == NULL ||
-                    msg->difs == NULL ||
-                    msg->difs[0] == NULL) {
-                        LOG_ERR("Invalid arguments");
-                        buffer_destroy(buf);
-                        return NULL;
-                }
-
-                ser_copy_value(strlen(msg->ap_name) + 1,
-                               data, msg->ap_name, &offset);
-
-                ser_copy_value(sizeof(size_t), data, &msg->difs_size, &offset);
-
-                pos = msg->difs;
-                for (i = 0; i < msg->difs_size; i++) {
-                        ser_copy_value(strlen(*pos) + 1, data, *pos, &offset);
-                        pos++;
-                }
-
-                break;
-        case IRM_FLOW_ACCEPT:
-                if (msg->ap_name == NULL ||
-                    msg->ae_name == NULL) {
-                        LOG_ERR("Invalid arguments");
-                        buffer_destroy(buf);
-                        return NULL;
-                }
-
-                ser_copy_value(sizeof(int), data, &msg->fd, &offset);
-
-                ser_copy_value(strlen(msg->ap_name) + 1,
-                               data, msg->ap_name, &offset);
-
-                ser_copy_value(strlen(msg->ae_name) + 1,
-                               data, msg->ae_name, &offset);
-
-                break;
-        case IRM_FLOW_ALLOC_RESP:
-                ser_copy_value(sizeof(int), data, &msg->fd, &offset);
-
-                ser_copy_value(sizeof(int), data, &msg->result, &offset);
-
-                break;
-        case IRM_FLOW_ALLOC:
-                if (msg->ap_name == NULL ||
-                    msg->ae_name == NULL ||
-                    msg->dst_ap_name == NULL ||
-                    msg->qos == NULL) {
-                        LOG_ERR("Invalid arguments");
-                        buffer_destroy(buf);
-                        return NULL;
-                }
-
-                ser_copy_value(strlen(msg->dst_ap_name) + 1,
-                               data, msg->dst_ap_name, &offset);
-
-                ser_copy_value(strlen(msg->ap_name) + 1,
-                               data, msg->ap_name, &offset);
-
-                ser_copy_value(strlen(msg->ae_name) + 1,
-                               data, msg->ae_name, &offset);
-
-                /* FIXME: Serialize qos spec here */
-
-                ser_copy_value(sizeof(int), data, &msg->oflags, &offset);
-
-                break;
-        case IRM_FLOW_ALLOC_RES:
-        case IRM_FLOW_DEALLOC:
-                ser_copy_value(sizeof(int), data, &msg->fd, &offset);
-                break;
-        case IRM_FLOW_CONTROL:
-                ser_copy_value(sizeof(int), data, &msg->fd, &offset);
-                ser_copy_value(sizeof(int), data, &msg->oflags, &offset);
-                break;
-        case IRM_FLOW_WRITE:
-                LOG_MISSING;
-                break;
-        case IRM_FLOW_READ:
-                LOG_MISSING;
-                break;
-        case IRM_AP_REG_R:
-        case IRM_FLOW_ALLOC_R:
-                ser_copy_value(sizeof(int), data, &msg->fd, &offset);
-                break;
-        case IRM_FLOW_ACCEPT_R:
-                ser_copy_value(sizeof(int), data, &msg->fd, &offset);
-
-                ser_copy_value(strlen(msg->ap_name) + 1,
-                               data, msg->ap_name, &offset);
-
-                ser_copy_value(strlen(msg->ae_name) + 1,
-                               data, msg->ae_name, &offset);
-                break;
-        case IRM_FLOW_ALLOC_RES_R:
-                ser_copy_value(sizeof(int), data, &msg->result, &offset);
-                break;
-        default:
-                LOG_ERR("Don't know that code");
-                buffer_destroy(buf);
-                return NULL;
-        }
-
-        buf->size = offset;
-
-        return buf;
-}
-
-struct irm_msg * deserialize_irm_msg(buffer_t * data)
-{
-        struct irm_msg * msg;
-        int i, j;
-        int offset = 0;
-        size_t difs_size;
-
-        if (data == NULL || data->data == NULL) {
-                LOG_ERR("Got a null pointer");
-                return NULL;
-        }
-
-        msg = malloc(sizeof(*msg));
-        if (msg == NULL) {
-                LOG_ERR("Failed to allocate memory");
-                return NULL;
-        }
-
-        deser_copy_value(sizeof(enum irm_msg_code),
-                         &msg->code, data->data, &offset);
-
-        switch (msg->code) {
-        case IRM_CREATE_IPCP:
-                msg->name = deser_copy_name(data->data, &offset);
-                if (msg->name == NULL) {
-                        LOG_ERR("Failed to reconstruct name");
-                        free(msg);
-                        return NULL;
-                }
-
-                if (deser_copy_string(data->data,
-                                      &msg->ipcp_type,
-                                      &offset)) {
-                        name_destroy(msg->name);
-                        free(msg);
-                        return NULL;
-                }
-
-                break;
-        case IRM_DESTROY_IPCP:
-                msg->name = deser_copy_name(data->data, &offset);
-                if (msg->name == NULL) {
-                        LOG_ERR("Failed to reconstruct name");
-                        free(msg);
-                        return NULL;
-                }
-
-                break;
-        case IRM_BOOTSTRAP_IPCP:
-                msg->name = deser_copy_name(data->data, &offset);
-                if (msg->name == NULL) {
-                        LOG_ERR("Failed to reconstruct name");
-                        free(msg);
-                        return NULL;
-                }
-
-                break;
-        case IRM_ENROLL_IPCP:
-                msg->name = deser_copy_name(data->data, &offset);
-                if (msg->name == NULL) {
-                        LOG_ERR("Failed to reconstruct name");
-                        free(msg);
-                        return NULL;
-                }
-
-                if (deser_copy_string(data->data,
-                                      &msg->dif_name,
-                                      &offset)) {
-                        name_destroy(msg->name);
-                        free(msg);
-                        return NULL;
-                }
-
-                break;
-        case IRM_REG_IPCP:
-        case IRM_UNREG_IPCP:
-                msg->name = deser_copy_name(data->data, &offset);
-                if (msg->name == NULL) {
-                        LOG_ERR("Failed to reconstruct name");
-                        free(msg);
-                        return NULL;
-                }
-
-                deser_copy_size_t(data->data, &difs_size, &offset);
-                msg->difs_size = difs_size;
-
-                msg->difs = malloc(sizeof(*(msg->difs)) * difs_size);
-                if (msg->difs == NULL) {
-                        name_destroy(msg->name);
-                        free(msg);
-                        return NULL;
-                }
-
-                for (i = 0; i < difs_size; i++) {
-                        if (deser_copy_string(data->data,
-                                              &msg->difs[i],
-                                              &offset)) {
-                                for (j = 0; j < i; j++)
-                                        free(msg->difs[j]);
-                                free(msg->difs);
-                                name_destroy(msg->name);
-                                free(msg);
-                                return NULL;
-                        }
-                }
-
-                break;
-        case IRM_AP_REG:
-        case IRM_AP_REG_R:
-        case IRM_AP_UNREG:
-        case IRM_FLOW_ACCEPT:
-        case IRM_FLOW_ACCEPT_R:
-        case IRM_FLOW_ALLOC_RESP:
-        case IRM_FLOW_ALLOC:
-        case IRM_FLOW_ALLOC_R:
-        case IRM_FLOW_ALLOC_RES:
-        case IRM_FLOW_ALLOC_RES_R:
-        case IRM_FLOW_DEALLOC:
-        case IRM_FLOW_CONTROL:
-        case IRM_FLOW_WRITE:
-        case IRM_FLOW_READ:
-                LOG_MISSING;
-                break;
-        default:
-                LOG_ERR("Don't know that code");
-                free(msg);
-                return NULL;
-        }
-
-        return msg;
-}
-
-buffer_t * serialize_ipcp_msg(struct ipcp_msg * msg)
-{
-        buffer_t * buf = NULL;
-        uint8_t * data = NULL;
-        int offset = 0;
-        char ** pos = NULL;
-        int i = 0;
-
-        if (msg == NULL)
-                return NULL;
-
-        buf = buffer_create();
-        if (buf == NULL)
-                return NULL;
-
-        data = buf->data;
-
-        ser_copy_value(sizeof(enum ipcp_msg_code),
-                       data, &msg->code, &offset);
-
-        switch (msg->code) {
-        case IPCP_BOOTSTRAP:
-                break;
-        case IPCP_ENROLL:
-                if (msg->dif_name == NULL) {
-                        buffer_destroy(buf);
-                        return NULL;
-                }
-
-                ser_copy_value(strlen(msg->dif_name) + 1, data,
-                               msg->dif_name, &offset);
-
-                if (msg->ap_name == NULL) {
-                        LOG_ERR("Null pointer passed");
-                        buffer_destroy(buf);
-                        return NULL;
-                }
-                ser_copy_value(strlen(msg->ap_name) + 1, data,
-                               msg->ap_name, &offset);
-
-                /* All these operations end with a list of DIFs */
-        case IPCP_REG:
-        case IPCP_UNREG:
-                if (msg->difs == NULL || msg->difs[0] == NULL) {
-                        buffer_destroy(buf);
-                        return NULL;
-                }
-
-                ser_copy_value(sizeof(size_t), data, &msg->difs_size, &offset);
-
-                pos = msg->difs;
-                for (i = 0; i < msg->difs_size; i++) {
-                        ser_copy_value(strlen(*pos) + 1, data, *pos, &offset);
-                        pos++;
-                }
-                break;
-        default:
-                LOG_ERR("Don't know that code");
-                buffer_destroy(buf);
-                return NULL;
-        }
-
-        buf->size = offset;
-
-        return buf;
-}
-
-struct ipcp_msg * deserialize_ipcp_msg(buffer_t * data)
-{
-        struct ipcp_msg * msg;
-        int i, j;
-        int offset = 0;
-        size_t difs_size;
-
-        if (data == NULL || data->data == NULL) {
-                LOG_ERR("Got a null pointer");
-                return NULL;
-        }
-
-        msg = malloc(sizeof(*msg));
-        if (msg == NULL) {
-                LOG_ERR("Failed to allocate memory");
-                return NULL;
-        }
-
-        deser_copy_value(sizeof(enum ipcp_msg_code),
-                         &msg->code, data->data, &offset);
-
-        switch (msg->code) {
-        case IPCP_BOOTSTRAP:
-                break;
-        case IPCP_ENROLL:
-                if (deser_copy_string(data->data,
-                                      &msg->dif_name,
-                                      &offset)) {
-                        free(msg);
-                        return NULL;
-                }
-
-                deser_copy_string(data->data,
-                                  &msg->ap_name,
-                                  &offset);
-                if (msg->ap_name == NULL) {
-                        LOG_ERR("Failed to reconstruct name");
-                        free(msg->dif_name);
-                        free(msg);
-                        return NULL;
-                }
-
-                deser_copy_size_t(data->data, &difs_size, &offset);
-                msg->difs_size = difs_size;
-
-                msg->difs = malloc(sizeof(*(msg->difs)) * difs_size);
-                if (msg->difs == NULL) {
-                        free(msg->ap_name);
-                        free(msg->dif_name);
-                        free(msg);
-                        return NULL;
-                }
-
-                for (i = 0; i < difs_size; i++) {
-                        if (deser_copy_string(data->data,
-                                              &msg->difs[i],
-                                              &offset)) {
-                                for (j = 0; j < i; j++)
-                                        free(msg->difs[j]);
-                                free(msg->dif_name);
-                                free(msg->difs);
-                                free(msg->ap_name);
-                                free(msg);
-                                return NULL;
-                        }
-                }
-                break;
-        case IPCP_REG:
-        case IPCP_UNREG:
-                deser_copy_size_t(data->data, &difs_size, &offset);
-                msg->difs_size = difs_size;
-
-                msg->difs = malloc(sizeof(*(msg->difs)) * difs_size);
-                if (msg->difs == NULL) {
-                        free(msg);
-                        return NULL;
-                }
-
-                for (i = 0; i < difs_size; i++) {
-                        if (deser_copy_string(data->data,
-                                              &msg->difs[i],
-                                              &offset)) {
-                                for (j = 0; j < i; j++)
-                                        free(msg->difs[j]);
-                                free(msg->difs);
-                                free(msg);
-                                return NULL;
-                        }
-                }
-
-                break;
-        default:
-                LOG_ERR("Don't know that code");
-                free(msg);
-                return NULL;
-        }
-
-        return msg;
-}