service.c File Reference

functions related to starting services (redesign) More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_constants.h"
#include "gnunet_resolver_service.h"
#include "speedup.h"

Include dependency graph for service.c:

Go to the source code of this file.

Data Structures
struct	ServiceListenContext
	Information the service tracks per listen operation. More...
struct	GNUNET_SERVICE_Handle
	Handle to a service. More...
struct	GNUNET_SERVICE_Client
	Handle to a client that is connected to a service. More...
struct	ServiceHandleList
	A list of service to be launched when GNUNET_SERVICE_main() is called. More...
struct	LaunchContext

Macros
#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)

Enumerations
enum	SuspendReason {   SUSPEND_STATE_NONE = 0 , SUSPEND_STATE_APP = 1 , SUSPEND_STATE_EMFILE = 2 , SUSPEND_STATE_APP_AND_EMFILE = 3 ,   SUSPEND_STATE_SHUTDOWN = 4 }
	Reasons why we might be suspended. More...

Functions
static enum GNUNET_GenericReturnValue	have_non_monitor_clients (struct GNUNET_SERVICE_Handle *sh)
	Check if any of the clients we have left are unrelated to monitoring.
static void	do_suspend (struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr)
	Suspend accepting connections from the listen socket temporarily.
static void	service_shutdown (void *cls)
	Shutdown task triggered when a service should be terminated.
static bool	check_ipv4_listed (const struct GNUNET_STRINGS_IPv4NetworkPolicy *list, const struct in_addr *add)
	Check if the given IP address is in the list of IP addresses.
static bool	check_ipv6_listed (const struct GNUNET_STRINGS_IPv6NetworkPolicy *list, const struct in6_addr *ip)
	Check if the given IP address is in the list of IP addresses.
static void	do_send (void *cls)
	Task run when we are ready to transmit data to the client.
static void	service_mq_send (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
	Signature of functions implementing the sending functionality of a message queue.
static void	service_mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Implementation function that cancels the currently sent message.
static void	service_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.
static void	warn_no_client_continue (void *cls)
	Task run to warn about missing calls to GNUNET_SERVICE_client_continue().
static int	service_client_mst_cb (void *cls, const struct GNUNET_MessageHeader *message)
	Functions with this signature are called whenever a complete message is received by the tokenizer for a client.
static void	service_client_recv (void *cls)
	A client sent us data.
static void	start_client (struct GNUNET_SERVICE_Handle *sh, struct GNUNET_NETWORK_Handle *csock)
	We have successfully accepted a connection from a client.
static void	accept_client (void *cls)
	We have a client.
static void	do_resume (struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr)
	Resume accepting connections from the listen socket.
static void	service_main (void *cls)
	First task run by any service.
static enum GNUNET_GenericReturnValue	process_acl4 (struct GNUNET_STRINGS_IPv4NetworkPolicy **ret, struct GNUNET_SERVICE_Handle *sh, const char *option)
	Parse an IPv4 access control list.
static enum GNUNET_GenericReturnValue	process_acl6 (struct GNUNET_STRINGS_IPv6NetworkPolicy **ret, struct GNUNET_SERVICE_Handle *sh, const char *option)
	Parse an IPv6 access control list.
static void	add_unixpath (struct sockaddr **saddrs, socklen_t *saddrlens, const char *unixpath)
	Add the given UNIX domain path as an address to the list (as the first entry).
static int	get_server_addresses (const char *service_name, const struct GNUNET_CONFIGURATION_Handle *cfg, struct sockaddr ***addrs, socklen_t **addr_lens)
	Get the list of addresses that a server for the given service should bind to.
static struct GNUNET_NETWORK_Handle *	open_listen_socket (const struct sockaddr *server_addr, socklen_t socklen)
	Create and initialize a listen socket for the server.
static enum GNUNET_GenericReturnValue	setup_service (const struct GNUNET_OS_ProjectData *pd, struct GNUNET_SERVICE_Handle *sh)
	Setup service handle.
static char *	get_user_name (struct GNUNET_SERVICE_Handle *sh)
	Get the name of the user that'll be used to provide the service.
static enum GNUNET_GenericReturnValue	set_user_id (struct GNUNET_SERVICE_Handle *sh)
	Set user ID.
static char *	get_pid_file_name (struct GNUNET_SERVICE_Handle *sh)
	Get the name of the file where we will write the PID of the service.
static void	pid_file_delete (struct GNUNET_SERVICE_Handle *sh)
	Delete the PID file that was created by our parent.
static enum GNUNET_GenericReturnValue	detach_terminal (struct GNUNET_SERVICE_Handle *sh)
	Detach from terminal.
static void	teardown_service (struct GNUNET_SERVICE_Handle *sh)
	Tear down the service, closing the listen sockets and freeing the ACLs.
static void	return_agpl (void *cls, const struct GNUNET_MessageHeader *msg)
	Function to return link to AGPL source upon request.
struct GNUNET_SERVICE_Handle *	GNUNET_SERVICE_start (const struct GNUNET_OS_ProjectData *pd, 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)
	Low-level function to start a service if the scheduler is already running.
static void	finish_client_drop (void *cls)
	Asynchronously finish dropping the client.
void	GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Handle *srv)
	Stops a service that was started with GNUNET_SERVICE_start().
int	GNUNET_SERVICE_run_ (const struct GNUNET_OS_ProjectData *pd, 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)
	Creates the "main" function for a GNUnet service.
int	GNUNET_SERVICE_register_ (const struct GNUNET_OS_ProjectData *pd, 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)
	Registers the GNUnet service to be scheduled as part of a monilithic libgnunet.
static void	do_registered_services_shutdown (void *cls)
static void	launch_registered_services (void *cls)
void	GNUNET_SERVICE_main (const struct GNUNET_OS_ProjectData *pd, int argc, char *const *argv, struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_GenericReturnValue with_scheduler)
	Run the mainloop in a monolithic libgnunet.
void	GNUNET_SERVICE_suspend (struct GNUNET_SERVICE_Handle *sh)
	Suspend accepting connections from the listen socket temporarily.
void	GNUNET_SERVICE_resume (struct GNUNET_SERVICE_Handle *sh)
	Resume accepting connections from the listen socket.
static void	resume_client_receive (void *cls)
	Task run to resume receiving data from the client after the client called GNUNET_SERVICE_client_continue().
void	GNUNET_SERVICE_client_continue (struct GNUNET_SERVICE_Client *c)
	Continue receiving further messages from the given client.
void	GNUNET_SERVICE_client_disable_continue_warning (struct GNUNET_SERVICE_Client *c)
	Disable the warning the server issues if a message is not acknowledged in a timely fashion.
void	GNUNET_SERVICE_client_drop (struct GNUNET_SERVICE_Client *c)
	Ask the server to disconnect from the given client.
void	GNUNET_SERVICE_shutdown (struct GNUNET_SERVICE_Handle *sh)
	Explicitly stops the service.
void	GNUNET_SERVICE_client_mark_monitor (struct GNUNET_SERVICE_Client *c)
	Set the 'monitor' flag on this client.
void	GNUNET_SERVICE_client_persist (struct GNUNET_SERVICE_Client *c)
	Set the persist option on this client.
struct GNUNET_MQ_Handle *	GNUNET_SERVICE_client_get_mq (struct GNUNET_SERVICE_Client *c)
	Obtain the message queue of c.

Variables
static struct ServiceHandleList *	hll_head
static struct ServiceHandleList *	hll_tail

Detailed Description

functions related to starting services (redesign)

Author

Christian Grothoff

Florian Dold

Definition in file service.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "util-service", __VA_ARGS__)

Definition at line 39 of file service.c.

LOG_STRERROR

#define LOG_STRERROR	(		kind,
			syscall
	)		GNUNET_log_from_strerror (kind, "util-service", syscall)

Definition at line 41 of file service.c.

{
  struct ServiceListenContext *next;
 
  struct ServiceListenContext *prev;
 
  struct GNUNET_SERVICE_Handle *sh;
 
  struct GNUNET_NETWORK_Handle *listen_socket;
 
  struct GNUNET_SCHEDULER_Task *listen_task;
};
 
 
enum SuspendReason
{
  SUSPEND_STATE_NONE = 0,
 
  SUSPEND_STATE_APP = 1,
 
  SUSPEND_STATE_EMFILE = 2,
 
  SUSPEND_STATE_APP_AND_EMFILE = 3,
 
  SUSPEND_STATE_SHUTDOWN = 4
};
 
 
struct GNUNET_SERVICE_Handle
{
  const struct GNUNET_CONFIGURATION_Handle *cfg;
 
  const struct GNUNET_OS_ProjectData *pd;
 
  const char *service_name;
 
  GNUNET_SERVICE_InitCallback service_init_cb;
 
  GNUNET_SERVICE_ConnectHandler connect_cb;
 
  GNUNET_SERVICE_DisconnectHandler disconnect_cb;
 
  void *cb_cls;
 
  struct ServiceListenContext *slc_head;
 
  struct ServiceListenContext *slc_tail;
 
  struct GNUNET_SERVICE_Client *clients_head;
 
  struct GNUNET_SERVICE_Client *clients_tail;
 
  struct GNUNET_MQ_MessageHandler *handlers;
 
  void *task_cls;
 
  struct GNUNET_STRINGS_IPv4NetworkPolicy *v4_denied;
 
  struct GNUNET_STRINGS_IPv6NetworkPolicy *v6_denied;
 
  struct GNUNET_STRINGS_IPv4NetworkPolicy *v4_allowed;
 
  struct GNUNET_STRINGS_IPv6NetworkPolicy *v6_allowed;
 
  int match_uid;
 
  int match_gid;
 
  enum SuspendReason suspend_state;
 
  enum GNUNET_SERVICE_Options options;
 
  int ready_confirm_fd;
 
  bool require_found;
};
 
 
struct GNUNET_SERVICE_Client
{
  struct GNUNET_SERVICE_Client *next;
 
  struct GNUNET_SERVICE_Client *prev;
 
  struct GNUNET_SERVICE_Handle *sh;
 
  struct GNUNET_NETWORK_Handle *sock;
 
  struct GNUNET_MQ_Handle *mq;
 
  struct GNUNET_MessageStreamTokenizer *mst;
 
  struct GNUNET_SCHEDULER_Task *warn_task;
 
  struct GNUNET_SCHEDULER_Task *drop_task;
 
  struct GNUNET_SCHEDULER_Task *recv_task;
 
  struct GNUNET_SCHEDULER_Task *send_task;
 
  const struct GNUNET_MessageHeader *msg;
 
  void *user_context;
 
  struct GNUNET_TIME_Absolute warn_start;
 
  size_t msg_pos;
 
  bool persist;
 
  bool is_monitor;
 
  bool needs_continue;
 
  uint16_t warn_type;
};
 
 
static enum GNUNET_GenericReturnValue
have_non_monitor_clients (struct GNUNET_SERVICE_Handle *sh)
{
  for (struct GNUNET_SERVICE_Client *client = sh->clients_head;
       NULL != client;
       client = client->next)
  {
    if (NULL != client->drop_task)
      continue;
    if (client->is_monitor)
      continue;
    return true;
  }
  return false;
}
 
 
static void
do_suspend (struct GNUNET_SERVICE_Handle *sh,
            enum SuspendReason sr)
{
  GNUNET_assert (0 == (sh->suspend_state & sr));
  sh->suspend_state |= sr;
  for (struct ServiceListenContext *slc = sh->slc_head;
       NULL != slc;
       slc = slc->next)
  {
    if (NULL != slc->listen_task)
    {
      GNUNET_SCHEDULER_cancel (slc->listen_task);
      slc->listen_task = NULL;
    }
  }
}
 
 
static void
service_shutdown (void *cls)
{
  struct GNUNET_SERVICE_Handle *sh = cls;
 
  switch (sh->options & GNUNET_SERVICE_OPTION_SHUTDOWN_BITMASK)
  {
  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 (! have_non_monitor_clients (sh))
      GNUNET_SERVICE_shutdown (sh);
    break;
  }
}
 
 
static bool
check_ipv4_listed (const struct GNUNET_STRINGS_IPv4NetworkPolicy *list,
                   const struct in_addr *add)
{
  for (unsigned int i = 0;
       0 != list[i].network.s_addr;
       i++)
  {
    if ( (add->s_addr & list[i].netmask.s_addr) ==
         (list[i].network.s_addr & list[i].netmask.s_addr) )
      return true;
  }
  return false;
}
 
 
static bool
check_ipv6_listed (const struct GNUNET_STRINGS_IPv6NetworkPolicy *list,
                   const struct in6_addr *ip)
{
  for (unsigned int i = 0;
       ! GNUNET_is_zero (&list[i].network);
       i++)
  {
    bool match = true;
 
    for (unsigned int j = 0; j < sizeof(struct in6_addr) / sizeof(int); j++)
      if (((((int *) ip)[j] & ((int *) &list[i].netmask)[j])) !=
          (((int *) &list[i].network)[j] & ((int *) &list[i].netmask)[j]))
      {
        match = false;
        break;
      }
    if (match)
      return true;
  }
  return false;
}
 
 
static void
do_send (void *cls)
{
  struct GNUNET_SERVICE_Client *client = cls;
  ssize_t ret;
  size_t left;
  const char *buf;
 
  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);
}
 
 
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;
 
  (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_now (&do_send,
                                                client);
}
 
 
static void
service_mq_cancel (struct GNUNET_MQ_Handle *mq,
                   void *impl_state)
{
  struct GNUNET_SERVICE_Client *client = impl_state;
 
  (void) mq;
  GNUNET_assert (0 == client->msg_pos);
  client->msg = NULL;
  GNUNET_SCHEDULER_cancel (client->send_task);
  client->send_task = NULL;
}
 
 
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;
 
  if ( (GNUNET_MQ_ERROR_NO_MATCH == error) &&
       (! 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);
}
 
 
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));
}
 
 
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 (! client->needs_continue);
  client->needs_continue = true;
  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;
}
 
 
static void
service_client_recv (void *cls)
{
  struct GNUNET_SERVICE_Client *client = cls;
  enum GNUNET_GenericReturnValue ret;
 
  client->recv_task = NULL;
  ret = GNUNET_MST_read (client->mst,
                         client->sock,
                         GNUNET_NO,
                         GNUNET_YES);
  if (GNUNET_SYSERR == ret)
  {
    /* client closed connection (or IO error) */
    if (NULL == client->drop_task)
    {
      GNUNET_assert (! client->needs_continue);
      GNUNET_SERVICE_client_drop (client);
    }
    return;
  }
  if (GNUNET_NO == ret)
    return; /* more messages in buffer, wait for application
               to be done processing */
  GNUNET_assert (GNUNET_OK == ret);
  if (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);
}
 
 
static void
start_client (struct GNUNET_SERVICE_Handle *sh,
              struct GNUNET_NETWORK_Handle *csock)
{
  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);
}
 
 
static void
accept_client (void *cls)
{
  struct ServiceListenContext *slc = cls;
  struct GNUNET_SERVICE_Handle *sh = slc->sh;
 
  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;
 
    case AF_UNIX:
      ok = GNUNET_OK;     /* controlled using file-system ACL now */
      break;
 
    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);
}
 
 
static void
do_resume (struct GNUNET_SERVICE_Handle *sh,
           enum SuspendReason sr)
{
  GNUNET_assert ((SUSPEND_STATE_NONE == sr) || (0 != (sh->suspend_state & sr)));
  sh->suspend_state -= sr;
  if (SUSPEND_STATE_NONE != sh->suspend_state)
    return;
  for (struct ServiceListenContext *slc = sh->slc_head;
       NULL != slc;
       slc = slc->next)
  {
    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);
  }
}
 
 
static void
service_main (void *cls)
{
  struct GNUNET_SERVICE_Handle *sh = cls;
 
  if (GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN !=
      (sh->options & GNUNET_SERVICE_OPTION_SHUTDOWN_BITMASK))
    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);
}
 
 
static enum GNUNET_GenericReturnValue
process_acl4 (struct GNUNET_STRINGS_IPv4NetworkPolicy **ret,
              struct GNUNET_SERVICE_Handle *sh,
              const char *option)
{
  char *opt;
 
  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 (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,
         sh->service_name,
         option);
    GNUNET_free (opt);
    return GNUNET_SYSERR;
  }
  GNUNET_free (opt);
  return GNUNET_OK;
}
 
 
static enum GNUNET_GenericReturnValue
process_acl6 (struct GNUNET_STRINGS_IPv6NetworkPolicy **ret,
              struct GNUNET_SERVICE_Handle *sh,
              const char *option)
{
  char *opt;
 
  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 (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,
         sh->service_name,
         option);
    GNUNET_free (opt);
    return GNUNET_SYSERR;
  }
  GNUNET_free (opt);
  return GNUNET_OK;
}
 
 
static void
add_unixpath (struct sockaddr **saddrs,
              socklen_t *saddrlens,
              const char *unixpath)
{
#ifdef AF_UNIX
  struct sockaddr_un *un;
 
  un = GNUNET_new (struct sockaddr_un);
  un->sun_family = AF_UNIX;
  GNUNET_strlcpy (un->sun_path, unixpath, sizeof(un->sun_path));
#if HAVE_SOCKADDR_UN_SUN_LEN
  un->sun_len = (u_char) sizeof(struct sockaddr_un);
#endif
  *saddrs = (struct sockaddr *) un;
  *saddrlens = sizeof(struct sockaddr_un);
#else
  /* this function should never be called
   * unless AF_UNIX is defined! */
  GNUNET_assert (0);
#endif
}
 
 
static int
get_server_addresses (const char *service_name,
                      const struct GNUNET_CONFIGURATION_Handle *cfg,
                      struct sockaddr ***addrs,
                      socklen_t **addr_lens)
{
  bool disablev6;
  struct GNUNET_NETWORK_Handle *desc;
  unsigned long long port;
  char *unixpath;
  struct addrinfo hints;
  struct addrinfo *res;
  struct addrinfo *pos;
  struct addrinfo *next;
  unsigned int i;
  int resi;
  int ret;
  struct sockaddr **saddrs;
  socklen_t *saddrlens;
  char *hostname;
 
  *addrs = NULL;
  *addr_lens = NULL;
  desc = NULL;
  disablev6 = false;
  if ((GNUNET_NO ==
       GNUNET_NETWORK_test_pf (PF_INET6)) ||
      (GNUNET_YES ==
       GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                             service_name,
                                             "DISABLEV6")))
    disablev6 = true;
 
  port = 0;
  if (GNUNET_SYSERR ==
      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"),
         service_name);
  }
  if (port > 65535)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Require valid port number for service `%s' in configuration!\n"),
         service_name);
    return GNUNET_SYSERR;
  }
 
  hostname = NULL;
  GNUNET_break (GNUNET_SYSERR !=
                GNUNET_CONFIGURATION_get_value_string (cfg,
                                                       service_name,
                                                       "BINDTO",
                                                       &hostname));
 
  unixpath = NULL;
#ifdef AF_UNIX
  if ( (GNUNET_OK ==
        GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                 service_name,
                                                 "UNIXPATH",
                                                 &unixpath)) &&
       (0 < strlen (unixpath)) )
  {
    /* probe UNIX support */
    struct sockaddr_un s_un;
 
    if (strlen (unixpath) >= sizeof(s_un.sun_path))
    {
      LOG (GNUNET_ERROR_TYPE_WARNING,
           "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);
    }
    if (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);
    if (NULL == desc)
    {
      if ((ENOBUFS == errno) ||
          (ENOMEM == errno) ||
          (ENFILE == errno) ||
          (EACCES == errno))
      {
        LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                      "socket");
        GNUNET_free (hostname);
        GNUNET_free (unixpath);
        return GNUNET_SYSERR;
      }
      LOG (GNUNET_ERROR_TYPE_WARNING,
           "Failed to create UNIX domain socket for service %s: %s\n",
           service_name,
           strerror (errno));
      GNUNET_free (unixpath);
      unixpath = NULL;
    }
    else
    {
      GNUNET_break (GNUNET_OK ==
                    GNUNET_NETWORK_socket_close (desc));
      desc = NULL;
    }
  }
#endif
 
  if ( (0 == port) &&
       (NULL == unixpath) )
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Have neither PORT nor UNIXPATH for service `%s', but one is required\n",
         service_name);
    GNUNET_free (hostname);
    return GNUNET_SYSERR;
  }
  if (0 == port)
  {
    saddrs = GNUNET_new_array (2, struct sockaddr *);
    saddrlens = GNUNET_new_array (2, socklen_t);
    add_unixpath (saddrs, saddrlens, unixpath);
    GNUNET_free (unixpath);
    GNUNET_free (hostname);
    *addrs = saddrs;
    *addr_lens = saddrlens;
    return 1;
  }
 
  if (NULL != hostname)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Resolving `%s' since that is where `%s' will bind to.\n",
         hostname,
         service_name);
    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))) ||
        (NULL == res))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Failed to resolve `%s': %s\n"),
           hostname,
           gai_strerror (ret));
      GNUNET_free (hostname);
      GNUNET_free (unixpath);
      return GNUNET_SYSERR;
    }
    next = res;
    i = 0;
    while (NULL != (pos = next))
    {
      next = pos->ai_next;
      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);
      freeaddrinfo (res);
      GNUNET_free (hostname);
      GNUNET_free (unixpath);
      return GNUNET_SYSERR;
    }
    resi = i;
    if (NULL != unixpath)
      resi++;
    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);
      i++;
    }
    next = res;
    while (NULL != (pos = next))
    {
      next = pos->ai_next;
      if ((disablev6) && (AF_INET6 == pos->ai_family))
        continue;
      if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol))
        continue;     /* not TCP */
      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));
      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]);
        GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
        ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
      }
      else
      {
        GNUNET_assert (AF_INET6 == pos->ai_family);
        GNUNET_assert (sizeof(struct sockaddr_in6) == pos->ai_addrlen);
        saddrlens[i] = pos->ai_addrlen;
        saddrs[i] = GNUNET_malloc (saddrlens[i]);
        GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
        ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
      }
      i++;
    }
    GNUNET_free (hostname);
    freeaddrinfo (res);
    resi = i;
  }
  else
  {
    /* will bind against everything, just set port */
    if (disablev6)
    {
      /* V4-only */
      resi = 1;
      if (NULL != unixpath)
        resi++;
      i = 0;
      saddrs = GNUNET_new_array (resi + 1, struct sockaddr *);
      saddrlens = GNUNET_new_array (resi + 1, socklen_t);
      if (NULL != unixpath)
      {
        add_unixpath (saddrs, saddrlens, unixpath);
        i++;
      }
      saddrlens[i] = sizeof(struct sockaddr_in);
      saddrs[i] = GNUNET_malloc (saddrlens[i]);
#if HAVE_SOCKADDR_IN_SIN_LEN
      ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i];
#endif
      ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
      ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
    }
    else
    {
      /* dual stack */
      resi = 2;
      if (NULL != unixpath)
        resi++;
      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);
        i++;
      }
      saddrlens[i] = sizeof(struct sockaddr_in6);
      saddrs[i] = GNUNET_malloc (saddrlens[i]);
#if HAVE_SOCKADDR_IN_SIN_LEN
      ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0];
#endif
      ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6;
      ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
      i++;
      saddrlens[i] = sizeof(struct sockaddr_in);
      saddrs[i] = GNUNET_malloc (saddrlens[i]);
#if HAVE_SOCKADDR_IN_SIN_LEN
      ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1];
#endif
      ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
      ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
    }
  }
  GNUNET_free (unixpath);
  *addrs = saddrs;
  *addr_lens = saddrlens;
  return resi;
}
 
 
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' */
      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");
      else
        LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "bind");
      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;
}
 
 
static enum GNUNET_GenericReturnValue
setup_service (const struct GNUNET_OS_ProjectData *pd,
               struct GNUNET_SERVICE_Handle *sh)
{
  int tolerant;
  struct GNUNET_NETWORK_Handle **csocks = NULL;
  struct GNUNET_NETWORK_Handle **lsocks;
  const char *nfds;
  const char *fdns;
  unsigned int cnt;
  int flags;
  char dummy;
 
  if (GNUNET_CONFIGURATION_have_value (sh->cfg,
                                       sh->service_name,
                                       "TOLERANT"))
  {
    if (GNUNET_SYSERR ==
        (tolerant = 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",
           sh->service_name);
      return GNUNET_SYSERR;
    }
  }
  else
    tolerant = GNUNET_NO;
 
  lsocks = NULL;
  errno = 0;
  if ( (NULL != (nfds = getenv ("LISTEN_FDS"))) &&
       (NULL != (fdns = getenv ("LISTEN_FDNAMES"))) &&
       (1 == sscanf (nfds,
                     "%u%c",
                     &cnt,
                     &dummy)) &&
       (cnt > 0) &&
       (cnt < FD_SETSIZE) )
  {
    char *fdnames;
    unsigned int pos;
 
    lsocks = GNUNET_new_array (cnt + 1,
                               struct GNUNET_NETWORK_Handle *);
    fdnames = GNUNET_strdup (fdns);
    pos = 0;
    for (const char *tok = strtok (fdnames,
                                   ":");
         NULL != tok;
         tok = strtok (NULL, ":"))
    {
      unsigned int fd;
 
      if (pos == cnt)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "More than LISTEN_FDS sockets given in LISTEN_FDNAMES\n");
        break;
      }
      if (1 != sscanf (tok,
                       "%u%c",
                       &fd,
                       &dummy))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "Malformed socket given in LISTEN_FDNAMES than in LISTEN_FDS\n");
        break;
      }
      if (fd >= FD_SETSIZE)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "Socket given in LISTEN_FDNAMES outside of select()able range\n");
        break;
      }
      flags = fcntl ((int) fd,
                     F_GETFD);
      if ((flags < 0) ||
          (0 != (flags & FD_CLOEXEC)) ||
          (NULL == (lsocks[pos] = GNUNET_NETWORK_socket_box_native ((int) fd))))
      {
        LOG (GNUNET_ERROR_TYPE_ERROR,
             "Could not access pre-bound socket %u\n",
             fd);
        break;
      }
      pos++;
    }
    if (0 == pos)
    {
      for (unsigned int i=0; i<cnt; i++)
        GNUNET_break (GNUNET_OK ==
                      GNUNET_NETWORK_socket_close (lsocks[i]));
      GNUNET_free (lsocks);
    }
    unsetenv ("LISTEN_FDS");
    cnt = pos;
  }
  if ( (0 != (GNUNET_SERVICE_OPTION_CLOSE_LSOCKS & sh->options)) &&
       (NULL != lsocks) )
  {
    csocks = lsocks;
    lsocks = NULL;
  }
 
  if (NULL != lsocks)
  {
    /* listen only on inherited sockets if we have any */
    for (struct GNUNET_NETWORK_Handle **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)
    {
      GNUNET_free (csocks);
      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 (addrlens);
    GNUNET_free (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");
      GNUNET_free (csocks);
      return GNUNET_SYSERR;
    }
  }
  if (NULL != csocks)
  {
    /* close inherited sockets to signal parent that we are ready */
    for (struct GNUNET_NETWORK_Handle **ls = csocks; NULL != *ls; ls++)
      GNUNET_NETWORK_socket_close (*ls);
    GNUNET_free (csocks);
  }
  sh->require_found = (GNUNET_NO == tolerant);
  sh->match_uid = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
                                                        sh->service_name,
                                                        "UNIX_MATCH_UID");
  sh->match_gid = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
                                                        sh->service_name,
                                                        "UNIX_MATCH_GID");
  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;
}
 
 
static char *
get_user_name (struct GNUNET_SERVICE_Handle *sh)
{
  char *un;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (sh->cfg,
                                               sh->service_name,
                                               "USERNAME",
                                               &un))
    return NULL;
  return un;
}
 
 
static enum GNUNET_GenericReturnValue
set_user_id (struct GNUNET_SERVICE_Handle *sh)
{
  char *user;
  struct passwd *pws;
 
  if (NULL == (user = get_user_name (sh)))
    return GNUNET_OK; /* keep */
  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)))
  {
    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_free (user);
  return GNUNET_OK;
}
 
 
static char *
get_pid_file_name (struct GNUNET_SERVICE_Handle *sh)
{
  char *pif;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (sh->cfg,
                                               sh->service_name,
                                               "PIDFILE",
                                               &pif))
    return NULL;
  return pif;
}
 
 
static void
pid_file_delete (struct GNUNET_SERVICE_Handle *sh)
{
  char *pif = get_pid_file_name (sh);
 
  if (NULL == pif)
    return; /* no PID file */
  if (0 != unlink (pif))
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
                       "unlink",
                       pif);
  GNUNET_free (pif);
}
 
 
static enum GNUNET_GenericReturnValue
detach_terminal (struct GNUNET_SERVICE_Handle *sh)
{
  pid_t pid;
  int nullfd;
  int filedes[2];
 
  if (0 != pipe (filedes))
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                  "pipe");
    return GNUNET_SYSERR;
  }
  pid = fork ();
  if (pid < 0)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                  "fork");
    return GNUNET_SYSERR;
  }
  if (0 != pid)
  {
    /* Parent */
    char c;
 
    GNUNET_break (0 == close (filedes[1]));
    c = 'X';
    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"));
      break;
 
    case 'S':
      LOG (GNUNET_ERROR_TYPE_INFO,
           _ ("Service process could not initialize server function\n"));
      break;
 
    case 'X':
      LOG (GNUNET_ERROR_TYPE_INFO,
           _ ("Service process failed to report status\n"));
      break;
    }
    exit (1);  /* child reported error */
  }
  GNUNET_break (0 == close (0));
  GNUNET_break (0 == close (1));
  GNUNET_break (0 == close (filedes[0]));
  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))
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
    (void) close (nullfd);
    return GNUNET_SYSERR;
  }
  (void) close (nullfd);
  /* Detach from controlling terminal */
  pid = setsid ();
  if (-1 == pid)
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                  "setsid");
  sh->ready_confirm_fd = filedes[1];
 
  return GNUNET_OK;
}
 
 
static void
teardown_service (struct GNUNET_SERVICE_Handle *sh)
{
  struct ServiceListenContext *slc;
 
  GNUNET_free (sh->v4_denied);
  GNUNET_free (sh->v6_denied);
  GNUNET_free (sh->v4_allowed);
  GNUNET_free (sh->v6_allowed);
  while (NULL != (slc = sh->slc_head))
  {
    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);
  }
}
 
 
static void
return_agpl (void *cls,
             const struct GNUNET_MessageHeader *msg)
{
  struct GNUNET_SERVICE_Client *client = cls;
  const struct GNUNET_OS_ProjectData *pd = client->sh->pd;
  struct GNUNET_MQ_Handle *mq;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *res;
  size_t slen;
 
  (void) msg;
  slen = strlen (pd->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);
}
 
 
struct GNUNET_SERVICE_Handle *
GNUNET_SERVICE_start (const struct GNUNET_OS_ProjectData *pd,
                      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->pd = pd;
  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 (pd,
                     sh))
  {
    GNUNET_free (sh->handlers);
    GNUNET_free (sh);
    return NULL;
  }
  do_resume (sh,
             SUSPEND_STATE_NONE);
  return sh;
}
 
 
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_CONTAINER_DLL_remove (sh->clients_head,
                               sh->clients_tail,
                               c);
  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 (! c->persist)
  {
    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)) &&
      (! have_non_monitor_clients (sh)))
    GNUNET_SERVICE_shutdown (sh);
}
 
 
void
GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Handle *srv)
{
  struct GNUNET_SERVICE_Client *client;
 
  GNUNET_SERVICE_suspend (srv);
  while (NULL != (client = srv->clients_head))
  {
    if (NULL == client->drop_task)
      GNUNET_SERVICE_client_drop (client);
    GNUNET_SCHEDULER_cancel (client->drop_task);
    finish_client_drop (client);
  }
  teardown_service (srv);
  GNUNET_free (srv->handlers);
  GNUNET_free (srv);
}
 
 
int
GNUNET_SERVICE_run_ (const struct GNUNET_OS_ProjectData *pd,
                     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;
 
#if ENABLE_NLS
  char *path;
#endif
  char *cfg_filename;
  char *opt_cfg_filename;
  char *loglev;
  const char *xdg;
  char *logfile;
  int do_daemonize;
  unsigned long long skew_offset;
  unsigned long long skew_variance;
  long long clock_offset;
  struct GNUNET_CONFIGURATION_Handle *cfg;
  int ret;
  int err;
  struct GNUNET_GETOPT_CommandLineOption service_options[] = {
    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 (pd,
                               NULL),
    GNUNET_GETOPT_option_loglevel (&loglev),
    GNUNET_GETOPT_option_logfile (&logfile),
    GNUNET_GETOPT_option_version (pd->version),
    GNUNET_GETOPT_OPTION_END
  };
 
  err = 1;
  memset (&sh, 0, sizeof(sh));
  xdg = getenv ("XDG_CONFIG_HOME");
  if (NULL != xdg)
    GNUNET_asprintf (&cfg_filename,
                     "%s%s%s",
                     xdg,
                     DIR_SEPARATOR_STR,
                     pd->config_file);
  else
    cfg_filename = GNUNET_strdup (pd->user_config_file);
  sh.pd = pd;
  sh.ready_confirm_fd = -1;
  sh.options = options;
  sh.cfg = cfg = GNUNET_CONFIGURATION_create (pd);
  sh.service_init_cb = service_init_cb;
  sh.connect_cb = connect_cb;
  sh.disconnect_cb = disconnect_cb;
  sh.cb_cls = cls;
  sh.handlers = (NULL == pd->agpl_url)
                ? GNUNET_MQ_copy_handlers (handlers)
                : GNUNET_MQ_copy_handlers2 (handlers,
                                            &return_agpl,
                                            NULL);
  sh.service_name = service_name;
  /* setup subsystems */
  loglev = NULL;
  logfile = NULL;
  opt_cfg_filename = NULL;
  do_daemonize = 0;
#if ENABLE_NLS
  if (NULL != pd->gettext_domain)
  {
    setlocale (LC_ALL, "");
    path = (NULL == pd->gettext_path)
      ? GNUNET_OS_installation_get_path (pd,
                                         GNUNET_OS_IPK_LOCALEDIR)
      : GNUNET_strdup (pd->gettext_path);
    if (NULL != path)
    {
      bindtextdomain (pd->gettext_domain, path);
      GNUNET_free (path);
    }
    textdomain (pd->gettext_domain);
  }
#endif
  ret = GNUNET_GETOPT_run (service_name,
                           service_options,
                           argc,
                           argv);
  if (GNUNET_SYSERR == ret)
    goto shutdown;
  if (GNUNET_NO == ret)
  {
    err = 0;
    goto shutdown;
  }
  if (GNUNET_OK != GNUNET_log_setup (service_name,
                                     loglev,
                                     logfile))
  {
    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_filename);
      goto shutdown;
    }
  }
  else
  {
    if (GNUNET_YES ==
        GNUNET_DISK_file_test (cfg_filename))
    {
      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 (GNUNET_OK !=
      setup_service (pd,
                     &sh))
    goto shutdown;
  if ( (1 == do_daemonize) &&
       (GNUNET_OK !=
        detach_terminal (&sh)) )
  {
    GNUNET_break (0);
    goto shutdown;
  }
  if (GNUNET_OK != set_user_id (&sh))
    goto shutdown;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Service `%s' runs with configuration from `%s'\n",
       service_name,
       (NULL != opt_cfg_filename) ? opt_cfg_filename : cfg_filename);
  if ( (GNUNET_OK ==
        GNUNET_CONFIGURATION_get_value_number (sh.cfg,
                                               "TESTING",
                                               "SKEW_OFFSET",
                                               &skew_offset)) &&
       (GNUNET_OK ==
        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 %lld ms\n",
         (long long) clock_offset);
  }
  GNUNET_RESOLVER_connect (sh.cfg);
 
  /* actually run service */
  err = 0;
  GNUNET_SCHEDULER_run (&service_main, &sh);
  /* shutdown */
  if (1 == do_daemonize)
    pid_file_delete (&sh);
 
