HTTP/S server transport plugin. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_plugin.h"
#include "gnunet_nat_service.h"
#include "plugin_transport_http_common.h"
#include <microhttpd.h>
#include <regex.h>
#include "gnunet_mhd_compat.h"

Include dependency graph for plugin_transport_http_server.c:

Data Structures
struct	ServerRequest
	Information we keep with MHD for an HTTP request. More...

struct	HttpAddressWrapper
	Wrapper to manage addresses. More...

struct	HTTP_Message
	Message to send using http. More...

struct	GNUNET_ATS_Session
	Session handle for connections. More...

struct	HTTP_Server_Plugin
	Encapsulation of all of the state of the plugin. More...

struct	GNUNET_ATS_SessionTagContext
	Closure for session_tag_it(). More...

Macros
#define	PLUGIN_NAME "http_server"

#define	LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_http_server_init

#define	LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_http_server_done

#define	HTTP_ERROR_RESPONSE "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\"><HTML><HEAD><TITLE>404 Not Found</TITLE></HEAD><BODY><H1>Not Found</H1>The requested URL was not found on this server.<P><HR><ADDRESS></ADDRESS></BODY></HTML>"

#define	_RECEIVE 0

#define	_SEND 1

#define	LOG(kind, ...)

#define	OPTION_LONG_POLL 1 /* GET request wants long-poll semantics */

#define	URL_REGEX ("^.*/([0-9A-Z]+);([0-9]+)(,[0-9]+)?$")

Functions
static void	notify_session_monitor (struct HTTP_Server_Plugin plugin, struct GNUNET_ATS_Session session, enum GNUNET_TRANSPORT_SessionState state)
	If a session monitor is attached, notify it about the new session state. More...

static void	server_wake_up (void *cls)
	Wake up an MHD connection which was suspended. More...

static void	server_reschedule (struct HTTP_Server_Plugin plugin, struct MHD_Daemon server, int now)
	Reschedule the execution of both IPv4 and IPv6 server. More...

static void	server_delete_session (struct GNUNET_ATS_Session *s)
	Deletes the session. More...

static int	http_server_plugin_disconnect_session (void cls, struct GNUNET_ATS_Session s)
	Disconnect session s by telling MHD to close the connections (reducing timeout, etc.). More...

static void	server_session_timeout (void *cls)
	Session was idle, so disconnect it. More...

static void	server_reschedule_session_timeout (struct GNUNET_ATS_Session *s)
	Increment session timeout due to activity session s. More...

static ssize_t	http_server_plugin_send (void cls, struct GNUNET_ATS_Session session, const char msgbuf, size_t msgbuf_size, unsigned int priority, struct GNUNET_TIME_Relative to, GNUNET_TRANSPORT_TransmitContinuation cont, void cont_cls)
	Function that can be used by the transport service to transmit a message using the plugin. More...

static int	destroy_session_shutdown_cb (void cls, const struct GNUNET_PeerIdentity peer, void *value)
	Terminate session during shutdown. More...

static int	destroy_session_cb (void cls, const struct GNUNET_PeerIdentity peer, void *value)
	Terminate session. More...

static void	http_server_plugin_disconnect_peer (void cls, const struct GNUNET_PeerIdentity target)
	Function that can be used to force the plugin to disconnect from the given peer and cancel all previous transmissions (and their continuationc). More...

static int	http_server_plugin_address_suggested (void cls, const void addr, size_t addrlen)
	Another peer has suggested an address for this peer and transport plugin. More...

static struct GNUNET_ATS_Session *	http_server_plugin_get_session (void cls, const struct GNUNET_HELLO_Address address)
	Creates a new outbound session the transport service will use to send data to the peer. More...

static void	server_v4_run (void *cls)
	Call MHD IPv4 to process pending requests and then go back and schedule the next run. More...

static void	server_v6_run (void *cls)
	Call MHD IPv6 to process pending requests and then go back and schedule the next run. More...

static struct GNUNET_SCHEDULER_Task *	server_schedule (struct HTTP_Server_Plugin plugin, struct MHD_Daemon daemon_handle, int now)
	Function that queries MHD's select sets and starts the task waiting for them. More...

static unsigned int	http_server_query_keepalive_factor (void *cls)
	Function that is called to get the keepalive factor. More...

static void	http_server_plugin_update_session_timeout (void cls, const struct GNUNET_PeerIdentity peer, struct GNUNET_ATS_Session *session)
	Function that will be called whenever the transport service wants to notify the plugin that a session is still active and in use and therefore the session timeout for this session has to be updated. More...

static void	server_mhd_connection_timeout (struct HTTP_Server_Plugin plugin, struct GNUNET_ATS_Session s, unsigned int to)
	Tell MHD that the connection should timeout after to seconds. More...

static int	server_parse_url (struct HTTP_Server_Plugin plugin, const char url, struct GNUNET_PeerIdentity target, uint32_t tag, uint32_t *options)
	Parse incoming URL for tag and target. More...

static int	session_tag_it (void cls, const struct GNUNET_PeerIdentity key, void *value)
	Find a session with a matching tag. More...

static struct ServerRequest *	server_lookup_connection (struct HTTP_Server_Plugin plugin, struct MHD_Connection mhd_connection, const char url, const char method)
	Lookup a mhd connection and create one if none is found. More...

static ssize_t	server_send_callback (void cls, uint64_t pos, char buf, size_t max)
	Callback called by MHD when it needs data to send. More...

static int	server_receive_mst_cb (void cls, const struct GNUNET_MessageHeader message)
	Callback called by MessageStreamTokenizer when a message has arrived. More...

static void	add_cors_headers (struct MHD_Response *response)
	Add headers to a request indicating that we allow Cross-Origin Resource Sharing. More...

static MHD_RESULT	server_access_cb (void cls, struct MHD_Connection mhd_connection, const char url, const char method, const char version, const char upload_data, size_t upload_data_size, void *httpSessionCache)
	MHD callback for a new incoming connection. More...

static void	server_disconnect_cb (void cls, struct MHD_Connection connection, void **httpSessionCache)
	Callback from MHD when a connection disconnects. More...

static void	server_connection_cb (void cls, struct MHD_Connection connection, void **socket_context, enum MHD_ConnectionNotificationCode toe)
	Callback from MHD when a connection starts/stops. More...

static MHD_RESULT	server_accept_cb (void cls, const struct sockaddr addr, socklen_t addr_len)
	Check if incoming connection is accepted. More...

static void	server_log (void arg, const char fmt, va_list ap)
	Log function called by MHD. More...

static struct MHD_Daemon *	run_mhd_start_daemon (struct HTTP_Server_Plugin plugin, const struct sockaddr_in addr, int v6)
	Invoke `MHD_start_daemon` with the various options we need to setup the HTTP server with the given listen address. More...

static int	server_start (struct HTTP_Server_Plugin *plugin)
	Start the HTTP server. More...

static void	server_add_address (void cls, int add_remove, const struct sockaddr addr, socklen_t addrlen)
	Add an address to the server's set of addresses and notify transport. More...

static void	server_remove_address (void cls, int add_remove, const struct sockaddr addr, socklen_t addrlen)
	Remove an address from the server's set of addresses and notify transport. More...

static void	server_nat_port_map_callback (void cls, void app_ctx, int add_remove, enum GNUNET_NAT_AddressClass ac, const struct sockaddr addr, socklen_t addrlen)
	Our external IP address/port mapping has changed. More...

static int	server_get_addresses (struct HTTP_Server_Plugin plugin, const char service_name, const struct GNUNET_CONFIGURATION_Handle cfg, struct sockaddr addrs, socklen_t addr_lens)
	Get valid server addresses. More...

static void	server_start_report_addresses (struct HTTP_Server_Plugin *plugin)
	Ask NAT for addresses. More...

static void	server_stop_report_addresses (struct HTTP_Server_Plugin *plugin)
	Stop NAT for addresses. More...

static int	server_check_ipv6_support (struct HTTP_Server_Plugin *plugin)
	Check if IPv6 supported on this system. More...

static void	server_notify_external_hostname (void *cls)
	Notify server about our external hostname. More...

static int	server_configure_plugin (struct HTTP_Server_Plugin *plugin)
	Configure the plugin. More...

void *	libgnunet_plugin_transport_http_client_done (void *cls)
	Exit point from the plugin. More...

static const char *	http_server_plugin_address_to_string (void cls, const void addr, size_t addrlen)
	Function called for a quick conversion of the binary address to a numeric address. More...

static enum GNUNET_NetworkType	http_server_plugin_get_network (void cls, struct GNUNET_ATS_Session session)
	Function obtain the network type for a session. More...

static enum GNUNET_NetworkType	http_server_plugin_get_network_for_address (void cls, const struct GNUNET_HELLO_Address address)
	Function obtain the network type for an address. More...

static void	http_server_plugin_update_inbound_delay (void cls, const struct GNUNET_PeerIdentity peer, struct GNUNET_ATS_Session *session, struct GNUNET_TIME_Relative delay)
	Function that will be called whenever the transport service wants to notify the plugin that the inbound quota changed and that the plugin should update it's delay for the next receive value. More...

static int	send_session_info_iter (void cls, const struct GNUNET_PeerIdentity peer, void *value)
	Return information about the given session to the monitor callback. More...

static void	http_server_plugin_setup_monitor (void cls, GNUNET_TRANSPORT_SessionInfoCallback sic, void sic_cls)
	Begin monitoring sessions of a plugin. More...

void *	libgnunet_plugin_transport_http_client_init (void *cls)
	Entry point for the plugin. More...

Detailed Description

HTTP/S server transport plugin.

Author: Matthias Wachs; David Barksdale; Christian Grothoff

Definition in file plugin_transport_http_server.c.

Macro Definition Documentation

◆ PLUGIN_NAME

#define PLUGIN_NAME "http_server"

Definition at line 45 of file plugin_transport_http_server.c.

◆ LIBGNUNET_PLUGIN_TRANSPORT_INIT

#define LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_http_server_init

Definition at line 46 of file plugin_transport_http_server.c.

◆ LIBGNUNET_PLUGIN_TRANSPORT_DONE

#define LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_http_server_done

Definition at line 48 of file plugin_transport_http_server.c.

◆ HTTP_ERROR_RESPONSE

#define HTTP_ERROR_RESPONSE "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\"><HTML><HEAD><TITLE>404 Not Found</TITLE></HEAD><BODY><H1>Not Found</H1>The requested URL was not found on this server.<P><HR><ADDRESS></ADDRESS></BODY></HTML>"

Definition at line 52 of file plugin_transport_http_server.c.

◆ _RECEIVE

#define _RECEIVE 0

Definition at line 54 of file plugin_transport_http_server.c.

◆ _SEND

#define _SEND 1

Definition at line 55 of file plugin_transport_http_server.c.

◆ LOG

#define LOG	(	kind,
		...
	)

Value:

GNUNET_log_from (kind, "transport-" PLUGIN_NAME, \

__VA_ARGS__)

GNUNET_log_from

#define GNUNET_log_from(kind, comp,...)

Definition: gnunet_common.h:542

PLUGIN_NAME

#define PLUGIN_NAME

Definition: plugin_transport_http_server.c:45

Definition at line 58 of file plugin_transport_http_server.c.

◆ OPTION_LONG_POLL

#define OPTION_LONG_POLL 1 /* GET request wants long-poll semantics */

Definition at line 87 of file plugin_transport_http_server.c.

◆ URL_REGEX

#define URL_REGEX ("^.*/([0-9A-Z]+);([0-9]+)(,[0-9]+)?$")

Function Documentation

◆ notify_session_monitor()

static void notify_session_monitor	(	struct HTTP_Server_Plugin *	plugin,
		struct GNUNET_ATS_Session *	session,
		enum GNUNET_TRANSPORT_SessionState	state
	)

static

If a session monitor is attached, notify it about the new session state.

Parameters

plugin	our plugin
session	session that changed state
state	new state of the session

Definition at line 474 of file plugin_transport_http_server.c.

 {
   struct GNUNET_TRANSPORT_SessionInfo info;
  
   if (NULL == plugin->sic)
     return;
   memset (&info, 0, sizeof(info));
   info.state = state;
   info.is_inbound = GNUNET_YES;
   info.num_msg_pending = session->msgs_in_queue;
   info.num_bytes_pending = session->bytes_in_queue;
   info.receive_delay = session->next_receive;
   info.session_timeout = session->timeout;
   info.address = session->address;
   plugin->sic (plugin->sic_cls,
                session,
                &info);
 }

References GNUNET_ATS_Session::address, GNUNET_ATS_Session::bytes_in_queue, GNUNET_YES, info, GNUNET_ATS_Session::msgs_in_queue, GNUNET_ATS_Session::next_receive, plugin, state, and GNUNET_ATS_Session::timeout.

Referenced by http_server_plugin_send(), send_session_info_iter(), server_delete_session(), server_lookup_connection(), server_receive_mst_cb(), server_send_callback(), and server_session_timeout().

Here is the caller graph for this function:

◆ server_wake_up()

static void server_wake_up ( void * cls )

static

Wake up an MHD connection which was suspended.

Parameters

cls	the session

Definition at line 502 of file plugin_transport_http_server.c.

 {
   struct GNUNET_ATS_Session *s = cls;
  
   s->recv_wakeup_task = NULL;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Session %p: Waking up PUT handle\n",
        s);
   GNUNET_assert (s->server_recv->suspended);
   MHD_resume_connection (s->server_recv->mhd_conn);
   s->server_recv->suspended = false;
 }

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, LOG, ServerRequest::mhd_conn, GNUNET_ATS_Session::recv_wakeup_task, GNUNET_ATS_Session::server_recv, and ServerRequest::suspended.

Referenced by http_server_plugin_update_inbound_delay(), and server_access_cb().

