Discard large metadata items first
[oweals/gnunet.git] / src / gns / gnunet-gns-proxy.c
index e544a786771db6f4677e96affcf82d36d8339760..7b783787b7586967d616dace262be000140f9a13 100644 (file)
      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      Boston, MA 02111-1307, USA.
 */
-
+/**
+ * @author Martin Schanzenbach
+ * @file src/gns/gnunet-gns-proxy.c
+ * @brief HTTP(S) proxy that rewrites URIs and fakes certificats to make GADS work
+ *        with legacy browsers
+ */
 #include "platform.h"
-#include <gnunet_util_lib.h>
-#include <gnunet_gns_service.h>
 #include <microhttpd.h>
 #include <curl/curl.h>
-#include <regex.h>
-#include "gns_proxy_proto.h"
-#include "gns.h"
-
-/** SSL **/
 #include <gnutls/gnutls.h>
 #include <gnutls/x509.h>
 #include <gnutls/abstract.h>
 #include <gnutls/crypto.h>
-#include <time.h>
+#include <regex.h>
+#include "gnunet_util_lib.h"
+#include "gnunet_gns_service.h"
+#include "gns_proxy_proto.h"
+#include "gns.h"
+
+#define HAVE_MHD_NO_LISTEN_SOCKET (MHD_VERSION >= 0x00091401)
 
 #define GNUNET_GNS_PROXY_PORT 7777
 #define MHD_MAX_CONNECTIONS 300
+#define MAX_HTTP_URI_LENGTH 2048
+#define POSTBUFFERSIZE 4096
 
 /* MHD/cURL defines */
-#define BUF_WAIT_FOR_CURL 0
-#define BUF_WAIT_FOR_MHD 1
-#define BUF_WAIT_FOR_PP 2
+enum BufferStatus
+  {
+    BUF_WAIT_FOR_CURL,
+    BUF_WAIT_FOR_MHD,
+    BUF_WAIT_FOR_PP 
+  };
+
 #define HTML_HDR_CONTENT "Content-Type: text/html"
 
 /* buffer padding for proper RE matching */
@@ -200,7 +210,7 @@ struct ProxyCurlTask
   long curl_response_code;
 
   /* The URL to fetch */
-  char url[2048];
+  char url[MAX_HTTP_URI_LENGTH];
 
   /* The cURL write buffer / MHD read buffer */
   char buffer[CURL_MAX_WRITE_SIZE + CURL_BUF_PADDING];
@@ -211,29 +221,29 @@ struct ProxyCurlTask
   /* Write pos in the buffer */
   char *buffer_write_ptr;
 
-  /* The buffer status (BUF_WAIT_FOR_CURL or BUF_WAIT_FOR_MHD) */
-  int buf_status;
+  /* connection */
+  struct MHD_Connection *connection;
 
-  /* Number of bytes in buffer */
-  unsigned int bytes_in_buffer;
+  /*put*/
+  size_t put_read_offset;
+  size_t put_read_size;
 
-  /* Indicates wheather the download is in progress */
-  int download_in_progress;
+  /*post*/
+  struct MHD_PostProcessor *post_handler;
 
-  /* Indicates wheather the download was successful */
-  int download_is_finished;
+  /* post data */
+  struct ProxyUploadData *upload_data_head;
+  struct ProxyUploadData *upload_data_tail;
 
-  /* Indicates wheather the download failed */
-  int download_error;
+  /* the type of POST encoding */
+  char* post_type;
 
-  /* Indicates wheather we need to parse HTML */
-  int parse_content;
+  struct curl_httppost *httppost;
 
-  /* Indicates wheather we are postprocessing the HTML right now */
-  int is_postprocessing;
+  struct curl_httppost *httppost_last;
 
-  /* Indicates wheather postprocessing has finished */
-  int pp_finished;
+  /* Number of bytes in buffer */
+  unsigned int bytes_in_buffer;
 
   /* PP task */
   GNUNET_SCHEDULER_TaskIdentifier pp_task;
@@ -244,15 +254,6 @@ struct ProxyCurlTask
   /* PP match list */
   struct ProxyREMatch *pp_match_tail;
 
-  /* The authority of the corresponding host (site of origin) */
-  char authority[256];
-
-  /* The hostname (Host header field) */
-  char host[256];
-
-  /* The LEgacy HOstname (can be empty) */
-  char leho[256];
-
   /* The associated daemon list entry */
   struct MhdHttpList *mhd;
 
@@ -265,14 +266,54 @@ struct ProxyCurlTask
   /* Cookies to set */
   struct ProxySetCookieHeader *set_cookies_tail;
 
+  /* The authority of the corresponding host (site of origin) */
+  char authority[256];
+
+  /* The hostname (Host header field) */
+  char host[256];
+
+  /* The LEgacy HOstname (can be empty) */
+  char leho[256];
+
+  /* The port */
+  uint16_t port;
+
+  /* The buffer status (BUF_WAIT_FOR_CURL or BUF_WAIT_FOR_MHD) */
+  enum BufferStatus buf_status;
+
   /* connection status */
   int ready_to_queue;
+
+  /* is curl running? */
+  int curl_running;
   
   /* are we done */
   int fin;
 
-  /* connection */
-  struct MHD_Connection *connection;
+  /* Already accepted */
+  int accepted;
+
+  /* Indicates wheather the download is in progress */
+  int download_in_progress;
+
+  /* Indicates wheather the download was successful */
+  int download_is_finished;
+
+  /* Indicates wheather the download failed */
+  int download_error;
+
+  /* Indicates wheather we need to parse HTML */
+  int parse_content;
+
+  /* Indicates wheather we are postprocessing the HTML right now */
+  int is_postprocessing;
+
+  /* Indicates wheather postprocessing has finished */
+  int pp_finished;
+
+  int post_done;
+
+  int is_httppost;
   
 };
 
@@ -287,6 +328,15 @@ struct ProxyREMatch
   /* DLL */
   struct ProxyREMatch *prev;
 
+  /* start of match in buffer */
+  char* start;
+
+  /* end of match in buffer */
+  char* end;
+
+  /* associated proxycurltask */
+  struct ProxyCurlTask *ctask;
+
   /* hostname found */
   char hostname[255];
 
@@ -299,14 +349,9 @@ struct ProxyREMatch
   /* are we done */
   int done;
 
-  /* start of match in buffer */
-  char* start;
-
-  /* end of match in buffer */
-  char* end;
+  /* is SSL */
+  int is_ssl;
 
-  /* associated proxycurltask */
-  struct ProxyCurlTask *ctask;
 };
 
 /**
@@ -324,6 +369,36 @@ struct ProxySetCookieHeader
   char *cookie;
 };
 
+/**
+ * Post data structure
+ */
+struct ProxyUploadData
+{
+  /* DLL */
+  struct ProxyUploadData *next;
+
+  /* DLL */
+  struct ProxyUploadData *prev;
+
+  char *key;
+
+  char *filename;
+
+  char *content_type;
+
+  size_t content_length;
+  
+  /* value */
+  char *value;
+
+  /* to copy */
+  size_t bytes_left;
+
+  /* size */
+  size_t total_bytes;
+};
+
+
 /* The port the proxy is running on (default 7777) */
 static unsigned long port = GNUNET_GNS_PROXY_PORT;
 
@@ -334,10 +409,10 @@ static char* cafile_opt;
 static struct GNUNET_NETWORK_Handle *lsock;
 
 /* The listen task ID */
-GNUNET_SCHEDULER_TaskIdentifier ltask;
+static GNUNET_SCHEDULER_TaskIdentifier ltask;
 
 /* The cURL download task */
-GNUNET_SCHEDULER_TaskIdentifier curl_download_task;
+static GNUNET_SCHEDULER_TaskIdentifier curl_download_task;
 
 /* The non SSL httpd daemon handle */
 static struct MHD_Daemon *httpd;
@@ -367,62 +442,178 @@ static struct MhdHttpList *mhd_httpd_tail;
 static regex_t re_dotplus;
 
 /* The users local GNS zone hash */
-static struct GNUNET_CRYPTO_ShortHashCode local_gns_zone;
+static struct GNUNET_CRYPTO_ShortHashCode *local_gns_zone;
 
 /* The users local private zone */
-static struct GNUNET_CRYPTO_ShortHashCode local_private_zone;
+static struct GNUNET_CRYPTO_ShortHashCode *local_private_zone;
 
 /* The users local shorten zone */
-static struct GNUNET_CRYPTO_ShortHashCode local_shorten_zone;
+static struct GNUNET_CRYPTO_ShortHashCode *local_shorten_zone;
 
 /* The CA for SSL certificate generation */
 static struct ProxyCA proxy_ca;
 
 /* UNIX domain socket for mhd */
-struct GNUNET_NETWORK_Handle *mhd_unix_socket;
+#if !HAVE_MHD_NO_LISTEN_SOCKET
+static struct GNUNET_NETWORK_Handle *mhd_unix_socket;
+#endif
 
 /* Shorten zone private key */
-struct GNUNET_CRYPTO_RsaPrivateKey *shorten_zonekey;
+static struct GNUNET_CRYPTO_RsaPrivateKey *shorten_zonekey;
+
 
 /**
  * Checks if name is in tld
  *
- * @param name the name to check
- * @param tld the TLD to check for
+ * @param name the name to check 
+ * @param tld the TLD to check for (must NOT begin with ".")
  * @return GNUNET_YES or GNUNET_NO
  */
-int
-is_tld(const char* name, const char* tld)
+static int
+is_tld (const char* name, const char* tld)
 {
-  size_t offset;
-
-  if (strlen(name) <= strlen(tld))  
-    return GNUNET_NO;  
-
-  offset = strlen(name) - strlen(tld);
-  if (0 != strcmp (name+offset, tld))
-  {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "%s is not in .%s TLD\n", name, tld);
-    return GNUNET_NO;
-  }
-
-  return GNUNET_YES;
+  size_t name_len = strlen (name);
+  size_t tld_len = strlen (tld);
+
+  GNUNET_break ('.' != tld[0]);
+  return ( (tld_len < name_len) &&
+          ( ('.' == name[name_len - tld_len - 1]) || (name_len == tld_len) ) &&
+          (0 == memcmp (tld,
+                        name + (name_len - tld_len),
+                        tld_len)) );
 }
 
+
 static int
