src/transport/plugin_transport_http.c

   1 /*
   2      This file is part of GNUnet
   3      (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file transport/plugin_transport_http.c
  23  * @brief http transport service plugin
  24  * @author Matthias Wachs
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_common.h"
  29 #include "gnunet_constants.h"
  30 #include "gnunet_protocols.h"
  31 #include "gnunet_connection_lib.h"
  32 #include "gnunet_service_lib.h"
  33 #include "gnunet_statistics_service.h"
  34 #include "gnunet_transport_service.h"
  35 #include "gnunet_resolver_service.h"
  36 #include "gnunet_server_lib.h"
  37 #include "gnunet_container_lib.h"
  38 #include "plugin_transport.h"
  39 #include "gnunet_os_lib.h"
  40 #include "microhttpd.h"
  41 #include <curl/curl.h>
  42
  43 #if BUILD_HTTPS
  44 #define LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_https_init
  45 #define LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_https_done
  46 #define LIBGNUNET_PLUGIN_TRANSPORT_COMPONENT transport_https
  47 #define PROTOCOL_PREFIX "https"
  48 #else
  49 #define LIBGNUNET_PLUGIN_TRANSPORT_INIT libgnunet_plugin_transport_http_init
  50 #define LIBGNUNET_PLUGIN_TRANSPORT_DONE libgnunet_plugin_transport_http_done
  51 #define LIBGNUNET_PLUGIN_TRANSPORT_COMPONENT transport_http
  52 #define PROTOCOL_PREFIX "http"
  53 #endif
  54
  55 #define DEBUG_HTTP GNUNET_YES
  56 #define DEBUG_CURL GNUNET_NO
  57 #define DEBUG_MHD GNUNET_NO
  58 #define DEBUG_CONNECTIONS GNUNET_NO
  59 #define DEBUG_SESSION_SELECTION GNUNET_NO
  60
  61 #define CURL_TCP_NODELAY GNUNET_YES
  62
  63 #define INBOUND GNUNET_NO
  64 #define OUTBOUND GNUNET_YES
  65
  66
  67
  68 /**
  69  * Text of the response sent back after the last bytes of a PUT
  70  * request have been received (just to formally obey the HTTP
  71  * protocol).
  72  */
  73 #define HTTP_PUT_RESPONSE "Thank you!"
  74
  75 /**
  76  * After how long do we expire an address that we
  77  * learned from another peer if it is not reconfirmed
  78  * by anyone?
  79  */
  80 #define LEARNED_ADDRESS_EXPIRATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 6)
  81
  82 /**
  83  * Page returned if request invalid
  84  */
  85 #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>"
  86
  87 /**
  88  * Timeout for a http connect
  89  */
  90 #define HTTP_CONNECT_TIMEOUT 30
  91
  92
  93 /**
  94  * Network format for IPv4 addresses.
  95  */
  96 struct IPv4HttpAddress
  97 {
  98   /**
  99    * IPv4 address, in network byte order.
 100    */
 101   uint32_t ipv4_addr GNUNET_PACKED;
 102
 103   /**
 104    * Port number, in network byte order.
 105    */
 106   uint16_t u_port GNUNET_PACKED;
 107
 108 };
 109
 110
 111 /**
 112  * Network format for IPv6 addresses.
 113  */
 114 struct IPv6HttpAddress
 115 {
 116   /**
 117    * IPv6 address.
 118    */
 119   struct in6_addr ipv6_addr GNUNET_PACKED;
 120
 121   /**
 122    * Port number, in network byte order.
 123    */
 124   uint16_t u6_port GNUNET_PACKED;
 125
 126 };
 127
 128
 129 /**
 130  *  Message to send using http
 131  */
 132 struct HTTP_Message
 133 {
 134   /**
 135    * next pointer for double linked list
 136    */
 137   struct HTTP_Message * next;
 138
 139   /**
 140    * previous pointer for double linked list
 141    */
 142   struct HTTP_Message * prev;
 143
 144   /**
 145    * buffer containing data to send
 146    */
 147   char *buf;
 148
 149   /**
 150    * amount of data already sent
 151    */
 152   size_t pos;
 153
 154   /**
 155    * buffer length
 156    */
 157   size_t size;
 158
 159   /**
 160    * Continuation function to call once the transmission buffer
 161    * has again space available.  NULL if there is no
 162    * continuation to call.
 163    */
 164   GNUNET_TRANSPORT_TransmitContinuation transmit_cont;
 165
 166   /**
 167    * Closure for transmit_cont.
 168    */
 169   void *transmit_cont_cls;
 170 };
 171
 172
 173 struct HTTP_PeerContext
 174 {
 175   /**
 176    * peer's identity
 177    */
 178   struct GNUNET_PeerIdentity identity;
 179
 180   /**
 181    * Pointer to the global plugin struct.
 182    */
 183   struct Plugin *plugin;
 184
 185   /**
 186    * Linked list of connections with this peer
 187    * head
 188    */
 189   struct Session * head;
 190
 191   /**
 192    * Linked list of connections with this peer
 193    * tail
 194    */
 195   struct Session * tail;
 196
 197   /**
 198    * id for next session
 199    */
 200   size_t session_id_counter;
 201
 202   /**
 203    * Last session used to send data
 204    */
 205   struct Session * last_session;
 206 };
 207
 208
 209 struct Session
 210 {
 211   /**
 212    * API requirement.
 213    */
 214   struct SessionHeader header;
 215
 216   /**
 217    * next session in linked list
 218    */
 219   struct Session * next;
 220
 221   /**
 222    * previous session in linked list
 223    */
 224   struct Session * prev;
 225
 226   /**
 227    * address of this session
 228    */
 229   void * addr;
 230
 231   /**
 232    * address length
 233    */
 234   size_t addrlen;
 235
 236   /**
 237    * target url
 238    */
 239   char * url;
 240
 241   /**
 242    * Message queue for outbound messages
 243    * head of queue
 244    */
 245   struct HTTP_Message * pending_msgs_head;
 246
 247   /**
 248    * Message queue for outbound messages
 249    * tail of queue
 250    */
 251   struct HTTP_Message * pending_msgs_tail;
 252
 253   /**
 254    * partner peer this connection belongs to
 255    */
 256   struct HTTP_PeerContext * peercontext;
 257
 258   /**
 259    * message stream tokenizer for incoming data
 260    */
 261   struct GNUNET_SERVER_MessageStreamTokenizer *msgtok;
 262
 263   /**
 264    * session direction
 265    * outbound: OUTBOUND (GNUNET_YES)
 266    * inbound : INBOUND (GNUNET_NO)
 267    */
 268   unsigned int direction;
 269
 270   /**
 271    * is session connected to send data?
 272    */
 273   unsigned int send_connected;
 274
 275   /**
 276    * is send connection active?
 277    */
 278   unsigned int send_active;
 279
 280   /**
 281    * connection disconnect forced (e.g. from transport)
 282    */
 283   unsigned int send_force_disconnect;
 284
 285   /**
 286    * is session connected to receive data?
 287    */
 288   unsigned int recv_connected;
 289
 290   /**
 291    * is receive connection active?
 292    */
 293   unsigned int recv_active;
 294
 295   /**
 296    * connection disconnect forced (e.g. from transport)
 297    */
 298   unsigned int recv_force_disconnect;
 299
 300   /**
 301    * id for next session
 302    * NOTE: 0 is not an ID, zero is not defined. A correct ID is always > 0
 303    */
 304   size_t session_id;
 305
 306   /**
 307    * entity managing sending data
 308    * outbound session: CURL *
 309    * inbound session: mhd_connection *
 310    */
 311   void * send_endpoint;
 312
 313   /**
 314    * entity managing recieving data
 315    * outbound session: CURL *
 316    * inbound session: mhd_connection *
 317    */
 318   void * recv_endpoint;
 319 };
 320
 321 /**
 322  * Encapsulation of all of the state of the plugin.
 323  */
 324 struct Plugin
 325 {
 326   /**
 327    * Our environment.
 328    */
 329   struct GNUNET_TRANSPORT_PluginEnvironment *env;
 330
 331   /**
 332    * Handle for reporting statistics.
 333    */
 334   struct GNUNET_STATISTICS_Handle *stats;
 335
 336   /**
 337    * Plugin Port
 338    */
 339   unsigned int port_inbound;
 340
 341   struct GNUNET_CONTAINER_MultiHashMap *peers;
 342
 343   /**
 344    * Daemon for listening for new IPv4 connections.
 345    */
 346   struct MHD_Daemon *http_server_daemon_v4;
 347
 348   /**
 349    * Daemon for listening for new IPv6connections.
 350    */
 351   struct MHD_Daemon *http_server_daemon_v6;
 352
 353   /**
 354    * Our primary task for http daemon handling IPv4 connections
 355    */
 356   GNUNET_SCHEDULER_TaskIdentifier http_server_task_v4;
 357
 358   /**
 359    * Our primary task for http daemon handling IPv6 connections
 360    */
 361   GNUNET_SCHEDULER_TaskIdentifier http_server_task_v6;
 362
 363   /**
 364    * The task sending data
 365    */
 366   GNUNET_SCHEDULER_TaskIdentifier http_curl_task;
 367
 368   /**
 369    * cURL Multihandle
 370    */
 371   CURLM * multi_handle;
 372
 373   /**
 374    * Our ASCII encoded, hashed peer identity
 375    * This string is used to distinguish between connections and is added to the urls
 376    */
 377   struct GNUNET_CRYPTO_HashAsciiEncoded my_ascii_hash_ident;
 378
 379   /**
 380    * IPv4 Address the plugin binds to
 381    */
 382   struct sockaddr_in * bind4_address;
 383
 384   /**
 385    * IPv6 Address the plugins binds to
 386    */
 387   struct sockaddr_in6 * bind6_address;
 388
 389   /**
 390    * Hostname to bind to
 391    */
 392   char * bind_hostname;
 393
 394   /**
 395    * Is IPv4 enabled?
 396    */
 397   int use_ipv6;
 398
 399   /**
 400    * Is IPv6 enabled?
 401    */
 402   int use_ipv4;
 403
 404   /**
 405    * Closure passed by MHD to the mhd_logger function
 406    */
 407   void * mhd_log;
 408
 409 #if BUILD_HTTPS
 410   /* The certificate MHD uses as an \0 terminated string */
 411   char * cert;
 412
 413   /* The private key MHD uses as an \0 terminated string */
 414   char * key;
 415
 416   /* crypto init string */
 417   char * crypto_init;
 418 #endif
 419 };
 420
 421
 422 /**
 423  * Function called for a quick conversion of the binary address to
 424  * a numeric address.  Note that the caller must not free the
 425  * address and that the next call to this function is allowed
 426  * to override the address again.
 427  *
 428  * @param cls closure
 429  * @param addr binary address
 430  * @param addrlen length of the address
 431  * @return string representing the same address
 432  */
 433 static const char*
 434 http_plugin_address_to_string (void *cls,
 435                                    const void *addr,
 436                                    size_t addrlen);
 437
 438
 439 /**
 440  * Call MHD to process pending ipv4 requests and then go back
 441  * and schedule the next run.
 442  */
 443 static void http_server_daemon_v4_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 444 /**
 445  * Call MHD to process pending ipv6 requests and then go back
 446  * and schedule the next run.
 447  */
 448 static void http_server_daemon_v6_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 449
 450 /**
 451  * Function setting up curl handle and selecting message to send
 452  * @param cls plugin
 453  * @param ses session to send data to
 454  * @param con connection
 455  * @return bytes sent to peer
 456  */
 457 static ssize_t send_check_connections (void *cls, struct Session *ps);
 458
 459 /**
 460  * Function setting up file descriptors and scheduling task to run
 461  * @param cls closure
 462  * @param ses session to send data to
 463  * @param
 464  */
 465 static int curl_schedule(void *cls );
 466
 467
 468 /**
 469  * Creates a valid url from passed address and id
 470  * @param cls plugin as closure
 471  * @param addr address to create url from
 472  * @param addrlen address lenth
 473  * @param id session id
 474  * @return the created url
 475  */
 476 static char * create_url(void * cls, const void * addr, size_t addrlen, size_t id)
 477 {
 478   struct Plugin *plugin = cls;
 479   char *url = NULL;
 480   char *addr_str = (char *) http_plugin_address_to_string(NULL, addr, addrlen);
 481
 482   GNUNET_assert ((addr!=NULL) && (addrlen != 0));
 483   GNUNET_asprintf(&url,
 484                   "%s://%s/%s;%u", PROTOCOL_PREFIX, addr_str,
 485                   (char *) (&plugin->my_ascii_hash_ident),id);
 486   GNUNET_free_non_null(addr_str);
 487   return url;
 488 }
 489
 490 /**
 491  * Removes a message from the linked list of messages
 492  * @param ps session
 493  * @param msg message
 494  * @return GNUNET_SYSERR if msg not found, GNUNET_OK on success
 495  */
 496 static int remove_http_message (struct Session * ps, struct HTTP_Message * msg)
 497 {
 498   GNUNET_CONTAINER_DLL_remove(ps->pending_msgs_head,ps->pending_msgs_tail,msg);
 499   GNUNET_free(msg);
 500   return GNUNET_OK;
 501 }
 502
 503 /**
 504  * Iterator to remove peer context
 505  * @param cls the plugin
 506  * @key the peers public key hashcode
 507  * @value the peer context
 508  * @return GNUNET_YES on success
 509  */
 510 int remove_peer_context_Iterator (void *cls, const GNUNET_HashCode *key, void *value)
 511 {
 512   struct Plugin *plugin = cls;
 513   struct HTTP_PeerContext * pc = value;
 514   struct Session * ps = pc->head;
 515   struct Session * tmp = NULL;
 516   struct HTTP_Message * msg = NULL;
 517   struct HTTP_Message * msg_tmp = NULL;
 518 #if DEBUG_HTTP
 519   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Freeing context for peer `%s'\n",GNUNET_i2s(&pc->identity));
 520 #endif
 521   GNUNET_CONTAINER_multihashmap_remove (plugin->peers, &pc->identity.hashPubKey, pc);
 522   while (ps!=NULL)
 523   {
 524         plugin->env->session_end(plugin, &pc->identity, ps);
 525         tmp = ps->next;
 526
 527     GNUNET_free_non_null (ps->addr);
 528     GNUNET_free(ps->url);
 529     if (ps->msgtok != NULL)
 530       GNUNET_SERVER_mst_destroy (ps->msgtok);
 531
 532     msg = ps->pending_msgs_head;
 533     while (msg!=NULL)
 534     {
 535       msg_tmp = msg->next;
 536       GNUNET_free(msg);
 537       msg = msg_tmp;
 538     }
 539     if (ps->direction==OUTBOUND)
 540     {
 541       if (ps->send_endpoint!=NULL)
 542         curl_easy_cleanup(ps->send_endpoint);
 543       if (ps->recv_endpoint!=NULL)
 544         curl_easy_cleanup(ps->recv_endpoint);
 545     }
 546
 547     GNUNET_free(ps);
 548     ps=tmp;
 549   }
 550   GNUNET_free(pc);
 551   GNUNET_STATISTICS_update (plugin->env->stats,
 552                             gettext_noop ("# HTTP peers active"),
 553                             -1,
 554                             GNUNET_NO);
 555   return GNUNET_YES;
 556 }
 557
 558
 559 /**
 560  * Removes a session from the linked list of sessions
 561  * @param pc peer context
 562  * @param ps session
 563  * @param call_msg_cont GNUNET_YES to call pending message continuations, otherwise no
 564  * @param call_msg_cont_result result to call message continuations with
 565  * @return GNUNET_SYSERR if msg not found, GNUNET_OK on success
 566  */
 567 static int remove_session (struct HTTP_PeerContext * pc, struct Session * ps,  int call_msg_cont, int call_msg_cont_result)
 568 {
 569   struct HTTP_Message * msg;
 570   struct Plugin * plugin = ps->peercontext->plugin;
 571
 572 #if DEBUG_CONNECTIONS
 573   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: removing %s session %X with id %u\n", ps, (ps->direction == INBOUND) ? "inbound" : "outbound", ps, ps->session_id);
 574 #endif
 575   plugin->env->session_end(plugin, &pc->identity, ps);
 576
 577   GNUNET_free_non_null (ps->addr);
 578   GNUNET_SERVER_mst_destroy (ps->msgtok);
 579   GNUNET_free(ps->url);
 580
 581   if (ps->direction==INBOUND)
 582   {
 583           if (ps->recv_endpoint != NULL)
 584           {
 585                   curl_easy_cleanup(ps->recv_endpoint);
 586                   ps->recv_endpoint = NULL;
 587           }
 588           if (ps->send_endpoint != NULL)
 589           {
 590                   curl_easy_cleanup(ps->send_endpoint);
 591                   ps->send_endpoint = NULL;
 592           }
 593   }
 594
 595   msg = ps->pending_msgs_head;
 596   while (msg!=NULL)
 597   {
 598     if ((call_msg_cont == GNUNET_YES) && (msg->transmit_cont!=NULL))
 599     {
 600       msg->transmit_cont (msg->transmit_cont_cls,&pc->identity,call_msg_cont_result);
 601     }
 602     GNUNET_CONTAINER_DLL_remove(ps->pending_msgs_head,ps->pending_msgs_head,msg);
 603     GNUNET_free(msg);
 604     msg = ps->pending_msgs_head;
 605   }
 606
 607   GNUNET_CONTAINER_DLL_remove(pc->head,pc->tail,ps);
 608   GNUNET_free(ps);
 609   ps = NULL;
 610
 611   /* no sessions left remove peer */
 612   if (pc->head==NULL)
 613   {
 614 #if DEBUG_HTTP
 615   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"No sessions left for peer `%s', removing context\n",GNUNET_i2s(&pc->identity));
 616 #endif
 617         remove_peer_context_Iterator(plugin, &pc->identity.hashPubKey, pc);
 618   }
 619
 620   return GNUNET_OK;
 621 }
 622
 623
 624 /**
 625  * Add the IP of our network interface to the list of
 626  * our external IP addresses.
 627  *
 628  * @param cls the 'struct Plugin*'
 629  * @param name name of the interface
 630  * @param isDefault do we think this may be our default interface
 631  * @param addr address of the interface
 632  * @param addrlen number of bytes in addr
 633  * @return GNUNET_OK to continue iterating
 634  */
 635 static int
 636 process_interfaces (void *cls,
 637                     const char *name,
 638                     int isDefault,
 639                     const struct sockaddr *addr, socklen_t addrlen)
 640 {
 641   struct Plugin *plugin = cls;
 642   struct IPv4HttpAddress * t4;
 643   struct IPv6HttpAddress * t6;
 644   int af;
 645
 646
 647   GNUNET_assert(cls !=NULL);
 648   af = addr->sa_family;
 649   if ((af == AF_INET) && (plugin->use_ipv4 == GNUNET_YES) && (plugin->bind6_address == NULL))
 650     {
 651           struct in_addr bnd_cmp = ((struct sockaddr_in *) addr)->sin_addr;
 652       t4 = GNUNET_malloc(sizeof(struct IPv4HttpAddress));
 653       /* Not skipping loopback addresses
 654       if (INADDR_LOOPBACK == ntohl(((struct sockaddr_in *) addr)->sin_addr.s_addr))
 655       {
 656
 657         return GNUNET_OK;
 658       }
 659       */
 660       t4->ipv4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
 661       t4->u_port = htons (plugin->port_inbound);
 662       if (plugin->bind4_address != NULL)
 663       {
 664           if (0 == memcmp(&plugin->bind4_address->sin_addr, &bnd_cmp, sizeof (struct in_addr)))
 665           {
 666                   plugin->env->notify_address(plugin->env->cls,PROTOCOL_PREFIX,t4, sizeof (struct IPv4HttpAddress), GNUNET_TIME_UNIT_FOREVER_REL);
 667           }
 668       }
 669       else
 670       {
 671           plugin->env->notify_address(plugin->env->cls,PROTOCOL_PREFIX,t4, sizeof (struct IPv4HttpAddress), GNUNET_TIME_UNIT_FOREVER_REL);
 672       }
 673       GNUNET_free (t4);
 674     }
 675   else if ((af == AF_INET6) && (plugin->use_ipv6 == GNUNET_YES)  && (plugin->bind4_address == NULL))
 676     {
 677           struct in6_addr bnd_cmp6 = ((struct sockaddr_in6 *) addr)->sin6_addr;
 678       if (IN6_IS_ADDR_LINKLOCAL (&((struct sockaddr_in6 *) addr)->sin6_addr))
 679         {
 680           return GNUNET_OK;
 681         }
 682       t6 = GNUNET_malloc(sizeof(struct IPv6HttpAddress));
 683       GNUNET_assert(t6 != NULL);
 684       if (plugin->bind6_address != NULL)
 685       {
 686           if (0 == memcmp(&plugin->bind6_address->sin6_addr, &bnd_cmp6, sizeof (struct in6_addr)))
 687           {
 688               memcpy (&t6->ipv6_addr,
 689                       &((struct sockaddr_in6 *) addr)->sin6_addr,
 690                       sizeof (struct in6_addr));
 691               t6->u6_port = htons (plugin->port_inbound);
 692               plugin->env->notify_address(plugin->env->cls,PROTOCOL_PREFIX,t6,sizeof (struct IPv6HttpAddress) , GNUNET_TIME_UNIT_FOREVER_REL);
 693           }
 694       }
 695       else
 696       {
 697           memcpy (&t6->ipv6_addr,
 698                   &((struct sockaddr_in6 *) addr)->sin6_addr,
 699                   sizeof (struct in6_addr));
 700           t6->u6_port = htons (plugin->port_inbound);
 701           plugin->env->notify_address(plugin->env->cls,PROTOCOL_PREFIX,t6,sizeof (struct IPv6HttpAddress) , GNUNET_TIME_UNIT_FOREVER_REL);
 702       }
 703       GNUNET_free (t6);
 704     }
 705   return GNUNET_OK;
 706 }
 707
 708
 709 /**
 710  * External logging function for MHD
 711  * @param arg arguments
 712  * @param fmt format string
 713  * @param ap  list of arguments
 714  */
 715 void mhd_logger (void * arg, const char * fmt, va_list ap)
 716 {
 717         char text[1024];
 718         vsnprintf(text, 1024, fmt, ap);
 719         va_end(ap);
 720         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,"MHD: %s \n", text);
 721 }
 722
 723 /**
 724  * Callback called by MHD when a connection is terminated
 725  * @param cls closure
 726  * @param connection the terminated connection
 727  * @httpSessionCache the mhd session reference
 728  */
 729 static void mhd_termination_cb (void *cls, struct MHD_Connection * connection, void **httpSessionCache)
 730 {
 731   struct Session * ps = *httpSessionCache;
 732   if (ps == NULL)
 733     return;
 734   struct HTTP_PeerContext * pc = ps->peercontext;
 735
 736   if (connection==ps->recv_endpoint)
 737   {
 738 #if DEBUG_CONNECTIONS
 739     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: inbound connection from peer `%s' was terminated\n", ps, GNUNET_i2s(&pc->identity));
 740 #endif
 741     ps->recv_active = GNUNET_NO;
 742     ps->recv_connected = GNUNET_NO;
 743     ps->recv_endpoint = NULL;
 744   }
 745   if (connection==ps->send_endpoint)
 746   {
 747
 748     ps->send_active = GNUNET_NO;
 749     ps->send_connected = GNUNET_NO;
 750     ps->send_endpoint = NULL;
 751 #if DEBUG_CONNECTIONS
 752     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: outbound connection from peer `%s' was terminated\n", ps, GNUNET_i2s(&pc->identity));
 753 #endif
 754   }
 755
 756   /* if both connections disconnected, remove session */
 757   if ((ps->send_connected == GNUNET_NO) && (ps->recv_connected == GNUNET_NO))
 758   {
 759       GNUNET_STATISTICS_update (pc->plugin->env->stats,
 760                             gettext_noop ("# HTTP inbound sessions for peers active"),
 761                             -1,
 762                             GNUNET_NO);
 763     remove_session(pc,ps,GNUNET_YES,GNUNET_SYSERR);
 764   }
 765 }
 766
 767 /**
 768  * Callback called by MessageStreamTokenizer when a message has arrived
 769  * @param cls current session as closure
 770  * @param client clien
 771  * @param message the message to be forwarded to transport service
 772  */
 773
 774 static void mhd_write_mst_cb (void *cls,
 775                               void *client,
 776                               const struct GNUNET_MessageHeader *message)
 777 {
 778
 779   struct Session *ps  = cls;
 780   GNUNET_assert(ps != NULL);
 781
 782   struct HTTP_PeerContext *pc = ps->peercontext;
 783   GNUNET_assert(pc != NULL);
 784 #if DEBUG_HTTP
 785   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 786               "Connection %X: Forwarding message to transport service, type %u and size %u from `%s' (`%s')\n",
 787               ps,
 788               ntohs(message->type),
 789               ntohs(message->size),
 790               GNUNET_i2s(&(ps->peercontext)->identity),http_plugin_address_to_string(NULL,ps->addr,ps->addrlen));
 791 #endif
 792   pc->plugin->env->receive (ps->peercontext->plugin->env->cls,
 793                             &pc->identity,
 794                             message, 1, ps,
 795                             NULL,
 796                             0);
 797 }
 798
 799 /**
 800  * Check if incoming connection is accepted.
 801  * NOTE: Here every connection is accepted
 802  * @param cls plugin as closure
 803  * @param addr address of incoming connection
 804  * @param addr_len address length of incoming connection
 805  * @return MHD_YES if connection is accepted, MHD_NO if connection is rejected
 806  *
 807  */
 808 static int
 809 mhd_accept_cb (void *cls,
 810                       const struct sockaddr *addr, socklen_t addr_len)
 811 {
 812 #if 0
 813   struct Plugin *plugin = cls;
 814 #endif
 815   /* Every connection is accepted, nothing more to do here */
 816   return MHD_YES;
 817 }
 818
 819
 820 /**
 821  * Callback called by MHD when it needs data to send
 822  * @param cls current session
 823  * @param pos position in buffer
 824  * @param buf the buffer to write data to
 825  * @param max max number of bytes available in buffer
 826  * @return bytes written to buffer
 827  */
 828 int mhd_send_callback (void *cls, uint64_t pos, char *buf, int max)
 829 {
 830   int bytes_read = 0;
 831   struct Session * ps = cls;
 832   struct HTTP_PeerContext * pc;
 833   struct HTTP_Message * msg;
 834   GNUNET_assert (ps!=NULL);
 835   pc = ps->peercontext;
 836   msg = ps->pending_msgs_tail;
 837   if (ps->send_force_disconnect==GNUNET_YES)
 838   {
 839 #if DEBUG_CONNECTIONS
 840     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: outbound forced to disconnect\n",ps);
 841 #endif
 842     return -1;
 843   }
 844
 845   if (msg!=NULL)
 846   {
 847     if ((msg->size-msg->pos) <= max)
 848     {
 849       memcpy(buf,&msg->buf[msg->pos],(msg->size-msg->pos));
 850       bytes_read = msg->size-msg->pos;
 851       msg->pos+=(msg->size-msg->pos);
 852     }
 853     else
 854     {
 855       memcpy(buf,&msg->buf[msg->pos],max);
 856       msg->pos+=max;
 857       bytes_read = max;
 858     }
 859
 860     if (msg->pos==msg->size)
 861     {
 862       if (NULL!=msg->transmit_cont)
 863         msg->transmit_cont (msg->transmit_cont_cls,&pc->identity,GNUNET_OK);
 864       remove_http_message(ps,msg);
 865     }
 866   }
 867   return bytes_read;
 868 }
 869
 870 /**
 871  * Process GET or PUT request received via MHD.  For
 872  * GET, queue response that will send back our pending
 873  * messages.  For PUT, process incoming data and send
 874  * to GNUnet core.  In either case, check if a session
 875  * already exists and create a new one if not.
 876  */
 877 static int
 878 mdh_access_cb (void *cls,
 879                        struct MHD_Connection *mhd_connection,
 880                        const char *url,
 881                        const char *method,
 882                        const char *version,
 883                        const char *upload_data,
 884                        size_t * upload_data_size, void **httpSessionCache)
 885 {
 886   struct Plugin *plugin = cls;
 887   struct MHD_Response *response;
 888   const union MHD_ConnectionInfo * conn_info;
 889
 890   struct sockaddr_in  *addrin;
 891   struct sockaddr_in6 *addrin6;
 892
 893   char address[INET6_ADDRSTRLEN+14];
 894   struct GNUNET_PeerIdentity pi_in;
 895   size_t id_num = 0;
 896
 897   struct IPv4HttpAddress ipv4addr;
 898   struct IPv6HttpAddress ipv6addr;
 899
 900   struct HTTP_PeerContext *pc;
 901   struct Session *ps = NULL;
 902   struct Session *ps_tmp = NULL;
 903
 904   int res = GNUNET_NO;
 905   int send_error_to_client;
 906   void * addr = NULL;
 907   size_t addr_len = 0 ;
 908
 909   GNUNET_assert(cls !=NULL);
 910   send_error_to_client = GNUNET_NO;
 911
 912   if (NULL == *httpSessionCache)
 913   {
 914     /* check url for peer identity , if invalid send HTTP 404*/
 915     size_t len = strlen(&url[1]);
 916     char * peer = GNUNET_malloc(104+1);
 917
 918     if ((len>104) && (url[104]==';'))
 919     {
 920         char * id = GNUNET_malloc((len-104)+1);
 921         strcpy(id,&url[105]);
 922         memcpy(peer,&url[1],103);
 923         peer[103] = '\0';
 924         id_num = strtoul ( id, NULL , 10);
 925         GNUNET_free(id);
 926     }
 927     res = GNUNET_CRYPTO_hash_from_string (peer, &(pi_in.hashPubKey));
 928     GNUNET_free(peer);
 929     if ( GNUNET_SYSERR == res )
 930     {
 931       response = MHD_create_response_from_data (strlen (HTTP_ERROR_RESPONSE),HTTP_ERROR_RESPONSE, MHD_NO, MHD_NO);
 932       res = MHD_queue_response (mhd_connection, MHD_HTTP_NOT_FOUND, response);
 933       MHD_destroy_response (response);
 934 #if DEBUG_CONNECTIONS
 935       if (res == MHD_YES)
 936         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Peer has no valid ident, sent HTTP 1.1/404\n");
 937       else
 938         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Peer has no valid ident, could not send error\n");
 939 #endif
 940       return res;
 941     }
 942   }
 943   else
 944   {
 945     ps = *httpSessionCache;
 946     pc = ps->peercontext;
 947   }
 948
 949   if (NULL == *httpSessionCache)
 950   {
 951     /* get peer context */
 952     pc = GNUNET_CONTAINER_multihashmap_get (plugin->peers, &pi_in.hashPubKey);
 953     /* Peer unknown */
 954     if (pc==NULL)
 955     {
 956       pc = GNUNET_malloc(sizeof (struct HTTP_PeerContext));
 957       pc->plugin = plugin;
 958       pc->session_id_counter=1;
 959       pc->last_session = NULL;
 960       memcpy(&pc->identity, &pi_in, sizeof(struct GNUNET_PeerIdentity));
 961       GNUNET_CONTAINER_multihashmap_put(plugin->peers, &pc->identity.hashPubKey, pc, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
 962       GNUNET_STATISTICS_update (plugin->env->stats,
 963                             gettext_noop ("# HTTP peers active"),
 964                             1,
 965                             GNUNET_NO);
 966     }
 967
 968     conn_info = MHD_get_connection_info(mhd_connection, MHD_CONNECTION_INFO_CLIENT_ADDRESS );
 969     /* Incoming IPv4 connection */
 970     if ( AF_INET == conn_info->client_addr->sin_family)
 971     {
 972       addrin = conn_info->client_addr;
 973       inet_ntop(addrin->sin_family, &(addrin->sin_addr),address,INET_ADDRSTRLEN);
 974       memcpy(&ipv4addr.ipv4_addr,&(addrin->sin_addr),sizeof(struct in_addr));
 975       ipv4addr.u_port = addrin->sin_port;
 976       addr = &ipv4addr;
 977       addr_len = sizeof(struct IPv4HttpAddress);
 978     }
 979     /* Incoming IPv6 connection */
 980     if ( AF_INET6 == conn_info->client_addr->sin_family)
 981     {
 982       addrin6 = (struct sockaddr_in6 *) conn_info->client_addr;
 983       inet_ntop(addrin6->sin6_family, &(addrin6->sin6_addr),address,INET6_ADDRSTRLEN);
 984       memcpy(&ipv6addr.ipv6_addr,&(addrin6->sin6_addr),sizeof(struct in6_addr));
 985       ipv6addr.u6_port = addrin6->sin6_port;
 986       addr = &ipv6addr;
 987       addr_len = sizeof(struct IPv6HttpAddress);
 988     }
 989
 990     GNUNET_assert (addr != NULL);
 991     GNUNET_assert (addr_len != 0);
 992
 993     ps = NULL;
 994     /* only inbound sessions here */
 995
 996     ps_tmp = pc->head;
 997     while (ps_tmp!=NULL)
 998     {
 999       if ((ps_tmp->direction==INBOUND) && (ps_tmp->session_id == id_num) && (id_num!=0))
1000       {
1001         if ((ps_tmp->recv_force_disconnect!=GNUNET_YES) && (ps_tmp->send_force_disconnect!=GNUNET_YES))
1002         ps=ps_tmp;
1003         break;
1004       }
1005       ps_tmp=ps_tmp->next;
1006     }
1007
1008     if (ps==NULL)
1009     {
1010       ps = GNUNET_malloc(sizeof (struct Session));
1011       ps->addr = GNUNET_malloc(addr_len);
1012       memcpy(ps->addr,addr,addr_len);
1013       ps->addrlen = addr_len;
1014       ps->direction=INBOUND;
1015       ps->pending_msgs_head = NULL;
1016       ps->pending_msgs_tail = NULL;
1017       ps->send_connected=GNUNET_NO;
1018       ps->send_active=GNUNET_NO;
1019       ps->recv_connected=GNUNET_NO;
1020       ps->recv_active=GNUNET_NO;
1021       ps->peercontext=pc;
1022       ps->session_id =id_num;
1023       ps->url = create_url (plugin, ps->addr, ps->addrlen, ps->session_id);
1024       GNUNET_CONTAINER_DLL_insert(pc->head,pc->tail,ps);
1025       GNUNET_STATISTICS_update (plugin->env->stats,
1026                             gettext_noop ("# HTTP inbound sessions for peers active"),
1027                             1,
1028                             GNUNET_NO);
1029     }
1030
1031     *httpSessionCache = ps;
1032     if (ps->msgtok==NULL)
1033       ps->msgtok = GNUNET_SERVER_mst_create (&mhd_write_mst_cb, ps);
1034 #if DEBUG_HTTP
1035     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: HTTP Daemon has new an incoming `%s' request from peer `%s' (`%s')\n",
1036                 ps,
1037                 method,
1038                 GNUNET_i2s(&pc->identity),
1039                 http_plugin_address_to_string(NULL, ps->addr, ps->addrlen));
1040 #endif
1041   }
1042
1043   /* Is it a PUT or a GET request */
1044   if (0 == strcmp (MHD_HTTP_METHOD_PUT, method))
1045   {
1046     if (ps->recv_force_disconnect == GNUNET_YES)
1047     {
1048 #if DEBUG_CONNECTIONS
1049       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: inbound connection was forced to disconnect\n",ps);
1050 #endif
1051       ps->recv_active = GNUNET_NO;
1052       return MHD_NO;
1053     }
1054     if ((*upload_data_size == 0) && (ps->recv_active==GNUNET_NO))
1055     {
1056       ps->recv_endpoint = mhd_connection;
1057       ps->recv_connected = GNUNET_YES;
1058       ps->recv_active = GNUNET_YES;
1059       ps->recv_force_disconnect = GNUNET_NO;
1060 #if DEBUG_CONNECTIONS
1061       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: inbound PUT connection connected\n",ps);
1062 #endif
1063       return MHD_YES;
1064     }
1065
1066     /* Transmission of all data complete */
1067     if ((*upload_data_size == 0) && (ps->recv_active == GNUNET_YES))
1068     {
1069       response = MHD_create_response_from_data (strlen (HTTP_PUT_RESPONSE),HTTP_PUT_RESPONSE, MHD_NO, MHD_NO);
1070       res = MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
1071 #if DEBUG_CONNECTIONS
1072       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: Sent HTTP/1.1: 200 OK as PUT Response\n",ps);
1073 #endif
1074       MHD_destroy_response (response);
1075       ps->recv_active=GNUNET_NO;
1076       return MHD_YES;
1077     }
1078
1079     /* Recieving data */
1080     if ((*upload_data_size > 0) && (ps->recv_active == GNUNET_YES))
1081     {
1082       res = GNUNET_SERVER_mst_receive(ps->msgtok, ps, upload_data,*upload_data_size, GNUNET_NO, GNUNET_NO);
1083       (*upload_data_size) = 0;
1084       return MHD_YES;
1085     }
1086     else
1087       return MHD_NO;
1088   }
1089   if ( 0 == strcmp (MHD_HTTP_METHOD_GET, method) )
1090   {
1091     if (ps->send_force_disconnect == GNUNET_YES)
1092     {
1093 #if DEBUG_CONNECTIONS
1094       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: outbound connection was  forced to disconnect\n",ps);
1095 #endif
1096       ps->send_active = GNUNET_NO;
1097       return MHD_NO;
1098     }
1099           ps->send_connected = GNUNET_YES;
1100           ps->send_active = GNUNET_YES;
1101           ps->send_endpoint = mhd_connection;
1102           ps->send_force_disconnect = GNUNET_NO;
1103 #if DEBUG_CONNECTIONS
1104           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: inbound GET connection connected\n",ps);
1105 #endif
1106           response = MHD_create_response_from_callback(-1,32 * 1024, &mhd_send_callback, ps, NULL);
1107           res = MHD_queue_response (mhd_connection, MHD_HTTP_OK, response);
1108           MHD_destroy_response (response);
1109           return MHD_YES;
1110   }
1111   return MHD_NO;
1112 }
1113
1114 /**
1115  * Function that queries MHD's select sets and
1116  * starts the task waiting for them.
1117  * @param cls plugin as closure
1118  * @param daemon_handle the MHD daemon handle
1119  * @return gnunet task identifier
1120  */
1121 static GNUNET_SCHEDULER_TaskIdentifier
1122 http_server_daemon_prepare (void * cls, struct MHD_Daemon *daemon_handle)
1123 {
1124   struct Plugin *plugin = cls;
1125   GNUNET_SCHEDULER_TaskIdentifier ret;
1126   fd_set rs;
1127   fd_set ws;
1128   fd_set es;
1129   struct GNUNET_NETWORK_FDSet *wrs;
1130   struct GNUNET_NETWORK_FDSet *wws;
1131   struct GNUNET_NETWORK_FDSet *wes;
1132   int max;
1133   unsigned long long timeout;
1134   int haveto;
1135   struct GNUNET_TIME_Relative tv;
1136
1137   GNUNET_assert(cls !=NULL);
1138   ret = GNUNET_SCHEDULER_NO_TASK;
1139   FD_ZERO(&rs);
1140   FD_ZERO(&ws);
1141   FD_ZERO(&es);
1142   wrs = GNUNET_NETWORK_fdset_create ();
1143   wes = GNUNET_NETWORK_fdset_create ();
1144   wws = GNUNET_NETWORK_fdset_create ();
1145   max = -1;
1146   GNUNET_assert (MHD_YES ==
1147                  MHD_get_fdset (daemon_handle,
1148                                 &rs,
1149                                 &ws,
1150                                 &es,
1151                                 &max));
1152   haveto = MHD_get_timeout (daemon_handle, &timeout);
1153   if (haveto == MHD_YES)
1154     tv.value = (uint64_t) timeout;
1155   else
1156     tv = GNUNET_TIME_UNIT_FOREVER_REL;
1157   GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max);
1158   GNUNET_NETWORK_fdset_copy_native (wws, &ws, max);
1159   GNUNET_NETWORK_fdset_copy_native (wes, &es, max);
1160   if (daemon_handle == plugin->http_server_daemon_v4)
1161   {
1162         if (plugin->http_server_task_v4 != GNUNET_SCHEDULER_NO_TASK)
1163         {
1164                 GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_server_task_v4);
1165                 plugin->http_server_daemon_v4 = GNUNET_SCHEDULER_NO_TASK;
1166         }
1167
1168     ret = GNUNET_SCHEDULER_add_select (plugin->env->sched,
1169                                        GNUNET_SCHEDULER_PRIORITY_DEFAULT,
1170                                        GNUNET_SCHEDULER_NO_TASK,
1171                                        tv,
1172                                        wrs,
1173                                        wws,
1174                                        &http_server_daemon_v4_run,
1175                                        plugin);
1176   }
1177   if (daemon_handle == plugin->http_server_daemon_v6)
1178   {
1179         if (plugin->http_server_task_v6 != GNUNET_SCHEDULER_NO_TASK)
1180         {
1181                 GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_server_task_v6);
1182                 plugin->http_server_task_v6 = GNUNET_SCHEDULER_NO_TASK;
1183         }
1184
1185     ret = GNUNET_SCHEDULER_add_select (plugin->env->sched,
1186                                        GNUNET_SCHEDULER_PRIORITY_DEFAULT,
1187                                        GNUNET_SCHEDULER_NO_TASK,
1188                                        tv,
1189                                        wrs,
1190                                        wws,
1191                                        &http_server_daemon_v6_run,
1192                                        plugin);
1193   }
1194   GNUNET_NETWORK_fdset_destroy (wrs);
1195   GNUNET_NETWORK_fdset_destroy (wws);
1196   GNUNET_NETWORK_fdset_destroy (wes);
1197   return ret;
1198 }
1199
1200 /**
1201  * Call MHD IPv4 to process pending requests and then go back
1202  * and schedule the next run.
1203  * @param cls plugin as closure
1204  * @param tc task context
1205  */
1206 static void http_server_daemon_v4_run (void *cls,
1207                              const struct GNUNET_SCHEDULER_TaskContext *tc)
1208 {
1209   struct Plugin *plugin = cls;
1210
1211   GNUNET_assert(cls !=NULL);
1212   plugin->http_server_task_v4 = GNUNET_SCHEDULER_NO_TASK;
1213
1214   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1215     return;
1216
1217   GNUNET_assert (MHD_YES == MHD_run (plugin->http_server_daemon_v4));
1218   plugin->http_server_task_v4 = http_server_daemon_prepare (plugin, plugin->http_server_daemon_v4);
1219  }
1220
1221
1222 /**
1223  * Call MHD IPv6 to process pending requests and then go back
1224  * and schedule the next run.
1225  * @param cls plugin as closure
1226  * @param tc task context
1227  */
1228 static void http_server_daemon_v6_run (void *cls,
1229                              const struct GNUNET_SCHEDULER_TaskContext *tc)
1230 {
1231   struct Plugin *plugin = cls;
1232
1233   GNUNET_assert(cls !=NULL);
1234   plugin->http_server_task_v6 = GNUNET_SCHEDULER_NO_TASK;
1235
1236   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1237     return;
1238
1239   GNUNET_assert (MHD_YES == MHD_run (plugin->http_server_daemon_v6));
1240   plugin->http_server_task_v6 = http_server_daemon_prepare (plugin, plugin->http_server_daemon_v6);
1241 }
1242
1243 static size_t curl_get_header_cb( void *ptr, size_t size, size_t nmemb, void *stream)
1244 {
1245   struct Session * ps = stream;
1246
1247   long http_result = 0;
1248   int res;
1249   /* Getting last http result code */
1250   GNUNET_assert(NULL!=ps);
1251   if (ps->recv_connected==GNUNET_NO)
1252   {
1253     res = curl_easy_getinfo(ps->recv_endpoint, CURLINFO_RESPONSE_CODE, &http_result);
1254     if (CURLE_OK == res)
1255     {
1256       if (http_result == 200)
1257       {
1258         ps->recv_connected = GNUNET_YES;
1259         ps->recv_active = GNUNET_YES;
1260 #if DEBUG_CONNECTIONS
1261         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: connected to recieve data\n",ps);
1262 #endif
1263         // Calling send_check_connections again since receive is established
1264         send_check_connections (ps->peercontext->plugin, ps);
1265       }
1266     }
1267   }
1268
1269 #if DEBUG_CURL
1270   char * tmp;
1271   size_t len = size * nmemb;
1272   tmp = NULL;
1273   if ((size * nmemb) < SIZE_MAX)
1274     tmp = GNUNET_malloc (len+1);
1275
1276   if ((tmp != NULL) && (len > 0))
1277   {
1278     memcpy(tmp,ptr,len);
1279     if (len>=2)
1280     {
1281       if (tmp[len-2] == 13)
1282         tmp[len-2]= '\0';
1283     }
1284     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: Header: %s\n",ps,tmp);
1285   }
1286   GNUNET_free_non_null (tmp);
1287 #endif
1288
1289   return size * nmemb;
1290 }
1291
1292 /**
1293  * Callback called by libcurl when new headers arrive
1294  * Used to get HTTP result for curl operations
1295  * @param ptr stream to read from
1296  * @param size size of one char element
1297  * @param nmemb number of char elements
1298  * @param stream closure set by user
1299  * @return bytes read by function
1300  */
1301
1302 static size_t curl_put_header_cb( void *ptr, size_t size, size_t nmemb, void *stream)
1303 {
1304   struct Session * ps = stream;
1305
1306   char * tmp;
1307   size_t len = size * nmemb;
1308   long http_result = 0;
1309   int res;
1310
1311   /* Getting last http result code */
1312   GNUNET_assert(NULL!=ps);
1313   res = curl_easy_getinfo(ps->send_endpoint, CURLINFO_RESPONSE_CODE, &http_result);
1314   if (CURLE_OK == res)
1315   {
1316     if ((http_result == 100) && (ps->send_connected==GNUNET_NO))
1317     {
1318       ps->send_connected = GNUNET_YES;
1319       ps->send_active = GNUNET_YES;
1320 #if DEBUG_CONNECTIONS
1321       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: connected to send data\n",ps);
1322 #endif
1323     }
1324     if ((http_result == 200) && (ps->send_connected==GNUNET_YES))
1325     {
1326       ps->send_connected = GNUNET_NO;
1327       ps->send_active = GNUNET_NO;
1328 #if DEBUG_CONNECTIONS
1329       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: sending disconnected\n",ps);
1330 #endif
1331     }
1332   }
1333
1334   tmp = NULL;
1335   if ((size * nmemb) < SIZE_MAX)
1336     tmp = GNUNET_malloc (len+1);
1337
1338   if ((tmp != NULL) && (len > 0))
1339   {
1340     memcpy(tmp,ptr,len);
1341     if (len>=2)
1342     {
1343       if (tmp[len-2] == 13)
1344         tmp[len-2]= '\0';
1345     }
1346   }
1347
1348   GNUNET_free_non_null (tmp);
1349
1350   return size * nmemb;
1351 }
1352
1353 /**
1354  * Callback method used with libcurl
1355  * Method is called when libcurl needs to read data during sending
1356  * @param stream pointer where to write data
1357  * @param size size of an individual element
1358  * @param nmemb count of elements that can be written to the buffer
1359  * @param ptr source pointer, passed to the libcurl handle
1360  * @return bytes written to stream
1361  */
1362 static size_t curl_send_cb(void *stream, size_t size, size_t nmemb, void *ptr)
1363 {
1364   struct Session * ps = ptr;
1365   struct HTTP_Message * msg = ps->pending_msgs_tail;
1366   size_t bytes_sent;
1367   size_t len;
1368
1369   if (ps->send_active == GNUNET_NO)
1370   {
1371         return CURL_READFUNC_PAUSE;
1372   }
1373
1374   if ((ps->pending_msgs_tail == NULL) && (ps->send_active == GNUNET_YES))
1375   {
1376 #if DEBUG_CONNECTIONS
1377     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: No Message to send, pausing connection\n",ps);
1378 #endif
1379     ps->send_active = GNUNET_NO;
1380     return CURL_READFUNC_PAUSE;
1381   }
1382
1383   GNUNET_assert (msg!=NULL);
1384
1385   /* data to send */
1386   if (msg->pos < msg->size)
1387   {
1388     /* data fit in buffer */
1389     if ((msg->size - msg->pos) <= (size * nmemb))
1390     {
1391       len = (msg->size - msg->pos);
1392       memcpy(stream, &msg->buf[msg->pos], len);
1393       msg->pos += len;
1394       bytes_sent = len;
1395     }
1396     else
1397     {
1398       len = size*nmemb;
1399       memcpy(stream, &msg->buf[msg->pos], len);
1400       msg->pos += len;
1401       bytes_sent = len;
1402     }
1403   }
1404   /* no data to send */
1405   else
1406   {
1407     bytes_sent = 0;
1408   }
1409
1410   if ( msg->pos == msg->size)
1411   {
1412 #if DEBUG_CONNECTIONS
1413     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: Message with %u bytes sent, removing message from queue \n",ps, msg->pos);
1414 #endif
1415     /* Calling transmit continuation  */
1416     if (NULL != ps->pending_msgs_tail->transmit_cont)
1417       msg->transmit_cont (ps->pending_msgs_tail->transmit_cont_cls,&(ps->peercontext)->identity,GNUNET_OK);
1418     remove_http_message(ps, msg);
1419   }
1420   return bytes_sent;
1421 }
1422
1423 static void curl_receive_mst_cb  (void *cls,
1424                                 void *client,
1425                                 const struct GNUNET_MessageHeader *message)
1426 {
1427   struct Session *ps  = cls;
1428   GNUNET_assert(ps != NULL);
1429
1430   struct HTTP_PeerContext *pc = ps->peercontext;
1431   GNUNET_assert(pc != NULL);
1432 #if DEBUG_HTTP
1433   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1434               "Connection %X: Forwarding message to transport service, type %u and size %u from `%s' (`%s')\n",
1435               ps,
1436               ntohs(message->type),
1437               ntohs(message->size),
1438               GNUNET_i2s(&(pc->identity)),http_plugin_address_to_string(NULL,ps->addr,ps->addrlen));
1439 #endif
1440   pc->plugin->env->receive (pc->plugin->env->cls,
1441                             &pc->identity,
1442                             message, 1, ps,
1443                             ps->addr,
1444                             ps->addrlen);
1445 }
1446
1447
1448 /**
1449 * Callback method used with libcurl
1450 * Method is called when libcurl needs to write data during sending
1451 * @param stream pointer where to write data
1452 * @param size size of an individual element
1453 * @param nmemb count of elements that can be written to the buffer
1454 * @param ptr destination pointer, passed to the libcurl handle
1455 * @return bytes read from stream
1456 */
1457 static size_t curl_receive_cb( void *stream, size_t size, size_t nmemb, void *ptr)
1458 {
1459   struct Session * ps = ptr;
1460 #if DEBUG_CONNECTIONS
1461   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: %u bytes received\n",ps, size*nmemb);
1462 #endif
1463   GNUNET_SERVER_mst_receive(ps->msgtok, ps, stream, size*nmemb, GNUNET_NO, GNUNET_NO);
1464   return (size * nmemb);
1465
1466 }
1467
1468 static void curl_handle_finished (struct Plugin *plugin)
1469 {
1470         struct Session *ps = NULL;
1471         struct HTTP_PeerContext *pc = NULL;
1472         struct CURLMsg *msg;
1473         struct HTTP_Message * cur_msg = NULL;
1474
1475         int msgs_in_queue;
1476         char * tmp;
1477         long http_result;
1478
1479         do
1480           {
1481                 msg = curl_multi_info_read (plugin->multi_handle, &msgs_in_queue);
1482                 if ((msgs_in_queue == 0) || (msg == NULL))
1483                   break;
1484                 /* get session for affected curl handle */
1485                 GNUNET_assert ( msg->easy_handle != NULL );
1486                 curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, &tmp);
1487                 ps = (struct Session *) tmp;
1488                 GNUNET_assert ( ps != NULL );
1489                 pc = ps->peercontext;
1490                 GNUNET_assert ( pc != NULL );
1491                 switch (msg->msg)
1492                   {
1493
1494                   case CURLMSG_DONE:
1495                         if ( (msg->data.result != CURLE_OK) &&
1496                                  (msg->data.result != CURLE_GOT_NOTHING) )
1497                         {
1498                           /* sending msg failed*/
1499                           if (msg->easy_handle == ps->send_endpoint)
1500                           {
1501         #if DEBUG_CONNECTIONS
1502                                 GNUNET_log(GNUNET_ERROR_TYPE_INFO,
1503                                                    _("Connection %X: HTTP PUT to peer `%s' (`%s') failed: `%s' `%s'\n"),
1504                                                    ps,
1505                                                    GNUNET_i2s(&pc->identity),
1506                                                    http_plugin_address_to_string(NULL, ps->addr, ps->addrlen),
1507                                                    "curl_multi_perform",
1508                                                    curl_easy_strerror (msg->data.result));
1509         #endif
1510                                 ps->send_connected = GNUNET_NO;
1511                                 ps->send_active = GNUNET_NO;
1512                                 curl_multi_remove_handle(plugin->multi_handle,ps->send_endpoint);
1513                                 //curl_easy_cleanup(ps->send_endpoint);
1514                                 //ps->send_endpoint=NULL;
1515                                 cur_msg = ps->pending_msgs_tail;
1516                                 if (( NULL != cur_msg) && ( NULL != cur_msg->transmit_cont))
1517                                   cur_msg->transmit_cont (cur_msg->transmit_cont_cls,&pc->identity,GNUNET_SYSERR);
1518                           }
1519                           /* GET connection failed */
1520                           if (msg->easy_handle == ps->recv_endpoint)
1521                           {
1522         #if DEBUG_CONNECTIONS
1523                                 GNUNET_log(GNUNET_ERROR_TYPE_INFO,
1524                                          _("Connection %X: HTTP GET to peer `%s' (`%s') failed: `%s' `%s'\n"),
1525                                          ps,
1526                                          GNUNET_i2s(&pc->identity),
1527                                          http_plugin_address_to_string(NULL, ps->addr, ps->addrlen),
1528                                          "curl_multi_perform",
1529                                          curl_easy_strerror (msg->data.result));
1530         #endif
1531                                 ps->recv_connected = GNUNET_NO;
1532                                 ps->recv_active = GNUNET_NO;
1533                                 curl_multi_remove_handle(plugin->multi_handle,ps->recv_endpoint);
1534                                 //curl_easy_cleanup(ps->recv_endpoint);
1535                                 //ps->recv_endpoint=NULL;
1536                           }
1537                         }
1538                         else
1539                         {
1540                           if (msg->easy_handle == ps->send_endpoint)
1541                           {
1542                                 GNUNET_assert (CURLE_OK == curl_easy_getinfo(msg->easy_handle, CURLINFO_RESPONSE_CODE, &http_result));
1543         #if DEBUG_CONNECTIONS
1544                                 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1545                                                         "Connection %X: HTTP PUT connection to peer `%s' (`%s') was closed with HTTP code %u\n",
1546                                                          ps,
1547                                                          GNUNET_i2s(&pc->identity),
1548                                                          http_plugin_address_to_string(NULL, ps->addr, ps->addrlen),
1549                                                          http_result);
1550         #endif
1551                                 /* Calling transmit continuation  */
1552                                 cur_msg = ps->pending_msgs_tail;
1553                                 if (( NULL != cur_msg) && (NULL != cur_msg->transmit_cont))
1554                                 {
1555                                   /* HTTP 1xx : Last message before here was informational */
1556                                   if ((http_result >=100) && (http_result < 200))
1557                                         cur_msg->transmit_cont (cur_msg->transmit_cont_cls,&pc->identity,GNUNET_OK);
1558                                   /* HTTP 2xx: successful operations */
1559                                   if ((http_result >=200) && (http_result < 300))
1560                                         cur_msg->transmit_cont (cur_msg->transmit_cont_cls,&pc->identity,GNUNET_OK);
1561                                   /* HTTP 3xx..5xx: error */
1562                                   if ((http_result >=300) && (http_result < 600))
1563                                         cur_msg->transmit_cont (cur_msg->transmit_cont_cls,&pc->identity,GNUNET_SYSERR);
1564                                 }
1565                                 ps->send_connected = GNUNET_NO;
1566                                 ps->send_active = GNUNET_NO;
1567                                 curl_multi_remove_handle(plugin->multi_handle,ps->send_endpoint);
1568                                 //curl_easy_cleanup(ps->send_endpoint);
1569                                 //ps->send_endpoint =NULL;
1570                           }
1571                           if (msg->easy_handle == ps->recv_endpoint)
1572                           {
1573         #if DEBUG_CONNECTIONS
1574                                 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1575                                                         "Connection %X: HTTP GET connection to peer `%s' (`%s') was closed with HTTP code %u\n",
1576                                                          ps,
1577                                                          GNUNET_i2s(&pc->identity),
1578                                                          http_plugin_address_to_string(NULL, ps->addr, ps->addrlen),
1579                                                          http_result);
1580         #endif
1581                                 ps->recv_connected = GNUNET_NO;
1582                                 ps->recv_active = GNUNET_NO;
1583                                 curl_multi_remove_handle(plugin->multi_handle,ps->recv_endpoint);
1584                                 //curl_easy_cleanup(ps->recv_endpoint);
1585                                 //ps->recv_endpoint=NULL;
1586                           }
1587                         }
1588                         if ((ps->recv_connected == GNUNET_NO) && (ps->send_connected == GNUNET_NO))
1589                           remove_session (pc, ps, GNUNET_YES, GNUNET_SYSERR);
1590                         break;
1591                   default:
1592                         break;
1593                   }
1594           }
1595         while ( (msgs_in_queue > 0) );
1596 }
1597
1598
1599 /**
1600  * Task performing curl operations
1601  * @param cls plugin as closure
1602  * @param tc gnunet scheduler task context
1603  */
1604 static void curl_perform (void *cls,
1605              const struct GNUNET_SCHEDULER_TaskContext *tc)
1606 {
1607   struct Plugin *plugin = cls;
1608   static unsigned int handles_last_run;
1609   int running;
1610   CURLMcode mret;
1611
1612   GNUNET_assert(cls !=NULL);
1613
1614
1615
1616   plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
1617   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1618     return;
1619
1620   do
1621     {
1622       running = 0;
1623       mret = curl_multi_perform (plugin->multi_handle, &running);
1624       if ((running < handles_last_run) && (running>0))
1625           curl_handle_finished(plugin);
1626       handles_last_run = running;
1627     }
1628   while (mret == CURLM_CALL_MULTI_PERFORM);
1629
1630   curl_schedule(plugin);
1631 }
1632
1633
1634 /**
1635  * Function setting up file descriptors and scheduling task to run
1636  *
1637  * @param cls plugin as closure
1638  * @return GNUNET_SYSERR for hard failure, GNUNET_OK for ok
1639  */
1640 static int curl_schedule(void *cls)
1641 {
1642   struct Plugin *plugin = cls;
1643   fd_set rs;
1644   fd_set ws;
1645   fd_set es;
1646   int max;
1647   struct GNUNET_NETWORK_FDSet *grs;
1648   struct GNUNET_NETWORK_FDSet *gws;
1649   long to;
1650   CURLMcode mret;
1651
1652   GNUNET_assert(cls !=NULL);
1653
1654   /* Cancel previous scheduled task */
1655   if (plugin->http_curl_task !=  GNUNET_SCHEDULER_NO_TASK)
1656   {
1657           GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_curl_task);
1658           plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
1659   }
1660
1661   max = -1;
1662   FD_ZERO (&rs);
1663   FD_ZERO (&ws);
1664   FD_ZERO (&es);
1665   mret = curl_multi_fdset (plugin->multi_handle, &rs, &ws, &es, &max);
1666   if (mret != CURLM_OK)
1667     {
1668       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1669                   _("%s failed at %s:%d: `%s'\n"),
1670                   "curl_multi_fdset", __FILE__, __LINE__,
1671                   curl_multi_strerror (mret));
1672       return GNUNET_SYSERR;
1673     }
1674   mret = curl_multi_timeout (plugin->multi_handle, &to);
1675   if (mret != CURLM_OK)
1676     {
1677       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1678                   _("%s failed at %s:%d: `%s'\n"),
1679                   "curl_multi_timeout", __FILE__, __LINE__,
1680                   curl_multi_strerror (mret));
1681       return GNUNET_SYSERR;
1682     }
1683
1684   grs = GNUNET_NETWORK_fdset_create ();
1685   gws = GNUNET_NETWORK_fdset_create ();
1686   GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1);
1687   GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1);
1688   plugin->http_curl_task = GNUNET_SCHEDULER_add_select (plugin->env->sched,
1689                                    GNUNET_SCHEDULER_PRIORITY_DEFAULT,
1690                                    GNUNET_SCHEDULER_NO_TASK,
1691                                                                     (to == -1) ? GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) : GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, to),
1692                                    grs,
1693                                    gws,
1694                                    &curl_perform,
1695                                    plugin);
1696   GNUNET_NETWORK_fdset_destroy (gws);
1697   GNUNET_NETWORK_fdset_destroy (grs);
1698   return GNUNET_OK;
1699 }
1700
1701 /**
1702  * Function setting up curl handle and selecting message to send
1703  *
1704  * @param cls plugin
1705  * @param ps session
1706  * @return GNUNET_SYSERR on failure, GNUNET_NO if connecting, GNUNET_YES if ok
1707  */
1708 static ssize_t send_check_connections (void *cls, struct Session *ps)
1709 {
1710   struct Plugin *plugin = cls;
1711   CURLMcode mret;
1712   struct HTTP_Message * msg;
1713
1714   struct GNUNET_TIME_Relative timeout = GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT;
1715
1716   GNUNET_assert(cls !=NULL);
1717
1718   if (ps->direction == OUTBOUND)
1719   {
1720     /* RECV DIRECTION */
1721     /* Check if session is connected to receive data, otherwise connect to peer */
1722     if (ps->recv_connected == GNUNET_NO)
1723     {
1724         int fresh = GNUNET_NO;
1725         if (ps->recv_endpoint == NULL)
1726         {
1727             fresh = GNUNET_YES;
1728                 ps->recv_endpoint = curl_easy_init();
1729         }
1730 #if DEBUG_CURL
1731         curl_easy_setopt(ps->recv_endpoint, CURLOPT_VERBOSE, 1L);
1732 #endif
1733 #if BUILD_HTTPS
1734         curl_easy_setopt (ps->recv_endpoint, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
1735                 curl_easy_setopt(ps->recv_endpoint, CURLOPT_SSL_VERIFYPEER, 0);
1736                 curl_easy_setopt(ps->recv_endpoint, CURLOPT_SSL_VERIFYHOST, 0);
1737 #endif
1738         curl_easy_setopt(ps->recv_endpoint, CURLOPT_URL, ps->url);
1739         curl_easy_setopt(ps->recv_endpoint, CURLOPT_HEADERFUNCTION, &curl_get_header_cb);
1740         curl_easy_setopt(ps->recv_endpoint, CURLOPT_WRITEHEADER, ps);
1741         curl_easy_setopt(ps->recv_endpoint, CURLOPT_READFUNCTION, curl_send_cb);
1742         curl_easy_setopt(ps->recv_endpoint, CURLOPT_READDATA, ps);
1743         curl_easy_setopt(ps->recv_endpoint, CURLOPT_WRITEFUNCTION, curl_receive_cb);
1744         curl_easy_setopt(ps->recv_endpoint, CURLOPT_WRITEDATA, ps);
1745         curl_easy_setopt(ps->recv_endpoint, CURLOPT_TIMEOUT, (long) timeout.value);
1746         curl_easy_setopt(ps->recv_endpoint, CURLOPT_PRIVATE, ps);
1747         curl_easy_setopt(ps->recv_endpoint, CURLOPT_CONNECTTIMEOUT, HTTP_CONNECT_TIMEOUT);
1748         curl_easy_setopt(ps->recv_endpoint, CURLOPT_BUFFERSIZE, 2*GNUNET_SERVER_MAX_MESSAGE_SIZE);
1749 #if CURL_TCP_NODELAY
1750         curl_easy_setopt(ps->recv_endpoint, CURLOPT_TCP_NODELAY, 1);
1751 #endif
1752
1753         if (fresh==GNUNET_YES)
1754         {
1755                         mret = curl_multi_add_handle(plugin->multi_handle, ps->recv_endpoint);
1756                         if (mret != CURLM_OK)
1757                         {
1758                           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1759                                                   _("Connection: %X: %s failed at %s:%d: `%s'\n"),
1760                                                   ps,
1761                                                   "curl_multi_add_handle", __FILE__, __LINE__,
1762                                                   curl_multi_strerror (mret));
1763                           return GNUNET_SYSERR;
1764                         }
1765         }
1766                 if (plugin->http_curl_task !=  GNUNET_SCHEDULER_NO_TASK)
1767                 {
1768                   GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_curl_task);
1769                   plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
1770                 }
1771                 plugin->http_curl_task = GNUNET_SCHEDULER_add_now (plugin->env->sched, &curl_perform, plugin);
1772     }
1773
1774     /* waiting for receive direction */
1775     if (ps->recv_connected==GNUNET_NO)
1776       return GNUNET_NO;
1777
1778     /* SEND DIRECTION */
1779     /* Check if session is connected to send data, otherwise connect to peer */
1780     if ((ps->send_connected == GNUNET_YES) && (ps->send_endpoint!= NULL))
1781     {
1782       if (ps->send_active == GNUNET_YES)
1783       {
1784 #if DEBUG_CONNECTIONS
1785         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: outbound active, enqueueing message\n",ps);
1786 #endif
1787         return GNUNET_YES;
1788       }
1789       if (ps->send_active == GNUNET_NO)
1790       {
1791 #if DEBUG_CONNECTIONS
1792         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: outbound paused, unpausing existing connection and enqueueing message\n",ps);
1793 #endif
1794         if (CURLE_OK == curl_easy_pause(ps->send_endpoint,CURLPAUSE_CONT))
1795         {
1796                         ps->send_active=GNUNET_YES;
1797                         if (plugin->http_curl_task !=  GNUNET_SCHEDULER_NO_TASK)
1798                         {
1799                           GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_curl_task);
1800                           plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
1801                         }
1802                         plugin->http_curl_task = GNUNET_SCHEDULER_add_now (plugin->env->sched, &curl_perform, plugin);
1803                         return GNUNET_YES;
1804         }
1805         else
1806                 return GNUNET_SYSERR;
1807       }
1808     }
1809     /* not connected, initiate connection */
1810     if (ps->send_connected==GNUNET_NO)
1811     {
1812         int fresh = GNUNET_NO;
1813         if (NULL == ps->send_endpoint)
1814         {
1815                 ps->send_endpoint = curl_easy_init();
1816                 fresh = GNUNET_YES;
1817         }
1818                 GNUNET_assert (ps->send_endpoint != NULL);
1819                 GNUNET_assert (NULL != ps->pending_msgs_tail);
1820 #if DEBUG_CONNECTIONS
1821                 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Connection %X: outbound not connected, initiating connection\n",ps);
1822 #endif
1823                 ps->send_active = GNUNET_NO;
1824                 msg = ps->pending_msgs_tail;
1825
1826 #if DEBUG_CURL
1827                 curl_easy_setopt(ps->send_endpoint, CURLOPT_VERBOSE, 1L);
1828 #endif
1829 #if BUILD_HTTPS
1830         curl_easy_setopt (ps->send_endpoint, CURLOPT_SSLVERSION, CURL_SSLVERSION_TLSv1);
1831                 curl_easy_setopt(ps->send_endpoint, CURLOPT_SSL_VERIFYPEER, 0);
1832                 curl_easy_setopt(ps->send_endpoint, CURLOPT_SSL_VERIFYHOST, 0);
1833 #endif
1834                 curl_easy_setopt(ps->send_endpoint, CURLOPT_URL, ps->url);
1835                 curl_easy_setopt(ps->send_endpoint, CURLOPT_PUT, 1L);
1836                 curl_easy_setopt(ps->send_endpoint, CURLOPT_HEADERFUNCTION, &curl_put_header_cb);
1837                 curl_easy_setopt(ps->send_endpoint, CURLOPT_WRITEHEADER, ps);
1838                 curl_easy_setopt(ps->send_endpoint, CURLOPT_READFUNCTION, curl_send_cb);
1839                 curl_easy_setopt(ps->send_endpoint, CURLOPT_READDATA, ps);
1840                 curl_easy_setopt(ps->send_endpoint, CURLOPT_WRITEFUNCTION, curl_receive_cb);
1841                 curl_easy_setopt(ps->send_endpoint, CURLOPT_READDATA, ps);
1842                 curl_easy_setopt(ps->send_endpoint, CURLOPT_TIMEOUT, (long) timeout.value);
1843                 curl_easy_setopt(ps->send_endpoint, CURLOPT_PRIVATE, ps);
1844                 curl_easy_setopt(ps->send_endpoint, CURLOPT_CONNECTTIMEOUT, HTTP_CONNECT_TIMEOUT);
1845                 curl_easy_setopt(ps->send_endpoint, CURLOPT_BUFFERSIZE, 2 * GNUNET_SERVER_MAX_MESSAGE_SIZE);
1846 #if CURL_TCP_NODELAY
1847                 curl_easy_setopt(ps->send_endpoint, CURLOPT_TCP_NODELAY, 1);
1848 #endif
1849
1850                 if (fresh==GNUNET_YES)
1851                 {
1852                         mret = curl_multi_add_handle(plugin->multi_handle, ps->send_endpoint);
1853                         if (mret != CURLM_OK)
1854                         {
1855                           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1856                                                   _("Connection: %X: %s failed at %s:%d: `%s'\n"),
1857                                                   ps,
1858                                                   "curl_multi_add_handle", __FILE__, __LINE__,
1859                                                   curl_multi_strerror (mret));
1860                           return GNUNET_SYSERR;
1861                         }
1862                 }
1863     }
1864         if (plugin->http_curl_task !=  GNUNET_SCHEDULER_NO_TASK)
1865         {
1866           GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_curl_task);
1867           plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
1868         }
1869         plugin->http_curl_task = GNUNET_SCHEDULER_add_now (plugin->env->sched, &curl_perform, plugin);
1870     return GNUNET_YES;
1871   }
1872   if (ps->direction == INBOUND)
1873   {
1874     GNUNET_assert (NULL != ps->pending_msgs_tail);
1875     if ((ps->recv_connected==GNUNET_YES) && (ps->send_connected==GNUNET_YES) &&
1876         (ps->recv_force_disconnect==GNUNET_NO) && (ps->recv_force_disconnect==GNUNET_NO))
1877         return GNUNET_YES;
1878   }
1879   return GNUNET_SYSERR;
1880 }
1881
1882 /**
1883  * select best session to transmit data to peer
1884  *
1885  * @param cls closure
1886  * @param pc peer context of target peer
1887  * @param addr address of target peer
1888  * @param addrlen address length
1889  * @param force_address does transport service enforce address?
1890  * @param session session passed by transport service
1891  * @return selected session
1892  *
1893  */
1894 static struct Session * send_select_session (void * cls, struct HTTP_PeerContext *pc, const void * addr, size_t addrlen, int force_address, struct Session * session)
1895 {
1896         struct Session * tmp = NULL;
1897         int addr_given = GNUNET_NO;
1898
1899         if ((addr!=NULL) && (addrlen>0))
1900                 addr_given = GNUNET_YES;
1901
1902         if (force_address == GNUNET_YES)
1903         {
1904                 /* check session given as argument */
1905                 if ((session != NULL) && (addr_given == GNUNET_YES))
1906                 {
1907                       if (0 == memcmp(session->addr, addr, addrlen))
1908                       {
1909                         /* connection can not be used, since it is disconnected */
1910                         if ((session->recv_force_disconnect==GNUNET_NO) && (session->send_force_disconnect==GNUNET_NO))
1911                         {
1912 #if DEBUG_SESSION_SELECTION
1913                                   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Session %X selected: Using session passed by transport to send to forced address \n", session);
1914 #endif
1915                                 return session;
1916                         }
1917                       }
1918                 }
1919                 /* check last session used */
1920                 if ((pc->last_session != NULL)&& (addr_given == GNUNET_YES))
1921                 {
1922                       if (0 == memcmp(pc->last_session->addr, addr, addrlen))
1923                       {
1924                         /* connection can not be used, since it is disconnected */
1925                         if ((pc->last_session->recv_force_disconnect==GNUNET_NO) && (pc->last_session->send_force_disconnect==GNUNET_NO))
1926                         {
1927 #if DEBUG_SESSION_SELECTION
1928                                   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Session %X selected: Using last session used to send to forced address \n", pc->last_session);
1929 #endif
1930                                 return pc->last_session;
1931                         }
1932                       }
1933                 }
1934                 /* find session in existing sessions */
1935                 tmp = pc->head;
1936                 while ((tmp!=NULL) && (addr_given == GNUNET_YES))
1937                 {
1938
1939                           if (0 == memcmp(tmp->addr, addr, addrlen))
1940                       {
1941                         /* connection can not be used, since it is disconnected */
1942                         if ((tmp->recv_force_disconnect==GNUNET_NO) && (tmp->send_force_disconnect==GNUNET_NO))
1943                         {
1944 #if DEBUG_SESSION_SELECTION
1945                                   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Session %X selected: Using existing session to send to forced address \n", session);
1946 #endif
1947                                   return session;
1948                         }
1949
1950                       }
1951                           tmp=tmp->next;
1952                 }
1953                 /* no session to use */
1954                 return NULL;
1955         }
1956         if ((force_address == GNUNET_NO) || (force_address == GNUNET_SYSERR))
1957         {
1958                 /* check session given as argument */
1959                 if (session != NULL)
1960                 {
1961                         /* connection can not be used, since it is disconnected */
1962                         if ((session->recv_force_disconnect==GNUNET_NO) && (session->send_force_disconnect==GNUNET_NO))
1963                         {
1964 #if DEBUG_SESSION_SELECTION
1965                                   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Session %X selected: Using session passed by transport to send not-forced address \n", session);
1966 #endif
1967                                   return session;
1968                         }
1969
1970                 }
1971                 /* check last session used */
1972                 if (pc->last_session != NULL)
1973                 {
1974                         /* connection can not be used, since it is disconnected */
1975                         if ((pc->last_session->recv_force_disconnect==GNUNET_NO) && (pc->last_session->send_force_disconnect==GNUNET_NO))
1976                         {
1977 #if DEBUG_SESSION_SELECTION
1978                                   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Session %X selected: Using last session to send to not-forced address \n", pc->last_session);
1979 #endif
1980                                 return pc->last_session;
1981                         }
1982                 }
1983                 /* find session in existing sessions */
1984                 tmp = pc->head;
1985                 while (tmp!=NULL)
1986                 {
1987                         /* connection can not be used, since it is disconnected */
1988                         if ((tmp->recv_force_disconnect==GNUNET_NO) && (tmp->send_force_disconnect==GNUNET_NO))
1989                         {
1990 #if DEBUG_SESSION_SELECTION
1991                                   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Session %X selected: Using existing session to send to not-forced address \n", tmp);
1992 #endif
1993                                 return tmp;
1994                         }
1995                         tmp=tmp->next;
1996                 }
1997                 return NULL;
1998         }
1999         return NULL;
2000 }
2001
2002 /**
2003  * Function that can be used by the transport service to transmit
2004  * a message using the plugin.   Note that in the case of a
2005  * peer disconnecting, the continuation MUST be called
2006  * prior to the disconnect notification itself.  This function
2007  * will be called with this peer's HELLO message to initiate
2008  * a fresh connection to another peer.
2009  *
2010  * @param cls closure
2011  * @param target who should receive this message
2012  * @param msgbuf the message to transmit
2013  * @param msgbuf_size number of bytes in 'msgbuf'
2014  * @param priority how important is the message (most plugins will
2015  *                 ignore message priority and just FIFO)
2016  * @param to how long to wait at most for the transmission (does not
2017  *                require plugins to discard the message after the timeout,
2018  *                just advisory for the desired delay; most plugins will ignore
2019  *                this as well)
2020  * @param session which session must be used (or NULL for "any")
2021  * @param addr the address to use (can be NULL if the plugin
2022  *                is "on its own" (i.e. re-use existing TCP connection))
2023  * @param addrlen length of the address in bytes
2024  * @param force_address GNUNET_YES if the plugin MUST use the given address,
2025  *                GNUNET_NO means the plugin may use any other address and
2026  *                GNUNET_SYSERR means that only reliable existing
2027  *                bi-directional connections should be used (regardless
2028  *                of address)
2029  * @param cont continuation to call once the message has
2030  *        been transmitted (or if the transport is ready
2031  *        for the next transmission call; or if the
2032  *        peer disconnected...); can be NULL
2033  * @param cont_cls closure for cont
2034  * @return number of bytes used (on the physical network, with overheads);
2035  *         -1 on hard errors (i.e. address invalid); 0 is a legal value
2036  *         and does NOT mean that the message was not transmitted (DV)
2037  */
2038 static ssize_t
2039 http_plugin_send (void *cls,
2040                   const struct GNUNET_PeerIdentity *target,
2041                   const char *msgbuf,
2042                   size_t msgbuf_size,
2043                   unsigned int priority,
2044                   struct GNUNET_TIME_Relative to,
2045                   struct Session *session,
2046                   const void *addr,
2047                   size_t addrlen,
2048                   int force_address,
2049                   GNUNET_TRANSPORT_TransmitContinuation cont,
2050                   void *cont_cls)
2051 {
2052   struct Plugin *plugin = cls;
2053   struct HTTP_Message *msg;
2054   struct HTTP_PeerContext * pc;
2055   struct Session * ps = NULL;
2056
2057   GNUNET_assert(cls !=NULL);
2058
2059 #if DEBUG_HTTP
2060   char * force;
2061   if (force_address == GNUNET_YES)
2062           GNUNET_asprintf(&force, "forced addr.");
2063   if (force_address == GNUNET_NO)
2064           GNUNET_asprintf(&force, "any addr.");
2065   if (force_address == GNUNET_SYSERR)
2066           GNUNET_asprintf(&force,"reliable bi-direc. address addr.");
2067
2068   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Transport tells me to send %u bytes to `%s' using %s (%s) and session: %X\n",
2069                                       msgbuf_size,
2070                                       GNUNET_i2s(target),
2071                                       force,
2072                                       http_plugin_address_to_string(NULL, addr, addrlen),
2073                                       session);
2074
2075   GNUNET_free(force);
2076 #endif
2077
2078   pc = GNUNET_CONTAINER_multihashmap_get (plugin->peers, &target->hashPubKey);
2079   /* Peer unknown */
2080   if (pc==NULL)
2081   {
2082     pc = GNUNET_malloc(sizeof (struct HTTP_PeerContext));
2083     pc->plugin = plugin;
2084     pc->session_id_counter=1;
2085     pc->last_session = NULL;
2086     memcpy(&pc->identity, target, sizeof(struct GNUNET_PeerIdentity));
2087     GNUNET_CONTAINER_multihashmap_put(plugin->peers, &pc->identity.hashPubKey, pc, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
2088     GNUNET_STATISTICS_update (plugin->env->stats,
2089                             gettext_noop ("# HTTP peers active"),
2090                             1,
2091                             GNUNET_NO);
2092   }
2093
2094   ps = send_select_session (plugin, pc, addr, addrlen, force_address, session);
2095
2096   /* session not existing, but address forced -> creating new session */
2097   if (ps==NULL)
2098   {
2099     if ((addr!=NULL) && (addrlen!=0))
2100     {
2101       ps = GNUNET_malloc(sizeof (struct Session));
2102 #if DEBUG_SESSION_SELECTION
2103       if (force_address == GNUNET_YES)
2104         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"No existing connection & forced address: creating new session %X to peer %s\n", ps, GNUNET_i2s(target));
2105       if (force_address != GNUNET_YES)
2106         GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"No existing connection: creating new session %X to peer %s\n", ps, GNUNET_i2s(target));
2107 #endif
2108       if ((addrlen!=0) && (addr!=NULL))
2109       {
2110       ps->addr = GNUNET_malloc(addrlen);
2111       memcpy(ps->addr,addr,addrlen);
2112       ps->addrlen = addrlen;
2113       }
2114       else
2115       {
2116         ps->addr = NULL;
2117         ps->addrlen = 0;
2118       }
2119       ps->direction=OUTBOUND;
2120       ps->recv_connected = GNUNET_NO;
2121       ps->recv_force_disconnect = GNUNET_NO;
2122       ps->send_connected = GNUNET_NO;
2123       ps->send_force_disconnect = GNUNET_NO;
2124       ps->pending_msgs_head = NULL;
2125       ps->pending_msgs_tail = NULL;
2126       ps->peercontext=pc;
2127       ps->session_id = pc->session_id_counter;
2128       pc->session_id_counter++;
2129       ps->url = create_url (plugin, ps->addr, ps->addrlen, ps->session_id);
2130       if (ps->msgtok == NULL)
2131         ps->msgtok = GNUNET_SERVER_mst_create (&curl_receive_mst_cb, ps);
2132       GNUNET_CONTAINER_DLL_insert(pc->head,pc->tail,ps);
2133 /* FIXME */
2134
2135       GNUNET_STATISTICS_update (plugin->env->stats,
2136                             gettext_noop ("# HTTP outbound sessions for peers active"),
2137                             1,
2138                             GNUNET_NO);
2139     }
2140     else
2141     {
2142 #if DEBUG_HTTP
2143       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"No existing session found & and no address given: no way to send this message to peer `%s'!\n", GNUNET_i2s(target));
2144 #endif
2145       return GNUNET_SYSERR;
2146     }
2147   }
2148
2149   /* create msg */
2150   msg = GNUNET_malloc (sizeof (struct HTTP_Message) + msgbuf_size);
2151   msg->next = NULL;
2152   msg->size = msgbuf_size;
2153   msg->pos = 0;
2154   msg->buf = (char *) &msg[1];
2155   msg->transmit_cont = cont;
2156   msg->transmit_cont_cls = cont_cls;
2157   memcpy (msg->buf,msgbuf, msgbuf_size);
2158   GNUNET_CONTAINER_DLL_insert(ps->pending_msgs_head,ps->pending_msgs_tail,msg);
2159
2160   if (send_check_connections (plugin, ps) == GNUNET_SYSERR)
2161           return GNUNET_SYSERR;
2162           if (force_address != GNUNET_YES)
2163                   pc->last_session = ps;
2164
2165           if (pc->last_session==NULL)
2166                   pc->last_session = ps;
2167           return msg->size;
2168 }
2169
2170
2171
2172 /**
2173  * Function that can be used to force the plugin to disconnect
2174  * from the given peer and cancel all previous transmissions
2175  * (and their continuationc).
2176  *
2177  * @param cls closure
2178  * @param target peer from which to disconnect
2179  */
2180 static void
2181 http_plugin_disconnect (void *cls,
2182                             const struct GNUNET_PeerIdentity *target)
2183 {
2184
2185
2186   struct Plugin *plugin = cls;
2187   struct HTTP_PeerContext *pc = NULL;
2188   struct Session *ps = NULL;
2189   //struct Session *tmp = NULL;
2190
2191   pc = GNUNET_CONTAINER_multihashmap_get (plugin->peers, &target->hashPubKey);
2192   if (pc==NULL)
2193     return;
2194   ps = pc->head;
2195
2196   while (ps!=NULL)
2197   {
2198     /* Telling transport that session is getting disconnected */
2199     plugin->env->session_end(plugin, target, ps);
2200     if (ps->direction==OUTBOUND)
2201     {
2202       if (ps->send_endpoint!=NULL)
2203       {
2204         //GNUNET_assert(CURLM_OK == curl_multi_remove_handle(plugin->multi_handle,ps->send_endpoint));
2205         //curl_easy_cleanup(ps->send_endpoint);
2206         //ps->send_endpoint=NULL;
2207         ps->send_force_disconnect = GNUNET_YES;
2208       }
2209       if (ps->recv_endpoint!=NULL)
2210       {
2211        //GNUNET_assert(CURLM_OK == curl_multi_remove_handle(plugin->multi_handle,ps->recv_endpoint));
2212        //curl_easy_cleanup(ps->recv_endpoint);
2213        //ps->recv_endpoint=NULL;
2214        ps->recv_force_disconnect = GNUNET_YES;
2215       }
2216     }
2217
2218     if (ps->direction==INBOUND)
2219     {
2220       ps->recv_force_disconnect = GNUNET_YES;
2221       ps->send_force_disconnect = GNUNET_YES;
2222     }
2223
2224     while (ps->pending_msgs_head!=NULL)
2225     {
2226       remove_http_message(ps, ps->pending_msgs_head);
2227     }
2228     ps->recv_active = GNUNET_NO;
2229     ps->send_active = GNUNET_NO;
2230     ps=ps->next;
2231   }
2232 }
2233
2234
2235 /**
2236  * Convert the transports address to a nice, human-readable
2237  * format.
2238  *
2239  * @param cls closure
2240  * @param type name of the transport that generated the address
2241  * @param addr one of the addresses of the host, NULL for the last address
2242  *        the specific address format depends on the transport
2243  * @param addrlen length of the address
2244  * @param numeric should (IP) addresses be displayed in numeric form?
2245  * @param timeout after how long should we give up?
2246  * @param asc function to call on each string
2247  * @param asc_cls closure for asc
2248  */
2249 static void
2250 http_plugin_address_pretty_printer (void *cls,
2251                                         const char *type,
2252                                         const void *addr,
2253                                         size_t addrlen,
2254                                         int numeric,
2255                                         struct GNUNET_TIME_Relative timeout,
2256                                         GNUNET_TRANSPORT_AddressStringCallback
2257                                         asc, void *asc_cls)
2258 {
2259   const struct IPv4HttpAddress *t4;
2260   const struct IPv6HttpAddress *t6;
2261   struct sockaddr_in a4;
2262   struct sockaddr_in6 a6;
2263   char * address;
2264   char * ret;
2265   unsigned int port;
2266   unsigned int res;
2267
2268   GNUNET_assert(cls !=NULL);
2269   if (addrlen == sizeof (struct IPv6HttpAddress))
2270   {
2271     address = GNUNET_malloc (INET6_ADDRSTRLEN);
2272     t6 = addr;
2273     a6.sin6_addr = t6->ipv6_addr;
2274     inet_ntop(AF_INET6, &(a6.sin6_addr),address,INET6_ADDRSTRLEN);
2275     port = ntohs(t6->u6_port);
2276   }
2277   else if (addrlen == sizeof (struct IPv4HttpAddress))
2278   {
2279     address = GNUNET_malloc (INET_ADDRSTRLEN);
2280     t4 = addr;
2281     a4.sin_addr.s_addr =  t4->ipv4_addr;
2282     inet_ntop(AF_INET, &(a4.sin_addr),address,INET_ADDRSTRLEN);
2283     port = ntohs(t4->u_port);
2284   }
2285   else
2286   {
2287     /* invalid address */
2288     GNUNET_break_op (0);
2289     asc (asc_cls, NULL);
2290     return;
2291   }
2292   res = GNUNET_asprintf(&ret,"%s://%s:%u/", PROTOCOL_PREFIX, address, port);
2293   GNUNET_free (address);
2294   GNUNET_assert(res != 0);
2295   asc (asc_cls, ret);
2296   GNUNET_free_non_null (ret);
2297 }
2298
2299
2300
2301 /**
2302  * Another peer has suggested an address for this
2303  * peer and transport plugin.  Check that this could be a valid
2304  * address.  If so, consider adding it to the list
2305  * of addresses.
2306  *
2307  * @param cls closure
2308  * @param addr pointer to the address
2309  * @param addrlen length of addr
2310  * @return GNUNET_OK if this is a plausible address for this peer
2311  *         and transport
2312  */
2313 static int
2314 http_plugin_address_suggested (void *cls,
2315                                const void *addr, size_t addrlen)
2316 {
2317   struct Plugin *plugin = cls;
2318   struct IPv4HttpAddress *v4;
2319   struct IPv6HttpAddress *v6;
2320   unsigned int port;
2321
2322   GNUNET_assert(cls !=NULL);
2323   if ((addrlen != sizeof (struct IPv4HttpAddress)) &&
2324       (addrlen != sizeof (struct IPv6HttpAddress)))
2325     {
2326       return GNUNET_SYSERR;
2327     }
2328   if (addrlen == sizeof (struct IPv4HttpAddress))
2329     {
2330       v4 = (struct IPv4HttpAddress *) addr;
2331       /* Not skipping loopback
2332       if (INADDR_LOOPBACK == ntohl(v4->ipv4_addr))
2333       {
2334         return GNUNET_SYSERR;
2335       } */
2336       port = ntohs (v4->u_port);
2337       if (port != plugin->port_inbound)
2338       {
2339         return GNUNET_SYSERR;
2340       }
2341     }
2342   if (addrlen == sizeof (struct IPv6HttpAddress))
2343     {
2344       v6 = (struct IPv6HttpAddress *) addr;
2345       if (IN6_IS_ADDR_LINKLOCAL (&v6->ipv6_addr))
2346         {
2347           return GNUNET_SYSERR;
2348         }
2349       port = ntohs (v6->u6_port);
2350       if (port != plugin->port_inbound)
2351       {
2352         return GNUNET_SYSERR;
2353       }
2354     }
2355
2356   return GNUNET_OK;
2357 }
2358
2359
2360 /**
2361  * Function called for a quick conversion of the binary address to
2362  * a numeric address.  Note that the caller must not free the
2363  * address and that the next call to this function is allowed
2364  * to override the address again.
2365  *
2366  * @param cls closure
2367  * @param addr binary address
2368  * @param addrlen length of the address
2369  * @return string representing the same address
2370  */
2371 static const char*
2372 http_plugin_address_to_string (void *cls,
2373                                    const void *addr,
2374                                    size_t addrlen)
2375 {
2376   const struct IPv4HttpAddress *t4;
2377   const struct IPv6HttpAddress *t6;
2378   struct sockaddr_in a4;
2379   struct sockaddr_in6 a6;
2380   char * address;
2381   char * ret;
2382   uint16_t port;
2383   unsigned int res;
2384
2385   if (addrlen == sizeof (struct IPv6HttpAddress))
2386     {
2387       address = GNUNET_malloc (INET6_ADDRSTRLEN);
2388       t6 = addr;
2389       a6.sin6_addr = t6->ipv6_addr;
2390       inet_ntop(AF_INET6, &(a6.sin6_addr),address,INET6_ADDRSTRLEN);
2391       port = ntohs(t6->u6_port);
2392     }
2393   else if (addrlen == sizeof (struct IPv4HttpAddress))
2394     {
2395       address = GNUNET_malloc (INET_ADDRSTRLEN);
2396       t4 = addr;
2397       a4.sin_addr.s_addr =  t4->ipv4_addr;
2398       inet_ntop(AF_INET, &(a4.sin_addr),address,INET_ADDRSTRLEN);
2399       port = ntohs(t4->u_port);
2400     }
2401   else
2402     {
2403       /* invalid address */
2404       return NULL;
2405     }
2406   res = GNUNET_asprintf(&ret,"%s:%u",address,port);
2407   GNUNET_free (address);
2408   GNUNET_assert(res != 0);
2409   return ret;
2410 }
2411
2412
2413 /**
2414  * Exit point from the plugin.
2415  */
2416 void *
2417 LIBGNUNET_PLUGIN_TRANSPORT_DONE (void *cls)
2418 {
2419   struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
2420   struct Plugin *plugin = api->cls;
2421   CURLMcode mret;
2422   GNUNET_assert(cls !=NULL);
2423
2424   if (plugin->http_server_daemon_v4 != NULL)
2425   {
2426     MHD_stop_daemon (plugin->http_server_daemon_v4);
2427     plugin->http_server_daemon_v4 = NULL;
2428   }
2429   if (plugin->http_server_daemon_v6 != NULL)
2430   {
2431     MHD_stop_daemon (plugin->http_server_daemon_v6);
2432     plugin->http_server_daemon_v6 = NULL;
2433   }
2434
2435   if ( plugin->http_server_task_v4 != GNUNET_SCHEDULER_NO_TASK)
2436   {
2437     GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_server_task_v4);
2438     plugin->http_server_task_v4 = GNUNET_SCHEDULER_NO_TASK;
2439   }
2440
2441   if ( plugin->http_server_task_v6 != GNUNET_SCHEDULER_NO_TASK)
2442   {
2443     GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_server_task_v6);
2444     plugin->http_server_task_v6 = GNUNET_SCHEDULER_NO_TASK;
2445   }
2446
2447
2448   /* free all peer information */
2449   if (plugin->peers!=NULL)
2450   {
2451           GNUNET_CONTAINER_multihashmap_iterate (plugin->peers,
2452                                                                                          &remove_peer_context_Iterator,
2453                                                                                          plugin);
2454           GNUNET_CONTAINER_multihashmap_destroy (plugin->peers);
2455   }
2456   if (plugin->multi_handle!=NULL)
2457   {
2458           mret = curl_multi_cleanup(plugin->multi_handle);
2459 #if DEBUG_HTTP
2460           if ( CURLM_OK != mret)
2461                 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"curl multihandle clean up failed\n");
2462 #endif
2463           plugin->multi_handle = NULL;
2464   }
2465   curl_global_cleanup();
2466
2467   if ( plugin->http_curl_task != GNUNET_SCHEDULER_NO_TASK)
2468   {
2469     GNUNET_SCHEDULER_cancel(plugin->env->sched, plugin->http_curl_task);
2470     plugin->http_curl_task = GNUNET_SCHEDULER_NO_TASK;
2471   }
2472
2473   GNUNET_free_non_null (plugin->bind4_address);
2474   GNUNET_free_non_null (plugin->bind6_address);
2475   GNUNET_free_non_null(plugin->bind_hostname);
2476 #if BUILD_HTTPS
2477   GNUNET_free_non_null (plugin->crypto_init);
2478   GNUNET_free_non_null (plugin->cert);
2479   GNUNET_free_non_null (plugin->key);
2480 #endif
2481   GNUNET_free (plugin);
2482   GNUNET_free (api);
2483 #if DEBUG_HTTP
2484   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Unload %s plugin complete...\n", PROTOCOL_PREFIX);
2485 #endif
2486   return NULL;
2487 }
2488
2489 #if BUILD_HTTPS
2490 static char *
2491 load_certificate( const char * file )
2492 {
2493   struct GNUNET_DISK_FileHandle * gn_file;
2494
2495   struct stat fstat;
2496   char * text = NULL;
2497
2498   if (0!=STAT(file, &fstat))
2499           return NULL;
2500   text = GNUNET_malloc (fstat.st_size+1);
2501   gn_file = GNUNET_DISK_file_open(file,GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_USER_READ);
2502   if (gn_file==NULL)
2503   {
2504           GNUNET_free(text);
2505           return NULL;
2506   }
2507   if (GNUNET_SYSERR == GNUNET_DISK_file_read(gn_file, text, fstat.st_size))
2508   {
2509           GNUNET_free(text);
2510           GNUNET_DISK_file_close(gn_file);
2511           return NULL;
2512   }
2513   text[fstat.st_size] = '\0';
2514   GNUNET_DISK_file_close(gn_file);
2515
2516   return text;
2517 }
2518 #endif
2519
2520
2521 /**
2522  * Entry point for the plugin.
2523  */
2524 void *
2525 LIBGNUNET_PLUGIN_TRANSPORT_INIT (void *cls)
2526 {
2527   struct GNUNET_TRANSPORT_PluginEnvironment *env = cls;
2528   struct Plugin *plugin;
2529   struct GNUNET_TRANSPORT_PluginFunctions *api;
2530   struct GNUNET_TIME_Relative gn_timeout;
2531   long long unsigned int port;
2532   char * component_name;
2533 #if BUILD_HTTPS
2534   char * key_file = NULL;
2535   char * cert_file = NULL;
2536 #endif
2537
2538   GNUNET_assert(cls !=NULL);
2539 #if DEBUG_HTTP
2540   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Starting %s plugin...\n", PROTOCOL_PREFIX);
2541 #endif
2542   GNUNET_asprintf(&component_name,"transport-%s",PROTOCOL_PREFIX);
2543
2544   plugin = GNUNET_malloc (sizeof (struct Plugin));
2545   plugin->stats = env->stats;
2546   plugin->env = env;
2547   plugin->peers = NULL;
2548   plugin->bind4_address = NULL;
2549   plugin->use_ipv6  = GNUNET_YES;
2550   plugin->use_ipv4  = GNUNET_YES;
2551
2552   api = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_PluginFunctions));
2553   api->cls = plugin;
2554   api->send = &http_plugin_send;
2555   api->disconnect = &http_plugin_disconnect;
2556   api->address_pretty_printer = &http_plugin_address_pretty_printer;
2557   api->check_address = &http_plugin_address_suggested;
2558   api->address_to_string = &http_plugin_address_to_string;
2559
2560   /* Hashing our identity to use it in URLs */
2561   GNUNET_CRYPTO_hash_to_enc ( &(plugin->env->my_identity->hashPubKey), &plugin->my_ascii_hash_ident);
2562
2563   /* Use IPv6? */
2564   if (GNUNET_CONFIGURATION_have_value (env->cfg,
2565                                                                            component_name, "USE_IPv6"))
2566     {
2567           plugin->use_ipv6 = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
2568                                                                                                                            component_name,
2569                                                                                                                            "USE_IPv6");
2570     }
2571   /* Use IPv4? */
2572   if (GNUNET_CONFIGURATION_have_value (env->cfg,
2573                                                                            component_name, "USE_IPv4"))
2574     {
2575           plugin->use_ipv4 = GNUNET_CONFIGURATION_get_value_yesno (env->cfg,
2576                                                         component_name,"USE_IPv4");
2577     }
2578   /* Reading port number from config file */
2579   if ((GNUNET_OK !=
2580        GNUNET_CONFIGURATION_get_value_number (env->cfg,
2581                                                                                           component_name,
2582                                               "PORT",
2583                                               &port)) ||
2584       (port > 65535) )
2585     {
2586       GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
2587                                            component_name,
2588                        _("Require valid port number for transport plugin `%s' in configuration!\n"),
2589                        PROTOCOL_PREFIX);
2590       GNUNET_free(component_name);
2591       LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
2592       return NULL;
2593     }
2594
2595   /* Reading ipv4 addresse to bind to from config file */
2596   if ((plugin->use_ipv4==GNUNET_YES) && (GNUNET_CONFIGURATION_have_value (env->cfg,
2597                                                                                                           component_name, "BINDTO4")))
2598   {
2599           GNUNET_break (GNUNET_OK ==
2600                                         GNUNET_CONFIGURATION_get_value_string (env->cfg,
2601                                                                                                                    component_name,
2602                                                                                                                    "BINDTO4",
2603                                                                                                                    &plugin->bind_hostname));
2604           plugin->bind4_address = GNUNET_malloc(sizeof(struct sockaddr_in));
2605           plugin->bind4_address->sin_family = AF_INET;
2606           plugin->bind4_address->sin_port = htons (port);
2607
2608           if (inet_pton(AF_INET,plugin->bind_hostname, &plugin->bind4_address->sin_addr)<=0)
2609           {
2610                   GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
2611                                                    component_name,
2612                                                    _("Misconfigured address to bind to in configuration!\n"));
2613                   GNUNET_free(plugin->bind4_address);
2614                   GNUNET_free(plugin->bind_hostname);
2615                   plugin->bind_hostname = NULL;
2616                   plugin->bind4_address = NULL;
2617           }
2618   }
2619
2620   /* Reading ipv4 addresse to bind to from config file */
2621   if ((plugin->use_ipv6==GNUNET_YES) && (GNUNET_CONFIGURATION_have_value (env->cfg,
2622                   component_name, "BINDTO6")))
2623   {
2624           if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (env->cfg,
2625                                                                                                                           component_name,
2626                                                                                                                           "BINDTO6",
2627                                                                                                                           &plugin->bind_hostname))
2628           {
2629                   plugin->bind6_address = GNUNET_malloc(sizeof(struct sockaddr_in6));
2630                   plugin->bind6_address->sin6_family = AF_INET6;
2631                   plugin->bind6_address->sin6_port = htons (port);
2632
2633                   if (inet_pton(AF_INET6,plugin->bind_hostname, &plugin->bind6_address->sin6_addr)<=0)
2634                   {
2635                           GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
2636                                                            component_name,
2637                                                            _("Misconfigured address to bind to in configuration!\n"));
2638                           GNUNET_free(plugin->bind6_address);
2639                           GNUNET_free(plugin->bind_hostname);
2640                           plugin->bind_hostname = NULL;
2641                           plugin->bind6_address = NULL;
2642                   }
2643           }
2644   }
2645
2646 #if BUILD_HTTPS
2647   /* Reading HTTPS crypto related configuration */
2648   /* Get crypto init string from config */
2649   if (GNUNET_CONFIGURATION_have_value (env->cfg,
2650                                                                            "transport-https", "CRYPTO_INIT"))
2651   {
2652                 GNUNET_CONFIGURATION_get_value_string (env->cfg,
2653                                                                                            "transport-https",
2654                                                                                            "CRYPTO_INIT",
2655                                                                                            &plugin->crypto_init);
2656   }
2657   else
2658   {
2659           GNUNET_asprintf(&plugin->crypto_init,"NORMAL");
2660   }
2661
2662 /* Get private key file from config */
2663   if (GNUNET_CONFIGURATION_have_value (env->cfg,
2664                                                                            "transport-https", "KEY_FILE"))
2665   {
2666                 GNUNET_CONFIGURATION_get_value_string (env->cfg,
2667                                                                                            "transport-https",
2668                                                                                            "KEY_FILE",
2669                                                                                            &key_file);
2670   }
2671   if (key_file==NULL)
2672           GNUNET_asprintf(&key_file,"https.key");
2673
2674 /* Get private key file from config */
2675   if (GNUNET_CONFIGURATION_have_value (env->cfg,"transport-https", "CERT_FILE"))
2676   {
2677           GNUNET_CONFIGURATION_get_value_string (env->cfg,
2678                                                                                          "transport-https",
2679                                                                                          "CERT_FILE",
2680                                                                                          &cert_file);
2681   }
2682   if (cert_file==NULL)
2683           GNUNET_asprintf(&cert_file,"https.cert");
2684
2685   /* read key & certificates from file */
2686   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Loading TLS certificate `%s' `%s'\n", key_file, cert_file);
2687
2688   plugin->key = load_certificate( key_file );
2689   plugin->cert = load_certificate( cert_file );
2690
2691   if ((plugin->key==NULL) || (plugin->cert==NULL))
2692   {
2693           char * cmd;
2694           int ret = 0;
2695           GNUNET_asprintf(&cmd,"gnunet-transport-certificate-creation %s %s", key_file, cert_file);
2696           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No usable TLS certificate found, creating certificate \n");
2697           ret = system(cmd);
2698
2699           if (ret != 0)
2700           {
2701                   GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
2702                                            "https",
2703                                                    _("Could not create a new TLS certificate, shell script `%s' failed!\n"),cmd,
2704                                                    "transport-https");
2705                   GNUNET_free (key_file);
2706                   GNUNET_free (cert_file);
2707                   GNUNET_free (component_name);
2708
2709                   LIBGNUNET_PLUGIN_TRANSPORT_DONE(api);
2710                   GNUNET_free (cmd);
2711                   return NULL;
2712           }
2713
2714           GNUNET_free (cmd);
2715
2716           plugin->key = load_certificate( key_file );
2717           plugin->cert = load_certificate( cert_file );
2718
2719           if ((plugin->key==NULL) || (plugin->cert==NULL))
2720           {
2721                   GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
2722                                            "https",
2723                                                    _("No usable TLS certificate found and creating one failed! \n"),
2724                                                    "transport-https");
2725                   GNUNET_free (key_file);
2726                   GNUNET_free (cert_file);
2727                   GNUNET_free (component_name);
2728
2729                   LIBGNUNET_PLUGIN_TRANSPORT_DONE(api);
2730                   return NULL;
2731           }
2732   }
2733
2734   GNUNET_free (key_file);
2735   GNUNET_free (cert_file);
2736
2737
2738   GNUNET_assert((plugin->key!=NULL) && (plugin->cert!=NULL));
2739   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "TLS certificate loaded\n");
2740 #endif
2741
2742   GNUNET_assert ((port > 0) && (port <= 65535));
2743   plugin->port_inbound = port;
2744   gn_timeout = GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT;
2745   unsigned int timeout = (gn_timeout.value) / 1000;
2746   if ((plugin->http_server_daemon_v6 == NULL) && (plugin->use_ipv6 == GNUNET_YES) && (port != 0))
2747   {
2748         struct sockaddr * tmp = (struct sockaddr *) plugin->bind6_address;
2749     plugin->http_server_daemon_v6 = MHD_start_daemon (
2750 #if DEBUG_MHD
2751                                                                    MHD_USE_DEBUG |
2752 #endif
2753 #if BUILD_HTTPS
2754                                                                    MHD_USE_SSL |
2755 #endif
2756                                                                    MHD_USE_IPv6,
2757                                        port,
2758                                        &mhd_accept_cb,
2759                                        plugin , &mdh_access_cb, plugin,
2760                                        MHD_OPTION_SOCK_ADDR, tmp,
2761                                        MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 32,
2762                                        //MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) 6,
2763 #if BUILD_HTTPS
2764                                        MHD_OPTION_HTTPS_PRIORITIES,  plugin->crypto_init,
2765                                        MHD_OPTION_HTTPS_MEM_KEY, plugin->key,
2766                                        MHD_OPTION_HTTPS_MEM_CERT, plugin->cert,
2767 #endif
2768                                        MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) timeout,
2769                                        MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (2 * GNUNET_SERVER_MAX_MESSAGE_SIZE),
2770                                        MHD_OPTION_NOTIFY_COMPLETED, &mhd_termination_cb, NULL,
2771                                        MHD_OPTION_EXTERNAL_LOGGER, mhd_logger, plugin->mhd_log,
2772                                        MHD_OPTION_END);
2773   }
2774   if ((plugin->http_server_daemon_v4 == NULL) && (plugin->use_ipv4 == GNUNET_YES) && (port != 0))
2775   {
2776   plugin->http_server_daemon_v4 = MHD_start_daemon (
2777 #if DEBUG_MHD
2778                                                                    MHD_USE_DEBUG |
2779 #endif
2780 #if BUILD_HTTPS
2781                                                                    MHD_USE_SSL |
2782 #endif
2783                                                                    MHD_NO_FLAG,
2784                                        port,
2785                                        &mhd_accept_cb,
2786                                        plugin , &mdh_access_cb, plugin,
2787                                        MHD_OPTION_SOCK_ADDR, (struct sockaddr_in *)plugin->bind4_address,
2788                                        MHD_OPTION_CONNECTION_LIMIT, (unsigned int) 32,
2789                                        //MHD_OPTION_PER_IP_CONNECTION_LIMIT, (unsigned int) 6,
2790 #if BUILD_HTTPS
2791                                        MHD_OPTION_HTTPS_PRIORITIES,  plugin->crypto_init,
2792                                        MHD_OPTION_HTTPS_MEM_KEY, plugin->key,
2793                                        MHD_OPTION_HTTPS_MEM_CERT, plugin->cert,
2794 #endif
2795                                        MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) timeout,
2796                                        MHD_OPTION_CONNECTION_MEMORY_LIMIT, (size_t) (2 * GNUNET_SERVER_MAX_MESSAGE_SIZE),
2797                                        MHD_OPTION_NOTIFY_COMPLETED, &mhd_termination_cb, NULL,
2798                                        MHD_OPTION_EXTERNAL_LOGGER, mhd_logger, plugin->mhd_log,
2799                                        MHD_OPTION_END);
2800   }
2801   if (plugin->http_server_daemon_v4 != NULL)
2802     plugin->http_server_task_v4 = http_server_daemon_prepare (plugin, plugin->http_server_daemon_v4);
2803   if (plugin->http_server_daemon_v6 != NULL)
2804     plugin->http_server_task_v6 = http_server_daemon_prepare (plugin, plugin->http_server_daemon_v6);
2805
2806
2807   if (plugin->http_server_task_v4 != GNUNET_SCHEDULER_NO_TASK)
2808   {
2809 #if DEBUG_HTTP
2810           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Starting MHD with IPv4 bound to %s with port %u\n",(plugin->bind_hostname!=NULL) ? plugin->bind_hostname : "every address",port);
2811 #endif
2812   }
2813   else if ((plugin->http_server_task_v6 != GNUNET_SCHEDULER_NO_TASK) && (plugin->http_server_task_v4 != GNUNET_SCHEDULER_NO_TASK))
2814   {
2815 #if DEBUG_HTTP
2816     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Starting MHD with IPv6 bound to %s with port %u\n",(plugin->bind_hostname!=NULL) ? plugin->bind_hostname : "every address", port);
2817 #endif
2818   }
2819   else if ((plugin->http_server_task_v6 != GNUNET_SCHEDULER_NO_TASK) && (plugin->http_server_task_v4 == GNUNET_SCHEDULER_NO_TASK))
2820   {
2821 #if DEBUG_HTTP
2822     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"Starting MHD with IPv4 and IPv6 bound to %s with port %u\n",(plugin->bind_hostname!=NULL) ? plugin->bind_hostname : "every address", port);
2823 #endif
2824   }
2825   else
2826   {
2827         char * tmp = NULL;
2828         if ((plugin->use_ipv6 == GNUNET_YES) && (plugin->use_ipv4 == GNUNET_YES))
2829                 GNUNET_asprintf(&tmp,"with IPv4 and IPv6 enabled");
2830         if ((plugin->use_ipv6 == GNUNET_NO) && (plugin->use_ipv4 == GNUNET_YES))
2831                 GNUNET_asprintf(&tmp,"with IPv4 enabled");
2832         if ((plugin->use_ipv6 == GNUNET_YES) && (plugin->use_ipv4 == GNUNET_NO))
2833                 GNUNET_asprintf(&tmp,"with IPv6 enabled");
2834         if ((plugin->use_ipv6 == GNUNET_NO) && (plugin->use_ipv4 == GNUNET_NO))
2835                 GNUNET_asprintf(&tmp,"with NO IP PROTOCOL enabled");
2836         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,"HTTP Server with %s could not be started on port %u! %s plugin failed!\n",tmp, port, PROTOCOL_PREFIX);
2837         GNUNET_free (tmp);
2838     GNUNET_free (component_name);
2839     LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
2840     return NULL;
2841   }
2842
2843   /* Initializing cURL */
2844   curl_global_init(CURL_GLOBAL_ALL);
2845   plugin->multi_handle = curl_multi_init();
2846
2847   if ( NULL == plugin->multi_handle )
2848   {
2849     GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR,
2850                                          component_name,
2851                                          _("Could not initialize curl multi handle, failed to start %s plugin!\n"),
2852                                          PROTOCOL_PREFIX);
2853     GNUNET_free(component_name);
2854     LIBGNUNET_PLUGIN_TRANSPORT_DONE (api);
2855     return NULL;
2856   }
2857
2858   plugin->peers = GNUNET_CONTAINER_multihashmap_create (10);
2859   GNUNET_OS_network_interfaces_list (&process_interfaces, plugin);
2860
2861   GNUNET_free(component_name);
2862   return api;
2863 }
2864
2865 /* end of plugin_transport_http.c */