Here is the caller graph for this function:

◆ server_reschedule()

static void server_reschedule	(	struct HTTP_Server_Plugin *	plugin,
		struct MHD_Daemon *	server,
		int	now
	)

static

Reschedule the execution of both IPv4 and IPv6 server.

Parameters

plugin	the plugin
server	which server to schedule v4 or v6?
now	GNUNET_YES to schedule execution immediately, GNUNET_NO to wait until timeout

Definition at line 1084 of file plugin_transport_http_server.c.

 {
   if ((server == plugin->server_v4) && (plugin->server_v4 != NULL))
   {
     if (GNUNET_YES == plugin->server_v4_immediately)
       return;   /* No rescheduling, server will run asap */
  
     if (GNUNET_YES == now)
       plugin->server_v4_immediately = GNUNET_YES;
  
     if (plugin->server_v4_task != NULL)
     {
       GNUNET_SCHEDULER_cancel (plugin->server_v4_task);
       plugin->server_v4_task = NULL;
     }
     plugin->server_v4_task = server_schedule (plugin, plugin->server_v4, now);
   }
  
   if ((server == plugin->server_v6) && (plugin->server_v6 != NULL))
   {
     if (GNUNET_YES == plugin->server_v6_immediately)
       return;   /* No rescheduling, server will run asap */
  
     if (GNUNET_YES == now)
       plugin->server_v6_immediately = GNUNET_YES;
  
     if (plugin->server_v6_task != NULL)
     {
       GNUNET_SCHEDULER_cancel (plugin->server_v6_task);
       plugin->server_v6_task = NULL;
     }
     plugin->server_v6_task = server_schedule (plugin, plugin->server_v6, now);
   }
 }

References GNUNET_SCHEDULER_cancel(), GNUNET_YES, plugin, and server_schedule().

Referenced by http_server_plugin_send(), server_connection_cb(), server_delete_session(), server_mhd_connection_timeout(), server_start(), server_v4_run(), and server_v6_run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_delete_session()

static void server_delete_session ( struct GNUNET_ATS_Session * s )

static

Deletes the session.

Must not be used afterwards.

Parameters

s	the session to delete

Definition at line 536 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = s->plugin;
   struct HTTP_Message *msg;
  
   if (NULL != s->timeout_task)
   {
     GNUNET_SCHEDULER_cancel (s->timeout_task);
     s->timeout_task = NULL;
     s->timeout = GNUNET_TIME_UNIT_ZERO_ABS;
   }
   if (NULL != s->recv_wakeup_task)
   {
     GNUNET_SCHEDULER_cancel (s->recv_wakeup_task);
     s->recv_wakeup_task = NULL;
     if (NULL != s->server_recv)
     {
       GNUNET_assert (s->server_recv->suspended);
       s->server_recv->suspended = false;
       MHD_resume_connection (s->server_recv->mhd_conn);
     }
   }
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONTAINER_multipeermap_remove (plugin->sessions,
                                                        &s->target,
                                                        s));
   while (NULL != (msg = s->msg_head))
   {
     GNUNET_CONTAINER_DLL_remove (s->msg_head,
                                  s->msg_tail,
                                  msg);
     if (NULL != msg->transmit_cont)
       msg->transmit_cont (msg->transmit_cont_cls,
                           &s->target,
                           GNUNET_SYSERR,
                           msg->size,
                           msg->pos + msg->overhead);
     GNUNET_assert (s->msgs_in_queue > 0);
     s->msgs_in_queue--;
     GNUNET_assert (s->bytes_in_queue >= msg->size);
     s->bytes_in_queue -= msg->size;
     GNUNET_free (msg);
   }
  
   GNUNET_assert (0 == s->msgs_in_queue);
   GNUNET_assert (0 == s->bytes_in_queue);
  
   if (NULL != s->server_send)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Server: %p / %p Terminating inbound PUT session to peer `%s'\n",
          s, s->server_send,
          GNUNET_i2s (&s->target));
     s->server_send->session = NULL;
     MHD_set_connection_option (s->server_send->mhd_conn,
                                MHD_CONNECTION_OPTION_TIMEOUT,
                                1 /* 0 = no timeout, so this is MIN */);
     if (s->server_send->suspended)
     {
       s->server_send->suspended = false;
       MHD_resume_connection (s->server_send->mhd_conn);
     }
     server_reschedule (plugin,
                        s->server_send->mhd_daemon,
                        GNUNET_YES);
   }
  
   if (NULL != s->server_recv)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Server: %p / %p Terminating inbound GET session to peer `%s'\n",
          s, s->server_recv, GNUNET_i2s (&s->target));
     s->server_recv->session = NULL;
     MHD_set_connection_option (s->server_recv->mhd_conn,
                                MHD_CONNECTION_OPTION_TIMEOUT,
                                1 /* 0 = no timeout, so this is MIN */);
     server_reschedule (plugin,
                        s->server_recv->mhd_daemon,
                        GNUNET_YES);
   }
   notify_session_monitor (plugin,
                           s,
                           GNUNET_TRANSPORT_SS_DONE);
   if (GNUNET_YES == s->known_to_service)
   {
     plugin->env->session_end (plugin->env->cls,
                               s->address,
                               s);
     s->known_to_service = GNUNET_NO;
   }
   if (NULL != s->msg_tk)
   {
     GNUNET_MST_destroy (s->msg_tk);
     s->msg_tk = NULL;
   }
   GNUNET_HELLO_address_free (s->address);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Session %p destroyed\n",
        s);
   GNUNET_free (s);
 }

Referenced by destroy_session_cb(), destroy_session_shutdown_cb(), http_server_plugin_disconnect_session(), and server_session_timeout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ http_server_plugin_disconnect_session()

static int http_server_plugin_disconnect_session	(	void *	cls,
		struct GNUNET_ATS_Session *	s
	)

static

Disconnect session s by telling MHD to close the connections (reducing timeout, etc.).

Parameters

cls	closure with the `struct HTTP_Server_Plugin`
s	the session

Returns: GNUNET_OK on success

Definition at line 648 of file plugin_transport_http_server.c.

 {
   server_delete_session (s);
   return GNUNET_OK;
 }

References GNUNET_OK, and server_delete_session().

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_session_timeout()

static void server_session_timeout ( void * cls )

static

Session was idle, so disconnect it.

Parameters

cls	the session

Definition at line 662 of file plugin_transport_http_server.c.

 {
   struct GNUNET_ATS_Session *s = cls;
   struct GNUNET_TIME_Relative left;
  
   s->timeout_task = NULL;
   left = GNUNET_TIME_absolute_get_remaining (s->timeout);
   if (0 != left.rel_value_us)
   {
     /* not actually our turn yet, but let's at least update
        the monitor, it may think we're about to die ... */
     notify_session_monitor (s->plugin,
                             s,
                             GNUNET_TRANSPORT_SS_UP);
     s->timeout_task = GNUNET_SCHEDULER_add_delayed (left,
                                                     &server_session_timeout,
                                                     s);
     return;
   }
   GNUNET_log (TIMEOUT_LOG,
               "Session %p was idle for %s, disconnecting\n",
               s,
               GNUNET_STRINGS_relative_time_to_string (
                 HTTP_SERVER_SESSION_TIMEOUT,
                 GNUNET_YES));
   server_delete_session (s);
 }

References GNUNET_log, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TRANSPORT_SS_UP, GNUNET_YES, HTTP_SERVER_SESSION_TIMEOUT, notify_session_monitor(), GNUNET_ATS_Session::plugin, GNUNET_TIME_Relative::rel_value_us, server_delete_session(), GNUNET_ATS_Session::timeout, TIMEOUT_LOG, and GNUNET_ATS_Session::timeout_task.

Referenced by server_lookup_connection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_reschedule_session_timeout()

static void server_reschedule_session_timeout ( struct GNUNET_ATS_Session * s )

static

Increment session timeout due to activity session s.

Parameters

s	the session

Definition at line 697 of file plugin_transport_http_server.c.

 {
   GNUNET_assert (NULL != s->timeout_task);
   s->timeout = GNUNET_TIME_relative_to_absolute (
     GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
 }

References GNUNET_assert, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_TIME_relative_to_absolute(), GNUNET_ATS_Session::timeout, and GNUNET_ATS_Session::timeout_task.

Referenced by http_server_plugin_update_session_timeout(), and server_receive_mst_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ http_server_plugin_send()

static ssize_t http_server_plugin_send	(	void *	cls,
		struct GNUNET_ATS_Session *	session,
		const char *	msgbuf,
		size_t	msgbuf_size,
		unsigned int	priority,
		struct GNUNET_TIME_Relative	to,
		GNUNET_TRANSPORT_TransmitContinuation	cont,
		void *	cont_cls
	)

static

Function that can be used by the transport service to transmit a message using the plugin.

Note that in the case of a peer disconnecting, the continuation MUST be called prior to the disconnect notification itself. This function will be called with this peer's HELLO message to initiate a fresh connection to another peer.

Parameters

cls	closure
session	which session must be used
msgbuf	the message to transmit
msgbuf_size	number of bytes in msgbuf
priority	how important is the message (most plugins will ignore message priority and just FIFO)
to	how long to wait at most for the transmission (does not require plugins to discard the message after the timeout, just advisory for the desired delay; most plugins will ignore this as well)
cont	continuation to call once the message has been transmitted (or if the transport is ready for the next transmission call; or if the peer disconnected...); can be NULL
cont_cls	closure for cont

Returns: number of bytes used (on the physical network, with overheads); -1 on hard errors (i.e. address invalid); 0 is a legal value and does NOT mean that the message was not transmitted (DV)

Definition at line 733 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
   struct HTTP_Message *msg;
   ssize_t bytes_sent = 0;
   char *stat_txt;
  
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Session %p/request %p: Sending message with %lu to peer `%s'\n",
        session,
        session->server_send,
        (unsigned long) msgbuf_size,
        GNUNET_i2s (&session->target));
  
   /* create new message and schedule */
   bytes_sent = sizeof(struct HTTP_Message) + msgbuf_size;
   msg = GNUNET_malloc (bytes_sent);
   msg->next = NULL;
   msg->size = msgbuf_size;
   msg->pos = 0;
   msg->buf = (char *) &msg[1];
   msg->transmit_cont = cont;
   msg->transmit_cont_cls = cont_cls;
   GNUNET_memcpy (msg->buf,
                  msgbuf,
                  msgbuf_size);
   GNUNET_CONTAINER_DLL_insert_tail (session->msg_head,
                                     session->msg_tail,
                                     msg);
   session->msgs_in_queue++;
   session->bytes_in_queue += msg->size;
   notify_session_monitor (plugin,
                           session,
                           GNUNET_TRANSPORT_SS_UP);
   GNUNET_asprintf (&stat_txt,
                    "# bytes currently in %s_server buffers",
                    plugin->protocol);
   GNUNET_STATISTICS_update (plugin->env->stats,
                             stat_txt, msgbuf_size, GNUNET_NO);
   GNUNET_free (stat_txt);
  
   if (NULL != session->server_send)
   {
     if (session->server_send->suspended)
     {
       MHD_resume_connection (session->server_send->mhd_conn);
       session->server_send->suspended = false;
     }
     server_reschedule (session->plugin,
                        session->server_send->mhd_daemon,
                        GNUNET_YES);
   }
   return bytes_sent;
 }

References GNUNET_ATS_Session::bytes_in_queue, GNUNET_asprintf(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TRANSPORT_SS_UP, GNUNET_YES, LOG, ServerRequest::mhd_conn, ServerRequest::mhd_daemon, msg, GNUNET_ATS_Session::msg_head, GNUNET_ATS_Session::msg_tail, GNUNET_ATS_Session::msgs_in_queue, notify_session_monitor(), plugin, GNUNET_ATS_Session::plugin, server_reschedule(), GNUNET_ATS_Session::server_send, GNUNET_MessageHeader::size, ServerRequest::suspended, and GNUNET_ATS_Session::target.

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_session_shutdown_cb()

static int destroy_session_shutdown_cb	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		void *	value
	)

static

Terminate session during shutdown.

Parameters

cls	the `struct HTTP_Server_Plugin *`
peer	for which this is a session
value	the `struct GNUNET_ATS_Session` to clean up

Returns: GNUNET_OK (continue to iterate)

Definition at line 805 of file plugin_transport_http_server.c.

 {
   struct GNUNET_ATS_Session *s = value;
   struct ServerRequest *sc_send;
   struct ServerRequest *sc_recv;
  
   sc_send = s->server_send;
   sc_recv = s->server_recv;
   server_delete_session (s);
   if (NULL != sc_send)
     sc_send->session = NULL;
   if (NULL != sc_recv)
     sc_recv->session = NULL;
  
   return GNUNET_OK;
 }

References GNUNET_OK, server_delete_session(), GNUNET_ATS_Session::server_recv, GNUNET_ATS_Session::server_send, ServerRequest::session, and value.

Referenced by libgnunet_plugin_transport_http_client_done().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_session_cb()

static int destroy_session_cb	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		void *	value
	)

static

Terminate session.

Parameters

cls	the `struct HTTP_Server_Plugin *`
peer	for which this is a session
value	the `struct GNUNET_ATS_Session` to clean up

Returns: GNUNET_OK (continue to iterate)

Definition at line 834 of file plugin_transport_http_server.c.

 {
   struct GNUNET_ATS_Session *s = value;
  
   server_delete_session (s);
   return GNUNET_OK;
 }

References GNUNET_OK, server_delete_session(), and value.

Referenced by http_server_plugin_disconnect_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ http_server_plugin_disconnect_peer()

static void http_server_plugin_disconnect_peer	(	void *	cls,
		const struct GNUNET_PeerIdentity *	target
	)

static

Function that can be used to force the plugin to disconnect from the given peer and cancel all previous transmissions (and their continuationc).

Parameters

cls	closure
target	peer from which to disconnect

Definition at line 854 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
  
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Transport tells me to disconnect `%s'\n",
        GNUNET_i2s (target));
   GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessions,
                                               target,
                                               &destroy_session_cb,
                                               plugin);
 }

