X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Futil%2Fservice.c;h=4fd16f93d8386b1624f80e763167c8b1c642ee9b;hb=a12b8c2c4cbf952c8c305cde193bb25c13a0912b;hp=3c9a023cbae13fa8298dccc988d8ebe42e978f32;hpb=66b5a9c821fd60bdc27612e0387d348416e694e0;p=oweals%2Fgnunet.git
diff --git a/src/util/service.c b/src/util/service.c
index 3c9a023cb..4fd16f93d 100644
--- a/src/util/service.c
+++ b/src/util/service.c
@@ -1,33 +1,35 @@
/*
This file is part of GNUnet.
- (C) 2009, 2012 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2016 GNUnet e.V.
- GNUnet is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
+ GNUnet is free software: you can redistribute it and/or modify it
+ under the terms of the GNU Affero General Public License as published
+ by the Free Software Foundation, either version 3 of the License,
+ or (at your option) any later version.
GNUnet is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ Affero General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see .
+
+ SPDX-License-Identifier: AGPL3.0-or-later
*/
/**
- * @file util/service.c
- * @brief functions related to starting services
+ * @file util/service_new.c
+ * @brief functions related to starting services (redesign)
* @author Christian Grothoff
+ * @author Florian Dold
*/
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_constants.h"
#include "gnunet_resolver_service.h"
+#include "speedup.h"
#if HAVE_MALLINFO
#include
@@ -35,29 +37,399 @@
#endif
-#define LOG(kind,...) GNUNET_log_from (kind, "util", __VA_ARGS__)
+#define LOG(kind,...) GNUNET_log_from (kind, "util-service", __VA_ARGS__)
+
+#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util-service", syscall)
+
+#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util-service", syscall, filename)
+
+
+/**
+ * Information the service tracks per listen operation.
+ */
+struct ServiceListenContext
+{
+
+ /**
+ * Kept in a DLL.
+ */
+ struct ServiceListenContext *next;
+
+ /**
+ * Kept in a DLL.
+ */
+ struct ServiceListenContext *prev;
+
+ /**
+ * Service this listen context belongs to.
+ */
+ struct GNUNET_SERVICE_Handle *sh;
+
+ /**
+ * Socket we are listening on.
+ */
+ struct GNUNET_NETWORK_Handle *listen_socket;
+
+ /**
+ * Task scheduled to do the listening.
+ */
+ struct GNUNET_SCHEDULER_Task *listen_task;
+
+};
+
+
+/**
+ * Reasons why we might be suspended.
+ */
+enum SuspendReason
+{
+ /**
+ * We are running normally.
+ */
+ SUSPEND_STATE_NONE = 0,
+
+ /**
+ * Application requested it.
+ */
+ SUSPEND_STATE_APP = 1,
+
+ /**
+ * OS ran out of file descriptors.
+ */
+ SUSPEND_STATE_EMFILE = 2,
+
+ /**
+ * Both reasons, APP and EMFILE apply.
+ */
+ SUSPEND_STATE_APP_AND_EMFILE = 3,
+
+ /**
+ * Suspension because service was permanently shutdown.
+ */
+ SUSPEND_STATE_SHUTDOWN = 4
+};
+
+
+/**
+ * Handle to a service.
+ */
+struct GNUNET_SERVICE_Handle
+{
+ /**
+ * Our configuration.
+ */
+ const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+ /**
+ * Name of our service.
+ */
+ const char *service_name;
+
+ /**
+ * Main service-specific task to run.
+ */
+ GNUNET_SERVICE_InitCallback service_init_cb;
+
+ /**
+ * Function to call when clients connect.
+ */
+ GNUNET_SERVICE_ConnectHandler connect_cb;
+
+ /**
+ * Function to call when clients disconnect / are disconnected.
+ */
+ GNUNET_SERVICE_DisconnectHandler disconnect_cb;
+
+ /**
+ * Closure for @e service_init_cb, @e connect_cb, @e disconnect_cb.
+ */
+ void *cb_cls;
+
+ /**
+ * DLL of listen sockets used to accept new connections.
+ */
+ struct ServiceListenContext *slc_head;
+
+ /**
+ * DLL of listen sockets used to accept new connections.
+ */
+ struct ServiceListenContext *slc_tail;
+
+ /**
+ * Our clients, kept in a DLL.
+ */
+ struct GNUNET_SERVICE_Client *clients_head;
+
+ /**
+ * Our clients, kept in a DLL.
+ */
+ struct GNUNET_SERVICE_Client *clients_tail;
+
+ /**
+ * Message handlers to use for all clients.
+ */
+ struct GNUNET_MQ_MessageHandler *handlers;
+
+ /**
+ * Closure for @e task.
+ */
+ void *task_cls;
+
+ /**
+ * IPv4 addresses that are not allowed to connect.
+ */
+ struct GNUNET_STRINGS_IPv4NetworkPolicy *v4_denied;
+
+ /**
+ * IPv6 addresses that are not allowed to connect.
+ */
+ struct GNUNET_STRINGS_IPv6NetworkPolicy *v6_denied;
+
+ /**
+ * IPv4 addresses that are allowed to connect (if not
+ * set, all are allowed).
+ */
+ struct GNUNET_STRINGS_IPv4NetworkPolicy *v4_allowed;
+
+ /**
+ * IPv6 addresses that are allowed to connect (if not
+ * set, all are allowed).
+ */
+ struct GNUNET_STRINGS_IPv6NetworkPolicy *v6_allowed;
+
+ /**
+ * Do we require a matching UID for UNIX domain socket connections?
+ * #GNUNET_NO means that the UID does not have to match (however,
+ * @e match_gid may still impose other access control checks).
+ */
+ int match_uid;
+
+ /**
+ * Do we require a matching GID for UNIX domain socket connections?
+ * Ignored if @e match_uid is #GNUNET_YES. Note that this is about
+ * checking that the client's UID is in our group OR that the
+ * client's GID is our GID. If both "match_gid" and @e match_uid are
+ * #GNUNET_NO, all users on the local system have access.
+ */
+ int match_gid;
+
+ /**
+ * Are we suspended, and if so, why?
+ */
+ enum SuspendReason suspend_state;
+
+ /**
+ * Our options.
+ */
+ enum GNUNET_SERVICE_Options options;
-#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util", syscall)
+ /**
+ * If we are daemonizing, this FD is set to the
+ * pipe to the parent. Send '.' if we started
+ * ok, '!' if not. -1 if we are not daemonizing.
+ */
+ int ready_confirm_fd;
-#define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util", syscall, filename)
+ /**
+ * Overall success/failure of the service start.
+ */
+ int ret;
+ /**
+ * If #GNUNET_YES, consider unknown message types an error where the
+ * client is disconnected.
+ */
+ int require_found;
+};
-/* ******************* access control ******************** */
/**
- * Start task that may speed up our system clock artificially
+ * Handle to a client that is connected to a service.
+ */
+struct GNUNET_SERVICE_Client
+{
+
+ /**
+ * Kept in a DLL.
+ */
+ struct GNUNET_SERVICE_Client *next;
+
+ /**
+ * Kept in a DLL.
+ */
+ struct GNUNET_SERVICE_Client *prev;
+
+ /**
+ * Service that this client belongs to.
+ */
+ struct GNUNET_SERVICE_Handle *sh;
+
+ /**
+ * Socket of this client.
+ */
+ struct GNUNET_NETWORK_Handle *sock;
+
+ /**
+ * Message queue for the client.
+ */
+ struct GNUNET_MQ_Handle *mq;
+
+ /**
+ * Tokenizer we use for processing incoming data.
+ */
+ struct GNUNET_MessageStreamTokenizer *mst;
+
+ /**
+ * Task that warns about missing calls to
+ * #GNUNET_SERVICE_client_continue().
+ */
+ struct GNUNET_SCHEDULER_Task *warn_task;
+
+ /**
+ * Task run to finish dropping the client after the stack has
+ * properly unwound.
+ */
+ struct GNUNET_SCHEDULER_Task *drop_task;
+
+ /**
+ * Task that receives data from the client to
+ * pass it to the handlers.
+ */
+ struct GNUNET_SCHEDULER_Task *recv_task;
+
+ /**
+ * Task that transmit data to the client.
+ */
+ struct GNUNET_SCHEDULER_Task *send_task;
+
+ /**
+ * Pointer to the message to be transmitted by @e send_task.
+ */
+ const struct GNUNET_MessageHeader *msg;
+
+ /**
+ * User context value, value returned from
+ * the connect callback.
+ */
+ void *user_context;
+
+ /**
+ * Time when we last gave a message from this client
+ * to the application.
+ */
+ struct GNUNET_TIME_Absolute warn_start;
+
+ /**
+ * Current position in @e msg at which we are transmitting.
+ */
+ size_t msg_pos;
+
+ /**
+ * Persist the file handle for this client no matter what happens,
+ * force the OS to close once the process actually dies. Should only
+ * be used in special cases!
+ */
+ int persist;
+
+ /**
+ * Is this client a 'monitor' client that should not be counted
+ * when deciding on destroying the server during soft shutdown?
+ * (see also #GNUNET_SERVICE_start)
+ */
+ int is_monitor;
+
+ /**
+ * Are we waiting for the application to call #GNUNET_SERVICE_client_continue()?
+ */
+ int needs_continue;
+
+ /**
+ * Type of last message processed (for warn_no_receive_done).
+ */
+ uint16_t warn_type;
+};
+
+
+/**
+ * Check if any of the clients we have left are unrelated to
+ * monitoring.
*
- * @param cfg configuration to use
- * @return GNUNET_OK on success, GNUNET_SYSERR if the speedup was not configured
+ * @param sh service to check clients for
+ * @return #GNUNET_YES if we have non-monitoring clients left
*/
-int
-GNUNET_SPEEDUP_start_ (const struct GNUNET_CONFIGURATION_Handle *cfg);
+static int
+have_non_monitor_clients (struct GNUNET_SERVICE_Handle *sh)
+{
+ for (struct GNUNET_SERVICE_Client *client = sh->clients_head;
+ NULL != client;
+ client = client->next)
+ {
+ if (client->is_monitor)
+ continue;
+ return GNUNET_YES;
+ }
+ return GNUNET_NO;
+}
+
/**
- * Stop tasks that modify clock behavior.
+ * Suspend accepting connections from the listen socket temporarily.
+ * Resume activity using #do_resume.
+ *
+ * @param sh service to stop accepting connections.
+ * @param sr reason for suspending accepting connections
*/
-void
-GNUNET_SPEEDUP_stop_ (void);
+static void
+do_suspend (struct GNUNET_SERVICE_Handle *sh,
+ enum SuspendReason sr)
+{
+ struct ServiceListenContext *slc;
+
+ GNUNET_assert (0 == (sh->suspend_state & sr));
+ sh->suspend_state |= sr;
+ for (slc = sh->slc_head; NULL != slc; slc = slc->next)
+ {
+ if (NULL != slc->listen_task)
+ {
+ GNUNET_SCHEDULER_cancel (slc->listen_task);
+ slc->listen_task = NULL;
+ }
+ }
+}
+
+
+/**
+ * Shutdown task triggered when a service should be terminated.
+ * This considers active clients and the service options to see
+ * how this specific service is to be terminated, and depending
+ * on this proceeds with the shutdown logic.
+ *
+ * @param cls our `struct GNUNET_SERVICE_Handle`
+ */
+static void
+service_shutdown (void *cls)
+{
+ struct GNUNET_SERVICE_Handle *sh = cls;
+
+ switch (sh->options)
+ {
+ case GNUNET_SERVICE_OPTION_NONE:
+ GNUNET_SERVICE_shutdown (sh);
+ break;
+ case GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN:
+ /* This task should never be run if we are using
+ the manual shutdown. */
+ GNUNET_assert (0);
+ break;
+ case GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN:
+ if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN))
+ do_suspend (sh,
+ SUSPEND_STATE_SHUTDOWN);
+ if (GNUNET_NO == have_non_monitor_clients (sh))
+ GNUNET_SERVICE_shutdown (sh);
+ break;
+ }
+}
/**
@@ -76,7 +448,8 @@ check_ipv4_listed (const struct GNUNET_STRINGS_IPv4NetworkPolicy *list,
if (NULL == list)
return GNUNET_NO;
i = 0;
- while ((list[i].network.s_addr != 0) || (list[i].netmask.s_addr != 0))
+ while ( (0 != list[i].network.s_addr) ||
+ (0 != list[i].netmask.s_addr) )
{
if ((add->s_addr & list[i].netmask.s_addr) ==
(list[i].network.s_addr & list[i].netmask.s_addr))
@@ -100,14 +473,12 @@ check_ipv6_listed (const struct GNUNET_STRINGS_IPv6NetworkPolicy *list,
{
unsigned int i;
unsigned int j;
- struct in6_addr zero;
if (NULL == list)
return GNUNET_NO;
- memset (&zero, 0, sizeof (struct in6_addr));
i = 0;
NEXT:
- while (0 != memcmp (&zero, &list[i].network, sizeof (struct in6_addr)))
+ while (0 != GNUNET_is_zero (&list[i].network))
{
for (j = 0; j < sizeof (struct in6_addr) / sizeof (int); j++)
if (((((int *) ip)[j] & ((int *) &list[i].netmask)[j])) !=
@@ -122,275 +493,464 @@ NEXT:
}
-/* ****************** service struct ****************** */
-
-
/**
- * Context for "service_task".
+ * Task run when we are ready to transmit data to the
+ * client.
+ *
+ * @param cls the `struct GNUNET_SERVICE_Client *` to send to
*/
-struct GNUNET_SERVICE_Context
+static void
+do_send (void *cls)
{
- /**
- * Our configuration.
- */
- const struct GNUNET_CONFIGURATION_Handle *cfg;
-
- /**
- * Handle for the server.
- */
- struct GNUNET_SERVER_Handle *server;
-
- /**
- * NULL-terminated array of addresses to bind to, NULL if we got pre-bound
- * listen sockets.
- */
- struct sockaddr **addrs;
-
- /**
- * Name of our service.
- */
- const char *service_name;
-
- /**
- * Main service-specific task to run.
- */
- GNUNET_SERVICE_Main task;
+ struct GNUNET_SERVICE_Client *client = cls;
+ ssize_t ret;
+ size_t left;
+ const char *buf;
- /**
- * Closure for task.
- */
- void *task_cls;
-
- /**
- * IPv4 addresses that are not allowed to connect.
- */
- struct GNUNET_STRINGS_IPv4NetworkPolicy *v4_denied;
-
- /**
- * IPv6 addresses that are not allowed to connect.
- */
- struct GNUNET_STRINGS_IPv6NetworkPolicy *v6_denied;
-
- /**
- * IPv4 addresses that are allowed to connect (if not
- * set, all are allowed).
- */
- struct GNUNET_STRINGS_IPv4NetworkPolicy *v4_allowed;
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "service: sending message with type %u\n",
+ ntohs(client->msg->type));
+
+
+ client->send_task = NULL;
+ buf = (const char *) client->msg;
+ left = ntohs (client->msg->size) - client->msg_pos;
+ ret = GNUNET_NETWORK_socket_send (client->sock,
+ &buf[client->msg_pos],
+ left);
+ GNUNET_assert (ret <= (ssize_t) left);
+ if (0 == ret)
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "no data send");
+ GNUNET_MQ_inject_error (client->mq,
+ GNUNET_MQ_ERROR_WRITE);
+ return;
+ }
+ if (-1 == ret)
+ {
+ if ( (EAGAIN == errno) ||
+ (EINTR == errno) )
+ {
+ /* ignore */
+ ret = 0;
+ }
+ else
+ {
+ if (EPIPE != errno)
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
+ "send");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "socket send returned with error code %i",
+ errno);
+ GNUNET_MQ_inject_error (client->mq,
+ GNUNET_MQ_ERROR_WRITE);
+ return;
+ }
+ }
+ if (0 == client->msg_pos)
+ {
+ GNUNET_MQ_impl_send_in_flight (client->mq);
+ }
+ client->msg_pos += ret;
+ if (left > (size_t) ret)
+ {
+ GNUNET_assert (NULL == client->drop_task);
+ client->send_task
+ = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ client->sock,
+ &do_send,
+ client);
+ return;
+ }
+ GNUNET_MQ_impl_send_continue (client->mq);
+}
- /**
- * IPv6 addresses that are allowed to connect (if not
- * set, all are allowed).
- */
- struct GNUNET_STRINGS_IPv6NetworkPolicy *v6_allowed;
- /**
- * My (default) message handlers. Adjusted copy
- * of "defhandlers".
- */
- struct GNUNET_SERVER_MessageHandler *my_handlers;
+/**
+ * Signature of functions implementing the sending functionality of a
+ * message queue.
+ *
+ * @param mq the message queue
+ * @param msg the message to send
+ * @param impl_state our `struct GNUNET_SERVICE_Client *`
+ */
+static void
+service_mq_send (struct GNUNET_MQ_Handle *mq,
+ const struct GNUNET_MessageHeader *msg,
+ void *impl_state)
+{
+ struct GNUNET_SERVICE_Client *client = impl_state;
- /**
- * Array of the lengths of the entries in addrs.
- */
- socklen_t *addrlens;
+ (void) mq;
+ if (NULL != client->drop_task)
+ return; /* we're going down right now, do not try to send */
+ GNUNET_assert (NULL == client->send_task);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Sending message of type %u and size %u to client\n",
+ ntohs (msg->type),
+ ntohs (msg->size));
+ client->msg = msg;
+ client->msg_pos = 0;
+ client->send_task
+ = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ client->sock,
+ &do_send,
+ client);
+}
- /**
- * NULL-terminated array of listen sockets we should take over.
- */
- struct GNUNET_NETWORK_Handle **lsocks;
- /**
- * Task ID of the shutdown task.
- */
- GNUNET_SCHEDULER_TaskIdentifier shutdown_task;
+/**
+ * Implementation function that cancels the currently sent message.
+ *
+ * @param mq message queue
+ * @param impl_state state specific to the implementation
+ */
+static void
+service_mq_cancel (struct GNUNET_MQ_Handle *mq,
+ void *impl_state)
+{
+ struct GNUNET_SERVICE_Client *client = impl_state;
- /**
- * Idle timeout for server.
- */
- struct GNUNET_TIME_Relative timeout;
+ (void) mq;
+ GNUNET_assert (0 == client->msg_pos);
+ client->msg = NULL;
+ GNUNET_SCHEDULER_cancel (client->send_task);
+ client->send_task = NULL;
+}
- /**
- * Overall success/failure of the service start.
- */
- int ret;
- /**
- * If we are daemonizing, this FD is set to the
- * pipe to the parent. Send '.' if we started
- * ok, '!' if not. -1 if we are not daemonizing.
- */
- int ready_confirm_fd;
+/**
+ * Generic error handler, called with the appropriate
+ * error code and the same closure specified at the creation of
+ * the message queue.
+ * Not every message queue implementation supports an error handler.
+ *
+ * @param cls closure with our `struct GNUNET_SERVICE_Client`
+ * @param error error code
+ */
+static void
+service_mq_error_handler (void *cls,
+ enum GNUNET_MQ_Error error)
+{
+ struct GNUNET_SERVICE_Client *client = cls;
+ struct GNUNET_SERVICE_Handle *sh = client->sh;
- /**
- * Do we close connections if we receive messages
- * for which we have no handler?
- */
- int require_found;
+ if ( (GNUNET_MQ_ERROR_NO_MATCH == error) &&
+ (GNUNET_NO == sh->require_found) )
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "No handler for message of type %u found\n",
+ (unsigned int) client->warn_type);
+ GNUNET_SERVICE_client_continue (client);
+ return; /* ignore error */
+ }
+ GNUNET_SERVICE_client_drop (client);
+}
- /**
- * Do we require a matching UID for UNIX domain socket connections?
- * #GNUNET_NO means that the UID does not have to match (however,
- * @e match_gid may still impose other access control checks).
- */
- int match_uid;
- /**
- * Do we require a matching GID for UNIX domain socket connections?
- * Ignored if @e match_uid is #GNUNET_YES. Note that this is about
- * checking that the client's UID is in our group OR that the
- * client's GID is our GID. If both "match_gid" and @e match_uid are
- * #GNUNET_NO, all users on the local system have access.
- */
- int match_gid;
+/**
+ * Task run to warn about missing calls to #GNUNET_SERVICE_client_continue().
+ *
+ * @param cls our `struct GNUNET_SERVICE_Client *` to process more requests from
+ */
+static void
+warn_no_client_continue (void *cls)
+{
+ struct GNUNET_SERVICE_Client *client = cls;
+
+ GNUNET_break (0 != client->warn_type); /* type should never be 0 here, as we don't use 0 */
+ client->warn_task
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+ &warn_no_client_continue,
+ client);
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ _("Processing code for message of type %u did not call `GNUNET_SERVICE_client_continue' after %s\n"),
+ (unsigned int) client->warn_type,
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (client->warn_start),
+ GNUNET_YES));
+}
- /**
- * Our options.
- */
- enum GNUNET_SERVICE_Options options;
-};
+/**
+ * Functions with this signature are called whenever a
+ * complete message is received by the tokenizer for a client.
+ *
+ * Do not call #GNUNET_MST_destroy() from within
+ * the scope of this callback.
+ *
+ * @param cls closure with the `struct GNUNET_SERVICE_Client *`
+ * @param message the actual message
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR if the client was dropped
+ */
+static int
+service_client_mst_cb (void *cls,
+ const struct GNUNET_MessageHeader *message)
+{
+ struct GNUNET_SERVICE_Client *client = cls;
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Received message of type %u and size %u from client\n",
+ ntohs (message->type),
+ ntohs (message->size));
+ GNUNET_assert (GNUNET_NO == client->needs_continue);
+ client->needs_continue = GNUNET_YES;
+ client->warn_type = ntohs (message->type);
+ client->warn_start = GNUNET_TIME_absolute_get ();
+ GNUNET_assert (NULL == client->warn_task);
+ client->warn_task
+ = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+ &warn_no_client_continue,
+ client);
+ GNUNET_MQ_inject_message (client->mq,
+ message);
+ if (NULL != client->drop_task)
+ return GNUNET_SYSERR;
+ return GNUNET_OK;
+}
-/* ****************** message handlers ****************** */
/**
- * Send a 'TEST' message back to the client.
+ * A client sent us data. Receive and process it. If we are done,
+ * reschedule this task.
*
- * @param cls the 'struct GNUNET_SERVER_Client' to send TEST to
- * @param size number of bytes available in 'buf'
- * @param buf where to copy the message
- * @return number of bytes written to 'buf'
+ * @param cls the `struct GNUNET_SERVICE_Client` that sent us data.
*/
-static size_t
-write_test (void *cls, size_t size, void *buf)
+static void
+service_client_recv (void *cls)
{
- struct GNUNET_SERVER_Client *client = cls;
- struct GNUNET_MessageHeader *msg;
+ struct GNUNET_SERVICE_Client *client = cls;
+ int ret;
- if (size < sizeof (struct GNUNET_MessageHeader))
+ client->recv_task = NULL;
+ ret = GNUNET_MST_read (client->mst,
+ client->sock,
+ GNUNET_NO,
+ GNUNET_YES);
+ if (GNUNET_SYSERR == ret)
{
- GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
- return 0; /* client disconnected */
+ /* client closed connection (or IO error) */
+ if (NULL == client->drop_task)
+ {
+ GNUNET_assert (GNUNET_NO == client->needs_continue);
+ GNUNET_SERVICE_client_drop (client);
+ }
+ return;
}
- msg = (struct GNUNET_MessageHeader *) buf;
- msg->type = htons (GNUNET_MESSAGE_TYPE_TEST);
- msg->size = htons (sizeof (struct GNUNET_MessageHeader));
- GNUNET_SERVER_receive_done (client, GNUNET_OK);
- return sizeof (struct GNUNET_MessageHeader);
+ if (GNUNET_NO == ret)
+ return; /* more messages in buffer, wait for application
+ to be done processing */
+ GNUNET_assert (GNUNET_OK == ret);
+ if (GNUNET_YES == client->needs_continue)
+ return;
+ if (NULL != client->recv_task)
+ return;
+ /* MST needs more data, re-schedule read job */
+ client->recv_task
+ = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ client->sock,
+ &service_client_recv,
+ client);
}
/**
- * Handler for TEST message.
+ * We have successfully accepted a connection from a client. Now
+ * setup the client (with the scheduler) and tell the application.
*
- * @param cls closure (refers to service)
- * @param client identification of the client
- * @param message the actual message
+ * @param sh service that accepted the client
+ * @param sock socket associated with the client
*/
static void
-handle_test (void *cls, struct GNUNET_SERVER_Client *client,
- const struct GNUNET_MessageHeader *message)
+start_client (struct GNUNET_SERVICE_Handle *sh,
+ struct GNUNET_NETWORK_Handle *csock)
{
- /* simply bounce message back to acknowledge */
- if (NULL ==
- GNUNET_SERVER_notify_transmit_ready (client,
- sizeof (struct GNUNET_MessageHeader),
- GNUNET_TIME_UNIT_FOREVER_REL,
- &write_test, client))
- GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ struct GNUNET_SERVICE_Client *client;
+
+ client = GNUNET_new (struct GNUNET_SERVICE_Client);
+ GNUNET_CONTAINER_DLL_insert (sh->clients_head,
+ sh->clients_tail,
+ client);
+ client->sh = sh;
+ client->sock = csock;
+ client->mq = GNUNET_MQ_queue_for_callbacks (&service_mq_send,
+ NULL,
+ &service_mq_cancel,
+ client,
+ sh->handlers,
+ &service_mq_error_handler,
+ client);
+ client->mst = GNUNET_MST_create (&service_client_mst_cb,
+ client);
+ if (NULL != sh->connect_cb)
+ client->user_context = sh->connect_cb (sh->cb_cls,
+ client,
+ client->mq);
+ GNUNET_MQ_set_handlers_closure (client->mq,
+ client->user_context);
+ client->recv_task
+ = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ client->sock,
+ &service_client_recv,
+ client);
}
/**
- * Default handlers for all services. Will be copied and the
- * "callback_cls" fields will be replaced with the specific service
- * struct.
+ * We have a client. Accept the incoming socket(s) (and reschedule
+ * the listen task).
+ *
+ * @param cls the `struct ServiceListenContext` of the ready listen socket
*/
-static const struct GNUNET_SERVER_MessageHandler defhandlers[] = {
- {&handle_test, NULL, GNUNET_MESSAGE_TYPE_TEST,
- sizeof (struct GNUNET_MessageHeader)},
- {NULL, NULL, 0, 0}
-};
-
+static void
+accept_client (void *cls)
+{
+ struct ServiceListenContext *slc = cls;
+ struct GNUNET_SERVICE_Handle *sh = slc->sh;
-/* ****************** service core routines ************** */
+ slc->listen_task = NULL;
+ while (1)
+ {
+ struct GNUNET_NETWORK_Handle *sock;
+ const struct sockaddr_in *v4;
+ const struct sockaddr_in6 *v6;
+ struct sockaddr_storage sa;
+ socklen_t addrlen;
+ int ok;
+
+ addrlen = sizeof (sa);
+ sock = GNUNET_NETWORK_socket_accept (slc->listen_socket,
+ (struct sockaddr *) &sa,
+ &addrlen);
+ if (NULL == sock)
+ {
+ if (EMFILE == errno)
+ do_suspend (sh,
+ SUSPEND_STATE_EMFILE);
+ else if (EAGAIN != errno)
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING,
+ "accept");
+ break;
+ }
+ switch (sa.ss_family)
+ {
+ case AF_INET:
+ GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
+ v4 = (const struct sockaddr_in *) &sa;
+ ok = ( ( (NULL == sh->v4_allowed) ||
+ (check_ipv4_listed (sh->v4_allowed,
+ &v4->sin_addr))) &&
+ ( (NULL == sh->v4_denied) ||
+ (! check_ipv4_listed (sh->v4_denied,
+ &v4->sin_addr)) ) );
+ break;
+ case AF_INET6:
+ GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
+ v6 = (const struct sockaddr_in6 *) &sa;
+ ok = ( ( (NULL == sh->v6_allowed) ||
+ (check_ipv6_listed (sh->v6_allowed,
+ &v6->sin6_addr))) &&
+ ( (NULL == sh->v6_denied) ||
+ (! check_ipv6_listed (sh->v6_denied,
+ &v6->sin6_addr)) ) );
+ break;
+#ifndef WINDOWS
+ case AF_UNIX:
+ ok = GNUNET_OK; /* controlled using file-system ACL now */
+ break;
+#endif
+ default:
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ _("Unknown address family %d\n"),
+ sa.ss_family);
+ return;
+ }
+ if (! ok)
+ {
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Service rejected incoming connection from %s due to policy.\n",
+ GNUNET_a2s ((const struct sockaddr *) &sa,
+ addrlen));
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (sock));
+ continue;
+ }
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Service accepted incoming connection from %s.\n",
+ GNUNET_a2s ((const struct sockaddr *) &sa,
+ addrlen));
+ start_client (slc->sh,
+ sock);
+ }
+ if (0 != sh->suspend_state)
+ return;
+ slc->listen_task
+ = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ slc->listen_socket,
+ &accept_client,
+ slc);
+}
/**
- * Check if access to the service is allowed from the given address.
+ * Resume accepting connections from the listen socket.
*
- * @param cls closure
- * @param uc credentials, if available, otherwise NULL
- * @param addr address
- * @param addrlen length of address
- * @return #GNUNET_YES to allow, #GNUNET_NO to deny, #GNUNET_SYSERR
- * for unknown address family (will be denied).
+ * @param sh service to resume accepting connections.
+ * @param sr reason that is no longer causing the suspension,
+ * or #SUSPEND_STATE_NONE on first startup
*/
-static int
-check_access (void *cls, const struct GNUNET_CONNECTION_Credentials *uc,
- const struct sockaddr *addr, socklen_t addrlen)
+static void
+do_resume (struct GNUNET_SERVICE_Handle *sh,
+ enum SuspendReason sr)
{
- struct GNUNET_SERVICE_Context *sctx = cls;
- const struct sockaddr_in *i4;
- const struct sockaddr_in6 *i6;
- int ret;
+ struct ServiceListenContext *slc;
- switch (addr->sa_family)
- {
- case AF_INET:
- GNUNET_assert (addrlen == sizeof (struct sockaddr_in));
- i4 = (const struct sockaddr_in *) addr;
- ret = ((NULL == sctx->v4_allowed) ||
- (check_ipv4_listed (sctx->v4_allowed, &i4->sin_addr))) &&
- ((NULL == sctx->v4_denied) ||
- (!check_ipv4_listed (sctx->v4_denied, &i4->sin_addr)));
- break;
- case AF_INET6:
- GNUNET_assert (addrlen == sizeof (struct sockaddr_in6));
- i6 = (const struct sockaddr_in6 *) addr;
- ret = ((NULL == sctx->v6_allowed) ||
- (check_ipv6_listed (sctx->v6_allowed, &i6->sin6_addr))) &&
- ((NULL == sctx->v6_denied) ||
- (!check_ipv6_listed (sctx->v6_denied, &i6->sin6_addr)));
- break;
-#ifndef WINDOWS
- case AF_UNIX:
- ret = GNUNET_OK; /* controlled using file-system ACL now */
- break;
-#endif
- default:
- LOG (GNUNET_ERROR_TYPE_WARNING, _("Unknown address family %d\n"),
- addr->sa_family);
- return GNUNET_SYSERR;
- }
- if (GNUNET_OK != ret)
+ GNUNET_assert ( (SUSPEND_STATE_NONE == sr) ||
+ (0 != (sh->suspend_state & sr)) );
+ sh->suspend_state -= sr;
+ if (SUSPEND_STATE_NONE != sh->suspend_state)
+ return;
+ for (slc = sh->slc_head; NULL != slc; slc = slc->next)
{
- LOG (GNUNET_ERROR_TYPE_WARNING,
- _("Access from `%s' denied to service `%s'\n"),
- GNUNET_a2s (addr, addrlen),
- sctx->service_name);
+ GNUNET_assert (NULL == slc->listen_task);
+ slc->listen_task
+ = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ slc->listen_socket,
+ &accept_client,
+ slc);
}
- return ret;
}
/**
- * Get the name of the file where we will
- * write the PID of the service.
+ * First task run by any service. Initializes our shutdown task,
+ * starts the listening operation on our listen sockets and launches
+ * the custom logic of the application service.
*
- * @param sctx service context
- * @return name of the file for the process ID
+ * @param cls our `struct GNUNET_SERVICE_Handle`
*/
-static char *
-get_pid_file_name (struct GNUNET_SERVICE_Context *sctx)
+static void
+service_main (void *cls)
{
- char *pif;
+ struct GNUNET_SERVICE_Handle *sh = cls;
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (sctx->cfg, sctx->service_name,
- "PIDFILE", &pif))
- return NULL;
- return pif;
+ if (GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN != sh->options)
+ GNUNET_SCHEDULER_add_shutdown (&service_shutdown,
+ sh);
+ do_resume (sh,
+ SUSPEND_STATE_NONE);
+
+ if (-1 != sh->ready_confirm_fd)
+ {
+ GNUNET_break (1 == WRITE (sh->ready_confirm_fd, ".", 1));
+ GNUNET_break (0 == CLOSE (sh->ready_confirm_fd));
+ sh->ready_confirm_fd = -1;
+ }
+
+ if (NULL != sh->service_init_cb)
+ sh->service_init_cb (sh->cb_cls,
+ sh->cfg,
+ sh);
}
@@ -398,31 +958,37 @@ get_pid_file_name (struct GNUNET_SERVICE_Context *sctx)
* Parse an IPv4 access control list.
*
* @param ret location where to write the ACL (set)
- * @param sctx service context to use to get the configuration
+ * @param sh service context to use to get the configuration
* @param option name of the ACL option to parse
* @return #GNUNET_SYSERR on parse error, #GNUNET_OK on success (including
* no ACL configured)
*/
static int
-process_acl4 (struct GNUNET_STRINGS_IPv4NetworkPolicy **ret, struct GNUNET_SERVICE_Context *sctx,
+process_acl4 (struct GNUNET_STRINGS_IPv4NetworkPolicy **ret,
+ struct GNUNET_SERVICE_Handle *sh,
const char *option)
{
char *opt;
- if (!GNUNET_CONFIGURATION_have_value (sctx->cfg, sctx->service_name, option))
+ if (! GNUNET_CONFIGURATION_have_value (sh->cfg,
+ sh->service_name,
+ option))
{
*ret = NULL;
return GNUNET_OK;
}
GNUNET_break (GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_string (sctx->cfg,
- sctx->service_name,
- option, &opt));
+ GNUNET_CONFIGURATION_get_value_string (sh->cfg,
+ sh->service_name,
+ option,
+ &opt));
if (NULL == (*ret = GNUNET_STRINGS_parse_ipv4_policy (opt)))
{
LOG (GNUNET_ERROR_TYPE_WARNING,
_("Could not parse IPv4 network specification `%s' for `%s:%s'\n"),
- opt, sctx->service_name, option);
+ opt,
+ sh->service_name,
+ option);
GNUNET_free (opt);
return GNUNET_SYSERR;
}
@@ -435,31 +1001,37 @@ process_acl4 (struct GNUNET_STRINGS_IPv4NetworkPolicy **ret, struct GNUNET_SERVI
* Parse an IPv6 access control list.
*
* @param ret location where to write the ACL (set)
- * @param sctx service context to use to get the configuration
+ * @param sh service context to use to get the configuration
* @param option name of the ACL option to parse
* @return #GNUNET_SYSERR on parse error, #GNUNET_OK on success (including
* no ACL configured)
*/
static int
-process_acl6 (struct GNUNET_STRINGS_IPv6NetworkPolicy **ret, struct GNUNET_SERVICE_Context *sctx,
+process_acl6 (struct GNUNET_STRINGS_IPv6NetworkPolicy **ret,
+ struct GNUNET_SERVICE_Handle *sh,
const char *option)
{
char *opt;
- if (!GNUNET_CONFIGURATION_have_value (sctx->cfg, sctx->service_name, option))
+ if (! GNUNET_CONFIGURATION_have_value (sh->cfg,
+ sh->service_name,
+ option))
{
*ret = NULL;
return GNUNET_OK;
}
GNUNET_break (GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_string (sctx->cfg,
- sctx->service_name,
- option, &opt));
+ GNUNET_CONFIGURATION_get_value_string (sh->cfg,
+ sh->service_name,
+ option,
+ &opt));
if (NULL == (*ret = GNUNET_STRINGS_parse_ipv6_policy (opt)))
{
LOG (GNUNET_ERROR_TYPE_WARNING,
_("Could not parse IPv6 network specification `%s' for `%s:%s'\n"),
- opt, sctx->service_name, option);
+ opt,
+ sh->service_name,
+ option);
GNUNET_free (opt);
return GNUNET_SYSERR;
}
@@ -475,18 +1047,28 @@ process_acl6 (struct GNUNET_STRINGS_IPv6NetworkPolicy **ret, struct GNUNET_SERVI
* @param saddrs array to update
* @param saddrlens where to store the address length
* @param unixpath path to add
+ * @param abstract #GNUNET_YES to add an abstract UNIX domain socket. This
+ * parameter is ignore on systems other than LINUX
*/
static void
-add_unixpath (struct sockaddr **saddrs, socklen_t * saddrlens,
- const char *unixpath)
+add_unixpath (struct sockaddr **saddrs,
+ socklen_t *saddrlens,
+ const char *unixpath,
+ int abstract)
{
#ifdef AF_UNIX
struct sockaddr_un *un;
un = GNUNET_new (struct sockaddr_un);
un->sun_family = AF_UNIX;
- strncpy (un->sun_path, unixpath, sizeof (un->sun_path) - 1);
-#if HAVE_SOCKADDR_IN_SIN_LEN
+ strncpy (un->sun_path,
+ unixpath,
+ sizeof (un->sun_path) - 1);
+#ifdef LINUX
+ if (GNUNET_YES == abstract)
+ un->sun_path[0] = '\0';
+#endif
+#if HAVE_SOCKADDR_UN_SUN_LEN
un->sun_len = (u_char) sizeof (struct sockaddr_un);
#endif
*saddrs = (struct sockaddr *) un;
@@ -509,7 +1091,7 @@ add_unixpath (struct sockaddr **saddrs, socklen_t * saddrlens,
* addresses the server should bind to and listen on; the
* array will be NULL-terminated (on success)
* @param addr_lens set (call by reference) to an array of the lengths
- * of the respective 'struct sockaddr' struct in the 'addrs'
+ * of the respective `struct sockaddr` struct in the @a addrs
* array (on success)
* @return number of addresses found on success,
* #GNUNET_SYSERR if the configuration
@@ -519,11 +1101,11 @@ add_unixpath (struct sockaddr **saddrs, socklen_t * saddrlens,
* zero (in this case, `*addrs` and `*addr_lens` will be
* set to NULL).
*/
-int
-GNUNET_SERVICE_get_server_addresses (const char *service_name,
- const struct GNUNET_CONFIGURATION_Handle
- *cfg, struct sockaddr ***addrs,
- socklen_t ** addr_lens)
+static int
+get_server_addresses (const char *service_name,
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct sockaddr ***addrs,
+ socklen_t **addr_lens)
{
int disablev6;
struct GNUNET_NETWORK_Handle *desc;
@@ -536,6 +1118,7 @@ GNUNET_SERVICE_get_server_addresses (const char *service_name,
unsigned int i;
int resi;
int ret;
+ int abstract;
struct sockaddr **saddrs;
socklen_t *saddrlens;
char *hostname;
@@ -543,47 +1126,25 @@ GNUNET_SERVICE_get_server_addresses (const char *service_name,
*addrs = NULL;
*addr_lens = NULL;
desc = NULL;
- if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "DISABLEV6"))
- {
- if (GNUNET_SYSERR ==
- (disablev6 =
- GNUNET_CONFIGURATION_get_value_yesno (cfg, service_name, "DISABLEV6")))
- return GNUNET_SYSERR;
- }
- else
- disablev6 = GNUNET_NO;
-
- if (!disablev6)
- {
- /* probe IPv6 support */
- desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
- if (NULL == desc)
- {
- if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) ||
- (EACCES == errno))
- {
- LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket");
- return GNUNET_SYSERR;
- }
- LOG (GNUNET_ERROR_TYPE_INFO,
- _
- ("Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"),
- service_name, STRERROR (errno));
- disablev6 = GNUNET_YES;
- }
- else
- {
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
- desc = NULL;
- }
- }
+ disablev6 = GNUNET_NO;
+ if ( (GNUNET_NO ==
+ GNUNET_NETWORK_test_pf (PF_INET6)) ||
+ (GNUNET_YES ==
+ GNUNET_CONFIGURATION_get_value_yesno (cfg,
+ service_name,
+ "DISABLEV6") ) )
+ disablev6 = GNUNET_YES;
port = 0;
- if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT"))
+ if (GNUNET_CONFIGURATION_have_value (cfg,
+ service_name,
+ "PORT"))
{
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_number (cfg, service_name,
- "PORT", &port))
+ GNUNET_CONFIGURATION_get_value_number (cfg,
+ service_name,
+ "PORT",
+ &port))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_("Require valid port number for service `%s' in configuration!\n"),
@@ -598,22 +1159,31 @@ GNUNET_SERVICE_get_server_addresses (const char *service_name,
}
}
- if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "BINDTO"))
+ if (GNUNET_CONFIGURATION_have_value (cfg,
+ service_name,
+ "BINDTO"))
{
GNUNET_break (GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_string (cfg, service_name,
- "BINDTO", &hostname));
+ GNUNET_CONFIGURATION_get_value_string (cfg,
+ service_name,
+ "BINDTO",
+ &hostname));
}
else
hostname = NULL;
unixpath = NULL;
+ abstract = GNUNET_NO;
#ifdef AF_UNIX
if ((GNUNET_YES ==
- GNUNET_CONFIGURATION_have_value (cfg, service_name, "UNIXPATH")) &&
+ GNUNET_CONFIGURATION_have_value (cfg,
+ service_name,
+ "UNIXPATH")) &&
(GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_filename (cfg, service_name, "UNIXPATH",
- &unixpath)) &&
+ GNUNET_CONFIGURATION_get_value_filename (cfg,
+ service_name,
+ "UNIXPATH",
+ &unixpath)) &&
(0 < strlen (unixpath)))
{
/* probe UNIX support */
@@ -622,40 +1192,57 @@ GNUNET_SERVICE_get_server_addresses (const char *service_name,
if (strlen (unixpath) >= sizeof (s_un.sun_path))
{
LOG (GNUNET_ERROR_TYPE_WARNING,
- _("UNIXPATH `%s' too long, maximum length is %llu\n"), unixpath,
+ _("UNIXPATH `%s' too long, maximum length is %llu\n"),
+ unixpath,
(unsigned long long) sizeof (s_un.sun_path));
unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
LOG (GNUNET_ERROR_TYPE_INFO,
- _("Using `%s' instead\n"), unixpath);
+ _("Using `%s' instead\n"),
+ unixpath);
}
- if (GNUNET_OK !=
- GNUNET_DISK_directory_create_for_file (unixpath))
+#ifdef LINUX
+ abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg,
+ "TESTING",
+ "USE_ABSTRACT_SOCKETS");
+ if (GNUNET_SYSERR == abstract)
+ abstract = GNUNET_NO;
+#endif
+ if ( (GNUNET_YES != abstract) &&
+ (GNUNET_OK !=
+ GNUNET_DISK_directory_create_for_file (unixpath)) )
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
"mkdir",
unixpath);
}
if (NULL != unixpath)
{
- desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0);
+ desc = GNUNET_NETWORK_socket_create (AF_UNIX,
+ SOCK_STREAM,
+ 0);
if (NULL == desc)
{
- if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) ||
+ if ((ENOBUFS == errno) ||
+ (ENOMEM == errno) ||
+ (ENFILE == errno) ||
(EACCES == errno))
{
- LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket");
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "socket");
GNUNET_free_non_null (hostname);
GNUNET_free (unixpath);
return GNUNET_SYSERR;
}
LOG (GNUNET_ERROR_TYPE_INFO,
_("Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"),
- service_name, STRERROR (errno));
+ service_name,
+ STRERROR (errno));
GNUNET_free (unixpath);
unixpath = NULL;
}
else
{
- GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (desc));
desc = NULL;
}
}
@@ -671,9 +1258,14 @@ GNUNET_SERVICE_get_server_addresses (const char *service_name,
}
if (0 == port)
{
- saddrs = GNUNET_malloc (2 * sizeof (struct sockaddr *));
- saddrlens = GNUNET_malloc (2 * sizeof (socklen_t));
- add_unixpath (saddrs, saddrlens, unixpath);
+ saddrs = GNUNET_new_array (2,
+ struct sockaddr *);
+ saddrlens = GNUNET_new_array (2,
+ socklen_t);
+ add_unixpath (saddrs,
+ saddrlens,
+ unixpath,
+ abstract);
GNUNET_free_non_null (unixpath);
GNUNET_free_non_null (hostname);
*addrs = saddrs;
@@ -684,16 +1276,24 @@ GNUNET_SERVICE_get_server_addresses (const char *service_name,
if (NULL != hostname)
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Resolving `%s' since that is where `%s' will bind to.\n", hostname,
+ "Resolving `%s' since that is where `%s' will bind to.\n",
+ hostname,
service_name);
- memset (&hints, 0, sizeof (struct addrinfo));
+ memset (&hints,
+ 0,
+ sizeof (struct addrinfo));
if (disablev6)
hints.ai_family = AF_INET;
hints.ai_protocol = IPPROTO_TCP;
- if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) ||
- (res == NULL))
+ if ((0 != (ret = getaddrinfo (hostname,
+ NULL,
+ &hints,
+ &res))) ||
+ (NULL == res))
{
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to resolve `%s': %s\n"), hostname,
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Failed to resolve `%s': %s\n"),
+ hostname,
gai_strerror (ret));
GNUNET_free (hostname);
GNUNET_free_non_null (unixpath);
@@ -704,14 +1304,17 @@ GNUNET_SERVICE_get_server_addresses (const char *service_name,
while (NULL != (pos = next))
{
next = pos->ai_next;
- if ((disablev6) && (pos->ai_family == AF_INET6))
+ if ( (disablev6) &&
+ (pos->ai_family == AF_INET6) )
continue;
i++;
}
if (0 == i)
{
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to find %saddress for `%s'.\n"),
- disablev6 ? "IPv4 " : "", hostname);
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Failed to find %saddress for `%s'.\n"),
+ disablev6 ? "IPv4 " : "",
+ hostname);
freeaddrinfo (res);
GNUNET_free (hostname);
GNUNET_free_non_null (unixpath);
@@ -720,32 +1323,45 @@ GNUNET_SERVICE_get_server_addresses (const char *service_name,
resi = i;
if (NULL != unixpath)
resi++;
- saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *));
- saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t));
+ saddrs = GNUNET_new_array (resi + 1,
+ struct sockaddr *);
+ saddrlens = GNUNET_new_array (resi + 1,
+ socklen_t);
i = 0;
if (NULL != unixpath)
{
- add_unixpath (saddrs, saddrlens, unixpath);
+ add_unixpath (saddrs,
+ saddrlens,
+ unixpath,
+ abstract);
i++;
}
next = res;
while (NULL != (pos = next))
{
next = pos->ai_next;
- if ((disablev6) && (AF_INET6 == pos->ai_family))
+ if ( (disablev6) &&
+ (AF_INET6 == pos->ai_family) )
continue;
- if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol))
+ if ( (IPPROTO_TCP != pos->ai_protocol) &&
+ (0 != pos->ai_protocol) )
continue; /* not TCP */
- if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype))
+ if ( (SOCK_STREAM != pos->ai_socktype) &&
+ (0 != pos->ai_socktype) )
continue; /* huh? */
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Service `%s' will bind to `%s'\n",
- service_name, GNUNET_a2s (pos->ai_addr, pos->ai_addrlen));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Service `%s' will bind to `%s'\n",
+ service_name,
+ GNUNET_a2s (pos->ai_addr,
+ pos->ai_addrlen));
if (AF_INET == pos->ai_family)
{
GNUNET_assert (sizeof (struct sockaddr_in) == pos->ai_addrlen);
saddrlens[i] = pos->ai_addrlen;
saddrs[i] = GNUNET_malloc (saddrlens[i]);
- memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
+ GNUNET_memcpy (saddrs[i],
+ pos->ai_addr,
+ saddrlens[i]);
((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
}
else
@@ -754,7 +1370,9 @@ GNUNET_SERVICE_get_server_addresses (const char *service_name,
GNUNET_assert (sizeof (struct sockaddr_in6) == pos->ai_addrlen);
saddrlens[i] = pos->ai_addrlen;
saddrs[i] = GNUNET_malloc (saddrlens[i]);
- memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
+ GNUNET_memcpy (saddrs[i],
+ pos->ai_addr,
+ saddrlens[i]);
((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
}
i++;
@@ -773,11 +1391,16 @@ GNUNET_SERVICE_get_server_addresses (const char *service_name,
if (NULL != unixpath)
resi++;
i = 0;
- saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *));
- saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t));
+ saddrs = GNUNET_new_array (resi + 1,
+ struct sockaddr *);
+ saddrlens = GNUNET_new_array (resi + 1,
+ socklen_t);
if (NULL != unixpath)
{
- add_unixpath (saddrs, saddrlens, unixpath);
+ add_unixpath (saddrs,
+ saddrlens,
+ unixpath,
+ abstract);
i++;
}
saddrlens[i] = sizeof (struct sockaddr_in);
@@ -794,12 +1417,17 @@ GNUNET_SERVICE_get_server_addresses (const char *service_name,
resi = 2;
if (NULL != unixpath)
resi++;
- saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *));
- saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t));
+ saddrs = GNUNET_new_array (resi + 1,
+ struct sockaddr *);
+ saddrlens = GNUNET_new_array (resi + 1,
+ socklen_t);
i = 0;
if (NULL != unixpath)
{
- add_unixpath (saddrs, saddrlens, unixpath);
+ add_unixpath (saddrs,
+ saddrlens,
+ unixpath,
+ abstract);
i++;
}
saddrlens[i] = sizeof (struct sockaddr_in6);
@@ -830,13 +1458,14 @@ GNUNET_SERVICE_get_server_addresses (const char *service_name,
/**
* Read listen sockets from the parent process (ARM).
*
- * @param sctx service context to initialize
- * @return #GNUNET_YES if ok, #GNUNET_NO if not ok (must bind yourself),
- * and #GNUNET_SYSERR on error.
+ * @param sh service context to initialize
+ * @return NULL-terminated array of sockets on success,
+ * NULL if not ok (must bind yourself)
*/
-static int
-receive_sockets_from_parent (struct GNUNET_SERVICE_Context *sctx)
+static struct GNUNET_NETWORK_Handle **
+receive_sockets_from_parent (struct GNUNET_SERVICE_Handle *sh)
{
+ static struct GNUNET_NETWORK_Handle **lsocks;
const char *env_buf;
int fail;
uint64_t count;
@@ -844,15 +1473,19 @@ receive_sockets_from_parent (struct GNUNET_SERVICE_Context *sctx)
HANDLE lsocks_pipe;
env_buf = getenv ("GNUNET_OS_READ_LSOCKS");
- if ((NULL == env_buf) || (strlen (env_buf) <= 0))
- return GNUNET_NO;
+ if ( (NULL == env_buf) ||
+ (strlen (env_buf) <= 0) )
+ return NULL;
/* Using W32 API directly here, because this pipe will
* never be used outside of this function, and it's just too much of a bother
* to create a GNUnet API that boxes a HANDLE (the way it is done with socks)
*/
- lsocks_pipe = (HANDLE) strtoul (env_buf, NULL, 10);
- if ( (0 == lsocks_pipe) || (INVALID_HANDLE_VALUE == lsocks_pipe))
- return GNUNET_NO;
+ lsocks_pipe = (HANDLE) strtoul (env_buf,
+ NULL,
+ 10);
+ if ( (0 == lsocks_pipe) ||
+ (INVALID_HANDLE_VALUE == lsocks_pipe))
+ return NULL;
fail = 1;
do
{
@@ -860,11 +1493,17 @@ receive_sockets_from_parent (struct GNUNET_SERVICE_Context *sctx)
int fail2;
DWORD rd;
- ret = ReadFile (lsocks_pipe, &count, sizeof (count), &rd, NULL);
- if ((0 == ret) || (sizeof (count) != rd) || (0 == count))
+ ret = ReadFile (lsocks_pipe,
+ &count,
+ sizeof (count),
+ &rd,
+ NULL);
+ if ( (0 == ret) ||
+ (sizeof (count) != rd) ||
+ (0 == count) )
break;
- sctx->lsocks =
- GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle *) * (count + 1));
+ lsocks = GNUNET_new_array (count + 1,
+ struct GNUNET_NETWORK_Handle *);
fail2 = 1;
for (i = 0; i < count; i++)
@@ -873,51 +1512,165 @@ receive_sockets_from_parent (struct GNUNET_SERVICE_Context *sctx)
uint64_t size;
SOCKET s;
- ret = ReadFile (lsocks_pipe, &size, sizeof (size), &rd, NULL);
- if ( (0 == ret) || (sizeof (size) != rd) || (sizeof (pi) != size) )
+ ret = ReadFile (lsocks_pipe,
+ &size,
+ sizeof (size),
+ &rd,
+ NULL);
+ if ( (0 == ret) ||
+ (sizeof (size) != rd) ||
+ (sizeof (pi) != size) )
break;
- ret = ReadFile (lsocks_pipe, &pi, sizeof (pi), &rd, NULL);
- if ( (0 == ret) || (sizeof (pi) != rd))
+ ret = ReadFile (lsocks_pipe,
+ &pi,
+ sizeof (pi),
+ &rd,
+ NULL);
+ if ( (0 == ret) ||
+ (sizeof (pi) != rd))
break;
- s = WSASocketA (pi.iAddressFamily, pi.iSocketType, pi.iProtocol, &pi, 0, WSA_FLAG_OVERLAPPED);
- sctx->lsocks[i] = GNUNET_NETWORK_socket_box_native (s);
- if (NULL == sctx->lsocks[i])
+ s = WSASocketA (pi.iAddressFamily,
+ pi.iSocketType,
+ pi.iProtocol,
+ &pi,
+ 0,
+ WSA_FLAG_OVERLAPPED);
+ lsocks[i] = GNUNET_NETWORK_socket_box_native (s);
+ if (NULL == lsocks[i])
break;
else if (i == count - 1)
fail2 = 0;
}
if (fail2)
break;
- sctx->lsocks[count] = NULL;
+ lsocks[count] = NULL;
fail = 0;
}
while (fail);
-
CloseHandle (lsocks_pipe);
if (fail)
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_("Could not access a pre-bound socket, will try to bind myself\n"));
- for (i = 0; (i < count) && (NULL != sctx->lsocks[i]); i++)
- GNUNET_break (0 == GNUNET_NETWORK_socket_close (sctx->lsocks[i]));
- GNUNET_free_non_null (sctx->lsocks);
- sctx->lsocks = NULL;
- return GNUNET_NO;
+ for (i = 0; (i < count) && (NULL != lsocks[i]); i++)
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (lsocks[i]));
+ GNUNET_free (lsocks);
+ return NULL;
}
- return GNUNET_YES;
+ return lsocks;
}
#endif
/**
- * Setup addr, addrlen, idle_timeout
- * based on configuration!
+ * Create and initialize a listen socket for the server.
+ *
+ * @param server_addr address to listen on
+ * @param socklen length of @a server_addr
+ * @return NULL on error, otherwise the listen socket
+ */
+static struct GNUNET_NETWORK_Handle *
+open_listen_socket (const struct sockaddr *server_addr,
+ socklen_t socklen)
+{
+ struct GNUNET_NETWORK_Handle *sock;
+ uint16_t port;
+ int eno;
+
+ switch (server_addr->sa_family)
+ {
+ case AF_INET:
+ port = ntohs (((const struct sockaddr_in *) server_addr)->sin_port);
+ break;
+ case AF_INET6:
+ port = ntohs (((const struct sockaddr_in6 *) server_addr)->sin6_port);
+ break;
+ case AF_UNIX:
+ port = 0;
+ break;
+ default:
+ GNUNET_break (0);
+ port = 0;
+ break;
+ }
+ sock = GNUNET_NETWORK_socket_create (server_addr->sa_family,
+ SOCK_STREAM,
+ 0);
+ if (NULL == sock)
+ {
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "socket");
+ errno = 0;
+ return NULL;
+ }
+ /* bind the socket */
+ if (GNUNET_OK != GNUNET_NETWORK_socket_bind (sock,
+ server_addr,
+ socklen))
+ {
+ eno = errno;
+ if (EADDRINUSE != errno)
+ {
+ /* we don't log 'EADDRINUSE' here since an IPv4 bind may
+ * fail if we already took the port on IPv6; if both IPv4 and
+ * IPv6 binds fail, then our caller will log using the
+ * errno preserved in 'eno' */
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "bind");
+ if (0 != port)
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("`%s' failed for port %d (%s).\n"),
+ "bind",
+ port,
+ (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
+ eno = 0;
+ }
+ else
+ {
+ if (0 != port)
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ _("`%s' failed for port %d (%s): address already in use\n"),
+ "bind", port,
+ (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
+ else if (AF_UNIX == server_addr->sa_family)
+ {
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ _("`%s' failed for `%s': address already in use\n"),
+ "bind",
+ GNUNET_a2s (server_addr, socklen));
+ }
+ }
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (sock));
+ errno = eno;
+ return NULL;
+ }
+ if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock,
+ 5))
+ {
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "listen");
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (sock));
+ errno = 0;
+ return NULL;
+ }
+ if (0 != port)
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Server starts to listen on port %u.\n",
+ port);
+ return sock;
+}
+
+
+/**
+ * Setup service handle
*
* Configuration may specify:
* - PORT (where to bind to for TCP)
* - UNIXPATH (where to bind to for UNIX domain sockets)
- * - TIMEOUT (after how many ms does an inactive service timeout);
* - DISABLEV6 (disable support for IPv6, otherwise we use dual-stack)
* - BINDTO (hostname or IP address to bind to, otherwise we take everything)
* - ACCEPT_FROM (only allow connections from specified IPv4 subnets)
@@ -925,108 +1678,171 @@ receive_sockets_from_parent (struct GNUNET_SERVICE_Context *sctx)
* - REJECT_FROM (disallow allow connections from specified IPv4 subnets)
* - REJECT_FROM6 (disallow allow connections from specified IPv6 subnets)
*
- * @param sctx service context to initialize
+ * @param sh service context to initialize
* @return #GNUNET_OK if configuration succeeded
*/
static int
-setup_service (struct GNUNET_SERVICE_Context *sctx)
+setup_service (struct GNUNET_SERVICE_Handle *sh)
{
- struct GNUNET_TIME_Relative idleout;
int tolerant;
-
+ struct GNUNET_NETWORK_Handle **lsocks;
#ifndef MINGW
const char *nfds;
unsigned int cnt;
int flags;
+ char dummy[2];
#endif
- if (GNUNET_CONFIGURATION_have_value (sctx->cfg, sctx->service_name, "TIMEOUT"))
- {
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_time (sctx->cfg, sctx->service_name,
- "TIMEOUT", &idleout))
- {
- LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Specified value for `%s' of service `%s' is invalid\n"),
- "TIMEOUT", sctx->service_name);
- return GNUNET_SYSERR;
- }
- sctx->timeout = idleout;
- }
- else
- sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
-
if (GNUNET_CONFIGURATION_have_value
- (sctx->cfg, sctx->service_name, "TOLERANT"))
+ (sh->cfg,
+ sh->service_name,
+ "TOLERANT"))
{
if (GNUNET_SYSERR ==
(tolerant =
- GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, sctx->service_name,
+ GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
+ sh->service_name,
"TOLERANT")))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_("Specified value for `%s' of service `%s' is invalid\n"),
- "TOLERANT", sctx->service_name);
+ "TOLERANT",
+ sh->service_name);
return GNUNET_SYSERR;
}
}
else
tolerant = GNUNET_NO;
+ lsocks = NULL;
#ifndef MINGW
errno = 0;
- if ((NULL != (nfds = getenv ("LISTEN_FDS"))) &&
- (1 == SSCANF (nfds, "%u", &cnt)) && (cnt > 0) && (cnt < FD_SETSIZE) &&
- (cnt + 4 < FD_SETSIZE))
+ if ( (NULL != (nfds = getenv ("LISTEN_FDS"))) &&
+ (1 == SSCANF (nfds,
+ "%u%1s",
+ &cnt,
+ dummy)) &&
+ (cnt > 0) &&
+ (cnt < FD_SETSIZE) &&
+ (cnt + 4 < FD_SETSIZE) )
{
- sctx->lsocks =
- GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle *) * (cnt + 1));
+ lsocks = GNUNET_new_array (cnt + 1,
+ struct GNUNET_NETWORK_Handle *);
while (0 < cnt--)
{
- flags = fcntl (3 + cnt, F_GETFD);
- if ((flags < 0) || (0 != (flags & FD_CLOEXEC)) ||
- (NULL ==
- (sctx->lsocks[cnt] = GNUNET_NETWORK_socket_box_native (3 + cnt))))
+ flags = fcntl (3 + cnt,
+ F_GETFD);
+ if ( (flags < 0) ||
+ (0 != (flags & FD_CLOEXEC)) ||
+ (NULL ==
+ (lsocks[cnt] = GNUNET_NETWORK_socket_box_native (3 + cnt))))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
- _
- ("Could not access pre-bound socket %u, will try to bind myself\n"),
+ _("Could not access pre-bound socket %u, will try to bind myself\n"),
(unsigned int) 3 + cnt);
cnt++;
- while (sctx->lsocks[cnt] != NULL)
- GNUNET_break (0 == GNUNET_NETWORK_socket_close (sctx->lsocks[cnt++]));
- GNUNET_free (sctx->lsocks);
- sctx->lsocks = NULL;
+ while (NULL != lsocks[cnt])
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (lsocks[cnt++]));
+ GNUNET_free (lsocks);
+ lsocks = NULL;
break;
}
}
unsetenv ("LISTEN_FDS");
}
#else
- if (getenv ("GNUNET_OS_READ_LSOCKS") != NULL)
+ if (NULL != getenv ("GNUNET_OS_READ_LSOCKS"))
{
- receive_sockets_from_parent (sctx);
+ lsocks = receive_sockets_from_parent (sh);
putenv ("GNUNET_OS_READ_LSOCKS=");
}
#endif
- if ((NULL == sctx->lsocks) &&
- (GNUNET_SYSERR ==
- GNUNET_SERVICE_get_server_addresses (sctx->service_name, sctx->cfg,
- &sctx->addrs, &sctx->addrlens)))
- return GNUNET_SYSERR;
- sctx->require_found = tolerant ? GNUNET_NO : GNUNET_YES;
- sctx->match_uid =
- GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, sctx->service_name,
+ if (NULL != lsocks)
+ {
+ /* listen only on inherited sockets if we have any */
+ struct GNUNET_NETWORK_Handle **ls;
+
+ for (ls = lsocks; NULL != *ls; ls++)
+ {
+ struct ServiceListenContext *slc;
+
+ slc = GNUNET_new (struct ServiceListenContext);
+ slc->sh = sh;
+ slc->listen_socket = *ls;
+ GNUNET_CONTAINER_DLL_insert (sh->slc_head,
+ sh->slc_tail,
+ slc);
+ }
+ GNUNET_free (lsocks);
+ }
+ else
+ {
+ struct sockaddr **addrs;
+ socklen_t *addrlens;
+ int num;
+
+ num = get_server_addresses (sh->service_name,
+ sh->cfg,
+ &addrs,
+ &addrlens);
+ if (GNUNET_SYSERR == num)
+ return GNUNET_SYSERR;
+
+ for (int i = 0; i < num; i++)
+ {
+ struct ServiceListenContext *slc;
+
+ slc = GNUNET_new (struct ServiceListenContext);
+ slc->sh = sh;
+ slc->listen_socket = open_listen_socket (addrs[i],
+ addrlens[i]);
+ GNUNET_free (addrs[i]);
+ if (NULL == slc->listen_socket)
+ {
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+ "bind");
+ GNUNET_free (slc);
+ continue;
+ }
+ GNUNET_CONTAINER_DLL_insert (sh->slc_head,
+ sh->slc_tail,
+ slc);
+ }
+ GNUNET_free_non_null (addrlens);
+ GNUNET_free_non_null (addrs);
+ if ( (0 != num) &&
+ (NULL == sh->slc_head) )
+ {
+ /* All attempts to bind failed, hard failure */
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _("Could not bind to any of the ports I was supposed to, refusing to run!\n"));
+ return GNUNET_SYSERR;
+ }
+ }
+
+ sh->require_found = tolerant ? GNUNET_NO : GNUNET_YES;
+ sh->match_uid
+ = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
+ sh->service_name,
"UNIX_MATCH_UID");
- sctx->match_gid =
- GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, sctx->service_name,
+ sh->match_gid
+ = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
+ sh->service_name,
"UNIX_MATCH_GID");
- process_acl4 (&sctx->v4_denied, sctx, "REJECT_FROM");
- process_acl4 (&sctx->v4_allowed, sctx, "ACCEPT_FROM");
- process_acl6 (&sctx->v6_denied, sctx, "REJECT_FROM6");
- process_acl6 (&sctx->v6_allowed, sctx, "ACCEPT_FROM6");
-
+ process_acl4 (&sh->v4_denied,
+ sh,
+ "REJECT_FROM");
+ process_acl4 (&sh->v4_allowed,
+ sh,
+ "ACCEPT_FROM");
+ process_acl6 (&sh->v6_denied,
+ sh,
+ "REJECT_FROM6");
+ process_acl6 (&sh->v6_allowed,
+ sh,
+ "ACCEPT_FROM6");
return GNUNET_OK;
}
@@ -1035,189 +1851,129 @@ setup_service (struct GNUNET_SERVICE_Context *sctx)
* Get the name of the user that'll be used
* to provide the service.
*
- * @param sctx service context
+ * @param sh service context
* @return value of the 'USERNAME' option
*/
static char *
-get_user_name (struct GNUNET_SERVICE_Context *sctx)
+get_user_name (struct GNUNET_SERVICE_Handle *sh)
{
char *un;
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (sctx->cfg, sctx->service_name,
- "USERNAME", &un))
+ GNUNET_CONFIGURATION_get_value_filename (sh->cfg,
+ sh->service_name,
+ "USERNAME",
+ &un))
return NULL;
return un;
}
/**
- * Write PID file.
+ * Set user ID.
*
- * @param sctx service context
- * @param pid PID to write (should be equal to 'getpid()'
- * @return #GNUNET_OK on success (including no work to be done)
+ * @param sh service context
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
*/
static int
-write_pid_file (struct GNUNET_SERVICE_Context *sctx, pid_t pid)
+set_user_id (struct GNUNET_SERVICE_Handle *sh)
{
- FILE *pidfd;
- char *pif;
char *user;
- char *rdir;
- int len;
-
- if (NULL == (pif = get_pid_file_name (sctx)))
- return GNUNET_OK; /* no file desired */
- user = get_user_name (sctx);
- rdir = GNUNET_strdup (pif);
- len = strlen (rdir);
- while ((len > 0) && (rdir[len] != DIR_SEPARATOR))
- len--;
- rdir[len] = '\0';
- if (0 != ACCESS (rdir, F_OK))
- {
- /* we get to create a directory -- and claim it
- * as ours! */
- (void) GNUNET_DISK_directory_create (rdir);
- if ((NULL != user) && (0 < strlen (user)))
- GNUNET_DISK_file_change_owner (rdir, user);
- }
- if (0 != ACCESS (rdir, W_OK | X_OK))
+
+ if (NULL == (user = get_user_name (sh)))
+ return GNUNET_OK; /* keep */
+#ifndef MINGW
+ struct passwd *pws;
+
+ errno = 0;
+ pws = getpwnam (user);
+ if (NULL == pws)
{
- LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "access", rdir);
- GNUNET_free (rdir);
- GNUNET_free_non_null (user);
- GNUNET_free (pif);
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Cannot obtain information about user `%s': %s\n"),
+ user,
+ errno == 0 ? _("No such user") : STRERROR (errno));
+ GNUNET_free (user);
return GNUNET_SYSERR;
}
- GNUNET_free (rdir);
- pidfd = FOPEN (pif, "w");
- if (NULL == pidfd)
+ if ( (0 != setgid (pws->pw_gid)) ||
+ (0 != setegid (pws->pw_gid)) ||
+#if HAVE_INITGROUPS
+ (0 != initgroups (user,
+ pws->pw_gid)) ||
+#endif
+ (0 != setuid (pws->pw_uid)) ||
+ (0 != seteuid (pws->pw_uid)))
{
- LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "fopen", pif);
- GNUNET_free (pif);
- GNUNET_free_non_null (user);
- return GNUNET_SYSERR;
+ if ((0 != setregid (pws->pw_gid,
+ pws->pw_gid)) ||
+ (0 != setreuid (pws->pw_uid,
+ pws->pw_uid)))
+ {
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Cannot change user/group to `%s': %s\n"),
+ user,
+ STRERROR (errno));
+ GNUNET_free (user);
+ return GNUNET_SYSERR;
+ }
}
- if (0 > FPRINTF (pidfd, "%u", pid))
- LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fprintf", pif);
- GNUNET_break (0 == FCLOSE (pidfd));
- if ((NULL != user) && (0 < strlen (user)))
- GNUNET_DISK_file_change_owner (pif, user);
- GNUNET_free_non_null (user);
- GNUNET_free (pif);
+#endif
+ GNUNET_free (user);
return GNUNET_OK;
}
/**
- * Task run during shutdown. Stops the server/service.
+ * Get the name of the file where we will
+ * write the PID of the service.
*
- * @param cls the `struct GNUNET_SERVICE_Context`
- * @param tc unused
+ * @param sh service context
+ * @return name of the file for the process ID
*/
-static void
-shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+static char *
+get_pid_file_name (struct GNUNET_SERVICE_Handle *sh)
{
- struct GNUNET_SERVICE_Context *service = cls;
- struct GNUNET_SERVER_Handle *server = service->server;
+ char *pif;
- service->shutdown_task = GNUNET_SCHEDULER_NO_TASK;
- if (0 != (service->options & GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN))
- GNUNET_SERVER_stop_listening (server);
- else
- GNUNET_SERVER_destroy (server);
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_filename (sh->cfg,
+ sh->service_name,
+ "PIDFILE",
+ &pif))
+ return NULL;
+ return pif;
}
/**
- * Initial task for the service.
+ * Delete the PID file that was created by our parent.
*
- * @param cls service context
- * @param tc unused
+ * @param sh service context
*/
static void
-service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+pid_file_delete (struct GNUNET_SERVICE_Handle *sh)
{
- struct GNUNET_SERVICE_Context *sctx = cls;
- unsigned int i;
-
- if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
- return;
- (void) GNUNET_SPEEDUP_start_ (sctx->cfg);
- GNUNET_RESOLVER_connect (sctx->cfg);
- if (NULL != sctx->lsocks)
- sctx->server
- = GNUNET_SERVER_create_with_sockets (&check_access, sctx, sctx->lsocks,
- sctx->timeout, sctx->require_found);
- else
- sctx->server
- = GNUNET_SERVER_create (&check_access, sctx, sctx->addrs, sctx->addrlens,
- sctx->timeout, sctx->require_found);
- if (NULL == sctx->server)
- {
- if (NULL != sctx->addrs)
- for (i = 0; NULL != sctx->addrs[i]; i++)
- LOG (GNUNET_ERROR_TYPE_INFO,
- _("Failed to start `%s' at `%s'\n"),
- sctx->service_name, GNUNET_a2s (sctx->addrs[i], sctx->addrlens[i]));
- sctx->ret = GNUNET_SYSERR;
- return;
- }
-#ifndef WINDOWS
- if (NULL != sctx->addrs)
- for (i = 0; NULL != sctx->addrs[i]; i++)
- if (AF_UNIX == sctx->addrs[i]->sa_family)
- GNUNET_DISK_fix_permissions (((const struct sockaddr_un *)sctx->addrs[i])->sun_path,
- sctx->match_uid,
- sctx->match_gid);
-#endif
+ char *pif = get_pid_file_name (sh);
-
- if (0 == (sctx->options & GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN))
- {
- /* install a task that will kill the server
- * process if the scheduler ever gets a shutdown signal */
- sctx->shutdown_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
- &shutdown_task,
- sctx);
- }
- sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
- memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers));
- i = 0;
- while (NULL != sctx->my_handlers[i].callback)
- sctx->my_handlers[i++].callback_cls = sctx;
- GNUNET_SERVER_add_handlers (sctx->server, sctx->my_handlers);
- if (-1 != sctx->ready_confirm_fd)
- {
- GNUNET_break (1 == WRITE (sctx->ready_confirm_fd, ".", 1));
- GNUNET_break (0 == CLOSE (sctx->ready_confirm_fd));
- sctx->ready_confirm_fd = -1;
- write_pid_file (sctx, getpid ());
- }
- if (NULL != sctx->addrs)
- {
- i = 0;
- while (NULL != sctx->addrs[i])
- {
- LOG (GNUNET_ERROR_TYPE_INFO, _("Service `%s' runs at %s\n"),
- sctx->service_name, GNUNET_a2s (sctx->addrs[i], sctx->addrlens[i]));
- i++;
- }
- }
- sctx->task (sctx->task_cls, sctx->server, sctx->cfg);
+ if (NULL == pif)
+ return; /* no PID file */
+ if (0 != UNLINK (pif))
+ LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
+ "unlink",
+ pif);
+ GNUNET_free (pif);
}
/**
* Detach from terminal.
*
- * @param sctx service context
+ * @param sh service context
* @return #GNUNET_OK on success, #GNUNET_SYSERR on error
*/
static int
-detach_terminal (struct GNUNET_SERVICE_Context *sctx)
+detach_terminal (struct GNUNET_SERVICE_Handle *sh)
{
#ifndef MINGW
pid_t pid;
@@ -1226,13 +1982,15 @@ detach_terminal (struct GNUNET_SERVICE_Context *sctx)
if (0 != PIPE (filedes))
{
- LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "pipe");
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "pipe");
return GNUNET_SYSERR;
}
pid = fork ();
if (pid < 0)
{
- LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fork");
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "fork");
return GNUNET_SYSERR;
}
if (0 != pid)
@@ -1242,15 +2000,19 @@ detach_terminal (struct GNUNET_SERVICE_Context *sctx)
GNUNET_break (0 == CLOSE (filedes[1]));
c = 'X';
- if (1 != READ (filedes[0], &c, sizeof (char)))
- LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "read");
+ if (1 != READ (filedes[0],
+ &c,
+ sizeof (char)))
+ LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
+ "read");
fflush (stdout);
switch (c)
{
case '.':
exit (0);
case 'I':
- LOG (GNUNET_ERROR_TYPE_INFO, _("Service process failed to initialize\n"));
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ _("Service process failed to initialize\n"));
break;
case 'S':
LOG (GNUNET_ERROR_TYPE_INFO,
@@ -1266,13 +2028,16 @@ detach_terminal (struct GNUNET_SERVICE_Context *sctx)
GNUNET_break (0 == CLOSE (0));
GNUNET_break (0 == CLOSE (1));
GNUNET_break (0 == CLOSE (filedes[0]));
- nullfd = OPEN ("/dev/null", O_RDWR | O_APPEND);
+ nullfd = OPEN ("/dev/null",
+ O_RDWR | O_APPEND);
if (nullfd < 0)
return GNUNET_SYSERR;
/* set stdin/stdout to /dev/null */
- if ((dup2 (nullfd, 0) < 0) || (dup2 (nullfd, 1) < 0))
+ if ( (dup2 (nullfd, 0) < 0) ||
+ (dup2 (nullfd, 1) < 0) )
{
- LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "dup2");
(void) CLOSE (nullfd);
return GNUNET_SYSERR;
}
@@ -1280,8 +2045,9 @@ detach_terminal (struct GNUNET_SERVICE_Context *sctx)
/* Detach from controlling terminal */
pid = setsid ();
if (-1 == pid)
- LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "setsid");
- sctx->ready_confirm_fd = filedes[1];
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+ "setsid");
+ sh->ready_confirm_fd = filedes[1];
#else
/* FIXME: we probably need to do something else
* elsewhere in order to fork the process itself... */
@@ -1292,144 +2058,262 @@ detach_terminal (struct GNUNET_SERVICE_Context *sctx)
/**
- * Set user ID.
+ * Tear down the service, closing the listen sockets and
+ * freeing the ACLs.
*
- * @param sctx service context
- * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
+ * @param sh handle to the service to tear down.
*/
-static int
-set_user_id (struct GNUNET_SERVICE_Context *sctx)
+static void
+teardown_service (struct GNUNET_SERVICE_Handle *sh)
{
- char *user;
-
- if (NULL == (user = get_user_name (sctx)))
- return GNUNET_OK; /* keep */
-#ifndef MINGW
- struct passwd *pws;
+ struct ServiceListenContext *slc;
- errno = 0;
- pws = getpwnam (user);
- if (NULL == pws)
- {
- LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Cannot obtain information about user `%s': %s\n"), user,
- errno == 0 ? _("No such user") : STRERROR (errno));
- GNUNET_free (user);
- return GNUNET_SYSERR;
- }
- if ((0 != setgid (pws->pw_gid)) || (0 != setegid (pws->pw_gid)) ||
-#if HAVE_INITGROUPS
- (0 != initgroups (user, pws->pw_gid)) ||
-#endif
- (0 != setuid (pws->pw_uid)) || (0 != seteuid (pws->pw_uid)))
+ GNUNET_free_non_null (sh->v4_denied);
+ GNUNET_free_non_null (sh->v6_denied);
+ GNUNET_free_non_null (sh->v4_allowed);
+ GNUNET_free_non_null (sh->v6_allowed);
+ while (NULL != (slc = sh->slc_head))
{
- if ((0 != setregid (pws->pw_gid, pws->pw_gid)) ||
- (0 != setreuid (pws->pw_uid, pws->pw_uid)))
- {
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Cannot change user/group to `%s': %s\n"),
- user, STRERROR (errno));
- GNUNET_free (user);
- return GNUNET_SYSERR;
- }
+ GNUNET_CONTAINER_DLL_remove (sh->slc_head,
+ sh->slc_tail,
+ slc);
+ if (NULL != slc->listen_task)
+ GNUNET_SCHEDULER_cancel (slc->listen_task);
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (slc->listen_socket));
+ GNUNET_free (slc);
}
-#endif
- GNUNET_free (user);
- return GNUNET_OK;
}
/**
- * Delete the PID file that was created by our parent.
+ * Function to return link to AGPL source upon request.
*
- * @param sctx service context
+ * @param cls closure with the identification of the client
+ * @param msg AGPL request
*/
static void
-pid_file_delete (struct GNUNET_SERVICE_Context *sctx)
+return_agpl (void *cls,
+ const struct GNUNET_MessageHeader *msg)
{
- char *pif = get_pid_file_name (sctx);
+ struct GNUNET_SERVICE_Client *client = cls;
+ struct GNUNET_MQ_Handle *mq;
+ struct GNUNET_MQ_Envelope *env;
+ struct GNUNET_MessageHeader *res;
+ size_t slen;
+
+ (void) msg;
+ slen = strlen (GNUNET_AGPL_URL) + 1;
+ env = GNUNET_MQ_msg_extra (res,
+ GNUNET_MESSAGE_TYPE_RESPONSE_AGPL,
+ slen);
+ memcpy (&res[1],
+ GNUNET_AGPL_URL,
+ slen);
+ mq = GNUNET_SERVICE_client_get_mq (client);
+ GNUNET_MQ_send (mq,
+ env);
+ GNUNET_SERVICE_client_continue (client);
+}
- if (NULL == pif)
- return; /* no PID file */
- if (0 != UNLINK (pif))
- LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "unlink", pif);
- GNUNET_free (pif);
+
+/**
+ * Low-level function to start a service if the scheduler
+ * is already running. Should only be used directly in
+ * special cases.
+ *
+ * The function will launch the service with the name @a service_name
+ * using the @a service_options to configure its shutdown
+ * behavior. When clients connect or disconnect, the respective
+ * @a connect_cb or @a disconnect_cb functions will be called. For
+ * messages received from the clients, the respective @a handlers will
+ * be invoked; for the closure of the handlers we use the return value
+ * from the @a connect_cb invocation of the respective client.
+ *
+ * Each handler MUST call #GNUNET_SERVICE_client_continue() after each
+ * message to receive further messages from this client. If
+ * #GNUNET_SERVICE_client_continue() is not called within a short
+ * time, a warning will be logged. If delays are expected, services
+ * should call #GNUNET_SERVICE_client_disable_continue_warning() to
+ * disable the warning.
+ *
+ * Clients sending invalid messages (based on @a handlers) will be
+ * dropped. Additionally, clients can be dropped at any time using
+ * #GNUNET_SERVICE_client_drop().
+ *
+ * The service must be stopped using #GNUNET_SERVICE_stop().
+ *
+ * @param service_name name of the service to run
+ * @param cfg configuration to use
+ * @param connect_cb function to call whenever a client connects
+ * @param disconnect_cb function to call whenever a client disconnects
+ * @param cls closure argument for @a connect_cb and @a disconnect_cb
+ * @param handlers NULL-terminated array of message handlers for the service,
+ * the closure will be set to the value returned by
+ * the @a connect_cb for the respective connection
+ * @return NULL on error
+ */
+struct GNUNET_SERVICE_Handle *
+GNUNET_SERVICE_start (const char *service_name,
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
+ GNUNET_SERVICE_ConnectHandler connect_cb,
+ GNUNET_SERVICE_DisconnectHandler disconnect_cb,
+ void *cls,
+ const struct GNUNET_MQ_MessageHandler *handlers)
+{
+ struct GNUNET_SERVICE_Handle *sh;
+
+ sh = GNUNET_new (struct GNUNET_SERVICE_Handle);
+ sh->service_name = service_name;
+ sh->cfg = cfg;
+ sh->connect_cb = connect_cb;
+ sh->disconnect_cb = disconnect_cb;
+ sh->cb_cls = cls;
+ sh->handlers = GNUNET_MQ_copy_handlers2 (handlers,
+ &return_agpl,
+ NULL);
+ if (GNUNET_OK != setup_service (sh))
+ {
+ GNUNET_free_non_null (sh->handlers);
+ GNUNET_free (sh);
+ return NULL;
+ }
+ do_resume (sh,
+ SUSPEND_STATE_NONE);
+ return sh;
}
/**
- * Run a standard GNUnet service startup sequence (initialize loggers
- * and configuration, parse options).
+ * Stops a service that was started with #GNUNET_SERVICE_start().
*
- * @param argc number of command line arguments
- * @param argv command line arguments
- * @param service_name our service name
- * @param options service options
- * @param task main task of the service
- * @param task_cls closure for @a task
- * @return #GNUNET_SYSERR on error, #GNUNET_OK
- * if we shutdown nicely
+ * @param srv service to stop
*/
-int
-GNUNET_SERVICE_run (int argc, char *const *argv,
- const char *service_name,
- enum GNUNET_SERVICE_Options options,
- GNUNET_SERVICE_Main task,
- void *task_cls)
+void
+GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Handle *srv)
{
-#define HANDLE_ERROR do { GNUNET_break (0); goto shutdown; } while (0)
+ struct GNUNET_SERVICE_Client *client;
+
+ GNUNET_SERVICE_suspend (srv);
+ while (NULL != (client = srv->clients_head))
+ GNUNET_SERVICE_client_drop (client);
+ teardown_service (srv);
+ GNUNET_free_non_null (srv->handlers);
+ GNUNET_free (srv);
+}
- int err;
- int ret;
- char *cfg_fn;
- char *opt_cfg_fn;
+
+/**
+ * Creates the "main" function for a GNUnet service. You
+ * should almost always use the #GNUNET_SERVICE_MAIN macro
+ * instead of calling this function directly (except
+ * for ARM, which should call this function directly).
+ *
+ * The function will launch the service with the name @a service_name
+ * using the @a service_options to configure its shutdown
+ * behavior. Once the service is ready, the @a init_cb will be called
+ * for service-specific initialization. @a init_cb will be given the
+ * service handler which can be used to control the service's
+ * availability. When clients connect or disconnect, the respective
+ * @a connect_cb or @a disconnect_cb functions will be called. For
+ * messages received from the clients, the respective @a handlers will
+ * be invoked; for the closure of the handlers we use the return value
+ * from the @a connect_cb invocation of the respective client.
+ *
+ * Each handler MUST call #GNUNET_SERVICE_client_continue() after each
+ * message to receive further messages from this client. If
+ * #GNUNET_SERVICE_client_continue() is not called within a short
+ * time, a warning will be logged. If delays are expected, services
+ * should call #GNUNET_SERVICE_client_disable_continue_warning() to
+ * disable the warning.
+ *
+ * Clients sending invalid messages (based on @a handlers) will be
+ * dropped. Additionally, clients can be dropped at any time using
+ * #GNUNET_SERVICE_client_drop().
+ *
+ * @param argc number of command-line arguments in @a argv
+ * @param argv array of command-line arguments
+ * @param service_name name of the service to run
+ * @param options options controlling shutdown of the service
+ * @param service_init_cb function to call once the service is ready
+ * @param connect_cb function to call whenever a client connects
+ * @param disconnect_cb function to call whenever a client disconnects
+ * @param cls closure argument for @a service_init_cb, @a connect_cb and @a disconnect_cb
+ * @param handlers NULL-terminated array of message handlers for the service,
+ * the closure will be set to the value returned by
+ * the @a connect_cb for the respective connection
+ * @return 0 on success, non-zero on error
+ */
+int
+GNUNET_SERVICE_run_ (int argc,
+ char *const *argv,
+ const char *service_name,
+ enum GNUNET_SERVICE_Options options,
+ GNUNET_SERVICE_InitCallback service_init_cb,
+ GNUNET_SERVICE_ConnectHandler connect_cb,
+ GNUNET_SERVICE_DisconnectHandler disconnect_cb,
+ void *cls,
+ const struct GNUNET_MQ_MessageHandler *handlers)
+{
+ struct GNUNET_SERVICE_Handle sh;
+ char *cfg_filename;
+ char *opt_cfg_filename;
char *loglev;
+ const char *xdg;
char *logfile;
int do_daemonize;
- unsigned int i;
unsigned long long skew_offset;
unsigned long long skew_variance;
long long clock_offset;
- struct GNUNET_SERVICE_Context sctx;
struct GNUNET_CONFIGURATION_Handle *cfg;
- const char *xdg;
+ int ret;
+ int err;
struct GNUNET_GETOPT_CommandLineOption service_options[] = {
- GNUNET_GETOPT_OPTION_CFG_FILE (&opt_cfg_fn),
- {'d', "daemonize", NULL,
- gettext_noop ("do daemonize (detach from terminal)"), 0,
- GNUNET_GETOPT_set_one, &do_daemonize},
- GNUNET_GETOPT_OPTION_HELP (NULL),
- GNUNET_GETOPT_OPTION_LOGLEVEL (&loglev),
- GNUNET_GETOPT_OPTION_LOGFILE (&logfile),
- GNUNET_GETOPT_OPTION_VERSION (PACKAGE_VERSION " " VCS_VERSION),
+ GNUNET_GETOPT_option_cfgfile (&opt_cfg_filename),
+ GNUNET_GETOPT_option_flag ('d',
+ "daemonize",
+ gettext_noop ("do daemonize (detach from terminal)"),
+ &do_daemonize),
+ GNUNET_GETOPT_option_help (NULL),
+ GNUNET_GETOPT_option_loglevel (&loglev),
+ GNUNET_GETOPT_option_logfile (&logfile),
+ GNUNET_GETOPT_option_version (PACKAGE_VERSION " " VCS_VERSION),
GNUNET_GETOPT_OPTION_END
};
+
err = 1;
- do_daemonize = 0;
- logfile = NULL;
- loglev = NULL;
- opt_cfg_fn = NULL;
+ memset (&sh,
+ 0,
+ sizeof (sh));
xdg = getenv ("XDG_CONFIG_HOME");
if (NULL != xdg)
- GNUNET_asprintf (&cfg_fn,
+ GNUNET_asprintf (&cfg_filename,
"%s%s%s",
xdg,
DIR_SEPARATOR_STR,
- "gnunet.conf");
+ GNUNET_OS_project_data_get ()->config_file);
else
- cfg_fn = GNUNET_strdup (GNUNET_DEFAULT_USER_CONFIG_FILE);
- memset (&sctx, 0, sizeof (sctx));
- sctx.options = options;
- sctx.ready_confirm_fd = -1;
- sctx.ret = GNUNET_OK;
- sctx.timeout = GNUNET_TIME_UNIT_FOREVER_REL;
- sctx.task = task;
- sctx.task_cls = task_cls;
- sctx.service_name = service_name;
- sctx.cfg = cfg = GNUNET_CONFIGURATION_create ();
+ cfg_filename = GNUNET_strdup (GNUNET_OS_project_data_get ()->user_config_file);
+ sh.ready_confirm_fd = -1;
+ sh.options = options;
+ sh.cfg = cfg = GNUNET_CONFIGURATION_create ();
+ sh.service_init_cb = service_init_cb;
+ sh.connect_cb = connect_cb;
+ sh.disconnect_cb = disconnect_cb;
+ sh.cb_cls = cls;
+ sh.handlers = GNUNET_MQ_copy_handlers (handlers);
+ sh.service_name = service_name;
/* setup subsystems */
- ret = GNUNET_GETOPT_run (service_name, service_options, argc, argv);
+ loglev = NULL;
+ logfile = NULL;
+ opt_cfg_filename = NULL;
+ do_daemonize = 0;
+ ret = GNUNET_GETOPT_run (service_name,
+ service_options,
+ argc,
+ argv);
if (GNUNET_SYSERR == ret)
goto shutdown;
if (GNUNET_NO == ret)
@@ -1437,239 +2321,420 @@ GNUNET_SERVICE_run (int argc, char *const *argv,
err = 0;
goto shutdown;
}
- if (GNUNET_OK != GNUNET_log_setup (service_name, loglev, logfile))
- HANDLE_ERROR;
- if (NULL == opt_cfg_fn)
- opt_cfg_fn = GNUNET_strdup (cfg_fn);
- if (GNUNET_YES == GNUNET_DISK_file_test (opt_cfg_fn))
+ if (GNUNET_OK != GNUNET_log_setup (service_name,
+ loglev,
+ logfile))
{
- if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, opt_cfg_fn))
+ GNUNET_break (0);
+ goto shutdown;
+ }
+ if (NULL != opt_cfg_filename)
+ {
+ if ( (GNUNET_YES !=
+ GNUNET_DISK_file_test (opt_cfg_filename)) ||
+ (GNUNET_SYSERR ==
+ GNUNET_CONFIGURATION_load (cfg,
+ opt_cfg_filename)) )
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Malformed configuration file `%s', exit ...\n"),
- opt_cfg_fn);
+ _("Malformed configuration file `%s', exit ...\n"),
+ opt_cfg_filename);
goto shutdown;
}
}
else
{
- if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, NULL))
+ if (GNUNET_YES ==
+ GNUNET_DISK_file_test (cfg_filename))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Malformed configuration, exit ...\n"));
- goto shutdown;
+ if (GNUNET_SYSERR ==
+ GNUNET_CONFIGURATION_load (cfg,
+ cfg_filename))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _("Malformed configuration file `%s', exit ...\n"),
+ cfg_filename);
+ goto shutdown;
+ }
+ }
+ else
+ {
+ if (GNUNET_SYSERR ==
+ GNUNET_CONFIGURATION_load (cfg,
+ NULL))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _("Malformed configuration, exit ...\n"));
+ goto shutdown;
+ }
}
- if (0 != strcmp (opt_cfg_fn, cfg_fn))
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Could not access configuration file `%s'\n"),
- opt_cfg_fn);
}
- if (GNUNET_OK != setup_service (&sctx))
+ if (GNUNET_OK != setup_service (&sh))
+ goto shutdown;
+ if ( (1 == do_daemonize) &&
+ (GNUNET_OK != detach_terminal (&sh)) )
+ {
+ GNUNET_break (0);
goto shutdown;
- if ((1 == do_daemonize) && (GNUNET_OK != detach_terminal (&sctx)))
- HANDLE_ERROR;
- if (GNUNET_OK != set_user_id (&sctx))
+ }
+ if (GNUNET_OK != set_user_id (&sh))
goto shutdown;
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Service `%s' runs with configuration from `%s'\n",
service_name,
- opt_cfg_fn);
+ (NULL != opt_cfg_filename) ? opt_cfg_filename : cfg_filename);
if ((GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_number (sctx.cfg, "TESTING",
- "SKEW_OFFSET", &skew_offset)) &&
+ GNUNET_CONFIGURATION_get_value_number (sh.cfg,
+ "TESTING",
+ "SKEW_OFFSET",
+ &skew_offset)) &&
(GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_number (sctx.cfg, "TESTING",
- "SKEW_VARIANCE", &skew_variance)))
+ GNUNET_CONFIGURATION_get_value_number (sh.cfg,
+ "TESTING",
+ "SKEW_VARIANCE",
+ &skew_variance)))
{
clock_offset = skew_offset - skew_variance;
GNUNET_TIME_set_offset (clock_offset);
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Skewing clock by %dll ms\n", clock_offset);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Skewing clock by %dll ms\n",
+ clock_offset);
}
+ GNUNET_RESOLVER_connect (sh.cfg);
+
/* actually run service */
err = 0;
- GNUNET_SCHEDULER_run (&service_task, &sctx);
+ GNUNET_SCHEDULER_run (&service_main,
+ &sh);
/* shutdown */
- if ((1 == do_daemonize) && (NULL != sctx.server))
- pid_file_delete (&sctx);
- GNUNET_free_non_null (sctx.my_handlers);
+ if (1 == do_daemonize)
+ pid_file_delete (&sh);
shutdown:
- if (-1 != sctx.ready_confirm_fd)
+ if (-1 != sh.ready_confirm_fd)
{
- if (1 != WRITE (sctx.ready_confirm_fd, err ? "I" : "S", 1))
- LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "write");
- GNUNET_break (0 == CLOSE (sctx.ready_confirm_fd));
+ if (1 != WRITE (sh.ready_confirm_fd,
+ err ? "I" : "S",
+ 1))
+ LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
+ "write");
+ GNUNET_break (0 == CLOSE (sh.ready_confirm_fd));
}
#if HAVE_MALLINFO
{
char *counter;
if ( (GNUNET_YES ==
- GNUNET_CONFIGURATION_have_value (sctx.cfg, service_name,
+ GNUNET_CONFIGURATION_have_value (sh.cfg,
+ service_name,
"GAUGER_HEAP")) &&
(GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_string (sctx.cfg, service_name,
+ GNUNET_CONFIGURATION_get_value_string (sh.cfg,
+ service_name,
"GAUGER_HEAP",
&counter)) )
{
struct mallinfo mi;
mi = mallinfo ();
- GAUGER (service_name, counter, mi.usmblks, "blocks");
+ GAUGER (service_name,
+ counter,
+ mi.usmblks,
+ "blocks");
GNUNET_free (counter);
}
}
#endif
+ teardown_service (&sh);
+ GNUNET_free_non_null (sh.handlers);
GNUNET_SPEEDUP_stop_ ();
GNUNET_CONFIGURATION_destroy (cfg);
- i = 0;
- if (NULL != sctx.addrs)
- while (NULL != sctx.addrs[i])
- GNUNET_free (sctx.addrs[i++]);
- GNUNET_free_non_null (sctx.addrs);
- GNUNET_free_non_null (sctx.addrlens);
GNUNET_free_non_null (logfile);
GNUNET_free_non_null (loglev);
- GNUNET_free (cfg_fn);
- GNUNET_free (opt_cfg_fn);
- GNUNET_free_non_null (sctx.v4_denied);
- GNUNET_free_non_null (sctx.v6_denied);
- GNUNET_free_non_null (sctx.v4_allowed);
- GNUNET_free_non_null (sctx.v6_allowed);
-
- return err ? GNUNET_SYSERR : sctx.ret;
+ GNUNET_free (cfg_filename);
+ GNUNET_free_non_null (opt_cfg_filename);
+
+ return err ? GNUNET_SYSERR : sh.ret;
}
/**
- * Run a service startup sequence within an existing
- * initialized system.
+ * Suspend accepting connections from the listen socket temporarily.
+ * Resume activity using #GNUNET_SERVICE_resume.
*
- * @param service_name our service name
- * @param cfg configuration to use
- * @param options service options
- * @return NULL on error, service handle
+ * @param sh service to stop accepting connections.
*/
-struct GNUNET_SERVICE_Context *
-GNUNET_SERVICE_start (const char *service_name,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- enum GNUNET_SERVICE_Options options)
+void
+GNUNET_SERVICE_suspend (struct GNUNET_SERVICE_Handle *sh)
{
- int i;
- struct GNUNET_SERVICE_Context *sctx;
+ do_suspend (sh,
+ SUSPEND_STATE_APP);
+}
- sctx = GNUNET_new (struct GNUNET_SERVICE_Context);
- sctx->ready_confirm_fd = -1; /* no daemonizing */
- sctx->ret = GNUNET_OK;
- sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
- sctx->service_name = service_name;
- sctx->cfg = cfg;
- sctx->options = options;
- /* setup subsystems */
- if (GNUNET_OK != setup_service (sctx))
- {
- GNUNET_SERVICE_stop (sctx);
- return NULL;
- }
- if (NULL != sctx->lsocks)
- sctx->server =
- GNUNET_SERVER_create_with_sockets (&check_access, sctx, sctx->lsocks,
- sctx->timeout, sctx->require_found);
- else
- sctx->server =
- GNUNET_SERVER_create (&check_access, sctx, sctx->addrs, sctx->addrlens,
- sctx->timeout, sctx->require_found);
+/**
+ * Resume accepting connections from the listen socket.
+ *
+ * @param sh service to resume accepting connections.
+ */
+void
+GNUNET_SERVICE_resume (struct GNUNET_SERVICE_Handle *sh)
+{
+ do_resume (sh,
+ SUSPEND_STATE_APP);
+}
+
+
+/**
+ * Task run to resume receiving data from the client after
+ * the client called #GNUNET_SERVICE_client_continue().
+ *
+ * @param cls our `struct GNUNET_SERVICE_Client`
+ */
+static void
+resume_client_receive (void *cls)
+{
+ struct GNUNET_SERVICE_Client *c = cls;
+ int ret;
- if (NULL == sctx->server)
+ c->recv_task = NULL;
+ /* first, check if there is still something in the buffer */
+ ret = GNUNET_MST_next (c->mst,
+ GNUNET_YES);
+ if (GNUNET_SYSERR == ret)
{
- GNUNET_SERVICE_stop (sctx);
- return NULL;
+ if (NULL == c->drop_task)
+ GNUNET_SERVICE_client_drop (c);
+ return;
}
-#ifndef WINDOWS
- if (NULL != sctx->addrs)
- for (i = 0; NULL != sctx->addrs[i]; i++)
- if (AF_UNIX == sctx->addrs[i]->sa_family)
- GNUNET_DISK_fix_permissions (((const struct sockaddr_un *)sctx->addrs[i])->sun_path,
- sctx->match_uid,
- sctx->match_gid);
-#endif
- sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
- memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers));
- i = 0;
- while ((sctx->my_handlers[i].callback != NULL))
- sctx->my_handlers[i++].callback_cls = sctx;
- GNUNET_SERVER_add_handlers (sctx->server, sctx->my_handlers);
- return sctx;
+ if (GNUNET_NO == ret)
+ return; /* done processing, wait for more later */
+ GNUNET_assert (GNUNET_OK == ret);
+ if (GNUNET_YES == c->needs_continue)
+ return; /* #GNUNET_MST_next() did give a message to the client */
+ /* need to receive more data from the network first */
+ if (NULL != c->recv_task)
+ return;
+ c->recv_task
+ = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ c->sock,
+ &service_client_recv,
+ c);
}
/**
- * Obtain the server used by a service. Note that the server must NOT
- * be destroyed by the caller.
+ * Continue receiving further messages from the given client.
+ * Must be called after each message received.
*
- * @param ctx the service context returned from the start function
- * @return handle to the server for this service, NULL if there is none
+ * @param c the client to continue receiving from
*/
-struct GNUNET_SERVER_Handle *
-GNUNET_SERVICE_get_server (struct GNUNET_SERVICE_Context *ctx)
+void
+GNUNET_SERVICE_client_continue (struct GNUNET_SERVICE_Client *c)
{
- return ctx->server;
+ GNUNET_assert (NULL == c->drop_task);
+ GNUNET_assert (GNUNET_YES == c->needs_continue);
+ GNUNET_assert (NULL == c->recv_task);
+ c->needs_continue = GNUNET_NO;
+ if (NULL != c->warn_task)
+ {
+ GNUNET_SCHEDULER_cancel (c->warn_task);
+ c->warn_task = NULL;
+ }
+ c->recv_task
+ = GNUNET_SCHEDULER_add_now (&resume_client_receive,
+ c);
}
/**
- * Stop a service that was started with "GNUNET_SERVICE_start".
+ * Disable the warning the server issues if a message is not
+ * acknowledged in a timely fashion. Use this call if a client is
+ * intentionally delayed for a while. Only applies to the current
+ * message.
*
- * @param sctx the service context returned from the start function
+ * @param c client for which to disable the warning
*/
void
-GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Context *sctx)
+GNUNET_SERVICE_client_disable_continue_warning (struct GNUNET_SERVICE_Client *c)
{
- unsigned int i;
+ GNUNET_break (NULL != c->warn_task);
+ if (NULL != c->warn_task)
+ {
+ GNUNET_SCHEDULER_cancel (c->warn_task);
+ c->warn_task = NULL;
+ }
+}
-#if HAVE_MALLINFO
+
+/**
+ * Asynchronously finish dropping the client.
+ *
+ * @param cls the `struct GNUNET_SERVICE_Client`.
+ */
+static void
+finish_client_drop (void *cls)
+{
+ struct GNUNET_SERVICE_Client *c = cls;
+ struct GNUNET_SERVICE_Handle *sh = c->sh;
+
+ c->drop_task = NULL;
+ GNUNET_assert (NULL == c->send_task);
+ GNUNET_assert (NULL == c->recv_task);
+ GNUNET_assert (NULL == c->warn_task);
+ GNUNET_MST_destroy (c->mst);
+ GNUNET_MQ_destroy (c->mq);
+ if (GNUNET_NO == c->persist)
{
- char *counter;
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_NETWORK_socket_close (c->sock));
+ if ( (0 != (SUSPEND_STATE_EMFILE & sh->suspend_state)) &&
+ (0 == (SUSPEND_STATE_SHUTDOWN & sh->suspend_state)) )
+ do_resume (sh,
+ SUSPEND_STATE_EMFILE);
+ }
+ else
+ {
+ GNUNET_NETWORK_socket_free_memory_only_ (c->sock);
+ }
+ GNUNET_free (c);
+ if ( (0 != (SUSPEND_STATE_SHUTDOWN & sh->suspend_state)) &&
+ (GNUNET_NO == have_non_monitor_clients (sh)) )
+ GNUNET_SERVICE_shutdown (sh);
+}
- if ( (GNUNET_YES ==
- GNUNET_CONFIGURATION_have_value (sctx->cfg, sctx->service_name,
- "GAUGER_HEAP")) &&
- (GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_string (sctx->cfg, sctx->service_name,
- "GAUGER_HEAP",
- &counter)) )
- {
- struct mallinfo mi;
- mi = mallinfo ();
- GAUGER (sctx->service_name, counter, mi.usmblks, "blocks");
- GNUNET_free (counter);
- }
+/**
+ * Ask the server to disconnect from the given client. This is the
+ * same as returning #GNUNET_SYSERR within the check procedure when
+ * handling a message, wexcept that it allows dropping of a client even
+ * when not handling a message from that client. The `disconnect_cb`
+ * will be called on @a c even if the application closes the connection
+ * using this function.
+ *
+ * @param c client to disconnect now
+ */
+void
+GNUNET_SERVICE_client_drop (struct GNUNET_SERVICE_Client *c)
+{
+ struct GNUNET_SERVICE_Handle *sh = c->sh;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Client dropped: %p (MQ: %p)\n",
+ c,
+ c->mq);
+#if EXECINFO
+ {
+ void *backtrace_array[MAX_TRACE_DEPTH];
+ int num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH);
+ char **backtrace_strings =
+ backtrace_symbols (backtrace_array,
+ t->num_backtrace_strings);
+ for (unsigned int i = 0; i < num_backtrace_strings; i++)
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "client drop trace %u: %s\n",
+ i,
+ backtrace_strings[i]);
}
#endif
- if (GNUNET_SCHEDULER_NO_TASK != sctx->shutdown_task)
+ if (NULL != c->drop_task)
{
- GNUNET_SCHEDULER_cancel (sctx->shutdown_task);
- sctx->shutdown_task = GNUNET_SCHEDULER_NO_TASK;
+ /* asked to drop twice! */
+ GNUNET_assert (0);
+ return;
}
- if (NULL != sctx->server)
- GNUNET_SERVER_destroy (sctx->server);
- GNUNET_free_non_null (sctx->my_handlers);
- if (NULL != sctx->addrs)
+ GNUNET_CONTAINER_DLL_remove (sh->clients_head,
+ sh->clients_tail,
+ c);
+ if (NULL != sh->disconnect_cb)
+ sh->disconnect_cb (sh->cb_cls,
+ c,
+ c->user_context);
+ if (NULL != c->warn_task)
{
- i = 0;
- while (NULL != sctx->addrs[i])
- GNUNET_free (sctx->addrs[i++]);
- GNUNET_free (sctx->addrs);
+ GNUNET_SCHEDULER_cancel (c->warn_task);
+ c->warn_task = NULL;
+ }
+ if (NULL != c->recv_task)
+ {
+ GNUNET_SCHEDULER_cancel (c->recv_task);
+ c->recv_task = NULL;
+ }
+ if (NULL != c->send_task)
+ {
+ GNUNET_SCHEDULER_cancel (c->send_task);
+ c->send_task = NULL;
}
- GNUNET_free_non_null (sctx->addrlens);
- GNUNET_free_non_null (sctx->v4_denied);
- GNUNET_free_non_null (sctx->v6_denied);
- GNUNET_free_non_null (sctx->v4_allowed);
- GNUNET_free_non_null (sctx->v6_allowed);
- GNUNET_free (sctx);
+ c->drop_task = GNUNET_SCHEDULER_add_now (&finish_client_drop,
+ c);
+}
+
+
+/**
+ * Explicitly stops the service.
+ *
+ * @param sh server to shutdown
+ */
+void
+GNUNET_SERVICE_shutdown (struct GNUNET_SERVICE_Handle *sh)
+{
+ struct GNUNET_SERVICE_Client *client;
+
+ if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN))
+ do_suspend (sh,
+ SUSPEND_STATE_SHUTDOWN);
+ while (NULL != (client = sh->clients_head))
+ GNUNET_SERVICE_client_drop (client);
+}
+
+
+/**
+ * Set the 'monitor' flag on this client. Clients which have been
+ * marked as 'monitors' won't prevent the server from shutting down
+ * once #GNUNET_SERVICE_stop_listening() has been invoked. The idea is
+ * that for "normal" clients we likely want to allow them to process
+ * their requests; however, monitor-clients are likely to 'never'
+ * disconnect during shutdown and thus will not be considered when
+ * determining if the server should continue to exist after
+ * shutdown has been triggered.
+ *
+ * @param c client to mark as a monitor
+ */
+void
+GNUNET_SERVICE_client_mark_monitor (struct GNUNET_SERVICE_Client *c)
+{
+ c->is_monitor = GNUNET_YES;
+ if ( (0 != (SUSPEND_STATE_SHUTDOWN & c->sh->suspend_state) &&
+ (GNUNET_NO == have_non_monitor_clients (c->sh)) ) )
+ GNUNET_SERVICE_shutdown (c->sh);
+}
+
+
+/**
+ * Set the persist option on this client. Indicates that the
+ * underlying socket or fd should never really be closed. Used for
+ * indicating process death.
+ *
+ * @param c client to persist the socket (never to be closed)
+ */
+void
+GNUNET_SERVICE_client_persist (struct GNUNET_SERVICE_Client *c)
+{
+ c->persist = GNUNET_YES;
+}
+
+
+/**
+ * Obtain the message queue of @a c. Convenience function.
+ *
+ * @param c the client to continue receiving from
+ * @return the message queue of @a c
+ */
+struct GNUNET_MQ_Handle *
+GNUNET_SERVICE_client_get_mq (struct GNUNET_SERVICE_Client *c)
+{
+ return c->mq;
}
-/* end of service.c */
+/* end of service_new.c */