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...

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. 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 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. More...

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. 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 enum GNUNET_GenericReturnValue	process_acl4 (struct GNUNET_STRINGS_IPv4NetworkPolicy *ret, struct GNUNET_SERVICE_Handle sh, const char *option)
	Parse an IPv4 access control list. More...

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. 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 enum GNUNET_GenericReturnValue	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 enum GNUNET_GenericReturnValue	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 enum GNUNET_GenericReturnValue	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...

static void	finish_client_drop (void *cls)
	Asynchronously finish dropping the client. 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...

int	GNUNET_SERVICE_register_ (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. More...

static void	do_registered_services_shutdown (void *cls)

static void	launch_registered_services (void *cls)

void	GNUNET_SERVICE_main (int argc, char const argv)
	Run the mainloop in a monolithic libgnunet. 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...

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...

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

◆ LOG_STRERROR

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

Definition at line 42 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 45 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 84 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 356 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 380 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 407 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 439 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 462 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, 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 492 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 561 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 589 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 612 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 637 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 670 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 701 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 746 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 783 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 877 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 906 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 937 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 978 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 1018 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 1062 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, 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 1358 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 ( 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 1466 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 = (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, 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, 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 1618 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 1639 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 1689 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 1709 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 1730 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 1814 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 1843 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_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 1903 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);
}

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

{
  struct GNUNET_CONFIGURATION_Handle *cfg = cls;
 
  for (struct ServiceHandleList *shl = hll_head;
       NULL != shl;
       shl = shl->next)
  {
    shl->sh->cfg = cfg;
    if (GNUNET_OK != setup_service (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, do_registered_services_shutdown(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), hll_head, ServiceHandleList::next, 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 2424 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 2199 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 2202 of file service.c.

Referenced by do_registered_services_shutdown(), and GNUNET_SERVICE_register_().

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ LOG

◆ LOG_STRERROR

◆ LOG_STRERROR_FILE

Enumeration Type Documentation

◆ SuspendReason

Function Documentation

◆ have_non_monitor_clients()

◆ do_suspend()

◆ service_shutdown()

◆ check_ipv4_listed()

◆ check_ipv6_listed()

◆ do_send()

◆ service_mq_send()

◆ service_mq_cancel()

◆ service_mq_error_handler()

◆ warn_no_client_continue()

◆ service_client_mst_cb()

◆ service_client_recv()

◆ start_client()

◆ accept_client()

◆ do_resume()

◆ service_main()

◆ process_acl4()

◆ process_acl6()

◆ add_unixpath()

◆ get_server_addresses()

◆ open_listen_socket()

◆ setup_service()

◆ get_user_name()

◆ set_user_id()

◆ get_pid_file_name()

◆ pid_file_delete()

◆ detach_terminal()

◆ teardown_service()

◆ return_agpl()

◆ finish_client_drop()

◆ do_registered_services_shutdown()

◆ launch_registered_services()

◆ resume_client_receive()

Variable Documentation

◆ hll_head

◆ hll_tail