References destroy_session_cb(), GNUNET_CONTAINER_multipeermap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), LOG, and plugin.

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ http_server_plugin_address_suggested()

static int http_server_plugin_address_suggested	(	void *	cls,
		const void *	addr,
		size_t	addrlen
	)

static

Another peer has suggested an address for this peer and transport plugin.

Check that this could be a valid address. If so, consider adding it to the list of addresses.

Parameters

cls	closure
addr	pointer to the address
addrlen	length of addr

Returns: GNUNET_OK if this is a plausible address for this peer and transport

Definition at line 882 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
   struct HttpAddressWrapper *next;
   struct HttpAddressWrapper *pos;
   const struct HttpAddress *haddr = addr;
  
   if ((NULL != plugin->ext_addr) &&
       (GNUNET_YES == (http_common_cmp_addresses (addr, addrlen,
                                                  plugin->ext_addr->address,
                                                  plugin->ext_addr->
                                                  address_length))) )
   {
     /* Checking HTTP_OPTIONS_VERIFY_CERTIFICATE option for external hostname */
     if ((ntohl (haddr->options) & HTTP_OPTIONS_VERIFY_CERTIFICATE) !=
         (plugin->options & HTTP_OPTIONS_VERIFY_CERTIFICATE))
       return GNUNET_NO;   /* VERIFY option not set as required! */
     return GNUNET_OK;
   }
   next = plugin->addr_head;
   while (NULL != (pos = next))
   {
     next = pos->next;
     if (GNUNET_YES == (http_common_cmp_addresses (addr,
                                                   addrlen,
                                                   pos->address,
                                                   pos->addrlen)))
       return GNUNET_OK;
   }
   return GNUNET_NO;
 }

References HttpAddress::addr, HttpAddressWrapper::address, HttpAddressWrapper::addrlen, GNUNET_NO, GNUNET_OK, GNUNET_YES, http_common_cmp_addresses(), HTTP_OPTIONS_VERIFY_CERTIFICATE, HttpAddressWrapper::next, HttpAddress::options, and plugin.

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ http_server_plugin_get_session()

static struct GNUNET_ATS_Session* http_server_plugin_get_session	(	void *	cls,
		const struct GNUNET_HELLO_Address *	address
	)

static

Creates a new outbound session the transport service will use to send data to the peer.

Since HTTP/S server cannot create sessions, always returns NULL.

Parameters

cls	the plugin
address	the address

Returns: always NULL

Definition at line 928 of file plugin_transport_http_server.c.

 {
   return NULL;
 }

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the caller graph for this function:

◆ server_v4_run()

static void server_v4_run ( void * cls )

static

Call MHD IPv4 to process pending requests and then go back and schedule the next run.

Parameters

cls	plugin as closure

Definition at line 942 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
  
   plugin->server_v4_task = NULL;
   plugin->server_v4_immediately = GNUNET_NO;
   GNUNET_assert (MHD_YES == MHD_run (plugin->server_v4));
   server_reschedule (plugin, plugin->server_v4, GNUNET_NO);
 }

References GNUNET_assert, GNUNET_NO, plugin, and server_reschedule().

Referenced by server_schedule().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_v6_run()

static void server_v6_run ( void * cls )

static

Call MHD IPv6 to process pending requests and then go back and schedule the next run.

Parameters

cls	plugin as closure

Definition at line 960 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
  
   plugin->server_v6_task = NULL;
   plugin->server_v6_immediately = GNUNET_NO;
   GNUNET_assert (MHD_YES == MHD_run (plugin->server_v6));
   server_reschedule (plugin, plugin->server_v6, GNUNET_NO);
 }

References GNUNET_assert, GNUNET_NO, plugin, and server_reschedule().

Referenced by server_schedule().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_schedule()

static struct GNUNET_SCHEDULER_Task* server_schedule	(	struct HTTP_Server_Plugin *	plugin,
		struct MHD_Daemon *	daemon_handle,
		int	now
	)

static

Function that queries MHD's select sets and starts the task waiting for them.

Parameters

plugin	plugin
daemon_handle	the MHD daemon handle
now	schedule now

Returns: gnunet task identifier

Definition at line 981 of file plugin_transport_http_server.c.

 {
   struct GNUNET_SCHEDULER_Task *ret;
   fd_set rs;
   fd_set ws;
   fd_set es;
   struct GNUNET_NETWORK_FDSet *wrs;
   struct GNUNET_NETWORK_FDSet *wws;
   int max;
   MHD_UNSIGNED_LONG_LONG timeout;
   static unsigned long long last_timeout = 0;
   int haveto;
   struct GNUNET_TIME_Relative tv;
  
   if (GNUNET_YES == plugin->in_shutdown)
     return NULL;
  
   ret = NULL;
   FD_ZERO (&rs);
   FD_ZERO (&ws);
   FD_ZERO (&es);
   wrs = GNUNET_NETWORK_fdset_create ();
   wws = GNUNET_NETWORK_fdset_create ();
   max = -1;
   GNUNET_assert (MHD_YES ==
                  MHD_get_fdset (daemon_handle,
                                 &rs,
                                 &ws,
                                 &es,
                                 &max));
   haveto = MHD_get_timeout (daemon_handle, &timeout);
   if (haveto == MHD_YES)
   {
     if (timeout != last_timeout)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "SELECT Timeout changed from %llu to %llu (ms)\n",
            last_timeout, timeout);
       last_timeout = timeout;
     }
     if (timeout <= GNUNET_TIME_UNIT_SECONDS.rel_value_us / 1000LL)
       tv.rel_value_us = (uint64_t) timeout * 1000LL;
     else
       tv = GNUNET_TIME_UNIT_SECONDS;
   }
   else
     tv = GNUNET_TIME_UNIT_SECONDS;
   /* Force immediate run, since we have outbound data to send */
   if (now == GNUNET_YES)
     tv = GNUNET_TIME_UNIT_MILLISECONDS;
   GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
   GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
  
   if (daemon_handle == plugin->server_v4)
   {
     if (plugin->server_v4_task != NULL)
     {
       GNUNET_SCHEDULER_cancel (plugin->server_v4_task);
       plugin->server_v4_task = NULL;
     }
 #if 0
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Scheduling IPv4 server task in %llu ms\n",
          tv);
 #endif
     ret =
       GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                    tv, wrs, wws,
                                    &server_v4_run, plugin);
   }
   if (daemon_handle == plugin->server_v6)
   {
     if (plugin->server_v6_task != NULL)
     {
       GNUNET_SCHEDULER_cancel (plugin->server_v6_task);
       plugin->server_v6_task = NULL;
     }
 #if 0
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Scheduling IPv6 server task in %llu ms\n", tv);
 #endif
     ret =
       GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                    tv, wrs, wws,
                                    &server_v6_run, plugin);
   }
   GNUNET_NETWORK_fdset_destroy (wrs);
   GNUNET_NETWORK_fdset_destroy (wws);
   return ret;
 }

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NETWORK_fdset_copy_native(), GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, LOG, max, plugin, GNUNET_TIME_Relative::rel_value_us, ret, server_v4_run(), server_v6_run(), and timeout.

Referenced by server_reschedule().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ http_server_query_keepalive_factor()

static unsigned int http_server_query_keepalive_factor ( void * cls )

static

Function that is called to get the keepalive factor.

GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT is divided by this number to calculate the interval between keepalive packets.

Parameters

cls	closure with the `struct HTTP_Server_Plugin`

Returns: keepalive factor

Definition at line 1131 of file plugin_transport_http_server.c.

 {
   return 3;
 }

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the caller graph for this function:

◆ http_server_plugin_update_session_timeout()

static void http_server_plugin_update_session_timeout	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		struct GNUNET_ATS_Session *	session
	)

static

Function that will be called whenever the transport service wants to notify the plugin that a session is still active and in use and therefore the session timeout for this session has to be updated.

Parameters

cls	closure
peer	which peer was the session for
session	which session is being updated

Definition at line 1147 of file plugin_transport_http_server.c.

 {
   server_reschedule_session_timeout (session);
 }

References server_reschedule_session_timeout().

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_mhd_connection_timeout()

static void server_mhd_connection_timeout	(	struct HTTP_Server_Plugin *	plugin,
		struct GNUNET_ATS_Session *	s,
		unsigned int	to
	)

static

Tell MHD that the connection should timeout after to seconds.

Parameters

plugin	our plugin
s	session for which the timeout changes
to	timeout in seconds

Definition at line 1164 of file plugin_transport_http_server.c.

 {
   /* Setting timeouts for other connections */
   if (NULL != s->server_recv)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Setting timeout for %p to %u sec.\n",
          s->server_recv, to);
     MHD_set_connection_option (s->server_recv->mhd_conn,
                                MHD_CONNECTION_OPTION_TIMEOUT,
                                to);
     server_reschedule (plugin, s->server_recv->mhd_daemon, GNUNET_NO);
   }
   if (NULL != s->server_send)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Setting timeout for %p to %u sec.\n",
          s->server_send, to);
     MHD_set_connection_option (s->server_send->mhd_conn,
                                MHD_CONNECTION_OPTION_TIMEOUT,
                                to);
     server_reschedule (plugin, s->server_send->mhd_daemon, GNUNET_NO);
   }
 }

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, LOG, ServerRequest::mhd_conn, ServerRequest::mhd_daemon, plugin, GNUNET_ATS_Session::server_recv, server_reschedule(), and GNUNET_ATS_Session::server_send.

Referenced by server_access_cb(), and server_lookup_connection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_parse_url()

static int server_parse_url	(	struct HTTP_Server_Plugin *	plugin,
		const char *	url,
		struct GNUNET_PeerIdentity *	target,
		uint32_t *	tag,
		uint32_t *	options
	)

static

Parse incoming URL for tag and target.

Parameters

plugin	plugin
url	incoming url
target	where to store the target
tag	where to store the tag
options	where to store the options

