OWEALs
/
gnunet
mirror of https://gnunet.org/git/gnunet.git


			
							12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470
							/*
     This file is part of GNUnet
     Copyright (C) 2002-2014 Christian Grothoff (and other contributing authors)

     GNUnet is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published
     by the Free Software Foundation; either version 3, or (at your
     option) any later version.

     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with GNUnet; see the file COPYING.  If not, write to the
     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
*/

/**
 * @file transport/plugin_transport_http_server.c
 * @brief HTTP/S server transport plugin
 * @author Matthias Wachs
 * @author David Barksdale
 * @author Christian Grothoff
 */
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_plugin.h"
#include "gnunet_nat_lib.h"
#include "plugin_transport_http_common.h"
#include <microhttpd.h>
#include <regex.h>


#if BUILD_HTTPS
#define PLUGIN_NAME "https_server"
#define LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_https_server_init
#define LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_https_server_done
#else
#define PLUGIN_NAME "http_server"
#define LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_http_server_init
#define LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_http_server_done
#endif

#define HTTP_ERROR_RESPONSE "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\"><HTML><HEAD><TITLE>404 Not Found</TITLE></HEAD><BODY><H1>Not Found</H1>The requested URL was not found on this server.<P><HR><ADDRESS></ADDRESS></BODY></HTML>"
#define _RECEIVE 0
#define _SEND 1


#define LOG(kind,...) GNUNET_log_from (kind, "transport-" PLUGIN_NAME,__VA_ARGS__)


/**
 * Information we keep with MHD for an HTTP request.
 */
struct ServerRequest
{
  /**
   * The session this server request belongs to
   * Can be NULL, when session was disconnected and freed
   */
  struct Session *session;

  /**
   * The MHD connection
   */
  struct MHD_Connection *mhd_conn;

  /**
   * The MHD daemon
   */
  struct MHD_Daemon *mhd_daemon;

  /**
   * Options requested by peer
   */
  uint32_t options;
#define OPTION_LONG_POLL 1 /* GET request wants long-poll semantics */

  /**
   * _RECV or _SEND
   */
  int direction;

  /**
   * For PUT requests: Is this the first or last callback with size 0
   * For GET requests: Have we sent a message
   */
  int connected;

};


/**
 * Wrapper to manage addresses
 */
struct HttpAddressWrapper
{
  /**
   * Linked list next
   */
  struct HttpAddressWrapper *next;

  /**
   * Linked list previous
   */
  struct HttpAddressWrapper *prev;

  /**
   * An address we are using.
   */
  struct HttpAddress *address;

  /**
   * Length of the address.
   */
  size_t addrlen;
};


/**
 *  Message to send using http
 */
struct HTTP_Message
{
  /**
   * next pointer for double linked list
   */
  struct HTTP_Message *next;

  /**
   * previous pointer for double linked list
   */
  struct HTTP_Message *prev;

  /**
   * buffer containing data to send
   */
  char *buf;

  /**
   * amount of data already sent
   */
  size_t pos;

  /**
   * buffer length
   */
  size_t size;

  /**
   * HTTP/S specific overhead
   */
  size_t overhead;

  /**
   * Continuation function to call once the transmission buffer
   * has again space available.  NULL if there is no
   * continuation to call.
   */
  GNUNET_TRANSPORT_TransmitContinuation transmit_cont;

  /**
   * Closure for transmit_cont.
   */
  void *transmit_cont_cls;
};


/**
 * Session handle for connections.
 */
struct Session
{

  /**
   * To whom are we talking to (set to our identity
   * if we are still waiting for the welcome message)
   */
  struct GNUNET_PeerIdentity target;

  /**
   * Pointer to the global plugin struct.
   */
  struct HTTP_Server_Plugin *plugin;

  /**
   * next pointer for double linked list
   */
  struct HTTP_Message *msg_head;

  /**
   * previous pointer for double linked list
   */
  struct HTTP_Message *msg_tail;

  /**
   * Message stream tokenizer for incoming data
   */
  struct GNUNET_SERVER_MessageStreamTokenizer *msg_tk;

  /**
   * Client recv handle
   */
  struct ServerRequest *server_recv;

  /**
   * Client send handle
   */
  struct ServerRequest *server_send;

  /**
   * Address
   */
  struct GNUNET_HELLO_Address *address;

  /**
   * Absolute time when to receive data again
   * Used for receive throttling
   */
  struct GNUNET_TIME_Absolute next_receive;

  /**
   * Absolute time when this connection will time out.
   */
  struct GNUNET_TIME_Absolute timeout;

  /**
   * Session timeout task
   */
  struct GNUNET_SCHEDULER_Task * timeout_task;

  /**
   * Task to resume MHD handling when receiving is allowed again
   */
  struct GNUNET_SCHEDULER_Task * recv_wakeup_task;

  /**
   * Number of bytes waiting for transmission to this peer.
   */
  unsigned long long bytes_in_queue;

  /**
   * Number of messages waiting for transmission to this peer.
   */
  unsigned int msgs_in_queue;

  /**
   * Unique HTTP/S connection tag for this connection
   */
  uint32_t tag;

  /**
   * ATS network type.
   */
  enum GNUNET_ATS_Network_Type scope;

  /**
   * #GNUNET_YES if this session is known to the service.
   */
  int known_to_service;

};


/**
 * Encapsulation of all of the state of the plugin.
 */
struct HTTP_Server_Plugin
{
  /**
   * Our environment.
   */
  struct GNUNET_TRANSPORT_PluginEnvironment *env;

  /**
   * Hash map of open sessions.
   */
  struct GNUNET_CONTAINER_MultiPeerMap *sessions;

  /**
   * Function to call about session status changes.
   */
  GNUNET_TRANSPORT_SessionInfoCallback sic;

  /**
   * Closure for @e sic.
   */
  void *sic_cls;

  /**
   * Plugin name
   */
  char *name;

  /**
   * Protocol
   */
  char *protocol;

  /**
   * External address
   */
  char *external_hostname;

  /**
   * External hostname the plugin can be connected to, can be different to
   * the host's FQDN, used e.g. for reverse proxying
   */
  struct GNUNET_HELLO_Address *ext_addr;

  /**
   * NAT handle & address management
   */
  struct GNUNET_NAT_Handle *nat;

  /**
   * IPv4 addresses DLL head
   */
  struct HttpAddressWrapper *addr_head;

  /**
   * IPv4 addresses DLL tail
   */
  struct HttpAddressWrapper *addr_tail;

  /**
   * IPv4 server socket to bind to
   */
  struct sockaddr_in *server_addr_v4;

  /**
   * IPv6 server socket to bind to
   */
  struct sockaddr_in6 *server_addr_v6;

  /**
   * MHD IPv4 daemon
   */
  struct MHD_Daemon *server_v4;

  /**
   * MHD IPv4 daemon
   */
  struct MHD_Daemon *server_v6;

#if BUILD_HTTPS
  /**
   * Crypto related
   *
   * Example:
   *
   * Use RC4-128 instead of AES:
   * NONE:+VERS-TLS1.0:+ARCFOUR-128:+SHA1:+RSA:+COMP-NULL
   *
   */
  char *crypto_init;

  /**
   * TLS key
   */
  char *key;

  /**
   * TLS certificate
   */
  char *cert;
#endif

  /**
   * MHD IPv4 task
   */
  struct GNUNET_SCHEDULER_Task * server_v4_task;

  /**
   * MHD IPv6 task
   */
  struct GNUNET_SCHEDULER_Task * server_v6_task;

  /**
   * Task calling transport service about external address
   */
  struct GNUNET_SCHEDULER_Task * notify_ext_task;

  /**
   * Notify transport only about external address
   */
  unsigned int external_only;

  /**
   * The IPv4 server is scheduled to run asap
   */
  int server_v4_immediately;

  /**
   * The IPv6 server is scheduled to run asap
   */
  int server_v6_immediately;

  /**
   * Verify external address
   */
  int verify_external_hostname;

  /**
   * Maximum number of sockets the plugin can use
   * Each http request /request connections are two connections
   */
  unsigned int max_request;

  /**
   * Current number of sockets the plugin can use
   * Each http connection are two requests
   */
  unsigned int cur_request;

  /**
   * Did we immediately end the session in disconnect_cb
   */
  int in_shutdown;

  /**
   * Length of peer id
   */
  int peer_id_length;

  /**
   * My options to be included in the address
   */
  uint32_t options;

  /**
   * use IPv6
   */
  uint16_t use_ipv6;

  /**
   * use IPv4
   */
  uint16_t use_ipv4;

  /**
   * Port used
   */
  uint16_t port;

  /**
   * Regex for parsing URLs. FIXME: this seems overkill.
   */
  regex_t url_regex;

};


/**
 * If a session monitor is attached, notify it about the new
 * session state.
 *
 * @param plugin our plugin
 * @param session session that changed state
 * @param state new state of the session
 */
static void
notify_session_monitor (struct HTTP_Server_Plugin *plugin,
                        struct Session *session,
                        enum GNUNET_TRANSPORT_SessionState state)
{
  struct GNUNET_TRANSPORT_SessionInfo info;

  if (NULL == plugin->sic)
    return;
  memset (&info, 0, sizeof (info));
  info.state = state;
  info.is_inbound = GNUNET_YES;
  info.num_msg_pending = session->msgs_in_queue;
  info.num_bytes_pending = session->bytes_in_queue;
  info.receive_delay = session->next_receive;
  info.session_timeout = session->timeout;
  info.address = session->address;
  plugin->sic (plugin->sic_cls,
               session,
               &info);
}


/**
 * Wake up an MHD connection which was suspended
 *
 * @param cls the session
 * @param tc task context
 */
static void
server_wake_up (void *cls,
                const struct GNUNET_SCHEDULER_TaskContext *tc)
{
  struct Session *s = cls;

  s->recv_wakeup_task = NULL;
  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
    return;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Session %p: Waking up PUT handle\n",
       s);
  MHD_resume_connection (s->server_recv->mhd_conn);
}


/**
 * Reschedule the execution of both IPv4 and IPv6 server.
 *
 * @param plugin the plugin
 * @param server which server to schedule v4 or v6?
 * @param now #GNUNET_YES to schedule execution immediately, #GNUNET_NO to wait
 * until timeout
 */
static void
server_reschedule (struct HTTP_Server_Plugin *plugin,
                   struct MHD_Daemon *server,
                   int now);


/**
 * Deletes the session.  Must not be used afterwards.
 *
 * @param s the session to delete
 */
