/*
This file is part of GNUnet
- (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Christian Grothoff (and other contributing authors)
+ (C) 2002-2013 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
*/
#include "platform.h"
-#include "gnunet_common.h"
-#include "gnunet_server_lib.h"
+#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_plugin.h"
#include "gnunet_nat_lib.h"
#include "plugin_transport_http_common.h"
-#include "microhttpd.h"
+#include <microhttpd.h>
+
+
#if BUILD_HTTPS
+#define PLUGIN_NAME "https_server"
#define LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_https_server_init
#define LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_https_server_done
#else
+#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
#endif
#define _RECEIVE 0
#define _SEND 1
+
+/* Enable output for debbuging URL's of incoming requests */
+#define DEBUG_URL_PARSE GNUNET_NO
+
+
/**
* Encapsulation of all of the state of the plugin.
*/
struct Plugin;
-
/**
* Session handle for connections.
*/
*/
int session_ended;
+ /**
+ * Are incoming connection established at the moment
+ */
+ int connect_in_progress;
+
/**
* Absolute time when to receive data again
* Used for receive throttling
*/
char *protocol;
+ /**
+ * My options to be included in the address
+ */
+ uint32_t options;
+
/**
* External address
*/
char *external_hostname;
+ /**
+ * Verify external address
+ */
+ int verify_external_hostname;
+
+
/**
* Maximum number of sockets the plugin can use
* Each http inbound /outbound connections are two connections
* External hostname the plugin can be connected to, can be different to
* the host's FQDN, used e.g. for reverse proxying
*/
- char *ext_addr;
+ struct HttpAddress *ext_addr;
/**
* Notify transport only about external address
*/
struct HttpAddressWrapper *prev;
- void *addr;
+ struct HttpAddress *address;
size_t addrlen;
};
*/
size_t size;
+ /**
+ * HTTP/S specific overhead
+ */
+ size_t overhead;
+
/**
* Continuation function to call once the transmission buffer
* has again space available. NULL if there is no
}
if (NULL == session->server_send)
{
+ if (GNUNET_NO == session->connect_in_progress)
+ {
+ GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, session->plugin->name,
+ "Session %p/connection %p: Sending message with %u bytes to peer `%s' with FAILED\n",
+ session, session->server_send,
+ msgbuf_size, GNUNET_i2s (&session->target));
GNUNET_break (0);
return GNUNET_SYSERR;
+ }
+ }
+ else
+ {
+ if (GNUNET_YES == session->server_send->disconnect)
+ return GNUNET_SYSERR;
}
- if (GNUNET_YES == session->server_send->disconnect)
- return GNUNET_SYSERR;
-
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, session->plugin->name,
"Session %p/connection %p: Sending message with %u to peer `%s' with \n",
session, session->server_send,
stat_txt, msgbuf_size, GNUNET_NO);
GNUNET_free (stat_txt);
- server_reschedule (session->plugin, session->server_send->mhd_daemon, GNUNET_YES);
- server_reschedule_session_timeout (session);
-
- /* struct Plugin *plugin = cls; */
+ if (NULL != session->server_send)
+ {
+ server_reschedule (session->plugin,
+ session->server_send->mhd_daemon,
+ GNUNET_YES);
+ server_reschedule_session_timeout (session);
+ }
return bytes_sent;
}
http_server_plugin_address_suggested (void *cls, const void *addr,
size_t addrlen)
{
- struct HTTP_Server_Plugin *plugin = cls;
- struct HttpAddressWrapper *next;
- struct HttpAddressWrapper *pos;
-
-
- if ((NULL != plugin->ext_addr) &&
- GNUNET_YES == (http_common_cmp_addresses (addr, addrlen,
- plugin->ext_addr, plugin->ext_addr_len)))
- return GNUNET_OK;
-
- next = plugin->addr_head;
- while (NULL != (pos = next))
- {
- next = pos->next;
- if (GNUNET_YES == (http_common_cmp_addresses(addr,
- addrlen,
- pos->addr,
- pos->addrlen)))
- return GNUNET_OK;
-
- }
-
- return GNUNET_NO;
+ struct HttpAddressWrapper *next;
+ struct HttpAddressWrapper *pos;
+ const struct HttpAddress *haddr = addr;
+
+ if ((NULL != p->ext_addr) &&
+ GNUNET_YES == (http_common_cmp_addresses (addr, addrlen,
+ p->ext_addr, p->ext_addr_len)))
+ {
+ /* Checking HTTP_OPTIONS_VERIFY_CERTIFICATE option for external hostname */
+ if ((ntohl(haddr->options) & HTTP_OPTIONS_VERIFY_CERTIFICATE) !=
+ (p->options & HTTP_OPTIONS_VERIFY_CERTIFICATE))
+ return GNUNET_NO; /* VERIFY option not set as required! */
+ return GNUNET_OK;
+ }
+
+ next = p->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;
}
GNUNET_CONTAINER_DLL_remove (s->msg_head, s->msg_tail, msg);
if (msg->transmit_cont != NULL)
{
- msg->transmit_cont (msg->transmit_cont_cls, &s->target, GNUNET_SYSERR);
+ msg->transmit_cont (msg->transmit_cont_cls, &s->target, GNUNET_SYSERR,
+ msg->size, msg->pos + msg->overhead);
}
GNUNET_free (msg);
msg = tmp;
GNUNET_free (s->addr);
GNUNET_free_non_null (s->server_recv);
GNUNET_free_non_null (s->server_send);
- GNUNET_free (s);
-
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"Session %p destroyed\n", s);
+ GNUNET_free (s);
}
return GNUNET_OK;
}
+
+
+/**
+ * Tell MHD that the connection should timeout after @a to seconds.
+ *
+ * @param plugin our plugin
+ * @param s session for which the timeout changes
+ * @param to timeout in seconds
+ */
static void
-server_mhd_connection_timeout (struct HTTP_Server_Plugin *plugin, struct Session *s, int to)
+server_mhd_connection_timeout (struct HTTP_Server_Plugin *plugin,
+ struct Session *s,
+ unsigned int to)
{
#if MHD_VERSION >= 0x00090E00
/* Setting timeouts for other connections */
- if (s->server_recv != NULL)
- {
- GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
- "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 (s->server_send != NULL)
- {
- GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
- "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);
- }
+ if (NULL != s->server_recv)
+ {
+ GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
+ "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)
+ {
+ GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
+ "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);
+ }
#endif
}
*/
static int
-server_parse_url (struct HTTP_Server_Plugin *plugin, const char * url, struct GNUNET_PeerIdentity * target, uint32_t *tag)
+server_parse_url (struct HTTP_Server_Plugin *plugin,
+ const char *url,
+ struct GNUNET_PeerIdentity *target,
+ uint32_t *tag)
{
- int debug = GNUNET_YES;
-
char * tag_start = NULL;
char * tag_end = NULL;
char * target_start = NULL;
char * separator = NULL;
- char hash[plugin->peer_id_length+1];
- int hash_length;
+ unsigned int hash_length;
unsigned long int ctag;
/* URL parsing
if (NULL == separator)
{
- if (debug) GNUNET_break (0);
+ if (DEBUG_URL_PARSE) GNUNET_break (0);
return GNUNET_SYSERR;
}
tag_start = separator + 1;
if (strlen (tag_start) == 0)
{
/* No tag after separator */
- if (debug) GNUNET_break (0);
+ if (DEBUG_URL_PARSE) GNUNET_break (0);
return GNUNET_SYSERR;
}
ctag = strtoul (tag_start, &tag_end, 10);
if (ctag == 0)
{
/* tag == 0 , invalid */
- if (debug) GNUNET_break (0);
+ if (DEBUG_URL_PARSE) GNUNET_break (0);
return GNUNET_SYSERR;
}
if ((ctag == ULONG_MAX) && (ERANGE == errno))
{
/* out of range: > ULONG_MAX */
- if (debug) GNUNET_break (0);
+ if (DEBUG_URL_PARSE) GNUNET_break (0);
return GNUNET_SYSERR;
}
if (ctag > UINT32_MAX)
{
/* out of range: > UINT32_MAX */
- if (debug) GNUNET_break (0);
+ if (DEBUG_URL_PARSE) GNUNET_break (0);
return GNUNET_SYSERR;
}
(*tag) = (uint32_t) ctag;
if (NULL == tag_end)
{
/* no char after tag */
- if (debug) GNUNET_break (0);
+ if (DEBUG_URL_PARSE) GNUNET_break (0);
return GNUNET_SYSERR;
}
if (url[strlen(url)] != tag_end[0])
{
/* there are more not converted chars after tag */
- if (debug) GNUNET_break (0);
+ if (DEBUG_URL_PARSE) GNUNET_break (0);
return GNUNET_SYSERR;
}
- if (debug)
+ if (DEBUG_URL_PARSE)
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"Found tag `%u' in url\n", (*tag));
if (hash_length != plugin->peer_id_length)
{
/* no char after tag */
- if (debug) GNUNET_break (0);
+ if (DEBUG_URL_PARSE) GNUNET_break (0);
return GNUNET_SYSERR;
}
- memcpy (hash, target_start, hash_length);
- hash[hash_length] = '\0';
-
- if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((const char *) hash, &(target->hashPubKey)))
- {
+ if (GNUNET_OK !=
+ GNUNET_CRYPTO_ecc_public_sign_key_from_string (target_start,
+ hash_length,
+ &target->public_key))
+ {
/* hash conversion failed */
- if (debug) GNUNET_break (0);
+ if (DEBUG_URL_PARSE) GNUNET_break (0);
return GNUNET_SYSERR;
}
-
- GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
- "Found target `%s' in url\n", GNUNET_h2s_full(&target->hashPubKey));
+ GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+ plugin->name,
+ "Found target `%s' in URL\n",
+ GNUNET_i2s_full (target));
return GNUNET_OK;
}
struct ServerConnection *sc = NULL;
const union MHD_ConnectionInfo *conn_info;
struct GNUNET_ATS_Information ats;
-
- char *addr;
+ struct HttpAddress *addr;
size_t addr_len;
-
struct GNUNET_PeerIdentity target;
uint32_t tag = 0;
int direction = GNUNET_SYSERR;
- int to;
+ unsigned int to;
conn_info = MHD_get_connection_info (mhd_connection,
MHD_CONNECTION_INFO_CLIENT_ADDRESS);
ats = plugin->env->get_address_type (plugin->env->cls, conn_info->client_addr, sizeof (struct sockaddr_in6));
break;
default:
- GNUNET_break (0);
+ /* external host name */
+ ats.type = htonl (GNUNET_ATS_NETWORK_TYPE);
+ ats.type = htonl (GNUNET_ATS_NET_WAN);
return NULL;
}
- GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
- "Creating new session for peer `%s' connecting from `%s'\n",
- GNUNET_i2s (&target),
- http_common_plugin_address_to_string (NULL, addr, addr_len));
s = GNUNET_malloc (sizeof (struct Session));
memcpy (&s->target, &target, sizeof (struct GNUNET_PeerIdentity));
s->server_send = NULL;
s->session_passed = GNUNET_NO;
s->session_ended = GNUNET_NO;
+ s->connect_in_progress = GNUNET_YES;
server_start_session_timeout(s);
GNUNET_CONTAINER_DLL_insert (plugin->head, plugin->tail, s);
+
+ GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
+ "Creating new session %p for peer `%s' connecting from `%s'\n",
+ s, GNUNET_i2s (&target),
+ http_common_plugin_address_to_string (NULL, p->protocol, addr, addr_len));
}
sc = GNUNET_malloc (sizeof (struct ServerConnection));
if (conn_info->client_addr->sa_family == AF_INET)
s->server_send = sc;
if (direction == _RECEIVE)
s->server_recv = sc;
+
+ if ((NULL != s->server_send) && (NULL != s->server_recv))
+ {
+ s->connect_in_progress = GNUNET_NO; /* PUT and GET are connected */
+ plugin->env->session_start (NULL, &s->target, PLUGIN_NAME, NULL, 0 ,s, NULL, 0);
+ }
+
#if MHD_VERSION >= 0x00090E00
if ((NULL == s->server_recv) || (NULL == s->server_send))
{
- to = (HTTP_SERVER_NOT_VALIDATED_TIMEOUT.rel_value / 1000);
- MHD_set_connection_option (mhd_connection, MHD_CONNECTION_OPTION_TIMEOUT, to);
+ 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
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"Session %p for peer `%s' fully connected\n",
s, GNUNET_i2s (&target));
- to = (SERVER_SESSION_TIMEOUT.rel_value / 1000);
+ to = (SERVER_SESSION_TIMEOUT.rel_value_us / 1000LL / 1000LL);
server_mhd_connection_timeout (plugin, s, to);
}
{
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->transmit_cont (msg->transmit_cont_cls, &s->target, GNUNET_OK,
+ msg->size, msg->size + msg->overhead);
GNUNET_free (msg);
}
}
const struct GNUNET_MessageHeader *message)
{
struct Session *s = cls;
- struct GNUNET_ATS_Information atsi[2];
+ struct HTTP_Server_Plugin *plugin = s->plugin;
+ struct GNUNET_ATS_Information atsi;
struct GNUNET_TIME_Relative delay;
char *stat_txt;
if (GNUNET_NO == server_exist_session(p, s))
return GNUNET_OK;
- struct HTTP_Server_Plugin *plugin = s->plugin;
- atsi[0].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
- atsi[0].value = htonl (1);
- atsi[1].type = htonl (GNUNET_ATS_NETWORK_TYPE);
- atsi[1].value = s->ats_address_network_type;
+ 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));
delay = plugin->env->receive (plugin->env->cls,
&s->target,
message,
- (const struct GNUNET_ATS_Information *) &atsi, 2,
- s, s->addr, s->addrlen);
+ s, NULL, 0);
+
+ plugin->env->update_address_metrics (plugin->env->cls,
+ &s->target,
+ NULL, 0, s, &atsi, 1);
GNUNET_asprintf (&stat_txt, "# bytes received via %s_server", plugin->protocol);
GNUNET_STATISTICS_update (plugin->env->stats,
s->session_passed = GNUNET_YES;
s->next_receive = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (), delay);
- if (delay.rel_value > 0)
+ if (delay.rel_value_us > 0)
{
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
- "Peer `%s' address `%s' next read delayed for %llu ms\n",
+ "Peer `%s' address `%s' next read delayed for %s\n",
GNUNET_i2s (&s->target),
- http_common_plugin_address_to_string (NULL, s->addr, s->addrlen),
- delay);
+ http_common_plugin_address_to_string (NULL, p->protocol, s->addr, s->addrlen),
+ GNUNET_STRINGS_relative_time_to_string (delay,
+ GNUNET_YES));
}
server_reschedule_session_timeout (s);
return GNUNET_OK;
else
{
response = MHD_create_response_from_data (strlen (HTTP_ERROR_RESPONSE), HTTP_ERROR_RESPONSE, MHD_NO, MHD_NO);
+ MHD_add_response_header (response,
+ MHD_HTTP_HEADER_CONTENT_TYPE,
+ "text/html");
res = MHD_queue_response (mhd_connection, MHD_HTTP_NOT_FOUND, response);
MHD_destroy_response (response);
return res;
response = MHD_create_response_from_data (strlen ("Thank you!"),
"Thank you!",
MHD_NO, MHD_NO);
- res = MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
+ MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
MHD_destroy_response (response);
return MHD_YES;
}
s, sc,
GNUNET_i2s (&s->target),
http_common_plugin_address_to_string (NULL,
+ p->protocol,
s->addr,
s->addrlen));
sc->connected = GNUNET_YES;
s, sc,
GNUNET_i2s (&s->target),
http_common_plugin_address_to_string (NULL,
+ p->protocol,
s->addr,
s->addrlen));
sc->connected = GNUNET_NO;
response = MHD_create_response_from_data (strlen ("Thank you!"),
"Thank you!",
MHD_NO, MHD_NO);
- res = MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
+ MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
MHD_destroy_response (response);
return MHD_YES;
}
s, sc,
GNUNET_i2s (&s->target),
http_common_plugin_address_to_string (NULL,
+ p->protocol,
s->addr,
s->addrlen),
*upload_data_size);
struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
- if ((s->next_receive.abs_value <= now.abs_value))
+ if ((s->next_receive.abs_value_us <= now.abs_value_us))
{
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"PUT with %u bytes forwarded to MST\n",
}
GNUNET_SERVER_mst_receive (s->msg_tk, s, upload_data,
*upload_data_size, GNUNET_NO, GNUNET_NO);
-#if MHD_VERSION >= 0x00090E00
- server_mhd_connection_timeout (plugin, s, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value / 1000);
-#endif
+ server_mhd_connection_timeout (plugin, s,
+ GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value_us / 1000LL / 1000LL);
(*upload_data_size) = 0;
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Session %p / Connection %p: no inbound bandwidth available! Next read was delayed by %llu ms\n",
- s, sc, now.abs_value - s->next_receive.abs_value);
+ "Session %p / Connection %p: no inbound bandwidth available! Next read was delayed by %s\n",
+ s, sc,
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (s->next_receive),
+ GNUNET_YES));
}
return MHD_YES;
}
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"Peer `%s' connection %p, GET on address `%s' disconnected\n",
GNUNET_i2s (&s->target), s->server_send,
- http_common_plugin_address_to_string (NULL, s->addr, s->addrlen));
+ http_common_plugin_address_to_string (NULL, p->protocol, s->addr, s->addrlen));
s->server_send = NULL;
if (NULL != (s->server_recv))
{
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"Peer `%s' connection %p PUT on address `%s' disconnected\n",
GNUNET_i2s (&s->target), s->server_recv,
- http_common_plugin_address_to_string (NULL, s->addr, s->addrlen));
+ http_common_plugin_address_to_string (NULL, p->protocol, s->addr, s->addrlen));
s->server_recv = NULL;
/* Do not terminate session when PUT disconnects
if (NULL != (s->server_send))
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"Peer `%s' on address `%s' disconnected\n",
GNUNET_i2s (&s->target),
- http_common_plugin_address_to_string (NULL, s->addr, s->addrlen));
+ http_common_plugin_address_to_string (NULL, p->protocol, s->addr, s->addrlen));
if ((GNUNET_YES == s->session_passed) && (GNUNET_NO == s->session_ended))
{
{
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
- "SELECT Timeout changed from %llu to %llu\n",
+ "SELECT Timeout changed from %llu to %llu (ms)\n",
last_timeout, timeout);
last_timeout = timeout;
}
- if (timeout <= GNUNET_TIME_UNIT_SECONDS.rel_value)
- tv.rel_value = (uint64_t) 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;
}
server_start (struct HTTP_Server_Plugin *plugin)
{
unsigned int timeout;
+ char *msg;
GNUNET_assert (NULL != plugin);
#if BUILD_HTTPS
#if MHD_VERSION >= 0x00090E00
- timeout = HTTP_SERVER_NOT_VALIDATED_TIMEOUT.rel_value / 1000;
+ timeout = HTTP_SERVER_NOT_VALIDATED_TIMEOUT.rel_value_us / 1000LL / 1000LL;
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"MHD can set timeout per connection! Default time out %u sec.\n",
timeout);
#else
- timeout = SERVER_SESSION_TIMEOUT.rel_value / 1000;
+ timeout = SERVER_SESSION_TIMEOUT.rel_value_us / 1000LL / 1000LL;
GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, plugin->name,
"MHD cannot set timeout per connection! Default time out %u sec.\n",
timeout);
#endif
+
plugin->server_v4 = NULL;
if (plugin->use_ipv4 == GNUNET_YES)
{
&server_disconnect_cb, plugin,
MHD_OPTION_EXTERNAL_LOGGER,
server_log, NULL, MHD_OPTION_END);
+ if (plugin->server_v4 == NULL)
+ {
+ GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, plugin->name,
+ "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 (plugin->use_ipv6 == GNUNET_YES)
{
&server_disconnect_cb, plugin,
MHD_OPTION_EXTERNAL_LOGGER,
server_log, NULL, MHD_OPTION_END);
-
- }
-
- if ((plugin->use_ipv4 == GNUNET_YES) && (plugin->server_v4 == NULL))
- {
- GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, plugin->name,
- "Failed to start %s IPv4 server component on port %u\n",
- plugin->name, plugin->port);
- return GNUNET_SYSERR;
+ if (plugin->server_v6 == NULL)
+ {
+ GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, plugin->name,
+ "Failed to start %s IPv6 server component on port %u\n",
+ plugin->name, plugin->port);
+ }
+ else
+ server_reschedule (plugin, plugin->server_v6, GNUNET_NO);
}
- server_reschedule (plugin, plugin->server_v4, GNUNET_NO);
- if ((plugin->use_ipv6 == GNUNET_YES) && (plugin->server_v6 == NULL))
+ msg = "No";
+ if ((plugin->server_v6 == NULL) && (plugin->server_v4 == NULL))
{
GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, plugin->name,
- "Failed to start %s IPv6 server component on port %u\n",
- plugin->name, plugin->port);
+ "%s %s server component started on port %u\n",
+ msg, plugin->name, plugin->port);
+ sleep (10);
return GNUNET_SYSERR;
}
- server_reschedule (plugin, plugin->server_v6, GNUNET_NO);
+ else if ((plugin->server_v6 != NULL) && (plugin->server_v4 != NULL))
+ msg = "IPv4 and IPv6";
+ else if (plugin->server_v6 != NULL)
+ msg = "IPv6";
+ else if (plugin->server_v4 != NULL)
+ msg = "IPv4";
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
- "%s server component started on port %u\n", plugin->name,
- plugin->port);
+ "%s %s server component started on port %u\n",
+ msg, plugin->name, plugin->port);
return GNUNET_OK;
}
struct HttpAddressWrapper *w = NULL;
w = GNUNET_malloc (sizeof (struct HttpAddressWrapper));
- w->addr = http_common_address_from_socket (plugin->protocol, addr, addrlen);
- if (NULL == w->addr)
+ 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->addr);
+ w->addrlen = http_common_address_get_size (w->address);
GNUNET_CONTAINER_DLL_insert(plugin->addr_head, plugin->addr_tail, w);
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"Notifying transport to add address `%s'\n",
- http_common_plugin_address_to_string(NULL, w->addr, w->addrlen));
+ http_common_plugin_address_to_string (NULL, p->protocol, w->address, w->addrlen));
#if BUILD_HTTPS
- plugin->env->notify_address (plugin->env->cls, add_remove, w->addr, w->addrlen, "https_client");
+ plugin->env->notify_address (plugin->env->cls, add_remove, w->address, w->addrlen, "https_client");
#else
- plugin->env->notify_address (plugin->env->cls, add_remove, w->addr, w->addrlen, "http_client");
+ plugin->env->notify_address (plugin->env->cls, add_remove, w->address, w->addrlen, "http_client");
#endif
}
while (NULL != w)
{
- if (GNUNET_YES == http_common_cmp_addresses(w->addr, w->addrlen, saddr, saddr_len))
+ if (GNUNET_YES == http_common_cmp_addresses(w->address, w->addrlen, saddr, saddr_len))
break;
w = w->next;
}
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"Notifying transport to remove address `%s'\n",
- http_common_plugin_address_to_string (NULL, w->addr, w->addrlen));
+ http_common_plugin_address_to_string (NULL, p->protocol, w->address, w->addrlen));
GNUNET_CONTAINER_DLL_remove (plugin->addr_head, plugin->addr_tail, w);
#if BUILD_HTTPS
- plugin->env->notify_address (plugin->env->cls, add_remove, w->addr, w->addrlen, "https_client");
+ plugin->env->notify_address (plugin->env->cls, add_remove, w->address, w->addrlen, "https_client");
#else
- plugin->env->notify_address (plugin->env->cls, add_remove, w->addr, w->addrlen, "http_client");
+ plugin->env->notify_address (plugin->env->cls, add_remove, w->address, w->addrlen, "http_client");
#endif
- GNUNET_free (w->addr);
+ GNUNET_free (w->address);
GNUNET_free (w);
}
{
w = plugin->addr_head;
GNUNET_CONTAINER_DLL_remove (plugin->addr_head, plugin->addr_tail, w);
- GNUNET_free (w->addr);
+ GNUNET_free (w->address);
GNUNET_free (w);
}
}
/**
- * Function called when the service shuts down. Unloads our plugins
- * and cancels pending validations.
+ * Notify server about our external hostname
*
- * @param cls closure, unused
+ * @param cls plugin
* @param tc task context (unused)
*/
static void
server_notify_external_hostname (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct HTTP_Server_Plugin *plugin = 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(&plugin->ext_addr, "%s://%s", plugin->protocol, plugin->external_hostname);
- plugin->ext_addr_len = strlen (plugin->ext_addr) + 1;
+ GNUNET_asprintf(&url, "%s://%s", plugin->protocol, plugin->external_hostname);
+
+ urlen = strlen (url) + 1;
+ plugin->ext_addr = GNUNET_malloc (sizeof (struct HttpAddress) + urlen);
+ plugin->ext_addr->options = htonl(plugin->options);
+ plugin->ext_addr->urlen = htonl (urlen);
+ plugin->ext_addr_len = sizeof (struct HttpAddress) + urlen;
+ memcpy (&plugin->ext_addr[1], url, urlen);
+ GNUNET_free (url);
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
- "Notifying transport about external hostname address `%s'\n", plugin->ext_addr);
+ "Notifying transport about external hostname address `%s'\n", plugin->external_hostname);
#if BUILD_HTTPS
+ if (GNUNET_YES == plugin->verify_external_hostname)
+ GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, plugin->name,
+ "Enabling SSL verification for external hostname address `%s'\n", plugin->external_hostname);
plugin->env->notify_address (plugin->env->cls, GNUNET_YES,
plugin->ext_addr, plugin->ext_addr_len,
"https_client");
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->port = port;
- GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
+ GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, plugin->name,
_("Using port %u\n"), plugin->port);
if ((plugin->use_ipv4 == GNUNET_YES) &&
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", &plugin->external_hostname))
+ "EXTERNAL_HOSTNAME", &eh_tmp))
{
char * tmp = NULL;
- if (NULL != strstr(plugin->external_hostname, "://"))
+ char * pos = NULL;
+ char * pos_url = NULL;
+
+ if (NULL != strstr(eh_tmp, "://"))
{
- tmp = strdup(&strstr(plugin->external_hostname, "://")[3]);
- GNUNET_free (plugin->external_hostname);
- plugin->external_hostname = 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, (NULL == pos_url) ? "" : pos_url);
+ }
+ else
+ GNUNET_asprintf (&plugin->external_hostname, "%s:%u", tmp, (uint16_t) port);
}
- GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
+ else
+ plugin->external_hostname = GNUNET_strdup (tmp);
+ GNUNET_free (eh_tmp);
+
+ GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, plugin->name,
_("Using external hostname `%s'\n"), plugin->external_hostname);
plugin->notify_ext_task = GNUNET_SCHEDULER_add_now (&server_notify_external_hostname, plugin);
plugin->max_connections);
- plugin->peer_id_length = strlen (GNUNET_h2s_full (&plugin->env->my_identity->hashPubKey));
+ plugin->peer_id_length = strlen (GNUNET_i2s_full (plugin->env->my_identity));
return GNUNET_OK;
}
s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_log (TIMEOUT_LOG,
- "Session %p was idle for %llu ms, disconnecting\n",
- s, (unsigned long long) SERVER_SESSION_TIMEOUT.rel_value);
+ "Session %p was idle for %s, disconnecting\n",
+ s,
+ GNUNET_STRINGS_relative_time_to_string (SERVER_SESSION_TIMEOUT,
+ GNUNET_YES));
/* call session destroy function */
GNUNET_assert (GNUNET_OK == server_disconnect (s));
&server_session_timeout,
s);
GNUNET_log (TIMEOUT_LOG,
- "Timeout for session %p set to %llu ms\n",
- s, (unsigned long long) SERVER_SESSION_TIMEOUT.rel_value);
+ "Timeout for session %p set to %s\n",
+ s,
+ GNUNET_STRINGS_relative_time_to_string (SERVER_SESSION_TIMEOUT,
+ GNUNET_YES));
}
&server_session_timeout,
s);
GNUNET_log (TIMEOUT_LOG,
- "Timeout rescheduled for session %p set to %llu ms\n",
- s, (unsigned long long) SERVER_SESSION_TIMEOUT.rel_value);
+ "Timeout rescheduled for session %p set to %s\n",
+ s,
+ GNUNET_STRINGS_relative_time_to_string (SERVER_SESSION_TIMEOUT,
+ GNUNET_YES));
}
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"Notifying transport to remove address `%s'\n",
http_common_plugin_address_to_string (NULL,
+ p->protocol,
plugin->ext_addr,
plugin->ext_addr_len));
#if BUILD_HTTPS
return NULL;
}
+const char *http_plugin_address_to_string (void *cls,
+ const void *addr,
+ size_t addrlen)
+{
+#if BUILD_HTTPS
+ return http_common_plugin_address_to_string (cls, PLUGIN_NAME, addr, addrlen);
+#else
+ return http_common_plugin_address_to_string (cls, PLUGIN_NAME, addr, addrlen);
+#endif
+
+}
+
+
+/**
+ * Function obtain the network type for a session
+ *
+ * @param cls closure ('struct Plugin*')
+ * @param session the session
+ * @return the network type in HBO or GNUNET_SYSERR
+ */
+static enum GNUNET_ATS_Network_Type
+http_server_get_network (void *cls,
+ struct Session *session)
+{
+ GNUNET_assert (NULL != session);
+ return ntohl (session->ats_address_network_type);
+}
+
/**
* Entry point for the plugin.
initialze the plugin or the API */
api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
api->cls = NULL;
- api->address_to_string = &http_common_plugin_address_to_string;
+ api->address_to_string = &http_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;
api->check_address = &http_server_plugin_address_suggested;
api->get_session = &http_server_plugin_get_session;
- api->address_to_string = &http_common_plugin_address_to_string;
+ api->address_to_string = &http_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_get_network;
#if BUILD_HTTPS
plugin->name = "transport-https_server";
LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
return NULL;
}
-
return api;
}