shutdown:
  if (-1 != sh.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));
  }
  teardown_service (&sh);
  GNUNET_free (sh.handlers);
  GNUNET_SPEEDUP_stop_ ();
  GNUNET_CONFIGURATION_destroy (cfg);
  GNUNET_free (logfile);
  GNUNET_free (loglev);
  GNUNET_free (cfg_filename);
  GNUNET_free (opt_cfg_filename);
 
  return err ? GNUNET_SYSERR : 0;
}
 
 
struct ServiceHandleList
{
  /* DLL */
  struct ServiceHandleList *prev;
 
  /* DLL */
  struct ServiceHandleList *next;
 
  /* Handle to the service to launch */
  struct GNUNET_SERVICE_Handle *sh;
};
 
/* The service list */
static struct ServiceHandleList *hll_head;
 
/* The service list */
static struct ServiceHandleList *hll_tail;
 
 
int
GNUNET_SERVICE_register_ (const struct GNUNET_OS_ProjectData *pd,
                          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 ServiceHandleList *hle;
  struct GNUNET_SERVICE_Handle *sh = GNUNET_new (struct GNUNET_SERVICE_Handle);
 
  sh->pd = pd;
  sh->ready_confirm_fd = -1;
  sh->options = options;
  sh->service_init_cb = service_init_cb;
  sh->connect_cb = connect_cb;
  sh->disconnect_cb = disconnect_cb;
  sh->cb_cls = cls;
  sh->handlers = (NULL == pd->agpl_url)
                ? GNUNET_MQ_copy_handlers (handlers)
                : GNUNET_MQ_copy_handlers2 (handlers, &return_agpl, NULL);
  sh->service_name = service_name;
  hle = GNUNET_new (struct ServiceHandleList);
  hle->sh = sh;
  GNUNET_CONTAINER_DLL_insert (hll_head,
                               hll_tail,
                               hle);
  return 0;
}
 
 
static void
do_registered_services_shutdown (void *cls)
{
  while (NULL != hll_head)
  {
    struct ServiceHandleList *shl = hll_head;
    struct GNUNET_SERVICE_Handle *sh = shl->sh;
 
    GNUNET_CONTAINER_DLL_remove (hll_head,
                                 hll_tail,
                                 shl);
    GNUNET_free (shl);
    if (-1 != sh->ready_confirm_fd)
    {
      if (1 != write (sh->ready_confirm_fd, "S", 1))
        LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
                      "write");
      GNUNET_break (0 ==
                    close (sh->ready_confirm_fd));
    }
    teardown_service (sh);
    GNUNET_free (sh->handlers);
    GNUNET_free (sh);
  }
}
 
 
struct LaunchContext
{
  struct GNUNET_CONFIGURATION_Handle *cfg;
  const struct GNUNET_OS_ProjectData *pd;
};
 
 
static void
launch_registered_services (void *cls)
{
  struct LaunchContext *lc = cls;
  struct GNUNET_CONFIGURATION_Handle *cfg = lc->cfg;
  const struct GNUNET_OS_ProjectData *pd = lc->pd;
 
  for (struct ServiceHandleList *shl = hll_head;
       NULL != shl;
       shl = shl->next)
  {
    shl->sh->cfg = cfg;
    if (GNUNET_OK !=
        setup_service (pd,
                       shl->sh))
      continue;
    if (GNUNET_OK !=
        set_user_id (shl->sh))
      continue;
    GNUNET_SCHEDULER_add_now (&service_main,
                              shl->sh);
  }
  GNUNET_SCHEDULER_add_shutdown (&do_registered_services_shutdown,
                                 NULL);
}
 
 
void
GNUNET_SERVICE_main (const struct GNUNET_OS_ProjectData *pd,
                     int argc,
                     char *const *argv,
                     struct GNUNET_CONFIGURATION_Handle *cfg,
                     enum GNUNET_GenericReturnValue with_scheduler)
{
  struct LaunchContext lc = {
    .pd = pd,
    .cfg = cfg
  };
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Entering GNUNET_SERVICE_main\n");
  if (GNUNET_YES == with_scheduler)
  {
    if (GNUNET_YES !=
        GNUNET_PROGRAM_conf_and_options (pd,
                                         argc,
                                         argv,
                                         cfg))
      return;
    GNUNET_SCHEDULER_run (&launch_registered_services,
                          &lc);
  }
  else
  {
    launch_registered_services (&lc);
    GNUNET_RESOLVER_connect (cfg);
  }
}
 
 
void
GNUNET_SERVICE_suspend (struct GNUNET_SERVICE_Handle *sh)
{
  do_suspend (sh,
              SUSPEND_STATE_APP);
}
 
 
void
GNUNET_SERVICE_resume (struct GNUNET_SERVICE_Handle *sh)
{
  do_resume (sh,
             SUSPEND_STATE_APP);
}
 
 
static void
resume_client_receive (void *cls)
{
  struct GNUNET_SERVICE_Client *c = cls;
  int ret;
 
  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)
  {
    if (NULL == c->drop_task)
      GNUNET_SERVICE_client_drop (c);
    return;
  }
  if (GNUNET_NO == ret)
    return; /* done processing, wait for more later */
  GNUNET_assert (GNUNET_OK == ret);
  if (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);
}
 
 
void
GNUNET_SERVICE_client_continue (struct GNUNET_SERVICE_Client *c)
{
  GNUNET_assert (NULL == c->drop_task);
  GNUNET_assert (c->needs_continue);
  GNUNET_assert (NULL == c->recv_task);
  c->needs_continue = false;
  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);
}
 
 
void
GNUNET_SERVICE_client_disable_continue_warning (struct GNUNET_SERVICE_Client *c)
{
  GNUNET_break (NULL != c->warn_task);
  if (NULL != c->warn_task)
  {
    GNUNET_SCHEDULER_cancel (c->warn_task);
    c->warn_task = NULL;
  }
}
 
 
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
  GNUNET_assert (NULL == c->drop_task);
  if (NULL != sh->disconnect_cb)
    sh->disconnect_cb (sh->cb_cls,
                       c,
                       c->user_context);
  if (NULL != c->warn_task)
  {
    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;
  }
  c->drop_task = GNUNET_SCHEDULER_add_now (&finish_client_drop,
                                           c);
}
 
 
void
GNUNET_SERVICE_shutdown (struct GNUNET_SERVICE_Handle *sh)
{
  if (0 == (sh->suspend_state & SUSPEND_STATE_SHUTDOWN))
    do_suspend (sh,
                SUSPEND_STATE_SHUTDOWN);
  for (struct GNUNET_SERVICE_Client *client = sh->clients_head;
       NULL != client;
       client = client->next)
  {
    if (NULL == client->drop_task)
      GNUNET_SERVICE_client_drop (client);
  }
}
 
 
void
GNUNET_SERVICE_client_mark_monitor (struct GNUNET_SERVICE_Client *c)
{
  c->is_monitor = true;
  if (((0 != (SUSPEND_STATE_SHUTDOWN & c->sh->suspend_state)) &&
       (! have_non_monitor_clients (c->sh))))
    GNUNET_SERVICE_shutdown (c->sh);
}
 
 
void
GNUNET_SERVICE_client_persist (struct GNUNET_SERVICE_Client *c)
{
  c->persist = true;
}
 
 
struct GNUNET_MQ_Handle *
GNUNET_SERVICE_client_get_mq (struct GNUNET_SERVICE_Client *c)
{
  return c->mq;
}
 
 
/* end of service.c */

LOG_STRERROR_FILE

#define LOG_STRERROR_FILE	(		kind,
			syscall,
			filename
	)		GNUNET_log_from_strerror_file (kind, "util-service", syscall, filename)

Definition at line 44 of file service.c.

Enumeration Type Documentation

SuspendReason

enum SuspendReason

Reasons why we might be suspended.

Enumerator
SUSPEND_STATE_NONE	We are running normally.
SUSPEND_STATE_APP	Application requested it.
SUSPEND_STATE_EMFILE	OS ran out of file descriptors.
SUSPEND_STATE_APP_AND_EMFILE	Both reasons, APP and EMFILE apply.
SUSPEND_STATE_SHUTDOWN	Suspension because service was permanently shutdown.

Definition at line 83 of file service.c.

{
  SUSPEND_STATE_NONE = 0,
 
  SUSPEND_STATE_APP = 1,
 
  SUSPEND_STATE_EMFILE = 2,
 
  SUSPEND_STATE_APP_AND_EMFILE = 3,
 
  SUSPEND_STATE_SHUTDOWN = 4
};

Function Documentation

have_non_monitor_clients()

static enum GNUNET_GenericReturnValue have_non_monitor_clients ( struct GNUNET_SERVICE_Handle *  sh )

static

Check if any of the clients we have left are unrelated to monitoring.

