service.c File Reference

functions related to starting services 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...

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 int	have_non_monitor_clients (struct GNUNET_SERVICE_Handle *sh)
	Check if any of the clients we have left are unrelated to monitoring. More...
static void	do_suspend (struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr)
	Suspend accepting connections from the listen socket temporarily. More...
static void	service_shutdown (void *cls)
	Shutdown task triggered when a service should be terminated. More...
static int	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. More...
static int	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. More...
static void	do_send (void *cls)
	Task run when we are ready to transmit data to the client. More...
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. More...
static void	service_mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Implementation function that cancels the currently sent message. More...
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. More...
static void	warn_no_client_continue (void *cls)
	Task run to warn about missing calls to GNUNET_SERVICE_client_continue(). More...
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. More...
static void	service_client_recv (void *cls)
	A client sent us data. More...
static void	start_client (struct GNUNET_SERVICE_Handle *sh, struct GNUNET_NETWORK_Handle *csock)
	We have successfully accepted a connection from a client. More...
static void	accept_client (void *cls)
	We have a client. More...
static void	do_resume (struct GNUNET_SERVICE_Handle *sh, enum SuspendReason sr)
	Resume accepting connections from the listen socket. More...
static void	service_main (void *cls)
	First task run by any service. More...
static int	process_acl4 (struct GNUNET_STRINGS_IPv4NetworkPolicy **ret, struct GNUNET_SERVICE_Handle *sh, const char *option)
	Parse an IPv4 access control list. More...
static int	process_acl6 (struct GNUNET_STRINGS_IPv6NetworkPolicy **ret, struct GNUNET_SERVICE_Handle *sh, const char *option)
	Parse an IPv6 access control list. More...
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). More...
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. More...
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. More...
static int	setup_service (struct GNUNET_SERVICE_Handle *sh)
	Setup service handle. More...
static char *	get_user_name (struct GNUNET_SERVICE_Handle *sh)
	Get the name of the user that'll be used to provide the service. More...
static int	set_user_id (struct GNUNET_SERVICE_Handle *sh)
	Set user ID. More...
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. More...
static void	pid_file_delete (struct GNUNET_SERVICE_Handle *sh)
	Delete the PID file that was created by our parent. More...
static int	detach_terminal (struct GNUNET_SERVICE_Handle *sh)
	Detach from terminal. More...
static void	teardown_service (struct GNUNET_SERVICE_Handle *sh)
	Tear down the service, closing the listen sockets and freeing the ACLs. More...
static void	return_agpl (void *cls, const struct GNUNET_MessageHeader *msg)
	Function to return link to AGPL source upon request. More...
struct GNUNET_SERVICE_Handle *	GNUNET_SERVICE_start (const char *service_name, const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_SERVICE_ConnectHandler connect_cb, GNUNET_SERVICE_DisconnectHandler disconnect_cb, void *cls, const struct GNUNET_MQ_MessageHandler *handlers)
	Low-level function to start a service if the scheduler is already running. More...
void	GNUNET_SERVICE_stop (struct GNUNET_SERVICE_Handle *srv)
	Stops a service that was started with GNUNET_SERVICE_start(). More...
int	GNUNET_SERVICE_run_ (int argc, char *const *argv, const char *service_name, enum GNUNET_SERVICE_Options options, GNUNET_SERVICE_InitCallback service_init_cb, GNUNET_SERVICE_ConnectHandler connect_cb, GNUNET_SERVICE_DisconnectHandler disconnect_cb, void *cls, const struct GNUNET_MQ_MessageHandler *handlers)
	Creates the "main" function for a GNUnet service. More...
void	GNUNET_SERVICE_suspend (struct GNUNET_SERVICE_Handle *sh)
	Suspend accepting connections from the listen socket temporarily. More...
void	GNUNET_SERVICE_resume (struct GNUNET_SERVICE_Handle *sh)
	Resume accepting connections from the listen socket. More...
static void	resume_client_receive (void *cls)
	Task run to resume receiving data from the client after the client called GNUNET_SERVICE_client_continue(). More...
void	GNUNET_SERVICE_client_continue (struct GNUNET_SERVICE_Client *c)
	Continue receiving further messages from the given client. More...
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. More...
static void	finish_client_drop (void *cls)
	Asynchronously finish dropping the client. More...
void	GNUNET_SERVICE_client_drop (struct GNUNET_SERVICE_Client *c)
	Ask the server to disconnect from the given client. More...
void	GNUNET_SERVICE_shutdown (struct GNUNET_SERVICE_Handle *sh)
	Explicitly stops the service. More...
void	GNUNET_SERVICE_client_mark_monitor (struct GNUNET_SERVICE_Client *c)
	Set the 'monitor' flag on this client. More...
void	GNUNET_SERVICE_client_persist (struct GNUNET_SERVICE_Client *c)
	Set the persist option on this client. More...
struct GNUNET_MQ_Handle *	GNUNET_SERVICE_client_get_mq (struct GNUNET_SERVICE_Client *c)
	Obtain the message queue of c. More...

Detailed Description

functions related to starting services

functions related to starting services (redesign)

Author

Christian Grothoff

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 41 of file service.c.

LOG_STRERROR

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

Definition at line 43 of file 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 46 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 85 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 int 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

GNUNET_YES if we have non-monitoring clients left

Definition at line 362 of file service.c.

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

References GNUNET_NO, GNUNET_YES, and 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.

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

References GNUNET_assert, GNUNET_SCHEDULER_cancel(), ServiceListenContext::listen_task, ServiceListenContext::next, 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 409 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 (GNUNET_NO == have_non_monitor_clients (sh))
      GNUNET_SERVICE_shutdown (sh);
    break;
  }
}

References do_suspend(), GNUNET_assert, GNUNET_NO, 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 int 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

GNUNET_NO if the IP is not in the list, GNUNET_YES if it it is

Definition at line 441 of file service.c.

{
  unsigned int i;
 
  if (NULL == list)
    return GNUNET_NO;
  i = 0;
  while ((0 != list[i].network.s_addr) || (0 != list[i].netmask.s_addr))
  {
    if ((add->s_addr & list[i].netmask.s_addr) ==
        (list[i].network.s_addr & list[i].netmask.s_addr))
      return GNUNET_YES;
    i++;
  }
  return GNUNET_NO;
}

References add, GNUNET_NO, GNUNET_YES, and list.

Referenced by accept_client().

Here is the caller graph for this function:

check_ipv6_listed()

static int 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

GNUNET_NO if the IP is not in the list, GNUNET_YES if it it is

Definition at line 468 of file service.c.

{
  unsigned int i;
 
  if (NULL == list)
    return GNUNET_NO;
  i = 0;
NEXT:
  while (GNUNET_NO == GNUNET_is_zero (&list[i].network))
  {
    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]))
      {
        i++;
        goto NEXT;
      }
    return GNUNET_YES;
  }
  return GNUNET_NO;
}

References GNUNET_is_zero, GNUNET_NO, GNUNET_YES, consensus-simulation::int, 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 499 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 buf, 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 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 568 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 596 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 618 of file service.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_SERVICE_Handle *sh = client->sh;
 
  if ((GNUNET_MQ_ERROR_NO_MATCH == error) && (GNUNET_NO == sh->require_found))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "No handler for message of type %u found\n",
                (unsigned int) client->warn_type);
    GNUNET_SERVICE_client_continue (client);
    return;   /* ignore error */
  }
  GNUNET_SERVICE_client_drop (client);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_ERROR_NO_MATCH, GNUNET_NO, 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 641 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, GNUNET_SERVICE_Client::warn_start, GNUNET_SERVICE_Client::warn_task, and GNUNET_SERVICE_Client::warn_type.

Referenced by service_client_mst_cb().

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 674 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 (GNUNET_NO == client->needs_continue);
  client->needs_continue = GNUNET_YES;
  client->warn_type = ntohs (message->type);
  client->warn_start = GNUNET_TIME_absolute_get ();
  GNUNET_assert (NULL == client->warn_task);
  client->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
                                                    &warn_no_client_continue,
                                                    client);
  GNUNET_MQ_inject_message (client->mq, message);
  if (NULL != client->drop_task)
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

References GNUNET_SERVICE_Client::drop_task, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_inject_message(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_MINUTES, GNUNET_YES, 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 705 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 (GNUNET_NO == 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 (GNUNET_YES == client->needs_continue)
    return;
  if (NULL != client->recv_task)
    return;
  /* MST needs more data, re-schedule read job */
  client->recv_task =
    GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                   client->sock,
                                   &service_client_recv,
                                   client);
}

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, and GNUNET_SERVICE_Client::sock.

Referenced by resume_client_receive(), 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 750 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_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 785 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 _, 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, ok, sh, ServiceListenContext::sh, start_client(), and SUSPEND_STATE_EMFILE.

Referenced by 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 873 of file service.c.