-get_uri_val_iter (void *cls,
+con_post_data_iter (void *cls,
                   enum MHD_ValueKind kind,
                   const char *key,
-                  const char *value)
+                  const char *filename,
+                  const char *content_type,
+                  const char *transfer_encoding,
+                  const char *data,
+                  uint64_t off,
+                  size_t size)
 {
-  char* buf = cls;
+  struct ProxyCurlTask* ctask = cls;
+  struct ProxyUploadData* pdata;
+  char* enc;
+  char* new_value;
+  
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Got POST data (file: %s, content type: %s): '%s=%.*s' at offset %llu size %llu\n",
+             filename, content_type,
+              key, (int) size, data, 
+             (unsigned long long) off, 
+             (unsigned long long) size);
+  GNUNET_assert (NULL != ctask->post_type);
+
+  if (0 == strcasecmp (MHD_HTTP_POST_ENCODING_MULTIPART_FORMDATA,
+                       ctask->post_type))
+  {
+    ctask->is_httppost = GNUNET_YES;
+    /* new part */
+    if (0 == off)
+    {
+      pdata = GNUNET_malloc (sizeof (struct ProxyUploadData));
+      pdata->key = GNUNET_strdup (key);
+
+      if (NULL != filename)
+        pdata->filename = GNUNET_strdup (filename);
+      if (NULL != content_type)
+        pdata->content_type = GNUNET_strdup (content_type);
+      pdata->value = GNUNET_malloc (size);
+      pdata->total_bytes = size;
+      memcpy (pdata->value, data, size);
+      GNUNET_CONTAINER_DLL_insert_tail (ctask->upload_data_head,
+                                        ctask->upload_data_tail,
+                                        pdata);
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Copied %llu bytes of POST Data\n", 
+                 (unsigned long long) size);
+      return MHD_YES;
+    }
+    
+    pdata = ctask->upload_data_tail;
+    new_value = GNUNET_malloc (size + pdata->total_bytes);
+    memcpy (new_value, pdata->value, pdata->total_bytes);
+    memcpy (new_value+off, data, size);
+    GNUNET_free (pdata->value);
+    pdata->value = new_value;
+    pdata->total_bytes += size;
+
+    return MHD_YES;
+  }
 
-  sprintf (buf+strlen (buf), "?%s=%s", key, value);
+  if (0 != strcasecmp (MHD_HTTP_POST_ENCODING_FORM_URLENCODED,
+                       ctask->post_type))
+  {
+    return MHD_NO;
+  }
 
+  ctask->is_httppost = GNUNET_NO;
+  
+  if (NULL != ctask->curl)
+    curl_easy_pause (ctask->curl, CURLPAUSE_CONT);
+
+  if (0 == off)
+  {
+    enc = curl_easy_escape (ctask->curl, key, 0);
+    if (NULL == enc)
+      {
+       GNUNET_break (0);
+       return MHD_NO;
+      }
+    /* a key */
+    pdata = GNUNET_malloc (sizeof (struct ProxyUploadData));
+    pdata->value = GNUNET_malloc (strlen (enc) + 3);
+    if (NULL != ctask->upload_data_head)
+    {
+      pdata->value[0] = '&';
+      memcpy (pdata->value+1, enc, strlen (enc));
+    }
+    else
+      memcpy (pdata->value, enc, strlen (enc));
+    pdata->value[strlen (pdata->value)] = '=';
+    pdata->bytes_left = strlen (pdata->value);
+    pdata->total_bytes = pdata->bytes_left;
+    curl_free (enc);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Escaped POST key: '%s'\n",
+                pdata->value);
+
+    GNUNET_CONTAINER_DLL_insert_tail (ctask->upload_data_head,
+                                      ctask->upload_data_tail,
+                                      pdata);
+  }
+
+  /* a value */
+  enc = curl_easy_escape (ctask->curl, data, 0);
+  if (NULL == enc)
+    {
+      GNUNET_break (0);
+      return MHD_NO;
+    }
+  pdata = GNUNET_malloc (sizeof (struct ProxyUploadData));
+  pdata->value = GNUNET_malloc (strlen (enc) + 1);
+  memcpy (pdata->value, enc, strlen (enc));
+  pdata->bytes_left = strlen (pdata->value);
+  pdata->total_bytes = pdata->bytes_left;
+  curl_free (enc);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Escaped POST value: '%s'\n",
+              pdata->value);
+
+  GNUNET_CONTAINER_DLL_insert_tail (ctask->upload_data_head,
+                                    ctask->upload_data_tail,
+                                    pdata);
   return MHD_YES;
 }
 
+
 /**
  * Read HTTP request header field 'Host'
  *
@@ -440,20 +631,52 @@ con_val_iter (void *cls,
 {
   struct ProxyCurlTask *ctask = cls;
   char* buf = ctask->host;
+  char* port;
   char* cstr;
   const char* hdr_val;
+  unsigned int uport;
 
   if (0 == strcmp ("Host", key))
   {
-    strcpy (buf, value);
+    port = strchr (value, ':');
+    if (NULL != port)
+    {
+      strncpy (buf, value, port-value);
+      port++;
+      if ((1 != sscanf (port, "%u", &uport)) ||
+           (uport > UINT16_MAX) ||
+           (0 == uport))
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    "Unable to parse port!\n");
+      else
+        ctask->port = (uint16_t) uport;
+    }
+    else
+      strcpy (buf, value);
     return MHD_YES;
   }
 
-  if (0 == strcmp ("Accept-Encoding", key))
+  if (0 == strcmp (MHD_HTTP_HEADER_ACCEPT_ENCODING, key))
     hdr_val = "";
   else
     hdr_val = value;
 
+  if (0 == strcasecmp (MHD_HTTP_HEADER_CONTENT_TYPE,
+                   key))
+  {
+    if (0 == strncasecmp (value,
+                     MHD_HTTP_POST_ENCODING_FORM_URLENCODED,
+                     strlen (MHD_HTTP_POST_ENCODING_FORM_URLENCODED)))
+      ctask->post_type = MHD_HTTP_POST_ENCODING_FORM_URLENCODED;
+    else if (0 == strncasecmp (value,
+                          MHD_HTTP_POST_ENCODING_MULTIPART_FORMDATA,
+                          strlen (MHD_HTTP_POST_ENCODING_MULTIPART_FORMDATA)))
+      ctask->post_type = MHD_HTTP_POST_ENCODING_MULTIPART_FORMDATA;
+    else
+      ctask->post_type = NULL;
+
+  }
+
   cstr = GNUNET_malloc (strlen (key) + strlen (hdr_val) + 3);
   GNUNET_snprintf (cstr, strlen (key) + strlen (hdr_val) + 3,
                    "%s: %s", key, hdr_val);
@@ -483,6 +706,7 @@ mhd_content_cb (void *cls,
                 char* buf,
                 size_t max);
 
+
 /**
  * Check HTTP response header for mime
  *
@@ -502,6 +726,9 @@ curl_check_hdr (void *buffer, size_t size, size_t nmemb, void *cls)
   char hdr_mime[html_mime_len+1];
   char hdr_generic[bytes+1];
   char new_cookie_hdr[bytes+strlen (ctask->leho)+1];
+  char new_location[MAX_HTTP_URI_LENGTH+500];
+  char real_host[264];
+  char leho_host[264];
   char* ndup;
   char* tok;
   char* cookie_domain;
@@ -509,6 +736,7 @@ curl_check_hdr (void *buffer, size_t size, size_t nmemb, void *cls)
   char* hdr_val;
   int delta_cdomain;
   size_t offset = 0;
+  char cors_hdr[strlen (ctask->leho) + strlen ("https://")];
   
   if (NULL == ctask->response)
   {
@@ -520,8 +748,30 @@ curl_check_hdr (void *buffer, size_t size, size_t nmemb, void *cls)
                                                         &mhd_content_cb,
                                                         ctask,
                                                         NULL);
+
+    /* if we have a leho add a CORS header */
+    if (0 != strcmp ("", ctask->leho))
+    {
+      /* We could also allow ssl and http here */
+      if (ctask->mhd->is_ssl)
+        sprintf (cors_hdr, "https://%s", ctask->leho);
+      else
+        sprintf (cors_hdr, "http://%s", ctask->leho);
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "MHD: Adding CORS header field %s\n",
+                  cors_hdr);
+
+      if (GNUNET_NO == MHD_add_response_header (ctask->response,
+                                              "Access-Control-Allow-Origin",
+                                              cors_hdr))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "MHD: Error adding CORS header field %s\n",
+                  cors_hdr);
+      }
+    }
     ctask->ready_to_queue = GNUNET_YES;
-    
   }
   
   if (html_mime_len <= bytes)
