...

6 files changed, 325 insertions, 173 deletions

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);