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