Returns: GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1203 of file plugin_transport_http_server.c.

 {
   regmatch_t matches[4];
   const char *tag_start;
   const char *target_start;
   char *tag_end;
   char *options_end;
   size_t hash_length;
   unsigned long int rc;
  
   /* URL parsing */
 #define URL_REGEX \
   ("^.*/([0-9A-Z]+);([0-9]+)(,[0-9]+)?$")
  
   if (NULL == url)
   {
     GNUNET_break (0);
     return GNUNET_SYSERR;
   }
  
   if (regexec (&plugin->url_regex, url, 4, matches, 0))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "URL `%s' did not match regex\n", url);
     return GNUNET_SYSERR;
   }
  
   target_start = &url[matches[1].rm_so];
   tag_start = &url[matches[2].rm_so];
  
   /* convert tag */
   rc = strtoul (tag_start, &tag_end, 10);
   if (&url[matches[2].rm_eo] != tag_end)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "URL tag did not line up with submatch\n");
     return GNUNET_SYSERR;
   }
   if (rc == 0)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "URL tag is zero\n");
     return GNUNET_SYSERR;
   }
   if ((rc == ULONG_MAX) && (ERANGE == errno))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "URL tag > ULONG_MAX\n");
     return GNUNET_SYSERR;
   }
   if (rc > UINT32_MAX)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "URL tag > UINT32_MAX\n");
     return GNUNET_SYSERR;
   }
   (*tag) = (uint32_t) rc;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Found tag `%u' in url\n",
        *tag);
  
   /* convert peer id */
   hash_length = matches[1].rm_eo - matches[1].rm_so;
   if (hash_length != plugin->peer_id_length)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "URL target is %lu bytes, expecting %u\n",
          (unsigned long) hash_length, plugin->peer_id_length);
     return GNUNET_SYSERR;
   }
   if (GNUNET_OK !=
       GNUNET_CRYPTO_eddsa_public_key_from_string (target_start,
                                                   hash_length,
                                                   &target->public_key))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "URL target conversion failed\n");
     return GNUNET_SYSERR;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Found target `%s' in URL\n",
        GNUNET_i2s_full (target));
  
   /* convert options */
   if (-1 == matches[3].rm_so)
   {
     *options = 0;
   }
   else
   {
     rc = strtoul (&url[matches[3].rm_so + 1], &options_end, 10);
     if (&url[matches[3].rm_eo] != options_end)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "URL options did not line up with submatch\n");
       return GNUNET_SYSERR;
     }
     if ((rc == ULONG_MAX) && (ERANGE == errno))
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "URL options > ULONG_MAX\n");
       return GNUNET_SYSERR;
     }
     if (rc > UINT32_MAX)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "URL options > UINT32_MAX\n");
       return GNUNET_SYSERR;
     }
     (*options) = (uint32_t) rc;
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Found options `%u' in url\n",
          *options);
   }
   return GNUNET_OK;
 }

References GNUNET_break, GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s_full(), GNUNET_OK, GNUNET_SYSERR, LOG, warningfilter::matches, options, plugin, and GNUNET_PeerIdentity::public_key.

Referenced by server_lookup_connection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ session_tag_it()

static int session_tag_it	(	void *	cls,
		const struct GNUNET_PeerIdentity *	key,
		void *	value
	)

static

Find a session with a matching tag.

Parameters

cls	the `struct GNUNET_ATS_SessionTagContext *`
key	peer identity (unused)
value	the `struct GNUNET_ATS_Session *`

Returns: GNUNET_NO if we found the session, GNUNET_OK if not

Definition at line 1351 of file plugin_transport_http_server.c.

 {
   struct GNUNET_ATS_SessionTagContext *stc = cls;
   struct GNUNET_ATS_Session *s = value;
  
   if (s->tag == stc->tag)
   {
     stc->res = s;
     return GNUNET_NO;
   }
   return GNUNET_YES;
 }

References GNUNET_NO, GNUNET_YES, GNUNET_ATS_SessionTagContext::res, GNUNET_ATS_Session::tag, GNUNET_ATS_SessionTagContext::tag, and value.

Referenced by server_lookup_connection().

Here is the caller graph for this function:

◆ server_lookup_connection()

static struct ServerRequest* server_lookup_connection	(	struct HTTP_Server_Plugin *	plugin,
		struct MHD_Connection *	mhd_connection,
		const char *	url,
		const char *	method
	)

static

Lookup a mhd connection and create one if none is found.

Parameters

plugin	the plugin handle
mhd_connection	the incoming mhd_connection
url	incoming requested URL
method	PUT or GET

Returns: the server connecetion

Definition at line 1377 of file plugin_transport_http_server.c.

 {
   struct GNUNET_ATS_Session *s = NULL;
   struct ServerRequest *sc = NULL;
   const union MHD_ConnectionInfo *conn_info;
   struct HttpAddress *addr;
   struct GNUNET_PeerIdentity target;
   size_t addr_len;
   struct GNUNET_ATS_SessionTagContext stc;
   uint32_t options;
   int direction = GNUNET_SYSERR;
   unsigned int to;
   enum GNUNET_NetworkType scope;
  
   conn_info = MHD_get_connection_info (mhd_connection,
                                        MHD_CONNECTION_INFO_CLIENT_ADDRESS);
   if ((conn_info->client_addr->sa_family != AF_INET) &&
       (conn_info->client_addr->sa_family != AF_INET6))
     return NULL;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "New %s request from %s\n",
        method,
        url);
   stc.tag = 0;
   options = 0; /* make gcc happy */
   if (GNUNET_SYSERR ==
       server_parse_url (plugin, url, &target, &stc.tag, &options))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Invalid url %s\n", url);
     return NULL;
   }
   if (0 == strcmp (MHD_HTTP_METHOD_PUT, method))
     direction = _RECEIVE;
   else if (0 == strcmp (MHD_HTTP_METHOD_GET, method))
     direction = _SEND;
   else
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Invalid method %s for request from %s\n",
          method, url);
     return NULL;
   }
  
   plugin->cur_request++;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "New %s request from %s with tag %u (%u of %u)\n",
        method,
        GNUNET_i2s (&target),
        stc.tag,
        plugin->cur_request, plugin->max_request);
   /* find existing session */
   stc.res = NULL;
   GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessions,
                                               &target,
                                               &session_tag_it,
                                               &stc);
   if (NULL == (s = stc.res))
   {
     /* create new session */
     addr = NULL;
     switch (conn_info->client_addr->sa_family)
     {
     case (AF_INET):
       addr = http_common_address_from_socket (plugin->protocol,
                                               conn_info->client_addr,
                                               sizeof(struct sockaddr_in));
       addr_len = http_common_address_get_size (addr);
       scope = plugin->env->get_address_type (plugin->env->cls,
                                              conn_info->client_addr,
                                              sizeof(struct sockaddr_in));
       break;
  
     case (AF_INET6):
       addr = http_common_address_from_socket (plugin->protocol,
                                               conn_info->client_addr,
                                               sizeof(struct sockaddr_in6));
       addr_len = http_common_address_get_size (addr);
       scope = plugin->env->get_address_type (plugin->env->cls,
                                              conn_info->client_addr,
                                              sizeof(struct sockaddr_in6));
       break;
  
     default:
       /* external host name */
       return NULL;
     }
     s = GNUNET_new (struct GNUNET_ATS_Session);
     s->target = target;
     s->plugin = plugin;
     s->scope = scope;
     s->address = GNUNET_HELLO_address_allocate (&s->target,
                                                 PLUGIN_NAME,
                                                 addr,
                                                 addr_len,
                                                 GNUNET_HELLO_ADDRESS_INFO_INBOUND);
     s->next_receive = GNUNET_TIME_UNIT_ZERO_ABS;
     s->tag = stc.tag;
     s->timeout = GNUNET_TIME_relative_to_absolute (HTTP_SERVER_SESSION_TIMEOUT);
     s->timeout_task = GNUNET_SCHEDULER_add_delayed (HTTP_SERVER_SESSION_TIMEOUT,
                                                     &server_session_timeout,
                                                     s);
     (void) GNUNET_CONTAINER_multipeermap_put (plugin->sessions,
                                               &s->target,
                                               s,
                                               GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
     notify_session_monitor (plugin,
                             s,
                             GNUNET_TRANSPORT_SS_INIT);
     notify_session_monitor (plugin,
                             s,
                             GNUNET_TRANSPORT_SS_HANDSHAKE);
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Creating new session %p for peer `%s' connecting from `%s'\n",
          s, GNUNET_i2s (&target),
          http_common_plugin_address_to_string (plugin->protocol,
                                                addr,
                                                addr_len));
     GNUNET_free (addr);
   }
  
   if ((_RECEIVE == direction) &&
       (NULL != s->server_recv))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Duplicate PUT request from `%s' tag %u, dismissing new request\n",
          GNUNET_i2s (&target),
          stc.tag);
     return NULL;
   }
   if ((_SEND == direction) && (NULL != s->server_send))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Duplicate GET request from `%s' tag %u, dismissing new request\n",
          GNUNET_i2s (&target),
          stc.tag);
     return NULL;
   }
   sc = GNUNET_new (struct ServerRequest);
   if (conn_info->client_addr->sa_family == AF_INET)
     sc->mhd_daemon = plugin->server_v4;
   if (conn_info->client_addr->sa_family == AF_INET6)
     sc->mhd_daemon = plugin->server_v6;
   sc->mhd_conn = mhd_connection;
   sc->direction = direction;
   sc->connected = GNUNET_NO;
   sc->session = s;
   sc->options = options;
   if (direction == _SEND)
   {
     s->server_send = sc;
   }
   if (direction == _RECEIVE)
   {
     s->server_recv = sc;
   }
  
   if ((GNUNET_NO == s->known_to_service) &&
       (NULL != s->server_send) &&
       (NULL != s->server_recv))
   {
     s->known_to_service = GNUNET_YES;
     notify_session_monitor (plugin,
                             s,
                             GNUNET_TRANSPORT_SS_UP);
     plugin->env->session_start (plugin->env->cls,
                                 s->address,
                                 s,
                                 s->scope);
   }
  
   to = (HTTP_SERVER_SESSION_TIMEOUT.rel_value_us / 1000LL / 1000LL);
   server_mhd_connection_timeout (plugin, s, to);
   return sc;
 }

Referenced by server_access_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_send_callback()

static ssize_t server_send_callback	(	void *	cls,
		uint64_t	pos,
		char *	buf,
		size_t	max
	)

static

Callback called by MHD when it needs data to send.

Parameters

cls	current session
pos	position in buffer
buf	the buffer to write data to
max	max number of bytes available in buf

Returns: bytes written to buf

Definition at line 1567 of file plugin_transport_http_server.c.

 {
   struct ServerRequest *sc = cls;
   struct GNUNET_ATS_Session *s = sc->session;
   ssize_t bytes_read = 0;
   struct HTTP_Message *msg;
   char *stat_txt;
  
   if (NULL == s)
   {
     /* session is disconnecting */
     return 0;
   }
  
   sc = s->server_send;
   if (NULL == sc)
     return 0;
   msg = s->msg_head;
   if (NULL != msg)
   {
     /* sending */
     bytes_read = GNUNET_MIN (msg->size - msg->pos,
                              max);
     GNUNET_memcpy (buf, &msg->buf[msg->pos], bytes_read);
     msg->pos += bytes_read;
  
     /* removing message */
     if (msg->pos == msg->size)
     {
       GNUNET_CONTAINER_DLL_remove (s->msg_head,
                                    s->msg_tail,
                                    msg);
       if (NULL != msg->transmit_cont)
         msg->transmit_cont (msg->transmit_cont_cls, &s->target, GNUNET_OK,
                             msg->size, msg->size + msg->overhead);
       GNUNET_assert (s->msgs_in_queue > 0);
       s->msgs_in_queue--;
       GNUNET_assert (s->bytes_in_queue >= msg->size);
       s->bytes_in_queue -= msg->size;
       GNUNET_free (msg);
       notify_session_monitor (s->plugin,
                               s,
                               GNUNET_TRANSPORT_SS_UPDATE);
     }
   }
   if (0 < bytes_read)
   {
     sc->connected = GNUNET_YES;
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Sent %lu bytes to peer `%s' with session %p \n",
          (unsigned long) bytes_read,
          GNUNET_i2s (&s->target),
          s);
     GNUNET_asprintf (&stat_txt,
                      "# bytes currently in %s_server buffers",
                      s->plugin->protocol);
     GNUNET_STATISTICS_update (s->plugin->env->stats,
                               stat_txt,
                               -bytes_read,
                               GNUNET_NO);
     GNUNET_free (stat_txt);
     GNUNET_asprintf (&stat_txt,
                      "# bytes transmitted via %s_server",
                      s->plugin->protocol);
     GNUNET_STATISTICS_update (s->plugin->env->stats,
                               stat_txt, bytes_read, GNUNET_NO);
     GNUNET_free (stat_txt);
   }
   else if ((sc->options & OPTION_LONG_POLL) && sc->connected)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Completing GET response to peer `%s' with session %p\n",
          GNUNET_i2s (&s->target),
          s);
     return MHD_CONTENT_READER_END_OF_STREAM;
   }
   else
   {
     MHD_suspend_connection (s->server_send->mhd_conn);
     s->server_send->suspended = true;
     return 0;
   }
   return bytes_read;
 }

References buf, GNUNET_ATS_Session::bytes_in_queue, Plugin::env, GNUNET_asprintf(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_memcpy, GNUNET_MIN, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_TRANSPORT_SS_UPDATE, GNUNET_YES, LOG, max, ServerRequest::mhd_conn, msg, GNUNET_ATS_Session::msg_head, GNUNET_ATS_Session::msg_tail, GNUNET_ATS_Session::msgs_in_queue, notify_session_monitor(), OPTION_LONG_POLL, GNUNET_FS_SearchContext::options, GNUNET_ATS_Session::plugin, Plugin::protocol, sc, GNUNET_ATS_Session::server_send, GNUNET_MessageHeader::size, ServerRequest::suspended, and GNUNET_ATS_Session::target.

Referenced by server_access_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_receive_mst_cb()

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

static

Callback called by MessageStreamTokenizer when a message has arrived.

Parameters

cls	current session as closure
message	the message to be forwarded to transport service

Returns: GNUNET_OK (all OK)

Definition at line 1664 of file plugin_transport_http_server.c.

 {
   struct GNUNET_ATS_Session *s = cls;
   struct HTTP_Server_Plugin *plugin = s->plugin;
   struct GNUNET_TIME_Relative delay;
   char *stat_txt;
  
   if (GNUNET_NO == s->known_to_service)
   {
     s->known_to_service = GNUNET_YES;
     plugin->env->session_start (plugin->env->cls,
                                 s->address,
                                 s,
                                 s->scope);
     notify_session_monitor (plugin,
                             s,
                             GNUNET_TRANSPORT_SS_UP);
   }
   delay = plugin->env->receive (plugin->env->cls,
                                 s->address,
                                 s,
                                 message);
   GNUNET_asprintf (&stat_txt,
                    "# bytes received via %s_server",
                    plugin->protocol);
   GNUNET_STATISTICS_update (plugin->env->stats,
                             stat_txt,
                             ntohs (message->size),
                             GNUNET_NO);
   GNUNET_free (stat_txt);
   s->next_receive = GNUNET_TIME_relative_to_absolute (delay);
   if (delay.rel_value_us > 0)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Peer `%s' address `%s' next read delayed for %s\n",
          GNUNET_i2s (&s->target),
          http_common_plugin_address_to_string (plugin->protocol,
                                                s->address->address,
                                                s->address->address_length),
          GNUNET_STRINGS_relative_time_to_string (delay,
                                                  GNUNET_YES));
   }
   server_reschedule_session_timeout (s);
   return GNUNET_OK;
 }

References GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, delay, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_SS_UP, GNUNET_YES, http_common_plugin_address_to_string(), GNUNET_ATS_Session::known_to_service, LOG, GNUNET_ATS_Session::next_receive, notify_session_monitor(), plugin, GNUNET_ATS_Session::plugin, GNUNET_TIME_Relative::rel_value_us, GNUNET_ATS_Session::scope, server_reschedule_session_timeout(), GNUNET_MessageHeader::size, and GNUNET_ATS_Session::target.

Referenced by server_access_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_cors_headers()

static void add_cors_headers ( struct MHD_Response * response )

static

Add headers to a request indicating that we allow Cross-Origin Resource Sharing.

Parameters

response response object to modify

Definition at line 1719 of file plugin_transport_http_server.c.

 {
   MHD_add_response_header (response,
                            "Access-Control-Allow-Origin",
                            "*");
   MHD_add_response_header (response,
                            "Access-Control-Allow-Methods",
                            "GET, PUT, OPTIONS");
   MHD_add_response_header (response,
                            "Access-Control-Max-Age",
                            "86400");
 }

References response.

Referenced by server_access_cb().

Here is the caller graph for this function:

◆ server_access_cb()

static MHD_RESULT server_access_cb	(	void *	cls,
		struct MHD_Connection *	mhd_connection,
		const char *	url,
		const char *	method,
		const char *	version,
		const char *	upload_data,
		size_t *	upload_data_size,
		void **	httpSessionCache
	)

static

MHD callback for a new incoming connection.

Parameters