@@ -553,14 +803,11 @@ curl_check_hdr (void *buffer, size_t size, size_t nmemb, void *cls)
                    MHD_HTTP_HEADER_SET_COOKIE,
                    cookie_hdr_len))
   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Looking for cookie in: `%s'\n", hdr_generic);    
     ndup = GNUNET_strdup (hdr_generic+cookie_hdr_len+1);
     memset (new_cookie_hdr, 0, sizeof (new_cookie_hdr));
-    tok = strtok (ndup, ";");
-
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Looking for cookie in : %s\n", hdr_generic);
-    
-    for (; tok != NULL; tok = strtok (NULL, ";"))
+    for (tok = strtok (ndup, ";"); tok != NULL; tok = strtok (NULL, ";"))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "Got Cookie token: %s\n", tok);
@@ -599,7 +846,7 @@ curl_check_hdr (void *buffer, size_t size, size_t nmemb, void *cls)
             continue;
           }
         }
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                     "Cookie domain invalid\n");
 
         
@@ -610,24 +857,11 @@ curl_check_hdr (void *buffer, size_t size, size_t nmemb, void *cls)
       offset++;
     }
     
-    //memcpy (new_cookie_hdr+offset, tok, strlen (tok));
-
     GNUNET_free (ndup);
 
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "Got Set-Cookie HTTP header %s\n", new_cookie_hdr);
 
-    //pch = GNUNET_malloc (sizeof (struct ProxySetCookieHeader));
-    //len = strlen (hdr_cookie) - cookie_hdr_len - 1;
-    //pch->cookie = GNUNET_malloc (len + 1);
-    //memset (pch->cookie, 0, len + 1);
-    //memcpy (pch->cookie, hdr_cookie+cookie_hdr_len+1, len);
-    //GNUNET_CONTAINER_DLL_insert (ctask->set_cookies_head,
-    //                             ctask->set_cookies_tail,
-    //                             pch);
-    //pch = ctask->set_cookies_head;
-    //while (pch != NULL)
-    //{
     if (GNUNET_NO == MHD_add_response_header (ctask->response,
                                               MHD_HTTP_HEADER_SET_COOKIE,
                                               new_cookie_hdr))
@@ -637,43 +871,65 @@ curl_check_hdr (void *buffer, size_t size, size_t nmemb, void *cls)
                   hdr_generic+cookie_hdr_len+1);
     }
     return bytes;
-      //GNUNET_free (pch->cookie);
-      //GNUNET_CONTAINER_DLL_remove (ctask->set_cookies_head,
-      //                             ctask->set_cookies_tail,
-      //                             pch);
-      //GNUNET_free (pch);
-      //pch = ctask->set_cookies_head;
-    //}
   }
 
   ndup = GNUNET_strdup (hdr_generic);
   hdr_type = strtok (ndup, ":");
 
-  if (hdr_type != NULL)
+  if (NULL == hdr_type)
+  {
+    GNUNET_free (ndup);
+    return bytes;
+  }
+
+  hdr_val = strtok (NULL, "");
+
+  if (NULL == hdr_val)
+  {
+    GNUNET_free (ndup);
+    return bytes;
+  }
+
+  hdr_val++;
+
+  if (0 == strcasecmp (MHD_HTTP_HEADER_LOCATION, hdr_type))
   {
-    hdr_val = strtok (NULL, "");
-    if (hdr_val != NULL)
+    if (ctask->mhd->is_ssl)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Trying to set %s: %s\n",
-                  hdr_type,
-                  hdr_val+1);
-      if (GNUNET_NO == MHD_add_response_header (ctask->response,
-                                                hdr_type,
-                                                hdr_val+1))
-      {
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                    "MHD: Error adding %s header field %s\n",
-                    hdr_type,
-                    hdr_val+1);
-      }
+      sprintf (leho_host, "https://%s", ctask->leho);
+      sprintf (real_host, "https://%s", ctask->host);
+    }
+    else
+    {
+      sprintf (leho_host, "http://%s", ctask->leho);
+      sprintf (real_host, "http://%s", ctask->host);
+    }
+
+    if (0 == memcmp (leho_host, hdr_val, strlen (leho_host)))
+    {
+      sprintf (new_location, "%s%s", real_host, hdr_val+strlen (leho_host));
+      hdr_val = new_location;
     }
   }
-  GNUNET_free (ndup);
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Trying to set %s: %s\n",
+              hdr_type,
+              hdr_val);
+  if (GNUNET_NO == MHD_add_response_header (ctask->response,
+                                            hdr_type,
+                                            hdr_val))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "MHD: Error adding %s header field %s\n",
+                hdr_type,
+                hdr_val);
+  }
+  GNUNET_free (ndup);
   return bytes;
 }
 
+
 /**
  * schedule mhd
  *
@@ -690,6 +946,7 @@ run_httpd (struct MhdHttpList *hd);
 static void
 run_httpds (void);
 
+
 /**
  * Task run whenever HTTP server operations are pending.
  *
@@ -700,6 +957,7 @@ static void
 do_httpd (void *cls,
           const struct GNUNET_SCHEDULER_TaskContext *tc);
 
+
 static void
 run_mhd_now (struct MhdHttpList *hd)
 {
@@ -714,11 +972,13 @@ run_mhd_now (struct MhdHttpList *hd)
   hd->httpd_task = GNUNET_SCHEDULER_add_now (&do_httpd, hd);
 }
 
+
 /**
  * Ask cURL for the select sets and schedule download
  */
 static void
-curl_download_prepare ();
+curl_download_prepare (void);
+
 
 /**
  * Callback to free content
@@ -731,8 +991,9 @@ mhd_content_free (void *cls,
                   const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ProxyCurlTask *ctask = cls;
-  GNUNET_assert (NULL == ctask->pp_match_head);
+  struct ProxyUploadData *pdata;
 
+  GNUNET_assert (NULL == ctask->pp_match_head);
   if (NULL != ctask->headers)
     curl_slist_free_all (ctask->headers);
 
@@ -742,7 +1003,23 @@ mhd_content_free (void *cls,
   if (NULL != ctask->response)
     MHD_destroy_response (ctask->response);
 
+  if (NULL != ctask->post_handler)
+    MHD_destroy_post_processor (ctask->post_handler);
+
+  if (GNUNET_SCHEDULER_NO_TASK != ctask->pp_task)
+    GNUNET_SCHEDULER_cancel (ctask->pp_task);
 
+  for (pdata = ctask->upload_data_head; NULL != pdata; pdata = ctask->upload_data_head)
+  {
+    GNUNET_CONTAINER_DLL_remove (ctask->upload_data_head,
+                                 ctask->upload_data_tail,
+                                 pdata);
+    GNUNET_free_non_null (pdata->filename);
+    GNUNET_free_non_null (pdata->content_type);
+    GNUNET_free_non_null (pdata->key);
+    GNUNET_free_non_null (pdata->value);
+    GNUNET_free (pdata);
+  }
   GNUNET_free (ctask);
 }
 
@@ -763,19 +1040,16 @@ mhd_content_cb (void *cls,
                 size_t max)
 {
   struct ProxyCurlTask *ctask = cls;
-  struct ProxyREMatch *re_match = ctask->pp_match_head;
+  struct ProxyREMatch *re_match;
   ssize_t copied = 0;
-  long long int bytes_to_copy = ctask->buffer_write_ptr - ctask->buffer_read_ptr;
-
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "MHD: content cb for %s. To copy: %lld\n",
-              ctask->url, bytes_to_copy);
-  GNUNET_assert (bytes_to_copy >= 0);
+  size_t bytes_to_copy = ctask->buffer_write_ptr - ctask->buffer_read_ptr;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "MHD: content cb for %s. To copy: %u\n",
+              ctask->url, (unsigned int) bytes_to_copy);
   if ((GNUNET_YES == ctask->download_is_finished) &&
       (GNUNET_NO == ctask->download_error) &&
-      (0 == bytes_to_copy) &&
-      (BUF_WAIT_FOR_CURL == ctask->buf_status))
+      (0 == bytes_to_copy))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "MHD: sending response for %s\n", ctask->url);
@@ -788,8 +1062,7 @@ mhd_content_cb (void *cls,
   
   if ((GNUNET_YES == ctask->download_error) &&
       (GNUNET_YES == ctask->download_is_finished) &&
-      (0 == bytes_to_copy) &&
-      (BUF_WAIT_FOR_CURL == ctask->buf_status))
+      (0 == bytes_to_copy))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "MHD: sending error response\n");
@@ -804,41 +1077,39 @@ mhd_content_cb (void *cls,
     return 0;
   
   copied = 0;
-  for (; NULL != re_match; re_match = ctask->pp_match_head)
+  for (re_match = ctask->pp_match_head; NULL != re_match; re_match = ctask->pp_match_head)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "MHD: Processing PP %s\n",
                 re_match->hostname);
     bytes_to_copy = re_match->start - ctask->buffer_read_ptr;
-    GNUNET_assert (bytes_to_copy >= 0);
-
     if (bytes_to_copy+copied > max)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-             "MHD: buffer in response too small for %d. Using available space (%d). (%s)\n",
-             bytes_to_copy,
-             max,
-             ctask->url);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                 "MHD: buffer in response too small for %u. Using available space (%d). (%s)\n",
+                 (unsigned int) bytes_to_copy,
+                 max,
+                 ctask->url);
       memcpy (buf+copied, ctask->buffer_read_ptr, max-copied);
       ctask->buffer_read_ptr += max-copied;
       copied = max;
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "MHD: copied %d bytes\n", copied);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                 "MHD: copied %d bytes\n", (int) copied);
       return copied;
     }
 
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "MHD: copying %d bytes to mhd response at offset %d\n",
-                bytes_to_copy, ctask->buffer_read_ptr);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "MHD: copying %u bytes to mhd response at offset %d\n",
+                (unsigned int) bytes_to_copy, ctask->buffer_read_ptr);
     memcpy (buf+copied, ctask->buffer_read_ptr, bytes_to_copy);
     copied += bytes_to_copy;
 
     if (GNUNET_NO == re_match->done)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "MHD: Waiting for PP of %s\n", re_match->hostname);
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "MHD: copied %d bytes\n", copied);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                 "MHD: copied %d bytes\n", (int) copied);
       ctask->buffer_read_ptr += bytes_to_copy;
       return copied;
     }
@@ -851,15 +1122,15 @@ mhd_content_cb (void *cls,
                   re_match->result,
                   ctask->url);
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "MHD: copied %d bytes\n", copied);
+                 "MHD: copied %d bytes\n", (int) copied);
       ctask->buffer_read_ptr += bytes_to_copy;
       return copied;
     }
     
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "MHD: Adding PP result %s to buffer\n",
                 re_match->result);
-    memcpy (buf+copied, re_match->result, strlen (re_match->result));
+    memcpy (buf + copied, re_match->result, strlen (re_match->result));
     copied += strlen (re_match->result);
     ctask->buffer_read_ptr = re_match->end;
     GNUNET_CONTAINER_DLL_remove (ctask->pp_match_head,
@@ -870,16 +1141,14 @@ mhd_content_cb (void *cls,
 
   bytes_to_copy = ctask->buffer_write_ptr - ctask->buffer_read_ptr;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "MHD: copied: %d left: %d, space left in buf: %d\n",
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "MHD: copied: %d left: %u, space left in buf: %d\n",
               copied,
-              bytes_to_copy, max-copied);
+              (unsigned int) bytes_to_copy, (int) (max - copied));
   
-  GNUNET_assert (0 <= bytes_to_copy);
-
   if (GNUNET_NO == ctask->download_is_finished)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "MHD: Purging buffer\n");
     memmove (ctask->buffer, ctask->buffer_read_ptr, bytes_to_copy);
     ctask->buffer_read_ptr = ctask->buffer;
@@ -887,28 +1156,23 @@ mhd_content_cb (void *cls,
     ctask->buffer[bytes_to_copy] = '\0';
   }
   
-  if (bytes_to_copy+copied > max)
-    bytes_to_copy = max-copied;
-
-  if (0 > bytes_to_copy)
-    bytes_to_copy = 0;
-  
+  if (bytes_to_copy + copied > max)
+    bytes_to_copy = max - copied;
   memcpy (buf+copied, ctask->buffer_read_ptr, bytes_to_copy);
   ctask->buffer_read_ptr += bytes_to_copy;
   copied += bytes_to_copy;
   ctask->buf_status = BUF_WAIT_FOR_CURL;
   
-  if ((NULL != ctask->curl) &&
-      (GNUNET_NO == ctask->download_is_finished) &&
-      ((ctask->buffer_write_ptr - ctask->buffer_read_ptr) <= 0))
+  if (NULL != ctask->curl)
     curl_easy_pause (ctask->curl, CURLPAUSE_CONT);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "MHD: copied %d bytes\n", copied);
+              "MHD: copied %d bytes\n", (int) copied);
   run_mhd_now (ctask->mhd);
   return copied;
 }
 
+
 /**
  * Shorten result callback
  *
@@ -923,7 +1187,7 @@ process_shorten (void* cls, const char* short_name)
   
   if (NULL == short_name)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "PP: Unable to shorten %s\n",
                 re_match->hostname);
     GNUNET_CONTAINER_DLL_remove (re_match->ctask->pp_match_head,
@@ -938,12 +1202,12 @@ process_shorten (void* cls, const char* short_name)
   else
     strcpy (result, short_name);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "PP: Shorten %s -> %s\n",
               re_match->hostname,
               result);
-  //this is evil.. what about https
-  if (re_match->ctask->mhd->is_ssl)
+  
+  if (re_match->is_ssl)
     sprintf (re_match->result, "href=\"https://%s", result);
   else
     sprintf (re_match->result, "href=\"http://%s", result);
@@ -954,8 +1218,10 @@ process_shorten (void* cls, const char* short_name)
 
 
 /**
- * Tabula Rasa postprocess buffer
+ * Postprocess data in buffer. From read ptr to write ptr
  *
+ * @param cls the curlproxytask
+ * @param tc task context
  */
 static void
 postprocess_buffer (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
@@ -970,37 +1236,42 @@ postprocess_buffer (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   if (GNUNET_YES != ctask->parse_content)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "PP: Not parsing content\n");
     ctask->buf_status = BUF_WAIT_FOR_MHD;
     run_mhd_now (ctask->mhd);
     return;
   }
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "PP: We need to parse the HTML\n");
 
   /* 0 means match found */
   while (0 == regexec (&re_dotplus, re_ptr, RE_N_MATCHES, m, 0))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "PP: regex match\n");
 
     GNUNET_assert (m[1].rm_so != -1);
 
     memset (re_hostname, 0, sizeof (re_hostname));
     memcpy (re_hostname, re_ptr+m[1].rm_so, (m[3].rm_eo-m[1].rm_so));
+    
 
     re_match = GNUNET_malloc (sizeof (struct ProxyREMatch));
     re_match->start = re_ptr + m[0].rm_so;
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "XXXXX: %d\n", re_match->start);
     re_match->end = re_ptr + m[3].rm_eo;
     re_match->done = GNUNET_NO;
     re_match->ctask = ctask;
+    
+    if ('s' == *(re_ptr+m[1].rm_so-strlen("://")-1)) //FIXME strcmp
+      re_match->is_ssl = GNUNET_YES;
+    else
+      re_match->is_ssl = GNUNET_NO;
+      
     strcpy (re_match->hostname, re_hostname);
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Got hostname %s\n", re_hostname);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "PP: Got hostname %s\n", re_hostname);
     re_ptr += m[3].rm_eo;
 
     if (GNUNET_YES == is_tld (re_match->hostname, GNUNET_GNS_TLD_PLUS))
@@ -1012,9 +1283,9 @@ postprocess_buffer (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
     re_match->shorten_task = GNUNET_GNS_shorten_zone (gns_handle,
                              re_match->hostname,
-                             &local_private_zone,
-                             &local_shorten_zone,
-                             &local_gns_zone,
+                             local_private_zone,
+                             local_shorten_zone,
+                             local_gns_zone,
                              &process_shorten,
                              re_match); //FIXME cancel appropriately
 
@@ -1024,14 +1295,20 @@ postprocess_buffer (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   }
   
   ctask->buf_status = BUF_WAIT_FOR_MHD;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "PP: No more matches\n");
   run_mhd_now (ctask->mhd);
 }
 
+
 /**
- * Tabula Rasa cURL download
+ * Handle data from cURL
  *
+ * @param ptr pointer to the data
+ * @param size number of blocks of data
+ * @param nmemb blocksize
+ * @param ctx the curlproxytask
+ * @return number of bytes handled
  */
 static size_t
 curl_download_cb (void *ptr, size_t size, size_t nmemb, void* ctx)
@@ -1042,15 +1319,18 @@ curl_download_cb (void *ptr, size_t size, size_t nmemb, void* ctx)
   size_t buf_space = sizeof (ctask->buffer) -
     (ctask->buffer_write_ptr-ctask->buffer);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "CURL: Got %d. %d free in buffer\n",
               total, buf_space);
 
+  if (BUF_WAIT_FOR_CURL != ctask->buf_status)
+    return CURL_WRITEFUNC_PAUSE;
+
   if (total > (buf_space - CURL_BUF_PADDING))
   {
     if (ctask->buf_status == BUF_WAIT_FOR_CURL)
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "CURL: Buffer full starting postprocessing\n");
       ctask->buf_status = BUF_WAIT_FOR_PP;
       ctask->pp_task = GNUNET_SCHEDULER_add_now (&postprocess_buffer,
@@ -1071,10 +1351,116 @@ curl_download_cb (void *ptr, size_t size, size_t nmemb, void* ctx)
   ctask->buffer_write_ptr += total;
   ctask->buffer_write_ptr[0] = '\0';
 
-  //run_mhd_now (ctask->mhd);
-  return total;
+  return total;
+}
+
+
+/**
+ * cURL callback for put data
+ */
+static size_t
+put_read_callback (void *buf, size_t size, size_t nmemb, void *cls)
+{
+  struct ProxyCurlTask *ctask = cls;
+  struct ProxyUploadData *pdata = ctask->upload_data_head;
+  size_t len = size * nmemb;
+  size_t to_copy;
+  char* pos;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "CURL: put read callback\n");
+
+  if (NULL == pdata)
+    return CURL_READFUNC_PAUSE;
+  
+  //fin
+  if (NULL == pdata->value)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "CURL: Terminating PUT\n");
+
+    GNUNET_CONTAINER_DLL_remove (ctask->upload_data_head,
+                                 ctask->upload_data_tail,
+                                 pdata);
+    GNUNET_free (pdata);
+    return 0;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "CURL: read callback value %s\n", pdata->value); 
+  
+  to_copy = pdata->bytes_left;
+  if (to_copy > len)
+    to_copy = len;
+  
+  pos = pdata->value + (pdata->total_bytes - pdata->bytes_left);
+  memcpy (buf, pos, to_copy);
+  pdata->bytes_left -= to_copy;
+  if (pdata->bytes_left <= 0)
+  {
+    GNUNET_free (pdata->value);
+    GNUNET_CONTAINER_DLL_remove (ctask->upload_data_head,
+                                 ctask->upload_data_tail,
+                                 pdata);
+    GNUNET_free (pdata);
+  }
+  return to_copy;
+}
+
+
+/**
+ * cURL callback for post data
+ */
+static size_t
+post_read_callback (void *buf, size_t size, size_t nmemb, void *cls)
+{
+  struct ProxyCurlTask *ctask = cls;
+  struct ProxyUploadData *pdata = ctask->upload_data_head;
+  size_t len = size * nmemb;
+  size_t to_copy;
+  char* pos;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "CURL: read callback\n");
+
+  if (NULL == pdata)
+    return CURL_READFUNC_PAUSE;
+  
+  //fin
+  if (NULL == pdata->value)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "CURL: Terminating POST data\n");
+
+    GNUNET_CONTAINER_DLL_remove (ctask->upload_data_head,
+                                 ctask->upload_data_tail,
+                                 pdata);
+    GNUNET_free (pdata);
+    return 0;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "CURL: read callback value %s\n", pdata->value); 
+  
+  to_copy = pdata->bytes_left;
+  if (to_copy > len)
+    to_copy = len;
+  
+  pos = pdata->value + (pdata->total_bytes - pdata->bytes_left);
+  memcpy (buf, pos, to_copy);
+  pdata->bytes_left -= to_copy;
+  if (pdata->bytes_left <= 0)
+  {
+    GNUNET_free (pdata->value);
+    GNUNET_CONTAINER_DLL_remove (ctask->upload_data_head,
+                                 ctask->upload_data_tail,
+                                 pdata);
+    GNUNET_free (pdata);
+  }
+  return to_copy;
 }
 
+
 /**
  * Task that is run when we are ready to receive more data
  * from curl
@@ -1085,6 +1471,7 @@ curl_download_cb (void *ptr, size_t size, size_t nmemb, void* ctx)
 static void
 curl_task_download (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
+
 /**
  * Ask cURL for the select sets and schedule download
  */
@@ -1105,9 +1492,7 @@ curl_download_prepare ()
   FD_ZERO (&rs);
   FD_ZERO (&ws);
   FD_ZERO (&es);
-  mret = curl_multi_fdset (curl_multi, &rs, &ws, &es, &max);
-
-  if (mret != CURLM_OK)
+  if (CURLM_OK != (mret = curl_multi_fdset (curl_multi, &rs, &ws, &es, &max)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "%s failed at %s:%d: `%s'\n",
@@ -1116,31 +1501,37 @@ curl_download_prepare ()
     //TODO cleanup here?
     return;
   }
-
-  mret = curl_multi_timeout (curl_multi, &to);
-  rtime = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, to);
-
+  to = -1;
+  GNUNET_break (CURLM_OK == curl_multi_timeout (curl_multi, &to));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "cURL multi fds: max=%d timeout=%llu\n", max, to);
-
+              "cURL multi fds: max=%d timeout=%lld\n", max, (long long) to);
+  if (-1 == to)
+    rtime = GNUNET_TIME_UNIT_FOREVER_REL;
+  else
+    rtime = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, to);
   grs = GNUNET_NETWORK_fdset_create ();
   gws = GNUNET_NETWORK_fdset_create ();
   GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
   GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Scheduling task cURL\n");
-
   if (curl_download_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (curl_download_task);
-  
-  curl_download_task =
-    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                 rtime,
-                                 grs, gws,
-                                 &curl_task_download, curl_multi);
+    GNUNET_SCHEDULER_cancel (curl_download_task);  
+  if (-1 != max)
+  {
+    curl_download_task =
+      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                   rtime,
+                                   grs, gws,
+                                   &curl_task_download, curl_multi);
+  }
+  else if (NULL != ctasks_head)
+  {
+    /* as specified in curl docs */
+    curl_download_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
+                                                       &curl_task_download,
+                                                       curl_multi);
+  }
   GNUNET_NETWORK_fdset_destroy (gws);
   GNUNET_NETWORK_fdset_destroy (grs);
-
 }
 
 
@@ -1161,7 +1552,6 @@ curl_task_download (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct ProxyCurlTask *ctask;
   int num_ctasks;
   long resp_code;
-
   struct ProxyCurlTask *clean_head = NULL;
   struct ProxyCurlTask *clean_tail = NULL;
 
@@ -1169,7 +1559,7 @@ curl_task_download (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Shutdown requested while trying to download\n");
     //TODO cleanup
     return;
@@ -1187,8 +1577,7 @@ curl_task_download (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Running curl tasks: %d\n", running);
 
-    ctask = ctasks_head;
-    for (; ctask != NULL; ctask = ctask->next)
+    for (ctask = ctasks_head; NULL != ctask; ctask = ctask->next)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "CTask: %s\n", ctask->url);
@@ -1203,7 +1592,7 @@ curl_task_download (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     
     do
     {
-      ctask = ctasks_head;
+      
       msg = curl_multi_info_read (curl_multi, &msgnum);
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Messages left: %d\n", msgnum);
@@ -1219,7 +1608,7 @@ curl_task_download (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
            GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                        "Download curl failed");
             
-           for (; ctask != NULL; ctask = ctask->next)
+           for (ctask = ctasks_head; NULL != ctask; ctask = ctask->next)
            {
              if (NULL == ctask->curl)
                continue;
@@ -1253,19 +1642,16 @@ curl_task_download (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                        "CURL: download completed.\n");
 
-           for (; ctask != NULL; ctask = ctask->next)
+           for (ctask = ctasks_head; NULL != ctask; ctask = ctask->next)
            {
              if (NULL == ctask->curl)
                continue;
 
-             if (memcmp (msg->easy_handle, ctask->curl, sizeof (CURL)) != 0)
-               continue;
-             
-             if (ctask->buf_status != BUF_WAIT_FOR_CURL)
+             if (0 != memcmp (msg->easy_handle, ctask->curl, sizeof (CURL)))
                continue;
              
              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                         "CURL: task %s found.\n", ctask->url);
+                         "CURL: completed task %s found.\n", ctask->url);
              if (CURLE_OK == curl_easy_getinfo (ctask->curl,
                                                 CURLINFO_RESPONSE_CODE,
                                                 &resp_code))
@@ -1281,11 +1667,9 @@ curl_task_download (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                                           ctask);
              }
 
-             //ctask->ready_to_queue = MHD_YES;
+             ctask->ready_to_queue = MHD_YES;
              ctask->download_is_finished = GNUNET_YES;
 
-             //GNUNET_SCHEDULER_add_now (&run_mhd, ctask->mhd);
-             
              /* We MUST not modify the multi handle else we loose messages */
              GNUNET_CONTAINER_DLL_remove (ctasks_head, ctasks_tail,
                                           ctask);
@@ -1304,7 +1688,7 @@ curl_task_download (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       }
     } while (msgnum > 0);
 
-    for (ctask=clean_head; ctask != NULL; ctask = ctask->next)
+    for (ctask=clean_head; NULL != ctask; ctask = ctask->next)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "CURL: Removing task %s.\n", ctask->url);
@@ -1314,10 +1698,8 @@ curl_task_download (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     }
     
     num_ctasks=0;
-    for (ctask=ctasks_head; ctask != NULL; ctask = ctask->next)
-    {
-      num_ctasks++;
-    }
+    for (ctask=ctasks_head; NULL != ctask; ctask = ctask->next)    
+      num_ctasks++; 
     
     if (num_ctasks != running)
     {
@@ -1327,7 +1709,6 @@ curl_task_download (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
     GNUNET_assert ( num_ctasks == running );
 
-    //run_httpds ();
   } while (mret == CURLM_CALL_MULTI_PERFORM);
   
   if (mret != CURLM_OK)
@@ -1339,6 +1720,7 @@ curl_task_download (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   curl_download_prepare();
 }
 
+
 /**
  * Process LEHO lookup
  *
@@ -1380,7 +1762,7 @@ process_leho_lookup (void *cls,
 
   if (0 != strcmp (ctask->leho, ""))
   {
-    sprintf (hosthdr, "%s%s", "Host: ", ctask->leho);
+    sprintf (hosthdr, "%s%s:%d", "Host: ", ctask->leho, ctask->port);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "New HTTP header value: %s\n", hosthdr);
     ctask->headers = curl_slist_append (ctask->headers, hosthdr);
@@ -1408,7 +1790,7 @@ process_leho_lookup (void *cls,
                   "Curl resolve: %s\n", resolvename);
       ctask->resolver = curl_slist_append ( ctask->resolver, resolvename);
       curl_easy_setopt (ctask->curl, CURLOPT_RESOLVE, ctask->resolver);
-      sprintf (curlurl, "https://%s%s", ctask->leho, ctask->url);
+      sprintf (curlurl, "https://%s:%d%s", ctask->leho, ctask->port, ctask->url);
       curl_easy_setopt (ctask->curl, CURLOPT_URL, curlurl);
     }
     else
@@ -1437,6 +1819,7 @@ process_leho_lookup (void *cls,
 
 }
 
+
 /**
  * Initialize download and trigger curl
  *
@@ -1465,7 +1848,7 @@ process_get_authority (void *cls,
 
   GNUNET_GNS_lookup_zone (gns_handle,
                           ctask->host,
-                          &local_gns_zone,
+                          local_gns_zone,
                           GNUNET_GNS_RECORD_LEHO,
                           GNUNET_YES, //Only cached for performance
                           shorten_zonekey,
@@ -1474,6 +1857,17 @@ process_get_authority (void *cls,
 }
 
 
+static void*
+mhd_log_callback (void* cls, const char* url)
+{
+  struct ProxyCurlTask *ctask;
+
+  ctask = GNUNET_malloc (sizeof (struct ProxyCurlTask));
+  strcpy (ctask->url, url);
+  return ctask;
+}
+
+
 /**
  * Main MHD callback for handling requests.
  *
@@ -1508,38 +1902,38 @@ create_response (void *cls,
                  void **con_cls)
 {
   struct MhdHttpList* hd = cls;
-  const char* page = "<html><head><title>gnoxy</title>"\
+  const char* page = "<html><head><title>gnunet-gns-proxy</title>"
                       "</head><body>cURL fail</body></html>";
   
-  char curlurl[512]; // buffer overflow!
+  char curlurl[MAX_HTTP_URI_LENGTH]; // buffer overflow!
   int ret = MHD_YES;
-
-  struct ProxyCurlTask *ctask;
+  int i;
+  struct ProxyCurlTask *ctask = *con_cls;
+  struct ProxyUploadData *fin_post;
+  struct curl_forms forms[5];
+  struct ProxyUploadData *upload_data_iter;
   
   //FIXME handle
-  if (0 != strcasecmp (meth, MHD_HTTP_METHOD_GET))
+  if ((0 != strcasecmp (meth, MHD_HTTP_METHOD_GET)) &&
+      (0 != strcasecmp (meth, MHD_HTTP_METHOD_PUT)) &&
+      (0 != strcasecmp (meth, MHD_HTTP_METHOD_POST)) &&
+      (0 != strcasecmp (meth, MHD_HTTP_METHOD_HEAD)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "MHD: %s NOT IMPLEMENTED!\n", meth);
     return MHD_NO;
   }
 
-  if (0 != *upload_data_size)
-    return MHD_NO;
 
-  if (NULL == *con_cls)
+  if (GNUNET_NO == ctask->accepted)
   {
-    ctask = GNUNET_malloc (sizeof (struct ProxyCurlTask));
-    ctask->mhd = hd;
-    *con_cls = ctask;
-    
-    // FIXME: probably not best here, also never free'ed...
-    if (NULL == curl_multi)
-      curl_multi = curl_multi_init ();
 
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Got %s request for %s\n", meth, url);
+    ctask->mhd = hd;
     ctask->curl = curl_easy_init();
-  
-    if ((NULL == ctask->curl) || (NULL == curl_multi)) // ugh, curl_multi init failure check MUCH earlier
+    ctask->curl_running = GNUNET_NO;
+    if (NULL == ctask->curl)
     {
       ctask->response = MHD_create_response_from_buffer (strlen (page),
                                                 (void*)page,
@@ -1551,45 +1945,83 @@ create_response (void *cls,
       GNUNET_free (ctask);
       return ret;
     }
-  
-    ctask->download_in_progress = GNUNET_YES;
-    ctask->buf_status = BUF_WAIT_FOR_CURL;
-    ctask->connection = con;
-    ctask->curl_response_code = MHD_HTTP_OK;
-    ctask->buffer_read_ptr = ctask->buffer;
-    ctask->buffer_write_ptr = ctask->buffer;
-    ctask->pp_task = GNUNET_SCHEDULER_NO_TASK;
+    
+    if (ctask->mhd->is_ssl)
+      ctask->port = HTTPS_PORT;
+    else
+      ctask->port = HTTP_PORT;
 
     MHD_get_connection_values (con,
                                MHD_HEADER_KIND,
                                &con_val_iter, ctask);
-
+    
     curl_easy_setopt (ctask->curl, CURLOPT_HEADERFUNCTION, &curl_check_hdr);
     curl_easy_setopt (ctask->curl, CURLOPT_HEADERDATA, ctask);
     curl_easy_setopt (ctask->curl, CURLOPT_WRITEFUNCTION, &curl_download_cb);
     curl_easy_setopt (ctask->curl, CURLOPT_WRITEDATA, ctask);
     curl_easy_setopt (ctask->curl, CURLOPT_FOLLOWLOCATION, 0);
-    //curl_easy_setopt (ctask->curl, CURLOPT_MAXREDIRS, 4);
-    /* no need to abort if the above failed */
+    curl_easy_setopt (ctask->curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
+
     if (GNUNET_NO == ctask->mhd->is_ssl)
     {
-      sprintf (curlurl, "http://%s%s", ctask->host, url);
-      MHD_get_connection_values (con,
-                                 MHD_GET_ARGUMENT_KIND,
-                                 &get_uri_val_iter, curlurl);
+      sprintf (curlurl, "http://%s:%d%s", ctask->host, ctask->port, ctask->url);
       curl_easy_setopt (ctask->curl, CURLOPT_URL, curlurl);
     }
-    strcpy (ctask->url, url);
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "MHD: Adding new curl task for %s%s\n", ctask->host, url);
-    MHD_get_connection_values (con,
-                               MHD_GET_ARGUMENT_KIND,
-                               &get_uri_val_iter, ctask->url);
-  
-    //curl_easy_setopt (ctask->curl, CURLOPT_URL, curlurl);
+    
+
     curl_easy_setopt (ctask->curl, CURLOPT_FAILONERROR, 1);
     curl_easy_setopt (ctask->curl, CURLOPT_CONNECTTIMEOUT, 600L);
     curl_easy_setopt (ctask->curl, CURLOPT_TIMEOUT, 600L);
+    
+    /* Add GNS header */
+    ctask->headers = curl_slist_append (ctask->headers,
+                                          "GNS: YES");
+    ctask->accepted = GNUNET_YES;
+    ctask->download_in_progress = GNUNET_YES;
+    ctask->buf_status = BUF_WAIT_FOR_CURL;
+    ctask->connection = con;
+    ctask->curl_response_code = MHD_HTTP_OK;
+    ctask->buffer_read_ptr = ctask->buffer;
+    ctask->buffer_write_ptr = ctask->buffer;
+    ctask->pp_task = GNUNET_SCHEDULER_NO_TASK;
+    
+
+    if (0 == strcasecmp (meth, MHD_HTTP_METHOD_PUT))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Setting up PUT\n");
+      
+      curl_easy_setopt (ctask->curl, CURLOPT_UPLOAD, 1);
+      curl_easy_setopt (ctask->curl, CURLOPT_READDATA, ctask);
+      curl_easy_setopt (ctask->curl, CURLOPT_READFUNCTION, &put_read_callback);
+      ctask->headers = curl_slist_append (ctask->headers,
+                                          "Transfer-Encoding: chunked");
+    }
+
+    if (0 == strcasecmp (meth, MHD_HTTP_METHOD_POST))
+    {
+      //FIXME handle multipart
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Setting up POST processor\n");
+      ctask->post_handler = MHD_create_post_processor (con,
+                                 POSTBUFFERSIZE,
+                                 &con_post_data_iter,
+                                 ctask);
+      ctask->headers = curl_slist_append (ctask->headers,
+                                         "Transfer-Encoding: chunked");
+      return MHD_YES;
+    }
+
+    if (0 == strcasecmp (meth, MHD_HTTP_METHOD_HEAD))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Setting NOBODY\n");
+      curl_easy_setopt (ctask->curl, CURLOPT_NOBODY, 1);
+    }
+
+    
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "MHD: Adding new curl task for %s\n", ctask->host);
 
     GNUNET_GNS_get_authority (gns_handle,
                               ctask->host,
@@ -1597,10 +2029,109 @@ create_response (void *cls,
                               ctask);
     ctask->ready_to_queue = GNUNET_NO;
     ctask->fin = GNUNET_NO;
+    ctask->curl_running = GNUNET_YES;
     return MHD_YES;
   }
 
   ctask = (struct ProxyCurlTask *) *con_cls;
+  if (0 == strcasecmp (meth, MHD_HTTP_METHOD_POST))
+  {
+    if (0 != *upload_data_size)
+    {
+      
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Invoking POST processor\n");
+      MHD_post_process (ctask->post_handler,
+                        upload_data, *upload_data_size);
+      *upload_data_size = 0;
+      if ((GNUNET_NO == ctask->is_httppost) &&
+          (GNUNET_NO == ctask->curl_running))
+      {
+        curl_easy_setopt (ctask->curl, CURLOPT_POST, 1);
+        curl_easy_setopt (ctask->curl, CURLOPT_READFUNCTION,
+                          &post_read_callback);
+        curl_easy_setopt (ctask->curl, CURLOPT_READDATA, ctask);
+        
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "MHD: Adding new curl task for %s\n", ctask->host);
+
+        GNUNET_GNS_get_authority (gns_handle,
+                                  ctask->host,
+                                  &process_get_authority,
+                                  ctask);
+        ctask->ready_to_queue = GNUNET_NO;
+        ctask->fin = GNUNET_NO;
+        ctask->curl_running = GNUNET_YES;
+      }
+      return MHD_YES;
+    }
+    else if (GNUNET_NO == ctask->post_done)
+    {
+      if (GNUNET_YES == ctask->is_httppost)
+      {
+        for (upload_data_iter = ctask->upload_data_head;
+             NULL != upload_data_iter;
+             upload_data_iter = upload_data_iter->next)
+        {
+          i = 0;
+          if (NULL != upload_data_iter->filename)
+          {
+            forms[i].option = CURLFORM_FILENAME;
+            forms[i].value = upload_data_iter->filename;
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                        "Adding filename %s\n",
+                        forms[i].value);
+            i++;
+          }
+          if (NULL != upload_data_iter->content_type)
+          {
+            forms[i].option = CURLFORM_CONTENTTYPE;
+            forms[i].value = upload_data_iter->content_type;
+            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                        "Adding content type %s\n",
+                        forms[i].value);
+            i++;
+          }
+          forms[i].option = CURLFORM_PTRCONTENTS;
+          forms[i].value = upload_data_iter->value;
+          forms[i+1].option = CURLFORM_END;
+
+          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                      "Adding formdata for %s (len=%lld)\n",
+                      upload_data_iter->key,
+                      upload_data_iter->total_bytes);
+
+          curl_formadd(&ctask->httppost, &ctask->httppost_last,
+                       CURLFORM_COPYNAME, upload_data_iter->key,
+                       CURLFORM_CONTENTSLENGTH, upload_data_iter->total_bytes,
+                       CURLFORM_ARRAY, forms,
+                       CURLFORM_END);
+        }
+        curl_easy_setopt (ctask->curl, CURLOPT_HTTPPOST,
+                          ctask->httppost);
+
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "MHD: Adding new curl task for %s\n", ctask->host);
+
+        GNUNET_GNS_get_authority (gns_handle,
+                                  ctask->host,
+                                  &process_get_authority,
+                                  ctask);
+        ctask->ready_to_queue = GNUNET_YES;
+        ctask->fin = GNUNET_NO;
+        ctask->curl_running = GNUNET_YES;
+        ctask->post_done = GNUNET_YES;
+        return MHD_YES;
+      }
+
+      fin_post = GNUNET_malloc (sizeof (struct ProxyUploadData));
+      GNUNET_CONTAINER_DLL_insert_tail (ctask->upload_data_head,
+                                        ctask->upload_data_tail,
+                                        fin_post);
+      ctask->post_done = GNUNET_YES;
+      return MHD_YES;
+    }
+  }
   
   if (GNUNET_YES != ctask->ready_to_queue)
     return MHD_YES; /* wait longer */
@@ -1625,11 +2156,15 @@ run_httpds ()
 {
   struct MhdHttpList *hd;
 
-  for (hd=mhd_httpd_head; hd != NULL; hd = hd->next)
+  for (hd=mhd_httpd_head; NULL != hd; hd = hd->next)
     run_httpd (hd);
 
 }
 
+
+#define UNSIGNED_MHD_LONG_LONG unsigned MHD_LONG_LONG
+
+
 /**
  * schedule mhd
  *
@@ -1646,7 +2181,7 @@ run_httpd (struct MhdHttpList *hd)
   struct GNUNET_NETWORK_FDSet *wes;
   int max;
   int haveto;
-  unsigned MHD_LONG_LONG timeout;
+  UNSIGNED_MHD_LONG_LONG timeout;
   struct GNUNET_TIME_Relative tv;
 
   FD_ZERO (&rs);
@@ -1664,7 +2199,7 @@ run_httpd (struct MhdHttpList *hd)
   
   haveto = MHD_get_timeout (hd->daemon, &timeout);
 
-  if (haveto == MHD_YES)
+  if (MHD_YES == haveto)
     tv.rel_value = (uint64_t) timeout;
   else
     tv = GNUNET_TIME_UNIT_FOREVER_REL;
@@ -1672,7 +2207,7 @@ run_httpd (struct MhdHttpList *hd)
   GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
   GNUNET_NETWORK_fdset_copy_native (wes, &es, max + 1);
   
-  if (hd->httpd_task != GNUNET_SCHEDULER_NO_TASK)
+  if (GNUNET_SCHEDULER_NO_TASK != hd->httpd_task)
     GNUNET_SCHEDULER_cancel (hd->httpd_task);
   hd->httpd_task =
     GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
@@ -1704,7 +2239,6 @@ do_httpd (void *cls,
 }
 
 
-
 /**
  * Read data from socket
  *
@@ -1714,6 +2248,7 @@ do_httpd (void *cls,
 static void
 do_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
+
 /**
  * Read from remote end
  *
@@ -1723,6 +2258,7 @@ do_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 static void
 do_read_remote (void* cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
+
 /**
  * Write data to remote socket
  *
@@ -1749,12 +2285,11 @@ do_write_remote (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   else
   {
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "write remote");
-    //Really!?!?!?
-    if (s5r->rtask != GNUNET_SCHEDULER_NO_TASK)
+    if (GNUNET_SCHEDULER_NO_TASK != s5r->rtask)
       GNUNET_SCHEDULER_cancel (s5r->rtask);
-    if (s5r->wtask != GNUNET_SCHEDULER_NO_TASK)
+    if (GNUNET_SCHEDULER_NO_TASK != s5r->wtask)
       GNUNET_SCHEDULER_cancel (s5r->wtask);
-    if (s5r->fwdrtask != GNUNET_SCHEDULER_NO_TASK)
+    if (GNUNET_SCHEDULER_NO_TASK != s5r->fwdrtask)
       GNUNET_SCHEDULER_cancel (s5r->fwdrtask);
     GNUNET_NETWORK_socket_close (s5r->remote_sock);
     GNUNET_NETWORK_socket_close (s5r->sock);
@@ -1777,13 +2312,12 @@ do_write_remote (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 cleanup_s5r (struct Socks5Request *s5r)
 {
-  if (s5r->rtask != GNUNET_SCHEDULER_NO_TASK)
+  if (GNUNET_SCHEDULER_NO_TASK != s5r->rtask)
     GNUNET_SCHEDULER_cancel (s5r->rtask);
-  if (s5r->fwdwtask != GNUNET_SCHEDULER_NO_TASK)
+  if (GNUNET_SCHEDULER_NO_TASK != s5r->fwdwtask)
     GNUNET_SCHEDULER_cancel (s5r->fwdwtask);
-  if (s5r->fwdrtask != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (s5r->fwdrtask);
-  
+  if (GNUNET_SCHEDULER_NO_TASK != s5r->fwdrtask)
+    GNUNET_SCHEDULER_cancel (s5r->fwdrtask);  
   if (NULL != s5r->remote_sock)
     GNUNET_NETWORK_socket_close (s5r->remote_sock);
   if ((NULL != s5r->sock) && (s5r->cleanup_sock == GNUNET_YES))
@@ -1792,6 +2326,7 @@ cleanup_s5r (struct Socks5Request *s5r)
   GNUNET_free(s5r);
 }
 
+
 /**
  * Write data to socket
  *
@@ -1816,13 +2351,11 @@ do_write (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                 len);
   }
   else
-  {
-    
+  {    
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "write");
     s5r->cleanup = GNUNET_YES;
     s5r->cleanup_sock = GNUNET_YES;
-    cleanup_s5r (s5r);
-    
+    cleanup_s5r (s5r); 
     return;
   }
 
@@ -1840,6 +2373,7 @@ do_write (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                      &do_read_remote, s5r);
 }
 
+
 /**
  * Read from remote end
  *
@@ -1852,8 +2386,6 @@ do_read_remote (void* cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct Socks5Request *s5r = cls;
   
   s5r->fwdrtask = GNUNET_SCHEDULER_NO_TASK;
-
-
   if ((NULL != tc->write_ready) &&
       (GNUNET_NETWORK_fdset_isset (tc->read_ready, s5r->remote_sock)) &&
       (s5r->wbuf_len = GNUNET_NETWORK_socket_recv (s5r->remote_sock, s5r->wbuf,
@@ -1865,7 +2397,7 @@ do_read_remote (void* cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   }
   else
   {
-    if (s5r->wbuf_len == 0)
+    if (0 == s5r->wbuf_len)
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "0 bytes received from remote... graceful shutdown!\n");
     if (s5r->fwdwtask != GNUNET_SCHEDULER_NO_TASK)
@@ -1883,8 +2415,7 @@ do_read_remote (void* cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   
   s5r->wtask = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                                s5r->sock,
-                                               &do_write, s5r);
-  
+                                               &do_write, s5r);  
 }
 
 
@@ -1909,18 +2440,19 @@ add_handle_to_mhd (struct GNUNET_NETWORK_Handle *h, struct MHD_Daemon *daemon)
   return MHD_add_connection (daemon, fd, addr, len);
 }
 
+
 /**
  * Read file in filename
  *
  * @param filename file to read
  * @param size pointer where filesize is stored
- * @return data
+ * @return NULL on error
  */
