add: version.h

fix: refactor

src/handlers/command.c

@@ -0,0 +1,142 @@
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <uuid/uuid.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <errno.h>
+
+#include <logger.h>
+#include <handlers.h>
+#include <helpers.h>
+#include <enums.h>
+#include <mpack.h>
+#include <models/schedule.h>
+
+static void
+handler_command_set_name(mpack_node_t map, controller_t *controller)
+{
+    char name_buffer[MAX_NAME_LENGTH + 1];
+    mpack_node_copy_cstr(mpack_node_map_uint(map, COMMAND_MAPPING_NAME), name_buffer, MAX_NAME_LENGTH + 1);
+    controller_set_name(controller, name_buffer);
+}
+
+static void
+handler_command_set_schedule(mpack_node_t map, controller_t *controller)
+{
+    uint8_t relay_num = mpack_node_u8(mpack_node_map_uint(map, COMMAND_MAPPING_RELAY_NUM));
+
+    relay_t *target_relay = controller->relays[relay_num];
+
+    mpack_node_t schedules_array = mpack_node_map_uint(map, COMMAND_MAPPING_SCHEDULES_ARRAY);
+
+    for(int i = 0; i < 7; ++i)
+    {
+        mpack_node_t schedules_map = mpack_node_array_at(schedules_array, i);
+
+        uuid_t schedule_id;
+        memcpy(schedule_id, mpack_node_data(mpack_node_map_uint(schedules_map, COMMAND_MAPPING_SCHEDULE_ID)), sizeof(uuid_t));
+
+        uint16_t periods_count = mpack_node_u16(mpack_node_map_uint(schedules_map, COMMAND_MAPPING_PERIODS_COUNT));
+        uint16_t *periods = (uint16_t*)mpack_node_bin_data(mpack_node_map_uint(schedules_map, COMMAND_MAPPING_PERIODS_BLOB));
+
+        if(target_relay->schedules[i])
+        {
+            schedule_free(target_relay->schedules[i]);
+        }
+        target_relay->schedules[i] = schedule_create(schedule_id, i, periods_count, periods);
+    }
+
+    relay_debug(target_relay);
+}
+
+static void
+handler_command_set_relay_name(mpack_node_t map, controller_t *controller)
+{
+    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)
+    {
+        relay_set_name(controller->relays[relay_num], relay_name);
+    }
+    relay_debug(controller->relays[relay_num]);
+}
+
+void
+handler_command(int fd, controller_t *controller)
+{
+    struct sockaddr_storage their_addr;
+    socklen_t addr_size;
+    int client_fd;
+
+    addr_size = sizeof(their_addr);
+
+    if((client_fd = accept(fd, (struct sockaddr *) &their_addr, &addr_size)) < 0)
+    {
+        LOG_ERROR("could not accept client: %s\n", strerror(errno));
+        return;
+    }
+
+    uint32_t payload_length;
+
+    if(recv(client_fd, &payload_length, sizeof(payload_length), 0) <= 0)
+    {
+        LOG_ERROR("unable to receive header: %s\n", strerror(errno));
+        return;
+    }
+
+    void *payload = malloc((payload_length + 1));
+    ssize_t bytes_transferred;
+
+    if((bytes_transferred = recv(client_fd, payload, payload_length, 0)) <= 0)
+    {
+        LOG_ERROR("unable to receive payload: %s\n", strerror(errno));
+        return;
+    }
+
+    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\n", command_code);
+
+    switch(command_code)
+    {
+        case COMMAND_CODE_GET_TIME:
+            break;
+        case COMMAND_CODE_GET_ID:
+            break;
+        case COMMAND_CODE_SET_NAME:
+            handler_command_set_name(root, controller);
+            break;
+        case COMMAND_CODE_GET_NAME:
+            break;
+        case COMMAND_CODE_SET_SCHEDULE:
+            handler_command_set_schedule(root, controller);
+            break;
+        case COMMAND_CODE_GET_SCHEDULE:
+            break;
+        case COMMAND_CODE_SET_RELAY_NAME:
+            handler_command_set_relay_name(root, controller);
+            break;
+        case COMMAND_CODE_GET_RELAY_NAME:
+            break;
+        default:
+            LOG_ERROR("received invalid command\n");
+    }
+
+    if(mpack_tree_destroy(&tree) != mpack_ok)
+    {
+        LOG_WARN("error when destroying mpack tree\n");
+    }
+    free(payload);
+    close(client_fd);
+}

src/handlers/discovery.c

