feat: push remaining changes to userspace components

clients/cpu_temp/src/cpu_temp.c

+#include "../../../common/include/message.h"
+#include "../../../common/include/userspace_comm.h"
+#include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <sys/types.h>
+#include <string.h>
 #include <sys/stat.h>
-#include <fcntl.h>
+#include <sys/types.h>
 #include <unistd.h>
-#include <string.h>
-#include "../../../common/include/message.h"
-#include "../../../common/include/userspace_comm.h"
 
 int main(int argc, char *argv[]) {
   if (argc < 3 || argc > 3) {
@@ -42,11 +42,9 @@ int main(int argc, char* argv[]) {
     message_t message = {
         .measurement_id = atoi(argv[1]),
         .datatype = FLOAT64,
-            .length=sizeof(cpu_temp)
+        .data.float64 = cpu_temp,
     };
 
-        memcpy(&message.data, &cpu_temp, sizeof(cpu_temp));
-
     send_userspace_message(&userspace_send_handle, message);
 
     usleep(sleep_ms * 1000);

common/include/data.h

+#pragma once
+
+#include "message.h"
+
+#if defined(__KERNEL__)
+#include <linux/types.h>
+typedef u8 uint8_t;
+typedef u16 uint16_t;
+typedef u32 uint32_t;
+typedef u64 uint64_t;
+typedef s8 int8_t;
+typedef s16 int16_t;
+typedef s32 int32_t;
+typedef s64 int64_t;
+#else
+#include <stddef.h>
+#include <stdint.h>
+#endif
+
+typedef struct data {
+  uint8_t sensor_id;
+  uint8_t count;
+  message_t *values;
+} data_t;

common/include/message.h

@@ -15,8 +15,6 @@ typedef s64 int64_t;
 #include <stdint.h>
 #endif
 
-#define MAX_MESSAGE_DATA_SIZE 8
-
 enum message_data_type {
   INT8,
   UINT8,
@@ -31,6 +29,19 @@ enum message_data_type {
 };
 typedef uint32_t message_data_type_t;
 
+typedef union message_data {
+  int8_t int8;
+  uint8_t uint8;
+  int16_t int16;
+  uint16_t uint16;
+  int32_t int32;
+  uint32_t uint32;
+  int64_t int64;
+  uint64_t uint64;
+  float float32;
+  double float64;
+} message_data_t;
+
 /**
  * typedef message_t - Structure to hold a message with a measurement.
  * @measurement_id: The id of the measurement. Every sender should have a unique
@@ -43,10 +54,9 @@ typedef uint32_t message_data_type_t;
  * @data: The measurement data.
  */
 typedef struct message {
-  uint8_t measurement_id;
+  message_data_t data;
   message_data_type_t datatype;
-  uint16_t length;
-  uint8_t data[MAX_MESSAGE_DATA_SIZE];
+  uint8_t measurement_id;
 } message_t;
 
 /**

common/src/message.c

@@ -26,13 +26,3 @@ size_t message_data_type_size(message_data_type_t type) {
     return 0;
   }
 }
-
-int message_check(message_t* message) {
-    int data_type_size = message_data_type_size(message->datatype);
-
-    if (data_type_size * message->length > MAX_MESSAGE_DATA_SIZE) {
-        return -1;
-    }
-
-    return 0;
-}

daemon/include/send.h

 #pragma once
-
+#include "../../common/include/data.h"
 #include "../../common/include/message.h"
 
 #define KERNEL_DEVICE_PATH "/dev/amogus"
@@ -9,5 +9,5 @@ typedef struct {
 } kernel_send_handle_t;
 
 int create_kernel_send_handle(kernel_send_handle_t *handle);
-int send_kernel_message(kernel_send_handle_t* handle, message_t* message);
+int send_kernel_message(kernel_send_handle_t *handle, data_t *data);
 int destroy_kernel_send_handle(kernel_send_handle_t *handle);

daemon/src/main.c

@@ -3,16 +3,16 @@
 #include "../include/receive.h"
 #include "../include/send.h"
 #include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
 #include <stddef.h>
-#include <string.h>
 #include <stdint.h>
-#include <stdlib.h>
 #include <stdio.h>
-#include <fcntl.h>
-#include <sys/types.h>
+#include <stdlib.h>
+#include <string.h>
 #include <sys/stat.h>
+#include <sys/types.h>
 #include <unistd.h>
-#include <signal.h>
 
 userspace_receive_handle_t userspace_receive_handle;
 kernel_send_handle_t kernel_send_handle;
@@ -25,55 +25,47 @@ void signal_handler(int sig) {
 
 void print_message_data(message_t *message) {
   int data_type_size = message_data_type_size(message->datatype);
-    for (int i = 0; i < data_type_size / message->length; i++) {
-        uint8_t buf[data_type_size];
-        for (int j = 0; j < data_type_size; j++) {
-            buf[j] = message->data[(i * data_type_size) + j];
-        }
-
   switch (message->datatype) {
   case INT8:
-                printf("%d", *(int8_t*)buf);
+    printf("%d", message->data.int8);
     break;
   case UINT8:
-                printf("%d", *(uint8_t*)buf);
+    printf("%d", message->data.uint8);
     break;
   case INT16:
-                printf("%d", *(int16_t*)buf);
+    printf("%d", message->data.int16);
     break;
   case UINT16:
-                printf("%d", *(uint16_t*)buf);
+    printf("%d", message->data.uint16);
     break;
   case INT32:
-                printf("%d", *(int32_t*)buf);
+    printf("%d", message->data.int32);
     break;
   case UINT32:
-                printf("%d", *(uint32_t*)buf);
+    printf("%d", message->data.uint32);
     break;
   case INT64:
-                printf("%ld", *(int64_t*)buf);
+    printf("%ld", message->data.int64);
     break;
   case UINT64:
-                printf("%ld", *(uint64_t*)buf);
+    printf("%ld", message->data.uint64);
     break;
   case FLOAT32:
-                printf("%f", *(float*)buf);
+    printf("%f", message->data.float32);
     break;
   case FLOAT64:
-                printf("%f", *(double*)buf);
+    printf("%f", message->data.float64);
     break;
   }
-
-        if (i != message->length - 1) {
-            printf(" ");
-        }
-    }
 }
 
 int main() {
   if (create_userspace_receive_handle(&userspace_receive_handle) != 0) {
     if (errno == EEXIST) {
-            fprintf(stderr, "Failed to create message queue (file '%s' exists, has another process already created the message queue?): %s\n", MSG_QUEUE_KEY, strerror(errno));
+      fprintf(stderr,
+              "Failed to create message queue (file '%s' exists, has another "
+              "process already created the message queue?): %s\n",
+              MSG_QUEUE_KEY, strerror(errno));
     } else {
       perror("Failed to create message queue");
     }
@@ -94,15 +86,27 @@ int main() {
   sigaction(SIGINT, &signal_action, NULL);
 
   while (1) {
-        message_t message;
+    message_t *message = malloc(sizeof(message_t));
 
-        if (recv_userspace_message(&userspace_receive_handle, &message) != 0) {
+    if (message == NULL) {
+      perror("Failed to allocate memory for message");
+      return EXIT_FAILURE;
+    }
+
+    if (recv_userspace_message(&userspace_receive_handle, message) != 0) {
       continue;
     }
 
-        printf("Received data from %d with length %d: ", message.measurement_id, message.length);
-        print_message_data(&message);
-        if (send_kernel_message(&kernel_send_handle, &message) == -1) {
+    printf("Received data from %d: ", message->measurement_id);
+    print_message_data(message);
+
+    data_t data = {
+        .values = message,
+        .sensor_id = 0x7C,
+        .count = 1,
+    };
+
+    if (send_kernel_message(&kernel_send_handle, &data) == -1) {
       printf(" (failed to send to kernel)");
     }
     printf("\n");

daemon/src/send.c

@@ -14,6 +14,6 @@ int destroy_kernel_send_handle(kernel_send_handle_t* handle) {
   return close(handle->fd);
 }
 
-int send_kernel_message(kernel_send_handle_t* handle, message_t* message) {
-    return write(handle->fd, message, sizeof(message_t));
+int send_kernel_message(kernel_send_handle_t *handle, data_t *data) {
+  return write(handle->fd, data, sizeof(data_t));
 }