-static char*
+static void*
 load_file (const char* filename, 
           unsigned int* size)
 {
-  char *buffer;
+  void *buffer;
   uint64_t fsize;
 
   if (GNUNET_OK !=
@@ -1953,7 +2485,7 @@ load_key_from_file (gnutls_x509_privkey_t key, const char* keyfile)
   gnutls_datum_t key_data;
   int ret;
 
-  key_data.data = (unsigned char*) load_file (keyfile, &key_data.size);
+  key_data.data = load_file (keyfile, &key_data.size);
   ret = gnutls_x509_privkey_import (key, &key_data,
                                     GNUTLS_X509_FMT_PEM);
   if (GNUTLS_E_SUCCESS != ret)
@@ -1979,10 +2511,9 @@ static int
 load_cert_from_file (gnutls_x509_crt_t crt, char* certfile)
 {
   gnutls_datum_t cert_data;
-  cert_data.data = NULL;
   int ret;
 
-  cert_data.data = (unsigned char*) load_file (certfile, &cert_data.size);
+  cert_data.data = load_file (certfile, &cert_data.size);
   ret = gnutls_x509_crt_import (crt, &cert_data,
                                 GNUTLS_X509_FMT_PEM);
   if (GNUTLS_E_SUCCESS != ret)
@@ -2005,7 +2536,6 @@ load_cert_from_file (gnutls_x509_crt_t crt, char* certfile)
 static struct ProxyGNSCertificate *
 generate_gns_certificate (const char *name)
 {
-
   int ret;
   unsigned int serial;
   size_t key_buf_size;
@@ -2021,12 +2551,7 @@ generate_gns_certificate (const char *name)
     GNUNET_break (0);
   }
 
-  ret = gnutls_x509_crt_set_key (request, proxy_ca.key);
-
-  if (GNUTLS_E_SUCCESS != ret)
-  {
-    GNUNET_break (0);
-  }
+  GNUNET_break (GNUTLS_E_SUCCESS == gnutls_x509_crt_set_key (request, proxy_ca.key));
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Generating cert\n");
 
@@ -2037,14 +2562,11 @@ generate_gns_certificate (const char *name)
   
   gnutls_x509_crt_set_dn_by_oid (request, GNUTLS_OID_X520_COUNTRY_NAME,
                                  0, "DE", 2);
-
   gnutls_x509_crt_set_dn_by_oid (request, GNUTLS_OID_X520_ORGANIZATION_NAME,
-                                 0, "GNUnet", 6);
-
+                                 0, "GADS", 4);
   gnutls_x509_crt_set_dn_by_oid (request, GNUTLS_OID_X520_COMMON_NAME,
                                  0, name, strlen (name));
-
-  ret = gnutls_x509_crt_set_version (request, 3);
+  GNUNET_break (GNUTLS_E_SUCCESS == gnutls_x509_crt_set_version (request, 3));
 
   ret = gnutls_rnd (GNUTLS_RND_NONCE, &serial, sizeof (serial));
 
@@ -2092,13 +2614,13 @@ generate_gns_certificate (const char *name)
 }
 
 
-/*
+/**
  * Accept policy for mhdaemons
  *
  * @param cls NULL
  * @param addr the sockaddr
  * @param addrlen the sockaddr length
- * @return MHD_NO if sockaddr is wrong or #conns too high
+ * @return MHD_NO if sockaddr is wrong or number of connections is too high
  */
 static int
 accept_cb (void* cls, const struct sockaddr *addr, socklen_t addrlen)
@@ -2131,7 +2653,7 @@ accept_cb (void* cls, const struct sockaddr *addr, socklen_t addrlen)
 static int
 add_handle_to_ssl_mhd (struct GNUNET_NETWORK_Handle *h, const char* domain)
 {
-  struct MhdHttpList *hd = NULL;
+  struct MhdHttpList *hd;
   struct ProxyGNSCertificate *pgc;
   struct NetworkHandleList *nh;
 
@@ -2152,19 +2674,36 @@ add_handle_to_ssl_mhd (struct GNUNET_NETWORK_Handle *h, const char* domain)
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "No previous SSL instance found... starting new one for %s\n",
                 domain);
-
-    hd->daemon = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_SSL, 4444,
-            &accept_cb, NULL,
-            &create_response, hd,
-            MHD_OPTION_LISTEN_SOCKET, GNUNET_NETWORK_get_fd (mhd_unix_socket),
-            MHD_OPTION_CONNECTION_LIMIT, MHD_MAX_CONNECTIONS,
-            MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
-            MHD_OPTION_NOTIFY_COMPLETED,
-            NULL, NULL,
-            MHD_OPTION_HTTPS_MEM_KEY, pgc->key,
-            MHD_OPTION_HTTPS_MEM_CERT, pgc->cert,
-            MHD_OPTION_END);
-
+#if HAVE_MHD_NO_LISTEN_SOCKET
+    hd->daemon = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_SSL | MHD_USE_NO_LISTEN_SOCKET,
+                                   0,
+                                   &accept_cb, NULL,
+                                   &create_response, hd,
+                                   MHD_OPTION_CONNECTION_LIMIT,
+                                   MHD_MAX_CONNECTIONS,
+                                  MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
+                                  MHD_OPTION_NOTIFY_COMPLETED, NULL, NULL,
+                                  MHD_OPTION_HTTPS_MEM_KEY, pgc->key,
+                                  MHD_OPTION_HTTPS_MEM_CERT, pgc->cert,
+                                  MHD_OPTION_URI_LOG_CALLBACK, &mhd_log_callback,
+                                  NULL,
+                                  MHD_OPTION_END);
+#else
+    hd->daemon = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_SSL,
+                                   4444 /* dummy port */,
+                                   &accept_cb, NULL,
+                                   &create_response, hd,
+                                  MHD_OPTION_LISTEN_SOCKET, GNUNET_NETWORK_get_fd (mhd_unix_socket),
+                                   MHD_OPTION_CONNECTION_LIMIT,
+                                   MHD_MAX_CONNECTIONS,
+                                  MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
+                                  MHD_OPTION_NOTIFY_COMPLETED, NULL, NULL,
+                                  MHD_OPTION_HTTPS_MEM_KEY, pgc->key,
+                                  MHD_OPTION_HTTPS_MEM_CERT, pgc->cert,
+                                  MHD_OPTION_URI_LOG_CALLBACK, &mhd_log_callback,
+                                  NULL,
+                                  MHD_OPTION_END);
+#endif
     GNUNET_assert (hd->daemon != NULL);
     hd->httpd_task = GNUNET_SCHEDULER_NO_TASK;
     
@@ -2182,7 +2721,6 @@ add_handle_to_ssl_mhd (struct GNUNET_NETWORK_Handle *h, const char* domain)
 }
 
 
