add: msgpack as binn replacement

handlers/command.c

@@ -14,19 +14,20 @@
 #include <handlers.h>
 #include <helpers.h>
 #include <enums.h>
-#include <binn.h>
+#include <mpack.h>
 #include <models/schedule.h>
 
 static void
-handler_command_set_schedule(binn *map, controller_t *controller)
+handler_command_set_schedule(mpack_node_t map, controller_t *controller)
 {
-    uint8_t relay_num = binn_map_uint8(map, COMMAND_MAPPING_RELAY_NUM);
-    int uuid_size = sizeof(uuid_t);
+    uint8_t relay_num = mpack_node_u8(mpack_node_map_uint(map, COMMAND_MAPPING_RELAY_NUM));
+
+    int uid_size = sizeof(uuid_t);
     uuid_t schedule_id;
-    memmove(schedule_id, binn_map_blob(map, COMMAND_MAPPING_SCHEDULE_ID, &uuid_size), uuid_size);
-    uint16_t periods_count = binn_map_uint16(map, COMMAND_MAPPING_PERIODS_COUNT);
-    int periods_size = sizeof(uint16_t) * (periods_count * 2);
-    uint16_t *periods = binn_map_blob(map, COMMAND_MAPPING_PERIODS_BLOB, &periods_size);
+    memcpy(schedule_id, mpack_node_data(mpack_node_map_uint(map, COMMAND_MAPPING_SCHEDULE_ID)), uid_size);
+
+    uint16_t periods_count = mpack_node_u16(mpack_node_map_uint(map, COMMAND_MAPPING_PERIODS_COUNT));
+    uint16_t *periods = (uint16_t*)mpack_node_bin_data(mpack_node_map_uint(map, COMMAND_MAPPING_PERIODS_BLOB));
 
     relay_t *target_relay = controller->relays[relay_num];
 
@@ -40,10 +41,10 @@ handler_command_set_schedule(binn *map, controller_t *controller)
 }
 
 static void
-handler_command_set_relay_name(binn *map, controller_t *controller)
+handler_command_set_relay_name(mpack_node_t map, controller_t *controller)
 {
-    uint8_t relay_num = binn_map_uint8(map, COMMAND_MAPPING_RELAY_NUM);
-    char *relay_name = binn_map_str(map, COMMAND_MAPPING_NAME);
+    uint8_t relay_num = mpack_node_u8(mpack_node_map_uint(map, COMMAND_MAPPING_RELAY_NUM));
+    const char *relay_name = mpack_node_str(mpack_node_map_uint(map, COMMAND_MAPPING_NAME));
 
     if(relay_num < controller->relay_count)
     {
@@ -84,7 +85,12 @@ handler_command(int fd, controller_t *controller)
         return;
     }
 
-    uint8_t command_code = binn_map_uint8(payload, COMMAND_MAPPING_CODE);
+    mpack_tree_t tree;
+    mpack_tree_init_data(&tree, payload, payload_length);
+    mpack_tree_parse(&tree);
+    mpack_node_t root = mpack_tree_root(&tree);
+
+    uint8_t command_code = mpack_node_u8(mpack_node_map_uint(root, COMMAND_MAPPING_CODE));
 
     LOG_INFO("received command %d", command_code);
 
@@ -95,17 +101,17 @@ handler_command(int fd, controller_t *controller)
         case COMMAND_CODE_GET_ID:
             break;
         case COMMAND_CODE_SET_NAME:
-            controller_set_name(controller, binn_map_str(payload, COMMAND_MAPPING_NAME));
+            controller_set_name(controller, mpack_node_str(mpack_node_map_uint(root, COMMAND_MAPPING_NAME)));
             break;
         case COMMAND_CODE_GET_NAME:
             break;
         case COMMAND_CODE_SET_SCHEDULE:
-            handler_command_set_schedule(payload, controller);
+            handler_command_set_schedule(root, controller);
             break;
         case COMMAND_CODE_GET_SCHEDULE:
             break;
         case COMMAND_CODE_SET_RELAY_NAME:
-            handler_command_set_relay_name(payload, controller);
+            handler_command_set_relay_name(root, controller);
             break;
         case COMMAND_CODE_GET_RELAY_NAME:
             break;
@@ -113,6 +119,10 @@ handler_command(int fd, controller_t *controller)
             LOG_ERROR("received invalid command");
     }
 
+    if(mpack_tree_destroy(&tree) != mpack_ok)
+    {
+        LOG_WARN("error when destroying mpack tree");
+    }
     free(payload);
     close(client_fd);
 }

handlers/discovery.c

@@ -13,7 +13,7 @@
 #include <logger.h>
 #include <handlers.h>
 #include <helpers.h>
-#include <binn.h>
+#include <mpack.h>
 #include <enums.h>
 
 void
@@ -37,36 +37,53 @@ handler_discovery(int fd, controller_t *controller)
         return;
     }
 
-    binn *map = binn_map();
+    char* payload;
+    size_t payload_size;
+    mpack_writer_t writer;
+    mpack_writer_init_growable(&writer, &payload, &payload_size);
 
-    binn_map_set_blob(map, DISCOVERY_MAPPING_ID, &controller->id, sizeof(uuid_t));
-    binn_map_set_str(map, DISCOVERY_MAPPING_NAME, controller->name);
-    binn_map_set_uint32(map, DISCOVERY_MAPPING_COMMAND_PORT, controller->command_port);
-    binn_map_set_uint8(map, DISCOVERY_MAPPING_RELAY_COUNT, controller->relay_count);
+    mpack_start_map(&writer, 2);
+    mpack_write_uint(&writer, DISCOVERY_MAPPING_ID);
+    mpack_write_bin(&writer, (char*)controller->id, sizeof(uuid_t));
+    mpack_write_uint(&writer, DISCOVERY_MAPPING_COMMAND_PORT);
+    mpack_write_u16(&writer, controller->command_port);
+    mpack_write_uint(&writer, DISCOVERY_MAPPING_RELAY_COUNT);
+    mpack_write_u8(&writer, controller->relay_count);
+    mpack_write_uint(&writer, COMMAND_MAPPING_PERIODS_COUNT);
+    mpack_write_cstr(&writer, controller->name);
+    mpack_finish_map(&writer);
 
-    void *payload = binn_ptr(map);
-    size_t payload_size = binn_size(map);
+    // finish writing
+    if(mpack_writer_destroy(&writer) != mpack_ok)
+    {
+        LOG_ERROR("error writing discovery answer payload");
+        return;
+
+    }
 
     int fd_answer = helper_connect_tcp_server(inet_ntoa(si_other.sin_addr), discovery_answer_port);
     if(fd_answer == -1)
     {
         LOG_ERROR("error during connecting");
-        binn_free(map);
+        free(payload);
         return;
     }
 
     if((bytes_transferred = send(fd_answer, &payload_size, sizeof(payload_size), 0)) <= 0)
     {
         LOG_ERROR("error during sending");
-        binn_free(map);
+        free(payload);
+        close(fd_answer);
         return;
     }
     if((bytes_transferred = send(fd_answer, payload, payload_size, 0)) <= 0)
     {
         LOG_ERROR("error during sending");
-        binn_free(map);
+        free(payload);
+        close(fd_answer);
         return;
     }
 
+    free(payload);
     close(fd_answer);
 }