#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"

Include dependency graph for tcp_server_legacy.c:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	HandlerList
	List of arrays of message handlers. More...

struct	NotifyList
	List of arrays of message handlers. More...

struct	GNUNET_SERVER_Handle
	handle for a server More...

struct	GNUNET_SERVER_TransmitHandle
	Handle server returns for aborting transmission to a client. More...

struct	GNUNET_SERVER_Client
	handle for a client of the server More...

Macros
#define	LOG_STRERROR_FILE(kind, syscall, filename)

Functions
void *	GNUNET_SERVER_client_get_user_context_ (struct GNUNET_SERVER_Client *client, size_t size)
	Return user context associated with the given client. More...

void	GNUNET_SERVER_client_set_user_context_ (struct GNUNET_SERVER_Client client, void ptr, size_t size)
	Set user context to be associated with the given client. More...

static void	process_listen_socket (void *cls)
	Scheduler says our listen socket is ready. 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...

struct GNUNET_SERVER_Handle *	GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access_cb, void access_cb_cls, struct GNUNET_NETWORK_Handle *lsocks, struct GNUNET_TIME_Relative idle_timeout, int require_found)
	Create a new server. More...

struct GNUNET_SERVER_Handle *	GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck access_cb, void access_cb_cls, struct sockaddr const server_addr, const socklen_t socklen, struct GNUNET_TIME_Relative idle_timeout, int require_found)
	Create a new server. More...

void	GNUNET_SERVER_client_mark_monitor (struct GNUNET_SERVER_Client *client)
	Set the 'monitor' flag on this client. More...

static void	do_destroy (void *cls)
	Helper function for test_monitor_clients() to trigger GNUNET_SERVER_destroy() after the stack has unwound. More...

static void	test_monitor_clients (struct GNUNET_SERVER_Handle *server)
	Check if only 'monitor' clients are left. More...

void	GNUNET_SERVER_suspend (struct GNUNET_SERVER_Handle *server)
	Suspend accepting connections from the listen socket temporarily. More...

void	GNUNET_SERVER_resume (struct GNUNET_SERVER_Handle *server)
	Resume accepting connections from the listen socket. More...

void	GNUNET_SERVER_stop_listening (struct GNUNET_SERVER_Handle *server)
	Stop the listen socket and get ready to shutdown the server once only 'monitor' clients are left. More...

void	GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *server)
	Free resources held by this server. More...

void	GNUNET_SERVER_add_handlers (struct GNUNET_SERVER_Handle server, const struct GNUNET_SERVER_MessageHandler handlers)
	Add additional handlers to an existing server. More...

void	GNUNET_SERVER_set_callbacks (struct GNUNET_SERVER_Handle server, GNUNET_SERVER_MstCreateCallback create, GNUNET_SERVER_MstDestroyCallback destroy, GNUNET_SERVER_MstReceiveCallback receive, void cls)
	Change functions used by the server to tokenize the message stream. More...

static void	warn_no_receive_done (void *cls)
	Task run to warn about missing calls to GNUNET_SERVER_receive_done. More...

void	GNUNET_SERVER_disable_receive_done_warning (struct GNUNET_SERVER_Client *client)
	Disable the warning the server issues if a message is not acknowledged in a timely fashion. More...

int	GNUNET_SERVER_inject (struct GNUNET_SERVER_Handle server, struct GNUNET_SERVER_Client sender, const struct GNUNET_MessageHeader *message)
	Inject a message into the server, pretend it came from the specified client. More...

static void	process_incoming (void cls, const void buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
	We are receiving an incoming message. More...

static void	process_mst (struct GNUNET_SERVER_Client *client, int ret)
	Process messages from the client's message tokenizer until either the tokenizer is empty (and then schedule receiving more), or until some handler is not immediately done (then wait for restart_processing) or shutdown. More...

static void	restart_processing (void *cls)
	Task run to start again receiving from the network and process requests. More...

static int	client_message_tokenizer_callback (void cls, void client, const struct GNUNET_MessageHeader *message)
	This function is called whenever our inbound message tokenizer has received a complete message. More...

struct GNUNET_SERVER_Client *	GNUNET_SERVER_connect_socket (struct GNUNET_SERVER_Handle server, struct GNUNET_CONNECTION_Handle connection)
	Add a TCP socket-based connection to the set of handles managed by this server. More...

void	GNUNET_SERVER_client_set_timeout (struct GNUNET_SERVER_Client *client, struct GNUNET_TIME_Relative timeout)
	Change the timeout for a particular client. More...

void	GNUNET_SERVER_client_keep (struct GNUNET_SERVER_Client *client)
	Notify the server that the given client handle should be kept (keeps the connection up if possible, increments the internal reference counter). More...

void	GNUNET_SERVER_client_drop (struct GNUNET_SERVER_Client *client)
	Notify the server that the given client handle is no longer required. More...

int	GNUNET_SERVER_client_get_address (struct GNUNET_SERVER_Client client, void addr, size_t addrlen)
	Obtain the network address of the other party. More...

void	GNUNET_SERVER_disconnect_notify (struct GNUNET_SERVER_Handle server, GNUNET_SERVER_DisconnectCallback callback, void callback_cls)
	Ask the server to notify us whenever a client disconnects. More...

void	GNUNET_SERVER_connect_notify (struct GNUNET_SERVER_Handle server, GNUNET_SERVER_ConnectCallback callback, void callback_cls)
	Ask the server to notify us whenever a client connects. More...

void	GNUNET_SERVER_disconnect_notify_cancel (struct GNUNET_SERVER_Handle server, GNUNET_SERVER_DisconnectCallback callback, void callback_cls)
	Ask the server to stop notifying us whenever a client connects. More...

void	GNUNET_SERVER_connect_notify_cancel (struct GNUNET_SERVER_Handle server, GNUNET_SERVER_ConnectCallback callback, void callback_cls)
	Ask the server to stop notifying us whenever a client disconnects. More...

void	GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
	Ask the server to disconnect from the given client. More...

int	GNUNET_SERVER_client_disable_corking (struct GNUNET_SERVER_Client *client)
	Disable the "CORK" feature for communication with the given client, forcing the OS to immediately flush the buffer on transmission instead of potentially buffering multiple messages. More...

static size_t	transmit_ready_callback_wrapper (void cls, size_t size, void buf)
	Wrapper for transmission notification that calls the original callback and update the last activity time for our connection. More...

struct GNUNET_SERVER_TransmitHandle *	GNUNET_SERVER_notify_transmit_ready (struct GNUNET_SERVER_Client client, size_t size, struct GNUNET_TIME_Relative timeout, GNUNET_CONNECTION_TransmitReadyNotify callback, void callback_cls)
	Notify us when the server has enough space to transmit a message of the given size to the given client. More...

void	GNUNET_SERVER_notify_transmit_ready_cancel (struct GNUNET_SERVER_TransmitHandle *th)
	Abort transmission request. More...

void	GNUNET_SERVER_client_persist_ (struct GNUNET_SERVER_Client *client)
	Set the persistent flag on this client, used to setup client connection to only be killed when the service it's connected to is actually dead. More...

void	GNUNET_SERVER_receive_done (struct GNUNET_SERVER_Client *client, int success)
	Resume receiving from this client, we are done processing the current request. More...

Macro Definition Documentation

◆ LOG_STRERROR_FILE

#define LOG_STRERROR_FILE	(	kind,
		syscall,
		filename
	)

Value:

                                                                   GNUNET_log_from_strerror_file (kind, \
                                                                   "util-server", \
                                                                   syscall, \
                                                                   filename)

Definition at line 31 of file tcp_server_legacy.c.

Function Documentation

◆ GNUNET_SERVER_client_get_user_context_()

void* GNUNET_SERVER_client_get_user_context_	(	struct GNUNET_SERVER_Client *	client,
		size_t	size
	)

Return user context associated with the given client.

Note: you should probably use the macro (call without the underscore).

Parameters

client	client to query
size	number of bytes in user context struct (for verification only)

Returns: pointer to user context

Definition at line 349 of file tcp_server_legacy.c.

 {
   if ((0 == client->user_context_size) &&
       (NULL == client->user_context))
     return NULL; /* never set */
   GNUNET_assert (size == client->user_context_size);
   return client->user_context;
 }

References GNUNET_assert, size, GNUNET_SERVER_Client::user_context, and GNUNET_SERVER_Client::user_context_size.

◆ GNUNET_SERVER_client_set_user_context_()

void GNUNET_SERVER_client_set_user_context_	(	struct GNUNET_SERVER_Client *	client,
		void *	ptr,
		size_t	size
	)

Set user context to be associated with the given client.

Note: you should probably use the macro (call without the underscore).

Parameters

client	client to query
ptr	pointer to user context
size	number of bytes in user context struct (for verification only)

Definition at line 369 of file tcp_server_legacy.c.

 {
   if (NULL == ptr)
   {
     client->user_context_size = 0;
     client->user_context = ptr;
     return;
   }
   client->user_context_size = size;
   client->user_context = ptr;
 }

References size, GNUNET_SERVER_Client::user_context, and GNUNET_SERVER_Client::user_context_size.

◆ process_listen_socket()

static void process_listen_socket ( void * cls )

static

Scheduler says our listen socket is ready.

Process it!

Parameters

cls	handle to our server for which we are processing the listen socket

Definition at line 391 of file tcp_server_legacy.c.

 {
   struct GNUNET_SERVER_Handle *server = cls;
   const struct GNUNET_SCHEDULER_TaskContext *tc;
   struct GNUNET_CONNECTION_Handle *sock;
   unsigned int i;
  
   server->listen_task = NULL;
   tc = GNUNET_SCHEDULER_get_task_context ();
   for (i = 0; NULL != server->listen_sockets[i]; i++)
   {
     if (GNUNET_NETWORK_fdset_isset (tc->read_ready,
                                     server->listen_sockets[i]))
     {
       sock =
         GNUNET_CONNECTION_create_from_accept (server->access_cb,
                                               server->access_cb_cls,
                                               server->listen_sockets[i]);
       if (NULL != sock)
       {
         LOG (GNUNET_ERROR_TYPE_DEBUG,
              "Server accepted incoming connection.\n");
         (void) GNUNET_SERVER_connect_socket (server,
                                              sock);
       }
     }
   }
   /* listen for more! */
   GNUNET_SERVER_resume (server);
 }

References GNUNET_SERVER_Handle::access_cb, GNUNET_SERVER_Handle::access_cb_cls, GNUNET_CONNECTION_create_from_accept(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_NETWORK_fdset_isset(), GNUNET_SCHEDULER_get_task_context(), GNUNET_SERVER_connect_socket(), GNUNET_SERVER_resume(), GNUNET_SERVER_Handle::listen_sockets, GNUNET_SERVER_Handle::listen_task, LOG, GNUNET_SCHEDULER_TaskContext::read_ready, GNUNET_CONNECTION_Handle::sock, and tc.

Referenced by GNUNET_SERVER_resume().

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 431 of file tcp_server_legacy.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' */
       LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                     "bind");
       if (0 != port)
         LOG (GNUNET_ERROR_TYPE_ERROR,
              _ ("`%s' failed for port %d (%s).\n"),
              "bind",
              port,
              (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
       eno = 0;
     }
     else
     {
       if (0 != port)
         LOG (GNUNET_ERROR_TYPE_WARNING,
              _ ("`%s' failed for port %d (%s): address already in use\n"),
              "bind", port,
              (AF_INET == server_addr->sa_family) ? "IPv4" : "IPv6");
       else if (AF_UNIX == server_addr->sa_family)
       {
         LOG (GNUNET_ERROR_TYPE_WARNING,
              _ ("`%s' failed for `%s': address already in use\n"),
              "bind",
              GNUNET_a2s (server_addr, socklen));
       }
     }
     GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
     errno = eno;
     return NULL;
   }
   if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock, 5))
   {
     LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
                   "listen");
     GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock));
     errno = 0;
     return NULL;
   }
   if (0 != port)
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Server starts to listen on port %u.\n",
          port);
   return sock;
 }

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 GNUNET_SERVER_create().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_create_with_sockets()

struct GNUNET_SERVER_Handle* GNUNET_SERVER_create_with_sockets	(	GNUNET_CONNECTION_AccessCheck	access_cb,
		void *	access_cb_cls,
		struct GNUNET_NETWORK_Handle **	lsocks,
		struct GNUNET_TIME_Relative	idle_timeout,
		int	require_found
	)

Create a new server.

Parameters

access_cb	function for access control
access_cb_cls	closure for access_cb
lsocks	NULL-terminated array of listen sockets
idle_timeout	after how long should we timeout idle connections?
require_found	if GNUNET_YES, connections sending messages of unknown type will be closed

Returns: handle for the new server, NULL on error (typically, "port" already in use)

Definition at line 532 of file tcp_server_legacy.c.

 {
   struct GNUNET_SERVER_Handle *server;
  
   server = GNUNET_new (struct GNUNET_SERVER_Handle);
   server->idle_timeout = idle_timeout;
   server->listen_sockets = lsocks;
   server->access_cb = access_cb;
   server->access_cb_cls = access_cb_cls;
   server->require_found = require_found;
   if (NULL != lsocks)
     GNUNET_SERVER_resume (server);
   return server;
 }

References GNUNET_SERVER_Handle::access_cb, GNUNET_SERVER_Handle::access_cb_cls, GNUNET_new, GNUNET_SERVER_resume(), GNUNET_SERVER_Handle::idle_timeout, GNUNET_SERVER_Handle::listen_sockets, and GNUNET_SERVER_Handle::require_found.

Referenced by GNUNET_SERVER_create(), LEGACY_SERVICE_start(), libgnunet_plugin_transport_tcp_init(), and service_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_create()

struct GNUNET_SERVER_Handle* GNUNET_SERVER_create	(	GNUNET_CONNECTION_AccessCheck	access_cb,
		void *	access_cb_cls,
		struct sockaddr const	server_addr,
		const socklen_t *	socklen,
		struct GNUNET_TIME_Relative	idle_timeout,
		int	require_found
	)

Create a new server.

Parameters

access_cb	function for access control
access_cb_cls	closure for access_cb
server_addr	address to listen on (including port), NULL terminated array
socklen	length of server_addr
idle_timeout	after how long should we timeout idle connections?
require_found	if YES, connections sending messages of unknown type will be closed

Returns: handle for the new server, NULL on error (typically, "port" already in use)

Definition at line 566 of file tcp_server_legacy.c.

 {
   struct GNUNET_NETWORK_Handle **lsocks;
   unsigned int i;
   unsigned int j;
   unsigned int k;
   int seen;
  
   i = 0;
   while (NULL != server_addr[i])
     i++;
   if (i > 0)
   {
     lsocks = GNUNET_malloc (sizeof(struct GNUNET_NETWORK_Handle *) * (i + 1));
     i = 0;
     j = 0;
     while (NULL != server_addr[i])
     {
       seen = 0;
       for (k = 0; k < i; k++)
         if ((socklen[k] == socklen[i]) &&
             (0 == memcmp (server_addr[k], server_addr[i], socklen[i])))
         {
           seen = 1;
           break;
         }
       if (0 != seen)
       {
         /* duplicate address, skip */
         i++;
         continue;
       }
       lsocks[j] = open_listen_socket (server_addr[i], socklen[i]);
       if (NULL != lsocks[j])
         j++;
       i++;
     }
     if (0 == j)
     {
       if (0 != errno)
         LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "bind");
       GNUNET_free (lsocks);
       lsocks = NULL;
     }
   }
   else
   {
     lsocks = NULL;
   }
   return GNUNET_SERVER_create_with_sockets (access_cb,
                                             access_cb_cls,
                                             lsocks,
                                             idle_timeout,
                                             require_found);
 }

References GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_malloc, GNUNET_SERVER_create_with_sockets(), LOG_STRERROR, and open_listen_socket().

Referenced by LEGACY_SERVICE_start(), and service_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_client_mark_monitor()

void GNUNET_SERVER_client_mark_monitor ( struct GNUNET_SERVER_Client * client )

Set the 'monitor' flag on this client.

Clients which have been marked as 'monitors' won't prevent the server from shutting down once 'GNUNET_SERVER_stop_listening()' has been invoked. The idea is that for "normal" clients we likely want to allow them to process their requests; however, monitor-clients are likely to 'never' disconnect during shutdown and thus will not be considered when determining if the server should continue to exist after GNUNET_SERVER_destroy() has been called.

Parameters

client the client to set the 'monitor' flag on

Definition at line 641 of file tcp_server_legacy.c.

 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Marking client as monitor!\n");
   client->is_monitor = GNUNET_YES;
 }

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_YES, and GNUNET_SERVER_Client::is_monitor.

◆ do_destroy()

static void do_destroy ( void * cls )

static

Helper function for test_monitor_clients() to trigger GNUNET_SERVER_destroy() after the stack has unwound.

Parameters

cls	the `struct GNUNET_SERVER_Handle *` to destroy

Definition at line 656 of file tcp_server_legacy.c.

 {
   struct GNUNET_SERVER_Handle *server = cls;
  
   GNUNET_SERVER_destroy (server);
 }

References GNUNET_SERVER_destroy().

Referenced by test_monitor_clients().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ test_monitor_clients()

static void test_monitor_clients ( struct GNUNET_SERVER_Handle * server )

static

Check if only 'monitor' clients are left.

If so, destroy the server completely.

Parameters

server server to test for full shutdown

Definition at line 671 of file tcp_server_legacy.c.

 {
   struct GNUNET_SERVER_Client *client;
  
   if (GNUNET_YES != server->in_soft_shutdown)
     return;
   for (client = server->clients_head; NULL != client; client = client->next)
     if (GNUNET_NO == client->is_monitor)
       return;
   /* not done yet */
   server->in_soft_shutdown = GNUNET_SYSERR;
   (void) GNUNET_SCHEDULER_add_now (&do_destroy, server);
 }

References GNUNET_SERVER_Handle::clients_head, do_destroy(), GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_SYSERR, GNUNET_YES, GNUNET_SERVER_Handle::in_soft_shutdown, GNUNET_SERVER_Client::is_monitor, GNUNET_SERVER_Client::next, and GNUNET_SERVER_Client::server.

Referenced by GNUNET_SERVER_client_disconnect(), and GNUNET_SERVER_stop_listening().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_suspend()

void GNUNET_SERVER_suspend ( struct GNUNET_SERVER_Handle * server )

Suspend accepting connections from the listen socket temporarily.

Parameters

server server to stop accepting connections.

Definition at line 692 of file tcp_server_legacy.c.

 {
   if (NULL != server->listen_task)
   {
     GNUNET_SCHEDULER_cancel (server->listen_task);
     server->listen_task = NULL;
   }
 }

References GNUNET_SCHEDULER_cancel(), GNUNET_SERVER_Handle::listen_task, and GNUNET_SERVER_Client::server.

Referenced by connect_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_resume()

void GNUNET_SERVER_resume ( struct GNUNET_SERVER_Handle * server )

Resume accepting connections from the listen socket.

Parameters

server server to resume accepting connections.

Definition at line 703 of file tcp_server_legacy.c.

 {
   struct GNUNET_NETWORK_FDSet *r;
   unsigned int i;
  
   if (NULL == server->listen_sockets)
     return;
   if (NULL == server->listen_sockets[0])
     return; /* nothing to do, no listen sockets! */
   if (NULL == server->listen_sockets[1])
   {
     /* simplified method: no fd set needed; this is then much simpler
        and much more efficient */
     server->listen_task =
       GNUNET_SCHEDULER_add_read_net_with_priority (GNUNET_TIME_UNIT_FOREVER_REL,
                                                    GNUNET_SCHEDULER_PRIORITY_HIGH,
                                                    server->listen_sockets[0],
                                                    &process_listen_socket,
                                                    server);
     return;
   }
   r = GNUNET_NETWORK_fdset_create ();
   i = 0;
   while (NULL != server->listen_sockets[i])
     GNUNET_NETWORK_fdset_set (r, server->listen_sockets[i++]);
   server->listen_task =
     GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
                                  GNUNET_TIME_UNIT_FOREVER_REL, r, NULL,
                                  &process_listen_socket, server);
   GNUNET_NETWORK_fdset_destroy (r);
 }

References GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_NETWORK_fdset_set(), GNUNET_SCHEDULER_add_read_net_with_priority(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_PRIORITY_HIGH, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_SERVER_Handle::listen_sockets, GNUNET_SERVER_Handle::listen_task, and process_listen_socket().

Referenced by disconnect_notify(), GNUNET_SERVER_create_with_sockets(), and process_listen_socket().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_stop_listening()

void GNUNET_SERVER_stop_listening ( struct GNUNET_SERVER_Handle * server )

Stop the listen socket and get ready to shutdown the server once only 'monitor' clients are left.

Parameters

server server to stop listening on

Definition at line 743 of file tcp_server_legacy.c.

 {
   unsigned int i;
  
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Server in soft shutdown\n");
   if (NULL != server->listen_task)
   {
     GNUNET_SCHEDULER_cancel (server->listen_task);
     server->listen_task = NULL;
   }
   if (NULL != server->listen_sockets)
   {
     i = 0;
     while (NULL != server->listen_sockets[i])
       GNUNET_break (GNUNET_OK ==
                     GNUNET_NETWORK_socket_close (server->listen_sockets[i++]));
     GNUNET_free (server->listen_sockets);
     server->listen_sockets = NULL;
   }
   if (GNUNET_NO == server->in_soft_shutdown)
     server->in_soft_shutdown = GNUNET_YES;
   test_monitor_clients (server);
 }

References GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NETWORK_socket_close(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_YES, GNUNET_SERVER_Handle::in_soft_shutdown, GNUNET_SERVER_Handle::listen_sockets, GNUNET_SERVER_Handle::listen_task, LOG, and test_monitor_clients().

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_destroy()

void GNUNET_SERVER_destroy ( struct GNUNET_SERVER_Handle * server )

Free resources held by this server.

Parameters

server server to destroy

Definition at line 775 of file tcp_server_legacy.c.

 {
   struct HandlerList *hpos;
   struct NotifyList *npos;
   unsigned int i;
  
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Server shutting down.\n");
   if (NULL != server->listen_task)
   {
     GNUNET_SCHEDULER_cancel (server->listen_task);
     server->listen_task = NULL;
   }
   if (NULL != server->listen_sockets)
   {
     i = 0;
     while (NULL != server->listen_sockets[i])
       GNUNET_break (GNUNET_OK ==
                     GNUNET_NETWORK_socket_close (server->listen_sockets[i++]));
     GNUNET_free (server->listen_sockets);
     server->listen_sockets = NULL;
   }
   while (NULL != server->clients_head)
     GNUNET_SERVER_client_disconnect (server->clients_head);
   while (NULL != (hpos = server->handlers))
   {
     server->handlers = hpos->next;
     GNUNET_free (hpos);
   }
   while (NULL != (npos = server->disconnect_notify_list_head))
   {
     npos->callback (npos->callback_cls,
                     NULL);
     GNUNET_CONTAINER_DLL_remove (server->disconnect_notify_list_head,
                                  server->disconnect_notify_list_tail,
                                  npos);
     GNUNET_free (npos);
   }
   while (NULL != (npos = server->connect_notify_list_head))
   {
     npos->callback (npos->callback_cls,
                     NULL);
     GNUNET_CONTAINER_DLL_remove (server->connect_notify_list_head,
                                  server->connect_notify_list_tail,
                                  npos);
     GNUNET_free (npos);
   }
   GNUNET_free (server);
 }

Referenced by do_destroy(), LEGACY_SERVICE_stop(), libgnunet_plugin_transport_tcp_done(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_add_handlers()

void GNUNET_SERVER_add_handlers	(	struct GNUNET_SERVER_Handle *	server,
		const struct GNUNET_SERVER_MessageHandler *	handlers
	)

Add additional handlers to an existing server.

Parameters

server	the server to add handlers to
handlers	array of message handlers for incoming messages; the last entry must have "NULL" for the "callback"; multiple entries for the same type are allowed, they will be called in order of occurrence. These handlers can be removed later; the handlers array must exist until removed (or server is destroyed).

Definition at line 840 of file tcp_server_legacy.c.

 {
   struct HandlerList *p;
  
   p = GNUNET_new (struct HandlerList);
   p->handlers = handlers;
   p->next = server->handlers;
   server->handlers = p;
 }

References GNUNET_new, handlers, GNUNET_SERVER_Handle::handlers, and p.

Referenced by LEGACY_SERVICE_start(), libgnunet_plugin_transport_tcp_init(), and service_task().

Here is the caller graph for this function:

◆ GNUNET_SERVER_set_callbacks()

void GNUNET_SERVER_set_callbacks	(	struct GNUNET_SERVER_Handle *	server,
		GNUNET_SERVER_MstCreateCallback	create,
		GNUNET_SERVER_MstDestroyCallback	destroy,
		GNUNET_SERVER_MstReceiveCallback	receive,
		void *	cls
	)

Change functions used by the server to tokenize the message stream.

(very rarely used).

Parameters

server	server to modify
create	new tokenizer initialization function
destroy	new tokenizer destruction function
receive	new tokenizer receive function
cls	closure for create, receive, destroy

Definition at line 863 of file tcp_server_legacy.c.

 {
   server->mst_create = create;
   server->mst_destroy = destroy;
   server->mst_receive = receive;
   server->mst_cls = cls;
 }

References create, destroy(), GNUNET_SERVER_Handle::mst_cls, GNUNET_SERVER_Handle::mst_create, GNUNET_SERVER_Handle::mst_destroy, and GNUNET_SERVER_Handle::mst_receive.

Here is the call graph for this function:

◆ warn_no_receive_done()

static void warn_no_receive_done ( void * cls )

static

Task run to warn about missing calls to GNUNET_SERVER_receive_done.

Parameters

cls	our `struct GNUNET_SERVER_Client *` to process more requests from

Definition at line 882 of file tcp_server_legacy.c.

 {
   struct GNUNET_SERVER_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_receive_done, client);
   LOG (GNUNET_ERROR_TYPE_WARNING,
        _ (
          "Processing code for message of type %u did not call `GNUNET_SERVER_receive_done' 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_SERVER_Client::warn_start, GNUNET_SERVER_Client::warn_task, and GNUNET_SERVER_Client::warn_type.

Referenced by GNUNET_SERVER_inject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_disable_receive_done_warning()

void GNUNET_SERVER_disable_receive_done_warning ( struct GNUNET_SERVER_Client * client )

Disable the warning the server issues if a message is not acknowledged in a timely fashion.

Use this call if a client is intentionally delayed for a while. Only applies to the current message.

Parameters

client client for which to disable the warning

Definition at line 908 of file tcp_server_legacy.c.

 {
   if (NULL != client->warn_task)
   {
     GNUNET_SCHEDULER_cancel (client->warn_task);
     client->warn_task = NULL;
   }
 }

References GNUNET_SCHEDULER_cancel(), and GNUNET_SERVER_Client::warn_task.

Referenced by handle_tcp_data().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_inject()

int GNUNET_SERVER_inject	(	struct GNUNET_SERVER_Handle *	server,
		struct GNUNET_SERVER_Client *	sender,
		const struct GNUNET_MessageHeader *	message
	)

Inject a message into the server, pretend it came from the specified client.

Delivery of the message will happen instantly (if a handler is installed; otherwise the call does nothing).

Parameters

server	the server receiving the message
sender	the "pretended" sender of the message can be NULL!
message	message to transmit

Returns: GNUNET_OK if the message was OK and the connection can stay open GNUNET_SYSERR if the connection to the client should be shut down

Definition at line 934 of file tcp_server_legacy.c.

 {
   struct HandlerList *pos;
   const struct GNUNET_SERVER_MessageHandler *mh;
   unsigned int i;
   uint16_t type;
   uint16_t size;
   int found;
  
   type = ntohs (message->type);
   size = ntohs (message->size);
   LOG (GNUNET_ERROR_TYPE_INFO,
        "Received message of type %u and size %u from client\n",
        type, size);
   found = GNUNET_NO;
   for (pos = server->handlers; NULL != pos; pos = pos->next)
   {
     i = 0;
     while (pos->handlers[i].callback != NULL)
     {
       mh = &pos->handlers[i];
       if ((mh->type == type) || (mh->type == GNUNET_MESSAGE_TYPE_ALL))
       {
         if ((0 != mh->expected_size) && (mh->expected_size != size))
         {
 #if GNUNET8_NETWORK_IS_DEAD
           LOG (GNUNET_ERROR_TYPE_WARNING,
                "Expected %u bytes for message of type %u, got %u\n",
                mh->expected_size, mh->type, size);
           GNUNET_break_op (0);
 #else
           LOG (GNUNET_ERROR_TYPE_DEBUG,
                "Expected %u bytes for message of type %u, got %u\n",
                mh->expected_size, mh->type, size);
 #endif
           return GNUNET_SYSERR;
         }
         if (NULL != sender)
         {
           if ((0 == sender->suspended) &&
               (NULL == sender->warn_task))
           {
             GNUNET_break (0 != type);          /* type should never be 0 here, as we don't use 0 */
             sender->warn_start = GNUNET_TIME_absolute_get ();
             sender->warn_task =
               GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
                                             &warn_no_receive_done,
                                             sender);
             sender->warn_type = type;
           }
           sender->suspended++;
         }
         mh->callback (mh->callback_cls, sender, message);
         found = GNUNET_YES;
       }
       i++;
     }
   }
   if (GNUNET_NO == found)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
          "Received message of unknown type %d\n", type);
     if (GNUNET_YES == server->require_found)
       return GNUNET_SYSERR;
   }
   return GNUNET_OK;
 }

References GNUNET_SERVER_MessageHandler::callback, GNUNET_break, GNUNET_break_op, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_MESSAGE_TYPE_ALL, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_MINUTES, GNUNET_YES, HandlerList::handlers, GNUNET_SERVER_Handle::handlers, LOG, mh, HandlerList::next, GNUNET_SERVER_Handle::require_found, GNUNET_MessageHeader::size, size, GNUNET_SERVER_Client::suspended, GNUNET_MessageHeader::type, type, warn_no_receive_done(), GNUNET_SERVER_Client::warn_start, GNUNET_SERVER_Client::warn_task, and GNUNET_SERVER_Client::warn_type.

Referenced by client_message_tokenizer_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_incoming()

static void process_incoming	(	void *	cls,
		const void *	buf,
		size_t	available,
		const struct sockaddr *	addr,
		socklen_t	addrlen,
		int	errCode
	)

static

We are receiving an incoming message.

Process it.

Parameters

cls	our closure (handle for the client)
buf	buffer with data received from network
available	number of bytes available in buf
addr	address of the sender
addrlen	length of addr
errCode	code indicating errors receiving, 0 for success

Definition at line 1099 of file tcp_server_legacy.c.

 {
   struct GNUNET_SERVER_Client *client = cls;
   struct GNUNET_SERVER_Handle *server = client->server;
   struct GNUNET_TIME_Absolute end;
   struct GNUNET_TIME_Absolute now;
   int ret;
  
   GNUNET_assert (GNUNET_YES == client->receive_pending);
   client->receive_pending = GNUNET_NO;
   now = GNUNET_TIME_absolute_get ();
   end = GNUNET_TIME_absolute_add (client->last_activity,
                                   client->idle_timeout);
  
   if ((NULL == buf) &&
       (0 == available) &&
       (NULL == addr) &&
       (0 == errCode) &&
       (GNUNET_YES != client->shutdown_now) &&
       (NULL != server) &&
       (GNUNET_YES == GNUNET_CONNECTION_check (client->connection)) &&
       (end.abs_value_us > now.abs_value_us))
   {
     /* wait longer, timeout changed (i.e. due to us sending) */
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Receive time out, but no disconnect due to sending (%p)\n",
          client);
     client->receive_pending = GNUNET_YES;
     GNUNET_CONNECTION_receive (client->connection,
                                GNUNET_MAX_MESSAGE_SIZE - 1,
                                GNUNET_TIME_absolute_get_remaining (end),
                                &process_incoming,
                                client);
     return;
   }
   if ((NULL == buf) ||
       (0 == available) ||
       (0 != errCode) ||
       (NULL == server) ||
       (GNUNET_YES == client->shutdown_now) ||
       (GNUNET_YES != GNUNET_CONNECTION_check (client->connection)))
   {
     /* other side closed connection, error connecting, etc. */
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Failed to connect or other side closed connection (%p)\n",
          client);
     GNUNET_SERVER_client_disconnect (client);
     return;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Server receives %u bytes from `%s'.\n",
        (unsigned int) available,
        GNUNET_a2s (addr, addrlen));
   GNUNET_SERVER_client_keep (client);
   client->last_activity = now;
  
   if (NULL != server->mst_receive)
   {
     ret = client->server->mst_receive (client->server->mst_cls,
                                        client->mst,
                                        client,
                                        buf,
                                        available,
                                        GNUNET_NO,
                                        GNUNET_YES);
   }
   else if (NULL != client->mst)
   {
     ret =
       GNUNET_SERVER_mst_receive (client->mst,
                                  client,
                                  buf,
                                  available,
                                  GNUNET_NO,
                                  GNUNET_YES);
   }
   else
   {
     GNUNET_break (0);
     return;
   }
   process_mst (client,
                ret);
   GNUNET_SERVER_client_drop (client);
 }

References GNUNET_TIME_Absolute::abs_value_us, buf, GNUNET_SERVER_Client::connection, end, GNUNET_a2s(), GNUNET_assert, GNUNET_break, GNUNET_CONNECTION_check(), GNUNET_CONNECTION_receive(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MAX_MESSAGE_SIZE, GNUNET_NO, GNUNET_SERVER_client_disconnect(), GNUNET_SERVER_client_drop(), GNUNET_SERVER_client_keep(), GNUNET_SERVER_mst_receive(), GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, GNUNET_SERVER_Client::idle_timeout, GNUNET_SERVER_Client::last_activity, LOG, GNUNET_SERVER_Client::mst, GNUNET_SERVER_Handle::mst_cls, GNUNET_SERVER_Handle::mst_receive, process_mst(), GNUNET_SERVER_Client::receive_pending, ret, GNUNET_SERVER_Client::server, and GNUNET_SERVER_Client::shutdown_now.

Referenced by GNUNET_SERVER_connect_socket(), process_mst(), and restart_processing().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_mst()

static void process_mst	(	struct GNUNET_SERVER_Client *	client,
		int	ret
	)

static

Process messages from the client's message tokenizer until either the tokenizer is empty (and then schedule receiving more), or until some handler is not immediately done (then wait for restart_processing) or shutdown.

Parameters

client	the client to process, RC must have already been increased using GNUNET_SERVER_client_keep and will be decreased by one in this function
ret	GNUNET_NO to start processing from the buffer, GNUNET_OK if the mst buffer is drained and we should instantly go back to receiving GNUNET_SYSERR if we should instantly abort due to error in a previous step

Definition at line 1038 of file tcp_server_legacy.c.

 {
   while ((GNUNET_SYSERR != ret) && (NULL != client->server) &&
          (GNUNET_YES != client->shutdown_now) && (0 == client->suspended))
   {
     if (GNUNET_OK == ret)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Server re-enters receive loop, timeout: %s.\n",
            GNUNET_STRINGS_relative_time_to_string (client->idle_timeout,
                                                    GNUNET_YES));
       client->receive_pending = GNUNET_YES;
       if (GNUNET_OK !=
           GNUNET_CONNECTION_receive (client->connection,
                                      GNUNET_MAX_MESSAGE_SIZE - 1,
                                      client->idle_timeout,
                                      &process_incoming,
                                      client))
         return;
       break;
     }
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Server processes additional messages instantly.\n");
     if (NULL != client->server->mst_receive)
       ret =
         client->server->mst_receive (client->server->mst_cls, client->mst,
                                      client, NULL, 0, GNUNET_NO, GNUNET_YES);
     else
       ret =
         GNUNET_SERVER_mst_receive (client->mst, client, NULL, 0, GNUNET_NO,
                                    GNUNET_YES);
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Server leaves instant processing loop: ret = %d, server = %p, shutdown = %d, suspended = %u\n",
        ret, client->server,
        client->shutdown_now,
        client->suspended);
   if (GNUNET_NO == ret)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Server has more data pending but is suspended.\n");
     client->receive_pending = GNUNET_SYSERR;    /* data pending */
   }
   if ((GNUNET_SYSERR == ret) ||
       (GNUNET_YES == client->shutdown_now))
     GNUNET_SERVER_client_disconnect (client);
 }

References GNUNET_SERVER_Client::connection, GNUNET_CONNECTION_receive(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MAX_MESSAGE_SIZE, GNUNET_NO, GNUNET_OK, GNUNET_SERVER_client_disconnect(), GNUNET_SERVER_mst_receive(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_YES, GNUNET_SERVER_Client::idle_timeout, LOG, GNUNET_SERVER_Client::mst, GNUNET_SERVER_Handle::mst_cls, GNUNET_SERVER_Handle::mst_receive, process_incoming(), GNUNET_SERVER_Client::receive_pending, ret, GNUNET_SERVER_Client::server, GNUNET_SERVER_Client::shutdown_now, and GNUNET_SERVER_Client::suspended.

Referenced by process_incoming(), and restart_processing().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ restart_processing()

static void restart_processing ( void * cls )

static

Task run to start again receiving from the network and process requests.

Parameters

cls	our `struct GNUNET_SERVER_Client *` to process more requests from

Definition at line 1198 of file tcp_server_legacy.c.

 {
   struct GNUNET_SERVER_Client *client = cls;
  
   GNUNET_assert (GNUNET_YES != client->shutdown_now);
   client->restart_task = NULL;
   if (GNUNET_NO == client->receive_pending)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG, "Server begins to read again from client.\n");
     client->receive_pending = GNUNET_YES;
     GNUNET_CONNECTION_receive (client->connection,
                                GNUNET_MAX_MESSAGE_SIZE - 1,
                                client->idle_timeout,
                                &process_incoming,
                                client);
     return;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Server continues processing messages still in the buffer.\n");
   GNUNET_SERVER_client_keep (client);
   client->receive_pending = GNUNET_NO;
   process_mst (client,
                GNUNET_NO);
   GNUNET_SERVER_client_drop (client);
 }

References GNUNET_SERVER_Client::connection, GNUNET_assert, GNUNET_CONNECTION_receive(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MAX_MESSAGE_SIZE, GNUNET_NO, GNUNET_SERVER_client_drop(), GNUNET_SERVER_client_keep(), GNUNET_YES, GNUNET_SERVER_Client::idle_timeout, LOG, process_incoming(), process_mst(), GNUNET_SERVER_Client::receive_pending, GNUNET_SERVER_Client::restart_task, and GNUNET_SERVER_Client::shutdown_now.

Referenced by GNUNET_SERVER_receive_done().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ client_message_tokenizer_callback()

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

static

This function is called whenever our inbound message tokenizer has received a complete message.

Parameters

cls	closure (struct GNUNET_SERVER_Handle)
client	identification of the client (`struct GNUNET_SERVER_Client *`)
message	the actual message

Returns: GNUNET_OK on success, GNUNET_SYSERR to stop further processing

Definition at line 1236 of file tcp_server_legacy.c.

 {
   struct GNUNET_SERVER_Handle *server = cls;
   struct GNUNET_SERVER_Client *sender = client;
   int ret;
  
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Tokenizer gives server message of type %u and size %u from client\n",
        ntohs (message->type), ntohs (message->size));
   sender->in_process_client_buffer = GNUNET_YES;
   ret = GNUNET_SERVER_inject (server, sender, message);
   sender->in_process_client_buffer = GNUNET_NO;
   if ((GNUNET_OK != ret) || (GNUNET_YES == sender->shutdown_now))
   {
     GNUNET_SERVER_client_disconnect (sender);
     return GNUNET_SYSERR;
   }
   return GNUNET_OK;
 }

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_OK, GNUNET_SERVER_client_disconnect(), GNUNET_SERVER_inject(), GNUNET_SYSERR, GNUNET_YES, GNUNET_SERVER_Client::in_process_client_buffer, LOG, ret, GNUNET_SERVER_Client::server, GNUNET_SERVER_Client::shutdown_now, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by GNUNET_SERVER_connect_socket().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_connect_socket()

struct GNUNET_SERVER_Client* GNUNET_SERVER_connect_socket	(	struct GNUNET_SERVER_Handle *	server,
		struct GNUNET_CONNECTION_Handle *	connection
	)

Add a TCP socket-based connection to the set of handles managed by this server.

Use this function for outgoing (P2P) connections that we initiated (and where this server should process incoming messages).

Parameters

server	the server to use
connection	the connection to manage (client must stop using this connection from now on)

Returns: the client handle

Definition at line 1271 of file tcp_server_legacy.c.

 {
   struct GNUNET_SERVER_Client *client;
   struct NotifyList *n;
  
   client = GNUNET_new (struct GNUNET_SERVER_Client);
   client->connection = connection;
   client->server = server;
   client->last_activity = GNUNET_TIME_absolute_get ();
   client->idle_timeout = server->idle_timeout;
   GNUNET_CONTAINER_DLL_insert (server->clients_head,
                                server->clients_tail,
                                client);
   if (NULL != server->mst_create)
     client->mst =
       server->mst_create (server->mst_cls, client);
   else
     client->mst =
       GNUNET_SERVER_mst_create (&client_message_tokenizer_callback,
                                 server);
   GNUNET_assert (NULL != client->mst);
   for (n = server->connect_notify_list_head; NULL != n; n = n->next)
     n->callback (n->callback_cls, client);
   client->receive_pending = GNUNET_YES;
   if (GNUNET_SYSERR ==
       GNUNET_CONNECTION_receive (client->connection,
                                  GNUNET_MAX_MESSAGE_SIZE - 1,
                                  client->idle_timeout,
                                  &process_incoming,
                                  client))
     return NULL;
   return client;
 }

References NotifyList::callback, NotifyList::callback_cls, client_message_tokenizer_callback(), GNUNET_SERVER_Handle::clients_head, GNUNET_SERVER_Handle::clients_tail, GNUNET_SERVER_Handle::connect_notify_list_head, GNUNET_SERVER_Client::connection, GNUNET_assert, GNUNET_CONNECTION_receive(), GNUNET_CONTAINER_DLL_insert, GNUNET_MAX_MESSAGE_SIZE, GNUNET_new, GNUNET_SERVER_mst_create(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_YES, GNUNET_SERVER_Handle::idle_timeout, GNUNET_SERVER_Client::idle_timeout, GNUNET_SERVER_Client::last_activity, GNUNET_SERVER_Client::mst, GNUNET_SERVER_Handle::mst_cls, GNUNET_SERVER_Handle::mst_create, NotifyList::next, process_incoming(), GNUNET_SERVER_Client::receive_pending, and GNUNET_SERVER_Client::server.

Referenced by notify_send_probe(), process_listen_socket(), and tcp_plugin_get_session().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_client_set_timeout()

void GNUNET_SERVER_client_set_timeout	(	struct GNUNET_SERVER_Client *	client,
		struct GNUNET_TIME_Relative	timeout
	)

Change the timeout for a particular client.

Decreasing the timeout may not go into effect immediately (only after the previous timeout times out or activity happens on the socket).

Parameters

client	the client to update
timeout	new timeout for activities on the socket

Definition at line 1316 of file tcp_server_legacy.c.

 {
   client->idle_timeout = timeout;
 }

References GNUNET_SERVER_Client::idle_timeout, and timeout.

Referenced by handle_tcp_welcome(), and tcp_plugin_send().

Here is the caller graph for this function:

◆ GNUNET_SERVER_client_keep()

void GNUNET_SERVER_client_keep ( struct GNUNET_SERVER_Client * client )

Notify the server that the given client handle should be kept (keeps the connection up if possible, increments the internal reference counter).

Parameters

client the client to keep

Definition at line 1331 of file tcp_server_legacy.c.

 {
   client->reference_count++;
 }

References GNUNET_SERVER_Client::reference_count.

Referenced by process_incoming(), and restart_processing().

Here is the caller graph for this function:

◆ GNUNET_SERVER_client_drop()

void GNUNET_SERVER_client_drop ( struct GNUNET_SERVER_Client * client )

Notify the server that the given client handle is no longer required.

Decrements the reference counter. If that counter reaches zero an inactive connection maybe closed.

Parameters

client the client to drop

Definition at line 1346 of file tcp_server_legacy.c.

 {
   GNUNET_assert (client->reference_count > 0);
   client->reference_count--;
   if ((GNUNET_YES == client->shutdown_now) && (0 == client->reference_count))
     GNUNET_SERVER_client_disconnect (client);
 }

References GNUNET_assert, GNUNET_SERVER_client_disconnect(), GNUNET_YES, GNUNET_SERVER_Client::reference_count, and GNUNET_SERVER_Client::shutdown_now.

Referenced by process_incoming(), and restart_processing().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_client_get_address()

int GNUNET_SERVER_client_get_address	(	struct GNUNET_SERVER_Client *	client,
		void **	addr,
		size_t *	addrlen
	)

Obtain the network address of the other party.

Parameters

client	the client to get the address for
addr	where to store the address
addrlen	where to store the length of the addr

Returns: GNUNET_OK on success

Definition at line 1364 of file tcp_server_legacy.c.

 {
   return GNUNET_CONNECTION_get_address (client->connection, addr, addrlen);
 }

References GNUNET_SERVER_Client::connection, and GNUNET_CONNECTION_get_address().

Referenced by handle_tcp_data(), handle_tcp_nat_probe(), and handle_tcp_welcome().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_disconnect_notify()

void GNUNET_SERVER_disconnect_notify	(	struct GNUNET_SERVER_Handle *	server,
		GNUNET_SERVER_DisconnectCallback	callback,
		void *	callback_cls
	)

Ask the server to notify us whenever a client disconnects.

This function is called whenever the actual network connection is closed; the reference count may be zero or larger than zero at this point.

Parameters

server	the server manageing the clients
callback	function to call on disconnect
callback_cls	closure for callback

Definition at line 1382 of file tcp_server_legacy.c.

 {
   struct NotifyList *n;
  
   n = GNUNET_new (struct NotifyList);
   n->callback = callback;
   n->callback_cls = callback_cls;
   GNUNET_CONTAINER_DLL_insert (server->disconnect_notify_list_head,
                                server->disconnect_notify_list_tail,
                                n);
 }

References NotifyList::callback, NotifyList::callback_cls, GNUNET_SERVER_Handle::disconnect_notify_list_head, GNUNET_SERVER_Handle::disconnect_notify_list_tail, GNUNET_CONTAINER_DLL_insert, and GNUNET_new.

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the caller graph for this function:

◆ GNUNET_SERVER_connect_notify()

void GNUNET_SERVER_connect_notify	(	struct GNUNET_SERVER_Handle *	server,
		GNUNET_SERVER_ConnectCallback	callback,
		void *	callback_cls
	)

Ask the server to notify us whenever a client connects.

This function is called whenever the actual network connection is opened. If the server is destroyed before this notification is explicitly cancelled, the 'callback' will once be called with a 'client' argument of NULL to indicate that the server itself is now gone (and that the callback won't be called anymore and also can no longer be cancelled).

Parameters

server	the server manageing the clients
callback	function to call on sconnect
callback_cls	closure for callback

Definition at line 1411 of file tcp_server_legacy.c.

 {
   struct NotifyList *n;
   struct GNUNET_SERVER_Client *client;
  
   n = GNUNET_new (struct NotifyList);
   n->callback = callback;
   n->callback_cls = callback_cls;
   GNUNET_CONTAINER_DLL_insert (server->connect_notify_list_head,
                                server->connect_notify_list_tail,
                                n);
   for (client = server->clients_head; NULL != client; client = client->next)
     callback (callback_cls, client);
 }

References NotifyList::callback, NotifyList::callback_cls, GNUNET_SERVER_Handle::clients_head, GNUNET_SERVER_Handle::connect_notify_list_head, GNUNET_SERVER_Handle::connect_notify_list_tail, GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_SERVER_Client::next, and GNUNET_SERVER_Client::server.

Referenced by libgnunet_plugin_transport_tcp_init().

Here is the caller graph for this function:

◆ GNUNET_SERVER_disconnect_notify_cancel()

void GNUNET_SERVER_disconnect_notify_cancel	(	struct GNUNET_SERVER_Handle *	server,
		GNUNET_SERVER_DisconnectCallback	callback,
		void *	callback_cls
	)

Ask the server to stop notifying us whenever a client connects.

Parameters

server	the server manageing the clients
callback	function to call on connect
callback_cls	closure for callback

Definition at line 1437 of file tcp_server_legacy.c.

 {
   struct NotifyList *pos;
  
   for (pos = server->disconnect_notify_list_head; NULL != pos; pos = pos->next)
     if ((pos->callback == callback) && (pos->callback_cls == callback_cls))
       break;
   if (NULL == pos)
   {
     GNUNET_break (0);
     return;
   }
   GNUNET_CONTAINER_DLL_remove (server->disconnect_notify_list_head,
                                server->disconnect_notify_list_tail,
                                pos);
   GNUNET_free (pos);
 }

References NotifyList::callback, NotifyList::callback_cls, GNUNET_SERVER_Handle::disconnect_notify_list_head, GNUNET_SERVER_Handle::disconnect_notify_list_tail, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, and NotifyList::next.

◆ GNUNET_SERVER_connect_notify_cancel()

void GNUNET_SERVER_connect_notify_cancel	(	struct GNUNET_SERVER_Handle *	server,
		GNUNET_SERVER_ConnectCallback	callback,
		void *	callback_cls
	)

Ask the server to stop notifying us whenever a client disconnects.

Parameters

server	the server manageing the clients
callback	function to call on disconnect
callback_cls	closure for callback

Definition at line 1467 of file tcp_server_legacy.c.

 {
   struct NotifyList *pos;
  
   for (pos = server->connect_notify_list_head; NULL != pos; pos = pos->next)
     if ((pos->callback == callback) && (pos->callback_cls == callback_cls))
       break;
   if (NULL == pos)
   {
     GNUNET_break (0);
     return;
   }
   GNUNET_CONTAINER_DLL_remove (server->connect_notify_list_head,
                                server->connect_notify_list_tail,
                                pos);
   GNUNET_free (pos);
 }

References NotifyList::callback, NotifyList::callback_cls, GNUNET_SERVER_Handle::connect_notify_list_head, GNUNET_SERVER_Handle::connect_notify_list_tail, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, and NotifyList::next.

◆ GNUNET_SERVER_client_disconnect()

void GNUNET_SERVER_client_disconnect ( struct GNUNET_SERVER_Client * client )

Ask the server to disconnect from the given client.

This is the same as returning GNUNET_SYSERR from a message handler, except that it allows dropping of a client even when not handling a message from that client.

Parameters

client the client to disconnect from

Definition at line 1497 of file tcp_server_legacy.c.

 {
   struct GNUNET_SERVER_Handle *server = client->server;
   struct NotifyList *n;
  
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Client is being disconnected from the server.\n");
   if (NULL != client->restart_task)
   {
     GNUNET_SCHEDULER_cancel (client->restart_task);
     client->restart_task = NULL;
   }
   if (NULL != client->warn_task)
   {
     GNUNET_SCHEDULER_cancel (client->warn_task);
     client->warn_task = NULL;
   }
   if (GNUNET_YES == client->receive_pending)
   {
     GNUNET_CONNECTION_receive_cancel (client->connection);
     client->receive_pending = GNUNET_NO;
   }
   client->shutdown_now = GNUNET_YES;
   client->reference_count++; /* make sure nobody else clean up client... */
   if ((NULL != client->mst) &&
       (NULL != server))
   {
     GNUNET_CONTAINER_DLL_remove (server->clients_head,
                                  server->clients_tail,
                                  client);
     if (NULL != server->mst_destroy)
       server->mst_destroy (server->mst_cls,
                            client->mst);
     else
       GNUNET_SERVER_mst_destroy (client->mst);
     client->mst = NULL;
     for (n = server->disconnect_notify_list_head; NULL != n; n = n->next)
       n->callback (n->callback_cls,
                    client);
   }
   client->reference_count--;
   if (client->reference_count > 0)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "RC of %p still positive, not destroying everything.\n",
          client);
     client->server = NULL;
     return;
   }
   if (GNUNET_YES == client->in_process_client_buffer)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Still processing inputs of %p, not destroying everything.\n",
          client);
     return;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "RC of %p now zero, destroying everything.\n",
        client);
   if (GNUNET_YES == client->persist)
     GNUNET_CONNECTION_persist_ (client->connection);
   if (NULL != client->th.cth)
     GNUNET_SERVER_notify_transmit_ready_cancel (&client->th);
   GNUNET_CONNECTION_destroy (client->connection);
   /* need to cancel again, as it might have been re-added
      in the meantime (i.e. during callbacks) */
   if (NULL != client->warn_task)
   {
     GNUNET_SCHEDULER_cancel (client->warn_task);
     client->warn_task = NULL;
   }
   if (GNUNET_YES == client->receive_pending)
   {
     GNUNET_CONNECTION_receive_cancel (client->connection);
     client->receive_pending = GNUNET_NO;
   }
   GNUNET_free (client);
   /* we might be in soft-shutdown, test if we're done */
   if (NULL != server)
     test_monitor_clients (server);
 }

Referenced by client_message_tokenizer_callback(), GNUNET_SERVER_client_drop(), GNUNET_SERVER_destroy(), GNUNET_SERVER_receive_done(), process_incoming(), process_mst(), and tcp_plugin_disconnect_session().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_client_disable_corking()

int GNUNET_SERVER_client_disable_corking ( struct GNUNET_SERVER_Client * client )

Disable the "CORK" feature for communication with the given client, forcing the OS to immediately flush the buffer on transmission instead of potentially buffering multiple messages.

Parameters

client handle to the client

Returns: GNUNET_OK on success

Definition at line 1589 of file tcp_server_legacy.c.

 {
   return GNUNET_CONNECTION_disable_corking (client->connection);
 }

References GNUNET_SERVER_Client::connection, and GNUNET_CONNECTION_disable_corking().

Here is the call graph for this function:

◆ transmit_ready_callback_wrapper()

static size_t transmit_ready_callback_wrapper	(	void *	cls,
		size_t	size,
		void *	buf
	)

static

Wrapper for transmission notification that calls the original callback and update the last activity time for our connection.

Parameters

cls	the `struct GNUNET_SERVER_Client *`
size	number of bytes we can transmit
buf	where to copy the message

Returns: number of bytes actually transmitted

Definition at line 1605 of file tcp_server_legacy.c.

 {
   struct GNUNET_SERVER_Client *client = cls;
   GNUNET_CONNECTION_TransmitReadyNotify callback;
  
   client->th.cth = NULL;
   callback = client->th.callback;
   client->th.callback = NULL;
   client->last_activity = GNUNET_TIME_absolute_get ();
   return callback (client->th.callback_cls, size, buf);
 }

References buf, GNUNET_SERVER_TransmitHandle::callback, GNUNET_SERVER_TransmitHandle::callback_cls, GNUNET_SERVER_TransmitHandle::cth, GNUNET_TIME_absolute_get(), GNUNET_SERVER_Client::last_activity, size, and GNUNET_SERVER_Client::th.

Referenced by GNUNET_SERVER_notify_transmit_ready().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_notify_transmit_ready()

struct GNUNET_SERVER_TransmitHandle* GNUNET_SERVER_notify_transmit_ready	(	struct GNUNET_SERVER_Client *	client,
		size_t	size,
		struct GNUNET_TIME_Relative	timeout,
		GNUNET_CONNECTION_TransmitReadyNotify	callback,
		void *	callback_cls
	)

Notify us when the server has enough space to transmit a message of the given size to the given client.

Parameters

client	client to transmit message to
size	requested amount of buffer space
timeout	after how long should we give up (and call notify with buf NULL and size 0)?
callback	function to call when space is available
callback_cls	closure for callback

Returns: non-NULL if the notify callback was queued; can be used to cancel the request using GNUNET_SERVER_notify_transmit_ready_cancel. NULL if we are already going to notify someone else (busy)

Definition at line 1619 of file tcp_server_legacy.c.

 {
   if (NULL != client->th.callback)
     return NULL;
   client->th.callback_cls = callback_cls;
   client->th.callback = callback;
   client->th.cth = GNUNET_CONNECTION_notify_transmit_ready (client->connection,
                                                             size,
                                                             timeout,
                                                             &
                                                             transmit_ready_callback_wrapper,
                                                             client);
   return &client->th;
 }

References GNUNET_SERVER_TransmitHandle::callback, GNUNET_SERVER_TransmitHandle::callback_cls, GNUNET_SERVER_Client::connection, GNUNET_SERVER_TransmitHandle::cth, GNUNET_CONNECTION_notify_transmit_ready(), size, GNUNET_SERVER_Client::th, timeout, and transmit_ready_callback_wrapper().

Referenced by process_pending_messages().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_notify_transmit_ready_cancel()

void GNUNET_SERVER_notify_transmit_ready_cancel ( struct GNUNET_SERVER_TransmitHandle * th )

Abort transmission request.

Parameters

th	request to abort

Definition at line 1646 of file tcp_server_legacy.c.

 {
   GNUNET_CONNECTION_notify_transmit_ready_cancel (th->cth);
   th->cth = NULL;
   th->callback = NULL;
 }

References GNUNET_SERVER_TransmitHandle::callback, GNUNET_SERVER_TransmitHandle::cth, and GNUNET_CONNECTION_notify_transmit_ready_cancel().

Referenced by GNUNET_SERVER_client_disconnect(), and tcp_plugin_disconnect_session().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_SERVER_client_persist_()

void GNUNET_SERVER_client_persist_ ( struct GNUNET_SERVER_Client * client )

Set the persistent flag on this client, used to setup client connection to only be killed when the service it's connected to is actually dead.

Parameters

client the client to set the persistent flag on

Definition at line 1662 of file tcp_server_legacy.c.

 {
   client->persist = GNUNET_YES;
 }

References GNUNET_YES, and GNUNET_SERVER_Client::persist.

◆ GNUNET_SERVER_receive_done()

void GNUNET_SERVER_receive_done	(	struct GNUNET_SERVER_Client *	client,
		int	success
	)

Resume receiving from this client, we are done processing the current request.

This function must be called from within each GNUNET_SERVER_MessageCallback (or its respective continuations).

Parameters

client	client we were processing a message of
success	GNUNET_OK to keep the connection open and continue to receive GNUNET_NO to close the connection (normal behavior) GNUNET_SYSERR to close the connection (signal serious error)

Definition at line 1681 of file tcp_server_legacy.c.

 {
   if (NULL == client)
     return;
   GNUNET_assert (client->suspended > 0);
   client->suspended--;
   if (GNUNET_OK != success)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "GNUNET_SERVER_receive_done called with failure indication\n");
     if ((client->reference_count > 0) || (client->suspended > 0))
       client->shutdown_now = GNUNET_YES;
     else
       GNUNET_SERVER_client_disconnect (client);
     return;
   }
   if (client->suspended > 0)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "GNUNET_SERVER_receive_done called, but more clients pending\n");
     return;
   }
   if (NULL != client->warn_task)
   {
     GNUNET_SCHEDULER_cancel (client->warn_task);
     client->warn_task = NULL;
   }
   if (GNUNET_YES == client->in_process_client_buffer)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "GNUNET_SERVER_receive_done called while still in processing loop\n");
     return;
   }
   if ((NULL == client->server) || (GNUNET_YES == client->shutdown_now))
   {
     GNUNET_SERVER_client_disconnect (client);
     return;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "GNUNET_SERVER_receive_done causes restart in reading from the socket\n");
   GNUNET_assert (NULL == client->restart_task);
   client->restart_task = GNUNET_SCHEDULER_add_now (&restart_processing,
                                                    client);
 }

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_SERVER_client_disconnect(), GNUNET_YES, GNUNET_SERVER_Client::in_process_client_buffer, LOG, GNUNET_SERVER_Client::reference_count, restart_processing(), GNUNET_SERVER_Client::restart_task, GNUNET_SERVER_Client::server, GNUNET_SERVER_Client::shutdown_now, GNUNET_SERVER_Client::suspended, and GNUNET_SERVER_Client::warn_task.

Referenced by delayed_done(), handle_tcp_data(), handle_tcp_nat_probe(), handle_tcp_welcome(), and write_test().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Macros

Functions

Macro Definition Documentation

◆ LOG_STRERROR_FILE

Function Documentation

◆ GNUNET_SERVER_client_get_user_context_()

◆ GNUNET_SERVER_client_set_user_context_()

◆ process_listen_socket()

◆ open_listen_socket()

◆ GNUNET_SERVER_create_with_sockets()

◆ GNUNET_SERVER_create()

◆ GNUNET_SERVER_client_mark_monitor()

◆ do_destroy()

◆ test_monitor_clients()

◆ GNUNET_SERVER_suspend()

◆ GNUNET_SERVER_resume()

◆ GNUNET_SERVER_stop_listening()

◆ GNUNET_SERVER_destroy()

◆ GNUNET_SERVER_add_handlers()

◆ GNUNET_SERVER_set_callbacks()

◆ warn_no_receive_done()

◆ GNUNET_SERVER_disable_receive_done_warning()

◆ GNUNET_SERVER_inject()

◆ process_incoming()

◆ process_mst()

◆ restart_processing()

◆ client_message_tokenizer_callback()

◆ GNUNET_SERVER_connect_socket()

◆ GNUNET_SERVER_client_set_timeout()

◆ GNUNET_SERVER_client_keep()

◆ GNUNET_SERVER_client_drop()

◆ GNUNET_SERVER_client_get_address()

◆ GNUNET_SERVER_disconnect_notify()

◆ GNUNET_SERVER_connect_notify()

◆ GNUNET_SERVER_disconnect_notify_cancel()

◆ GNUNET_SERVER_connect_notify_cancel()

◆ GNUNET_SERVER_client_disconnect()

◆ GNUNET_SERVER_client_disable_corking()

◆ transmit_ready_callback_wrapper()

◆ GNUNET_SERVER_notify_transmit_ready()

◆ GNUNET_SERVER_notify_transmit_ready_cancel()

◆ GNUNET_SERVER_client_persist_()

◆ GNUNET_SERVER_receive_done()