#include "microhttpd.h"
#include <curl/curl.h>
+#if BUILD_HTTPS
+#define LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_https_init
+#define LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_https_done
+#define LIBGNUNET_PLUGIN_TRANSPORT_COMPONENT transport_https
+#define PROTOCOL_PREFIX "https"
+#else
+#define LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_http_init
+#define LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_http_done
+#define LIBGNUNET_PLUGIN_TRANSPORT_COMPONENT transport_http
+#define PROTOCOL_PREFIX "http"
+#endif
+
#define DEBUG_HTTP GNUNET_NO
#define DEBUG_CURL GNUNET_NO
-#define DEBUG_MHD GNUNET_YES
+#define DEBUG_MHD GNUNET_NO
#define DEBUG_CONNECTIONS GNUNET_NO
#define DEBUG_SESSION_SELECTION GNUNET_NO
#define INBOUND GNUNET_NO
#define OUTBOUND GNUNET_YES
-#define PROTOCOL_PREFIX "http"
+
/**
* Text of the response sent back after the last bytes of a PUT
* Closure passed by MHD to the mhd_logger function
*/
void * mhd_log;
+
+ /* only needed for HTTPS plugin */
+#if BUILD_HTTPS
+ /* The certificate MHD uses as an \0 terminated string */
+ char * cert;
+
+ /* The private key MHD uses as an \0 terminated string */
+ char * key;
+
+ /* crypto init string */
+ char * crypto_init;
+#endif
};
/**
* Function setting up curl handle and selecting message to send
- * @param cls plugin
+ * @param plugin plugin
* @param ses session to send data to
* @param con connection
* @return bytes sent to peer
*/
-static ssize_t send_check_connections (void *cls, struct Session *ps);
+static int send_check_connections (struct Plugin *plugin, struct Session *ps);
/**
* Function setting up file descriptors and scheduling task to run
* @param ses session to send data to
* @param
*/
-static int curl_schedule(void *cls );
+static int curl_schedule (struct Plugin *plugin);
/**
* Creates a valid url from passed address and id
- * @param cls plugin as closure
+ * @param plugin plugin
* @param addr address to create url from
* @param addrlen address lenth
* @param id session id
* @return the created url
*/
-static char * create_url(void * cls, const void * addr, size_t addrlen, size_t id)
+static char * create_url(struct Plugin *plugin, const void * addr, size_t addrlen, size_t id)
{
- struct Plugin *plugin = cls;
char *url = NULL;
char *addr_str = (char *) http_plugin_address_to_string(NULL, addr, addrlen);
{
if (0 == memcmp(&plugin->bind4_address->sin_addr, &bnd_cmp, sizeof (struct in_addr)))
{
- plugin->env->notify_address(plugin->env->cls,"http",t4, sizeof (struct IPv4HttpAddress), GNUNET_TIME_UNIT_FOREVER_REL);
+ plugin->env->notify_address(plugin->env->cls,PROTOCOL_PREFIX,t4, sizeof (struct IPv4HttpAddress), GNUNET_TIME_UNIT_FOREVER_REL);
}
}
else
{
- plugin->env->notify_address(plugin->env->cls,"http",t4, sizeof (struct IPv4HttpAddress), GNUNET_TIME_UNIT_FOREVER_REL);
+ plugin->env->notify_address(plugin->env->cls,PROTOCOL_PREFIX,t4, sizeof (struct IPv4HttpAddress), GNUNET_TIME_UNIT_FOREVER_REL);
}
GNUNET_free (t4);
}
&((struct sockaddr_in6 *) addr)->sin6_addr,
sizeof (struct in6_addr));
t6->u6_port = htons (plugin->port_inbound);
- plugin->env->notify_address(plugin->env->cls,"http",t6,sizeof (struct IPv6HttpAddress) , GNUNET_TIME_UNIT_FOREVER_REL);
+ plugin->env->notify_address(plugin->env->cls,PROTOCOL_PREFIX,t6,sizeof (struct IPv6HttpAddress) , GNUNET_TIME_UNIT_FOREVER_REL);
}
}
else
&((struct sockaddr_in6 *) addr)->sin6_addr,
sizeof (struct in6_addr));
t6->u6_port = htons (plugin->port_inbound);
- plugin->env->notify_address(plugin->env->cls,"http",t6,sizeof (struct IPv6HttpAddress) , GNUNET_TIME_UNIT_FOREVER_REL);
+ plugin->env->notify_address(plugin->env->cls,PROTOCOL_PREFIX,t6,sizeof (struct IPv6HttpAddress) , GNUNET_TIME_UNIT_FOREVER_REL);
}
GNUNET_free (t6);
}
*
*/
static int
-mhd_accept_cb (void *cls,
- const struct sockaddr *addr, socklen_t addr_len)
+mhd_accept_cb (void *cls, const struct sockaddr *addr, socklen_t addr_len)
{
#if 0
struct Plugin *plugin = cls;
*/
int mhd_send_callback (void *cls, uint64_t pos, char *buf, int max)
{
- int bytes_read = 0;
struct Session * ps = cls;
struct HTTP_PeerContext * pc;
struct HTTP_Message * msg;
+ int bytes_read = 0;
+
GNUNET_assert (ps!=NULL);
+
pc = ps->peercontext;
msg = ps->pending_msgs_tail;
if (ps->send_force_disconnect==GNUNET_YES)
*/
static int
mdh_access_cb (void *cls,
- struct MHD_Connection *mhd_connection,
- const char *url,
- const char *method,
- const char *version,
- const char *upload_data,
- size_t * upload_data_size, void **httpSessionCache)
+ struct MHD_Connection *mhd_connection,
+ const char *url,
+ const char *method,
+ const char *version,
+ const char *upload_data,
+ size_t * upload_data_size, void **httpSessionCache)
{
struct Plugin *plugin = cls;
struct MHD_Response *response;
/**
* Function that queries MHD's select sets and
* starts the task waiting for them.
- * @param cls plugin as closure
+ * @param plugin plugin
* @param daemon_handle the MHD daemon handle
* @return gnunet task identifier
*/
static GNUNET_SCHEDULER_TaskIdentifier
-http_server_daemon_prepare (void * cls, struct MHD_Daemon *daemon_handle)
+http_server_daemon_prepare (struct Plugin *plugin , struct MHD_Daemon *daemon_handle)
{
- struct Plugin *plugin = cls;
GNUNET_SCHEDULER_TaskIdentifier ret;
fd_set rs;
fd_set ws;
int haveto;
struct GNUNET_TIME_Relative tv;
- GNUNET_assert(cls !=NULL);
ret = GNUNET_SCHEDULER_NO_TASK;
FD_ZERO(&rs);
FD_ZERO(&ws);
GNUNET_assert (MHD_YES == MHD_run (plugin->http_server_daemon_v4));
plugin->http_server_task_v4 = http_server_daemon_prepare (plugin, plugin->http_server_daemon_v4);
- return;
-}
+ }
/**
GNUNET_assert (MHD_YES == MHD_run (plugin->http_server_daemon_v6));
plugin->http_server_task_v6 = http_server_daemon_prepare (plugin, plugin->http_server_daemon_v6);
- return;
}
static size_t curl_get_header_cb( void *ptr, size_t size, size_t nmemb, void *stream)
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: Header: %s\n",ps,tmp);
}
- if (NULL != tmp)
- GNUNET_free (tmp);
+ GNUNET_free_non_null (tmp);
#endif
return size * nmemb;
tmp[len-2]= '\0';
}
}
- if (NULL != tmp)
- GNUNET_free (tmp);
+
+ GNUNET_free_non_null (tmp);
return size * nmemb;
}
size_t len;
if (ps->send_active == GNUNET_NO)
+ {
return CURL_READFUNC_PAUSE;
+ }
if ((ps->pending_msgs_tail == NULL) && (ps->send_active == GNUNET_YES))
{
plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
return;
-
do
{
running = 0;
* @param cls plugin as closure
* @return GNUNET_SYSERR for hard failure, GNUNET_OK for ok
*/
-static int curl_schedule(void *cls)
+static int curl_schedule(struct Plugin *plugin)
{
- struct Plugin *plugin = cls;
fd_set rs;
fd_set ws;
fd_set es;
long to;
CURLMcode mret;
- GNUNET_assert(cls !=NULL);
-
/* Cancel previous scheduled task */
if (plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_curl_task);
plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
}
+
max = -1;
FD_ZERO (&rs);
FD_ZERO (&ws);
plugin->http_curl_task = GNUNET_SCHEDULER_add_select (plugin->env->sched,
GNUNET_SCHEDULER_PRIORITY_DEFAULT,
GNUNET_SCHEDULER_NO_TASK,
- GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 0),
+ (to == -1) ? GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) : GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, to),
grs,
gws,
&curl_perform,
return GNUNET_OK;
}
+/**
+ * Function to log curl debug messages with GNUNET_log
+ * @param curl handle
+ * @param type curl_infotype
+ * @param data data
+ * @param size size
+ * @param cls closure
+ * @return 0
+ */
+int curl_logger (CURL * curl, curl_infotype type , char * data, size_t size , void * cls)
+{
+ char * text = GNUNET_malloc(size+2);
+ if (type == CURLINFO_TEXT)
+ {
+ memcpy(text,data,size);
+ if (text[size-1] == '\n')
+ text[size] = '\0';
+ else
+ {
+ text[size] = '\n';
+ text[size+1] = '\0';
+ }
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"CURL: Connection %X - %s", cls, text);
+ GNUNET_free(text);
+ }
+ return 0;
+}
+
/**
* Function setting up curl handle and selecting message to send
*
- * @param cls plugin
+ * @param plugin plugin
* @param ps session
* @return GNUNET_SYSERR on failure, GNUNET_NO if connecting, GNUNET_YES if ok
*/
-static ssize_t send_check_connections (void *cls, struct Session *ps)
+static int send_check_connections (struct Plugin *plugin, struct Session *ps)
{
- struct Plugin *plugin = cls;
CURLMcode mret;
struct HTTP_Message * msg;
struct GNUNET_TIME_Relative timeout = GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT;
- GNUNET_assert(cls !=NULL);
-
if (ps->direction == OUTBOUND)
{
/* RECV DIRECTION */
}
#if DEBUG_CURL
curl_easy_setopt(ps->recv_endpoint, CURLOPT_VERBOSE, 1L);
+ curl_easy_setopt(ps->recv_endpoint, CURLOPT_DEBUGFUNCTION , &curl_logger);
+ curl_easy_setopt(ps->recv_endpoint, CURLOPT_DEBUGDATA , ps->recv_endpoint);
+#endif
+#if BUILD_HTTPS
+ curl_easy_setopt (ps->recv_endpoint, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
+ curl_easy_setopt(ps->recv_endpoint, CURLOPT_SSL_VERIFYPEER, 0);
+ curl_easy_setopt(ps->recv_endpoint, CURLOPT_SSL_VERIFYHOST, 0);
#endif
curl_easy_setopt(ps->recv_endpoint, CURLOPT_URL, ps->url);
curl_easy_setopt(ps->recv_endpoint, CURLOPT_HEADERFUNCTION, &curl_get_header_cb);
return GNUNET_SYSERR;
}
}
- if (curl_schedule (plugin) == GNUNET_SYSERR)
- {
-#if DEBUG_CONNECTIONS
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: could not schedule curl task\n",ps);
-#endif
- return GNUNET_SYSERR;
- }
-#if DEBUG_CONNECTIONS
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: inbound not connected, initiating connection\n",ps);
-#endif
+ if (plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
+ {
+ GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_curl_task);
+ plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
+ }
+ plugin->http_curl_task = GNUNET_SCHEDULER_add_now (plugin->env->sched, &curl_perform, plugin);
}
/* waiting for receive direction */
if (CURLE_OK == curl_easy_pause(ps->send_endpoint,CURLPAUSE_CONT))
{
ps->send_active=GNUNET_YES;
+ if (plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
+ {
+ GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_curl_task);
+ plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
+ }
+ plugin->http_curl_task = GNUNET_SCHEDULER_add_now (plugin->env->sched, &curl_perform, plugin);
return GNUNET_YES;
}
else
#if DEBUG_CURL
curl_easy_setopt(ps->send_endpoint, CURLOPT_VERBOSE, 1L);
+ curl_easy_setopt(ps->send_endpoint, CURLOPT_DEBUGFUNCTION , &curl_logger);
+ curl_easy_setopt(ps->send_endpoint, CURLOPT_DEBUGDATA , ps->send_endpoint);
+#endif
+#if BUILD_HTTPS
+ curl_easy_setopt (ps->send_endpoint, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
+ curl_easy_setopt(ps->send_endpoint, CURLOPT_SSL_VERIFYPEER, 0);
+ curl_easy_setopt(ps->send_endpoint, CURLOPT_SSL_VERIFYHOST, 0);
#endif
curl_easy_setopt(ps->send_endpoint, CURLOPT_URL, ps->url);
curl_easy_setopt(ps->send_endpoint, CURLOPT_PUT, 1L);
}
}
}
- if (curl_schedule (plugin) == GNUNET_SYSERR)
- return GNUNET_SYSERR;
+ if (plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
+ {
+ GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_curl_task);
+ plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
+ }
+ plugin->http_curl_task = GNUNET_SCHEDULER_add_now (plugin->env->sched, &curl_perform, plugin);
return GNUNET_YES;
}
if (ps->direction == INBOUND)
* @return selected session
*
*/
-static struct Session * send_select_session (void * cls, struct HTTP_PeerContext *pc, const void * addr, size_t addrlen, int force_address, struct Session * session)
+static struct Session * send_select_session (struct HTTP_PeerContext *pc, const void * addr, size_t addrlen, int force_address, struct Session * session)
{
struct Session * tmp = NULL;
int addr_given = GNUNET_NO;
GNUNET_NO);
}
- ps = send_select_session (plugin, pc, addr, addrlen, force_address, session);
+ ps = send_select_session (pc, addr, addrlen, force_address, session);
/* session not existing, but address forced -> creating new session */
if (ps==NULL)
{
- if ((addr!=NULL) && (addrlen!=0))
- {
+ if ((addr!=NULL) && (addrlen!=0))
+ {
ps = GNUNET_malloc(sizeof (struct Session));
#if DEBUG_SESSION_SELECTION
if (force_address == GNUNET_YES)
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"No existing connection & forced address: creating new session %X to peer %s\n", ps, GNUNET_i2s(target));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"No existing connection & forced address: creating new session %X to peer %s\n", ps, GNUNET_i2s(target));
if (force_address != GNUNET_YES)
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"No existing connection: creating new session %X to peer %s\n", ps, GNUNET_i2s(target));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"No existing connection: creating new session %X to peer %s\n", ps, GNUNET_i2s(target));
#endif
if ((addrlen!=0) && (addr!=NULL))
{
- ps->addr = GNUNET_malloc(addrlen);
- memcpy(ps->addr,addr,addrlen);
- ps->addrlen = addrlen;
- }
- else
- {
- ps->addr = NULL;
- ps->addrlen = 0;
+ ps->addr = GNUNET_malloc(addrlen);
+ memcpy(ps->addr,addr,addrlen);
+ ps->addrlen = addrlen;
}
- ps->direction=OUTBOUND;
- ps->recv_connected = GNUNET_NO;
- ps->recv_force_disconnect = GNUNET_NO;
- ps->send_connected = GNUNET_NO;
- ps->send_force_disconnect = GNUNET_NO;
- ps->pending_msgs_head = NULL;
- ps->pending_msgs_tail = NULL;
- ps->peercontext=pc;
- ps->session_id = pc->session_id_counter;
- pc->session_id_counter++;
- ps->url = create_url (plugin, ps->addr, ps->addrlen, ps->session_id);
- if (ps->msgtok == NULL)
- ps->msgtok = GNUNET_SERVER_mst_create (&curl_receive_mst_cb, ps);
- GNUNET_CONTAINER_DLL_insert(pc->head,pc->tail,ps);
-/* FIXME */
-
- GNUNET_STATISTICS_update (plugin->env->stats,
- gettext_noop ("# HTTP outbound sessions for peers active"),
- 1,
- GNUNET_NO);
- }
- else
- {
+ else
+ {
+ ps->addr = NULL;
+ ps->addrlen = 0;
+ }
+ ps->direction=OUTBOUND;
+ ps->recv_connected = GNUNET_NO;
+ ps->recv_force_disconnect = GNUNET_NO;
+ ps->send_connected = GNUNET_NO;
+ ps->send_force_disconnect = GNUNET_NO;
+ ps->pending_msgs_head = NULL;
+ ps->pending_msgs_tail = NULL;
+ ps->peercontext=pc;
+ ps->session_id = pc->session_id_counter;
+ pc->session_id_counter++;
+ ps->url = create_url (plugin, ps->addr, ps->addrlen, ps->session_id);
+ if (ps->msgtok == NULL)
+ ps->msgtok = GNUNET_SERVER_mst_create (&curl_receive_mst_cb, ps);
+ GNUNET_CONTAINER_DLL_insert(pc->head,pc->tail,ps);
+ GNUNET_STATISTICS_update (plugin->env->stats,
+ gettext_noop ("# HTTP outbound sessions for peers active"),
+ 1,
+ GNUNET_NO);
+ }
+ else
+ {
#if DEBUG_HTTP
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"No existing session found & and no address given: no way to send this message to peer `%s'!\n", GNUNET_i2s(target));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"No existing session found & and no address given: no way to send this message to peer `%s'!\n", GNUNET_i2s(target));
#endif
- return GNUNET_SYSERR;
+ return GNUNET_SYSERR;
}
}
memcpy (msg->buf,msgbuf, msgbuf_size);
GNUNET_CONTAINER_DLL_insert(ps->pending_msgs_head,ps->pending_msgs_tail,msg);
- if (send_check_connections (plugin, ps) != GNUNET_SYSERR)
- {
+ if (send_check_connections (plugin, ps) == GNUNET_SYSERR)
+ return GNUNET_SYSERR;
if (force_address != GNUNET_YES)
pc->last_session = ps;
if (pc->last_session==NULL)
pc->last_session = ps;
return msg->size;
- }
- else
- return GNUNET_SYSERR;
}
* Exit point from the plugin.
*/
void *
-libgnunet_plugin_transport_http_done (void *cls)
+LIBGNUNET_PLUGIN_TRANSPORT_DONE (void *cls)
{
struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
struct Plugin *plugin = api->cls;
plugin->http_server_task_v6 = GNUNET_SCHEDULER_NO_TASK;
}
-
/* free all peer information */
if (plugin->peers!=NULL)
{
GNUNET_free_non_null (plugin->bind4_address);
GNUNET_free_non_null (plugin->bind6_address);
GNUNET_free_non_null(plugin->bind_hostname);
+#if BUILD_HTTPS
+ GNUNET_free_non_null (plugin->crypto_init);
+ GNUNET_free_non_null (plugin->cert);
+ GNUNET_free_non_null (plugin->key);
+#endif
GNUNET_free (plugin);
GNUNET_free (api);
#if DEBUG_HTTP
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Unload http plugin complete...\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Unload %s plugin complete...\n", PROTOCOL_PREFIX);
#endif
return NULL;
}
+#if BUILD_HTTPS
+static char *
+load_certificate( const char * file )
+{
+ struct GNUNET_DISK_FileHandle * gn_file;
+
+ struct stat fstat;
+ char * text = NULL;
+
+ if (0!=STAT(file, &fstat))
+ return NULL;
+ text = GNUNET_malloc (fstat.st_size+1);
+ gn_file = GNUNET_DISK_file_open(file,GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_USER_READ);
+ if (gn_file==NULL)
+ {
+ GNUNET_free(text);
+ return NULL;
+ }
+ if (GNUNET_SYSERR == GNUNET_DISK_file_read(gn_file, text, fstat.st_size))
+ {
+ GNUNET_free(text);
+ GNUNET_DISK_file_close(gn_file);
+ return NULL;
+ }
+ text[fstat.st_size] = '\0';
+ GNUNET_DISK_file_close(gn_file);
+
+ return text;
+}
+#endif
+
/**
* Entry point for the plugin.
*/
void *
-libgnunet_plugin_transport_http_init (void *cls)
+LIBGNUNET_PLUGIN_TRANSPORT_INIT (void *cls)
{
struct GNUNET_TRANSPORT_PluginEnvironment *env = cls;
struct Plugin *plugin;
struct GNUNET_TRANSPORT_PluginFunctions *api;
struct GNUNET_TIME_Relative gn_timeout;
long long unsigned int port;
+ char * component_name;
+#if BUILD_HTTPS
+ char * key_file = NULL;
+ char * cert_file = NULL;
+#endif
GNUNET_assert(cls !=NULL);
#if DEBUG_HTTP
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Starting http plugin...\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Starting %s plugin...\n", PROTOCOL_PREFIX);
#endif
+ GNUNET_asprintf(&component_name,"transport-%s",PROTOCOL_PREFIX);
plugin = GNUNET_malloc (sizeof (struct Plugin));
plugin->stats = env->stats;
/* Hashing our identity to use it in URLs */
GNUNET_CRYPTO_hash_to_enc ( &(plugin->env->my_identity->hashPubKey), &plugin->my_ascii_hash_ident);
- /* Reading port number from config file */
+ /* Use IPv6? */
if (GNUNET_CONFIGURATION_have_value (env->cfg,
- "transport-http", "USE_IPv6"))
+ component_name, "USE_IPv6"))
{
plugin->use_ipv6 = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
- "transport-http",
- "USE_IPv6");
+ component_name,
+ "USE_IPv6");
}
- /* Reading port number from config file */
+ /* Use IPv4? */
if (GNUNET_CONFIGURATION_have_value (env->cfg,
- "transport-http", "USE_IPv4"))
+ component_name, "USE_IPv4"))
{
plugin->use_ipv4 = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
- "transport-http",
- "USE_IPv4");
+ component_name,"USE_IPv4");
}
/* Reading port number from config file */
if ((GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (env->cfg,
- "transport-http",
+ component_name,
"PORT",
&port)) ||
(port > 65535) )
{
GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
- "http",
+ component_name,
_("Require valid port number for transport plugin `%s' in configuration!\n"),
- "transport-http");
- libgnunet_plugin_transport_http_done (api);
+ PROTOCOL_PREFIX);
+ GNUNET_free(component_name);
+ LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
return NULL;
}
/* Reading ipv4 addresse to bind to from config file */
if ((plugin->use_ipv4==GNUNET_YES) && (GNUNET_CONFIGURATION_have_value (env->cfg,
- "transport-http", "BINDTO4")))
+ component_name, "BINDTO4")))
{
GNUNET_break (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_string (env->cfg,
- "transport-http",
+ component_name,
"BINDTO4",
&plugin->bind_hostname));
plugin->bind4_address = GNUNET_malloc(sizeof(struct sockaddr_in));
if (inet_pton(AF_INET,plugin->bind_hostname, &plugin->bind4_address->sin_addr)<=0)
{
GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
- "http",
- _("Misconfigured address to bind to in configuration!\n"),
- "transport-http");
+ component_name,
+ _("Misconfigured address to bind to in configuration!\n"));
GNUNET_free(plugin->bind4_address);
GNUNET_free(plugin->bind_hostname);
plugin->bind_hostname = NULL;
/* Reading ipv4 addresse to bind to from config file */
if ((plugin->use_ipv6==GNUNET_YES) && (GNUNET_CONFIGURATION_have_value (env->cfg,
- "transport-http", "BINDTO6")))
+ component_name, "BINDTO6")))
{
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (env->cfg,
- "transport-http",
- "BINDTO6",
- &plugin->bind_hostname))
+ component_name,
+ "BINDTO6",
+ &plugin->bind_hostname))
{
plugin->bind6_address = GNUNET_malloc(sizeof(struct sockaddr_in6));
plugin->bind6_address->sin6_family = AF_INET6;
if (inet_pton(AF_INET6,plugin->bind_hostname, &plugin->bind6_address->sin6_addr)<=0)
{
GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
- "http",
- _("Misconfigured address to bind to in configuration!\n"),
- "transport-http");
+ component_name,
+ _("Misconfigured address to bind to in configuration!\n"));
GNUNET_free(plugin->bind6_address);
GNUNET_free(plugin->bind_hostname);
plugin->bind_hostname = NULL;
}
}
+#if BUILD_HTTPS
+ /* Reading HTTPS crypto related configuration */
+ /* Get crypto init string from config */
+ if (GNUNET_CONFIGURATION_have_value (env->cfg,
+ "transport-https", "CRYPTO_INIT"))
+ {
+ GNUNET_CONFIGURATION_get_value_string (env->cfg,
+ "transport-https",
+ "CRYPTO_INIT",
+ &plugin->crypto_init);
+ }
+ else
+ {
+ GNUNET_asprintf(&plugin->crypto_init,"NORMAL");
+ }
+
+/* Get private key file from config */
+ if (GNUNET_CONFIGURATION_have_value (env->cfg,
+ "transport-https", "KEY_FILE"))
+ {
+ GNUNET_CONFIGURATION_get_value_string (env->cfg,
+ "transport-https",
+ "KEY_FILE",
+ &key_file);
+ }
+ if (key_file==NULL)
+ GNUNET_asprintf(&key_file,"https.key");
+
+/* Get private key file from config */
+ if (GNUNET_CONFIGURATION_have_value (env->cfg,"transport-https", "CERT_FILE"))
+ {
+ GNUNET_CONFIGURATION_get_value_string (env->cfg,
+ "transport-https",
+ "CERT_FILE",
+ &cert_file);
+ }
+ if (cert_file==NULL)
+ GNUNET_asprintf(&cert_file,"https.cert");
+
+ /* read key & certificates from file */
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Loading TLS certificate `%s' `%s'\n", key_file, cert_file);
+
+ plugin->key = load_certificate( key_file );
+ plugin->cert = load_certificate( cert_file );
+
+ if ((plugin->key==NULL) || (plugin->cert==NULL))
+ {
+ char * cmd;
+ int ret = 0;
+ GNUNET_asprintf(&cmd,"gnunet-transport-certificate-creation %s %s", key_file, cert_file);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No usable TLS certificate found, creating certificate \n");
+ ret = system(cmd);
+
+ if (ret != 0)
+ {
+ GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+ "https",
+ _("Could not create a new TLS certificate, shell script `%s' failed!\n"),cmd,
+ "transport-https");
+ GNUNET_free (key_file);
+ GNUNET_free (cert_file);
+ GNUNET_free (component_name);
+
+ LIBGNUNET_PLUGIN_TRANSPORT_DONE(api);
+ GNUNET_free (cmd);
+ return NULL;
+ }
+
+ GNUNET_free (cmd);
+
+ plugin->key = load_certificate( key_file );
+ plugin->cert = load_certificate( cert_file );
+
+ if ((plugin->key==NULL) || (plugin->cert==NULL))
+ {
+ GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
+ "https",
+ _("No usable TLS certificate found and creating one failed! \n"),
+ "transport-https");
+ GNUNET_free (key_file);
+ GNUNET_free (cert_file);
+ GNUNET_free (component_name);
+
+ LIBGNUNET_PLUGIN_TRANSPORT_DONE(api);
+ return NULL;
+ }
+ }
+ GNUNET_free (key_file);
+ GNUNET_free (cert_file);
+
+ GNUNET_assert((plugin->key!=NULL) && (plugin->cert!=NULL));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "TLS certificate loaded\n");
+#endif
+
GNUNET_assert ((port > 0) && (port <= 65535));
plugin->port_inbound = port;
gn_timeout = GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT;
plugin->http_server_daemon_v6 = MHD_start_daemon (
#if DEBUG_MHD
MHD_USE_DEBUG |
+#endif
+#if BUILD_HTTPS
+ MHD_USE_SSL |
#endif
MHD_USE_IPv6,
port,
MHD_OPTION_SOCK_ADDR, tmp,
MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 32,
//MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) 6,
+#if BUILD_HTTPS
+ MHD_OPTION_HTTPS_PRIORITIES, plugin->crypto_init,
+ MHD_OPTION_HTTPS_MEM_KEY, plugin->key,
+ MHD_OPTION_HTTPS_MEM_CERT, plugin->cert,
+#endif
MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) timeout,
MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (2 * GNUNET_SERVER_MAX_MESSAGE_SIZE),
MHD_OPTION_NOTIFY_COMPLETED, &mhd_termination_cb, NULL,
plugin->http_server_daemon_v4 = MHD_start_daemon (
#if DEBUG_MHD
MHD_USE_DEBUG |
+#endif
+#if BUILD_HTTPS
+ MHD_USE_SSL |
#endif
MHD_NO_FLAG,
port,
MHD_OPTION_SOCK_ADDR, (struct sockaddr_in *)plugin->bind4_address,
MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 32,
//MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) 6,
+#if BUILD_HTTPS
+ MHD_OPTION_HTTPS_PRIORITIES, plugin->crypto_init,
+ MHD_OPTION_HTTPS_MEM_KEY, plugin->key,
+ MHD_OPTION_HTTPS_MEM_CERT, plugin->cert,
+#endif
MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) timeout,
MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (2 * GNUNET_SERVER_MAX_MESSAGE_SIZE),
MHD_OPTION_NOTIFY_COMPLETED, &mhd_termination_cb, NULL,
GNUNET_asprintf(&tmp,"with IPv6 enabled");
if ((plugin->use_ipv6 == GNUNET_NO) && (plugin->use_ipv4 == GNUNET_NO))
GNUNET_asprintf(&tmp,"with NO IP PROTOCOL enabled");
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,"HTTP Server with %s could not be started on port %u! https plugin failed!\n",tmp, port);
- GNUNET_free(tmp);
- libgnunet_plugin_transport_http_done (api);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,"HTTP Server with %s could not be started on port %u! %s plugin failed!\n",tmp, port, PROTOCOL_PREFIX);
+ GNUNET_free (tmp);
+ GNUNET_free (component_name);
+ LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
return NULL;
}
if ( NULL == plugin->multi_handle )
{
GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
- "https",
- _("Could not initialize curl multi handle, failed to start http plugin!\n"),
- "transport-https");
- libgnunet_plugin_transport_http_done (api);
+ component_name,
+ _("Could not initialize curl multi handle, failed to start %s plugin!\n"),
+ PROTOCOL_PREFIX);
+ GNUNET_free(component_name);
+ LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
return NULL;
}
plugin->peers = GNUNET_CONTAINER_multihashmap_create (10);
GNUNET_OS_network_interfaces_list (&process_interfaces, plugin);
+ GNUNET_free(component_name);
return api;
}
projects / oweals / gnunet.git / blobdiff