X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftransport%2Fplugin_transport_http_server.c;h=6a9c1b0baba318e9002aede5072a3ebdc1264ee8;hb=4bd01d03e323377bbbd7609e29d8179bcb682deb;hp=3e5a8f24f48a0901c57994129b8bf803bd849dd9;hpb=f65f40d0d8162e31b32fdc2595b7e5088cd0a5b3;p=oweals%2Fgnunet.git diff --git a/src/transport/plugin_transport_http_server.c b/src/transport/plugin_transport_http_server.c index 3e5a8f24f..6a9c1b0ba 100644 --- a/src/transport/plugin_transport_http_server.c +++ b/src/transport/plugin_transport_http_server.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet - (C) 2002-2014 Christian Grothoff (and other contributing authors) + Copyright (C) 2002-2014, 2017 GNUnet e.V. GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published @@ -14,8 +14,8 @@ You should have received a copy of the GNU General Public License along with GNUnet; see the file COPYING. If not, write to the - Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. + Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ /** @@ -29,7 +29,7 @@ #include "gnunet_util_lib.h" #include "gnunet_statistics_service.h" #include "gnunet_transport_plugin.h" -#include "gnunet_nat_lib.h" +#include "gnunet_nat_service.h" #include "plugin_transport_http_common.h" #include #include @@ -63,7 +63,7 @@ struct ServerRequest * The session this server request belongs to * Can be NULL, when session was disconnected and freed */ - struct Session *session; + struct GNUNET_ATS_Session *session; /** * The MHD connection @@ -92,6 +92,11 @@ struct ServerRequest */ int connected; + /** + * Currently suspended + */ + bool suspended; + }; @@ -174,7 +179,7 @@ struct HTTP_Message /** * Session handle for connections. */ -struct Session +struct GNUNET_ATS_Session { /** @@ -201,7 +206,7 @@ struct Session /** * Message stream tokenizer for incoming data */ - struct GNUNET_SERVER_MessageStreamTokenizer *msg_tk; + struct GNUNET_MessageStreamTokenizer *msg_tk; /** * Client recv handle @@ -232,12 +237,12 @@ struct Session /** * Session timeout task */ - GNUNET_SCHEDULER_TaskIdentifier timeout_task; + struct GNUNET_SCHEDULER_Task * timeout_task; /** * Task to resume MHD handling when receiving is allowed again */ - GNUNET_SCHEDULER_TaskIdentifier recv_wakeup_task; + struct GNUNET_SCHEDULER_Task * recv_wakeup_task; /** * Number of bytes waiting for transmission to this peer. @@ -255,9 +260,9 @@ struct Session uint32_t tag; /** - * ATS network type in NBO + * ATS network type. */ - uint32_t ats_address_network_type; + enum GNUNET_ATS_Network_Type scope; /** * #GNUNET_YES if this session is known to the service. @@ -374,17 +379,17 @@ struct HTTP_Server_Plugin /** * MHD IPv4 task */ - GNUNET_SCHEDULER_TaskIdentifier server_v4_task; + struct GNUNET_SCHEDULER_Task *server_v4_task; /** * MHD IPv6 task */ - GNUNET_SCHEDULER_TaskIdentifier server_v6_task; + struct GNUNET_SCHEDULER_Task *server_v6_task; /** * Task calling transport service about external address */ - GNUNET_SCHEDULER_TaskIdentifier notify_ext_task; + struct GNUNET_SCHEDULER_Task *notify_ext_task; /** * Notify transport only about external address @@ -466,7 +471,7 @@ struct HTTP_Server_Plugin */ static void notify_session_monitor (struct HTTP_Server_Plugin *plugin, - struct Session *session, + struct GNUNET_ATS_Session *session, enum GNUNET_TRANSPORT_SessionState state) { struct GNUNET_TRANSPORT_SessionInfo info; @@ -491,21 +496,19 @@ notify_session_monitor (struct HTTP_Server_Plugin *plugin, * Wake up an MHD connection which was suspended * * @param cls the session - * @param tc task context */ static void -server_wake_up (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +server_wake_up (void *cls) { - struct Session *s = cls; + struct GNUNET_ATS_Session *s = cls; - s->recv_wakeup_task = GNUNET_SCHEDULER_NO_TASK; - if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) - return; + 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; } @@ -529,23 +532,27 @@ server_reschedule (struct HTTP_Server_Plugin *plugin, * @param s the session to delete */ static void -server_delete_session (struct Session *s) +server_delete_session (struct GNUNET_ATS_Session *s) { struct HTTP_Server_Plugin *plugin = s->plugin; struct HTTP_Message *msg; - if (GNUNET_SCHEDULER_NO_TASK != s->timeout_task) + if (NULL != s->timeout_task) { GNUNET_SCHEDULER_cancel (s->timeout_task); - s->timeout_task = GNUNET_SCHEDULER_NO_TASK; + s->timeout_task = NULL; s->timeout = GNUNET_TIME_UNIT_ZERO_ABS; } - if (GNUNET_SCHEDULER_NO_TASK != s->recv_wakeup_task) + if (NULL != s->recv_wakeup_task) { GNUNET_SCHEDULER_cancel (s->recv_wakeup_task); - s->recv_wakeup_task = GNUNET_SCHEDULER_NO_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, @@ -582,7 +589,14 @@ server_delete_session (struct Session *s) MHD_set_connection_option (s->server_send->mhd_conn, MHD_CONNECTION_OPTION_TIMEOUT, 1 /* 0 = no timeout, so this is MIN */); - server_reschedule (plugin, s->server_send->mhd_daemon, GNUNET_YES); + 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) @@ -594,7 +608,9 @@ server_delete_session (struct Session *s) 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); + server_reschedule (plugin, + s->server_recv->mhd_daemon, + GNUNET_YES); } notify_session_monitor (plugin, s, @@ -604,17 +620,17 @@ server_delete_session (struct Session *s) plugin->env->session_end (plugin->env->cls, s->address, s); + s->known_to_service = GNUNET_NO; } if (NULL != s->msg_tk) { - GNUNET_SERVER_mst_destroy (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); } @@ -629,7 +645,7 @@ server_delete_session (struct Session *s) */ static int http_server_plugin_disconnect_session (void *cls, - struct Session *s) + struct GNUNET_ATS_Session *s) { server_delete_session (s); return GNUNET_OK; @@ -640,16 +656,14 @@ http_server_plugin_disconnect_session (void *cls, * Session was idle, so disconnect it * * @param cls the session - * @param tc task context */ static void -server_session_timeout (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +server_session_timeout (void *cls) { - struct Session *s = cls; + struct GNUNET_ATS_Session *s = cls; struct GNUNET_TIME_Relative left; - s->timeout_task = GNUNET_SCHEDULER_NO_TASK; + s->timeout_task = NULL; left = GNUNET_TIME_absolute_get_remaining (s->timeout); if (0 != left.rel_value_us) { @@ -678,9 +692,9 @@ server_session_timeout (void *cls, * @param s the session */ static void -server_reschedule_session_timeout (struct Session *s) +server_reschedule_session_timeout (struct GNUNET_ATS_Session *s) { - GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != s->timeout_task); + GNUNET_assert (NULL != s->timeout_task); s->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); } @@ -714,7 +728,7 @@ server_reschedule_session_timeout (struct Session *s) */ static ssize_t http_server_plugin_send (void *cls, - struct Session *session, + struct GNUNET_ATS_Session *session, const char *msgbuf, size_t msgbuf_size, unsigned int priority, @@ -743,7 +757,7 @@ http_server_plugin_send (void *cls, msg->buf = (char *) &msg[1]; msg->transmit_cont = cont; msg->transmit_cont_cls = cont_cls; - memcpy (msg->buf, + GNUNET_memcpy (msg->buf, msgbuf, msgbuf_size); GNUNET_CONTAINER_DLL_insert_tail (session->msg_head, @@ -762,9 +776,16 @@ http_server_plugin_send (void *cls, 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; } @@ -774,34 +795,36 @@ http_server_plugin_send (void *cls, * * @param cls the `struct HTTP_Server_Plugin *` * @param peer for which this is a session - * @param value the `struct Session` to clean up + * @param value the `struct GNUNET_ATS_Session` to clean up * @return #GNUNET_OK (continue to iterate) */ static int destroy_session_shutdown_cb (void *cls, - const struct GNUNET_PeerIdentity *peer, - void *value) + const struct GNUNET_PeerIdentity *peer, + void *value) { - struct Session *s = value; + 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); - - GNUNET_free_non_null (sc_send); - GNUNET_free_non_null (sc_recv); + if (NULL != sc_send) + sc_send->session = NULL; + if (NULL != sc_recv) + sc_recv->session = NULL; return GNUNET_OK; } + /** * Terminate session. * * @param cls the `struct HTTP_Server_Plugin *` * @param peer for which this is a session - * @param value the `struct Session` to clean up + * @param value the `struct GNUNET_ATS_Session` to clean up * @return #GNUNET_OK (continue to iterate) */ static int @@ -809,12 +832,13 @@ destroy_session_cb (void *cls, const struct GNUNET_PeerIdentity *peer, void *value) { - struct Session *s = value; + struct GNUNET_ATS_Session *s = value; server_delete_session (s); return GNUNET_OK; } + /** * Function that can be used to force the plugin to disconnect * from the given peer and cancel all previous transmissions @@ -896,7 +920,7 @@ http_server_plugin_address_suggested (void *cls, * @param address the address * @return always NULL */ -static struct Session * +static struct GNUNET_ATS_Session * http_server_plugin_get_session (void *cls, const struct GNUNET_HELLO_Address *address) { @@ -909,17 +933,13 @@ http_server_plugin_get_session (void *cls, * and schedule the next run. * * @param cls plugin as closure - * @param tc task context */ static void -server_v4_run (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +server_v4_run (void *cls) { struct HTTP_Server_Plugin *plugin = cls; - plugin->server_v4_task = GNUNET_SCHEDULER_NO_TASK; - if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) - return; + 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); @@ -931,17 +951,13 @@ server_v4_run (void *cls, * and schedule the next run. * * @param cls plugin as closure - * @param tc task context */ static void -server_v6_run (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +server_v6_run (void *cls) { struct HTTP_Server_Plugin *plugin = cls; - plugin->server_v6_task = GNUNET_SCHEDULER_NO_TASK; - if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) - return; + 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); @@ -957,12 +973,12 @@ server_v6_run (void *cls, * @param now schedule now * @return gnunet task identifier */ -static GNUNET_SCHEDULER_TaskIdentifier +static struct GNUNET_SCHEDULER_Task * server_schedule (struct HTTP_Server_Plugin *plugin, struct MHD_Daemon *daemon_handle, int now) { - GNUNET_SCHEDULER_TaskIdentifier ret; + struct GNUNET_SCHEDULER_Task * ret; fd_set rs; fd_set ws; fd_set es; @@ -975,9 +991,9 @@ server_schedule (struct HTTP_Server_Plugin *plugin, struct GNUNET_TIME_Relative tv; if (GNUNET_YES == plugin->in_shutdown) - return GNUNET_SCHEDULER_NO_TASK; + return NULL; - ret = GNUNET_SCHEDULER_NO_TASK; + ret = NULL; FD_ZERO (&rs); FD_ZERO (&ws); FD_ZERO (&es); @@ -1015,10 +1031,10 @@ server_schedule (struct HTTP_Server_Plugin *plugin, if (daemon_handle == plugin->server_v4) { - if (plugin->server_v4_task != GNUNET_SCHEDULER_NO_TASK) + if (plugin->server_v4_task != NULL) { GNUNET_SCHEDULER_cancel (plugin->server_v4_task); - plugin->server_v4_task = GNUNET_SCHEDULER_NO_TASK; + plugin->server_v4_task = NULL; } #if 0 LOG (GNUNET_ERROR_TYPE_DEBUG, @@ -1032,10 +1048,10 @@ server_schedule (struct HTTP_Server_Plugin *plugin, } if (daemon_handle == plugin->server_v6) { - if (plugin->server_v6_task != GNUNET_SCHEDULER_NO_TASK) + if (plugin->server_v6_task != NULL) { GNUNET_SCHEDULER_cancel (plugin->server_v6_task); - plugin->server_v6_task = GNUNET_SCHEDULER_NO_TASK; + plugin->server_v6_task = NULL; } #if 0 LOG (GNUNET_ERROR_TYPE_DEBUG, @@ -1073,10 +1089,10 @@ server_reschedule (struct HTTP_Server_Plugin *plugin, if (GNUNET_YES == now) plugin->server_v4_immediately = GNUNET_YES; - if (plugin->server_v4_task != GNUNET_SCHEDULER_NO_TASK) + if (plugin->server_v4_task != NULL) { GNUNET_SCHEDULER_cancel (plugin->server_v4_task); - plugin->server_v4_task = GNUNET_SCHEDULER_NO_TASK; + plugin->server_v4_task = NULL; } plugin->server_v4_task = server_schedule (plugin, plugin->server_v4, now); } @@ -1089,10 +1105,10 @@ server_reschedule (struct HTTP_Server_Plugin *plugin, if (GNUNET_YES == now) plugin->server_v6_immediately = GNUNET_YES; - if (plugin->server_v6_task != GNUNET_SCHEDULER_NO_TASK) + if (plugin->server_v6_task != NULL) { GNUNET_SCHEDULER_cancel (plugin->server_v6_task); - plugin->server_v6_task = GNUNET_SCHEDULER_NO_TASK; + plugin->server_v6_task = NULL; } plugin->server_v6_task = server_schedule (plugin, plugin->server_v6, now); } @@ -1126,7 +1142,7 @@ http_server_query_keepalive_factor (void *cls) static void http_server_plugin_update_session_timeout (void *cls, const struct GNUNET_PeerIdentity *peer, - struct Session *session) + struct GNUNET_ATS_Session *session) { server_reschedule_session_timeout (session); } @@ -1141,7 +1157,7 @@ http_server_plugin_update_session_timeout (void *cls, */ static void server_mhd_connection_timeout (struct HTTP_Server_Plugin *plugin, - struct Session *s, + struct GNUNET_ATS_Session *s, unsigned int to) { /* Setting timeouts for other connections */ @@ -1304,12 +1320,12 @@ server_parse_url (struct HTTP_Server_Plugin *plugin, /** * Closure for #session_tag_it(). */ -struct SessionTagContext +struct GNUNET_ATS_SessionTagContext { /** * Set to session matching the tag. */ - struct Session *res; + struct GNUNET_ATS_Session *res; /** * Tag we are looking for. @@ -1321,9 +1337,9 @@ struct SessionTagContext /** * Find a session with a matching tag. * - * @param cls the `struct SessionTagContext *` + * @param cls the `struct GNUNET_ATS_SessionTagContext *` * @param key peer identity (unused) - * @param value the `struct Session *` + * @param value the `struct GNUNET_ATS_Session *` * @return #GNUNET_NO if we found the session, #GNUNET_OK if not */ static int @@ -1331,8 +1347,8 @@ session_tag_it (void *cls, const struct GNUNET_PeerIdentity *key, void *value) { - struct SessionTagContext *stc = cls; - struct Session *s = value; + struct GNUNET_ATS_SessionTagContext *stc = cls; + struct GNUNET_ATS_Session *s = value; if (s->tag == stc->tag) { @@ -1358,17 +1374,17 @@ server_lookup_connection (struct HTTP_Server_Plugin *plugin, const char *url, const char *method) { - struct Session *s = NULL; + struct GNUNET_ATS_Session *s = NULL; struct ServerRequest *sc = NULL; const union MHD_ConnectionInfo *conn_info; struct HttpAddress *addr; - struct GNUNET_ATS_Information ats; struct GNUNET_PeerIdentity target; size_t addr_len; - struct SessionTagContext stc; + struct GNUNET_ATS_SessionTagContext stc; uint32_t options; int direction = GNUNET_SYSERR; unsigned int to; + enum GNUNET_ATS_Network_Type scope; conn_info = MHD_get_connection_info (mhd_connection, MHD_CONNECTION_INFO_CLIENT_ADDRESS); @@ -1380,6 +1396,7 @@ server_lookup_connection (struct HTTP_Server_Plugin *plugin, method, url); stc.tag = 0; + options = 0; /* make gcc happy */ if (GNUNET_SYSERR == server_parse_url (plugin, url, &target, &stc.tag, &options)) { @@ -1423,34 +1440,32 @@ server_lookup_connection (struct HTTP_Server_Plugin *plugin, conn_info->client_addr, sizeof (struct sockaddr_in)); addr_len = http_common_address_get_size (addr); - ats = plugin->env->get_address_type (plugin->env->cls, - conn_info->client_addr, - sizeof (struct sockaddr_in)); + 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); - ats = plugin->env->get_address_type (plugin->env->cls, - conn_info->client_addr, - sizeof (struct sockaddr_in6)); + scope = plugin->env->get_address_type (plugin->env->cls, + conn_info->client_addr, + sizeof (struct sockaddr_in6)); break; default: - /* external host name */ - ats.type = htonl (GNUNET_ATS_NETWORK_TYPE); - ats.type = htonl (GNUNET_ATS_NET_WAN); + /* external host name */ return NULL; } - s = GNUNET_new (struct Session); + 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->ats_address_network_type = ats.value; s->next_receive = GNUNET_TIME_UNIT_ZERO_ABS; s->tag = stc.tag; s->timeout = GNUNET_TIME_relative_to_absolute (HTTP_SERVER_SESSION_TIMEOUT); @@ -1520,30 +1535,14 @@ server_lookup_connection (struct HTTP_Server_Plugin *plugin, notify_session_monitor (plugin, s, GNUNET_TRANSPORT_SS_UP); - plugin->env->session_start (NULL, + plugin->env->session_start (plugin->env->cls, s->address, s, - NULL, 0); + s->scope); } - if ( (NULL == s->server_recv) || - (NULL == s->server_send) ) - { - to = (HTTP_SERVER_NOT_VALIDATED_TIMEOUT.rel_value_us / 1000LL / 1000LL); - MHD_set_connection_option (mhd_connection, - MHD_CONNECTION_OPTION_TIMEOUT, to); - server_reschedule (plugin, sc->mhd_daemon, GNUNET_NO); - } - else - { - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Session %p for peer `%s' fully connected\n", - s, GNUNET_i2s (&target)); - to = (HTTP_SERVER_SESSION_TIMEOUT.rel_value_us / 1000LL / 1000LL); - server_mhd_connection_timeout (plugin, s, to); - } - LOG (GNUNET_ERROR_TYPE_DEBUG, - "Setting timeout for %p to %u sec.\n", sc, to); + to = (HTTP_SERVER_SESSION_TIMEOUT.rel_value_us / 1000LL / 1000LL); + server_mhd_connection_timeout (plugin, s, to); return sc; } @@ -1564,7 +1563,7 @@ server_send_callback (void *cls, size_t max) { struct ServerRequest *sc = cls; - struct Session *s = sc->session; + struct GNUNET_ATS_Session *s = sc->session; ssize_t bytes_read = 0; struct HTTP_Message *msg; char *stat_txt; @@ -1584,7 +1583,7 @@ server_send_callback (void *cls, /* sending */ bytes_read = GNUNET_MIN (msg->size - msg->pos, max); - memcpy (buf, &msg->buf[msg->pos], bytes_read); + GNUNET_memcpy (buf, &msg->buf[msg->pos], bytes_read); msg->pos += bytes_read; /* removing message */ @@ -1637,6 +1636,12 @@ server_send_callback (void *cls, 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; } @@ -1645,34 +1650,25 @@ server_send_callback (void *cls, * Callback called by MessageStreamTokenizer when a message has arrived * * @param cls current session as closure - * @param client client * @param message the message to be forwarded to transport service - * @return #GNUNET_OK + * @return #GNUNET_OK (all OK) */ static int server_receive_mst_cb (void *cls, - void *client, const struct GNUNET_MessageHeader *message) { - struct Session *s = cls; + struct GNUNET_ATS_Session *s = cls; struct HTTP_Server_Plugin *plugin = s->plugin; - struct GNUNET_ATS_Information atsi; struct GNUNET_TIME_Relative delay; char *stat_txt; - atsi.type = htonl (GNUNET_ATS_NETWORK_TYPE); - atsi.value = s->ats_address_network_type; - GNUNET_break (s->ats_address_network_type != - ntohl (GNUNET_ATS_NET_UNSPECIFIED)); - if (GNUNET_NO == s->known_to_service) { s->known_to_service = GNUNET_YES; - plugin->env->session_start (NULL, + plugin->env->session_start (plugin->env->cls, s->address, s, - NULL, - 0); + s->scope); notify_session_monitor (plugin, s, GNUNET_TRANSPORT_SS_UP); @@ -1681,14 +1677,13 @@ server_receive_mst_cb (void *cls, s->address, s, message); - plugin->env->update_address_metrics (plugin->env->cls, - s->address, s, - &atsi, 1); GNUNET_asprintf (&stat_txt, "# bytes received via %s_server", plugin->protocol); GNUNET_STATISTICS_update (plugin->env->stats, - stat_txt, ntohs (message->size), GNUNET_NO); + 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) @@ -1753,7 +1748,7 @@ server_access_cb (void *cls, { struct HTTP_Server_Plugin *plugin = cls; struct ServerRequest *sc = *httpSessionCache; - struct Session *s; + struct GNUNET_ATS_Session *s; struct MHD_Response *response; int res = MHD_YES; @@ -1788,10 +1783,9 @@ server_access_cb (void *cls, else { /* existing session already has matching connection, refuse */ - response = MHD_create_response_from_data (strlen (HTTP_ERROR_RESPONSE), - HTTP_ERROR_RESPONSE, - MHD_NO, - MHD_NO); + 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"); @@ -1806,8 +1800,9 @@ server_access_cb (void *cls, { /* Session was already disconnected; sent HTTP/1.1: 200 OK as response */ - response = MHD_create_response_from_data (strlen ("Thank you!"), - "Thank you!", MHD_NO, MHD_NO); + 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); @@ -1850,8 +1845,9 @@ server_access_cb (void *cls, s->address->address_length)); sc->connected = GNUNET_NO; /* Sent HTTP/1.1: 200 OK as PUT Response\ */ - response = MHD_create_response_from_data (strlen ("Thank you!"), - "Thank you!", MHD_NO, MHD_NO); + 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); @@ -1878,26 +1874,35 @@ server_access_cb (void *cls, *upload_data_size); if (s->msg_tk == NULL) { - s->msg_tk = GNUNET_SERVER_mst_create (&server_receive_mst_cb, s); + s->msg_tk = GNUNET_MST_create (&server_receive_mst_cb, + s); } - GNUNET_SERVER_mst_receive (s->msg_tk, s, upload_data, *upload_data_size, - GNUNET_NO, GNUNET_NO); + 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); + 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_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); - if (GNUNET_SCHEDULER_NO_TASK == s->recv_wakeup_task) - s->recv_wakeup_task = GNUNET_SCHEDULER_add_delayed (delay, - &server_wake_up, s); + 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; } @@ -1961,7 +1966,7 @@ server_disconnect_cb (void *cls, sc->session->server_recv = NULL; if (NULL != sc->session->msg_tk) { - GNUNET_SERVER_mst_destroy (sc->session->msg_tk); + GNUNET_MST_destroy (sc->session->msg_tk); sc->session->msg_tk = NULL; } } @@ -1971,6 +1976,37 @@ server_disconnect_cb (void *cls, } +/** + * Callback from MHD when a connection starts/stops + * + * @param cls closure with the `struct HTTP_Server_Plugin *` + * @param connection connection handle + * @param socket_context socket-specific pointer + * @param toe reason for connection notification + * @see #MHD_OPTION_NOTIFY_CONNECTION + */ +static void +server_connection_cb (void *cls, + struct MHD_Connection *connection, + void **socket_context, + enum MHD_ConnectionNotificationCode toe) +{ + 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); +} + + /** * Check if incoming connection is accepted. * @@ -2199,11 +2235,13 @@ server_load_certificate (struct HTTP_Server_Plugin *plugin) * * @param plugin our plugin * @param addr listen address to use + * @param v6 MHD_NO_FLAG or MHD_USE_IPv6, depending on context * @return NULL on error */ static struct MHD_Daemon * run_mhd_start_daemon (struct HTTP_Server_Plugin *plugin, - const struct sockaddr_in *addr) + const struct sockaddr_in *addr, + int v6) { struct MHD_Daemon *server; unsigned int timeout; @@ -2226,7 +2264,8 @@ run_mhd_start_daemon (struct HTTP_Server_Plugin *plugin, #if BUILD_HTTPS MHD_USE_SSL | #endif - MHD_USE_SUSPEND_RESUME, + MHD_USE_SUSPEND_RESUME | + v6, plugin->port, &server_accept_cb, plugin, &server_access_cb, plugin, @@ -2246,13 +2285,15 @@ run_mhd_start_daemon (struct HTTP_Server_Plugin *plugin, timeout, MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (2 * - GNUNET_SERVER_MAX_MESSAGE_SIZE), + 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 SO_TCPSTEALTH +#ifdef TCP_STEALTH if ( (NULL != server) && (0 != (plugin->options & HTTP_OPTIONS_TCP_STEALTH)) ) { @@ -2263,7 +2304,7 @@ run_mhd_start_daemon (struct HTTP_Server_Plugin *plugin, NULL); if ( (0 != setsockopt ((int) di->listen_fd, IPPROTO_TCP, - SO_TCPSTEALTH, + TCP_STEALTH, plugin->env->my_identity, sizeof (struct GNUNET_PeerIdentity))) ) { @@ -2306,7 +2347,8 @@ server_start (struct HTTP_Server_Plugin *plugin) { plugin->server_v4 = run_mhd_start_daemon (plugin, - (const struct sockaddr_in *) plugin->server_addr_v4); + (const struct sockaddr_in *) plugin->server_addr_v4, + MHD_NO_FLAG); if (NULL == plugin->server_v4) { @@ -2327,7 +2369,8 @@ server_start (struct HTTP_Server_Plugin *plugin) { plugin->server_v6 = run_mhd_start_daemon (plugin, - (const struct sockaddr_in *) plugin->server_addr_v6); + (const struct sockaddr_in *) plugin->server_addr_v6, + MHD_USE_IPv6); if (NULL == plugin->server_v6) { LOG (GNUNET_ERROR_TYPE_ERROR, @@ -2494,12 +2537,14 @@ server_remove_address (void *cls, * @param cls closure, the 'struct LocalAddrList' * @param add_remove #GNUNET_YES to mean the new public IP address, #GNUNET_NO to mean * the previous (now invalid) one + * @param ac address class the address belongs to * @param addr either the previous or the new public IP address * @param addrlen actual lenght of the address */ static void server_nat_port_map_callback (void *cls, int add_remove, + enum GNUNET_NAT_AddressClass ac, const struct sockaddr *addr, socklen_t addrlen) { @@ -2519,7 +2564,8 @@ server_nat_port_map_callback (void *cls, if ((NULL != plugin->server_addr_v4) && (0 != memcmp (&plugin->server_addr_v4->sin_addr, - &s4->sin_addr, sizeof (struct in_addr)))) + &s4->sin_addr, + sizeof (struct in_addr)))) { LOG (GNUNET_ERROR_TYPE_DEBUG, "Skipping address `%s' (not bindto address)\n", @@ -2682,7 +2728,7 @@ server_get_addresses (struct HTTP_Server_Plugin *plugin, GNUNET_assert (pos->ai_addrlen == sizeof (struct sockaddr_in)); saddrlens[i] = pos->ai_addrlen; saddrs[i] = GNUNET_malloc (saddrlens[i]); - memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); + GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); } else @@ -2691,7 +2737,7 @@ server_get_addresses (struct HTTP_Server_Plugin *plugin, GNUNET_assert (pos->ai_addrlen == sizeof (struct sockaddr_in6)); saddrlens[i] = pos->ai_addrlen; saddrs[i] = GNUNET_malloc (saddrlens[i]); - memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); + GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); } i++; @@ -2775,13 +2821,16 @@ server_start_report_addresses (struct HTTP_Server_Plugin *plugin) return; } - plugin->nat = - GNUNET_NAT_register (plugin->env->cfg, - GNUNET_YES, - plugin->port, + plugin->nat + = GNUNET_NAT_register (plugin->env->cfg, + "transport-http_server", + IPPROTO_TCP, (unsigned int) res, - (const struct sockaddr **) addrs, addrlens, - &server_nat_port_map_callback, NULL, plugin); + (const struct sockaddr **) addrs, + addrlens, + &server_nat_port_map_callback, + NULL, + plugin); while (res > 0) { res--; @@ -2835,13 +2884,18 @@ server_check_ipv6_support (struct HTTP_Server_Plugin *plugin) int res = GNUNET_NO; /* Probe IPv6 support */ - desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0); + desc = GNUNET_NETWORK_socket_create (PF_INET6, + SOCK_STREAM, + 0); if (NULL == desc) { - if ((errno == ENOBUFS) || (errno == ENOMEM) || (errno == ENFILE) || - (errno == EACCES)) + if ( (errno == ENOBUFS) || + (errno == ENOMEM) || + (errno == ENFILE) || + (errno == EACCES) ) { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket"); + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, + "socket"); } LOG (GNUNET_ERROR_TYPE_WARNING, _("Disabling IPv6 since it is not supported on this system!\n")); @@ -2849,7 +2903,8 @@ server_check_ipv6_support (struct HTTP_Server_Plugin *plugin) } else { - GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc)); + GNUNET_break (GNUNET_OK == + GNUNET_NETWORK_socket_close (desc)); desc = NULL; res = GNUNET_YES; } @@ -2864,11 +2919,9 @@ server_check_ipv6_support (struct HTTP_Server_Plugin *plugin) * Notify server about our external hostname * * @param cls plugin - * @param tc task context (unused) */ static void -server_notify_external_hostname (void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +server_notify_external_hostname (void *cls) { struct HTTP_Server_Plugin *plugin = cls; struct HttpAddress *ext_addr; @@ -2876,21 +2929,17 @@ server_notify_external_hostname (void *cls, unsigned int urlen; char *url; - plugin->notify_ext_task = GNUNET_SCHEDULER_NO_TASK; - if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) - return; - - GNUNET_asprintf(&url, - "%s://%s", - plugin->protocol, - plugin->external_hostname); - + 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; - memcpy (&ext_addr[1], url, urlen); + GNUNET_memcpy (&ext_addr[1], url, urlen); GNUNET_free (url); LOG (GNUNET_ERROR_TYPE_DEBUG, @@ -2902,14 +2951,26 @@ server_notify_external_hostname (void *cls, 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); + 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); + 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 } @@ -2983,15 +3044,20 @@ server_configure_plugin (struct HTTP_Server_Plugin *plugin) 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))) + 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->protocol, + bind4_address); plugin->server_addr_v4 = GNUNET_new (struct sockaddr_in); - if (1 != inet_pton (AF_INET, bind4_address, + if (1 != inet_pton (AF_INET, + bind4_address, &plugin->server_addr_v4->sin_addr)) { LOG (GNUNET_ERROR_TYPE_ERROR, @@ -3005,7 +3071,7 @@ server_configure_plugin (struct HTTP_Server_Plugin *plugin) else { LOG (GNUNET_ERROR_TYPE_DEBUG, - _("Binding to IPv4 address %s\n"), + "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); @@ -3017,14 +3083,17 @@ server_configure_plugin (struct HTTP_Server_Plugin *plugin) (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string (plugin->env->cfg, plugin->name, - "BINDTO6", &bind6_address))) + "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)) + 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"), @@ -3037,7 +3106,7 @@ server_configure_plugin (struct HTTP_Server_Plugin *plugin) else { LOG (GNUNET_ERROR_TYPE_DEBUG, - _("Binding to IPv6 address %s\n"), + "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); @@ -3047,17 +3116,19 @@ server_configure_plugin (struct HTTP_Server_Plugin *plugin) 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"); + 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"); + 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; @@ -3087,7 +3158,7 @@ server_configure_plugin (struct HTTP_Server_Plugin *plugin) "%s:%u/%s", tmp, (uint16_t) port, - (NULL == pos_url) ? "" : pos_url); + pos_url); } else GNUNET_asprintf (&plugin->external_hostname, @@ -3170,10 +3241,10 @@ LIBGNUNET_PLUGIN_TRANSPORT_DONE (void *cls) _("Shutting down plugin `%s'\n"), plugin->name); - if (GNUNET_SCHEDULER_NO_TASK != plugin->notify_ext_task) + if (NULL != plugin->notify_ext_task) { GNUNET_SCHEDULER_cancel (plugin->notify_ext_task); - plugin->notify_ext_task = GNUNET_SCHEDULER_NO_TASK; + plugin->notify_ext_task = NULL; } if (NULL != plugin->ext_addr) @@ -3198,26 +3269,16 @@ LIBGNUNET_PLUGIN_TRANSPORT_DONE (void *cls) /* Stop to report addresses to transport service */ server_stop_report_addresses (plugin); - 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; - } - if (GNUNET_SCHEDULER_NO_TASK != plugin->server_v4_task) + if (NULL != plugin->server_v4_task) { GNUNET_SCHEDULER_cancel (plugin->server_v4_task); - plugin->server_v4_task = GNUNET_SCHEDULER_NO_TASK; + plugin->server_v4_task = NULL; } - if (GNUNET_SCHEDULER_NO_TASK != plugin->server_v6_task) + if (NULL != plugin->server_v6_task) { GNUNET_SCHEDULER_cancel (plugin->server_v6_task); - plugin->server_v6_task = GNUNET_SCHEDULER_NO_TASK; + plugin->server_v6_task = NULL; } #if BUILD_HTTPS GNUNET_free_non_null (plugin->crypto_init); @@ -3229,6 +3290,16 @@ LIBGNUNET_PLUGIN_TRANSPORT_DONE (void *cls) 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_non_null (plugin->external_hostname); GNUNET_free_non_null (plugin->ext_addr); @@ -3271,15 +3342,33 @@ http_server_plugin_address_to_string (void *cls, /** * Function obtain the network type for a session * - * @param cls closure ('struct HTTP_Server_Plugin*') + * @param cls closure (`struct HTTP_Server_Plugin *`) * @param session the session * @return the network type in HBO or #GNUNET_SYSERR */ static enum GNUNET_ATS_Network_Type http_server_plugin_get_network (void *cls, - struct Session *session) + struct GNUNET_ATS_Session *session) { - return ntohl (session->ats_address_network_type); + return session->scope; +} + + +/** + * Function obtain the network type for an address. + * + * @param cls closure (`struct Plugin *`) + * @param address the address + * @return the network type + */ +static enum GNUNET_ATS_Network_Type +http_server_plugin_get_network_for_address (void *cls, + const struct GNUNET_HELLO_Address *address) +{ + struct HTTP_Server_Plugin *plugin = cls; + + return http_common_get_network_for_address (plugin->env, + address); } @@ -3296,7 +3385,7 @@ http_server_plugin_get_network (void *cls, static void http_server_plugin_update_inbound_delay (void *cls, const struct GNUNET_PeerIdentity *peer, - struct Session *session, + struct GNUNET_ATS_Session *session, struct GNUNET_TIME_Relative delay) { session->next_receive = GNUNET_TIME_relative_to_absolute (delay); @@ -3304,7 +3393,7 @@ http_server_plugin_update_inbound_delay (void *cls, "New inbound delay %s\n", GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_NO)); - if (GNUNET_SCHEDULER_NO_TASK != session->recv_wakeup_task) + if (NULL != session->recv_wakeup_task) { GNUNET_SCHEDULER_cancel (session->recv_wakeup_task); session->recv_wakeup_task @@ -3321,7 +3410,7 @@ http_server_plugin_update_inbound_delay (void *cls, * * @param cls the `struct Plugin` with the monitor callback (`sic`) * @param peer peer we send information about - * @param value our `struct Session` to send information about + * @param value our `struct GNUNET_ATS_Session` to send information about * @return #GNUNET_OK (continue to iterate) */ static int @@ -3330,7 +3419,7 @@ send_session_info_iter (void *cls, void *value) { struct HTTP_Server_Plugin *plugin = cls; - struct Session *session = value; + struct GNUNET_ATS_Session *session = value; notify_session_monitor (plugin, session, @@ -3413,6 +3502,7 @@ LIBGNUNET_PLUGIN_TRANSPORT_INIT (void *cls) 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; @@ -3429,7 +3519,7 @@ LIBGNUNET_PLUGIN_TRANSPORT_INIT (void *cls) plugin->name, "TCP_STEALTH")) { -#ifdef SO_TCPSTEALTH +#ifdef TCP_STEALTH plugin->options |= HTTP_OPTIONS_TCP_STEALTH; #else GNUNET_log (GNUNET_ERROR_TYPE_ERROR, @@ -3440,12 +3530,12 @@ LIBGNUNET_PLUGIN_TRANSPORT_INIT (void *cls) } /* Compile URL regex */ - if (regcomp(&plugin->url_regex, - URL_REGEX, - REG_EXTENDED)) + if (regcomp (&plugin->url_regex, + URL_REGEX, + REG_EXTENDED)) { LOG (GNUNET_ERROR_TYPE_ERROR, - _("Unable to compile URL regex\n")); + _("Unable to compile URL regex\n")); LIBGNUNET_PLUGIN_TRANSPORT_DONE (api); return NULL; }