{
  struct ServiceListenContext *slc;
 
  GNUNET_assert ((SUSPEND_STATE_NONE == sr) || (0 != (sh->suspend_state & sr)));
  sh->suspend_state -= sr;
  if (SUSPEND_STATE_NONE != sh->suspend_state)
    return;
  for (slc = sh->slc_head; NULL != slc; slc = slc->next)
  {
    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, ServiceListenContext::listen_socket, ServiceListenContext::listen_task, ServiceListenContext::next, 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 901 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 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_().

Here is the call graph for this function:

Here is the caller graph for this function:

process_acl4()

static int 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 932 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_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 int 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 973 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_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 1013 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 1057 of file service.c.

{
  int 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 = GNUNET_NO;
  if ((GNUNET_NO == GNUNET_NETWORK_test_pf (PF_INET6)) ||
      (GNUNET_YES ==
       GNUNET_CONFIGURATION_get_value_yesno (cfg, service_name, "DISABLEV6")))
    disablev6 = GNUNET_YES;
 
  port = 0;
  if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT"))
  {
    if (GNUNET_OK != 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;
    }
  }
 
  if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "BINDTO"))
  {
    GNUNET_break (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_string (cfg,
                                                         service_name,
                                                         "BINDTO",
                                                         &hostname));
  }
  else
    hostname = NULL;
 
  unixpath = NULL;
#ifdef AF_UNIX
  if ((GNUNET_YES ==
       GNUNET_CONFIGURATION_have_value (cfg, service_name, "UNIXPATH")) &&
      (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_INFO,
           _ (
             "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %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_CONFIGURATION_have_value(), 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, hostname, 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 1353 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 int setup_service ( 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

sh	service context to initialize

Returns

GNUNET_OK if configuration succeeded

Definition at line 1461 of file service.c.

{
  int tolerant;
  struct GNUNET_NETWORK_Handle **csocks = NULL;
  struct GNUNET_NETWORK_Handle **lsocks;
  const char *nfds;
  unsigned int cnt;
  int flags;
  char dummy[2];
 
  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"))) &&
      (1 == sscanf (nfds, "%u%1s", &cnt, dummy)) && (cnt > 0) &&
      (cnt < FD_SETSIZE) && (cnt + 4 < FD_SETSIZE))
  {
    lsocks = GNUNET_new_array (cnt + 1, struct GNUNET_NETWORK_Handle *);
    while (0 < cnt--)
    {
      flags = fcntl (3 + cnt, F_GETFD);
      if ((flags < 0) || (0 != (flags & FD_CLOEXEC)) ||
          (NULL == (lsocks[cnt] = GNUNET_NETWORK_socket_box_native (3 + cnt))))
      {
        LOG (GNUNET_ERROR_TYPE_ERROR,
             _ (
               "Could not access pre-bound socket %u, will try to bind myself\n"),
             (unsigned int) 3 + cnt);
        cnt++;
        while (NULL != lsocks[cnt])
          GNUNET_break (GNUNET_OK ==
                        GNUNET_NETWORK_socket_close (lsocks[cnt++]));
        GNUNET_free (lsocks);
        lsocks = NULL;
        break;
      }
    }
    unsetenv ("LISTEN_FDS");
  }
  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)
      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 = tolerant ? GNUNET_NO : GNUNET_YES;
  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 _, dummy, get_server_addresses(), getenv(), GNUNET_break, GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONFIGURATION_have_value(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_ERROR, 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_SYSERR, GNUNET_YES, ServiceListenContext::listen_socket, LOG, ls, open_listen_socket(), process_acl4(), process_acl6(), sh, and ServiceListenContext::sh.

Referenced by GNUNET_SERVICE_run_(), and GNUNET_SERVICE_start().

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 1608 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_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 int 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 1628 of file service.c.

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

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 1679 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_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 1698 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 int 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 1717 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 1797 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 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 1824 of file service.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  struct GNUNET_MQ_Handle *mq;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *res;
  size_t slen;
  const struct GNUNET_OS_ProjectData *pd = GNUNET_OS_project_data_get ();
 
  (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_OS_project_data_get(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_get_mq(), mq, msg, and res.

Referenced by GNUNET_SERVICE_run_(), and GNUNET_SERVICE_start().

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 2213 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 (GNUNET_YES == c->needs_continue)
    return; /* #GNUNET_MST_next() did give a message to the client */
  /* need to receive more data from the network first */
  if (NULL != c->recv_task)
    return;
  c->recv_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                                c->sock,
                                                &service_client_recv,
                                                c);
}

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:

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 2290 of file service.c.

{
  struct GNUNET_SERVICE_Client *c = cls;
  struct GNUNET_SERVICE_Handle *sh = c->sh;
 
  c->drop_task = NULL;
  GNUNET_assert (NULL == c->send_task);
  GNUNET_assert (NULL == c->recv_task);
  GNUNET_assert (NULL == c->warn_task);
  GNUNET_MST_destroy (c->mst);
  GNUNET_MQ_destroy (c->mq);
  if (GNUNET_NO == c->persist)
  {
    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (c->sock));
    if ((0 != (SUSPEND_STATE_EMFILE & sh->suspend_state)) &&
        (0 == (SUSPEND_STATE_SHUTDOWN & sh->suspend_state)))
      do_resume (sh, SUSPEND_STATE_EMFILE);
  }
  else
  {
    GNUNET_NETWORK_socket_free_memory_only_ (c->sock);
  }
  GNUNET_free (c);
  if ((0 != (SUSPEND_STATE_SHUTDOWN & sh->suspend_state)) &&
      (GNUNET_NO == have_non_monitor_clients (sh)))
    GNUNET_SERVICE_shutdown (sh);
}

References do_resume(), GNUNET_SERVICE_Client::drop_task, GNUNET_assert, GNUNET_break, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_MST_destroy(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_free_memory_only_(), GNUNET_NO, 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().

Here is the call graph for this function:

Here is the caller graph for this function: