diff --git a/clients/CMakeLists.txt b/clients/CMakeLists.txt
index ad38b36c7bf153d9c06201f06d5f3220d3c5e10a..8e025abdcd7745350d2c269912cc3598f57971df 100644
--- a/clients/CMakeLists.txt
+++ b/clients/CMakeLists.txt
@@ -1,2 +1 @@
 add_subdirectory(cpu_temp)
-add_subdirectory(test)
diff --git a/clients/cpu_temp/src/cpu_temp.c b/clients/cpu_temp/src/cpu_temp.c
index 5f126f10e00e3e0c33b39960f21f82a246964d5e..91d7bfe4f95a5320197eb101780fe5829d2f6c04 100644
--- a/clients/cpu_temp/src/cpu_temp.c
+++ b/clients/cpu_temp/src/cpu_temp.c
@@ -5,7 +5,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include <string.h>
-#include "../../../common/include/protocol.h"
+#include "../../../common/include/message.h"
 #include "../../../common/include/userspace_comm.h"
 
 int main(int argc, char* argv[]) {
@@ -14,8 +14,8 @@ int main(int argc, char* argv[]) {
         return EXIT_FAILURE;
     }
 
-    send_t send;
-    if (send_init(&send) == -1) {
+    userspace_send_handle_t userspace_send_handle;
+    if (create_userspace_send_handle(&userspace_send_handle) == -1) {
         perror("Failed to open message queue");
         return EXIT_FAILURE;
     }
@@ -39,20 +39,20 @@ int main(int argc, char* argv[]) {
 
         cpu_temp = (double)atoi(buffer) / 1000;
 
-        daemon_measurement_t packet = {
+        message_t message = {
             .measurement_id=atoi(argv[1]),
             .datatype=FLOAT64,
             .length=sizeof(cpu_temp)
         };
 
-        memcpy(&packet.data, &cpu_temp, sizeof(cpu_temp));
+        memcpy(&message.data, &cpu_temp, sizeof(cpu_temp));
 
-        send_send(&send, packet);
+        send_userspace_message(&userspace_send_handle, message);
 
         usleep(sleep_ms * 1000);
     }
 
-    send_destroy(&send);
+    destroy_userspace_send_handle(&userspace_send_handle);
     close(file_fd);
 
     return EXIT_SUCCESS;
diff --git a/clients/test/CMakeLists.txt b/clients/test/CMakeLists.txt
deleted file mode 100644
index 71d30b5a14edd088cfcd51464766d0a1a1c8f1a9..0000000000000000000000000000000000000000
--- a/clients/test/CMakeLists.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-add_executable(test
-    src/test.c
-)
-target_link_libraries(test
-    PRIVATE common
-)
-target_include_directories(test
-    PRIVATE include
-)
diff --git a/clients/test/src/test.c b/clients/test/src/test.c
deleted file mode 100644
index 935b6d18dd6162050b5e4947856131670c2a610b..0000000000000000000000000000000000000000
--- a/clients/test/src/test.c
+++ /dev/null
@@ -1,37 +0,0 @@
-#include <stdio.h>
-#include "../../../common/include/communication.h"
-
-#define PATH "/dev/amogus"
-
-int main(int argc, char* argv[]) {
-    communication_handle_t handle;
-
-    if(create_communication_handle(PATH, &handle) != 0) {
-        printf("Couldn't create communication handle, did you sudo\n");
-        return 0;
-    }
-
-    printf("Created communication handle\n");
-
-    message_t message;
-
-    uint32_t data = 69;
-
-    if(create_message(&message, 0, sizeof(uint32_t),UINT32, &data) != 0) {
-        printf("Couldn't create message\n");
-        return 0;
-    }
-
-    printf("Created message\n");
-
-    if(push_message(&handle, &message) != 0) {
-        printf("Couldn't push message\n");
-        return 0;
-    }
-
-    printf("Destroyed message\n");
-
-    destroy_communication_handle(&handle);
-
-    printf("Destroyed communication handle\n");
-}
diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index 94f58803b5619a086c95548aa9a5243b1d3532b6..2c04648af68afd954557dfb139ed221711c28d17 100644
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -1,7 +1,6 @@
 add_library(common
-    src/protocol.c
+    src/message.c
     src/userspace_comm.c
-    src/communication.c
 )
 target_include_directories(common
     PUBLIC include
diff --git a/common/include/communication.h b/common/include/communication.h
deleted file mode 100644
index b3d5420b23c8ac572d422140c4bff88ef49c99e6..0000000000000000000000000000000000000000
--- a/common/include/communication.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-#include <stddef.h>
-#include <stdint.h>
-#include "message.h"
-
-typedef struct communication_handle {
-    int fd;
-} communication_handle_t;
-
-int create_communication_handle(char* path, communication_handle_t* handle);
-
-void destroy_communication_handle(communication_handle_t* handle);
-
-int create_message(message_t* message, int32_t id, message_data_type_t type, size_t length, void* data);
-
-int push_message(communication_handle_t* handle, message_t* message);
-
-void destroy_message(message_t* message);
diff --git a/common/include/message.h b/common/include/message.h
index 66a8fed9431d6e2cb89a4f22bb241315573c2221..171d46367be1290d8ebe8dbfd5c01f2568f572aa 100644
--- a/common/include/message.h
+++ b/common/include/message.h
@@ -15,7 +15,7 @@
   #include <stddef.h>
 #endif
 
-#define MESSAGE_DATA_SIZE 4096
+#define MAX_MESSAGE_DATA_SIZE 4096
 
 typedef enum message_data_type : uint32_t {
    INT8,
@@ -30,11 +30,33 @@ typedef enum message_data_type : uint32_t {
    FLOAT64
 } message_data_type_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 id.
+ * @daemon_measurement_datatype: Datatype of the data. All values in `data` must be of this type.
+ * @length: How many types of `datatype` are in `data`. Must not exceed (`length` * daemon_measurement_datatype_size(`datatype`)) > MAX_DAEMON_PACKET_DATA_SIZE.
+ * @data: The measurement data.
+ */
 typedef struct message {
-    int32_t id;
-    message_data_type_t type;
-    uint32_t length;
-    uint8_t data[MESSAGE_DATA_SIZE];
+    uint8_t measurement_id;
+    message_data_type_t datatype;
+    uint16_t length;
+    uint8_t data[MAX_MESSAGE_DATA_SIZE];
 } message_t;
 
+/**
+ * message_data_type_size() - Get the size of a `message_data_type_t`.
+ * @arg1: The datatype to get the size of.
+ *
+ * Returns the size.
+ */
 size_t message_data_type_size(message_data_type_t type);
+/**
+ * message_check() - Check if a `message_t` is correct.
+ * @arg1: Message to check.
+ *
+ * Checks if the datatype size * length not exceeds MAX_DAEMON_PACKET_DATA_SIZE.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+int message_check(message_t* message);
diff --git a/common/include/protocol.h b/common/include/protocol.h
deleted file mode 100644
index b20646a46a413607ac7a26f28e00eb9c4153623d..0000000000000000000000000000000000000000
--- a/common/include/protocol.h
+++ /dev/null
@@ -1,56 +0,0 @@
-#pragma once
-#include <stdint.h>
-#include <sys/ipc.h>
-
-#define MAX_DAEMON_PACKET_DATA_SIZE 4096
-
-#define MSG_QUEUE_KEY "/var/run/sibyl"
-#define MSG_QUEUE_PROJ_ID 69
-
-/**
- * typedef daemon_measurement_datatype_t - Enum of possible datatypes for `daemon_measurement_t`.
- */
-typedef enum {
-    CHAR,
-    INT64,
-    UINT64,
-    FLOAT64
-} __attribute__ ((__packed__)) daemon_measurement_datatype_t;
-
-/**
- * typedef daemon_measurement_t - Structure to hold a userspace measurement.
- * @measurement_id: The id of the measurement. Every sender should have a unique id.
- * @daemon_measurement_datatype: Datatype of the data. All values in `data` must be of this type.
- * @length: How many types of `datatype` are in `data`. Must not exceed (`length` * daemon_measurement_datatype_size(`datatype`)) > MAX_DAEMON_PACKET_DATA_SIZE.
- * @data: The measurement data.
- */
-typedef struct {
-    uint8_t measurement_id;
-    daemon_measurement_datatype_t datatype;
-    uint16_t length;
-    uint8_t data[MAX_DAEMON_PACKET_DATA_SIZE];
-} daemon_measurement_t;
-
-/**
- * daemon_measurement_datatype_size() - Get the size of a `daemon_measurement_datatype_t`.
- * @arg1: The datatype to get the size of.
- *
- * Returns the size.
- */
-int daemon_measurement_datatype_size(daemon_measurement_datatype_t datatype);
-/**
- * daemon_measurement_check() - Check if a `daemon_measurement_t` is correct.
- * @arg1: Measurement to check.
- *
- * Checks if the datatype size * length not exceeds MAX_DAEMON_PACKET_DATA_SIZE.
- *
- * Returns 0 on success, -1 on error.
- */
-int daemon_measurement_check(daemon_measurement_t* daemon_measurement);
-
-/**
- * msg_queue_key() - Return the message queue key for the userspace communication.
- *
- * Returns the key of the message queue or -1 on error.
- */
-key_t msg_queue_key();
diff --git a/common/include/userspace_comm.h b/common/include/userspace_comm.h
index 6540dd12def65990721585b4927f3c82acade609..51a819917d83b31e7ce1b26ef2ea1f9ac5c3776a 100644
--- a/common/include/userspace_comm.h
+++ b/common/include/userspace_comm.h
@@ -1,29 +1,40 @@
 #pragma once
-#include "protocol.h"
+
+#include "message.h"
+#include <sys/ipc.h>
 
 #define MESSAGE_MEASUREMENT_ID 1
+#define MSG_QUEUE_KEY "/var/run/sibyl"
+#define MSG_QUEUE_PROJ_ID 69
 
 /**
- * typedef send_t - Holds the a handle to the message queue.
+ * typedef userspace_send_handle_t - Holds the a handle to the message queue.
  * @msg_queue_id: Id of the message queue.
  */
 typedef struct {
     int msg_queue_id;
-} send_t;
+} userspace_send_handle_t;
 
 /**
- * typedef message_t - Wrapper around `daemon_measurement_t` to make it sendable over a message queue.
+ * typedef message_queue_message_t - Wrapper around `daemon_measurement_t` to make it sendable over a message queue.
  * @message_type: The messages' type.
  * @measurement: The measurement.
  */
 typedef struct {
     // required by the message queue api in order to work
     long message_type;
-    daemon_measurement_t measurement;
-} message_t;
+    message_t message;
+} message_queue_message_t;
+
+/**
+ * msg_queue_key() - Return the message queue key for the userspace communication.
+ *
+ * Returns the key of the message queue or -1 on error.
+ */
+key_t msg_queue_key();
 
 /**
- * send_init() - Initializes the send module.
+ * create_userspace_send_handle_t() - Initializes the send module.
  * @arg1: The send module.
  *
  * Tries to get a handle to a message queue.
@@ -31,13 +42,13 @@ typedef struct {
  *
  * Returns 0 on success, -1 on error.
  */
-int send_init(send_t* send);
+int create_userspace_send_handle(userspace_send_handle_t* handle);
 /**
  * send_send() - Sends a message over the message queue.
  *
  * Returns 0 on success, -1 on error.
  */
-int send_send(send_t* send, daemon_measurement_t measurement);
+int send_userspace_message(userspace_send_handle_t* handle, message_t message);
 /**
  * send_destroy() - Destroys the message queue handle.
  *
@@ -45,4 +56,4 @@ int send_send(send_t* send, daemon_measurement_t measurement);
  *
  * Always returns 0.
  */
-int send_destroy(send_t* send);
+int destroy_userspace_send_handle(userspace_send_handle_t* handle);
diff --git a/common/src/communication.c b/common/src/communication.c
deleted file mode 100644
index d435db0abeacfae78d1346bce247cd0628f7385a..0000000000000000000000000000000000000000
--- a/common/src/communication.c
+++ /dev/null
@@ -1,40 +0,0 @@
-#include "../include/communication.h"
-#include <stddef.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-
-int create_communication_handle(char* path, communication_handle_t* handle) {
-    handle->fd = open(path, O_WRONLY);
-    if (handle->fd < 0) {
-        return -1;
-    }
-    return 0;
-}
-
-void destroy_communication_handle(communication_handle_t* handle) {
-    close(handle->fd);
-}
-
-int create_message(message_t* message, int32_t id, message_data_type_t type, size_t length, void* data) {
-    message->id = id;
-    message->type = type;
-    message->length = length;
-
-    if(length > MESSAGE_DATA_SIZE) {
-        return -1;
-    }
-
-    memcpy(&message->data, data, length);
-
-    return 0;
-}
-
-int push_message(communication_handle_t* handle, message_t* message) {
-    if(write(handle->fd, message, sizeof(message_t)) == -1) {
-        return -1;
-    }
-
-    return 0;
-}
diff --git a/common/src/message.c b/common/src/message.c
index e59740ca100bf5aa558c6188b17424e79d2f0869..dd72492686881c68c8389ce3bebc7c48d765c3c8 100644
--- a/common/src/message.c
+++ b/common/src/message.c
@@ -25,4 +25,14 @@ size_t message_data_type_size(message_data_type_t type) {
         default:
             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;
+}
diff --git a/common/src/protocol.c b/common/src/protocol.c
deleted file mode 100644
index 0ce57442e8b0a2491342823bcc60f55366788831..0000000000000000000000000000000000000000
--- a/common/src/protocol.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include "../include/protocol.h"
-
-int daemon_measurement_datatype_size(daemon_measurement_datatype_t datatype) {
-    switch (datatype) {
-        case CHAR:
-            return 1;
-        case INT64:
-        case UINT64:
-        case FLOAT64:
-            return 8;
-    }
-}
-
-int daemon_measurement_check(daemon_measurement_t* daemon_measurement) {
-    int datatype_size = daemon_measurement_datatype_size(daemon_measurement->datatype);
-
-    if (datatype_size * daemon_measurement->length > MAX_DAEMON_PACKET_DATA_SIZE) {
-        return -1;
-    }
-
-    return 0;
-}
-
-key_t msg_queue_key() {
-    return ftok(MSG_QUEUE_KEY, MSG_QUEUE_PROJ_ID);
-}
diff --git a/common/src/userspace_comm.c b/common/src/userspace_comm.c
index 14e2786bbae13bf2497464356bc4a4b8106b0d4e..8a00efd7b0cbb25f540a4ff02eab4ed1725f825e 100644
--- a/common/src/userspace_comm.c
+++ b/common/src/userspace_comm.c
@@ -1,9 +1,12 @@
-#include "../include/protocol.h"
 #include "../include/userspace_comm.h"
 #include <sys/ipc.h>
 #include <sys/msg.h>
 
-int send_init(send_t* send) {
+key_t msg_queue_key() {
+    return ftok(MSG_QUEUE_KEY, MSG_QUEUE_PROJ_ID);
+}
+
+int create_userspace_send_handle(userspace_send_handle_t* handle) {
     int key;
     int msg_queue_id;
 
@@ -14,21 +17,21 @@ int send_init(send_t* send) {
         return -1;
     }
 
-    send->msg_queue_id = msg_queue_id;
+    handle->msg_queue_id = msg_queue_id;
 
     return 0;
 }
 
-int send_send(send_t *send, daemon_measurement_t measurement) {
-    message_t message = {
+int send_userspace_message(userspace_send_handle_t* handle, message_t message) {
+    message_queue_message_t message_queue_message = {
         .message_type = MESSAGE_MEASUREMENT_ID,
-        .measurement = measurement,
+        .message = message,
     };
 
-    msgsnd(send->msg_queue_id, &message, sizeof(daemon_measurement_t), 0);
+    msgsnd(handle->msg_queue_id, &message_queue_message, sizeof(message_t), 0);
     return 0;
 }
 
-int send_destroy(send_t *send) {
+int destroy_userspace_send_handle(userspace_send_handle_t* handle) {
     return 0;
 }
diff --git a/daemon/CMakeLists.txt b/daemon/CMakeLists.txt
index 52d7c4c5f14f28afd5508c5803da9f7cbf54d160..ed44e75e6276876e7d894580e174e4bdada1602e 100644
--- a/daemon/CMakeLists.txt
+++ b/daemon/CMakeLists.txt
@@ -1,6 +1,7 @@
 add_executable(daemon
     src/main.c
     src/receive.c
+    src/send.c
 )
 
 target_link_libraries(daemon
diff --git a/daemon/include/receive.h b/daemon/include/receive.h
index d6a116c283ce4b1e07a4842e4d9167f111c02ef3..b2508e00d5ca978084c21522f8904abf5a3dc5e8 100644
--- a/daemon/include/receive.h
+++ b/daemon/include/receive.h
@@ -1,17 +1,17 @@
 #pragma once
-#include "../../common/include/protocol.h"
+#include "../../common/include/message.h"
 #include <sys/ipc.h>
 
 /**
- * typedef receive_t - The receive module.
+ * typedef userspace_receive_handle_t - The receive module.
  * @msg_id: Id of the message queue that is used internally to communicate.
  */
 typedef struct {
     int msg_queue_id;
-} receive_t;
+} userspace_receive_handle_t;
 
 /**
- * receive_init() - Initializes the receive module.
+ * create_userspace_receive_handle() - Initializes the receive module.
  * @arg1: The receive module.
  *
  * Creates a file at `MSG_QUEUE_KEY` and a message queue with `MSG_QUEUE_KEY` as key and `MSG_QUEUE_PROJ_ID` as project id.
@@ -19,17 +19,17 @@ typedef struct {
  *
  * Returns 0 on success, -1 on error.
  */
-int receive_init(receive_t* receive);
+int create_userspace_receive_handle(userspace_receive_handle_t* handle);
 /**
- * receive_read() - Reads a measurement from the message queue.
+ * recv_userspace_receive_handle() - Reads a measurement from the message queue.
  * @arg1: The receive module.
  * @arg2: The struct to store the read measurement in.
  *
  * Returns 0 on success, -1 on error.
  */
-int receive_read(receive_t* receive, daemon_measurement_t* daemon_measurement);
+int recv_userspace_message(userspace_receive_handle_t* handle, message_t* message);
 /**
- * receive_deinit() - Deinitializes the receive module.
+ * destroy_userspace_receive_handle() - Deinitializes the receive module.
  * @arg1: The receive module.
  *
  * The always returns 0, but is not guaranteed to be successful, so any occuring error is silent.
@@ -37,4 +37,4 @@ int receive_read(receive_t* receive, daemon_measurement_t* daemon_measurement);
  *
  * Always returns 0.
  */
-int receive_destroy(receive_t* receive);
+int destroy_userspace_receive_handle(userspace_receive_handle_t* handle);
diff --git a/daemon/include/send.h b/daemon/include/send.h
new file mode 100644
index 0000000000000000000000000000000000000000..e70aabc7fce80aff5da8dfa30837fd91b6248663
--- /dev/null
+++ b/daemon/include/send.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "../../common/include/message.h"
+
+#define KERNEL_DEVICE_PATH "/dev/amogus"
+
+typedef struct {
+    int fd;
+} 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 destroy_kernel_send_handle(kernel_send_handle_t* handle);
diff --git a/daemon/src/main.c b/daemon/src/main.c
index 9b74fd7738e1355f69f6472a400bee5a2785a982..3f0106ad3617f8ee34f4dee6b238d1eb05ce4e4c 100644
--- a/daemon/src/main.c
+++ b/daemon/src/main.c
@@ -1,5 +1,7 @@
+#include "../../common/include/message.h"
 #include "../include/receive.h"
 #include <stddef.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <fcntl.h>
@@ -8,23 +10,38 @@
 #include <unistd.h>
 #include <signal.h>
 
-receive_t receive;
+userspace_receive_handle_t userspace_receive_handle;
 void signal_handler(int sig) {
-    receive_destroy(&receive);
+    destroy_userspace_receive_handle(&userspace_receive_handle);
     exit(1);
 }
 
-void print_measurement_data(daemon_measurement_t* measurement) {
-    int datatype_size = daemon_measurement_datatype_size(measurement->datatype);
-    for (int i = 0; i < datatype_size / measurement->length; i++) {
-        uint8_t buf[datatype_size];
-        for (int j = 0; j < datatype_size; j++) {
-            buf[j] = measurement->data[(i * datatype_size) + j];
+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 (measurement->datatype) {
-            case CHAR:
-                printf("%c", *(char*)buf);
+        switch (message->datatype) {
+            case INT8:
+                printf("%d", *(int8_t*)buf);
+                break;
+            case UINT8:
+                printf("%d", *(uint8_t*)buf);
+                break;
+            case INT16:
+                printf("%d", *(int16_t*)buf);
+                break;
+            case UINT16:
+                printf("%d", *(uint16_t*)buf);
+                break;
+            case INT32:
+                printf("%d", *(int32_t*)buf);
+                break;
+            case UINT32:
+                printf("%d", *(uint32_t*)buf);
                 break;
             case INT64:
                 printf("%ld", *(int64_t*)buf);
@@ -32,19 +49,22 @@ void print_measurement_data(daemon_measurement_t* measurement) {
             case UINT64:
                 printf("%ld", *(uint64_t*)buf);
                 break;
+            case FLOAT32:
+                printf("%f", *(float*)buf);
+                break;
             case FLOAT64:
                 printf("%f", *(double*)buf);
                 break;
         }
 
-        if (measurement->datatype != CHAR && i != measurement->length - 1) {
+        if (i != message->length - 1) {
             printf(" ");
         }
     }
 }
 
 int main() {
-    if (receive_init(&receive) != 0) {
+    if (create_userspace_receive_handle(&userspace_receive_handle) != 0) {
         perror("Failed to create receive module");
         return EXIT_FAILURE;
     }
@@ -57,18 +77,18 @@ int main() {
     sigaction(SIGINT, &signal_action, NULL);
 
     while (1) {
-        daemon_measurement_t daemon_measurement;
+        message_t message;
 
-        if (receive_read(&receive, &daemon_measurement) != 0) {
+        if (recv_userspace_message(&userspace_receive_handle, &message) != 0) {
             continue;
         }
 
-        printf("Received data from %d with length %d: ", daemon_measurement.measurement_id, daemon_measurement.length);
-        print_measurement_data(&daemon_measurement);
+        printf("Received data from %d with length %d: ", message.measurement_id, message.length);
+        print_message_data(&message);
         printf("\n");
     }
 
-    receive_destroy(&receive);
+    destroy_userspace_receive_handle(&userspace_receive_handle);
 
     return EXIT_SUCCESS;
 }
diff --git a/daemon/src/receive.c b/daemon/src/receive.c
index 839986e9fda4d9ffd1e037e9801db8914600ef92..3047220add900fc784fa2f2fcdca4c18e9163a35 100644
--- a/daemon/src/receive.c
+++ b/daemon/src/receive.c
@@ -1,4 +1,4 @@
-#include "../../common/include/protocol.h"
+#include "../../common/include/message.h"
 #include "../../common/include/userspace_comm.h"
 #include "../include/receive.h"
 #include <stddef.h>
@@ -25,7 +25,7 @@ int remove_run_file() {
     return remove(MSG_QUEUE_KEY);
 }
 
-int receive_init(receive_t* receive) {
+int create_userspace_receive_handle(userspace_receive_handle_t* handle) {
     if (create_run_file() == -1) {
         return -1;
     }
@@ -35,32 +35,29 @@ int receive_init(receive_t* receive) {
         return -1;
     }
 
-    int msg_queue_id = msgget(key, IPC_CREAT | IPC_EXCL | IPC_NOWAIT);
-    if (msg_queue_id == -1) {
+    if ((handle->msg_queue_id = msgget(key, IPC_CREAT | IPC_EXCL | IPC_NOWAIT)) == -1) {
         return -1;
     }
 
-    receive->msg_queue_id = msg_queue_id;
-
     return 0;
 }
 
-int receive_read(receive_t* receive, daemon_measurement_t* daemon_measurement) {
-    message_t message;
+int recv_userspace_message(userspace_receive_handle_t* handle, message_t* message) {
+    message_queue_message_t message_queue_message;
 
-    ssize_t read = msgrcv(receive->msg_queue_id, &message, sizeof(daemon_measurement_t), MESSAGE_MEASUREMENT_ID, 0);
+    ssize_t read = msgrcv(handle->msg_queue_id, &message_queue_message, sizeof(message_t), MESSAGE_MEASUREMENT_ID, 0);
     if (read == -1) {
         return -1;
     }
 
-    *daemon_measurement = message.measurement;
+    *message = message_queue_message.message;
 
     return 0;
 }
 
-int receive_destroy(receive_t* receive) {
+int destroy_userspace_receive_handle(userspace_receive_handle_t* handle) {
     remove_run_file();
-    msgctl(receive->msg_queue_id, IPC_RMID, NULL);
+    msgctl(handle->msg_queue_id, IPC_RMID, NULL);
 
     return 0;
 }
diff --git a/daemon/src/send.c b/daemon/src/send.c
new file mode 100644
index 0000000000000000000000000000000000000000..d104e82c0b27f188c6de462cbd693ef268334314
--- /dev/null
+++ b/daemon/src/send.c
@@ -0,0 +1,19 @@
+#include "../include/send.h"
+#include <fcntl.h>
+#include <unistd.h>
+
+int create_kernel_send_handle(kernel_send_handle_t* handle) {
+    handle->fd = open(KERNEL_DEVICE_PATH, O_WRONLY);
+    if (handle->fd < 0) {
+        return -1;
+    }
+    return 0;
+}
+
+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));
+}
diff --git a/kernel/Makefile b/kernel/Makefile
index 18bff6088a9de36e11827e47085320d390ed5c7c..6998dbcfce9031bfefb8712192c528b3e9cf6f9a 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -1,9 +1,9 @@
-obj-m += kmod.o 
+obj-m += kmod.o
 
-PWD := $(CURDIR) 
+PWD := $(CURDIR)
 
-all: 
-	$(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules 
+all:
+	$(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
 
-clean: 
-	$(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
\ No newline at end of file
+clean:
+	$(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean