From ee48214209e66aa8c6f353262b175895373f76df Mon Sep 17 00:00:00 2001
From: Nathanael Sensfelder <SpamShield0@MultiAgentSystems.org>
Date: Sat, 4 Jan 2020 21:31:55 +0100
Subject: ...

---
 src/client.c                                 |   9 +-
 src/config/parameters/parameters.c           |  16 +-
 src/config/parameters/parameters_accessors.c |  48 +++-
 src/config/parameters/parse_config_file.c    |  68 ++++--
 src/device/physical/physical_device.c        |  12 +
 src/device/virtual/virtual_device.c          |   6 +-
 src/main.c                                   |  11 +-
 src/server/communication_node.c              |  15 +-
 src/server/communication_thread.c            |  33 ++-
 src/server/conversion_main_loop.c            | 331 ++++++++++++++++-----------
 src/server/daemon.c                          |   5 +
 src/server/interruption.c                    |  69 +++++-
 src/server/server.c                          |  45 ++--
 src/util/string.c                            |   1 +
 14 files changed, 453 insertions(+), 216 deletions(-)

(limited to 'src')

diff --git a/src/client.c b/src/client.c
index b0459af..4d1f659 100644
--- a/src/client.c
+++ b/src/client.c
@@ -97,7 +97,7 @@ static int open_socket
 static int send_commands
 (
    const int argc,
-   const char * argv [const restrict static argc],
+   const char * const argv [const restrict static argc],
    FILE socket [const restrict static 1]
 )
 {
@@ -158,16 +158,19 @@ static int receive_reply
    FILE socket [const restrict static 1]
 )
 {
+   /* TODO: implement. */
+   (void) fclose(socket);
+
    return 0;
 }
 
 /******************************************************************************/
 /**** EXPORTED FUNCTIONS ******************************************************/
 /******************************************************************************/
