Switched to sockets, continuing implementation...

17 files changed, 869 insertions, 135 deletions

diff --git a/src/server/CMakeLists.txt b/src/server/CMakeLists.txt
index 2d1beaa..b3f0c15 100644
--- a/src/server/CMakeLists.txt
+++ b/src/server/CMakeLists.txt
@@ -1,7 +1,16 @@
 set(
    SRC_FILES ${SRC_FILES}
    ${CMAKE_CURRENT_SOURCE_DIR}/server.c
+   ${CMAKE_CURRENT_SOURCE_DIR}/server_create_socket.c
+   ${CMAKE_CURRENT_SOURCE_DIR}/server_finalize.c
+   ${CMAKE_CURRENT_SOURCE_DIR}/server_initialize.c
+   ${CMAKE_CURRENT_SOURCE_DIR}/server_joining_threads.c
+   ${CMAKE_CURRENT_SOURCE_DIR}/server_new_connection.c
+   ${CMAKE_CURRENT_SOURCE_DIR}/server_signals.c
+   ${CMAKE_CURRENT_SOURCE_DIR}/server_wait_for_event.c
    ${CMAKE_CURRENT_SOURCE_DIR}/server_worker.c
+   ${CMAKE_CURRENT_SOURCE_DIR}/server_worker_handle_request.c
+   ${CMAKE_CURRENT_SOURCE_DIR}/server_worker_receive.c
 )
 
 set(SRC_FILES ${SRC_FILES} PARENT_SCOPE)
diff --git a/src/server/server.c b/src/server/server.c
index 8a75615..874f5eb 100644
--- a/src/server/server.c
+++ b/src/server/server.c
@@ -1,72 +1,81 @@
 #include <signal.h>
+#include <string.h>
 #include <stdio.h>
 
 #include "../parameters/parameters.h"
 
 #include "server.h"
 
-volatile char ZoO_SERVER_IS_RUNNING = (char) 1;
-
-static void request_termination (int const signo)
+int ZoO_server_main
+(
+   const struct ZoO_parameters params [const restrict static 1]
+)
 {
-   if ((signo == SIGINT) || (signo == SIGTERM))
+   struct ZoO_server server;
+   ZoO_index retries;
+
+   if (ZoO_server_set_signal_handlers < 0)
    {
-      ZoO_SERVER_IS_RUNNING = (char) 0;
+      return -1;
    }
-}
 
-int ZoO_server_main (const struct ZoO_parameters params)
-{
-   struct ZoO_server server;
-   struct ZoO_server_message msg_buffer;
-   struct ZoO_server_worker_parameters worker_params;
-
-   if
-   (
-      ZoO_server_initialize
-      (
-         &server,
-         ZoO_parameters_get_session_name(&params)
-      ) < 0
-   )
+   if (ZoO_server_initialize(&server, params) < 0)
    {
       return -1;
    }
 
-   ZoO_server_worker_initialize_parameters
-   (
-      &worker_params,
-      &server,
-      &msg_buffer,
-      &params
-   );
-
-   while ((ZoO_SERVER_IS_RUNNING == (char) 1) || (server.running_threads > 0))
+   while (ZoO_server_is_running())
    {
-      if (ZoO_server_receive_message(&server, &msg_buffer) < 0)
+      switch (ZoO_server_wait_for_new_event(&server))
       {
-         ZoO_server_no_mq_termination(&server);
+         case 0: /* Timed out or signal'd. */
+            ZoO_server_handle_joining_threads(&server);
+
+            retries = 0;
+
+            break;
+
+         case 1: /* New client attempted connection. */
+            ZoO_server_handle_joining_threads(&server);
+            (void) ZoO_server_handle_new_connection(&server);
 
-         break;
+            retries = 0;
+
+            break;
+
+         case -1: /* Something bad happened. */
+            retries += 1;
+
+            if (retries == ZoO_SERVER_MAX_RETRIES)
+            {
+               ZoO_server_finalize(&server);
+
+               return -1;
+            }
+
+            break;
       }
+   }
 
-      switch (msg_buffer.type)
+   /* Waiting for the threads to join... */
+   while (server.workers.currently_running > 0)
+   {
+      switch (ZoO_server_wait_for_new_event(&server))
       {
-         case 'C': /* Client request */
-            ZoO_server_add_worker(&server, &worker_params);
+         case 0: /* Timed out. */
+         case 1: /* New client attempted connection. */
+            ZoO_server_handle_joining_threads(&server);
             break;
 
-         case 'J': /* Join request */
-            ZoO_server_finalize_worker(&server, &msg_buffer);
-            break;
+         case -1: /* Something bad happened. */
+            retries += 1;
+
+            if (retries == ZoO_SERVER_MAX_RETRIES)
+            {
+               ZoO_server_finalize(&server);
 
-         default:
-            fprintf
-            (
-               stderr,
-               "[W] Received message with unknown type '%c'.\n",
-               msg_buffer.type
-            );
+               return -1;
+            }
             break;
       }
    }
diff --git a/src/server/server.h b/src/server/server.h
index f6aa0de..36ec4ce 100644
--- a/src/server/server.h
+++ b/src/server/server.h
@@ -5,36 +5,54 @@
 
 #include "server_types.h"
 
-int ZoO_server_cleanup_session (const char * session);
-
 int ZoO_server_initialize
 (
-   struct ZoO_server [const restrict static 1],
-   const char * session
+   struct ZoO_server server [const restrict static 1],
+   const struct ZoO_parameters params [const restrict static 1]
+);
+
+int ZoO_server_socket_open
+(
+   struct ZoO_server_socket server_socket [const restrict static 1],
+   const char socket_name [const restrict static 1]
+);
+
+void ZoO_server_request_termination (void);
+int ZoO_server_is_running (void);
+int ZoO_server_set_signal_handlers (void);
+
+int ZoO_server_main
+(
+   const struct ZoO_parameters params [const restrict static 1]
 );
 
-int ZoO_server_main (const struct ZoO_parameters params);
-int ZoO_server_finalize (struct ZoO_server [const restrict static 1]);
+void ZoO_server_finalize (struct ZoO_server [const restrict static 1]);
 
-void ZoO_server_no_mq_termination (struct ZoO_server [const restrict static 1]);
+int ZoO_server_wait_for_new_event
+(
+   struct ZoO_server server [const restrict static 1]
+);
 
-int ZoO_server_receive_message
+void ZoO_server_handle_joining_threads
 (
-   struct ZoO_server [const restrict static 1],
-   struct ZoO_server_message msg_buffer [const restrict static 1]
+   struct ZoO_server server [const restrict static 1]
 );
 
-int ZoO_server_add_worker
+int ZoO_server_handle_new_connection
+(
+   struct ZoO_server server [const restrict static 1]
+);
+
+void * ZoO_server_worker_main (void * input);
+
+int ZoO_server_worker_receive
 (
-   struct ZoO_server s [const restrict static 1],
-   struct ZoO_server_message msg_buffer [const restrict static 1],
-   struct ZoO_worker_parameters worker_params [const restrict static 1]
+   struct ZoO_server_worker worker [const restrict static 1]
 );
 
-int ZoO_server_finalize_worker
+int ZoO_server_worker_handle_request
 (
-   struct ZoO_server [const restrict static 1],
-   struct ZoO_server_message msg_buffer [const restrict static 1]
+   struct ZoO_server_worker worker [const restrict static 1]
 );
 
 #endif
diff --git a/src/server/server_add_server_worker.c b/src/server/server_add_server_worker.c
deleted file mode 100644
index cae10fd..0000000
--- a/src/server/server_add_server_worker.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include <pthread.h>
-
-#include "server.h"
-
-int ZoO_server_add_worker
-(
-   struct ZoO_server s [const restrict static 1],
-   struct ZoO_server_message msg_buffer [const restrict static 1]
-)
-{
-   /* TODO */
-   return -1;
-}
diff --git a/src/server/server_create_socket.c b/src/server/server_create_socket.c
new file mode 100644
index 0000000..77e55b7
--- /dev/null
+++ b/src/server/server_create_socket.c
@@ -0,0 +1,188 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <sys/socket.h>
+#include <sys/un.h>
+
+#include "server.h"
+
+static int create_socket (int result [const restrict static 1])
+{
+   const int old_errno = errno;
+
+   errno = 0;
+   *result = socket(AF_UNIX, SOCK_STREAM, 0);
+
+   if (*result == -1)
+   {
+      fprintf
+      (
+         stderr,
+         "[F] Unable to create server socket: %s.\n",
+         strerror(errno)
+      );
+
+      errno = old_errno;
+
+      return -1;
+   }
+
+   errno = old_errno;
+
+   return 0;
+}
+
+static int bind_socket
+(
+   const int socket,
+   const char socket_name [const restrict static 1]
+)
+{
+   struct sockaddr_un addr;
+   const int old_errno = errno;
+
+   errno = 0;
+   memset(&addr, 0, sizeof(struct sockaddr_un));
+
+   addr.sun_family = AF_UNIX;
+
+   /* addr.sun_path == 108. Using 107 ensure null-termination. */
+   strncpy(addr.sun_path, socket_name, 107);
+
+   errno = old_errno;
+
+   if
+   (
+      bind
+      (
+         socket,
+         (const struct sockaddr *) &addr,
+         (socklen_t) sizeof(struct sockaddr_un)
+      ) != 0
+   )
+   {
+      fprintf
+      (
+         stderr,
+         "[F] Unable to bind server socket to %s: %s.\n",
+         socket_name,
+         strerror(errno)
+      );
+
+      errno = old_errno;
+
+      return -1;
+   }
+
+   errno = old_errno;
+
+   return 0;
+}
+
+static int set_socket_to_unblocking (const int socket)
+{
+   int current_flags;
+   const int old_errno = errno;
+
+   current_flags = fcntl(socket, F_GETFD);
+
+   if (current_flags == -1)
+   {
+      fprintf
+      (
+         stderr,
+         "[F] Unable to get server socket properties: %s.\n",
+         strerror(errno)
+      );
+
+      errno = old_errno;
+
+      return -1;
+   }
+
+   /* current_flags = current_flags & (~O_NONBLOCK); */
+
+   current_flags = fcntl(socket, F_SETFD, (current_flags | O_NONBLOCK));
+
+   if (current_flags == -1)
+   {
+      fprintf
+      (
+         stderr,
+         "[F] Unable to set server socket properties: %s.\n",
+         strerror(errno)
+      );
+
+      errno = old_errno;
+
+      return -2;
+   }
+
+   errno = old_errno;
+
+   return 0;
+}
+
+static int set_socket_as_listener (const int socket)
+{
+   const int old_errno = errno;
+
+   if (listen(socket, ZoO_SERVER_SOCKET_LISTEN_BACKLOG) != 0)
+   {
+      fprintf
+      (
+         stderr,
+         "[F] Unable to set server socket properties: %s.\n",
+         strerror(errno)
+      );
+
+      errno = old_errno;
+
+      return -1;
+   }
+
+   errno = old_errno;
+
+   return 0;
+}
+
+int ZoO_server_socket_open
+(
+   struct ZoO_server_socket server_socket [const restrict static 1],
+   const char socket_name [const restrict static 1]
+)
+{
+   if (create_socket(&(server_socket->file_descriptor)) < 0)
+   {
+      return -1;
+   }
+
+   if (bind_socket(server_socket->file_descriptor, socket_name) < 0)
+   {
+      close(server_socket->file_descriptor);
+
+      return -1;
+   }
+
+   if (set_socket_to_unblocking(server_socket->file_descriptor) < 0)
+   {
+      close(server_socket->file_descriptor);
+
+      return -1;
+   }
+
+   if (set_socket_as_listener(server_socket->file_descriptor) < 0)
+   {
+      close(server_socket->file_descriptor);
+
+      return -1;
+   }
+
+   FD_ZERO(&(server_socket->as_a_set));
+   FD_SET(server_socket->file_descriptor, &(server_socket->as_a_set));
+
+   return 0;
+}
diff --git a/src/server/server_finalize.c b/src/server/server_finalize.c
new file mode 100644
index 0000000..c38fb7d
--- /dev/null
+++ b/src/server/server_finalize.c
@@ -0,0 +1,42 @@
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "../parameters/parameters.h"
+
+#include "server.h"
+
+static void finalize_thread_collection
+(
+   struct ZoO_server_thread_collection workers [const restrict static 1]
+)
+{
+   free((void *) workers->threads);
+
+   workers->threads_capacity = 0;
+
+   pthread_mutex_destroy(&(workers->mutex));
+   pthread_barrier_destroy(&(workers->barrier));
+
+   workers->currently_running = 0;
+}
+
+static void finalize_socket
+(
+   struct ZoO_server_socket socket [const restrict static 1]
+)
+{
+   FD_ZERO(&(socket->as_a_set));
+
+   close(socket->file_descriptor);
+
+   socket->file_descriptor = -1;
+}
+
+void ZoO_server_finalize
+(
+   struct ZoO_server server [const restrict static 1]
+)
+{
+   finalize_thread_collection(&(server->workers));
+   finalize_socket(&(server->socket));
+}
diff --git a/src/server/server_initialize.c b/src/server/server_initialize.c
new file mode 100644
index 0000000..9213156
--- /dev/null
+++ b/src/server/server_initialize.c
@@ -0,0 +1,99 @@
+#include <signal.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "../parameters/parameters.h"
+
+#include "server.h"
+
+static int initialize_worker_collection
+(
+   struct ZoO_server_thread_collection c [const restrict static 1]
+)
+{
+	int error;
+
+	c->threads = (struct ZoO_server_thread_data *) NULL;
+	c->threads_capacity = 0;
+   c->currently_running = 0;
+
+	error =
+		pthread_mutex_init
+		(
+			&(c->mutex),
+			(const pthread_mutexattr_t *) NULL
+		);
+
+	if (error != 0)
+	{
+		fprintf
+		(
+			stderr,
+         "[F] Unable to initialize worker collection's mutex: %s.\n",
+         strerror(error)
+		);
+
+      return -1;
+	}
+
+   error =
+      pthread_barrier_init
+      (
+         &(c->barrier),
+         (const pthread_barrierattr_t *) NULL,
+         2
+      );
+
+   if (error != 0)
+	{
+		fprintf
+		(
+			stderr,
+         "[F] Unable to initialize worker collection's barrier: %s.\n",
+         strerror(error)
+		);
+
+      return -1;
+	}
+
+   return 0;
+}
+
+void initialize_thread_parameters
+(
+   struct ZoO_server server [const restrict static 1],
+   const struct ZoO_parameters params [const restrict static 1]
+)
+{
+   server->thread_params.thread_collection = &(server->workers);
+   server->thread_params.server_params = params;
+   server->thread_params.socket = -1;
+}
+
+int ZoO_server_initialize
+(
+   struct ZoO_server server [const restrict static 1],
+   const struct ZoO_parameters params [const restrict static 1]
+)
+{
+   if (initialize_worker_collection(&(server->workers)) < 0)
+   {
+      return -1;
+   }
+
+   if
+   (
+      ZoO_server_socket_open
+      (
+         &(server->socket),
+         ZoO_parameters_get_session_name(params)
+      ) < 0
+   )
+   {
+      return -2;
+   }
+
+   initialize_thread_parameters(server, params);
+
+   return 0;
+}
diff --git a/src/server/server_joining_threads.c b/src/server/server_joining_threads.c
new file mode 100644
index 0000000..48b5ac6
--- /dev/null
+++ b/src/server/server_joining_threads.c
@@ -0,0 +1,36 @@
+#include <sys/socket.h>
+
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#include "../parameters/parameters.h"
+
+#include "server.h"
+
+void ZoO_server_handle_joining_threads
+(
+   struct ZoO_server server [const restrict static 1]
+)
+{
+   ZoO_index i;
+
+   pthread_mutex_lock(&(server->workers.mutex));
+
+   for (i = 0; i < server->workers.threads_capacity; ++i)
+   {
+      if (server->workers.threads[i].state == ZoO_SERVER_JOINING_THREAD)
+      {
+         pthread_join(server->workers.threads[i].posix_id, (void **) NULL);
+
+         server->workers.threads[i].state = ZoO_SERVER_NO_THREAD;
+
+         server->workers.currently_running -= 1;
+      }
+   }
+
+   pthread_mutex_unlock(&(server->workers.mutex));
+}
diff --git a/src/server/server_new_connection.c b/src/server/server_new_connection.c
new file mode 100644
index 0000000..5392de5
--- /dev/null
+++ b/src/server/server_new_connection.c
@@ -0,0 +1,181 @@
+#include <sys/socket.h>
+
+#include <errno.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#include "../parameters/parameters.h"
+
+#include "server.h"
+
+static int get_new_socket (struct ZoO_server server [const restrict static 1])
+{
+   const int old_errno = errno;
+
+   server->thread_params.socket =
+      accept
+      (
+         server->socket.file_descriptor,
+         (struct sockaddr *) NULL,
+         (socklen_t *) NULL
+      );
+
+   if (server->thread_params.socket == -1)
+   {
+      fprintf
+      (
+         stderr,
+         "[E] Unable to accept on the server's socket: %s.\n",
+         strerror(errno)
+      );
+
+      errno = old_errno;
+
+      return -1;
+   }
+
+   errno = old_errno;
+
+   return 0;
+}
+
+static int get_new_thread (struct ZoO_server server [const restrict static 1])
+{
+   struct ZoO_server_thread_data * new_threads;
+   ZoO_index i;
+
+   pthread_mutex_lock(&(server->workers.mutex));
+
+   for (i = 0; i < server->workers.threads_capacity; ++i)
+   {
+      if (server->workers.threads[i].state == ZoO_SERVER_NO_THREAD)
+      {
+         server->thread_params.thread_id = i;
+
+         pthread_mutex_unlock(&(server->workers.mutex));
+
+         return 0;
+      }
+   }
+
+   if
+   (
+      (server->workers.threads_capacity == ZoO_INDEX_MAX)
+      ||
+      (
+         (size_t) (server->workers.threads_capacity + 1)
+         > (SIZE_MAX / sizeof(struct ZoO_server_thread_data))
+      )
+   )
+   {
+      fprintf
+      (
+         stderr,
+         "[E] Maximum number of concurrent threads attained, unable to add"
+         " more.\n"
+      );
+
+      pthread_mutex_unlock(&(server->workers.mutex));
+
+      return -1;
+   }
+
+   server->thread_params.thread_id = server->workers.threads_capacity;
+   server->workers.threads_capacity += 1;
+
+   new_threads =
+      (struct ZoO_server_thread_data *) realloc
+      (
+         &(server->workers.threads),
+         (
+            sizeof(struct ZoO_server_thread_data)
+            * ((size_t) server->workers.threads_capacity)
+         )
+      );
+
+   if (new_threads == ((struct ZoO_server_thread_data *) NULL))
+   {
+      fprintf
+      (
+         stderr,
+         "[E] Reallocation of the threads' data list failed.\n"
+      );
+
+      pthread_mutex_unlock(&(server->workers.mutex));
+
+      return -1;
+   }
+
+   server->workers.threads = new_threads;
+
+   pthread_mutex_unlock(&(server->workers.mutex));
+
+   return 0;
+}
+
+static int spawn_thread (struct ZoO_server server [const restrict static 1])
+{
+   const ZoO_index thread_id = server->thread_params.thread_id;
+   int error;
+
+   server->workers.threads[thread_id].state = ZoO_SERVER_RUNNING_THREAD;
+
+   error =
+      pthread_create
+      (
+         &(server->workers.threads[thread_id].posix_id),
+         (const pthread_attr_t *) NULL,
+         ZoO_server_worker_main,
+         (void *) &(server->thread_params)
+      );
+
+   if (error != 0)
+   {
+      fprintf
+      (
+         stderr,
+         "[E] Unable to spawn thread: %s.\n",
+         strerror(error)
+      );
+
+      server->workers.threads[thread_id].state = ZoO_SERVER_NO_THREAD;
+
+      return -1;
+   }
+
+   pthread_barrier_wait(&(server->workers.barrier));
+
+   server->workers.currently_running += 1;
+
+   return 0;
+}
+
+int ZoO_server_handle_new_connection
+(
+   struct ZoO_server server [const restrict static 1]
+)
+{
+   if (get_new_socket(server) < 0)
+   {
+      return -1;
+   }
+
+   if (get_new_thread(server) < 0)
+   {
+      close(server->thread_params.socket);
+
+      return -2;
+   }
+
+   if (spawn_thread(server) < 0)
+   {
+      close(server->thread_params.socket);
+
+      return -3;
+  }
+
+   return 0;
+}
diff --git a/src/server/server_signal.c b/src/server/server_signal.c
new file mode 100644
index 0000000..97137e8
--- /dev/null
+++ b/src/server/server_signal.c
@@ -0,0 +1,41 @@
+#include <signal.h>
+#include <string.h>
+#include <stdio.h>
+
+#include "server.h"
+
+static volatile char ZoO_SERVER_IS_RUNNING = (char) 1;
+
+static void request_termination (int const signo)
+{
+   if ((signo == SIGINT) || (signo == SIGTERM))
+   {
+      ZoO_server_request_termination();
+   }
+}
+
+void ZoO_server_request_termination (void)
+{
+   ZoO_SERVER_IS_RUNNING = (char) 0;
+}
+
+int ZoO_server_is_running (void)
+{
+   return (int) ZoO_SERVER_IS_RUNNING;
+}
+
+int ZoO_server_set_signal_handlers (void)
+{
+   struct sigaction act;
+
+   /*
+      act.sa_handler = request_termination;
+      act.sa_mask =
+      act.sa_flags =
+      act.sa_restorer =
+   */
+
+   /* TODO */
+
+   return -1;
+}
diff --git a/src/server/server_types.h b/src/server/server_types.h
index aeb0ec8..99959f5 100644
--- a/src/server/server_types.h
+++ b/src/server/server_types.h
@@ -1,27 +1,70 @@
 #ifndef _ZoO_SERVER_SERVER_TYPES_H_
 #define _ZoO_SERVER_SERVER_TYPES_H_
 
-#include <mqueue.h>
+#include <sys/time.h>
+
+#include <pthread.h>
 
 #include "../core/index.h"
 
 #include "../pipe/pipe_types.h"
 
-struct ZoO_server_message
+#define ZoO_SERVER_MAX_RETRIES 10
+#define ZoO_SERVER_BUFFER_SIZE 0
+
+#define ZoO_SERVER_SOCKET_ACCEPT_TIMEOUT_SEC 60
+#define ZoO_SERVER_SOCKET_LISTEN_BACKLOG     5
+
+enum ZoO_server_thread_state
+{
+   ZoO_SERVER_JOINING_THREAD,
+   ZoO_SERVER_RUNNING_THREAD,
+   ZoO_SERVER_NO_THREAD
+};
+
+struct ZoO_server_thread_data
+{
+   pthread_t posix_id;
+   enum ZoO_server_thread_state state;
+};
+
+struct ZoO_server_thread_collection
+{
+   struct ZoO_server_thread_data * threads;
+   size_t threads_capacity;
+   pthread_mutex_t mutex;
+   pthread_barrier_t barrier;
+   ZoO_index currently_running;
+};
+
+struct ZoO_server_socket
+{
+   int file_descriptor;
+   fd_set as_a_set;
+   struct timeval timeout;
+};
+
+struct ZoO_server_thread_parameters
+{
+   struct ZoO_server_thread_collection * thread_collection;
+   const struct ZoO_parameters * server_params;
+   ZoO_index thread_id;
+   int socket;
+};
+
+struct ZoO_server_worker
 {
-   char type;
-   union
-   {
-      struct ZoO_pipe_names pipe_names;
-      ZoO_index pthread_id;
-   } data;
+   char * buffer;
+   size_t buffer_capacity;
+   size_t buffer_length;
+   struct ZoO_server_thread_parameters params;
 };
 
 struct ZoO_server
 {
-   /* TODO: insert 2 thread barrier. */
-   mqd_t mailbox;
-   ZoO_index running_threads;
+   struct ZoO_server_thread_collection workers;
+   struct ZoO_server_socket socket;
+   struct ZoO_server_thread_parameters thread_params;
 };
 
 #endif
diff --git a/src/server/server_wait_for_event.c b/src/server/server_wait_for_event.c
new file mode 100644
index 0000000..b229e6b
--- /dev/null
+++ b/src/server/server_wait_for_event.c
@@ -0,0 +1,53 @@
+#include <sys/select.h>
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "server.h"
+
+int ZoO_server_wait_for_event
+(
+   struct ZoO_server server [const static 1]
+)
+{
+   int ready_fds;
+   const int old_errno = errno;
+
+   /* call to select may alter timeout */
+   memset((void *) &(server->socket.timeout), 0, sizeof(struct timeval));
+
+   server->socket.timeout.tv_sec = ZoO_SERVER_SOCKET_ACCEPT_TIMEOUT_SEC;
+
+   ready_fds = select
+   (
+      (server->socket.file_descriptor + 1),
+      &(server->socket.as_a_set),
+      (fd_set *) NULL,
+      (fd_set *) NULL,
+      &(server->socket.timeout)
+   );
+
+   if (errno == EINTR)
+   {
+      ready_fds = 0;
+   }
+
+   if (ready_fds == -1)
+   {
+      fprintf
+      (
+         stderr,
+         "[F] Unable to wait on server socket: %s.\n",
+         strerror(errno)
+      );
+
+      errno = old_errno;
+
+      return -1;
+   }
+
+   errno = old_errno;
+
+   return ready_fds;
+}
diff --git a/src/server/server_worker.c b/src/server/server_worker.c
index 04f71ca..f6378e0 100644
--- a/src/server/server_worker.c
+++ b/src/server/server_worker.c
@@ -1,21 +1,62 @@
-#include "worker.h"
+#include <signal.h>
+#include <string.h>
+#include <stdio.h>
 
-void ZoO_worker_initialize_parameters
+#include "server.h"
+
+static void initialize
+(
+   struct ZoO_server_worker worker [const restrict static 1],
+   void * input
+)
+{
+   memcpy
+   (
+      (void *) &(worker->params),
+      (const void *) input,
+      sizeof(struct ZoO_server_thread_parameters)
+   );
+
+   pthread_barrier_wait(&(worker->params.thread_collection->barrier));
+
+   worker->buffer = (char *) NULL;
+   worker->buffer_capacity = 0;
+   worker->buffer_length = 0;
+}
+
+static void finalize
 (
-   struct ZoO_worker_parameters worker_params;
-   const struct ZoO_server_message msg_buffer [const restrict static 1],
-   const struct ZoO_parameters params [const restrict static 1]
+   struct ZoO_server_worker worker [const restrict static 1]
 )
 {
-   worker_params->thread_id = 0;
-   pthread_barrier_t * barrier;
-   mqd_t * server_mailbox;
-   const struct ZoO_pipe_names * pipe_names;
+   pthread_mutex_lock(&(worker->params.thread_collection->mutex));
+
+   worker->params.thread_collection->threads[worker->params.thread_id].state =
+      ZoO_SERVER_JOINING_THREAD;
+
+   pthread_mutex_unlock(&(worker->params.thread_collection->mutex));
+}
+
+void * ZoO_server_worker_main (void * input)
+{
+   struct ZoO_server_worker worker;
+
+   initialize(&worker, input);
+
+   while (ZoO_server_is_running())
+   {
+      if (ZoO_server_worker_receive(&worker) < 0)
+      {
+         break;
+      }
+
+      if (ZoO_server_worker_handle_request(&worker) < 0)
+      {
+         break;
+      }
+   }
 
-   /* Program data */
-   ZoO_index markov_order;
-   struct ZoO_knowledge * k;
-   const char * storage_filename;
+   finalize(&worker);
 
-   /* TODO */
+   return NULL;
 }
diff --git a/src/server/server_worker.h b/src/server/server_worker.h
deleted file mode 100644
index 825cc11..0000000
--- a/src/server/server_worker.h
+++ /dev/null
@@ -1,8 +0,0 @@
-#ifndef _ZoO_WORKER_WORKER_H_
-#define _ZoO_WORKER_WORKER_H_
-
-#include "../parameters/parameters_types.h"
-
-#include "worker_types.h"
-
-#endif
diff --git a/src/server/server_worker_handle_request.c b/src/server/server_worker_handle_request.c
new file mode 100644
index 0000000..0c97091
--- /dev/null
+++ b/src/server/server_worker_handle_request.c
@@ -0,0 +1,11 @@
+#include "server.h"
+
+int ZoO_server_worker_handle_request
+(
+   struct ZoO_server_worker worker [const restrict static 1]
+)
+{
+   /* TODO */
+
+   return 0;
+}
diff --git a/src/server/server_worker_receive.c b/src/server/server_worker_receive.c
new file mode 100644
index 0000000..6e70159
--- /dev/null
+++ b/src/server/server_worker_receive.c
@@ -0,0 +1,11 @@
+#include "server.h"
+
+int ZoO_server_worker_receive
+(
+   struct ZoO_server_worker worker [const restrict static 1]
+)
+{
+   /* TODO */
+
+   return 0;
+}
diff --git a/src/server/server_worker_types.h b/src/server/server_worker_types.h
deleted file mode 100644
index 07757bd..0000000
--- a/src/server/server_worker_types.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#ifndef _ZoO_WORKER_WORKER_TYPES_H_
-#define _ZoO_WORKER_WORKER_TYPES_H_
-
-#include <mqueue.h>
-
-#include "../core/index_types.h"
-
-#include "../pipes/pipes_types.h"
-
-#include "../knowledge/knowledge_types.h"
-
-
-struct ZoO_worker_parameters
-{
-   /* Communication data */
-   ZoO_index thread_id;
-   pthread_barrier_t * barrier;
-   mqd_t * server_mailbox;
-   const struct ZoO_pipe_names * pipe_names;
-
-   /* Program data */
-   ZoO_index markov_order;
-   struct ZoO_knowledge * k;
-   const char * storage_filename;
-};
-
-#endif