main.c

#include "../../common/include/message.h"
#include "../../common/include/userspace_comm.h"
#include "../include/receive.h"
#include "../include/send.h"
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

userspace_receive_handle_t userspace_receive_handle;
kernel_send_handle_t kernel_send_handle;

void signal_handler(int sig) {
  destroy_userspace_receive_handle(&userspace_receive_handle);
  destroy_kernel_send_handle(&kernel_send_handle);
  exit(1);
}

void print_message_data(message_t *message) {
  int data_type_size = message_data_type_size(message->datatype);
  switch (message->datatype) {
  case INT8:
    printf("%d", message->data.int8);
    break;
  case UINT8:
    printf("%d", message->data.uint8);
    break;
  case INT16:
    printf("%d", message->data.int16);
    break;
  case UINT16:
    printf("%d", message->data.uint16);
    break;
  case INT32:
    printf("%d", message->data.int32);
    break;
  case UINT32:
    printf("%d", message->data.uint32);
    break;
  case INT64:
    printf("%ld", message->data.int64);
    break;
  case UINT64:
    printf("%ld", message->data.uint64);
    break;
  case FLOAT32:
    printf("%f", message->data.float32);
    break;
  case FLOAT64:
    printf("%f", message->data.float64);
    break;
  }
}

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));
    } else {
      perror("Failed to create message queue");
    }
    return EXIT_FAILURE;
  }

  if (create_kernel_send_handle(&kernel_send_handle) != 0) {
    destroy_userspace_receive_handle(&userspace_receive_handle);
    perror("Failed to create kernel connection (is the kernel module loaded?)");
    return EXIT_FAILURE;
  }

  struct sigaction signal_action;
  signal_action.sa_handler = signal_handler;
  signal_action.sa_flags = 0;
  sigemptyset(&signal_action.sa_mask);

  sigaction(SIGINT, &signal_action, NULL);

  while (1) {
    message_t *message = malloc(sizeof(message_t));

    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: ", 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");
  }

  destroy_userspace_receive_handle(&userspace_receive_handle);

  return EXIT_SUCCESS;
}