summaryrefslogtreecommitdiff
path: root/src/server
diff options
context:
space:
mode:
Diffstat (limited to 'src/server')
-rw-r--r--src/server/communication_node.c15
-rw-r--r--src/server/communication_thread.c33
-rw-r--r--src/server/conversion_main_loop.c331
-rw-r--r--src/server/daemon.c5
-rw-r--r--src/server/interruption.c69
-rw-r--r--src/server/server.c45
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);