cls	the plugin handle
mhd_connection	the mhd connection
url	the requested URL
method	GET or PUT
version	HTTP version
upload_data	upload data
upload_data_size	size of upload_data
httpSessionCache	the session cache to remember the connection

Returns: #MHD_YES if connection is accepted, #MHD_NO on reject

Definition at line 1747 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
   struct ServerRequest *sc = *httpSessionCache;
   struct GNUNET_ATS_Session *s;
   struct MHD_Response *response;
   MHD_RESULT res = MHD_YES;
  
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        _ (
          "Access from connection %p (%u of %u) for `%s' `%s' url `%s' with upload data size %lu\n"),
        sc,
        plugin->cur_request,
        plugin->max_request,
        method,
        version,
        url,
        (unsigned long) (*upload_data_size));
   if (NULL == sc)
   {
     /* CORS pre-flight request */
     if (0 == strcmp (MHD_HTTP_METHOD_OPTIONS, method))
     {
       response = MHD_create_response_from_buffer (0, NULL,
                                                   MHD_RESPMEM_PERSISTENT);
       add_cors_headers (response);
       res = MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
       MHD_destroy_response (response);
       return res;
     }
     /* new connection */
     sc = server_lookup_connection (plugin, mhd_connection, url, method);
     if (NULL != sc)
     {
       /* attach to new / existing session */
       (*httpSessionCache) = sc;
     }
     else
     {
       /* existing session already has matching connection, refuse */
       response = MHD_create_response_from_buffer (strlen (HTTP_ERROR_RESPONSE),
                                                   HTTP_ERROR_RESPONSE,
                                                   MHD_RESPMEM_PERSISTENT);
       MHD_add_response_header (response,
                                MHD_HTTP_HEADER_CONTENT_TYPE,
                                "text/html");
       add_cors_headers (response);
       res = MHD_queue_response (mhd_connection, MHD_HTTP_NOT_FOUND, response);
       MHD_destroy_response (response);
       return res;
     }
   }
   /* 'old' connection */
   if (NULL == (s = sc->session))
   {
     /* Session was already disconnected;
        sent HTTP/1.1: 200 OK as response */
     response = MHD_create_response_from_buffer (strlen ("Thank you!"),
                                                 "Thank you!",
                                                 MHD_RESPMEM_PERSISTENT);
     add_cors_headers (response);
     MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
     MHD_destroy_response (response);
     return MHD_YES;
   }
  
   if (sc->direction == _SEND)
   {
     response = MHD_create_response_from_callback (MHD_SIZE_UNKNOWN, 32 * 1024,
                                                   &server_send_callback, sc,
                                                   NULL);
     add_cors_headers (response);
     MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
     MHD_destroy_response (response);
     return MHD_YES;
   }
   if (sc->direction == _RECEIVE)
   {
     if ((*upload_data_size == 0) && (sc->connected == GNUNET_NO))
     {
       /* (*upload_data_size == 0) first callback when header are passed */
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Session %p / Connection %p: Peer `%s' PUT on address `%s' connected\n",
            s, sc,
            GNUNET_i2s (&s->target),
            http_common_plugin_address_to_string (plugin->protocol,
                                                  s->address->address,
                                                  s->address->address_length));
       sc->connected = GNUNET_YES;
       return MHD_YES;
     }
     else if ((*upload_data_size == 0) && (sc->connected == GNUNET_YES))
     {
       /* (*upload_data_size == 0) when upload is complete */
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Session %p / Connection %p: Peer `%s' PUT on address `%s' finished upload\n",
            s, sc,
            GNUNET_i2s (&s->target),
            http_common_plugin_address_to_string (plugin->protocol,
                                                  s->address->address,
                                                  s->address->address_length));
       sc->connected = GNUNET_NO;
       /* Sent HTTP/1.1: 200 OK as PUT Response\ */
       response = MHD_create_response_from_buffer (strlen ("Thank you!"),
                                                   "Thank you!",
                                                   MHD_RESPMEM_PERSISTENT);
       add_cors_headers (response);
       MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
       MHD_destroy_response (response);
       return MHD_YES;
     }
     else if ((*upload_data_size > 0) && (sc->connected == GNUNET_YES))
     {
       struct GNUNET_TIME_Relative delay;
  
       /* (*upload_data_size > 0) for every segment received */
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Session %p / Connection %p: Peer `%s' PUT on address `%s' received %lu bytes\n",
            s, sc,
            GNUNET_i2s (&s->target),
            http_common_plugin_address_to_string (plugin->protocol,
                                                  s->address->address,
                                                  s->address->address_length),
            (unsigned long) *upload_data_size);
       delay = GNUNET_TIME_absolute_get_remaining (s->next_receive);
       if (0 == delay.rel_value_us)
       {
         LOG (GNUNET_ERROR_TYPE_DEBUG,
              "PUT with %lu bytes forwarded to MST\n",
              (unsigned long) *upload_data_size);
         if (s->msg_tk == NULL)
         {
           s->msg_tk = GNUNET_MST_create (&server_receive_mst_cb,
                                          s);
         }
         GNUNET_MST_from_buffer (s->msg_tk,
                                 upload_data,
                                 *upload_data_size,
                                 GNUNET_NO, GNUNET_NO);
         server_mhd_connection_timeout (plugin, s,
                                        GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.
                                        rel_value_us / 1000LL
                                        / 1000LL);
         (*upload_data_size) = 0;
       }
       else
       {
         /* delay processing */
         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                     "Session %p / Connection %p: no inbound bandwidth available! Next read was delayed by %s\n",
                     s,
                     sc,
                     GNUNET_STRINGS_relative_time_to_string (delay,
                                                             GNUNET_YES));
         GNUNET_assert (s->server_recv->mhd_conn == mhd_connection);
         MHD_suspend_connection (s->server_recv->mhd_conn);
         s->server_recv->suspended = true;
         if (NULL == s->recv_wakeup_task)
           s->recv_wakeup_task
             = GNUNET_SCHEDULER_add_delayed (delay,
                                             &server_wake_up,
                                             s);
       }
       return MHD_YES;
     }
     else
     {
       GNUNET_break (0);
       return MHD_NO;
     }
   }
   return res;
 }

References _, _RECEIVE, _SEND, add_cors_headers(), GNUNET_HELLO_Address::address, GNUNET_ATS_Session::address, GNUNET_HELLO_Address::address_length, delay, GNUNET_assert, GNUNET_break, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MST_create(), GNUNET_MST_from_buffer(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, http_common_plugin_address_to_string(), HTTP_ERROR_RESPONSE, LOG, ServerRequest::mhd_conn, MHD_HTTP_NOT_FOUND, MHD_HTTP_OK, MHD_RESULT, GNUNET_ATS_Session::msg_tk, GNUNET_ATS_Session::next_receive, plugin, GNUNET_ATS_Session::recv_wakeup_task, GNUNET_TIME_Relative::rel_value_us, res, response, sc, server_lookup_connection(), server_mhd_connection_timeout(), server_receive_mst_cb(), GNUNET_ATS_Session::server_recv, server_send_callback(), server_wake_up(), ServerRequest::suspended, and GNUNET_ATS_Session::target.

Referenced by run_mhd_start_daemon().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_disconnect_cb()

static void server_disconnect_cb	(	void *	cls,
		struct MHD_Connection *	connection,
		void **	httpSessionCache
	)

static

Callback from MHD when a connection disconnects.

Parameters

cls	closure with the `struct HTTP_Server_Plugin *`
connection	the disconnected MHD connection
httpSessionCache	the pointer to distinguish

Definition at line 1937 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
   struct ServerRequest *sc = *httpSessionCache;
  
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Disconnect for connection %p\n",
        sc);
   if (NULL == sc)
   {
     /* CORS pre-flight request finished */
     return;
   }
  
   if (NULL != sc->session)
   {
     if (sc->direction == _SEND)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Peer `%s' connection  %p, GET on address `%s' disconnected\n",
            GNUNET_i2s (&sc->session->target),
            sc->session->server_send,
            http_common_plugin_address_to_string (plugin->protocol,
                                                  sc->session->address->address,
                                                  sc->session->address->
                                                  address_length));
  
       sc->session->server_send = NULL;
     }
     else if (sc->direction == _RECEIVE)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Peer `%s' connection %p PUT on address `%s' disconnected\n",
            GNUNET_i2s (&sc->session->target),
            sc->session->server_recv,
            http_common_plugin_address_to_string (plugin->protocol,
                                                  sc->session->address->address,
                                                  sc->session->address->
                                                  address_length));
       sc->session->server_recv = NULL;
       if (NULL != sc->session->msg_tk)
       {
         GNUNET_MST_destroy (sc->session->msg_tk);
         sc->session->msg_tk = NULL;
       }
     }
   }
   GNUNET_free (sc);
   plugin->cur_request--;
 }

References _RECEIVE, _SEND, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_MST_destroy(), http_common_plugin_address_to_string(), LOG, plugin, and sc.

Referenced by run_mhd_start_daemon().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_connection_cb()

static void server_connection_cb	(	void *	cls,
		struct MHD_Connection *	connection,
		void **	socket_context,
		enum MHD_ConnectionNotificationCode	toe
	)

static

Callback from MHD when a connection starts/stops.

Parameters

cls	closure with the `struct HTTP_Server_Plugin *`
connection	connection handle
socket_context	socket-specific pointer
toe	reason for connection notification

See also: #MHD_OPTION_NOTIFY_CONNECTION

Definition at line 2001 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
   const union MHD_ConnectionInfo *info;
  
   if (MHD_CONNECTION_NOTIFY_STARTED == toe)
     return;
  
   /* Reschedule to remove closed socket from our select set */
   info = MHD_get_connection_info (connection,
                                   MHD_CONNECTION_INFO_DAEMON);
   GNUNET_assert (NULL != info);
   server_reschedule (plugin,
                      info->daemon,
                      GNUNET_YES);
 }

References GNUNET_assert, GNUNET_YES, info, plugin, and server_reschedule().

Referenced by run_mhd_start_daemon().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_accept_cb()

static MHD_RESULT server_accept_cb	(	void *	cls,
		const struct sockaddr *	addr,
		socklen_t	addr_len
	)

static

Check if incoming connection is accepted.

Parameters

cls	plugin as closure
addr	address of incoming connection
addr_len	number of bytes in addr

Returns: #MHD_YES if connection is accepted, #MHD_NO if connection is rejected

Definition at line 2031 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
  
   if (plugin->cur_request <= plugin->max_request)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          _ ("Accepting connection (%u of %u) from `%s'\n"),
          plugin->cur_request, plugin->max_request,
          GNUNET_a2s (addr, addr_len));
     return MHD_YES;
   }
   else
   {
     LOG (GNUNET_ERROR_TYPE_WARNING,
          _ (
            "Server reached maximum number connections (%u), rejecting new connection\n"),
          plugin->max_request);
     return MHD_NO;
   }
 }

References _, GNUNET_a2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, LOG, and plugin.

Referenced by run_mhd_start_daemon().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_log()

static void server_log	(	void *	arg,
		const char *	fmt,
		va_list	ap
	)

static

Log function called by MHD.

Parameters

arg	NULL
fmt	format string
ap	arguments for the format string (va_start() and va_end() will be called by MHD)

Definition at line 2065 of file plugin_transport_http_server.c.

 {
   char text[1024];
  
   vsnprintf (text,
              sizeof(text),
              fmt,
              ap);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Server: %s\n",
               text);
 }

References GNUNET_ERROR_TYPE_DEBUG, and GNUNET_log.

Referenced by run_mhd_start_daemon().

Here is the caller graph for this function:

◆ run_mhd_start_daemon()

static struct MHD_Daemon* run_mhd_start_daemon	(	struct HTTP_Server_Plugin *	plugin,
		const struct sockaddr_in *	addr,
		int	v6
	)

static

Invoke MHD_start_daemon with the various options we need to setup the HTTP server with the given listen address.

Parameters

plugin	our plugin
addr	listen address to use
v6	MHD_NO_FLAG or MHD_USE_IPv6, depending on context

Returns: NULL on error

Definition at line 2261 of file plugin_transport_http_server.c.

 {
   struct MHD_Daemon *server;
   unsigned int timeout;
  
 #if MHD_VERSION >= 0x00090E00
   timeout = HTTP_SERVER_NOT_VALIDATED_TIMEOUT.rel_value_us / 1000LL / 1000LL;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "MHD can set timeout per connection! Default time out %u sec.\n",
        timeout);
 #else
   timeout = HTTP_SERVER_SESSION_TIMEOUT.rel_value_us / 1000LL / 1000LL;
   LOG (GNUNET_ERROR_TYPE_WARNING,
        "MHD cannot set timeout per connection! Default time out %u sec.\n",
        timeout);
 #endif
   server = MHD_start_daemon (
 #if VERBOSE_SERVER
     MHD_USE_DEBUG |
 #endif
 #if BUILD_HTTPS
     MHD_USE_SSL |
 #endif
     MHD_USE_SUSPEND_RESUME
     | v6,
     plugin->port,
     &server_accept_cb, plugin,
     &server_access_cb, plugin,
     MHD_OPTION_SOCK_ADDR,
     addr,
     MHD_OPTION_CONNECTION_LIMIT,
     (unsigned int) plugin->max_request,
 #if BUILD_HTTPS
     MHD_OPTION_HTTPS_PRIORITIES,
     plugin->crypto_init,
     MHD_OPTION_HTTPS_MEM_KEY,
     plugin->key,
     MHD_OPTION_HTTPS_MEM_CERT,
     plugin->cert,
 #endif
     MHD_OPTION_CONNECTION_TIMEOUT,
     timeout,
     MHD_OPTION_CONNECTION_MEMORY_LIMIT,
     (size_t) (2
               * GNUNET_MAX_MESSAGE_SIZE),
     MHD_OPTION_NOTIFY_COMPLETED,
     &server_disconnect_cb, plugin,
     MHD_OPTION_NOTIFY_CONNECTION,
     &server_connection_cb, plugin,
     MHD_OPTION_EXTERNAL_LOGGER,
     &server_log, NULL,
     MHD_OPTION_END);
 #ifdef TCP_STEALTH
   if ((NULL != server) &&
       (0 != (plugin->options & HTTP_OPTIONS_TCP_STEALTH)))
   {
     const union MHD_DaemonInfo *di;
  
     di = MHD_get_daemon_info (server,
                               MHD_DAEMON_INFO_LISTEN_FD,
                               NULL);
     if ((0 != setsockopt ((int) di->listen_fd,
                           IPPROTO_TCP,
                           TCP_STEALTH,
                           plugin->env->my_identity,
                           sizeof(struct GNUNET_PeerIdentity))))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _ ("TCP_STEALTH not supported on this platform.\n"));
       MHD_stop_daemon (server);
       server = NULL;
     }
   }
 #endif
   return server;
 }

References _, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, HTTP_OPTIONS_TCP_STEALTH, HTTP_SERVER_NOT_VALIDATED_TIMEOUT, HTTP_SERVER_SESSION_TIMEOUT, LOG, plugin, server_accept_cb(), server_access_cb(), server_connection_cb(), server_disconnect_cb(), server_log(), timeout, and VERBOSE_SERVER.

Referenced by server_start().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_start()

static int server_start ( struct HTTP_Server_Plugin * plugin )

static

Start the HTTP server.

Parameters

plugin the plugin handle

Returns: GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 2348 of file plugin_transport_http_server.c.

 {
   const char *msg;
  
   GNUNET_assert (NULL != plugin);
 #if BUILD_HTTPS
   if (GNUNET_SYSERR == server_load_certificate (plugin))
   {
     LOG (GNUNET_ERROR_TYPE_ERROR,
          _ (
            "Could not load or create server certificate! Loading plugin failed!\n"));
     return GNUNET_SYSERR;
   }
 #endif
  
  
   plugin->server_v4 = NULL;
   if (GNUNET_YES == plugin->use_ipv4)
   {
     plugin->server_v4
       = run_mhd_start_daemon (plugin,
                               (const struct
                                sockaddr_in *) plugin->server_addr_v4,
                               MHD_NO_FLAG);
  
     if (NULL == plugin->server_v4)
     {
       LOG (GNUNET_ERROR_TYPE_ERROR,
            "Failed to start %s IPv4 server component on port %u\n",
            plugin->name,
            plugin->port);
     }
     else
       server_reschedule (plugin,
                          plugin->server_v4,
                          GNUNET_NO);
   }
  
  
   plugin->server_v6 = NULL;
   if (GNUNET_YES == plugin->use_ipv6)
   {
     plugin->server_v6
       = run_mhd_start_daemon (plugin,
                               (const struct
                                sockaddr_in *) plugin->server_addr_v6,
                               MHD_USE_IPv6);
     if (NULL == plugin->server_v6)
     {
       LOG (GNUNET_ERROR_TYPE_ERROR,
            "Failed to start %s IPv6 server component on port %u\n",
            plugin->name,
            plugin->port);
     }
     else
     {
       server_reschedule (plugin,
                          plugin->server_v6,
                          GNUNET_NO);
     }
   }
   msg = "No";
   if ((NULL == plugin->server_v6) &&
       (NULL == plugin->server_v4))
   {
     LOG (GNUNET_ERROR_TYPE_ERROR,
          "%s %s server component started on port %u\n",
          msg,
          plugin->name,
          plugin->port);
     return GNUNET_SYSERR;
   }
   if ((NULL != plugin->server_v6) &&
       (NULL != plugin->server_v4))
     msg = "IPv4 and IPv6";
   else if (NULL != plugin->server_v6)
     msg = "IPv6";
   else if (NULL != plugin->server_v4)
     msg = "IPv4";
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "%s %s server component started on port %u\n",
        msg,
        plugin->name,
        plugin->port);
   return GNUNET_OK;
 }

References _, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, LOG, msg, plugin, run_mhd_start_daemon(), and server_reschedule().

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_add_address()

static void server_add_address	(	void *	cls,
		int	add_remove,
		const struct sockaddr *	addr,
		socklen_t	addrlen
	)

static

Add an address to the server's set of addresses and notify transport.

Parameters

cls	the plugin handle
add_remove	GNUNET_YES on add, GNUNET_NO on remove
addr	the address
addrlen	address length

Definition at line 2445 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
   struct GNUNET_HELLO_Address *address;
   struct HttpAddressWrapper *w = NULL;
  
   w = GNUNET_new (struct HttpAddressWrapper);
   w->address = http_common_address_from_socket (plugin->protocol,
                                                 addr,
                                                 addrlen);
   if (NULL == w->address)
   {
     GNUNET_free (w);
     return;
   }
   w->addrlen = http_common_address_get_size (w->address);
  
   GNUNET_CONTAINER_DLL_insert (plugin->addr_head,
                                plugin->addr_tail,
                                w);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Notifying transport to add address `%s'\n",
        http_common_plugin_address_to_string (plugin->protocol,
                                              w->address,
                                              w->addrlen));
   /* modify our published address list */
 #if BUILD_HTTPS
   address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
                                            "https_client", w->address,
                                            w->addrlen,
                                            GNUNET_HELLO_ADDRESS_INFO_NONE);
 #else
   address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
                                            "http_client", w->address,
                                            w->addrlen,
                                            GNUNET_HELLO_ADDRESS_INFO_NONE);
 #endif
  
   plugin->env->notify_address (plugin->env->cls,
                                add_remove,
                                address);
   GNUNET_HELLO_address_free (address);
 }

References address, HttpAddressWrapper::address, HttpAddressWrapper::addrlen, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_address_free, GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_new, http_common_address_from_socket(), http_common_address_get_size(), http_common_plugin_address_to_string(), LOG, and plugin.

Referenced by server_nat_port_map_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_remove_address()

static void server_remove_address	(	void *	cls,
		int	add_remove,
		const struct sockaddr *	addr,
		socklen_t	addrlen
	)

static

Remove an address from the server's set of addresses and notify transport.

Parameters

cls	the plugin handle
add_remove	GNUNET_YES on add, GNUNET_NO on remove
addr	the address
addrlen	address length

Definition at line 2502 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
   struct GNUNET_HELLO_Address *address;
   struct HttpAddressWrapper *w = plugin->addr_head;
   size_t saddr_len;
   void *saddr;
  
   saddr = http_common_address_from_socket (plugin->protocol,
                                            addr,
                                            addrlen);
   if (NULL == saddr)
     return;
   saddr_len = http_common_address_get_size (saddr);
  
   while (NULL != w)
   {
     if (GNUNET_YES ==
         http_common_cmp_addresses (w->address,
                                    w->addrlen,
                                    saddr,
                                    saddr_len))
       break;
     w = w->next;
   }
   GNUNET_free (saddr);
  
   if (NULL == w)
     return;
  
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Notifying transport to remove address `%s'\n",
        http_common_plugin_address_to_string (plugin->protocol,
                                              w->address,
                                              w->addrlen));
   GNUNET_CONTAINER_DLL_remove (plugin->addr_head,
                                plugin->addr_tail,
                                w);
   /* modify our published address list */
 #if BUILD_HTTPS
   address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
                                            "https_client", w->address,
                                            w->addrlen,
                                            GNUNET_HELLO_ADDRESS_INFO_NONE);
 #else
   address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
                                            "http_client", w->address,
                                            w->addrlen,
                                            GNUNET_HELLO_ADDRESS_INFO_NONE);
 #endif
   plugin->env->notify_address (plugin->env->cls, add_remove, address);
   GNUNET_HELLO_address_free (address);
   GNUNET_free (w->address);
   GNUNET_free (w);
 }

References address, HttpAddressWrapper::address, HttpAddressWrapper::addrlen, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_address_free, GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_YES, http_common_address_from_socket(), http_common_address_get_size(), http_common_cmp_addresses(), http_common_plugin_address_to_string(), LOG, HttpAddressWrapper::next, and plugin.

Referenced by server_nat_port_map_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_nat_port_map_callback()

static void server_nat_port_map_callback	(	void *	cls,
		void **	app_ctx,
		int	add_remove,
		enum GNUNET_NAT_AddressClass	ac,
		const struct sockaddr *	addr,
		socklen_t	addrlen
	)

static

Our external IP address/port mapping has changed.

Parameters

	cls	closure, the 'struct LocalAddrList'
[in,out]	app_ctx	location where the app can store stuff on add and retrieve it on remove
	add_remove	GNUNET_YES to mean the new public IP address, GNUNET_NO to mean the previous (now invalid) one
	ac	address class the address belongs to
	addr	either the previous or the new public IP address
	addrlen	actual length of the address

Definition at line 2575 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
  
   (void) app_ctx;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "NAT called to %s address `%s'\n",
        (add_remove == GNUNET_NO) ? "remove" : "add",
        GNUNET_a2s (addr, addrlen));
  
   if (AF_INET == addr->sa_family)
   {
     struct sockaddr_in *s4 = (struct sockaddr_in *) addr;
  
     if (GNUNET_NO == plugin->use_ipv4)
       return;
  
     if ((NULL != plugin->server_addr_v4) &&
         (0 != memcmp (&plugin->server_addr_v4->sin_addr,
                       &s4->sin_addr,
                       sizeof(struct in_addr))))
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Skipping address `%s' (not bindto address)\n",
            GNUNET_a2s (addr, addrlen));
       return;
     }
   }
  
   if (AF_INET6 == addr->sa_family)
   {
     struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) addr;
     if (GNUNET_NO == plugin->use_ipv6)
       return;
  
     if ((NULL != plugin->server_addr_v6) &&
         (0 != memcmp (&plugin->server_addr_v6->sin6_addr,
                       &s6->sin6_addr, sizeof(struct in6_addr))))
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Skipping address `%s' (not bindto address)\n",
            GNUNET_a2s (addr, addrlen));
       return;
     }
   }
  
   switch (add_remove)
   {
   case GNUNET_YES:
     server_add_address (cls, add_remove, addr, addrlen);
     break;
  
   case GNUNET_NO:
     server_remove_address (cls, add_remove, addr, addrlen);
     break;
   }
 }

References GNUNET_a2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_YES, LOG, plugin, server_add_address(), and server_remove_address().

Referenced by server_start_report_addresses().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_get_addresses()

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

static

Get valid server addresses.

Parameters

plugin	the plugin handle
service_name	the servicename
cfg	configuration handle
addrs	addresses
addr_lens	address length

Returns: number of addresses

Definition at line 2650 of file plugin_transport_http_server.c.

 {
   int disablev6;
   unsigned long long port;
   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;
  
   disablev6 = ! plugin->use_ipv6;
  
   port = 0;
   if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT"))
   {
     GNUNET_break (GNUNET_OK ==
                   GNUNET_CONFIGURATION_get_value_number (cfg, service_name,
                                                          "PORT", &port));
     if (port > 65535)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _ (
                     "Require valid port number for service in configuration!\n"));
       return GNUNET_SYSERR;
     }
   }
   if (0 == port)
   {
     LOG (GNUNET_ERROR_TYPE_INFO,
          "Starting in listen only mode\n");
     return -1;   /* listen only */
   }
  
  
   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;
  
   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;
     if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) ||
         (NULL == res))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _ ("Failed to resolve `%s': %s\n"),
                   hostname,
                   gai_strerror (ret));
       GNUNET_free (hostname);
       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)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _ ("Failed to find %saddress for `%s'.\n"),
                   disablev6 ? "IPv4 " : "", hostname);
       freeaddrinfo (res);
       GNUNET_free (hostname);
       return GNUNET_SYSERR;
     }
     resi = i;
     saddrs = GNUNET_malloc ((resi + 1) * sizeof(struct sockaddr *));
     saddrlens = GNUNET_malloc ((resi + 1) * sizeof(socklen_t));
     i = 0;
     next = res;
     while (NULL != (pos = next))
     {
       next = pos->ai_next;
       if ((disablev6) && (pos->ai_family == AF_INET6))
         continue;
       if ((pos->ai_protocol != IPPROTO_TCP) && (0 != pos->ai_protocol))
         continue;               /* not TCP */
       if ((pos->ai_socktype != SOCK_STREAM) && (0 != pos->ai_socktype))
         continue;               /* huh? */
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Service will bind to `%s'\n",
            GNUNET_a2s (pos->ai_addr,
                        pos->ai_addrlen));
       if (pos->ai_family == AF_INET)
       {
         GNUNET_assert (pos->ai_addrlen == sizeof(struct sockaddr_in));
         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 (pos->ai_family == AF_INET6);
         GNUNET_assert (pos->ai_addrlen == sizeof(struct sockaddr_in6));
         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;
       i = 0;
       saddrs = GNUNET_malloc ((resi + 1) * sizeof(struct sockaddr *));
       saddrlens = GNUNET_malloc ((resi + 1) * sizeof(socklen_t));
  
       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;
       saddrs = GNUNET_malloc ((resi + 1) * sizeof(struct sockaddr *));
       saddrlens = GNUNET_malloc ((resi + 1) * sizeof(socklen_t));
       i = 0;
       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);
     }
   }
   *addrs = saddrs;
   *addr_lens = saddrlens;
   return resi;
 }

References _, cfg, GNUNET_a2s(), GNUNET_assert, GNUNET_break, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_have_value(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_OK, GNUNET_SYSERR, hostname, LOG, plugin, port, res, ret, and service_name.

Referenced by server_start_report_addresses().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_start_report_addresses()

static void server_start_report_addresses ( struct HTTP_Server_Plugin * plugin )

static

Ask NAT for addresses.

Parameters

plugin the plugin handle

Definition at line 2838 of file plugin_transport_http_server.c.

 {
   int res = GNUNET_OK;
   struct sockaddr **addrs;
   socklen_t *addrlens;
  
   res = server_get_addresses (plugin,
                               plugin->name,
                               plugin->env->cfg,
                               &addrs, &addrlens);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        _ ("Found %u addresses to report to NAT service\n"),
        res);
  
   if (GNUNET_SYSERR == res)
   {
     plugin->nat = NULL;
     return;
   }
  
   plugin->nat
     = GNUNET_NAT_register (plugin->env->cfg,
                            plugin->name,
                            IPPROTO_TCP,
                            (unsigned int) res,
                            (const struct sockaddr **) addrs,
                            addrlens,
                            &server_nat_port_map_callback,
                            NULL,
                            plugin);
   while (res > 0)
   {
     res--;
     GNUNET_assert (NULL != addrs[res]);
     GNUNET_free (addrs[res]);
   }
   GNUNET_free (addrs);
   GNUNET_free (addrlens);
 }

References _, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NAT_register(), GNUNET_OK, GNUNET_SYSERR, LOG, plugin, res, server_get_addresses(), and server_nat_port_map_callback().

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_stop_report_addresses()

static void server_stop_report_addresses ( struct HTTP_Server_Plugin * plugin )

static

Stop NAT for addresses.

Parameters

plugin the plugin handle

Definition at line 2885 of file plugin_transport_http_server.c.

 {
   struct HttpAddressWrapper *w;
  
   /* Stop NAT handle */
   if (NULL != plugin->nat)
   {
     GNUNET_NAT_unregister (plugin->nat);
     plugin->nat = NULL;
   }
   /* Clean up addresses */
   while (NULL != plugin->addr_head)
   {
     w = plugin->addr_head;
     GNUNET_CONTAINER_DLL_remove (plugin->addr_head,
                                  plugin->addr_tail,
                                  w);
     GNUNET_free (w->address);
     GNUNET_free (w);
   }
 }

References HttpAddressWrapper::address, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NAT_unregister(), and plugin.

Referenced by libgnunet_plugin_transport_http_client_done().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_check_ipv6_support()

static int server_check_ipv6_support ( struct HTTP_Server_Plugin * plugin )

static

Check if IPv6 supported on this system.

Parameters

plugin the plugin handle

Returns: GNUNET_YES on success, else GNUNET_NO

Definition at line 2915 of file plugin_transport_http_server.c.

 {
   struct GNUNET_NETWORK_Handle *desc = NULL;
   int res = GNUNET_NO;
  
   /* Probe IPv6 support */
   desc = GNUNET_NETWORK_socket_create (PF_INET6,
                                        SOCK_STREAM,
                                        0);
   if (NULL == desc)
   {
     if ((errno == ENOBUFS) ||
         (errno == ENOMEM) ||
         (errno == ENFILE) ||
         (errno == EACCES))
     {
       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                            "socket");
     }
     LOG (GNUNET_ERROR_TYPE_WARNING,
          _ ("Disabling IPv6 since it is not supported on this system!\n"));
     res = GNUNET_NO;
   }
   else
   {
     GNUNET_break (GNUNET_OK ==
                   GNUNET_NETWORK_socket_close (desc));
     desc = NULL;
     res = GNUNET_YES;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Testing IPv6 on this system: %s\n",
        (res == GNUNET_YES) ? "successful" : "failed");
   return res;
 }

References _, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log_strerror, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_NO, GNUNET_OK, GNUNET_YES, LOG, and res.

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_notify_external_hostname()

static void server_notify_external_hostname ( void * cls )

static

Notify server about our external hostname.

Parameters

cls plugin

Definition at line 2958 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
   struct HttpAddress *ext_addr;
   size_t ext_addr_len;
   unsigned int urlen;
   char *url;
  
   plugin->notify_ext_task = NULL;
   GNUNET_asprintf (&url,
                    "%s://%s",
                    plugin->protocol,
                    plugin->external_hostname);
   urlen = strlen (url) + 1;
   ext_addr = GNUNET_malloc (sizeof(struct HttpAddress) + urlen);
   ext_addr->options = htonl (plugin->options);
   ext_addr->urlen = htonl (urlen);
   ext_addr_len = sizeof(struct HttpAddress) + urlen;
   GNUNET_memcpy (&ext_addr[1], url, urlen);
   GNUNET_free (url);
  
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Notifying transport about external hostname address `%s'\n",
        plugin->external_hostname);
  
 #if BUILD_HTTPS
   if (GNUNET_YES == plugin->verify_external_hostname)
     LOG (GNUNET_ERROR_TYPE_INFO,
          "Enabling SSL verification for external hostname address `%s'\n",
          plugin->external_hostname);
   plugin->ext_addr
     = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
                                      "https_client",
                                      ext_addr,
                                      ext_addr_len,
                                      GNUNET_HELLO_ADDRESS_INFO_NONE);
   plugin->env->notify_address (plugin->env->cls,
                                GNUNET_YES,
                                plugin->ext_addr);
   GNUNET_free (ext_addr);
 #else
   plugin->ext_addr
     = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
                                      "http_client",
                                      ext_addr,
                                      ext_addr_len,
                                      GNUNET_HELLO_ADDRESS_INFO_NONE);
   plugin->env->notify_address (plugin->env->cls,
                                GNUNET_YES,
                                plugin->ext_addr);
   GNUNET_free (ext_addr);
 #endif
 }

References GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_HELLO_address_allocate(), GNUNET_HELLO_ADDRESS_INFO_NONE, GNUNET_malloc, GNUNET_memcpy, GNUNET_YES, LOG, HttpAddress::options, plugin, and HttpAddress::urlen.

Referenced by server_configure_plugin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ server_configure_plugin()

static int server_configure_plugin ( struct HTTP_Server_Plugin * plugin )

static

Configure the plugin.

Parameters

plugin plugin handle

Returns: GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 3020 of file plugin_transport_http_server.c.

 {
   unsigned long long port;
   unsigned long long max_connections;
   char *bind4_address = NULL;
   char *bind6_address = NULL;
   char *eh_tmp = NULL;
   int external_hostname_use_port;
  
   /* Use IPv4? */
   if (GNUNET_CONFIGURATION_have_value
         (plugin->env->cfg, plugin->name, "USE_IPv4"))
   {
     plugin->use_ipv4 =
       GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
                                             plugin->name,
                                             "USE_IPv4");
   }
   else
     plugin->use_ipv4 = GNUNET_YES;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        _ ("IPv4 support is %s\n"),
        (plugin->use_ipv4 == GNUNET_YES) ? "enabled" : "disabled");
  
   /* Use IPv6? */
   if (GNUNET_CONFIGURATION_have_value
         (plugin->env->cfg, plugin->name, "USE_IPv6"))
   {
     plugin->use_ipv6 =
       GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
                                             plugin->name,
                                             "USE_IPv6");
   }
   else
     plugin->use_ipv6 = GNUNET_YES;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        _ ("IPv6 support is %s\n"),
        (plugin->use_ipv6 == GNUNET_YES) ? "enabled" : "disabled");
  
   if ((plugin->use_ipv4 == GNUNET_NO) && (plugin->use_ipv6 == GNUNET_NO))
   {
     LOG (GNUNET_ERROR_TYPE_ERROR,
          _ ("Neither IPv4 nor IPv6 are enabled! Fix in configuration\n"));
     return GNUNET_SYSERR;
   }
  
   /* Reading port number from config file */
   if ((GNUNET_OK !=
        GNUNET_CONFIGURATION_get_value_number (plugin->env->cfg,
                                               plugin->name,
                                               "PORT", &port)) || (port > 65535))
   {
     LOG (GNUNET_ERROR_TYPE_ERROR,
          _ ("Port is required! Fix in configuration\n"));
     return GNUNET_SYSERR;
   }
   plugin->port = port;
  
   LOG (GNUNET_ERROR_TYPE_INFO,
        _ ("Using port %u\n"), plugin->port);
  
   if ((plugin->use_ipv4 == GNUNET_YES) &&
       (GNUNET_YES ==
        GNUNET_CONFIGURATION_get_value_string (plugin->env->cfg,
                                               plugin->name,
                                               "BINDTO",
                                               &bind4_address)))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Binding %s plugin to specific IPv4 address: `%s'\n",
          plugin->protocol,
          bind4_address);
     plugin->server_addr_v4 = GNUNET_new (struct sockaddr_in);
     if (1 != inet_pton (AF_INET,
                         bind4_address,
                         &plugin->server_addr_v4->sin_addr))
     {
       LOG (GNUNET_ERROR_TYPE_ERROR,
            _ ("Specific IPv4 address `%s' in configuration file is invalid!\n"),
            bind4_address);
       GNUNET_free (bind4_address);
       GNUNET_free (plugin->server_addr_v4);
       plugin->server_addr_v4 = NULL;
       return GNUNET_SYSERR;
     }
     else
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Binding to IPv4 address %s\n",
            bind4_address);
       plugin->server_addr_v4->sin_family = AF_INET;
       plugin->server_addr_v4->sin_port = htons (plugin->port);
     }
     GNUNET_free (bind4_address);
   }
  
   if ((plugin->use_ipv6 == GNUNET_YES) &&
       (GNUNET_YES ==
        GNUNET_CONFIGURATION_get_value_string (plugin->env->cfg,
                                               plugin->name,
                                               "BINDTO6",
                                               &bind6_address)))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Binding %s plugin to specific IPv6 address: `%s'\n",
          plugin->protocol, bind6_address);
     plugin->server_addr_v6 = GNUNET_new (struct sockaddr_in6);
     if (1 !=
         inet_pton (AF_INET6,
                    bind6_address,
                    &plugin->server_addr_v6->sin6_addr))
     {
       LOG (GNUNET_ERROR_TYPE_ERROR,
            _ ("Specific IPv6 address `%s' in configuration file is invalid!\n"),
            bind6_address);
       GNUNET_free (bind6_address);
       GNUNET_free (plugin->server_addr_v6);
       plugin->server_addr_v6 = NULL;
       return GNUNET_SYSERR;
     }
     else
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            "Binding to IPv6 address %s\n",
            bind6_address);
       plugin->server_addr_v6->sin6_family = AF_INET6;
       plugin->server_addr_v6->sin6_port = htons (plugin->port);
     }
     GNUNET_free (bind6_address);
   }
  
   plugin->verify_external_hostname = GNUNET_NO;
 #if BUILD_HTTPS
   plugin->verify_external_hostname
     = GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
                                             plugin->name,
                                             "VERIFY_EXTERNAL_HOSTNAME");
   if (GNUNET_SYSERR == plugin->verify_external_hostname)
     plugin->verify_external_hostname = GNUNET_NO;
   if (GNUNET_YES == plugin->verify_external_hostname)
     plugin->options |= HTTP_OPTIONS_VERIFY_CERTIFICATE;
 #endif
   external_hostname_use_port
     = GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
                                             plugin->name,
                                             "EXTERNAL_HOSTNAME_USE_PORT");
   if (GNUNET_SYSERR == external_hostname_use_port)
     external_hostname_use_port = GNUNET_NO;
  
  
   if (GNUNET_YES ==
       GNUNET_CONFIGURATION_get_value_string (plugin->env->cfg,
                                              plugin->name,
                                              "EXTERNAL_HOSTNAME",
                                              &eh_tmp))
   {
     char *tmp;
     char *pos = NULL;
     char *pos_url = NULL;
  
     if (NULL != strstr (eh_tmp, "://"))
       tmp = &strstr (eh_tmp, "://")[3];
     else
       tmp = eh_tmp;
  
     if (GNUNET_YES == external_hostname_use_port)
     {
       if ((strlen (tmp) > 1) && (NULL != (pos = strchr (tmp, '/'))))
       {
         pos_url = pos + 1;
         pos[0] = '\0';
         GNUNET_asprintf (&plugin->external_hostname,
                          "%s:%u/%s",
                          tmp,
                          (uint16_t) port,
                          pos_url);
       }
       else
         GNUNET_asprintf (&plugin->external_hostname,
                          "%s:%u",
                          tmp,
                          (uint16_t) port);
     }
     else
       plugin->external_hostname = GNUNET_strdup (tmp);
     GNUNET_free (eh_tmp);
  
     LOG (GNUNET_ERROR_TYPE_INFO,
          _ ("Using external hostname `%s'\n"),
          plugin->external_hostname);
     plugin->notify_ext_task = GNUNET_SCHEDULER_add_now (
       &server_notify_external_hostname,
       plugin);
  
     /* Use only configured external hostname */
     if (GNUNET_CONFIGURATION_have_value
           (plugin->env->cfg,
           plugin->name,
           "EXTERNAL_HOSTNAME_ONLY"))
     {
       plugin->external_only =
         GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
                                               plugin->name,
                                               "EXTERNAL_HOSTNAME_ONLY");
     }
     else
       plugin->external_only = GNUNET_NO;
  
     if (GNUNET_YES == plugin->external_only)
       LOG (GNUNET_ERROR_TYPE_DEBUG,
            _ ("Notifying transport only about hostname `%s'\n"),
            plugin->external_hostname);
   }
   else
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "No external hostname configured\n");
  
   /* Optional parameters */
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (plugin->env->cfg,
                                              plugin->name,
                                              "MAX_CONNECTIONS",
                                              &max_connections))
     max_connections = 128;
   plugin->max_request = max_connections;
  
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        _ ("Maximum number of connections is %u\n"),
        plugin->max_request);
  
   plugin->peer_id_length = strlen (GNUNET_i2s_full (plugin->env->my_identity));
  
   return GNUNET_OK;
 }

References _, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONFIGURATION_have_value(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_i2s_full(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, GNUNET_SYSERR, GNUNET_YES, HTTP_OPTIONS_VERIFY_CERTIFICATE, LOG, max_connections, plugin, port, and server_notify_external_hostname().

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ libgnunet_plugin_transport_http_client_done()

void* libgnunet_plugin_transport_http_client_done ( void * cls )

Exit point from the plugin.

Parameters

cls api

Returns: NULL

Definition at line 3263 of file plugin_transport_http_server.c.

 {
   struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
   struct HTTP_Server_Plugin *plugin = api->cls;
  
   if (NULL == api->cls)
   {
     /* Free for stub mode */
     GNUNET_free (api);
     return NULL;
   }
   plugin->in_shutdown = GNUNET_YES;
   LOG (GNUNET_ERROR_TYPE_INFO,
        _ ("Shutting down plugin `%s'\n"),
        plugin->name);
  
   if (NULL != plugin->notify_ext_task)
   {
     GNUNET_SCHEDULER_cancel (plugin->notify_ext_task);
     plugin->notify_ext_task = NULL;
   }
  
   if (NULL != plugin->ext_addr)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Notifying transport to remove address `%s'\n",
          http_common_plugin_address_to_string (plugin->protocol,
                                                plugin->ext_addr->address,
                                                plugin->ext_addr->address_length));
 #if BUILD_HTTPS
     plugin->env->notify_address (plugin->env->cls,
                                  GNUNET_NO,
                                  plugin->ext_addr);
 #else
     plugin->env->notify_address (plugin->env->cls,
                                  GNUNET_NO,
                                  plugin->ext_addr);
 #endif
     GNUNET_HELLO_address_free (plugin->ext_addr);
     plugin->ext_addr = NULL;
   }
  
   /* Stop to report addresses to transport service */
   server_stop_report_addresses (plugin);
   if (NULL != plugin->server_v4_task)
   {
     GNUNET_SCHEDULER_cancel (plugin->server_v4_task);
     plugin->server_v4_task = NULL;
   }
  
   if (NULL != plugin->server_v6_task)
   {
     GNUNET_SCHEDULER_cancel (plugin->server_v6_task);
     plugin->server_v6_task = NULL;
   }
 #if BUILD_HTTPS
   GNUNET_free (plugin->crypto_init);
   GNUNET_free (plugin->cert);
   GNUNET_free (plugin->key);
 #endif
   GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions,
                                          &destroy_session_shutdown_cb,
                                          plugin);
   GNUNET_CONTAINER_multipeermap_destroy (plugin->sessions);
   plugin->sessions = NULL;
   if (NULL != plugin->server_v4)
   {
     MHD_stop_daemon (plugin->server_v4);
     plugin->server_v4 = NULL;
   }
   if (NULL != plugin->server_v6)
   {
     MHD_stop_daemon (plugin->server_v6);
     plugin->server_v6 = NULL;
   }
   /* Clean up */
   GNUNET_free (plugin->external_hostname);
   GNUNET_free (plugin->ext_addr);
   GNUNET_free (plugin->server_addr_v4);
   GNUNET_free (plugin->server_addr_v6);
   regfree (&plugin->url_regex);
  
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        _ ("Shutdown for plugin `%s' complete\n"),
        plugin->name);
  
   GNUNET_free (plugin);
   GNUNET_free (api);
   return NULL;
 }

References _, GNUNET_TRANSPORT_PluginFunctions::cls, destroy_session_shutdown_cb(), GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_HELLO_address_free, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_YES, http_common_plugin_address_to_string(), LOG, plugin, and server_stop_report_addresses().

Here is the call graph for this function:

◆ http_server_plugin_address_to_string()

static const char* http_server_plugin_address_to_string	(	void *	cls,
		const void *	addr,
		size_t	addrlen
	)

static

Function called for a quick conversion of the binary address to a numeric address.

Note that the caller must not free the address and that the next call to this function is allowed to override the address again.

Parameters

cls	unused
addr	binary address
addrlen	length of the address

Returns: string representing the same address

Definition at line 3367 of file plugin_transport_http_server.c.

 {
   return http_common_plugin_address_to_string (PLUGIN_NAME,
                                                addr,
                                                addrlen);
 }

References http_common_plugin_address_to_string(), and PLUGIN_NAME.

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ http_server_plugin_get_network()

static enum GNUNET_NetworkType http_server_plugin_get_network	(	void *	cls,
		struct GNUNET_ATS_Session *	session
	)

static

Function obtain the network type for a session.

Parameters

cls	closure (`struct HTTP_Server_Plugin *`)
session	the session

Returns: the network type in HBO or GNUNET_SYSERR

Definition at line 3367 of file plugin_transport_http_server.c.

 {
   return session->scope;
 }

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the caller graph for this function:

◆ http_server_plugin_get_network_for_address()

static enum GNUNET_NetworkType http_server_plugin_get_network_for_address	(	void *	cls,
		const struct GNUNET_HELLO_Address *	address
	)

static

Function obtain the network type for an address.

Parameters

cls	closure (`struct Plugin *`)
address	the address

Returns: the network type

Definition at line 3367 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
  
   return http_common_get_network_for_address (plugin->env,
                                               address);
 }

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the caller graph for this function:

◆ http_server_plugin_update_inbound_delay()

static void http_server_plugin_update_inbound_delay	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		struct GNUNET_ATS_Session *	session,
		struct GNUNET_TIME_Relative	delay
	)

static

Function that will be called whenever the transport service wants to notify the plugin that the inbound quota changed and that the plugin should update it's delay for the next receive value.

Parameters

cls	closure
peer	which peer was the session for
session	which session is being updated
delay	new delay to use for receiving

Definition at line 3422 of file plugin_transport_http_server.c.

 {
   session->next_receive = GNUNET_TIME_relative_to_absolute (delay);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "New inbound delay %s\n",
        GNUNET_STRINGS_relative_time_to_string (delay,
                                                GNUNET_NO));
   if (NULL != session->recv_wakeup_task)
   {
     GNUNET_SCHEDULER_cancel (session->recv_wakeup_task);
     session->recv_wakeup_task
       = GNUNET_SCHEDULER_add_delayed (delay,
                                       &server_wake_up,
                                       session);
   }
 }

References delay, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_relative_to_absolute(), LOG, GNUNET_ATS_Session::next_receive, GNUNET_ATS_Session::recv_wakeup_task, and server_wake_up().

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_session_info_iter()

static int send_session_info_iter	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		void *	value
	)

static

Return information about the given session to the monitor callback.

Parameters

cls	the `struct Plugin` with the monitor callback (`sic`)
peer	peer we send information about
value	our `struct GNUNET_ATS_Session` to send information about

Returns: GNUNET_OK (continue to iterate)

Definition at line 3453 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
   struct GNUNET_ATS_Session *session = value;
  
   notify_session_monitor (plugin,
                           session,
                           GNUNET_TRANSPORT_SS_INIT);
   return GNUNET_OK;
 }

References GNUNET_OK, GNUNET_TRANSPORT_SS_INIT, notify_session_monitor(), plugin, and value.

Referenced by http_server_plugin_setup_monitor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ http_server_plugin_setup_monitor()

static void http_server_plugin_setup_monitor	(	void *	cls,
		GNUNET_TRANSPORT_SessionInfoCallback	sic,
		void *	sic_cls
	)

static

Begin monitoring sessions of a plugin.

There can only be one active monitor per plugin (i.e. if there are multiple monitors, the transport service needs to multiplex the generated events over all of them).

Parameters

cls	closure of the plugin
sic	callback to invoke, NULL to disable monitor; plugin will being by iterating over all active sessions immediately and then enter monitor mode
sic_cls	closure for sic

Definition at line 3480 of file plugin_transport_http_server.c.

 {
   struct HTTP_Server_Plugin *plugin = cls;
  
   plugin->sic = sic;
   plugin->sic_cls = sic_cls;
   if (NULL != sic)
   {
     GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions,
                                            &send_session_info_iter,
                                            plugin);
     /* signal end of first iteration */
     sic (sic_cls, NULL, NULL);
   }
 }

References GNUNET_CONTAINER_multipeermap_iterate(), plugin, send_session_info_iter(), HTTP_Server_Plugin::sic, and HTTP_Server_Plugin::sic_cls.

Referenced by libgnunet_plugin_transport_http_client_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ libgnunet_plugin_transport_http_client_init()

void* libgnunet_plugin_transport_http_client_init ( void * cls )

Entry point for the plugin.

Parameters

cls env

Returns: api

Definition at line 3506 of file plugin_transport_http_server.c.

 {
   struct GNUNET_TRANSPORT_PluginEnvironment *env = cls;
   struct GNUNET_TRANSPORT_PluginFunctions *api;
   struct HTTP_Server_Plugin *plugin;
  
   if (NULL == env->receive)
   {
     /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
        initialize the plugin or the API */
     api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
     api->cls = NULL;
     api->address_to_string = &http_server_plugin_address_to_string;
     api->string_to_address = &http_common_plugin_string_to_address;
     api->address_pretty_printer = &http_common_plugin_address_pretty_printer;
     return api;
   }
   plugin = GNUNET_new (struct HTTP_Server_Plugin);
   plugin->env = env;
   plugin->sessions = GNUNET_CONTAINER_multipeermap_create (128,
                                                            GNUNET_YES);
  
   api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
   api->cls = plugin;
   api->send = &http_server_plugin_send;
   api->disconnect_peer = &http_server_plugin_disconnect_peer;
   api->disconnect_session = &http_server_plugin_disconnect_session;
   api->query_keepalive_factor = &http_server_query_keepalive_factor;
   api->check_address = &http_server_plugin_address_suggested;
   api->get_session = &http_server_plugin_get_session;
  
   api->address_to_string = &http_server_plugin_address_to_string;
   api->string_to_address = &http_common_plugin_string_to_address;
   api->address_pretty_printer = &http_common_plugin_address_pretty_printer;
   api->get_network = &http_server_plugin_get_network;
   api->get_network_for_address = &http_server_plugin_get_network_for_address;
   api->update_session_timeout = &http_server_plugin_update_session_timeout;
   api->update_inbound_delay = &http_server_plugin_update_inbound_delay;
   api->setup_monitor = &http_server_plugin_setup_monitor;
 #if BUILD_HTTPS
   plugin->name = "transport-https_server";
   plugin->protocol = "https";
 #else
   plugin->name = "transport-http_server";
   plugin->protocol = "http";
 #endif
  
   if (GNUNET_YES ==
       GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
                                             plugin->name,
                                             "TCP_STEALTH"))
   {
 #ifdef TCP_STEALTH
     plugin->options |= HTTP_OPTIONS_TCP_STEALTH;
 #else
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 _ ("TCP_STEALTH not supported on this platform.\n"));
     LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
     return NULL;
 #endif
   }
  
   /* Compile URL regex */
   if (regcomp (&plugin->url_regex,
                URL_REGEX,
                REG_EXTENDED))
   {
     LOG (GNUNET_ERROR_TYPE_ERROR,
          _ ("Unable to compile URL regex\n"));
     LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
     return NULL;
   }
  
   /* Configure plugin */
   if (GNUNET_SYSERR == server_configure_plugin (plugin))
   {
     LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
     return NULL;
   }
  
   /* Check IPv6 support */
   if (GNUNET_YES == plugin->use_ipv6)
     plugin->use_ipv6 = server_check_ipv6_support (plugin);
  
   /* Report addresses to transport service */
   if (GNUNET_NO == plugin->external_only)
     server_start_report_addresses (plugin);
  
   if (GNUNET_SYSERR == server_start (plugin))
   {
     LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
     return NULL;
   }
   return api;
 }

Here is the call graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ PLUGIN_NAME

◆ LIBGNUNET_PLUGIN_TRANSPORT_INIT

◆ LIBGNUNET_PLUGIN_TRANSPORT_DONE

◆ HTTP_ERROR_RESPONSE

◆ _RECEIVE

◆ _SEND

◆ LOG

◆ OPTION_LONG_POLL

◆ URL_REGEX

Function Documentation

◆ notify_session_monitor()

◆ server_wake_up()

◆ server_reschedule()

◆ server_delete_session()

◆ http_server_plugin_disconnect_session()

◆ server_session_timeout()

◆ server_reschedule_session_timeout()

◆ http_server_plugin_send()

◆ destroy_session_shutdown_cb()

◆ destroy_session_cb()

◆ http_server_plugin_disconnect_peer()

◆ http_server_plugin_address_suggested()

◆ http_server_plugin_get_session()

◆ server_v4_run()

◆ server_v6_run()

◆ server_schedule()

◆ http_server_query_keepalive_factor()

◆ http_server_plugin_update_session_timeout()

◆ server_mhd_connection_timeout()

◆ server_parse_url()

◆ session_tag_it()

◆ server_lookup_connection()

◆ server_send_callback()

◆ server_receive_mst_cb()

◆ add_cors_headers()

◆ server_access_cb()

◆ server_disconnect_cb()

◆ server_connection_cb()

◆ server_accept_cb()

◆ server_log()

◆ run_mhd_start_daemon()

◆ server_start()

◆ server_add_address()

◆ server_remove_address()

◆ server_nat_port_map_callback()

◆ server_get_addresses()

◆ server_start_report_addresses()

◆ server_stop_report_addresses()

◆ server_check_ipv6_support()

◆ server_notify_external_hostname()

◆ server_configure_plugin()

◆ libgnunet_plugin_transport_http_client_done()

◆ http_server_plugin_address_to_string()

◆ http_server_plugin_get_network()

◆ http_server_plugin_get_network_for_address()

◆ http_server_plugin_update_inbound_delay()

◆ send_session_info_iter()

◆ http_server_plugin_setup_monitor()

◆ libgnunet_plugin_transport_http_client_init()