Parameters

sh	service to check clients for

Returns

true if we have non-monitoring clients left

Definition at line 359 of file service.c.

{
  for (struct GNUNET_SERVICE_Client *client = sh->clients_head;
       NULL != client;
       client = client->next)
  {
    if (NULL != client->drop_task)
      continue;
    if (client->is_monitor)
      continue;
    return true;
  }
  return false;
}

References sh.

Referenced by finish_client_drop(), GNUNET_SERVICE_client_mark_monitor(), and service_shutdown().

Here is the caller graph for this function:

do_suspend()

static void do_suspend ( struct GNUNET_SERVICE_Handle *  sh, enum SuspendReason  sr  )

static

Suspend accepting connections from the listen socket temporarily.

Resume activity using do_resume.

Parameters

sh	service to stop accepting connections.
sr	reason for suspending accepting connections

Definition at line 383 of file service.c.

{
  GNUNET_assert (0 == (sh->suspend_state & sr));
  sh->suspend_state |= sr;
  for (struct ServiceListenContext *slc = sh->slc_head;
       NULL != slc;
       slc = slc->next)
  {
    if (NULL != slc->listen_task)
    {
      GNUNET_SCHEDULER_cancel (slc->listen_task);
      slc->listen_task = NULL;
    }
  }
}

References GNUNET_assert, GNUNET_SCHEDULER_cancel(), and sh.

Referenced by accept_client(), GNUNET_SERVICE_shutdown(), GNUNET_SERVICE_suspend(), and service_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

service_shutdown()

static void service_shutdown ( void *  cls )

static

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.

Parameters

cls	our struct GNUNET_SERVICE_Handle

Definition at line 410 of file service.c.

{
  struct GNUNET_SERVICE_Handle *sh = cls;
 
  switch (sh->options & GNUNET_SERVICE_OPTION_SHUTDOWN_BITMASK)
  {
  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 (! have_non_monitor_clients (sh))
      GNUNET_SERVICE_shutdown (sh);
    break;
  }
}

References do_suspend(), GNUNET_assert, GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN, GNUNET_SERVICE_OPTION_NONE, GNUNET_SERVICE_OPTION_SHUTDOWN_BITMASK, GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN, GNUNET_SERVICE_shutdown(), have_non_monitor_clients(), sh, and SUSPEND_STATE_SHUTDOWN.

Referenced by service_main().

Here is the call graph for this function:

Here is the caller graph for this function:

check_ipv4_listed()

static bool check_ipv4_listed ( const struct GNUNET_STRINGS_IPv4NetworkPolicy *  list, const struct in_addr *  add  )

static

Check if the given IP address is in the list of IP addresses.

Parameters

list	a list of networks
add	the IP to check (in network byte order)

Returns

false if the IP is not in the list, true if it it is

Definition at line 442 of file service.c.

{
  for (unsigned int i = 0;
       0 != list[i].network.s_addr;
       i++)
  {
    if ( (add->s_addr & list[i].netmask.s_addr) ==
         (list[i].network.s_addr & list[i].netmask.s_addr) )
      return true;
  }
  return false;
}

References add, and list.

Referenced by accept_client().

Here is the caller graph for this function:

check_ipv6_listed()

static bool check_ipv6_listed ( const struct GNUNET_STRINGS_IPv6NetworkPolicy *  list, const struct in6_addr *  ip  )

static

Check if the given IP address is in the list of IP addresses.

Parameters

list	a list of networks
ip	the IP to check (in network byte order)

Returns

false if the IP is not in the list, true if it it is

Definition at line 465 of file service.c.

{
  for (unsigned int i = 0;
       ! GNUNET_is_zero (&list[i].network);
       i++)
  {
    bool match = true;
 
    for (unsigned int j = 0; j < sizeof(struct in6_addr) / sizeof(int); j++)
      if (((((int *) ip)[j] & ((int *) &list[i].netmask)[j])) !=
          (((int *) &list[i].network)[j] & ((int *) &list[i].netmask)[j]))
      {
        match = false;
        break;
      }
    if (match)
      return true;
  }
  return false;
}

References GNUNET_is_zero, and list.

Referenced by accept_client().

Here is the caller graph for this function:

do_send()

static void do_send ( void *  cls )

static

Task run when we are ready to transmit data to the client.

Parameters

cls	the struct GNUNET_SERVICE_Client * to send to

Definition at line 495 of file service.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  ssize_t ret;
  size_t left;
  const char *buf;
 
  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);
}

References do_send(), GNUNET_SERVICE_Client::drop_task, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log_strerror, GNUNET_MQ_ERROR_WRITE, GNUNET_MQ_impl_send_continue(), GNUNET_MQ_impl_send_in_flight(), GNUNET_MQ_inject_error(), GNUNET_NETWORK_socket_send(), GNUNET_SCHEDULER_add_write_net(), GNUNET_TIME_UNIT_FOREVER_REL, LOG, GNUNET_SERVICE_Client::mq, GNUNET_SERVICE_Client::msg, GNUNET_SERVICE_Client::msg_pos, ret, GNUNET_SERVICE_Client::send_task, GNUNET_MessageHeader::size, GNUNET_SERVICE_Client::sock, and GNUNET_MessageHeader::type.

Referenced by do_send(), and service_mq_send().

Here is the call graph for this function:

Here is the caller graph for this function:

service_mq_send()

static void service_mq_send ( struct GNUNET_MQ_Handle *  mq, const struct GNUNET_MessageHeader *  msg, void *  impl_state  )

static

Signature of functions implementing the sending functionality of a message queue.

Parameters

mq	the message queue
msg	the message to send
impl_state	our struct GNUNET_SERVICE_Client *

Definition at line 564 of file service.c.

{
  struct GNUNET_SERVICE_Client *client = impl_state;
 
  (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_now (&do_send,
                                                client);
}

References do_send(), GNUNET_SERVICE_Client::drop_task, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SCHEDULER_add_now(), LOG, mq, msg, GNUNET_SERVICE_Client::msg, GNUNET_SERVICE_Client::msg_pos, GNUNET_SERVICE_Client::send_task, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by start_client().

Here is the call graph for this function:

Here is the caller graph for this function:

service_mq_cancel()

static void service_mq_cancel ( struct GNUNET_MQ_Handle *  mq, void *  impl_state  )

static

Implementation function that cancels the currently sent message.

Parameters

mq	message queue
impl_state	state specific to the implementation

Definition at line 592 of file service.c.

{
  struct GNUNET_SERVICE_Client *client = impl_state;
 
  (void) mq;
  GNUNET_assert (0 == client->msg_pos);
  client->msg = NULL;
  GNUNET_SCHEDULER_cancel (client->send_task);
  client->send_task = NULL;
}

References GNUNET_assert, GNUNET_SCHEDULER_cancel(), mq, GNUNET_SERVICE_Client::msg, GNUNET_SERVICE_Client::msg_pos, and GNUNET_SERVICE_Client::send_task.

Referenced by start_client().

Here is the call graph for this function:

Here is the caller graph for this function:

service_mq_error_handler()

static void service_mq_error_handler ( void *  cls, enum GNUNET_MQ_Error  error  )

static

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.

Parameters

cls	closure with our struct GNUNET_SERVICE_Client
error	error code

Definition at line 615 of file service.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_SERVICE_Handle *sh = client->sh;
 
  if ( (GNUNET_MQ_ERROR_NO_MATCH == error) &&
       (! 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);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_ERROR_NO_MATCH, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), sh, GNUNET_SERVICE_Client::sh, and GNUNET_SERVICE_Client::warn_type.

Referenced by start_client().

Here is the call graph for this function:

Here is the caller graph for this function:

warn_no_client_continue()

static void warn_no_client_continue ( void *  cls )

static

Task run to warn about missing calls to GNUNET_SERVICE_client_continue().

Parameters

cls	our struct GNUNET_SERVICE_Client * to process more requests from

Definition at line 640 of file service.c.

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

References _, GNUNET_break, GNUNET_ERROR_TYPE_WARNING, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_UNIT_MINUTES, GNUNET_YES, LOG, warn_no_client_continue(), GNUNET_SERVICE_Client::warn_start, GNUNET_SERVICE_Client::warn_task, and GNUNET_SERVICE_Client::warn_type.

Referenced by service_client_mst_cb(), and warn_no_client_continue().

Here is the call graph for this function:

Here is the caller graph for this function:

service_client_mst_cb()

static int service_client_mst_cb ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

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.

Parameters

cls	closure with the struct GNUNET_SERVICE_Client *
message	the actual message

Returns

GNUNET_OK on success, GNUNET_SYSERR if the client was dropped

Definition at line 673 of file service.c.

{
  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 (! client->needs_continue);
  client->needs_continue = true;
  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;
}

References GNUNET_SERVICE_Client::drop_task, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_inject_message(), GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_MINUTES, LOG, GNUNET_SERVICE_Client::mq, GNUNET_SERVICE_Client::needs_continue, GNUNET_MessageHeader::size, GNUNET_MessageHeader::type, warn_no_client_continue(), GNUNET_SERVICE_Client::warn_start, GNUNET_SERVICE_Client::warn_task, and GNUNET_SERVICE_Client::warn_type.

Referenced by start_client().

Here is the call graph for this function:

Here is the caller graph for this function:

service_client_recv()

static void service_client_recv ( void *  cls )

static

A client sent us data.

Receive and process it. If we are done, reschedule this task.

Parameters

cls	the struct GNUNET_SERVICE_Client that sent us data.

Definition at line 704 of file service.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  enum GNUNET_GenericReturnValue ret;
 
  client->recv_task = NULL;
  ret = GNUNET_MST_read (client->mst,
                         client->sock,
                         GNUNET_NO,
                         GNUNET_YES);
  if (GNUNET_SYSERR == ret)
  {
    /* client closed connection (or IO error) */
    if (NULL == client->drop_task)
    {
      GNUNET_assert (! client->needs_continue);
      GNUNET_SERVICE_client_drop (client);
    }
    return;
  }
  if (GNUNET_NO == ret)
    return; /* more messages in buffer, wait for application
               to be done processing */
  GNUNET_assert (GNUNET_OK == ret);
  if (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);
}

References GNUNET_SERVICE_Client::drop_task, GNUNET_assert, GNUNET_MST_read(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, GNUNET_SERVICE_Client::mst, GNUNET_SERVICE_Client::needs_continue, GNUNET_SERVICE_Client::recv_task, ret, service_client_recv(), and GNUNET_SERVICE_Client::sock.

Referenced by resume_client_receive(), service_client_recv(), and start_client().

Here is the call graph for this function:

Here is the caller graph for this function:

start_client()

static void start_client ( struct GNUNET_SERVICE_Handle *  sh, struct GNUNET_NETWORK_Handle *  csock  )

static

We have successfully accepted a connection from a client.

Now setup the client (with the scheduler) and tell the application.

Parameters

sh	service that accepted the client
csock	socket associated with the client

Definition at line 749 of file service.c.

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

References GNUNET_IDENTITY_Handle::cb_cls, GNUNET_CONTAINER_DLL_insert, GNUNET_MQ_queue_for_callbacks(), GNUNET_MQ_set_handlers_closure(), GNUNET_MST_create(), GNUNET_new, GNUNET_SCHEDULER_add_read_net(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_SERVICE_Client::mq, GNUNET_SERVICE_Client::mst, GNUNET_SERVICE_Client::recv_task, service_client_mst_cb(), service_client_recv(), service_mq_cancel(), service_mq_error_handler(), service_mq_send(), sh, GNUNET_SERVICE_Client::sh, GNUNET_SERVICE_Client::sock, and GNUNET_SERVICE_Client::user_context.

Referenced by accept_client().

Here is the call graph for this function:

Here is the caller graph for this function:

accept_client()

static void accept_client ( void *  cls )

static

We have a client.

Accept the incoming socket(s) (and reschedule the listen task).

Parameters

cls	the struct ServiceListenContext of the ready listen socket

Definition at line 786 of file service.c.

{
  struct ServiceListenContext *slc = cls;
  struct GNUNET_SERVICE_Handle *sh = slc->sh;
 
  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;
 
    case AF_UNIX:
      ok = GNUNET_OK;     /* controlled using file-system ACL now */
      break;
 
    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);
}

References _, accept_client(), check_ipv4_listed(), check_ipv6_listed(), do_suspend(), GNUNET_a2s(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log_strerror, GNUNET_NETWORK_socket_accept(), GNUNET_NETWORK_socket_close(), GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_TIME_UNIT_FOREVER_REL, ServiceListenContext::listen_socket, ServiceListenContext::listen_task, LOG, sh, ServiceListenContext::sh, start_client(), and SUSPEND_STATE_EMFILE.

Referenced by accept_client(), and do_resume().

Here is the call graph for this function:

Here is the caller graph for this function:

do_resume()

static void do_resume ( struct GNUNET_SERVICE_Handle *  sh, enum SuspendReason  sr  )

static

Resume accepting connections from the listen socket.

Parameters

sh	service to resume accepting connections.
sr	reason that is no longer causing the suspension, or SUSPEND_STATE_NONE on first startup

Definition at line 880 of file service.c.

{
  GNUNET_assert ((SUSPEND_STATE_NONE == sr) || (0 != (sh->suspend_state & sr)));
  sh->suspend_state -= sr;
  if (SUSPEND_STATE_NONE != sh->suspend_state)
    return;
  for (struct ServiceListenContext *slc = sh->slc_head;
       NULL != slc;
       slc = slc->next)
  {
    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);
  }
}

References accept_client(), GNUNET_assert, GNUNET_SCHEDULER_add_read_net(), GNUNET_TIME_UNIT_FOREVER_REL, sh, and SUSPEND_STATE_NONE.

Referenced by finish_client_drop(), GNUNET_SERVICE_resume(), GNUNET_SERVICE_start(), and service_main().

Here is the call graph for this function:

Here is the caller graph for this function:

service_main()

static void service_main ( void *  cls )

static

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.

Parameters

cls	our struct GNUNET_SERVICE_Handle

Definition at line 909 of file service.c.

{
  struct GNUNET_SERVICE_Handle *sh = cls;
 
  if (GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN !=
      (sh->options & GNUNET_SERVICE_OPTION_SHUTDOWN_BITMASK))
    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);
}

References GNUNET_IDENTITY_Handle::cb_cls, GNUNET_IDENTITY_Handle::cfg, do_resume(), GNUNET_break, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN, GNUNET_SERVICE_OPTION_SHUTDOWN_BITMASK, service_shutdown(), sh, and SUSPEND_STATE_NONE.

Referenced by GNUNET_SERVICE_run_(), and launch_registered_services().

Here is the call graph for this function:

Here is the caller graph for this function:

process_acl4()

static enum GNUNET_GenericReturnValue process_acl4 ( struct GNUNET_STRINGS_IPv4NetworkPolicy **  ret, struct GNUNET_SERVICE_Handle *  sh, const char *  option  )

static

Parse an IPv4 access control list.

Parameters

ret	location where to write the ACL (set)
sh	service context to use to get the configuration
option	name of the ACL option to parse

Returns

GNUNET_SYSERR on parse error, GNUNET_OK on success (including no ACL configured)

Definition at line 940 of file service.c.

{
  char *opt;
 
  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 (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,
         sh->service_name,
         option);
    GNUNET_free (opt);
    return GNUNET_SYSERR;
  }
  GNUNET_free (opt);
  return GNUNET_OK;
}

References _, GNUNET_IDENTITY_Handle::cfg, GNUNET_break, GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_have_value(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_OK, GNUNET_STRINGS_parse_ipv4_policy(), GNUNET_SYSERR, LOG, ret, and sh.

Referenced by setup_service().

Here is the call graph for this function:

Here is the caller graph for this function:

process_acl6()

static enum GNUNET_GenericReturnValue process_acl6 ( struct GNUNET_STRINGS_IPv6NetworkPolicy **  ret, struct GNUNET_SERVICE_Handle *  sh, const char *  option  )

static

Parse an IPv6 access control list.

Parameters

ret	location where to write the ACL (set)
sh	service context to use to get the configuration
option	name of the ACL option to parse

Returns

GNUNET_SYSERR on parse error, GNUNET_OK on success (including no ACL configured)

Definition at line 981 of file service.c.

{
  char *opt;
 
  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 (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,
         sh->service_name,
         option);
    GNUNET_free (opt);
    return GNUNET_SYSERR;
  }
  GNUNET_free (opt);
  return GNUNET_OK;
}