static void
server_delete_session (struct Session *s)
{
  struct HTTP_Server_Plugin *plugin = s->plugin;
  struct HTTP_Message *msg;

  if (NULL != s->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (s->timeout_task);
    s->timeout_task = NULL;
    s->timeout = GNUNET_TIME_UNIT_ZERO_ABS;
  }
  if (NULL != s->recv_wakeup_task)
  {
    GNUNET_SCHEDULER_cancel (s->recv_wakeup_task);
    s->recv_wakeup_task = NULL;
    if (NULL != s->server_recv)
      MHD_resume_connection (s->server_recv->mhd_conn);
  }
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multipeermap_remove (plugin->sessions,
                                                       &s->target,
                                                       s));
  while (NULL != (msg = s->msg_head))
  {
    GNUNET_CONTAINER_DLL_remove (s->msg_head,
                                 s->msg_tail,
                                 msg);
    if (NULL != msg->transmit_cont)
      msg->transmit_cont (msg->transmit_cont_cls,
                          &s->target,
                          GNUNET_SYSERR,
                          msg->size,
                          msg->pos + msg->overhead);
    GNUNET_assert (s->msgs_in_queue > 0);
    s->msgs_in_queue--;
    GNUNET_assert (s->bytes_in_queue >= msg->size);
    s->bytes_in_queue -= msg->size;
    GNUNET_free (msg);
  }

  GNUNET_assert (0 == s->msgs_in_queue);
  GNUNET_assert (0 == s->bytes_in_queue);

  if (NULL != s->server_send)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Server: %p / %p Terminating inbound PUT session to peer `%s'\n",
         s, s->server_send,
         GNUNET_i2s (&s->target));
    s->server_send->session = NULL;
    MHD_set_connection_option (s->server_send->mhd_conn,
                               MHD_CONNECTION_OPTION_TIMEOUT,
                               1 /* 0 = no timeout, so this is MIN */);
    server_reschedule (plugin, s->server_send->mhd_daemon, GNUNET_YES);
  }

  if (NULL != s->server_recv)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Server: %p / %p Terminating inbound GET session to peer `%s'\n",
         s, s->server_recv, GNUNET_i2s (&s->target));
    s->server_recv->session = NULL;
    MHD_set_connection_option (s->server_recv->mhd_conn,
                               MHD_CONNECTION_OPTION_TIMEOUT,
                               1 /* 0 = no timeout, so this is MIN */);
    server_reschedule (plugin, s->server_recv->mhd_daemon, GNUNET_YES);
  }
  notify_session_monitor (plugin,
                          s,
                          GNUNET_TRANSPORT_SS_DONE);
  if (GNUNET_YES == s->known_to_service)
  {
    plugin->env->session_end (plugin->env->cls,
                              s->address,
                              s);
    s->known_to_service = GNUNET_NO;
  }
  if (NULL != s->msg_tk)
  {
    GNUNET_SERVER_mst_destroy (s->msg_tk);
    s->msg_tk = NULL;
  }
  GNUNET_HELLO_address_free (s->address);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Session %p destroyed\n",
       s);

  GNUNET_free (s);
}


/**
 * Disconnect session @a s by telling MHD to close the
 * connections (reducing timeout, etc.).
 *
 * @param cls closure with the `struct HTTP_Server_Plugin`
 * @param s the session
 * @return #GNUNET_OK on success
 */
static int
http_server_plugin_disconnect_session (void *cls,
                                       struct Session *s)
{
  server_delete_session (s);
  return GNUNET_OK;
}


/**
 * Session was idle, so disconnect it
 *
 * @param cls the session
 * @param tc task context
 */
static void
server_session_timeout (void *cls,
                        const struct GNUNET_SCHEDULER_TaskContext *tc)
{
  struct Session *s = cls;
  struct GNUNET_TIME_Relative left;

  s->timeout_task = NULL;
  left = GNUNET_TIME_absolute_get_remaining (s->timeout);
  if (0 != left.rel_value_us)
  {
    /* not actually our turn yet, but let's at least update
       the monitor, it may think we're about to die ... */
    notify_session_monitor (s->plugin,
                            s,
                            GNUNET_TRANSPORT_SS_UP);
    s->timeout_task = GNUNET_SCHEDULER_add_delayed (left,
                                                    &server_session_timeout,
                                                    s);
    return;
  }
  GNUNET_log (TIMEOUT_LOG,
              "Session %p was idle for %s, disconnecting\n",
              s,
	      GNUNET_STRINGS_relative_time_to_string (HTTP_SERVER_SESSION_TIMEOUT,
						      GNUNET_YES));
  server_delete_session (s);
}


/**
 * Increment session timeout due to activity session @a s
 *
 * @param s the session
 */
static void
server_reschedule_session_timeout (struct Session *s)
{
 GNUNET_assert (NULL != s->timeout_task);
  s->timeout = GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
}


/**
 * Function that can be used by the transport service to transmit
 * a message using the plugin.   Note that in the case of a
 * peer disconnecting, the continuation MUST be called
 * prior to the disconnect notification itself.  This function
 * will be called with this peer's HELLO message to initiate
 * a fresh connection to another peer.
 *
 * @param cls closure
 * @param session which session must be used
 * @param msgbuf the message to transmit
 * @param msgbuf_size number of bytes in @a msgbuf
 * @param priority how important is the message (most plugins will
 *                 ignore message priority and just FIFO)
 * @param to how long to wait at most for the transmission (does not
 *                require plugins to discard the message after the timeout,
 *                just advisory for the desired delay; most plugins will ignore
 *                this as well)
 * @param cont continuation to call once the message has
 *        been transmitted (or if the transport is ready
 *        for the next transmission call; or if the
 *        peer disconnected...); can be NULL
 * @param cont_cls closure for @a cont
 * @return number of bytes used (on the physical network, with overheads);
 *         -1 on hard errors (i.e. address invalid); 0 is a legal value
 *         and does NOT mean that the message was not transmitted (DV)
 */
static ssize_t
http_server_plugin_send (void *cls,
                         struct Session *session,
                         const char *msgbuf,
                         size_t msgbuf_size,
                         unsigned int priority,
                         struct GNUNET_TIME_Relative to,
                         GNUNET_TRANSPORT_TransmitContinuation cont,
                         void *cont_cls)
{
  struct HTTP_Server_Plugin *plugin = cls;
  struct HTTP_Message *msg;
  ssize_t bytes_sent = 0;
  char *stat_txt;

  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Session %p/request %p: Sending message with %u to peer `%s'\n",
       session,
       session->server_send,
       msgbuf_size,
       GNUNET_i2s (&session->target));

  /* create new message and schedule */
  bytes_sent = sizeof (struct HTTP_Message) + msgbuf_size;
  msg = GNUNET_malloc (bytes_sent);
  msg->next = NULL;
  msg->size = msgbuf_size;
  msg->pos = 0;
  msg->buf = (char *) &msg[1];
  msg->transmit_cont = cont;
  msg->transmit_cont_cls = cont_cls;
  memcpy (msg->buf,
          msgbuf,
          msgbuf_size);
  GNUNET_CONTAINER_DLL_insert_tail (session->msg_head,
                                    session->msg_tail,
                                    msg);
  session->msgs_in_queue++;
  session->bytes_in_queue += msg->size;
  notify_session_monitor (plugin,
                          session,
                          GNUNET_TRANSPORT_SS_UP);
  GNUNET_asprintf (&stat_txt,
                   "# bytes currently in %s_server buffers",
                   plugin->protocol);
  GNUNET_STATISTICS_update (plugin->env->stats,
                            stat_txt, msgbuf_size, GNUNET_NO);
  GNUNET_free (stat_txt);

  if (NULL != session->server_send)
    server_reschedule (session->plugin,
                       session->server_send->mhd_daemon,
                       GNUNET_YES);
  return bytes_sent;
}


/**
 * Terminate session during shutdown.
 *
 * @param cls the `struct HTTP_Server_Plugin *`
 * @param peer for which this is a session
 * @param value the `struct Session` to clean up
 * @return #GNUNET_OK (continue to iterate)
 */
static int
destroy_session_shutdown_cb (void *cls,
                    const struct GNUNET_PeerIdentity *peer,
                    void *value)
{
  struct Session *s = value;
  struct ServerRequest *sc_send;
  struct ServerRequest *sc_recv;

  sc_send = s->server_send;
  sc_recv = s->server_recv;
  server_delete_session (s);

  GNUNET_free_non_null (sc_send);
  GNUNET_free_non_null (sc_recv);

  return GNUNET_OK;
}

/**
 * Terminate session.
 *
 * @param cls the `struct HTTP_Server_Plugin *`
 * @param peer for which this is a session
 * @param value the `struct Session` to clean up
 * @return #GNUNET_OK (continue to iterate)
 */
static int
destroy_session_cb (void *cls,
                    const struct GNUNET_PeerIdentity *peer,
                    void *value)
{
  struct Session *s = value;

  server_delete_session (s);
  return GNUNET_OK;
}

/**
 * Function that can be used to force the plugin to disconnect
 * from the given peer and cancel all previous transmissions
 * (and their continuationc).
 *
 * @param cls closure
 * @param target peer from which to disconnect
 */
static void
http_server_plugin_disconnect_peer (void *cls,
                                    const struct GNUNET_PeerIdentity *target)
{
  struct HTTP_Server_Plugin *plugin = cls;

  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Transport tells me to disconnect `%s'\n",
       GNUNET_i2s (target));
  GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessions,
                                              target,
                                              &destroy_session_cb,
                                              plugin);
}


/**
 * Another peer has suggested an address for this
 * peer and transport plugin.  Check that this could be a valid
 * address.  If so, consider adding it to the list
 * of addresses.
 *
 * @param cls closure
 * @param addr pointer to the address
 * @param addrlen length of @a addr
 * @return #GNUNET_OK if this is a plausible address for this peer
 *         and transport
 */
static int
http_server_plugin_address_suggested (void *cls,
                                      const void *addr,
                                      size_t addrlen)
{
  struct HTTP_Server_Plugin *plugin = cls;
  struct HttpAddressWrapper *next;
  struct HttpAddressWrapper *pos;
  const struct HttpAddress *haddr = addr;

  if ((NULL != plugin->ext_addr) &&
      GNUNET_YES == (http_common_cmp_addresses (addr, addrlen,
                                                plugin->ext_addr->address,
                                                plugin->ext_addr->address_length)))
  {
    /* Checking HTTP_OPTIONS_VERIFY_CERTIFICATE option for external hostname */
    if ((ntohl (haddr->options) & HTTP_OPTIONS_VERIFY_CERTIFICATE) !=
        (plugin->options & HTTP_OPTIONS_VERIFY_CERTIFICATE))
      return GNUNET_NO; /* VERIFY option not set as required! */
    return GNUNET_OK;
  }
  next  = plugin->addr_head;
  while (NULL != (pos = next))
  {
    next = pos->next;
    if (GNUNET_YES == (http_common_cmp_addresses(addr,
                                                 addrlen,
                                                 pos->address,
                                                 pos->addrlen)))
      return GNUNET_OK;
  }
  return GNUNET_NO;
}


/**
 * Creates a new outbound session the transport
 * service will use to send data to the peer.
 *
 * Since HTTP/S server cannot create sessions, always returns NULL.
 *
 * @param cls the plugin
 * @param address the address
 * @return always NULL
 */
static struct Session *
http_server_plugin_get_session (void *cls,
                                const struct GNUNET_HELLO_Address *address)
{
  return NULL;
}


/**
 * Call MHD IPv4 to process pending requests and then go back
 * and schedule the next run.
 *
 * @param cls plugin as closure
 * @param tc task context
 */
static void
server_v4_run (void *cls,
               const struct GNUNET_SCHEDULER_TaskContext *tc)
{
  struct HTTP_Server_Plugin *plugin = cls;

  plugin->server_v4_task = NULL;
  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
    return;
  plugin->server_v4_immediately = GNUNET_NO;
  GNUNET_assert (MHD_YES == MHD_run (plugin->server_v4));
  server_reschedule (plugin, plugin->server_v4, GNUNET_NO);
}


/**
 * Call MHD IPv6 to process pending requests and then go back
 * and schedule the next run.
 *
 * @param cls plugin as closure
 * @param tc task context
 */
static void
server_v6_run (void *cls,
               const struct GNUNET_SCHEDULER_TaskContext *tc)
{
  struct HTTP_Server_Plugin *plugin = cls;

  plugin->server_v6_task = NULL;
  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
    return;
  plugin->server_v6_immediately = GNUNET_NO;
  GNUNET_assert (MHD_YES == MHD_run (plugin->server_v6));
  server_reschedule (plugin, plugin->server_v6, GNUNET_NO);
}


/**
 * Function that queries MHD's select sets and
 * starts the task waiting for them.
 *
 * @param plugin plugin
 * @param daemon_handle the MHD daemon handle
 * @param now schedule now
 * @return gnunet task identifier
 */
static struct GNUNET_SCHEDULER_Task *
server_schedule (struct HTTP_Server_Plugin *plugin,
                 struct MHD_Daemon *daemon_handle,
                 int now)
{
  struct GNUNET_SCHEDULER_Task * ret;
  fd_set rs;
  fd_set ws;
  fd_set es;
  struct GNUNET_NETWORK_FDSet *wrs;
  struct GNUNET_NETWORK_FDSet *wws;
  int max;
  MHD_UNSIGNED_LONG_LONG timeout;
  static unsigned long long last_timeout = 0;
  int haveto;
  struct GNUNET_TIME_Relative tv;

  if (GNUNET_YES == plugin->in_shutdown)
    return NULL;

  ret = NULL;
  FD_ZERO (&rs);
  FD_ZERO (&ws);
  FD_ZERO (&es);
  wrs = GNUNET_NETWORK_fdset_create ();
  wws = GNUNET_NETWORK_fdset_create ();
  max = -1;
  GNUNET_assert (MHD_YES ==
                 MHD_get_fdset (daemon_handle,
                                &rs,
                                &ws,
                                &es,
                                &max));
  haveto = MHD_get_timeout (daemon_handle, &timeout);
  if (haveto == MHD_YES)
  {
    if (timeout != last_timeout)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "SELECT Timeout changed from %llu to %llu (ms)\n",
           last_timeout, timeout);
      last_timeout = timeout;
    }
    if (timeout <= GNUNET_TIME_UNIT_SECONDS.rel_value_us / 1000LL)
      tv.rel_value_us = (uint64_t) timeout * 1000LL;
    else
      tv = GNUNET_TIME_UNIT_SECONDS;
  }
  else
    tv = GNUNET_TIME_UNIT_SECONDS;
  /* Force immediate run, since we have outbound data to send */
  if (now == GNUNET_YES)
    tv = GNUNET_TIME_UNIT_MILLISECONDS;
  GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
  GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);

  if (daemon_handle == plugin->server_v4)
  {
    if (plugin->server_v4_task != NULL)
    {
      GNUNET_SCHEDULER_cancel (plugin->server_v4_task);
      plugin->server_v4_task = NULL;
    }
#if 0
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Scheduling IPv4 server task in %llu ms\n",
         tv);
#endif
    ret =
        GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                     tv, wrs, wws,
                                     &server_v4_run, plugin);
  }
  if (daemon_handle == plugin->server_v6)
  {
    if (plugin->server_v6_task != NULL)
    {
      GNUNET_SCHEDULER_cancel (plugin->server_v6_task);
      plugin->server_v6_task = NULL;
    }
#if 0
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Scheduling IPv6 server task in %llu ms\n", tv);
#endif
    ret =
        GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                     tv, wrs, wws,
                                     &server_v6_run, plugin);
  }
  GNUNET_NETWORK_fdset_destroy (wrs);
  GNUNET_NETWORK_fdset_destroy (wws);
  return ret;
}


/**
 * Reschedule the execution of both IPv4 and IPv6 server
 *
 * @param plugin the plugin
 * @param server which server to schedule v4 or v6?
 * @param now #GNUNET_YES to schedule execution immediately, #GNUNET_NO to wait
 * until timeout
 */
static void
server_reschedule (struct HTTP_Server_Plugin *plugin,
                   struct MHD_Daemon *server,
                   int now)
{
  if ((server == plugin->server_v4) && (plugin->server_v4 != NULL))
  {
    if (GNUNET_YES == plugin->server_v4_immediately)
      return; /* No rescheduling, server will run asap */

    if (GNUNET_YES == now)
      plugin->server_v4_immediately = GNUNET_YES;

    if (plugin->server_v4_task != NULL)
    {
      GNUNET_SCHEDULER_cancel (plugin->server_v4_task);
      plugin->server_v4_task = NULL;
    }
    plugin->server_v4_task = server_schedule (plugin, plugin->server_v4, now);
  }

  if ((server == plugin->server_v6) && (plugin->server_v6 != NULL))
  {
    if (GNUNET_YES == plugin->server_v6_immediately)
      return; /* No rescheduling, server will run asap */

    if (GNUNET_YES == now)
      plugin->server_v6_immediately = GNUNET_YES;

    if (plugin->server_v6_task != NULL)
    {
      GNUNET_SCHEDULER_cancel (plugin->server_v6_task);
      plugin->server_v6_task = NULL;
    }
    plugin->server_v6_task = server_schedule (plugin, plugin->server_v6, now);
  }
}


/**
 * Function that is called to get the keepalive factor.
 * GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT is divided by this number to
 * calculate the interval between keepalive packets.
 *
 * @param cls closure with the `struct HTTP_Server_Plugin`
 * @return keepalive factor
 */
static unsigned int
http_server_query_keepalive_factor (void *cls)
{
  return 3;
}


/**
 * Function that will be called whenever the transport service wants to
 * notify the plugin that a session is still active and in use and
 * therefore the session timeout for this session has to be updated
 *
 * @param cls closure
 * @param peer which peer was the session for
 * @param session which session is being updated
 */
static void
http_server_plugin_update_session_timeout (void *cls,
                                           const struct GNUNET_PeerIdentity *peer,
                                           struct Session *session)
{
  server_reschedule_session_timeout (session);
}


/**
 * Tell MHD that the connection should timeout after @a to seconds.
 *
 * @param plugin our plugin
 * @param s session for which the timeout changes
 * @param to timeout in seconds
 */
static void
server_mhd_connection_timeout (struct HTTP_Server_Plugin *plugin,
			       struct Session *s,
			       unsigned int to)
{
  /* Setting timeouts for other connections */
  if (NULL != s->server_recv)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Setting timeout for %p to %u sec.\n",
         s->server_recv, to);
    MHD_set_connection_option (s->server_recv->mhd_conn,
			       MHD_CONNECTION_OPTION_TIMEOUT,
			       to);
    server_reschedule (plugin, s->server_recv->mhd_daemon, GNUNET_NO);
  }
  if (NULL != s->server_send)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Setting timeout for %p to %u sec.\n",
         s->server_send, to);
    MHD_set_connection_option (s->server_send->mhd_conn,
			       MHD_CONNECTION_OPTION_TIMEOUT,
			       to);
    server_reschedule (plugin, s->server_send->mhd_daemon, GNUNET_NO);
  }
}


/**
 * Parse incoming URL for tag and target
 *
 * @param plugin plugin
 * @param url incoming url
 * @param target where to store the target
 * @param tag where to store the tag
 * @param options where to store the options
 * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
 */
static int
server_parse_url (struct HTTP_Server_Plugin *plugin,
		  const char *url,
		  struct GNUNET_PeerIdentity *target,
		  uint32_t *tag,
		  uint32_t *options)
{
  regmatch_t matches[4];
  const char *tag_start;
  const char *target_start;
  char *tag_end;
  char *options_end;
  size_t hash_length;
  unsigned long int rc;

  /* URL parsing */
#define URL_REGEX \
  ("^.*/([0-9A-Z]+);([0-9]+)(,[0-9]+)?$")

  if (NULL == url)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }

  if (regexec(&plugin->url_regex, url, 4, matches, 0))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "URL `%s' did not match regex\n", url);
    return GNUNET_SYSERR;
  }

  target_start = &url[matches[1].rm_so];
  tag_start = &url[matches[2].rm_so];

  /* convert tag */
  rc = strtoul (tag_start, &tag_end, 10);
  if (&url[matches[2].rm_eo] != tag_end)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "URL tag did not line up with submatch\n");
    return GNUNET_SYSERR;
  }
  if (rc == 0)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "URL tag is zero\n");
    return GNUNET_SYSERR;
  }
  if ((rc == ULONG_MAX) && (ERANGE == errno))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "URL tag > ULONG_MAX\n");
    return GNUNET_SYSERR;
  }
  if (rc > UINT32_MAX)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "URL tag > UINT32_MAX\n");
    return GNUNET_SYSERR;
  }
  (*tag) = (uint32_t)rc;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Found tag `%u' in url\n",
       *tag);

  /* convert peer id */
  hash_length = matches[1].rm_eo - matches[1].rm_so;
  if (hash_length != plugin->peer_id_length)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "URL target is %u bytes, expecting %u\n",
         hash_length, plugin->peer_id_length);
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK !=
      GNUNET_CRYPTO_eddsa_public_key_from_string (target_start,
						     hash_length,
						     &target->public_key))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "URL target conversion failed\n");
    return GNUNET_SYSERR;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Found target `%s' in URL\n",
       GNUNET_i2s_full (target));

  /* convert options */
  if (-1 == matches[3].rm_so)
  {
    *options = 0;
  }
  else
  {
    rc = strtoul (&url[matches[3].rm_so + 1], &options_end, 10);
    if (&url[matches[3].rm_eo] != options_end)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "URL options did not line up with submatch\n");
      return GNUNET_SYSERR;
    }
    if ((rc == ULONG_MAX) && (ERANGE == errno))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "URL options > ULONG_MAX\n");
      return GNUNET_SYSERR;
    }
    if (rc > UINT32_MAX)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "URL options > UINT32_MAX\n");
      return GNUNET_SYSERR;
    }
    (*options) = (uint32_t) rc;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Found options `%u' in url\n",
         *options);
  }
  return GNUNET_OK;
}


/**
 * Closure for #session_tag_it().
 */
struct SessionTagContext
{
  /**
   * Set to session matching the tag.
   */
  struct Session *res;

  /**
   * Tag we are looking for.
   */
  uint32_t tag;
};


/**
 * Find a session with a matching tag.
 *
 * @param cls the `struct SessionTagContext *`
 * @param key peer identity (unused)
 * @param value the `struct Session *`
 * @return #GNUNET_NO if we found the session, #GNUNET_OK if not
 */
static int
session_tag_it (void *cls,
                const struct GNUNET_PeerIdentity *key,
                void *value)
{
  struct SessionTagContext *stc = cls;
  struct Session *s = value;

  if (s->tag == stc->tag)
  {
    stc->res = s;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}


/**
 * Lookup a mhd connection and create one if none is found
 *
 * @param plugin the plugin handle
 * @param mhd_connection the incoming mhd_connection
 * @param url incoming requested URL
 * @param method PUT or GET
 * @return the server connecetion
 */
static struct ServerRequest *
server_lookup_connection (struct HTTP_Server_Plugin *plugin,
                          struct MHD_Connection *mhd_connection,
                          const char *url,
                          const char *method)
{
  struct Session *s = NULL;
  struct ServerRequest *sc = NULL;
  const union MHD_ConnectionInfo *conn_info;
  struct HttpAddress *addr;
  struct GNUNET_PeerIdentity target;
  size_t addr_len;
  struct SessionTagContext stc;
  uint32_t options;
  int direction = GNUNET_SYSERR;
  unsigned int to;
  enum GNUNET_ATS_Network_Type scope;

  conn_info = MHD_get_connection_info (mhd_connection,
                                       MHD_CONNECTION_INFO_CLIENT_ADDRESS);
  if ((conn_info->client_addr->sa_family != AF_INET) &&
      (conn_info->client_addr->sa_family != AF_INET6))
    return NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "New %s request from %s\n",
       method,
       url);
  stc.tag = 0;
  if (GNUNET_SYSERR ==
      server_parse_url (plugin, url, &target, &stc.tag, &options))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Invalid url %s\n", url);
    return NULL;
  }
  if (0 == strcmp (MHD_HTTP_METHOD_PUT, method))
    direction = _RECEIVE;
  else if (0 == strcmp (MHD_HTTP_METHOD_GET, method))
    direction = _SEND;
  else
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Invalid method %s for request from %s\n",
         method, url);
    return NULL;
  }

  plugin->cur_request++;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "New %s request from %s with tag %u (%u of %u)\n",
       method,
       GNUNET_i2s (&target),
       stc.tag,
       plugin->cur_request, plugin->max_request);
  /* find existing session */
  stc.res = NULL;
  GNUNET_CONTAINER_multipeermap_get_multiple (plugin->sessions,
                                              &target,
                                              &session_tag_it,
                                              &stc);
  if (NULL == (s = stc.res))
  {
    /* create new session */
    addr = NULL;
    switch (conn_info->client_addr->sa_family)
    {
    case (AF_INET):
      addr = http_common_address_from_socket (plugin->protocol,
                                              conn_info->client_addr,
                                              sizeof (struct sockaddr_in));
      addr_len = http_common_address_get_size (addr);
      scope = plugin->env->get_address_type (plugin->env->cls,
                                             conn_info->client_addr,
                                             sizeof (struct sockaddr_in));
      break;
    case (AF_INET6):
      addr = http_common_address_from_socket (plugin->protocol,
                                              conn_info->client_addr,
                                              sizeof (struct sockaddr_in6));
      addr_len = http_common_address_get_size (addr);
      scope = plugin->env->get_address_type (plugin->env->cls,
                                             conn_info->client_addr,
                                             sizeof (struct sockaddr_in6));
      break;
    default:
      /* external host name */
      return NULL;
    }
    s = GNUNET_new (struct Session);
    s->target = target;
    s->plugin = plugin;
    s->scope = scope;
    s->address = GNUNET_HELLO_address_allocate (&s->target,
                                                PLUGIN_NAME,
                                                addr,
                                                addr_len,
                                                GNUNET_HELLO_ADDRESS_INFO_INBOUND);
    s->next_receive = GNUNET_TIME_UNIT_ZERO_ABS;
    s->tag = stc.tag;
    s->timeout = GNUNET_TIME_relative_to_absolute (HTTP_SERVER_SESSION_TIMEOUT);
    s->timeout_task = GNUNET_SCHEDULER_add_delayed (HTTP_SERVER_SESSION_TIMEOUT,
                                                    &server_session_timeout,
                                                    s);
    (void) GNUNET_CONTAINER_multipeermap_put (plugin->sessions,
                                              &s->target,
                                              s,
                                              GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
    notify_session_monitor (plugin,
                            s,
                            GNUNET_TRANSPORT_SS_INIT);
    notify_session_monitor (plugin,
                            s,
                            GNUNET_TRANSPORT_SS_HANDSHAKE);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Creating new session %p for peer `%s' connecting from `%s'\n",
         s, GNUNET_i2s (&target),
         http_common_plugin_address_to_string (plugin->protocol,
                                               addr,
                                               addr_len));
    GNUNET_free_non_null (addr);
  }

  if ( (_RECEIVE == direction) &&
       (NULL != s->server_recv) )
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Duplicate PUT request from `%s' tag %u, dismissing new request\n",
         GNUNET_i2s (&target),
         stc.tag);
    return NULL;
  }
  if ((_SEND == direction) && (NULL != s->server_send))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Duplicate GET request from `%s' tag %u, dismissing new request\n",
         GNUNET_i2s (&target),
         stc.tag);
    return NULL;
  }
  sc = GNUNET_new (struct ServerRequest);
  if (conn_info->client_addr->sa_family == AF_INET)
    sc->mhd_daemon = plugin->server_v4;
  if (conn_info->client_addr->sa_family == AF_INET6)
    sc->mhd_daemon = plugin->server_v6;
  sc->mhd_conn = mhd_connection;
  sc->direction = direction;
  sc->connected = GNUNET_NO;
  sc->session = s;
  sc->options = options;
  if (direction == _SEND)
  {
    s->server_send = sc;
  }
  if (direction == _RECEIVE)
  {
    s->server_recv = sc;
  }

  if ((GNUNET_NO == s->known_to_service) &&
      (NULL != s->server_send) &&
      (NULL != s->server_recv) )
  {
    s->known_to_service = GNUNET_YES;
    notify_session_monitor (plugin,
                            s,
                            GNUNET_TRANSPORT_SS_UP);
    plugin->env->session_start (plugin->env->cls,
                                s->address,
                                s,
                                s->scope);
  }

  if ( (NULL == s->server_recv) ||
       (NULL == s->server_send) )
  {
    to = (HTTP_SERVER_NOT_VALIDATED_TIMEOUT.rel_value_us / 1000LL / 1000LL);
    MHD_set_connection_option (mhd_connection,
			       MHD_CONNECTION_OPTION_TIMEOUT, to);
    server_reschedule (plugin, sc->mhd_daemon, GNUNET_NO);
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Session %p for peer `%s' fully connected\n",
         s, GNUNET_i2s (&target));
    to = (HTTP_SERVER_SESSION_TIMEOUT.rel_value_us / 1000LL / 1000LL);
    server_mhd_connection_timeout (plugin, s, to);
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Setting timeout for %p to %u sec.\n", sc, to);
  return sc;
}


/**
 * Callback called by MHD when it needs data to send
 *
 * @param cls current session
 * @param pos position in buffer
 * @param buf the buffer to write data to
 * @param max max number of bytes available in @a buf
 * @return bytes written to @a buf
 */
static ssize_t
server_send_callback (void *cls,
                      uint64_t pos,
                      char *buf,
                      size_t max)
{
  struct ServerRequest *sc = cls;
  struct Session *s = sc->session;
  ssize_t bytes_read = 0;
  struct HTTP_Message *msg;
  char *stat_txt;

  if (NULL == s)
  {
    /* session is disconnecting */
    return 0;
  }

  sc = s->server_send;
  if (NULL == sc)
    return 0;
  msg = s->msg_head;
  if (NULL != msg)
  {
    /* sending */
    bytes_read = GNUNET_MIN (msg->size - msg->pos,
                             max);
    memcpy (buf, &msg->buf[msg->pos], bytes_read);
    msg->pos += bytes_read;

    /* removing message */
    if (msg->pos == msg->size)
    {
      GNUNET_CONTAINER_DLL_remove (s->msg_head,
                                   s->msg_tail,
                                   msg);
      if (NULL != msg->transmit_cont)
        msg->transmit_cont (msg->transmit_cont_cls, &s->target, GNUNET_OK,
                            msg->size, msg->size + msg->overhead);
      GNUNET_assert (s->msgs_in_queue > 0);
      s->msgs_in_queue--;
      GNUNET_assert (s->bytes_in_queue >= msg->size);
      s->bytes_in_queue -= msg->size;
      GNUNET_free (msg);
      notify_session_monitor (s->plugin,
                              s,
                              GNUNET_TRANSPORT_SS_UPDATE);
    }
  }
  if (0 < bytes_read)
  {
    sc->connected = GNUNET_YES;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Sent %u bytes to peer `%s' with session %p \n",
         bytes_read,
         GNUNET_i2s (&s->target),
         s);
    GNUNET_asprintf (&stat_txt,
                     "# bytes currently in %s_server buffers",
                     s->plugin->protocol);
    GNUNET_STATISTICS_update (s->plugin->env->stats,
                              stat_txt,
                              - bytes_read,
                              GNUNET_NO);
    GNUNET_free (stat_txt);
    GNUNET_asprintf (&stat_txt,
                     "# bytes transmitted via %s_server",
                     s->plugin->protocol);
    GNUNET_STATISTICS_update (s->plugin->env->stats,
                              stat_txt, bytes_read, GNUNET_NO);
    GNUNET_free (stat_txt);
  }
  else if ((sc->options & OPTION_LONG_POLL) && sc->connected)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Completing GET response to peer `%s' with session %p\n",
         GNUNET_i2s (&s->target),
         s);
    return MHD_CONTENT_READER_END_OF_STREAM;
  }
  return bytes_read;
}


/**
 * Callback called by MessageStreamTokenizer when a message has arrived
 *
 * @param cls current session as closure
 * @param client client
 * @param message the message to be forwarded to transport service
 * @return #GNUNET_OK
 */
static int
server_receive_mst_cb (void *cls,
                       void *client,
                       const struct GNUNET_MessageHeader *message)
{
  struct Session *s = cls;
  struct HTTP_Server_Plugin *plugin = s->plugin;
  struct GNUNET_TIME_Relative delay;
  char *stat_txt;

  if (GNUNET_NO == s->known_to_service)
  {
    s->known_to_service = GNUNET_YES;
    plugin->env->session_start (plugin->env->cls,
                                s->address,
                                s,
                                s->scope);
    notify_session_monitor (plugin,
                            s,
                            GNUNET_TRANSPORT_SS_UP);
  }
  delay = plugin->env->receive (plugin->env->cls,
                                s->address,
                                s,
                                message);
  GNUNET_asprintf (&stat_txt,
                   "# bytes received via %s_server",
                   plugin->protocol);
  GNUNET_STATISTICS_update (plugin->env->stats,
                            stat_txt, ntohs (message->size), GNUNET_NO);
  GNUNET_free (stat_txt);
  s->next_receive = GNUNET_TIME_relative_to_absolute (delay);
  if (delay.rel_value_us > 0)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Peer `%s' address `%s' next read delayed for %s\n",
         GNUNET_i2s (&s->target),
         http_common_plugin_address_to_string (plugin->protocol,
                                               s->address->address,
                                               s->address->address_length),
         GNUNET_STRINGS_relative_time_to_string (delay,
                                                 GNUNET_YES));
  }
  server_reschedule_session_timeout (s);
  return GNUNET_OK;
}


/**
 * Add headers to a request indicating that we allow Cross-Origin Resource
 * Sharing.
 *
 * @param response response object to modify
 */
static void
add_cors_headers(struct MHD_Response *response)
{
  MHD_add_response_header (response,
                           "Access-Control-Allow-Origin",
                           "*");
  MHD_add_response_header (response,
                           "Access-Control-Allow-Methods",
                           "GET, PUT, OPTIONS");
  MHD_add_response_header (response,
                           "Access-Control-Max-Age",
                           "86400");
}


/**
 * MHD callback for a new incoming connection
 *
 * @param cls the plugin handle
 * @param mhd_connection the mhd connection
 * @param url the requested URL
 * @param method GET or PUT
 * @param version HTTP version
 * @param upload_data upload data
 * @param upload_data_size size of @a upload_data
 * @param httpSessionCache the session cache to remember the connection
 * @return MHD_YES if connection is accepted, MHD_NO on reject
 */
static int
server_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 HTTP_Server_Plugin *plugin = cls;
  struct ServerRequest *sc = *httpSessionCache;
  struct Session *s;
  struct MHD_Response *response;
  int res = MHD_YES;

  LOG (GNUNET_ERROR_TYPE_DEBUG,
       _("Access from connection %p (%u of %u) for `%s' `%s' url `%s' with upload data size %u\n"),
       sc,
       plugin->cur_request,
       plugin->max_request,
       method,
       version,
       url,
       (*upload_data_size));
  if (NULL == sc)
  {
    /* CORS pre-flight request */
    if (0 == strcmp (MHD_HTTP_METHOD_OPTIONS, method))
    {
      response = MHD_create_response_from_buffer (0, NULL,
          MHD_RESPMEM_PERSISTENT);
      add_cors_headers(response);
      res = MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
      MHD_destroy_response (response);
      return res;
    }
    /* new connection */
    sc = server_lookup_connection (plugin, mhd_connection, url, method);
    if (NULL != sc)
    {
      /* attach to new / existing session */
      (*httpSessionCache) = sc;
    }
    else
    {
      /* existing session already has matching connection, refuse */
      response = MHD_create_response_from_data (strlen (HTTP_ERROR_RESPONSE),
                                                HTTP_ERROR_RESPONSE,
                                                MHD_NO,
                                                MHD_NO);
      MHD_add_response_header (response,
			       MHD_HTTP_HEADER_CONTENT_TYPE,
			       "text/html");
      add_cors_headers(response);
      res = MHD_queue_response (mhd_connection, MHD_HTTP_NOT_FOUND, response);
      MHD_destroy_response (response);
      return res;
    }
  }
  /* 'old' connection */
  if (NULL == (s = sc->session))
  {
    /* Session was already disconnected;
       sent HTTP/1.1: 200 OK as response */
    response = MHD_create_response_from_data (strlen ("Thank you!"),
        "Thank you!", MHD_NO, MHD_NO);
    add_cors_headers(response);
    MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
    MHD_destroy_response (response);
    return MHD_YES;
  }

  if (sc->direction == _SEND)
  {
    response = MHD_create_response_from_callback (MHD_SIZE_UNKNOWN, 32 * 1024,
        &server_send_callback, sc, NULL);
    add_cors_headers(response);
    MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
    MHD_destroy_response (response);
    return MHD_YES;
  }
  if (sc->direction == _RECEIVE)
  {
    if ((*upload_data_size == 0) && (sc->connected == GNUNET_NO))
    {
      /* (*upload_data_size == 0) first callback when header are passed */
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Session %p / Connection %p: Peer `%s' PUT on address `%s' connected\n",
           s, sc,
           GNUNET_i2s (&s->target),
           http_common_plugin_address_to_string (plugin->protocol,
                                                 s->address->address,
                                                 s->address->address_length));
      sc->connected = GNUNET_YES;
      return MHD_YES;
    }
    else if ((*upload_data_size == 0) && (sc->connected == GNUNET_YES))
    {
      /* (*upload_data_size == 0) when upload is complete */
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Session %p / Connection %p: Peer `%s' PUT on address `%s' finished upload\n",
           s, sc,
           GNUNET_i2s (&s->target),
           http_common_plugin_address_to_string (plugin->protocol,
                                                 s->address->address,
                                                 s->address->address_length));
      sc->connected = GNUNET_NO;
      /* Sent HTTP/1.1: 200 OK as PUT Response\ */
      response = MHD_create_response_from_data (strlen ("Thank you!"),
          "Thank you!", MHD_NO, MHD_NO);
      add_cors_headers(response);
      MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
      MHD_destroy_response (response);
      return MHD_YES;
    }
    else if ((*upload_data_size > 0) && (sc->connected == GNUNET_YES))
    {
      struct GNUNET_TIME_Relative delay;

      /* (*upload_data_size > 0) for every segment received */
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Session %p / Connection %p: Peer `%s' PUT on address `%s' received %u bytes\n",
           s, sc,
           GNUNET_i2s (&s->target),
           http_common_plugin_address_to_string (plugin->protocol,
                                                 s->address->address,
                                                 s->address->address_length),
           *upload_data_size);
      delay = GNUNET_TIME_absolute_get_remaining (s->next_receive);
      if (0 == delay.rel_value_us)
      {
        LOG (GNUNET_ERROR_TYPE_DEBUG,
             "PUT with %u bytes forwarded to MST\n",
             *upload_data_size);
        if (s->msg_tk == NULL)
        {
          s->msg_tk = GNUNET_SERVER_mst_create (&server_receive_mst_cb, s);
        }
        GNUNET_SERVER_mst_receive (s->msg_tk, s, upload_data, *upload_data_size,
            GNUNET_NO, GNUNET_NO);
        server_mhd_connection_timeout (plugin, s,
            GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value_us / 1000LL
                / 1000LL);
        (*upload_data_size) = 0;
      }
      else
      {
        /* delay processing */
        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
            "Session %p / Connection %p: no inbound bandwidth available! Next read was delayed by %s\n",
            s, sc, GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES));
        GNUNET_assert(s->server_recv->mhd_conn == mhd_connection);
        MHD_suspend_connection (s->server_recv->mhd_conn);
        if (NULL == s->recv_wakeup_task)
          s->recv_wakeup_task = GNUNET_SCHEDULER_add_delayed (delay,
              &server_wake_up, s);
      }
      return MHD_YES;
    }
    else
    {
      GNUNET_break (0);
      return MHD_NO;
    }
  }
  return res;
}


/**
 * Callback from MHD when a connection disconnects
 *
 * @param cls closure with the `struct HTTP_Server_Plugin *`
 * @param connection the disconnected MHD connection
 * @param httpSessionCache the pointer to distinguish
 */
static void
server_disconnect_cb (void *cls,
                      struct MHD_Connection *connection,
                      void **httpSessionCache)
{
  struct HTTP_Server_Plugin *plugin = cls;
  struct ServerRequest *sc = *httpSessionCache;

  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Disconnect for connection %p\n",
       sc);
  if (NULL == sc)
  {
    /* CORS pre-flight request finished */
    return;
  }

  if (NULL != sc->session)
  {
    if (sc->direction == _SEND)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Peer `%s' connection  %p, GET on address `%s' disconnected\n",
           GNUNET_i2s (&sc->session->target),
           sc->session->server_send,
           http_common_plugin_address_to_string (plugin->protocol,
               sc->session->address->address,
               sc->session->address->address_length));

      sc->session->server_send = NULL;
    }
    else if (sc->direction == _RECEIVE)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Peer `%s' connection %p PUT on address `%s' disconnected\n",
           GNUNET_i2s (&sc->session->target),
           sc->session->server_recv,
           http_common_plugin_address_to_string (plugin->protocol,
               sc->session->address->address,
               sc->session->address->address_length));
      sc->session->server_recv = NULL;
      if (NULL != sc->session->msg_tk)
      {
        GNUNET_SERVER_mst_destroy (sc->session->msg_tk);
        sc->session->msg_tk = NULL;
      }
    }
  }
  GNUNET_free (sc);
  plugin->cur_request--;
}


/**
 * Check if incoming connection is accepted.
 *
 * @param cls plugin as closure
 * @param addr address of incoming connection
 * @param addr_len number of bytes in @a addr
 * @return MHD_YES if connection is accepted, MHD_NO if connection is rejected
 */
static int
server_accept_cb (void *cls,
                  const struct sockaddr *addr,
                  socklen_t addr_len)
{
  struct HTTP_Server_Plugin *plugin = cls;

  if (plugin->cur_request <= plugin->max_request)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         _("Accepting connection (%u of %u) from `%s'\n"),
         plugin->cur_request, plugin->max_request,
         GNUNET_a2s (addr, addr_len));
    return MHD_YES;
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         _("Server reached maximum number connections (%u), rejecting new connection\n"),
         plugin->max_request);
    return MHD_NO;
  }
}


/**
 * Log function called by MHD.
 *
 * @param arg NULL
 * @param fmt format string
 * @param ap arguments for the format string (va_start() and va_end()
 *           will be called by MHD)
 */
static void
server_log (void *arg,
            const char *fmt,
            va_list ap)
{
  char text[1024];

  vsnprintf (text,
             sizeof (text),
             fmt,
             ap);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Server: %s\n",
              text);
}


#if BUILD_HTTPS
/**
 * Load ssl certificate from file
 *
 * @param file filename
 * @return content of the file
 */
static char *
server_load_file (const char *file)
{
  struct GNUNET_DISK_FileHandle *gn_file;
  uint64_t fsize;
  char *text = NULL;

  if (GNUNET_OK != GNUNET_DISK_file_size (file,
      &fsize, GNUNET_NO, GNUNET_YES))
    return NULL;
  text = GNUNET_malloc (fsize + 1);
  gn_file =
      GNUNET_DISK_file_open (file, GNUNET_DISK_OPEN_READ,
                             GNUNET_DISK_PERM_USER_READ);
  if (NULL == gn_file)
  {
    GNUNET_free (text);
    return NULL;
  }
  if (GNUNET_SYSERR == GNUNET_DISK_file_read (gn_file, text, fsize))
  {
    GNUNET_free (text);
    GNUNET_DISK_file_close (gn_file);
    return NULL;
  }
  text[fsize] = '\0';
  GNUNET_DISK_file_close (gn_file);
  return text;
}
#endif


#if BUILD_HTTPS
/**
 * Load ssl certificate
 *
 * @param plugin the plugin
 * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
 */
static int
server_load_certificate (struct HTTP_Server_Plugin *plugin)
{
  int res = GNUNET_OK;
  char *key_file;
  char *cert_file;


  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (plugin->env->cfg,
                                               plugin->name,
                                               "KEY_FILE", &key_file))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               plugin->name, "CERT_FILE");
    return GNUNET_SYSERR;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (plugin->env->cfg,
                                               plugin->name,
                                               "CERT_FILE", &cert_file))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               plugin->name, "CERT_FILE");
    GNUNET_free (key_file);
    return GNUNET_SYSERR;
  }
  /* Get crypto init string from config. If not present, use
   * default values */
  if (GNUNET_OK ==
      GNUNET_CONFIGURATION_get_value_string (plugin->env->cfg,
                                             plugin->name,
                                             "CRYPTO_INIT",
                                             &plugin->crypto_init))
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Using crypto init string `%s'\n",
         plugin->crypto_init);
  else
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Using default crypto init string \n");

  /* read key & certificates from file */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Trying to loading TLS certificate from key-file `%s' cert-file`%s'\n",
              key_file, cert_file);

  plugin->key = server_load_file (key_file);
  plugin->cert = server_load_file (cert_file);

  if ((plugin->key == NULL) || (plugin->cert == NULL))
  {
    struct GNUNET_OS_Process *cert_creation;

    GNUNET_free_non_null (plugin->key);
    plugin->key = NULL;
    GNUNET_free_non_null (plugin->cert);
    plugin->cert = NULL;

    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "No usable TLS certificate found, creating certificate\n");
    errno = 0;
    cert_creation =
        GNUNET_OS_start_process (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
                                 NULL, NULL, NULL,
                                 "gnunet-transport-certificate-creation",
                                 "gnunet-transport-certificate-creation",
                                 key_file,
                                 cert_file,
                                 NULL);
    if (NULL == cert_creation)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _("Could not create a new TLS certificate, program `gnunet-transport-certificate-creation' could not be started!\n"));
      GNUNET_free (key_file);
      GNUNET_free (cert_file);

      GNUNET_free_non_null (plugin->key);
      plugin->key = NULL;
      GNUNET_free_non_null (plugin->cert);
      plugin->cert = NULL;
      GNUNET_free_non_null (plugin->crypto_init);
      plugin->crypto_init = NULL;

      return GNUNET_SYSERR;
    }
    GNUNET_assert (GNUNET_OK == GNUNET_OS_process_wait (cert_creation));
    GNUNET_OS_process_destroy (cert_creation);

    plugin->key = server_load_file (key_file);
    plugin->cert = server_load_file (cert_file);
  }

  if ((plugin->key == NULL) || (plugin->cert == NULL))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _("No usable TLS certificate found and creating one at `%s/%s' failed!\n"),
         key_file, cert_file);
    GNUNET_free (key_file);
    GNUNET_free (cert_file);

    GNUNET_free_non_null (plugin->key);
    plugin->key = NULL;
    GNUNET_free_non_null (plugin->cert);
    plugin->cert = NULL;
    GNUNET_free_non_null (plugin->crypto_init);
    plugin->crypto_init = NULL;

    return GNUNET_SYSERR;
  }
  GNUNET_free (key_file);
  GNUNET_free (cert_file);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "TLS certificate loaded\n");
  return res;
}
#endif


/**
 * Invoke `MHD_start_daemon` with the various options we need to
 * setup the HTTP server with the given listen address.
 *
 * @param plugin our plugin
 * @param addr listen address to use
 * @param v6 MHD_NO_FLAG or MHD_USE_IPv6, depending on context
 * @return NULL on error
 */
static struct MHD_Daemon *
run_mhd_start_daemon (struct HTTP_Server_Plugin *plugin,
                      const struct sockaddr_in *addr,
                      int v6)
{
  struct MHD_Daemon *server;
  unsigned int timeout;

#if MHD_VERSION >= 0x00090E00
  timeout = HTTP_SERVER_NOT_VALIDATED_TIMEOUT.rel_value_us / 1000LL / 1000LL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "MHD can set timeout per connection! Default time out %u sec.\n",
       timeout);
#else
  timeout = HTTP_SERVER_SESSION_TIMEOUT.rel_value_us / 1000LL / 1000LL;
  LOG (GNUNET_ERROR_TYPE_WARNING,
       "MHD cannot set timeout per connection! Default time out %u sec.\n",
       timeout);
#endif
  server = MHD_start_daemon (
#if VERBOSE_SERVER
                             MHD_USE_DEBUG |
#endif
#if BUILD_HTTPS
                             MHD_USE_SSL |
#endif
                             MHD_USE_SUSPEND_RESUME |
                             v6,
                             plugin->port,
                             &server_accept_cb, plugin,
                             &server_access_cb, plugin,
                             MHD_OPTION_SOCK_ADDR,
                             addr,
                             MHD_OPTION_CONNECTION_LIMIT,
                             (unsigned int) plugin->max_request,
#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,
                             timeout,
                             MHD_OPTION_CONNECTION_MEMORY_LIMIT,
                             (size_t) (2 *
                                       GNUNET_SERVER_MAX_MESSAGE_SIZE),
                             MHD_OPTION_NOTIFY_COMPLETED,
                             &server_disconnect_cb, plugin,
                             MHD_OPTION_EXTERNAL_LOGGER,
                             &server_log, NULL,
                             MHD_OPTION_END);
#ifdef TCP_STEALTH
  if ( (NULL != server) &&
       (0 != (plugin->options & HTTP_OPTIONS_TCP_STEALTH)) )
  {
    const union MHD_DaemonInfo *di;

    di = MHD_get_daemon_info (server,
                              MHD_DAEMON_INFO_LISTEN_FD,
                              NULL);
    if ( (0 != setsockopt ((int) di->listen_fd,
                           IPPROTO_TCP,
                           TCP_STEALTH,
                           plugin->env->my_identity,
                           sizeof (struct GNUNET_PeerIdentity))) )
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _("TCP_STEALTH not supported on this platform.\n"));
      MHD_stop_daemon (server);
      server = NULL;
    }
  }
#endif
  return server;
}


/**
 * Start the HTTP server
 *
 * @param plugin the plugin handle
 * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
 */
static int
server_start (struct HTTP_Server_Plugin *plugin)
{
  const char *msg;

  GNUNET_assert (NULL != plugin);
#if BUILD_HTTPS
  if (GNUNET_SYSERR == server_load_certificate (plugin))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _("Could not load or create server certificate! Loading plugin failed!\n"));
    return GNUNET_SYSERR;
  }
#endif


  plugin->server_v4 = NULL;
  if (GNUNET_YES == plugin->use_ipv4)
  {
    plugin->server_v4
      = run_mhd_start_daemon (plugin,
                              (const struct sockaddr_in *) plugin->server_addr_v4,
                              MHD_NO_FLAG);

    if (NULL == plugin->server_v4)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Failed to start %s IPv4 server component on port %u\n",
           plugin->name,
           plugin->port);
    }
    else
      server_reschedule (plugin,
                         plugin->server_v4,
                         GNUNET_NO);
  }


  plugin->server_v6 = NULL;
  if (GNUNET_YES == plugin->use_ipv6)
  {
    plugin->server_v6
      = run_mhd_start_daemon (plugin,
                              (const struct sockaddr_in *) plugin->server_addr_v6,
                              MHD_USE_IPv6);
    if (NULL == plugin->server_v6)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Failed to start %s IPv6 server component on port %u\n",
           plugin->name,
           plugin->port);
    }
    else
    {
      server_reschedule (plugin,
                         plugin->server_v6,
                         GNUNET_NO);
    }
  }
  msg = "No";
  if ( (NULL == plugin->server_v6) &&
       (NULL == plugin->server_v4) )
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "%s %s server component started on port %u\n",
         msg,
         plugin->name,
         plugin->port);
    return GNUNET_SYSERR;
  }
  if ((NULL != plugin->server_v6) &&
      (NULL != plugin->server_v4))
    msg = "IPv4 and IPv6";
  else if (NULL != plugin->server_v6)
    msg = "IPv6";
  else if (NULL != plugin->server_v4)
    msg = "IPv4";
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "%s %s server component started on port %u\n",
       msg,
       plugin->name,
       plugin->port);
  return GNUNET_OK;
}


/**
 * Add an address to the server's set of addresses and notify transport
 *
 * @param cls the plugin handle
 * @param add_remove #GNUNET_YES on add, #GNUNET_NO on remove
 * @param addr the address
 * @param addrlen address length
 */
static void
server_add_address (void *cls,
                    int add_remove,
                    const struct sockaddr *addr,
                    socklen_t addrlen)
{
  struct HTTP_Server_Plugin *plugin = cls;
  struct GNUNET_HELLO_Address *address;
  struct HttpAddressWrapper *w = NULL;

  w = GNUNET_new (struct HttpAddressWrapper);
  w->address = http_common_address_from_socket (plugin->protocol,
                                                addr,
                                                addrlen);
  if (NULL == w->address)
  {
    GNUNET_free (w);
    return;
  }
  w->addrlen = http_common_address_get_size (w->address);

  GNUNET_CONTAINER_DLL_insert (plugin->addr_head,
                               plugin->addr_tail,
                               w);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Notifying transport to add address `%s'\n",
       http_common_plugin_address_to_string (plugin->protocol,
                                             w->address,
                                             w->addrlen));
  /* modify our published address list */
#if BUILD_HTTPS
  address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
      "https_client", w->address, w->addrlen, GNUNET_HELLO_ADDRESS_INFO_NONE);
#else
  address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
      "http_client", w->address, w->addrlen, GNUNET_HELLO_ADDRESS_INFO_NONE);
#endif

  plugin->env->notify_address (plugin->env->cls,
                               add_remove,
                               address);
  GNUNET_HELLO_address_free (address);
}


/**
 * Remove an address from the server's set of addresses and notify transport
 *
 * @param cls the plugin handle
 * @param add_remove #GNUNET_YES on add, #GNUNET_NO on remove
 * @param addr the address
 * @param addrlen address length
 */
static void
server_remove_address (void *cls,
                       int add_remove,
                       const struct sockaddr *addr,
                       socklen_t addrlen)
{
  struct HTTP_Server_Plugin *plugin = cls;
  struct GNUNET_HELLO_Address *address;
  struct HttpAddressWrapper *w = plugin->addr_head;
  size_t saddr_len;
  void * saddr;

  saddr = http_common_address_from_socket (plugin->protocol,
                                           addr,
                                           addrlen);
  if (NULL == saddr)
    return;
  saddr_len = http_common_address_get_size (saddr);

  while (NULL != w)
  {
    if (GNUNET_YES ==
        http_common_cmp_addresses (w->address,
                                   w->addrlen,
                                   saddr,
                                   saddr_len))
      break;
    w = w->next;
  }
  GNUNET_free (saddr);

  if (NULL == w)
    return;

  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Notifying transport to remove address `%s'\n",
       http_common_plugin_address_to_string (plugin->protocol,
                                             w->address,
                                             w->addrlen));
  GNUNET_CONTAINER_DLL_remove (plugin->addr_head,
                               plugin->addr_tail,
                               w);
  /* modify our published address list */
#if BUILD_HTTPS
  address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
      "https_client", w->address, w->addrlen, GNUNET_HELLO_ADDRESS_INFO_NONE);
#else
  address = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
      "http_client", w->address, w->addrlen, GNUNET_HELLO_ADDRESS_INFO_NONE);
#endif
  plugin->env->notify_address (plugin->env->cls, add_remove, address);
  GNUNET_HELLO_address_free (address);
  GNUNET_free (w->address);
  GNUNET_free (w);
}


/**
 * Our external IP address/port mapping has changed.
 *
 * @param cls closure, the 'struct LocalAddrList'
 * @param add_remove #GNUNET_YES to mean the new public IP address, #GNUNET_NO to mean
 *     the previous (now invalid) one
 * @param addr either the previous or the new public IP address
 * @param addrlen actual lenght of the address
 */
static void
server_nat_port_map_callback (void *cls,
                              int add_remove,
                              const struct sockaddr *addr,
                              socklen_t addrlen)
{
  struct HTTP_Server_Plugin *plugin = cls;

  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "NAT called to %s address `%s'\n",
       (add_remove == GNUNET_NO) ? "remove" : "add",
       GNUNET_a2s (addr, addrlen));

  if (AF_INET == addr->sa_family)
  {
    struct sockaddr_in *s4 = (struct sockaddr_in *) addr;

    if (GNUNET_NO == plugin->use_ipv4)
      return;

    if ((NULL != plugin->server_addr_v4) &&
        (0 != memcmp (&plugin->server_addr_v4->sin_addr,
                      &s4->sin_addr, sizeof (struct in_addr))))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Skipping address `%s' (not bindto address)\n",
           GNUNET_a2s (addr, addrlen));
      return;
    }
  }

  if (AF_INET6 == addr->sa_family)
  {
    struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) addr;
    if (GNUNET_NO == plugin->use_ipv6)
      return;

    if ((NULL != plugin->server_addr_v6) &&
        (0 != memcmp (&plugin->server_addr_v6->sin6_addr,
                      &s6->sin6_addr, sizeof (struct in6_addr))))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Skipping address `%s' (not bindto address)\n",
           GNUNET_a2s (addr, addrlen));
      return;
    }
  }

  switch (add_remove)
  {
  case GNUNET_YES:
    server_add_address (cls, add_remove, addr, addrlen);
    break;
  case GNUNET_NO:
    server_remove_address (cls, add_remove, addr, addrlen);
    break;
  }
}


/**
 * Get valid server addresses
 *
 * @param plugin the plugin handle
 * @param service_name the servicename
 * @param cfg configuration handle
 * @param addrs addresses
 * @param addr_lens address length
 * @return number of addresses
 */
static int
server_get_addresses (struct HTTP_Server_Plugin *plugin,
                      const char *service_name,
                      const struct GNUNET_CONFIGURATION_Handle *cfg,
                      struct sockaddr ***addrs,
                      socklen_t ** addr_lens)
{
  int disablev6;
  unsigned long long port;
  struct addrinfo hints;
  struct addrinfo *res;
  struct addrinfo *pos;
  struct addrinfo *next;
  unsigned int i;
  int resi;
  int ret;
  struct sockaddr **saddrs;
  socklen_t *saddrlens;
  char *hostname;

  *addrs = NULL;
  *addr_lens = NULL;

  disablev6 = !plugin->use_ipv6;

  port = 0;
  if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT"))
  {
    GNUNET_break (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_number (cfg, service_name,
                                                         "PORT", &port));
    if (port > 65535)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _("Require valid port number for service in configuration!\n"));
      return GNUNET_SYSERR;
    }
  }
  if (0 == port)
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         "Starting in listen only mode\n");
    return -1; /* listen only */
  }


  if (GNUNET_CONFIGURATION_have_value (cfg, service_name,
                                       "BINDTO"))
  {
    GNUNET_break (GNUNET_OK ==
                  GNUNET_CONFIGURATION_get_value_string (cfg, service_name,
                                                         "BINDTO", &hostname));
  }
  else
    hostname = NULL;

  if (NULL != hostname)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Resolving `%s' since that is where `%s' will bind to.\n",
         hostname, service_name);
    memset (&hints, 0, sizeof (struct addrinfo));
    if (disablev6)
      hints.ai_family = AF_INET;
    if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) ||
        (NULL == res))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _("Failed to resolve `%s': %s\n"),
                  hostname,
                  gai_strerror (ret));
      GNUNET_free (hostname);
      return GNUNET_SYSERR;
    }
    next = res;
    i = 0;
    while (NULL != (pos = next))
    {
      next = pos->ai_next;
      if ((disablev6) && (pos->ai_family == AF_INET6))
        continue;
      i++;
    }
    if (0 == i)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _("Failed to find %saddress for `%s'.\n"),
                  disablev6 ? "IPv4 " : "", hostname);
      freeaddrinfo (res);
      GNUNET_free (hostname);
      return GNUNET_SYSERR;
    }
    resi = i;
    saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *));
    saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t));
    i = 0;
    next = res;
    while (NULL != (pos = next))
    {
      next = pos->ai_next;
      if ((disablev6) && (pos->ai_family == AF_INET6))
        continue;
      if ((pos->ai_protocol != IPPROTO_TCP) && (0 != pos->ai_protocol))
        continue;               /* not TCP */
      if ((pos->ai_socktype != SOCK_STREAM) && (0 != pos->ai_socktype))
        continue;               /* huh? */
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Service will bind to `%s'\n",
           GNUNET_a2s (pos->ai_addr,
                       pos->ai_addrlen));
      if (pos->ai_family == AF_INET)
      {
        GNUNET_assert (pos->ai_addrlen == sizeof (struct sockaddr_in));
        saddrlens[i] = pos->ai_addrlen;
        saddrs[i] = GNUNET_malloc (saddrlens[i]);
        memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
        ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
      }
      else
      {
        GNUNET_assert (pos->ai_family == AF_INET6);
        GNUNET_assert (pos->ai_addrlen == sizeof (struct sockaddr_in6));
        saddrlens[i] = pos->ai_addrlen;
        saddrs[i] = GNUNET_malloc (saddrlens[i]);
        memcpy (saddrs[i], pos->ai_addr, saddrlens[i]);
        ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
      }
      i++;
    }
    GNUNET_free (hostname);
    freeaddrinfo (res);
    resi = i;
  }
  else
  {
    /* will bind against everything, just set port */
    if (disablev6)
    {
      /* V4-only */
      resi = 1;
      i = 0;
      saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *));
      saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t));

      saddrlens[i] = sizeof (struct sockaddr_in);
      saddrs[i] = GNUNET_malloc (saddrlens[i]);
#if HAVE_SOCKADDR_IN_SIN_LEN
      ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i];
#endif
      ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
      ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
    }
    else
    {
      /* dual stack */
      resi = 2;
      saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *));
      saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t));
      i = 0;
      saddrlens[i] = sizeof (struct sockaddr_in6);
      saddrs[i] = GNUNET_malloc (saddrlens[i]);
#if HAVE_SOCKADDR_IN_SIN_LEN
      ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0];
#endif
      ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6;
      ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port);
      i++;
      saddrlens[i] = sizeof (struct sockaddr_in);
      saddrs[i] = GNUNET_malloc (saddrlens[i]);
#if HAVE_SOCKADDR_IN_SIN_LEN
      ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1];
#endif
      ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET;
      ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port);
    }
  }
  *addrs = saddrs;
  *addr_lens = saddrlens;
  return resi;
}


/**
 * Ask NAT for addresses
 *
 * @param plugin the plugin handle
 */
static void
server_start_report_addresses (struct HTTP_Server_Plugin *plugin)
{
  int res = GNUNET_OK;
  struct sockaddr **addrs;
  socklen_t *addrlens;

  res = server_get_addresses (plugin,
                              plugin->name,
                              plugin->env->cfg,
                              &addrs, &addrlens);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       _("Found %u addresses to report to NAT service\n"),
       res);

  if (GNUNET_SYSERR == res)
  {
    plugin->nat = NULL;
    return;
  }

  plugin->nat =
      GNUNET_NAT_register (plugin->env->cfg,
                           GNUNET_YES,
                           plugin->port,
                           (unsigned int) res,
                           (const struct sockaddr **) addrs, addrlens,
                           &server_nat_port_map_callback, NULL, plugin);
  while (res > 0)
  {
    res--;
    GNUNET_assert (NULL != addrs[res]);
    GNUNET_free (addrs[res]);
  }
  GNUNET_free_non_null (addrs);
  GNUNET_free_non_null (addrlens);
}


/**
 * Stop NAT for addresses
 *
 * @param plugin the plugin handle
 */
static void
server_stop_report_addresses (struct HTTP_Server_Plugin *plugin)
{
  struct HttpAddressWrapper *w;

  /* Stop NAT handle */
  if (NULL != plugin->nat)
  {
    GNUNET_NAT_unregister (plugin->nat);
    plugin->nat = NULL;
  }
  /* Clean up addresses */
  while (NULL != plugin->addr_head)
  {
    w = plugin->addr_head;
    GNUNET_CONTAINER_DLL_remove (plugin->addr_head,
                                 plugin->addr_tail,
                                 w);
    GNUNET_free (w->address);
    GNUNET_free (w);
  }
}


/**
 * Check if IPv6 supported on this system
 *
 * @param plugin the plugin handle
 * @return #GNUNET_YES on success, else #GNUNET_NO
 */
static int
server_check_ipv6_support (struct HTTP_Server_Plugin *plugin)
{
  struct GNUNET_NETWORK_Handle *desc = NULL;
  int res = GNUNET_NO;

  /* Probe IPv6 support */
  desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
  if (NULL == desc)
  {
    if ((errno == ENOBUFS) || (errno == ENOMEM) || (errno == ENFILE) ||
        (errno == EACCES))
    {
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
    }
    LOG (GNUNET_ERROR_TYPE_WARNING,
         _("Disabling IPv6 since it is not supported on this system!\n"));
    res = GNUNET_NO;
  }
  else
  {
    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc));
    desc = NULL;
    res = GNUNET_YES;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Testing IPv6 on this system: %s\n",
       (res == GNUNET_YES) ? "successful" : "failed");
  return res;
}


/**
 * Notify server about our external hostname
 *
 * @param cls plugin
 * @param tc task context (unused)
 */
static void
server_notify_external_hostname (void *cls,
                                 const struct GNUNET_SCHEDULER_TaskContext *tc)
{
  struct HTTP_Server_Plugin *plugin = cls;
  struct HttpAddress *ext_addr;
  size_t ext_addr_len;
  unsigned int urlen;
  char *url;

  plugin->notify_ext_task = NULL;
  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
    return;

  GNUNET_asprintf(&url,
                  "%s://%s",
                  plugin->protocol,
                  plugin->external_hostname);

  urlen = strlen (url) + 1;
  ext_addr = GNUNET_malloc (sizeof (struct HttpAddress) + urlen);
  ext_addr->options = htonl (plugin->options);
  ext_addr->urlen = htonl (urlen);
  ext_addr_len = sizeof (struct HttpAddress) + urlen;
  memcpy (&ext_addr[1], url, urlen);
  GNUNET_free (url);

  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Notifying transport about external hostname address `%s'\n",
       plugin->external_hostname);

#if BUILD_HTTPS
  if (GNUNET_YES == plugin->verify_external_hostname)
    LOG (GNUNET_ERROR_TYPE_INFO,
         "Enabling SSL verification for external hostname address `%s'\n",
         plugin->external_hostname);
  plugin->ext_addr = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
      "https_client", ext_addr, ext_addr_len, GNUNET_HELLO_ADDRESS_INFO_NONE );
  plugin->env->notify_address (plugin->env->cls, GNUNET_YES, plugin->ext_addr);
  GNUNET_free (ext_addr);
#else
  plugin->ext_addr = GNUNET_HELLO_address_allocate (plugin->env->my_identity,
      "http_client", ext_addr, ext_addr_len, GNUNET_HELLO_ADDRESS_INFO_NONE );
  plugin->env->notify_address (plugin->env->cls, GNUNET_YES, plugin->ext_addr);
  GNUNET_free (ext_addr);
#endif
}


/**
 * Configure the plugin
 *
 * @param plugin plugin handle
 * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
 */
static int
server_configure_plugin (struct HTTP_Server_Plugin *plugin)
{
  unsigned long long port;
  unsigned long long max_connections;
  char *bind4_address = NULL;
  char *bind6_address = NULL;
  char *eh_tmp = NULL;
  int external_hostname_use_port;

  /* Use IPv4? */
  if (GNUNET_CONFIGURATION_have_value
      (plugin->env->cfg, plugin->name, "USE_IPv4"))
  {
    plugin->use_ipv4 =
        GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
                                              plugin->name,
                                              "USE_IPv4");
  }
  else
    plugin->use_ipv4 = GNUNET_YES;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       _("IPv4 support is %s\n"),
       (plugin->use_ipv4 == GNUNET_YES) ? "enabled" : "disabled");

  /* Use IPv6? */
  if (GNUNET_CONFIGURATION_have_value
      (plugin->env->cfg, plugin->name, "USE_IPv6"))
  {
    plugin->use_ipv6 =
        GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
                                              plugin->name,
                                              "USE_IPv6");
  }
  else
    plugin->use_ipv6 = GNUNET_YES;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       _("IPv6 support is %s\n"),
       (plugin->use_ipv6 == GNUNET_YES) ? "enabled" : "disabled");

  if ((plugin->use_ipv4 == GNUNET_NO) && (plugin->use_ipv6 == GNUNET_NO))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _("Neither IPv4 nor IPv6 are enabled! Fix in configuration\n"));
    return GNUNET_SYSERR;
  }

  /* Reading port number from config file */
  if ((GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (plugin->env->cfg,
                                              plugin->name,
                                              "PORT", &port)) || (port > 65535))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _("Port is required! Fix in configuration\n"));
    return GNUNET_SYSERR;
  }
  plugin->port = port;

  LOG (GNUNET_ERROR_TYPE_INFO,
       _("Using port %u\n"), plugin->port);

  if ((plugin->use_ipv4 == GNUNET_YES) &&
      (GNUNET_YES == GNUNET_CONFIGURATION_get_value_string (plugin->env->cfg,
                          plugin->name, "BINDTO", &bind4_address)))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Binding %s plugin to specific IPv4 address: `%s'\n",
         plugin->protocol, bind4_address);
    plugin->server_addr_v4 = GNUNET_new (struct sockaddr_in);
    if (1 != inet_pton (AF_INET, bind4_address,
                        &plugin->server_addr_v4->sin_addr))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _("Specific IPv4 address `%s' in configuration file is invalid!\n"),
           bind4_address);
      GNUNET_free (bind4_address);
      GNUNET_free (plugin->server_addr_v4);
      plugin->server_addr_v4 = NULL;
      return GNUNET_SYSERR;
    }
    else
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           _("Binding to IPv4 address %s\n"),
           bind4_address);
      plugin->server_addr_v4->sin_family = AF_INET;
      plugin->server_addr_v4->sin_port = htons (plugin->port);
    }
    GNUNET_free (bind4_address);
  }

  if ((plugin->use_ipv6 == GNUNET_YES) &&
      (GNUNET_YES ==
       GNUNET_CONFIGURATION_get_value_string (plugin->env->cfg,
                                              plugin->name,
                                              "BINDTO6", &bind6_address)))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Binding %s plugin to specific IPv6 address: `%s'\n",
         plugin->protocol, bind6_address);
    plugin->server_addr_v6 = GNUNET_new (struct sockaddr_in6);
    if (1 !=
        inet_pton (AF_INET6, bind6_address, &plugin->server_addr_v6->sin6_addr))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _("Specific IPv6 address `%s' in configuration file is invalid!\n"),
           bind6_address);
      GNUNET_free (bind6_address);
      GNUNET_free (plugin->server_addr_v6);
      plugin->server_addr_v6 = NULL;
      return GNUNET_SYSERR;
    }
    else
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           _("Binding to IPv6 address %s\n"),
           bind6_address);
      plugin->server_addr_v6->sin6_family = AF_INET6;
      plugin->server_addr_v6->sin6_port = htons (plugin->port);
    }
    GNUNET_free (bind6_address);
  }

  plugin->verify_external_hostname = GNUNET_NO;
#if BUILD_HTTPS
  plugin->verify_external_hostname = GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
                                                                           plugin->name,
                                                                           "VERIFY_EXTERNAL_HOSTNAME");
  if (GNUNET_SYSERR == plugin->verify_external_hostname)
  	plugin->verify_external_hostname = GNUNET_NO;
  if (GNUNET_YES == plugin->verify_external_hostname)
  	plugin->options |= HTTP_OPTIONS_VERIFY_CERTIFICATE;
