#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;
+ struct HttpAddress *h_addr;
+ h_addr = (struct HttpAddress *) addr;
-
- if ((NULL != plugin->ext_addr) &&
+ if ((NULL != p->ext_addr) &&
GNUNET_YES == (http_common_cmp_addresses (addr, addrlen,
- plugin->ext_addr, plugin->ext_addr_len)))
- return GNUNET_OK;
+ p->ext_addr, p->ext_addr_len)))
+ {
+ /* Checking HTTP_OPTIONS_VERIFY_CERTIFICATE option for external hostname */
+ if ((ntohl(h_addr->options) & HTTP_OPTIONS_VERIFY_CERTIFICATE) !=
+ (p->options & HTTP_OPTIONS_VERIFY_CERTIFICATE))
+ return GNUNET_NO; /* VERIFY option not set as required! */
+ return GNUNET_OK;
+ }
- next = plugin->addr_head;
+ next = p->addr_head;
while (NULL != (pos = next))
{
next = pos->next;
if (GNUNET_YES == (http_common_cmp_addresses(addr,
addrlen,
- pos->addr,
+ pos->address,
pos->addrlen)))
return GNUNET_OK;
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);
}
static int
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 long int ctag;
/* URL parsing
* URL is valid if it is in the form [prefix with (multiple) '/'][peerid[103];tag]*/
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;
}
- (*tag) = strtoul (tag_start, &tag_end, 10);
- if ((*tag) == 0)
+ 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 (((*tag) == ULONG_MAX) && (ERANGE == errno))
+ 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_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);
if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((const char *) hash, &(target->hashPubKey)))
{
/* hash conversion failed */
- if (debug) GNUNET_break (0);
+ if (DEBUG_URL_PARSE) GNUNET_break (0);
return GNUNET_SYSERR;
}
const union MHD_ConnectionInfo *conn_info;
struct GNUNET_ATS_Information ats;
- char *addr;
+ struct HttpAddress *addr;
size_t addr_len;
struct GNUNET_PeerIdentity target;
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))
{
{
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,
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, plugin->name,
"Peer `%s' address `%s' next read delayed for %llu ms\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),
delay);
}
server_reschedule_session_timeout (s);
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;
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;
s, sc,
GNUNET_i2s (&s->target),
http_common_plugin_address_to_string (NULL,
+ p->protocol,
s->addr,
s->addrlen),
*upload_data_size);
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))
{
}
+#define UNSIGNED_MHD_LONG_LONG unsigned MHD_LONG_LONG
+
/**
* Function that queries MHD's select sets and
* starts the task waiting for them.
struct GNUNET_NETWORK_FDSet *wws;
struct GNUNET_NETWORK_FDSet *wes;
int max;
- unsigned MHD_LONG_LONG timeout;
+ UNSIGNED_MHD_LONG_LONG timeout;
static unsigned long long last_timeout = 0;
int haveto;
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);
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";