References _, GNUNET_IDENTITY_Handle::cfg, GNUNET_break, GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_have_value(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_OK, GNUNET_STRINGS_parse_ipv6_policy(), GNUNET_SYSERR, LOG, ret, and sh.

Referenced by setup_service().

Here is the call graph for this function:

Here is the caller graph for this function:

add_unixpath()

static void add_unixpath ( struct sockaddr **  saddrs, socklen_t *  saddrlens, const char *  unixpath  )

static

Add the given UNIX domain path as an address to the list (as the first entry).

Parameters

saddrs	array to update
saddrlens	where to store the address length
unixpath	path to add

Definition at line 1021 of file service.c.

{
#ifdef AF_UNIX
  struct sockaddr_un *un;
 
  un = GNUNET_new (struct sockaddr_un);
  un->sun_family = AF_UNIX;
  GNUNET_strlcpy (un->sun_path, unixpath, sizeof(un->sun_path));
#if HAVE_SOCKADDR_UN_SUN_LEN
  un->sun_len = (u_char) sizeof(struct sockaddr_un);
#endif
  *saddrs = (struct sockaddr *) un;
  *saddrlens = sizeof(struct sockaddr_un);
#else
  /* this function should never be called
   * unless AF_UNIX is defined! */
  GNUNET_assert (0);
#endif
}

References GNUNET_assert, GNUNET_new, and GNUNET_strlcpy().

Referenced by get_server_addresses().

Here is the call graph for this function:

Here is the caller graph for this function:

get_server_addresses()

static int get_server_addresses ( const char *  service_name, const struct GNUNET_CONFIGURATION_Handle *  cfg, struct sockaddr ***  addrs, socklen_t **  addr_lens  )

static

Get the list of addresses that a server for the given service should bind to.

Parameters

service_name	name of the service
cfg	configuration (which specifies the addresses)
addrs	set (call by reference) to an array of pointers to the addresses the server should bind to and listen on; the array will be NULL-terminated (on success)
addr_lens	set (call by reference) to an array of the lengths of the respective struct sockaddr struct in the addrs array (on success)

Returns

number of addresses found on success, GNUNET_SYSERR if the configuration did not specify reasonable finding information or if it specified a hostname that could not be resolved; GNUNET_NO if the number of addresses configured is zero (in this case, *addrs and *addr_lens will be set to NULL).

Definition at line 1065 of file service.c.

{
  bool disablev6;
  struct GNUNET_NETWORK_Handle *desc;
  unsigned long long port;
  char *unixpath;
  struct addrinfo hints;
  struct addrinfo *res;
  struct addrinfo *pos;
  struct addrinfo *next;
  unsigned int i;
  int resi;
  int ret;
  struct sockaddr **saddrs;
  socklen_t *saddrlens;
  char *hostname;
 
  *addrs = NULL;
  *addr_lens = NULL;
  desc = NULL;
  disablev6 = false;
  if ((GNUNET_NO ==
       GNUNET_NETWORK_test_pf (PF_INET6)) ||
      (GNUNET_YES ==
       GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                             service_name,
                                             "DISABLEV6")))
    disablev6 = true;
 
  port = 0;
  if (GNUNET_SYSERR ==
      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"),
         service_name);
  }
  if (port > 65535)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Require valid port number for service `%s' in configuration!\n"),
         service_name);
    return GNUNET_SYSERR;
  }
 
  hostname = NULL;
  GNUNET_break (GNUNET_SYSERR !=
                GNUNET_CONFIGURATION_get_value_string (cfg,
                                                       service_name,
                                                       "BINDTO",
                                                       &hostname));
 
  unixpath = NULL;
#ifdef AF_UNIX
  if ( (GNUNET_OK ==
        GNUNET_CONFIGURATION_get_value_filename (cfg,
                                                 service_name,
                                                 "UNIXPATH",
                                                 &unixpath)) &&
       (0 < strlen (unixpath)) )
  {
    /* probe UNIX support */
    struct sockaddr_un s_un;
 
    if (strlen (unixpath) >= sizeof(s_un.sun_path))
    {
      LOG (GNUNET_ERROR_TYPE_WARNING,
           "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);
    }
    if (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);
    if (NULL == desc)
    {
      if ((ENOBUFS == errno) ||
          (ENOMEM == errno) ||
          (ENFILE == errno) ||
          (EACCES == errno))
      {
        LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                      "socket");
        GNUNET_free (hostname);
        GNUNET_free (unixpath);
        return GNUNET_SYSERR;
      }
      LOG (GNUNET_ERROR_TYPE_WARNING,
           "Failed to create UNIX domain socket for service %s: %s\n",
           service_name,
           strerror (errno));
      GNUNET_free (unixpath);
      unixpath = NULL;
    }
    else
    {
      GNUNET_break (GNUNET_OK ==
                    GNUNET_NETWORK_socket_close (desc));
      desc = NULL;
    }
  }
#endif
 
  if ( (0 == port) &&
       (NULL == unixpath) )
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Have neither PORT nor UNIXPATH for service `%s', but one is required\n",
         service_name);
    GNUNET_free (hostname);
    return GNUNET_SYSERR;
  }
  if (0 == port)
  {
    saddrs = GNUNET_new_array (2, struct sockaddr *);
    saddrlens = GNUNET_new_array (2, socklen_t);
    add_unixpath (saddrs, saddrlens, unixpath);
    GNUNET_free (unixpath);
    GNUNET_free (hostname);
    *addrs = saddrs;
    *addr_lens = saddrlens;
    return 1;
  }
 
  if (NULL != hostname)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Resolving `%s' since that is where `%s' will bind to.\n",
         hostname,
         service_name);
    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))) ||
        (NULL == res))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Failed to resolve `%s': %s\n"),
           hostname,
           gai_strerror (ret));
      GNUNET_free (hostname);
      GNUNET_free (unixpath);
      return GNUNET_SYSERR;
    }
    next = res;
    i = 0;
    while (NULL != (pos = next))
    {
      next = pos->ai_next;
      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);
      freeaddrinfo (res);
      GNUNET_free (hostname);
      GNUNET_free (unixpath);
      return GNUNET_SYSERR;
    }
    resi = i;
    if (NULL != unixpath)
      resi++;
    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);
      i++;
    }
    next = res;
    while (NULL != (pos = next))
    {
      next = pos->ai_next;
      if ((disablev6) && (AF_INET6 == pos->ai_family))
        continue;
      if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol))
        continue;     /* not TCP */
      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));
      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]);
        GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
        ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
      }
      else
      {
        GNUNET_assert (AF_INET6 == pos->ai_family);
        GNUNET_assert (sizeof(struct sockaddr_in6) == pos->ai_addrlen);
        saddrlens[i] = pos->ai_addrlen;
        saddrs[i] = GNUNET_malloc (saddrlens[i]);
        GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
        ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
      }
      i++;
    }
    GNUNET_free (hostname);
    freeaddrinfo (res);
    resi = i;
  }
  else
  {
    /* will bind against everything, just set port */
    if (disablev6)
    {
      /* V4-only */
      resi = 1;
      if (NULL != unixpath)
        resi++;
      i = 0;
      saddrs = GNUNET_new_array (resi + 1, struct sockaddr *);
      saddrlens = GNUNET_new_array (resi + 1, socklen_t);
      if (NULL != unixpath)
      {
        add_unixpath (saddrs, saddrlens, unixpath);
        i++;
      }
      saddrlens[i] = sizeof(struct sockaddr_in);
      saddrs[i] = GNUNET_malloc (saddrlens[i]);
#if HAVE_SOCKADDR_IN_SIN_LEN
      ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i];
#endif
      ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
      ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
    }
    else
    {
      /* dual stack */
      resi = 2;
      if (NULL != unixpath)
        resi++;
      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);
        i++;
      }
      saddrlens[i] = sizeof(struct sockaddr_in6);
      saddrs[i] = GNUNET_malloc (saddrlens[i]);
#if HAVE_SOCKADDR_IN_SIN_LEN
      ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0];
#endif
      ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6;
      ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
      i++;
      saddrlens[i] = sizeof(struct sockaddr_in);
      saddrs[i] = GNUNET_malloc (saddrlens[i]);
#if HAVE_SOCKADDR_IN_SIN_LEN
      ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1];
#endif
      ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
      ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
    }
  }
  GNUNET_free (unixpath);
  *addrs = saddrs;
  *addr_lens = saddrlens;
  return resi;
}

References _, add_unixpath(), cfg, GNUNET_a2s(), GNUNET_assert, GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_DISK_directory_create_for_file(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_strerror_file, GNUNET_malloc, GNUNET_memcpy, GNUNET_NETWORK_shorten_unixpath(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_NETWORK_test_pf(), GNUNET_new_array, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, LOG, LOG_STRERROR, port, res, ret, and service_name.

Referenced by setup_service().

Here is the call graph for this function:

Here is the caller graph for this function:

open_listen_socket()

static struct GNUNET_NETWORK_Handle * open_listen_socket ( const struct sockaddr *  server_addr, socklen_t  socklen  )

static

Create and initialize a listen socket for the server.

Parameters

server_addr	address to listen on
socklen	length of server_addr

Returns

NULL on error, otherwise the listen socket

Definition at line 1367 of file service.c.

{
  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' */
      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");
      else
        LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "bind");
      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;
}

References _, GNUNET_a2s(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_NETWORK_socket_listen(), GNUNET_OK, LOG, LOG_STRERROR, and port.

Referenced by setup_service().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_service()

static enum GNUNET_GenericReturnValue setup_service ( const struct GNUNET_OS_ProjectData *  pd, struct GNUNET_SERVICE_Handle *  sh  )

static

Setup service handle.

Configuration may specify:

• PORT (where to bind to for TCP)
• UNIXPATH (where to bind to for UNIX domain sockets)
• 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)
• ACCEPT_FROM6 (only allow connections from specified IPv6 subnets)
• REJECT_FROM (disallow allow connections from specified IPv4 subnets)
• REJECT_FROM6 (disallow allow connections from specified IPv6 subnets)

Parameters

pd	project data to use for the service
sh	service context to initialize

Returns

GNUNET_OK if configuration succeeded

Definition at line 1476 of file service.c.

{
  int tolerant;
  struct GNUNET_NETWORK_Handle **csocks = NULL;
  struct GNUNET_NETWORK_Handle **lsocks;
  const char *nfds;
  const char *fdns;
  unsigned int cnt;
  int flags;
  char dummy;
 
  if (GNUNET_CONFIGURATION_have_value (sh->cfg,
                                       sh->service_name,
                                       "TOLERANT"))
  {
    if (GNUNET_SYSERR ==
        (tolerant = 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",
           sh->service_name);
      return GNUNET_SYSERR;
    }
  }
  else
    tolerant = GNUNET_NO;
 
  lsocks = NULL;
  errno = 0;
  if ( (NULL != (nfds = getenv ("LISTEN_FDS"))) &&
       (NULL != (fdns = getenv ("LISTEN_FDNAMES"))) &&
       (1 == sscanf (nfds,
                     "%u%c",
                     &cnt,
                     &dummy)) &&
       (cnt > 0) &&
       (cnt < FD_SETSIZE) )
  {
    char *fdnames;
    unsigned int pos;
 
    lsocks = GNUNET_new_array (cnt + 1,
                               struct GNUNET_NETWORK_Handle *);
    fdnames = GNUNET_strdup (fdns);
    pos = 0;
    for (const char *tok = strtok (fdnames,
                                   ":");
         NULL != tok;
         tok = strtok (NULL, ":"))
    {
      unsigned int fd;
 
      if (pos == cnt)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "More than LISTEN_FDS sockets given in LISTEN_FDNAMES\n");
        break;
      }
      if (1 != sscanf (tok,
                       "%u%c",
                       &fd,
                       &dummy))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "Malformed socket given in LISTEN_FDNAMES than in LISTEN_FDS\n");
        break;
      }
      if (fd >= FD_SETSIZE)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "Socket given in LISTEN_FDNAMES outside of select()able range\n");
        break;
      }
      flags = fcntl ((int) fd,
                     F_GETFD);
      if ((flags < 0) ||
          (0 != (flags & FD_CLOEXEC)) ||
          (NULL == (lsocks[pos] = GNUNET_NETWORK_socket_box_native ((int) fd))))
      {
        LOG (GNUNET_ERROR_TYPE_ERROR,
             "Could not access pre-bound socket %u\n",
             fd);
        break;
      }
      pos++;
    }
    if (0 == pos)
    {
      for (unsigned int i=0; i<cnt; i++)
        GNUNET_break (GNUNET_OK ==
                      GNUNET_NETWORK_socket_close (lsocks[i]));
      GNUNET_free (lsocks);
    }
    unsetenv ("LISTEN_FDS");
    cnt = pos;
  }
  if ( (0 != (GNUNET_SERVICE_OPTION_CLOSE_LSOCKS & sh->options)) &&
       (NULL != lsocks) )
  {
    csocks = lsocks;
    lsocks = NULL;
  }
 
  if (NULL != lsocks)
  {
    /* listen only on inherited sockets if we have any */
    for (struct GNUNET_NETWORK_Handle **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)
    {
      GNUNET_free (csocks);
      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 (addrlens);
    GNUNET_free (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");
      GNUNET_free (csocks);
      return GNUNET_SYSERR;
    }
  }
  if (NULL != csocks)
  {
    /* close inherited sockets to signal parent that we are ready */
    for (struct GNUNET_NETWORK_Handle **ls = csocks; NULL != *ls; ls++)
      GNUNET_NETWORK_socket_close (*ls);
    GNUNET_free (csocks);
  }
  sh->require_found = (GNUNET_NO == tolerant);
  sh->match_uid = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
                                                        sh->service_name,
                                                        "UNIX_MATCH_UID");
  sh->match_gid = GNUNET_CONFIGURATION_get_value_yesno (sh->cfg,
                                                        sh->service_name,
                                                        "UNIX_MATCH_GID");
  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;
}

References _, GNUNET_IDENTITY_Handle::cfg, dummy, GNUNET_NETWORK_Handle::fd, get_server_addresses(), getenv(), GNUNET_break, GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONFIGURATION_have_value(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_strerror, GNUNET_NETWORK_socket_box_native(), GNUNET_NETWORK_socket_close(), GNUNET_new, GNUNET_new_array, GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_OPTION_CLOSE_LSOCKS, GNUNET_strdup, GNUNET_SYSERR, ServiceListenContext::listen_socket, LOG, ls, open_listen_socket(), process_acl4(), process_acl6(), sh, and ServiceListenContext::sh.

Referenced by GNUNET_SERVICE_run_(), GNUNET_SERVICE_start(), and launch_registered_services().

Here is the call graph for this function:

Here is the caller graph for this function:

get_user_name()

static char * get_user_name ( struct GNUNET_SERVICE_Handle *  sh )

static

Get the name of the user that'll be used to provide the service.

Parameters

sh	service context

Returns

value of the 'USERNAME' option

Definition at line 1676 of file service.c.

{
  char *un;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (sh->cfg,
                                               sh->service_name,
                                               "USERNAME",
                                               &un))
    return NULL;
  return un;
}

References GNUNET_IDENTITY_Handle::cfg, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_OK, and sh.

Referenced by set_user_id().

Here is the call graph for this function:

Here is the caller graph for this function:

set_user_id()

static enum GNUNET_GenericReturnValue set_user_id ( struct GNUNET_SERVICE_Handle *  sh )

static

Set user ID.

Parameters

sh	service context

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1697 of file service.c.

{
  char *user;
  struct passwd *pws;
 
  if (NULL == (user = get_user_name (sh)))
    return GNUNET_OK; /* keep */
  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)))
  {
    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_free (user);
  return GNUNET_OK;
}

References _, get_user_name(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_OK, GNUNET_SYSERR, LOG, and sh.

Referenced by GNUNET_SERVICE_run_(), and launch_registered_services().

Here is the call graph for this function:

Here is the caller graph for this function:

get_pid_file_name()

static char * get_pid_file_name ( struct GNUNET_SERVICE_Handle *  sh )

static

Get the name of the file where we will write the PID of the service.

Parameters

sh	service context

Returns

name of the file for the process ID

Definition at line 1747 of file service.c.

{
  char *pif;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (sh->cfg,
                                               sh->service_name,
                                               "PIDFILE",
                                               &pif))
    return NULL;
  return pif;
}

References GNUNET_IDENTITY_Handle::cfg, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_OK, and sh.

Referenced by pid_file_delete().

Here is the call graph for this function:

Here is the caller graph for this function:

pid_file_delete()

static void pid_file_delete ( struct GNUNET_SERVICE_Handle *  sh )

static

Delete the PID file that was created by our parent.

Parameters

sh	service context

Definition at line 1767 of file service.c.

{
  char *pif = get_pid_file_name (sh);
 
  if (NULL == pif)
    return; /* no PID file */
  if (0 != unlink (pif))
    LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
                       "unlink",
                       pif);
  GNUNET_free (pif);
}

References get_pid_file_name(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, LOG_STRERROR_FILE, and sh.

Referenced by GNUNET_SERVICE_run_().

Here is the call graph for this function:

Here is the caller graph for this function:

detach_terminal()

static enum GNUNET_GenericReturnValue detach_terminal ( struct GNUNET_SERVICE_Handle *  sh )

static

Detach from terminal.

Parameters

sh	service context

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1788 of file service.c.

{
  pid_t pid;
  int nullfd;
  int filedes[2];
 
  if (0 != pipe (filedes))
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                  "pipe");
    return GNUNET_SYSERR;
  }
  pid = fork ();
  if (pid < 0)
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                  "fork");
    return GNUNET_SYSERR;
  }
  if (0 != pid)
  {
    /* Parent */
    char c;
 
    GNUNET_break (0 == close (filedes[1]));
    c = 'X';
    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"));
      break;
 
    case 'S':
      LOG (GNUNET_ERROR_TYPE_INFO,
           _ ("Service process could not initialize server function\n"));
      break;
 
    case 'X':
      LOG (GNUNET_ERROR_TYPE_INFO,
           _ ("Service process failed to report status\n"));
      break;
    }
    exit (1);  /* child reported error */
  }
  GNUNET_break (0 == close (0));
  GNUNET_break (0 == close (1));
  GNUNET_break (0 == close (filedes[0]));
  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))
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2");
    (void) close (nullfd);
    return GNUNET_SYSERR;
  }
  (void) close (nullfd);
  /* Detach from controlling terminal */
  pid = setsid ();
  if (-1 == pid)
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                  "setsid");
  sh->ready_confirm_fd = filedes[1];
 
  return GNUNET_OK;
}

References _, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_OK, GNUNET_SYSERR, LOG, LOG_STRERROR, pid, and sh.

Referenced by GNUNET_SERVICE_run_().

Here is the caller graph for this function:

teardown_service()

static void teardown_service ( struct GNUNET_SERVICE_Handle *  sh )

static

Tear down the service, closing the listen sockets and freeing the ACLs.

Parameters

sh	handle to the service to tear down.

Definition at line 1872 of file service.c.

{
  struct ServiceListenContext *slc;
 
  GNUNET_free (sh->v4_denied);
  GNUNET_free (sh->v6_denied);
  GNUNET_free (sh->v4_allowed);
  GNUNET_free (sh->v6_allowed);
  while (NULL != (slc = sh->slc_head))
  {
    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);
  }
}

References GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NETWORK_socket_close(), GNUNET_OK, GNUNET_SCHEDULER_cancel(), ServiceListenContext::listen_socket, ServiceListenContext::listen_task, and sh.

Referenced by do_registered_services_shutdown(), GNUNET_SERVICE_run_(), and GNUNET_SERVICE_stop().

Here is the call graph for this function:

Here is the caller graph for this function:

return_agpl()

static void return_agpl ( void *  cls, const struct GNUNET_MessageHeader *  msg  )

static

Function to return link to AGPL source upon request.

Parameters

cls	closure with the identification of the client
msg	AGPL request

Definition at line 1901 of file service.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  const struct GNUNET_OS_ProjectData *pd = client->sh->pd;
  struct GNUNET_MQ_Handle *mq;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *res;
  size_t slen;
 
  (void) msg;
  slen = strlen (pd->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);
}

References GNUNET_OS_ProjectData::agpl_url, env, GNUNET_AGPL_URL, GNUNET_MESSAGE_TYPE_RESPONSE_AGPL, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), mq, msg, GNUNET_SERVICE_Handle::pd, res, and GNUNET_SERVICE_Client::sh.

Referenced by GNUNET_SERVICE_register_(), GNUNET_SERVICE_run_(), and GNUNET_SERVICE_start().

Here is the call graph for this function:

Here is the caller graph for this function:

finish_client_drop()

static void finish_client_drop ( void *  cls )

static

Asynchronously finish dropping the client.

Parameters

cls	the struct GNUNET_SERVICE_Client.

Definition at line 1967 of file service.c.

{
  struct GNUNET_SERVICE_Client *c = cls;
  struct GNUNET_SERVICE_Handle *sh = c->sh;
 
  c->drop_task = NULL;
  GNUNET_CONTAINER_DLL_remove (sh->clients_head,
                               sh->clients_tail,
                               c);
  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 (! c->persist)
  {
    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)) &&
      (! have_non_monitor_clients (sh)))
    GNUNET_SERVICE_shutdown (sh);
}

References do_resume(), GNUNET_SERVICE_Client::drop_task, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_MST_destroy(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_free_memory_only_(), GNUNET_OK, GNUNET_SERVICE_shutdown(), have_non_monitor_clients(), GNUNET_SERVICE_Client::mq, GNUNET_SERVICE_Client::mst, GNUNET_SERVICE_Client::persist, GNUNET_SERVICE_Client::recv_task, GNUNET_SERVICE_Client::send_task, sh, GNUNET_SERVICE_Client::sh, GNUNET_SERVICE_Client::sock, SUSPEND_STATE_EMFILE, SUSPEND_STATE_SHUTDOWN, and GNUNET_SERVICE_Client::warn_task.

Referenced by GNUNET_SERVICE_client_drop(), and GNUNET_SERVICE_stop().

Here is the call graph for this function:

Here is the caller graph for this function:

do_registered_services_shutdown()

static void do_registered_services_shutdown ( void *  cls )

static

Definition at line 2286 of file service.c.

{
  while (NULL != hll_head)
  {
    struct ServiceHandleList *shl = hll_head;
    struct GNUNET_SERVICE_Handle *sh = shl->sh;
 
    GNUNET_CONTAINER_DLL_remove (hll_head,
                                 hll_tail,
                                 shl);
    GNUNET_free (shl);
    if (-1 != sh->ready_confirm_fd)
    {
      if (1 != write (sh->ready_confirm_fd, "S", 1))
        LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
                      "write");
      GNUNET_break (0 ==
                    close (sh->ready_confirm_fd));
    }
    teardown_service (sh);
    GNUNET_free (sh->handlers);
    GNUNET_free (sh);
  }
}

References GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, hll_head, hll_tail, LOG_STRERROR, sh, ServiceHandleList::sh, and teardown_service().

Referenced by launch_registered_services().

Here is the call graph for this function:

Here is the caller graph for this function:

launch_registered_services()

static void launch_registered_services ( void *  cls )

static

Definition at line 2320 of file service.c.

{
  struct LaunchContext *lc = cls;
  struct GNUNET_CONFIGURATION_Handle *cfg = lc->cfg;
  const struct GNUNET_OS_ProjectData *pd = lc->pd;
 
  for (struct ServiceHandleList *shl = hll_head;
       NULL != shl;
       shl = shl->next)
  {
    shl->sh->cfg = cfg;
    if (GNUNET_OK !=
        setup_service (pd,
                       shl->sh))
      continue;
    if (GNUNET_OK !=
        set_user_id (shl->sh))
      continue;
    GNUNET_SCHEDULER_add_now (&service_main,
                              shl->sh);
  }
  GNUNET_SCHEDULER_add_shutdown (&do_registered_services_shutdown,
                                 NULL);
}

References cfg, LaunchContext::cfg, do_registered_services_shutdown(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), hll_head, ServiceHandleList::next, LaunchContext::pd, service_main(), set_user_id(), and setup_service().

Referenced by GNUNET_SERVICE_main().

Here is the call graph for this function:

Here is the caller graph for this function:

resume_client_receive()

static void resume_client_receive ( void *  cls )

static

Task run to resume receiving data from the client after the client called GNUNET_SERVICE_client_continue().

Parameters

cls	our struct GNUNET_SERVICE_Client

Definition at line 2402 of file service.c.

{
  struct GNUNET_SERVICE_Client *c = cls;
  int ret;
 
  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)
  {
    if (NULL == c->drop_task)
      GNUNET_SERVICE_client_drop (c);
    return;
  }
  if (GNUNET_NO == ret)
    return; /* done processing, wait for more later */
  GNUNET_assert (GNUNET_OK == ret);
  if (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);
}

References GNUNET_SERVICE_Client::drop_task, GNUNET_assert, GNUNET_MST_next(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, GNUNET_SERVICE_Client::mst, GNUNET_SERVICE_Client::needs_continue, GNUNET_SERVICE_Client::recv_task, ret, service_client_recv(), and GNUNET_SERVICE_Client::sock.

Referenced by GNUNET_SERVICE_client_continue().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

hll_head

struct ServiceHandleList* hll_head

static

Definition at line 2246 of file service.c.

Referenced by do_registered_services_shutdown(), GNUNET_SERVICE_register_(), and launch_registered_services().

hll_tail

struct ServiceHandleList* hll_tail

static

Definition at line 2249 of file service.c.

Referenced by do_registered_services_shutdown(), and GNUNET_SERVICE_register_().