-int relabsd_client
+int relabsd_client_main
 (
    const int argc,
-   const char * argv [const restrict static argc],
+   const char * const argv [const restrict static argc],
    struct relabsd_parameters parameters [const restrict static 1]
 )
 {
diff --git a/src/config/parameters/parameters.c b/src/config/parameters/parameters.c
index ac6a790..fa53b6a 100644
--- a/src/config/parameters/parameters.c
+++ b/src/config/parameters/parameters.c
@@ -216,6 +216,8 @@ int relabsd_parameters_parse_options
          || RELABSD_STRING_EQUALS("--timeout", argv[i])
       )
       {
+         int timeout;
+
          if (argc == i)
          {
             RELABSD_FATAL("Missing value for \"%s\" <OPTION>.", argv[i]);
@@ -226,17 +228,7 @@ int relabsd_parameters_parse_options
 
          ++i;
 
-         if
-         (
-            relabsd_util_parse_int
-            (
-               argv[i],
-               0,
-               INT_MAX,
-               &(parameters->timeout)
-            )
-            < 0
-         )
+         if (relabsd_util_parse_int(argv[i], 0, INT_MAX, &timeout) < 0)
          {
             RELABSD_FATAL
             (
@@ -250,6 +242,8 @@ int relabsd_parameters_parse_options
 
             return -1;
          }
+
+         relabsd_parameters_set_timeout(timeout, parameters);
       }
       else if
       (
diff --git a/src/config/parameters/parameters_accessors.c b/src/config/parameters/parameters_accessors.c
index bd6624c..71c2482 100644
--- a/src/config/parameters/parameters_accessors.c
+++ b/src/config/parameters/parameters_accessors.c
@@ -1,5 +1,6 @@
-/**** POSIXS ^*****************************************************************/
+/**** POSIXS ******************************************************************/
 #include <stdlib.h>
+#include <string.h>
 
 /**** RELABSD *****************************************************************/
 #include <relabsd/config/parameters.h>
@@ -66,9 +67,52 @@ enum relabsd_parameters_run_mode relabsd_parameters_get_execution_mode
 struct relabsd_axis * relabsd_parameters_get_axis
 (
    const enum relabsd_axis_name i,
-   const struct relabsd_parameters parameters [const restrict static 1]
+   struct relabsd_parameters parameters [const restrict static 1]
 )
 {
    return (parameters->axes + i);
 }
 
+void relabsd_parameters_set_timeout
+(
+   const int timeout_msec,
+   struct relabsd_parameters parameters [const restrict static 1]
+)
+{
+   if (timeout_msec == 0)
+   {
+      parameters->use_timeout = 0;
+
+      return;
+   }
+
+   parameters->use_timeout = 1;
+
+   (void) memset((void *) &(parameters->timeout), 0, sizeof(struct timeval));
+
+   /* FIXME: Not sure that's correct. */
+   parameters->timeout.tv_sec = (time_t) (timeout_msec / 1000);
+   parameters->timeout.tv_usec =
+      (
+         ((suseconds_t) timeout_msec)
+         * ((suseconds_t) 1000)
+      );
+
+   return;
+}
+
+int relabsd_parameters_use_timeout
+(
+   const struct relabsd_parameters parameters [const restrict static 1]
+)
+{
+   return parameters->use_timeout;
+}
+
+struct timeval relabsd_parameters_get_timeout
+(
+   const struct relabsd_parameters parameters [const restrict static 1]
+)
+{
+   return parameters->timeout;
+}
diff --git a/src/config/parameters/parse_config_file.c b/src/config/parameters/parse_config_file.c
index a6920b4..c01090d 100644
--- a/src/config/parameters/parse_config_file.c
+++ b/src/config/parameters/parse_config_file.c
@@ -123,47 +123,66 @@ static int read_axis_options
    return -1;
 }
 
-/*
-static int parse_timeout_option
+static int parse_timeout_configuration_line
 (
-   struct relabsd_config * const conf,
-   const char * const param
+   FILE file [const restrict static 1],
+   struct relabsd_parameters parameters [const static 1]
 )
 {
+   int read_count;
    int timeout_msec;
-   const int prev_errno = errno;
-
-   conf->enable_timeout = 1;
 
    errno = 0;
 
-   timeout_msec = atoi(param);
+   read_count = fscanf(file, "%d", &timeout_msec);
 
-   if (timeout_msec <= 0)
+   if (read_count == EOF)
    {
-      RELABSD_FATAL
+      if (errno == 0)
+      {
+         RELABSD_S_FATAL
+         (
+            "Unexpected end of file while reading the timeout parameter in the"
+            " configuration file."
+         );
+      }
+      else
+      {
+         RELABSD_FATAL
+         (
+            "An error occured while reading the timeout parameter in the"
+            " configuration file: %s.",
+            strerror(errno)
+         );
+      }
+
+      return -1;
+   }
+   else if (read_count < 1)
+   {
+      RELABSD_S_FATAL
       (
-         "Illegal value for timeout \"%d\": accepted range is [1, %d].",
-         timeout_msec,
-         INT_MAX
+         "Invalid parameter count for the timeout option in the configuration"
+         " file."
       );
 
       return -1;
    }
-
-   memset((void *) &(conf->timeout), 0, sizeof(struct timeval));
-
-   conf->timeout.tv_sec = (time_t) (timeout_msec / 1000);
-
-   conf->timeout.tv_usec =
+   else if (timeout_msec < 0)
+   {
+      RELABSD_FATAL
       (
-         ((suseconds_t) timeout_msec)
-         * ((suseconds_t) 1000)
+         "Invalid value the timeout option in the configuration file (%d).",
+         timeout_msec
       );
 
+      return -1;
+   }
+
+   relabsd_parameters_set_timeout(timeout_msec, parameters);
+
    return 0;
 }
-*/
 
 /*
  * Returns -1 on (fatal) error,
@@ -184,6 +203,11 @@ static int parse_axis_configuration_line
 
    if (axis_index == RELABSD_UNKNOWN)
    {
+      if (RELABSD_IS_PREFIX("TO", axis_name))
+      {
+         return parse_timeout_configuration_line(file, parameters);
+      }
+
       RELABSD_FATAL("Unknown axis '%s' in the configuration file.", axis_name);
 
       return -1;
diff --git a/src/device/physical/physical_device.c b/src/device/physical/physical_device.c
index e7b4167..ca6f595 100644
--- a/src/device/physical/physical_device.c
+++ b/src/device/physical/physical_device.c
@@ -196,6 +196,10 @@ int relabsd_physical_device_read
 
          return -1;
    }
+
+   RELABSD_S_PROG_ERROR("Reached what is supposed to be dead code.");
+
+   return -1;
 }
 
 int relabsd_physical_device_is_late
@@ -205,3 +209,11 @@ int relabsd_physical_device_is_late
 {
    return device->is_late;
 }
+
+int relabsd_physical_device_get_file_descriptor
+(
+   const struct relabsd_physical_device device [const restrict static 1]
+)
+{
+   return device->file;
+}
diff --git a/src/device/virtual/virtual_device.c b/src/device/virtual/virtual_device.c
index 7617c8c..246a90b 100644
--- a/src/device/virtual/virtual_device.c
+++ b/src/device/virtual/virtual_device.c
@@ -24,7 +24,7 @@
 /******************************************************************************/
 static void replace_rel_axes
 (
-   const struct relabsd_parameters parameters [const static 1],
+   struct relabsd_parameters parameters [const static 1],
    const struct relabsd_virtual_device device [const restrict static 1]
 )
 {
@@ -151,7 +151,7 @@ static int rename_device
 /******************************************************************************/
 int relabsd_virtual_device_create_from
 (
-   const struct relabsd_parameters parameters [const restrict static 1],
+   struct relabsd_parameters parameters [const restrict static 1],
    struct relabsd_virtual_device device [const restrict static 1]
 )
 {
@@ -316,7 +316,7 @@ int relabsd_virtual_device_write_evdev_event
 
 void relabsd_virtual_device_set_axes_to_zero
 (
-   const struct relabsd_parameters parameters [const restrict static 1],
+   struct relabsd_parameters parameters [const restrict static 1],
    const struct relabsd_virtual_device device [const restrict static 1]
 )
 {
diff --git a/src/main.c b/src/main.c
index d4089b9..79ed9d7 100644
--- a/src/main.c
+++ b/src/main.c
@@ -13,11 +13,13 @@
 /******************************************************************************/
 /**** EXPORTED FUNCTIONS ******************************************************/
 /******************************************************************************/
-int main (int argc, char ** argv)
+int main (int const argc, const char * const * const argv)
 {
    int retval;
    struct relabsd_parameters params;
 
+   retval = -1;
+
    RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "relabsd started.");
 
    if (relabsd_parameters_parse_execution_mode(argc, argv, &params) < 0)
@@ -33,9 +35,14 @@ int main (int argc, char ** argv)
          retval = relabsd_client_main(argc, argv, &params);
          break;
 
-      case RELABSD_PARAMETERS_RUN_SERVER_MODE:
+      case RELABSD_PARAMETERS_SERVER_MODE:
          retval = relabsd_server_main(argc, argv, &params);
          break;
+
+      case RELABSD_PARAMETERS_COMPATIBILITY_TEST_MODE:
+         /* TODO: implement this. */
+         RELABSD_S_FATAL("Compatibility test mode not implemented.");
+         break;
    }
 
    RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "relabsd terminating.");
diff --git a/src/server/communication_node.c b/src/server/communication_node.c
index 70c7323..96f4af4 100644
--- a/src/server/communication_node.c
+++ b/src/server/communication_node.c
@@ -9,6 +9,7 @@
 
 /**** RELABSD *****************************************************************/
 #include <relabsd/debug.h>
+#include <relabsd/server.h>
 
 /******************************************************************************/
 /**** LOCAL FUNCTIONS *********************************************************/
@@ -79,7 +80,7 @@ static int bind_socket
 
    return 0;
 }
-
+/*
 static int set_socket_to_unblocking (const int socket)
 {
    int current_flags;
@@ -114,7 +115,7 @@ static int set_socket_to_unblocking (const int socket)
 
    return 0;
 }
-
+*/
 static int set_socket_as_listener (const int socket)
 {
    errno = 0;
@@ -155,16 +156,6 @@ int relabsd_server_create_communication_node
       return -1;
    }
 
-   /*
-   if (set_socket_to_unblocking(*socket) < 0)
-   {
-      /* TODO: err message. *//*
-      (void) close(*socket);
-
-      return -1;
-   }
-   */
-
    if (set_socket_as_listener(*socket) < 0)
    {
       /* TODO: err message. */
diff --git a/src/server/communication_thread.c b/src/server/communication_thread.c
index 2da54d2..e226f17 100644
--- a/src/server/communication_thread.c
+++ b/src/server/communication_thread.c
@@ -4,20 +4,24 @@
 
 /**** RELABSD *****************************************************************/
 #include <relabsd/debug.h>
+#include <relabsd/server.h>
 
 /******************************************************************************/
 /**** LOCAL FUNCTIONS *********************************************************/
 /******************************************************************************/
+/* TODO: implement. */
+/*
 void main_loop (struct relabsd_server server [const static 1])
 {
-
 }
+*/
 
 void * posix_main_loop (void * params)
 {
-   main_loop((struct relabsd_server *) params);
+   /* main_loop((struct relabsd_server *) params);*/
+   params = NULL;
 
-   return NULL;
+   return params;
 }
 
 /******************************************************************************/
@@ -52,3 +56,26 @@ int relabsd_server_create_communication_thread
 
    return 0;
 }
+
+int relabsd_server_join_communication_thread
+(
+   struct relabsd_server server [const static 1]
+)
+{
+   int err;
+
+   err = pthread_join(server->communication_thread, (void **) NULL);
+
+   if (err != 0)
+   {
+      RELABSD_FATAL
+      (
+         "Unable to join with the communication thread: %s",
+         strerror(err)
+      );
+
+      return -1;
+   }
+
+   return 0;
+}
diff --git a/src/server/conversion_main_loop.c b/src/server/conversion_main_loop.c
index b5b97db..c948954 100644
--- a/src/server/conversion_main_loop.c
+++ b/src/server/conversion_main_loop.c
@@ -1,192 +1,245 @@
-#include <fcntl.h>
+/**** POSIX *******************************************************************/
+#include <sys/select.h>
+
 #include <errno.h>
 #include <string.h>
-#include <unistd.h>
-#include <signal.h>
-
-#include "pervasive.h"
-#include "error.h"
-#include "config.h"
-#include "input.h"
-#include "relabsd_device.h"
 
-static void handle_relative_axis_event
-(
-   struct relabsd_config * const conf,
-   const struct relabsd_device * const dev,
-   unsigned int const input_type,
-   unsigned int const input_code,
-   int value
-)
-{
-   unsigned int abs_code;
-   enum relabsd_axis rad_code;
+/**** RELABSD *****************************************************************/
+#include <relabsd/debug.h>
+#include <relabsd/server.h>
 
-   rad_code = relabsd_axis_convert_evdev_rel(input_code, &abs_code);
+#include <relabsd/config/parameters.h>
 
-   switch (relabsd_config_filter(conf, rad_code, &value))
-   {
-      case -1:
-         /* 'conf' doesn't want the event to be transmitted. */
-         break;
-
-      case 0:
-         /* 'conf' wants the event to be transmitted as is. */
-         relabsd_device_write_evdev_event(dev, input_type, input_code, value);
-         break;
-
-      case 1:
-         /* 'conf' allows the value to be emitted */
-         relabsd_device_write_evdev_event(dev, EV_ABS, abs_code, value);
-         break;
-   }
-}
+#include <relabsd/device/axis.h>
+#include <relabsd/device/physical_device.h>
+#include <relabsd/device/virtual_device.h>
 
+/******************************************************************************/
+/**** LOCAL FUNCTIONS *********************************************************/
+/******************************************************************************/
 static void convert_input
 (
-   struct relabsd_config * const conf,
-   struct relabsd_input * const input,
-   const struct relabsd_device * const dev
+   struct relabsd_server server [const restrict static 1]
 )
 {
    unsigned int input_type, input_code;
    int value;
 
-   RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Handling input events...");
-
-   input->timed_out = 1;
+   if
+   (
+      relabsd_physical_device_read
+      (
+         &(server->physical_device),
+         &input_type,
+         &input_code,
+         &value
+      )
+      < 0
+   )
+   {
+      return;
+   }
 
-   while (RELABSD_RUN == 1)
+   if (input_type == EV_REL)
    {
-      if (conf->enable_timeout)
-      {
-         switch (relabsd_input_wait_for_next_event(input, conf))
-         {
-            case 1:
-               input->timed_out = 0;
-               break;
-
-            case 0:
-               relabsd_device_set_axes_to_zero(dev, conf);
-               input->timed_out = 1;
-               break;
-
-            case -1:
-               continue;
-         }
-      }
+      unsigned int abs_code;
+      enum relabsd_axis_name axis_name;
 
-      if (relabsd_input_read(input, &input_type, &input_code, &value) < 0)
-      {
-         /*
-          * The next event should not be retransmitted, or some kind of error
-          * happened.
-          */
-         /* TODO: error handling. */
-         continue;
-      }
+      axis_name =
+         relabsd_axis_name_and_evdev_abs_from_evdev_rel(input_code, &abs_code);
 
-      if (input_type == EV_REL)
+      if (axis_name == RELABSD_UNKNOWN)
       {
-         /* We might have to convert the event. */
-         handle_relative_axis_event(conf, dev, input_type, input_code, value);
+         return;
       }
-      else
+
+      switch
+      (
+         relabsd_axis_filter_new_value
+         (
+            relabsd_parameters_get_axis(axis_name, &(server->parameters)),
+            &value
+         )
+      )
       {
-         /* Any other event is retransmitted as is. */
-         relabsd_device_write_evdev_event(dev, input_type, input_code, value);
+         case -1:
+            /* Doesn't want the event to be transmitted. */
+            return;
+
+         case 1:
+            (void) relabsd_virtual_device_write_evdev_event
+            (
+               &(server->virtual_device),
+               EV_ABS,
+               abs_code,
+               value
+            );
+            return;
+
+         case 0:
+            (void) relabsd_virtual_device_write_evdev_event
+            (
+               &(server->virtual_device),
+               input_type,
+               input_code,
+               value
+            );
+            return;
       }
    }
+   else
+   {
+      /* Any other event is retransmitted as is. */
+      (void) relabsd_virtual_device_write_evdev_event
+      (
+         &(server->virtual_device),
+         input_type,
+         input_code,
+         value
+      );
+   }
 }
 
-int relabsd_server_conversion_loop
+static void reset_axes
 (
-   struct relabsd_server server [const static 1]
+   struct relabsd_server server [const restrict static 1]
 )
 {
-   return 0;
+   relabsd_virtual_device_set_axes_to_zero
+   (
+      &(server->parameters),
+      &(server->virtual_device)
+   );
 }
 
-
-int wait_for_next_event
+static int wait_for_next_event
 (
-   const struct relabsd_physical_device * const input,
-   const struct relabsd_config * const config
+   fd_set ready_to_read [const restrict static 1],
+   struct relabsd_server server [const static 1]
 )
 {
-   int ready_fds;
-   const int old_errno = errno;
-   fd_set ready_to_read;
-   struct timeval curr_timeout;
+   int ready_fds, physical_device_fd, interruption_fd, highest_fd;
 
-   FD_ZERO(&ready_to_read);
-   FD_SET(input->fd, &ready_to_read);
+   FD_ZERO(ready_to_read);
 
-   /* call to select may alter timeout */
-   memcpy
-   (
-      (void *) &(curr_timeout),
-      (const void *) &(config->timeout),
-      sizeof(struct timeval)
-   );
+   physical_device_fd =
+      relabsd_physical_device_get_file_descriptor(&(server->physical_device));
 
-   errno = 0;
+   FD_SET(physical_device_fd, ready_to_read);
 
-   RELABSD_S_ERROR
-   (
-      "Waiting for input to be ready..."
-   );
+   if (relabsd_physical_device_is_late(&(server->physical_device)))
+   {
+      return 1;
+   }
 
-   ready_fds = select
-   (
-      (input->fd + 1),
-      &ready_to_read,
-      (fd_set *) NULL,
-      (fd_set *) NULL,
-      (input->timed_out) ? NULL : &(curr_timeout)
-   );
+   interruption_fd = relabsd_server_get_interruption_file_descriptor();
 
-   if (errno != 0)
-   {
-      RELABSD_ERROR
-      (
-         "Unable to wait for timeout: %s (errno: %d).",
-         strerror(errno),
-         errno
-      );
+   FD_SET(interruption_fd, ready_to_read);
 
-      if (errno == EINTR)
-      {
-         /* Signal interruption? */
-      }
-      else
-      {
-         /* TODO: error message */
-      }
+   if (interruption_fd > physical_device_fd)
+   {
+      highest_fd = interruption_fd;
+   }
+   {
+      highest_fd = physical_device_fd;
+   }
 
-      errno = old_errno;
+   errno = 0;
 
-      return -1;
+   if (relabsd_parameters_use_timeout(&(server->parameters)))
+   {
+      struct timeval curr_timeout;
+
+      /* TODO: mutex lock */
+      /* call to select may alter timeout */
+      curr_timeout = relabsd_parameters_get_timeout(&(server->parameters));
+      /* TODO: mutex unlock */
+
+      ready_fds =
+         select
+         (
+            (highest_fd + 1),
+            ready_to_read,
+            (fd_set *) NULL,
+            (fd_set *) NULL,
+            (struct timeval *) &curr_timeout
+         );
+   }
+   else
+   {
+      ready_fds =
+         select
+         (
+            (highest_fd + 1),
+            ready_to_read,
+            (fd_set *) NULL,
+            (fd_set *) NULL,
+            (struct timeval *) NULL
+         );
    }
 
    if (ready_fds == -1)
    {
-      /* TODO: error message */
-
-      RELABSD_S_ERROR
+      RELABSD_ERROR
       (
-         "Unable to wait for timeout, yet errno was not set to anything."
+         "Error while waiting for new input from the physical device: %s.",
+         strerror(errno)
       );
 
-      errno = old_errno;
+      FD_ZERO(ready_to_read);
 
-      return -1;
+      return 1;
    }
 
-   RELABSD_ERROR
-   (
-      "Input is ready, ready_fds = %d", ready_fds
-   );
-
+   /* ready_fds == 0 on timeout */
    return ready_fds;
 }
+
+/******************************************************************************/
+/**** EXPORTED FUNCTIONS ******************************************************/
+/******************************************************************************/
+int relabsd_server_conversion_loop
+(
+   struct relabsd_server server [const static 1]
+)
+{
+   fd_set ready_to_read;
+
+   for (;;)
+   {
+      switch (wait_for_next_event(&ready_to_read, server))
+      {
+         case 1:
+         case 2:
+            if (!relabsd_server_keep_running())
+            {
+               return 0;
+            }
+
+            if
+            (
+               FD_ISSET
+               (
+                  relabsd_physical_device_get_file_descriptor
+                  (
+                     &(server->physical_device)
+                  ),
+                  &ready_to_read
+               )
+            )
+            {
+               /* TODO: mutex lock */
+               convert_input(server);
+               /* TODO: mutex unlock */
+            }
+
+            break;
+
+         case 0:
+            /* TODO: mutex lock */
+            reset_axes(server);
+            /* TODO: mutex unlock */
+            break;
+      }
+   }
+}
diff --git a/src/server/daemon.c b/src/server/daemon.c
index c8561f3..9740b80 100644
--- a/src/server/daemon.c
+++ b/src/server/daemon.c
@@ -151,6 +151,8 @@ int relabsd_server_create_daemon (void)
 
    if (proc_id != ((pid_t) 0))
    {
+      errno = 0;
+
       if (close(unnamed_pipe[1]) == -1)
       {
          RELABSD_ERROR
@@ -195,6 +197,8 @@ int relabsd_server_create_daemon (void)
    /* We need those. */
 
    /* 14/ Signal completion ***************************************************/
+   errno = 0;
+
    if (write(unnamed_pipe[0], (void *) "!", (size_t) 1) == -1)
    {
       RELABSD_ERROR
@@ -206,6 +210,7 @@ int relabsd_server_create_daemon (void)
    }
 
    /* Step 15 is done on the very first process. */
+   errno = 0;
 
    if (close(unnamed_pipe[1]) == -1)
    {
diff --git a/src/server/interruption.c b/src/server/interruption.c
index 6eb7827..32cda53 100644
--- a/src/server/interruption.c
+++ b/src/server/interruption.c
@@ -1,23 +1,86 @@
+/**** POSIX *******************************************************************/
+#include <errno.h>
+#include <signal.h>
+#include <string.h>
+#include <unistd.h>
+
+/**** RELABSD *****************************************************************/
+#include <relabsd/debug.h>
+
+/******************************************************************************/
+/**** LOCAL FUNCTIONS *********************************************************/
+/******************************************************************************/
+static int RELABSD_INTERRUPTION_PIPES[2];
 static int RELABSD_RUN = 1;
 
-static void interrupt (int unused_mandatory_parameter)
+static void interrupt (int unused_mandatory_parameter __attribute__((unused)))
 {
    RELABSD_RUN = 0;
 
-   RELABSD_S_WARNING("Interrupted, will exit at the next input device event.");
+   errno = 0;
+
+   if (write(RELABSD_INTERRUPTION_PIPES[0], (void *) "!", (size_t) 1) == -1)
+   {
+      RELABSD_ERROR
+      (
+         "Unable to signal the interruption to the conversion thread."
+         " Interruption should still occur following the next input from the"
+         " physical device. Error: %s.",
+         strerror(errno)
+      );
+   }
+}
+
+/******************************************************************************/
+/**** EXPORTED FUNCTIONS ******************************************************/
+/******************************************************************************/
+int relabsd_server_keep_running (void)
+{
+   return RELABSD_RUN;
+}
+
+void relabsd_server_interrupt (void)
+{
+   interrupt(0);
 }
 
-static int set_signal_handlers ()
+int relabsd_server_initialize_signal_handlers (void)
 {
    RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Setting signal handlers.");
 
+   errno = 0;
+
+   if (pipe(RELABSD_INTERRUPTION_PIPES) == -1)
+   {
+      RELABSD_FATAL
+      (
+         "Unable to create an unnamed pipe for the interruption handling: %s",
+         strerror(errno)
+      );
+
+      return -1;
+   }
+
    if (signal(SIGINT, interrupt) == SIG_ERR)
    {
       RELABSD_S_FATAL("Unable to set the SIGINT signal handler.");
 
+      (void) close(RELABSD_INTERRUPTION_PIPES[0]);
+      (void) close(RELABSD_INTERRUPTION_PIPES[1]);
+
       return -1;
    }
 
    return 0;
 }
 
+void relabsd_server_finalize_signal_handlers (void)
+{
+   (void) close(RELABSD_INTERRUPTION_PIPES[0]);
+   (void) close(RELABSD_INTERRUPTION_PIPES[1]);
+}
+
+int relabsd_server_get_interruption_file_descriptor (void)
+{
+   return RELABSD_INTERRUPTION_PIPES[1];
+}
diff --git a/src/server/server.c b/src/server/server.c
index d6678d2..2988732 100644
--- a/src/server/server.c
+++ b/src/server/server.c
@@ -5,22 +5,25 @@
 
 #include <relabsd/config/parameters.h>
 
+#include <relabsd/device/physical_device.h>
+#include <relabsd/device/virtual_device.h>
+
 /******************************************************************************/
 /**** LOCAL FUNCTIONS *********************************************************/
 /******************************************************************************/
 static int initialize
 (
-   struct relabsd_server server [const restrict static 1],
-   struct relabsd_parameters parameters [const static 1]
+   struct relabsd_server server [const restrict static 1]
 )
 {
-   server->parameters = parameters;
-
    if
    (
       relabsd_physical_device_open
       (
-         relabsd_parameters_get_physical_device_name(parameters),
+         relabsd_parameters_get_physical_device_file_name
+         (
+            &(server->parameters)
+         ),
          &(server->physical_device)
       )
       < 0
@@ -29,7 +32,15 @@ static int initialize
       return -1;
    }
 
-   if (relabsd_virtual_device_create(parameters, &(server->virtual_device)) < 0)
+   if
+   (
+      relabsd_virtual_device_create_from
+      (
+         &(server->parameters),
+         &(server->virtual_device)
+      )
+      < 0
+   )
    {
       relabsd_physical_device_close(&(server->physical_device));
 
@@ -39,10 +50,10 @@ static int initialize
    if
    (
       (
-         relabsd_parameters_get_communication_node_name(parameters)
+         relabsd_parameters_get_communication_node_name(&(server->parameters))
          != ((char *) NULL)
       )
-      && (relabsd_server_create_communication_thread(&server) < 0)
+      && (relabsd_server_create_communication_thread(server) < 0)
    )
    {
       relabsd_virtual_device_destroy(&(server->virtual_device));
@@ -58,11 +69,11 @@ static void finalize (struct relabsd_server server [const static 1])
 {
    if
    (
-      relabsd_parameters_get_communication_node_name(server->parameters)
+      relabsd_parameters_get_communication_node_name(&(server->parameters))
       != ((char *) NULL)
    )
    {
-      relabsd_server_join_communication_thread(&server);
+      relabsd_server_join_communication_thread(server);
    }
 
    relabsd_virtual_device_destroy(&(server->virtual_device));
@@ -72,32 +83,34 @@ static void finalize (struct relabsd_server server [const static 1])
 /******************************************************************************/
 /**** EXPORTED FUNCTIONS ******************************************************/
 /******************************************************************************/
-int relabsd_server
+int relabsd_server_main
 (
    const int argc,
-   const char * const argv [const restrict static argc],
-   struct relabsd_parameters parameters [const static 1]
+   const char * const argv [const static argc],
+   struct relabsd_parameters parameters [const restrict static 1]
 )
 {
    struct relabsd_server server;
 
+   server.parameters = *parameters;
+
    RELABSD_S_DEBUG(RELABSD_DEBUG_PROGRAM_FLOW, "Started server mode.");
 
-   if (relabsd_parameters_parse_options(argc, argv, parameters) < 0)
+   if (relabsd_parameters_parse_options(argc, argv, &(server.parameters)) < 0)
    {
       return -1;
    }
 
    if
    (
-      relabsd_parameters_get_run_as_daemon(parameters)
+      relabsd_parameters_get_run_as_daemon(&(server.parameters))
       && (relabsd_server_create_daemon() < 0)
    )
    {
       return -2;
    }
 
-   (void) initialize(&server, parameters);
+   (void) initialize(&server);
 
    (void) relabsd_server_conversion_loop(&server);
 
diff --git a/src/util/string.c b/src/util/string.c
index 7e754bd..ff4e8d3 100644
--- a/src/util/string.c
+++ b/src/util/string.c
@@ -1,5 +1,6 @@
 /**** POSIX *******************************************************************/
 #include <stdlib.h>
+#include <stdio.h>
 
 /******************************************************************************/
 /**** LOCAL FUNCTIONS *********************************************************/
-- 
cgit v1.2.3-70-g09d2