-
 /**
  * Read data from incoming connection
  *
@@ -2197,7 +2735,6 @@ do_read (void* cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct socks5_server_hello *s_hello;
   struct socks5_client_request *c_req;
   struct socks5_server_response *s_resp;
-
   int ret;
   char domain[256];
   uint8_t dom_len;
@@ -2206,7 +2743,6 @@ do_read (void* cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   uint32_t remote_ip;
   struct sockaddr_in remote_addr;
   struct in_addr *r_sin_addr;
-
   struct NetworkHandleList *nh;
 
   s5r->rtask = GNUNET_SCHEDULER_NO_TASK;
@@ -2459,12 +2995,7 @@ do_read (void* cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                        s5r->remote_sock,
                                        &do_read_remote, s5r);
     }
-
-
   }
-
-  //GNUNET_CONTAINER_DLL_remove (s5conns.head, s5conns.tail, s5r);
-
 }
 
 
@@ -2508,7 +3039,6 @@ do_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   s5r->rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                               s5r->sock,
                                               &do_read, s5r);
-  //GNUNET_CONTAINER_DLL_insert (s5conns.head, s5conns.tail, s5r);
 }
 
 
@@ -2522,18 +3052,22 @@ static void
 do_shutdown (void *cls,
              const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-
   struct MhdHttpList *hd;
   struct MhdHttpList *tmp_hd;
   struct NetworkHandleList *nh;
   struct NetworkHandleList *tmp_nh;
   struct ProxyCurlTask *ctask;
   struct ProxyCurlTask *ctask_tmp;
+  struct ProxyUploadData *pdata;
   
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Shutting down...\n");
-
-  gnutls_global_deinit ();
+  if (NULL != local_gns_zone)
+    GNUNET_free (local_gns_zone); 
+  if (NULL != local_private_zone)
+    GNUNET_free (local_private_zone);
+  if (NULL != local_shorten_zone)
+    GNUNET_free (local_shorten_zone);
 
   if (GNUNET_SCHEDULER_NO_TASK != curl_download_task)
   {
@@ -2556,13 +3090,11 @@ do_shutdown (void *cls,
       GNUNET_SCHEDULER_cancel (hd->httpd_task);
       hd->httpd_task = GNUNET_SCHEDULER_NO_TASK;
     }
-
     if (NULL != hd->daemon)
     {
       MHD_stop_daemon (hd->daemon);
       hd->daemon = NULL;
     }
-
     for (nh = hd->socket_handles_head; nh != NULL; nh = tmp_nh)
     {
       tmp_nh = nh->next;
@@ -2600,11 +3132,25 @@ do_shutdown (void *cls,
     if (NULL != ctask->response)
       MHD_destroy_response (ctask->response);
 
+    pdata = ctask->upload_data_head;
 
+    //FIXME free pdata here
+    for (; pdata != NULL; pdata = ctask->upload_data_head)
+    {
+      GNUNET_CONTAINER_DLL_remove (ctask->upload_data_head,
+                                   ctask->upload_data_tail,
+                                   pdata);
+      GNUNET_free_non_null (pdata->filename);
+      GNUNET_free_non_null (pdata->content_type);
+      GNUNET_free_non_null (pdata->key);
+      GNUNET_free_non_null (pdata->value);
+      GNUNET_free (pdata);
+    }
     GNUNET_free (ctask);
   }
-
+  curl_multi_cleanup (curl_multi);
   GNUNET_GNS_disconnect (gns_handle);
+  gnutls_global_deinit ();
 }
 
 
@@ -2642,9 +3188,9 @@ static int
 load_local_zone_key (const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   char *keyfile;
-  struct GNUNET_CRYPTO_RsaPrivateKey *key = NULL;
+  struct GNUNET_CRYPTO_RsaPrivateKey *key;
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
-  struct GNUNET_CRYPTO_ShortHashCode *zone = NULL;
+  struct GNUNET_CRYPTO_ShortHashCode *zone;
   struct GNUNET_CRYPTO_ShortHashAsciiEncoded zonename;
 
   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
@@ -2665,73 +3211,79 @@ load_local_zone_key (const struct GNUNET_CONFIGURATION_Handle *cfg)
 
   key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
   GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
+  local_gns_zone = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_ShortHashCode));
   GNUNET_CRYPTO_short_hash(&pkey,
                            sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                           &local_gns_zone);
-  zone = &local_gns_zone;
+                           local_gns_zone);
+  zone = local_gns_zone;
   GNUNET_CRYPTO_short_hash_to_enc (zone, &zonename);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Using zone: %s!\n", &zonename);
   GNUNET_CRYPTO_rsa_key_free(key);
   GNUNET_free(keyfile);
-  
+  keyfile = NULL;
+
   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
                                                    "PRIVATE_ZONEKEY", &keyfile))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Unable to load private zone key config value!\n");
-    return GNUNET_NO;
   }
 
-  if (GNUNET_NO == GNUNET_DISK_file_test (keyfile))
+  if ((NULL != keyfile) && (GNUNET_NO == GNUNET_DISK_file_test (keyfile)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Unable to load private zone key %s!\n", keyfile);
     GNUNET_free(keyfile);
-    return GNUNET_NO;
   }
-
-  key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
-  GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
-  GNUNET_CRYPTO_short_hash(&pkey,
-                           sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                           &local_private_zone);
-  GNUNET_CRYPTO_short_hash_to_enc (zone, &zonename);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Using private zone: %s!\n", &zonename);
-  GNUNET_CRYPTO_rsa_key_free(key);
-  GNUNET_free(keyfile);
+  else
+  {
+    key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+    GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
+    local_private_zone = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_ShortHashCode));
+    GNUNET_CRYPTO_short_hash(&pkey,
+                             sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                             local_private_zone);
+    GNUNET_CRYPTO_short_hash_to_enc (zone, &zonename);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Using private zone: %s!\n", &zonename);
+    GNUNET_CRYPTO_rsa_key_free(key);
+    GNUNET_free(keyfile);
+  }
+  keyfile = NULL;
 
   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
                                                    "SHORTEN_ZONEKEY", &keyfile))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Unable to load shorten zone key config value!\n");
-    return GNUNET_NO;
   }
 
-  if (GNUNET_NO == GNUNET_DISK_file_test (keyfile))
+  if ((NULL != keyfile) && (GNUNET_NO == GNUNET_DISK_file_test (keyfile)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Unable to load shorten zone key %s!\n", keyfile);
     GNUNET_free(keyfile);
-    return GNUNET_NO;
   }
-
-  key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
-  GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
-  GNUNET_CRYPTO_short_hash(&pkey,
-                           sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                           &local_shorten_zone);
-  GNUNET_CRYPTO_short_hash_to_enc (zone, &zonename);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Using shorten zone: %s!\n", &zonename);
-  GNUNET_CRYPTO_rsa_key_free(key);
-  GNUNET_free(keyfile);
+  else
+  {
+    key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+    GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
+    local_shorten_zone = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_ShortHashCode));
+    GNUNET_CRYPTO_short_hash(&pkey,
+                             sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                             local_shorten_zone);
+    GNUNET_CRYPTO_short_hash_to_enc (zone, &zonename);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Using shorten zone: %s!\n", &zonename);
+    GNUNET_CRYPTO_rsa_key_free(key);
+    GNUNET_free(keyfile);
+  }
 
   return GNUNET_YES;
 }
 
+
 /**
  * Main function that will be run
  *
@@ -2746,24 +3298,29 @@ run (void *cls, char *const *args, const char *cfgfile,
 {
   struct sockaddr_in sa;
   struct MhdHttpList *hd;
-  struct sockaddr_un mhd_unix_sock_addr;
-  size_t len;
-  char* proxy_sockfile;
   char* cafile_cfg = NULL;
   char* cafile;
+#if !HAVE_MHD_NO_LISTEN_SOCKET
+  size_t len;
+  char* proxy_sockfile;
+  struct sockaddr_un mhd_unix_sock_addr;
+#endif
 
-  curl_multi = NULL;
-
+  if (NULL == (curl_multi = curl_multi_init ()))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to create cURL multo handle!\n");
+    return;
+  }
+  
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               "Loading CA\n");
-  
   cafile = cafile_opt;
-
   if (NULL == cafile)
   {
     if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns-proxy",
-                                                          "PROXY_CACERT",
-                                                          &cafile_cfg))
+                                                             "PROXY_CACERT",
+                                                             &cafile_cfg))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   "Unable to load proxy CA config value!\n");
@@ -2773,9 +3330,10 @@ run (void *cls, char *const *args, const char *cfgfile,
     }
     cafile = cafile_cfg;
   }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Using %s as CA\n", cafile);
   
   gnutls_global_init ();
-
   gnutls_x509_crt_init (&proxy_ca.cert);
   gnutls_x509_privkey_init (&proxy_ca.key);
   
@@ -2793,19 +3351,16 @@ run (void *cls, char *const *args, const char *cfgfile,
   
   compile_regex (&re_dotplus, (char*) RE_A_HREF);
 
-  gns_handle = GNUNET_GNS_connect (cfg);
-
-  if (GNUNET_NO == load_local_zone_key (cfg))
+  if (NULL == (gns_handle = GNUNET_GNS_connect (cfg)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unable to load zone!\n");
+                "Unable to connect to GNS!\n");
     return;
   }
-
-  if (NULL == gns_handle)
+  if (GNUNET_NO == load_local_zone_key (cfg))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unable to connect to GNS!\n");
+                "Unable to load zone!\n");
     return;
   }
 
@@ -2840,13 +3395,9 @@ run (void *cls, char *const *args, const char *cfgfile,
                 GNUNET_a2s ((const struct sockaddr *) &sa, sizeof (sa)));
     return;
   }
-
   ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                          lsock, &do_accept, NULL);
 
-  ctasks_head = NULL;
-  ctasks_tail = NULL;
-
   if (0 != curl_global_init (CURL_GLOBAL_WIN32))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -2857,11 +3408,7 @@ run (void *cls, char *const *args, const char *cfgfile,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Proxy listens on port %u\n",
               port);
-
-  mhd_httpd_head = NULL;
-  mhd_httpd_tail = NULL;
-  total_mhd_connections = 0;
-
+#if ! HAVE_MHD_NO_LISTEN_SOCKET
   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns-proxy",
                                                             "PROXY_UNIXPATH",
                                                             &proxy_sockfile))
@@ -2870,12 +3417,9 @@ run (void *cls, char *const *args, const char *cfgfile,
                 "Specify PROXY_UNIXPATH in gns-proxy config section!\n");
     return;
   }
-  
-  mhd_unix_socket = GNUNET_NETWORK_socket_create (AF_UNIX,
-                                                SOCK_STREAM,
-                                                0);
-
-  if (NULL == mhd_unix_socket)
+  if (NULL == (mhd_unix_socket = GNUNET_NETWORK_socket_create (AF_UNIX,
+                                                              SOCK_STREAM,
+                                                              0)))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Unable to create unix domain socket!\n");
@@ -2893,7 +3437,6 @@ run (void *cls, char *const *args, const char *cfgfile,
 #endif
 
   len = strlen (proxy_sockfile) + sizeof(AF_UNIX);
-
   GNUNET_free (proxy_sockfile);
 
   if (GNUNET_OK != GNUNET_NETWORK_socket_bind (mhd_unix_socket,
@@ -2912,31 +3455,43 @@ run (void *cls, char *const *args, const char *cfgfile,
                 "Unable to listen on unix domain socket!\n");
     return;
   }
+#endif
 
   hd = GNUNET_malloc (sizeof (struct MhdHttpList));
   hd->is_ssl = GNUNET_NO;
   strcpy (hd->domain, "");
-  httpd = MHD_start_daemon (MHD_USE_DEBUG, 4444, //Dummy port
-            &accept_cb, NULL,
-            &create_response, hd,
-            MHD_OPTION_LISTEN_SOCKET, GNUNET_NETWORK_get_fd (mhd_unix_socket),
-            MHD_OPTION_CONNECTION_LIMIT, MHD_MAX_CONNECTIONS,
-            MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
-            MHD_OPTION_NOTIFY_COMPLETED,
-            NULL, NULL,
-            MHD_OPTION_END);
-
-  GNUNET_assert (httpd != NULL);
+
+#if HAVE_MHD_NO_LISTEN_SOCKET
+  httpd = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_NO_LISTEN_SOCKET,
+                            0,
+                           &accept_cb, NULL,
+                           &create_response, hd,
+                           MHD_OPTION_CONNECTION_LIMIT, MHD_MAX_CONNECTIONS,
+                           MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
+                           MHD_OPTION_NOTIFY_COMPLETED,
+                           NULL, NULL,
+                           MHD_OPTION_URI_LOG_CALLBACK, &mhd_log_callback, NULL,
+                           MHD_OPTION_END);
+#else
+  httpd = MHD_start_daemon (MHD_USE_DEBUG,
+                           4444 /* Dummy port */,
+                           &accept_cb, NULL,
+                           &create_response, hd,
+                           MHD_OPTION_LISTEN_SOCKET, GNUNET_NETWORK_get_fd (mhd_unix_socket),
+                           MHD_OPTION_CONNECTION_LIMIT, MHD_MAX_CONNECTIONS,
+                           MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
+                           MHD_OPTION_NOTIFY_COMPLETED,
+                           NULL, NULL,
+                           MHD_OPTION_URI_LOG_CALLBACK, &mhd_log_callback, NULL,
+                           MHD_OPTION_END);
+#endif
+  GNUNET_break (httpd != NULL);
   hd->daemon = httpd;
   hd->httpd_task = GNUNET_SCHEDULER_NO_TASK;
-
   GNUNET_CONTAINER_DLL_insert (mhd_httpd_head, mhd_httpd_tail, hd);
-
   run_httpds ();
-
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
                                 &do_shutdown, NULL);
-
 }
 
 
@@ -2952,20 +3507,17 @@ main (int argc, char *const *argv)
 {
   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
     {'p', "port", NULL,
-     gettext_noop ("listen on specified port"), 1,
-     &GNUNET_GETOPT_set_string, &port},
+     gettext_noop ("listen on specified port (default: 7777)"), 1,
+     &GNUNET_GETOPT_set_ulong, &port},
     {'a', "authority", NULL,
       gettext_noop ("pem file to use as CA"), 1,
       &GNUNET_GETOPT_set_string, &cafile_opt},
     GNUNET_GETOPT_OPTION_END
   };
-
   int ret;
 
   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
-
-
   GNUNET_log_setup ("gnunet-gns-proxy", "WARNING", NULL);
   ret =
       (GNUNET_OK ==
@@ -2973,11 +3525,8 @@ main (int argc, char *const *argv)
                            _("GNUnet GNS proxy"),
                            options,
                            &run, NULL)) ? 0 : 1;
-  GNUNET_free_non_null ((char*)argv);
-
+  GNUNET_free_non_null ((char *) argv);
   return ret;
 }
 
-
-
-
+/* end of gnunet-gns-proxy.c */