#endif
  external_hostname_use_port = GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
                                                                     plugin->name,
                                                                     "EXTERNAL_HOSTNAME_USE_PORT");
  if (GNUNET_SYSERR == external_hostname_use_port)
  	external_hostname_use_port = GNUNET_NO;


  if (GNUNET_YES ==
      GNUNET_CONFIGURATION_get_value_string (plugin->env->cfg,
                                             plugin->name,
                                             "EXTERNAL_HOSTNAME",
                                             &eh_tmp))
  {
    char *tmp;
    char *pos = NULL;
    char *pos_url = NULL;

    if (NULL != strstr(eh_tmp, "://"))
      tmp = &strstr(eh_tmp, "://")[3];
    else
      tmp = eh_tmp;

    if (GNUNET_YES == external_hostname_use_port)
    {
      if ( (strlen (tmp) > 1) && (NULL != (pos = strchr(tmp, '/'))) )
      {
        pos_url = pos + 1;
        pos[0] = '\0';
        GNUNET_asprintf (&plugin->external_hostname,
                         "%s:%u/%s",
                         tmp,
                         (uint16_t) port,
                         (NULL == pos_url) ? "" : pos_url);
      }
      else
        GNUNET_asprintf (&plugin->external_hostname,
                         "%s:%u",
                         tmp,
                         (uint16_t) port);
    }
    else
      plugin->external_hostname = GNUNET_strdup (tmp);
    GNUNET_free (eh_tmp);

    LOG (GNUNET_ERROR_TYPE_INFO,
         _("Using external hostname `%s'\n"),
         plugin->external_hostname);
    plugin->notify_ext_task = GNUNET_SCHEDULER_add_now (&server_notify_external_hostname,
                                                        plugin);

    /* Use only configured external hostname */
    if (GNUNET_CONFIGURATION_have_value
        (plugin->env->cfg,
         plugin->name,
         "EXTERNAL_HOSTNAME_ONLY"))
    {
      plugin->external_only =
        GNUNET_CONFIGURATION_get_value_yesno (plugin->env->cfg,
                                              plugin->name,
                                              "EXTERNAL_HOSTNAME_ONLY");
    }
    else
      plugin->external_only = GNUNET_NO;

    if (GNUNET_YES == plugin->external_only)
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           _("Notifying transport only about hostname `%s'\n"),
           plugin->external_hostname);
  }
  else
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "No external hostname configured\n");

  /* Optional parameters */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (plugin->env->cfg,
                                             plugin->name,
                                             "MAX_CONNECTIONS",
                                             &max_connections))
    max_connections = 128;
  plugin->max_request = max_connections;

  LOG (GNUNET_ERROR_TYPE_DEBUG,
       _("Maximum number of connections is %u\n"),
       plugin->max_request);

  plugin->peer_id_length = strlen (GNUNET_i2s_full (plugin->env->my_identity));

  return GNUNET_OK;
}


/**
 * Exit point from the plugin.
 *
 * @param cls api
 * @return NULL
 */
void *
LIBGNUNET_PLUGIN_TRANSPORT_DONE (void *cls)
{
  struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
  struct HTTP_Server_Plugin *plugin = api->cls;

  if (NULL == api->cls)
  {
    /* Free for stub mode */
    GNUNET_free (api);
    return NULL;
  }
  plugin->in_shutdown = GNUNET_YES;
  LOG (GNUNET_ERROR_TYPE_INFO,
       _("Shutting down plugin `%s'\n"),
       plugin->name);

  if (NULL != plugin->notify_ext_task)
  {
    GNUNET_SCHEDULER_cancel (plugin->notify_ext_task);
    plugin->notify_ext_task = NULL;
  }

  if (NULL != plugin->ext_addr)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Notifying transport to remove address `%s'\n",
         http_common_plugin_address_to_string (plugin->protocol,
                                               plugin->ext_addr->address,
                                               plugin->ext_addr->address_length));
#if BUILD_HTTPS
    plugin->env->notify_address (plugin->env->cls,
                                 GNUNET_NO,
                                 plugin->ext_addr);
#else
  plugin->env->notify_address (plugin->env->cls,
                               GNUNET_NO,
                               plugin->ext_addr);
#endif
    GNUNET_HELLO_address_free (plugin->ext_addr);
    plugin->ext_addr = NULL;
  }

  /* Stop to report addresses to transport service */
  server_stop_report_addresses (plugin);
  if (NULL != plugin->server_v4)
  {
    MHD_stop_daemon (plugin->server_v4);
    plugin->server_v4 = NULL;
  }
  if (NULL != plugin->server_v6)
  {
    MHD_stop_daemon (plugin->server_v6);
    plugin->server_v6 = NULL;
  }
  if (NULL != plugin->server_v4_task)
  {
    GNUNET_SCHEDULER_cancel (plugin->server_v4_task);
    plugin->server_v4_task = NULL;
  }

  if (NULL != plugin->server_v6_task)
  {
    GNUNET_SCHEDULER_cancel (plugin->server_v6_task);
    plugin->server_v6_task = NULL;
  }
#if BUILD_HTTPS
  GNUNET_free_non_null (plugin->crypto_init);
  GNUNET_free_non_null (plugin->cert);
  GNUNET_free_non_null (plugin->key);
#endif
  GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions,
                                         &destroy_session_shutdown_cb,
                                         plugin);
  GNUNET_CONTAINER_multipeermap_destroy (plugin->sessions);
  plugin->sessions = NULL;
  /* Clean up */
  GNUNET_free_non_null (plugin->external_hostname);
  GNUNET_free_non_null (plugin->ext_addr);
  GNUNET_free_non_null (plugin->server_addr_v4);
  GNUNET_free_non_null (plugin->server_addr_v6);
  regfree (&plugin->url_regex);

  LOG (GNUNET_ERROR_TYPE_DEBUG,
       _("Shutdown for plugin `%s' complete\n"),
       plugin->name);

  GNUNET_free (plugin);
  GNUNET_free (api);
  return NULL;
}


/**
 * Function called for a quick conversion of the binary address to
 * a numeric address.  Note that the caller must not free the
 * address and that the next call to this function is allowed
 * to override the address again.
 *
 * @param cls unused
 * @param addr binary address
 * @param addrlen length of the address
 * @return string representing the same address
 */
static const char *
http_server_plugin_address_to_string (void *cls,
                                      const void *addr,
                                      size_t addrlen)
{
  return http_common_plugin_address_to_string (PLUGIN_NAME,
                                               addr,
                                               addrlen);
}


/**
 * Function obtain the network type for a session
 *
 * @param cls closure ('struct HTTP_Server_Plugin*')
 * @param session the session
 * @return the network type in HBO or #GNUNET_SYSERR
 */
static enum GNUNET_ATS_Network_Type
http_server_plugin_get_network (void *cls,
                                struct Session *session)
{
  return session->scope;
}


/**
 * Function that will be called whenever the transport service wants to
 * notify the plugin that the inbound quota changed and that the plugin
 * should update it's delay for the next receive value
 *
 * @param cls closure
 * @param peer which peer was the session for
 * @param session which session is being updated
 * @param delay new delay to use for receiving
 */
static void
http_server_plugin_update_inbound_delay (void *cls,
                                         const struct GNUNET_PeerIdentity *peer,
                                         struct Session *session,
                                         struct GNUNET_TIME_Relative delay)
{
  session->next_receive = GNUNET_TIME_relative_to_absolute (delay);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "New inbound delay %s\n",
       GNUNET_STRINGS_relative_time_to_string (delay,
                                               GNUNET_NO));
  if (NULL != session->recv_wakeup_task)
  {
    GNUNET_SCHEDULER_cancel (session->recv_wakeup_task);
    session->recv_wakeup_task
      = GNUNET_SCHEDULER_add_delayed (delay,
                                      &server_wake_up,
                                      session);
  }
}


/**
 * Return information about the given session to the
 * monitor callback.
 *
 * @param cls the `struct Plugin` with the monitor callback (`sic`)
 * @param peer peer we send information about
 * @param value our `struct Session` to send information about
 * @return #GNUNET_OK (continue to iterate)
 */
static int
send_session_info_iter (void *cls,
                        const struct GNUNET_PeerIdentity *peer,
                        void *value)
{
  struct HTTP_Server_Plugin *plugin = cls;
  struct Session *session = value;

  notify_session_monitor (plugin,
                          session,
                          GNUNET_TRANSPORT_SS_INIT);
  return GNUNET_OK;
}


/**
 * Begin monitoring sessions of a plugin.  There can only
 * be one active monitor per plugin (i.e. if there are
 * multiple monitors, the transport service needs to
 * multiplex the generated events over all of them).
 *
 * @param cls closure of the plugin
 * @param sic callback to invoke, NULL to disable monitor;
 *            plugin will being by iterating over all active
 *            sessions immediately and then enter monitor mode
 * @param sic_cls closure for @a sic
 */
static void
http_server_plugin_setup_monitor (void *cls,
                                  GNUNET_TRANSPORT_SessionInfoCallback sic,
                                  void *sic_cls)
{
  struct HTTP_Server_Plugin *plugin = cls;

  plugin->sic = sic;
  plugin->sic_cls = sic_cls;
  if (NULL != sic)
  {
    GNUNET_CONTAINER_multipeermap_iterate (plugin->sessions,
                                           &send_session_info_iter,
                                           plugin);
    /* signal end of first iteration */
    sic (sic_cls, NULL, NULL);
  }
}


/**
 * Entry point for the plugin.
 *
 * @param cls env
 * @return api
 */
void *
LIBGNUNET_PLUGIN_TRANSPORT_INIT (void *cls)
{
  struct GNUNET_TRANSPORT_PluginEnvironment *env = cls;
  struct GNUNET_TRANSPORT_PluginFunctions *api;
  struct HTTP_Server_Plugin *plugin;

  if (NULL == env->receive)
  {
    /* run in 'stub' mode (i.e. as part of gnunet-peerinfo), don't fully
       initialze the plugin or the API */
    api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
    api->cls = NULL;
    api->address_to_string = &http_server_plugin_address_to_string;
    api->string_to_address = &http_common_plugin_string_to_address;
    api->address_pretty_printer = &http_common_plugin_address_pretty_printer;
    return api;
  }
  plugin = GNUNET_new (struct HTTP_Server_Plugin);
  plugin->env = env;
  plugin->sessions = GNUNET_CONTAINER_multipeermap_create (128,
                                                           GNUNET_YES);

  api = GNUNET_new (struct GNUNET_TRANSPORT_PluginFunctions);
  api->cls = plugin;
  api->send = &http_server_plugin_send;
  api->disconnect_peer = &http_server_plugin_disconnect_peer;
  api->disconnect_session = &http_server_plugin_disconnect_session;
  api->query_keepalive_factor = &http_server_query_keepalive_factor;
  api->check_address = &http_server_plugin_address_suggested;
  api->get_session = &http_server_plugin_get_session;

  api->address_to_string = &http_server_plugin_address_to_string;
  api->string_to_address = &http_common_plugin_string_to_address;
  api->address_pretty_printer = &http_common_plugin_address_pretty_printer;
  api->get_network = &http_server_plugin_get_network;
  api->update_session_timeout = &http_server_plugin_update_session_timeout;
  api->update_inbound_delay = &http_server_plugin_update_inbound_delay;
  api->setup_monitor = &http_server_plugin_setup_monitor;
#if BUILD_HTTPS
  plugin->name = "transport-https_server";
  plugin->protocol = "https";
#else
  plugin->name = "transport-http_server";
  plugin->protocol = "http";
#endif

  if (GNUNET_YES ==
      GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
                                            plugin->name,
                                            "TCP_STEALTH"))
  {
#ifdef TCP_STEALTH
    plugin->options |= HTTP_OPTIONS_TCP_STEALTH;
#else
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _("TCP_STEALTH not supported on this platform.\n"));
    LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
    return NULL;
#endif
  }

  /* Compile URL regex */
  if (regcomp(&plugin->url_regex,
              URL_REGEX,
              REG_EXTENDED))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
                     _("Unable to compile URL regex\n"));
    LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
    return NULL;
  }

  /* Configure plugin */
  if (GNUNET_SYSERR == server_configure_plugin (plugin))
  {
    LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
    return NULL;
  }

  /* Check IPv6 support */
  if (GNUNET_YES == plugin->use_ipv6)
    plugin->use_ipv6 = server_check_ipv6_support (plugin);

  /* Report addresses to transport service */
  if (GNUNET_NO == plugin->external_only)
    server_start_report_addresses (plugin);

  if (GNUNET_SYSERR == server_start (plugin))
  {
    LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
    return NULL;
  }
  return api;
}

/* end of plugin_transport_http_server.c */