@@ -0,0 +1,89 @@
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <uuid/uuid.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <errno.h>
+
+#include <logger.h>
+#include <handlers.h>
+#include <helpers.h>
+#include <mpack.h>
+#include <enums.h>
+
+void
+handler_discovery(int fd, controller_t *controller)
+{
+    ssize_t bytes_transferred;
+    uint16_t discovery_answer_port;
+    struct sockaddr_in si_other;
+    socklen_t slen = sizeof(si_other);
+
+    if((bytes_transferred = recvfrom(fd, &discovery_answer_port, sizeof(discovery_answer_port), 0, (struct sockaddr *) &si_other, &slen)) <= 0)
+    {
+        LOG_ERROR("received invalid discovery from %s\n", inet_ntoa(si_other.sin_addr));
+        return;
+    }
+    LOG_INFO("received discovery from %s:%d\n", inet_ntoa(si_other.sin_addr), discovery_answer_port);
+
+    if(discovery_answer_port == 0)
+    {
+        LOG_ERROR("invalid port received\n");
+        return;
+    }
+
+    char* payload;
+    size_t payload_size;
+    mpack_writer_t writer;
+    mpack_writer_init_growable(&writer, &payload, &payload_size);
+
+    mpack_start_map(&writer, 4);
+    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, DISCOVERY_MAPPING_NAME);
+    mpack_write_cstr(&writer, controller->name);
+    mpack_finish_map(&writer);
+
+    // finish writing
+    if(mpack_writer_destroy(&writer) != mpack_ok)
+    {
+        LOG_ERROR("error writing discovery answer payload\n");
+        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\n");
+        free(payload);
+        return;
+    }
+
+    if((bytes_transferred = send(fd_answer, &payload_size, sizeof(payload_size), 0)) <= 0)
+    {
+        LOG_ERROR("error during sending\n");
+        free(payload);
+        close(fd_answer);
+        return;
+    }
+    if((bytes_transferred = send(fd_answer, payload, payload_size, 0)) <= 0)
+    {
+        LOG_ERROR("error during sending\n");
+        free(payload);
+        close(fd_answer);
+        return;
+    }
+
+    free(payload);
+    close(fd_answer);
+}

src/handlers/loop.c

@@ -0,0 +1,46 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <time.h>
+
+#include <logger.h>
+#include <models/controller.h>
+#include <handlers.h>
+#include <drivers.h>
+#include <enums.h>
+#include <helpers.h>
+#include <wiringPi.h>
+#include <wiring_debug.h>
+
+void
+handler_loop(controller_t *controller)
+{
+    time_t timestamp = time(NULL);
+    struct tm *time_struct = localtime(&timestamp);
+    LOG_DEBUG("===== IDLE LOOP START =====\n");
+    for(uint_fast8_t i = 0; i < controller->relay_count; ++i)
+    {
+        relay_t *relay = controller->relays[i];
+        int is_active = 0;
+        if(relay_is_active(relay, time_struct))
+        {
+            LOG_DEBUG("relay %d is active\n", i);
+            is_active = 1;
+        }
+        if(global_config.relay_configs[i].inverted)
+        {
+            is_active = !is_active;
+        }
+        switch(global_config.relay_configs[i].driver)
+        {
+            case RELAY_DRIVER_GPIO:
+                driver_gpio_set(global_config.relay_configs[i].pin, is_active);
+                break;
+            case RELAY_DRIVER_PIFACE:
+                driver_piface_set(global_config.relay_configs[i].pin, is_active);
+                break;
+            default:
+                LOG_WARN("relay %d is not using a driver\n", i);
+        }
+    }
+}

src/handlers/poll.c

@@ -0,0 +1,50 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <time.h>
+#include <lmdb.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <poll.h>
+#include <signal.h>
+
+#include <logger.h>
+#include <models/controller.h>
+#include <database.h>
+#include <config.h>
+#include <constants.h>
+#include <handlers.h>
+#include <drivers.h>
+#include <enums.h>
+#include <helpers.h>
+#include <wiringPi.h>
+#include <piFace.h>
+#include <wiring_debug.h>
+
+void
+handler_poll(struct pollfd *fds, controller_t *controller, MDB_env *mdb_env)
+{
+    /* An event on one of the fds has occurred. */
+    for(int i = 0; i < POLL_FDS_COUNT; i++) {
+        if(fds[i].revents & POLLIN)
+        {
+            /* data may be read on device number i. */
+            LOG_DEBUG("fd %i may read data\n", fds[i].fd);
+            switch(i)
+            {
+                case POLL_FDS_DISCOVERY:
+                    handler_discovery(fds[i].fd, controller);
+                    break;
+                case POLL_FDS_COMMAND:
+                    handler_command(fds[i].fd, controller);
+                    controller_save(controller, mdb_env);
+                    break;
+            }
+        }
+        if(fds[i].revents & POLLHUP)
+        {
+            /* A hangup has occurred on device number i. */
+            LOG_DEBUG("fd %i got closed\n", fds[i].fd);
+        }
+    }
+}