src/gns/gnunet-gns-proxy.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2012-2018 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your 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      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18 /**
  19  * @author Martin Schanzenbach
  20  * @author Christian Grothoff
  21  * @file src/gns/gnunet-gns-proxy.c
  22  * @brief HTTP(S) proxy that rewrites URIs and fakes certificats to make GNS work
  23  *        with legacy browsers
  24  *
  25  * TODO:
  26  * - double-check queueing logic
  27  */
  28 #include "platform.h"
  29 #include <microhttpd.h>
  30 #if HAVE_CURL_CURL_H
  31 #include <curl/curl.h>
  32 #elif HAVE_GNURL_CURL_H
  33 #include <gnurl/curl.h>
  34 #endif
  35 #include <gnutls/gnutls.h>
  36 #include <gnutls/x509.h>
  37 #include <gnutls/abstract.h>
  38 #include <gnutls/crypto.h>
  39 #if HAVE_GNUTLS_DANE
  40 #include <gnutls/dane.h>
  41 #endif
  42 #include <regex.h>
  43 #include "gnunet_util_lib.h"
  44 #include "gnunet_gns_service.h"
  45 #include "gnunet_identity_service.h"
  46 #include "gns.h"
  47
  48
  49
  50 /**
  51  * Default Socks5 listen port.
  52  */
  53 #define GNUNET_GNS_PROXY_PORT 7777
  54
  55 /**
  56  * Maximum supported length for a URI.
  57  * Should die. @deprecated
  58  */
  59 #define MAX_HTTP_URI_LENGTH 2048
  60
  61 /**
  62  * Size of the buffer for the data upload / download.  Must be
  63  * enough for curl, thus CURL_MAX_WRITE_SIZE is needed here (16k).
  64  */
  65 #define IO_BUFFERSIZE CURL_MAX_WRITE_SIZE
  66
  67 /**
  68  * Size of the read/write buffers for Socks.   Uses
  69  * 256 bytes for the hostname (at most), plus a few
  70  * bytes overhead for the messages.
  71  */
  72 #define SOCKS_BUFFERSIZE (256 + 32)
  73
  74 /**
  75  * Port for plaintext HTTP.
  76  */
  77 #define HTTP_PORT 80
  78
  79 /**
  80  * Port for HTTPS.
  81  */
  82 #define HTTPS_PORT 443
  83
  84 /**
  85  * Largest allowed size for a PEM certificate.
  86  */
  87 #define MAX_PEM_SIZE (10 * 1024)
  88
  89 /**
  90  * After how long do we clean up unused MHD TLS instances?
  91  */
  92 #define MHD_CACHE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
  93
  94 /**
  95  * After how long do we clean up Socks5 handles that failed to show any activity
  96  * with their respective MHD instance?
  97  */
  98 #define HTTP_HANDSHAKE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
  99
 100
 101 /**
 102  * Log curl error.
 103  *
 104  * @param level log level
 105  * @param fun name of curl_easy-function that gave the error
 106  * @param rc return code from curl
 107  */
 108 #define LOG_CURL_EASY(level,fun,rc) \
 109    GNUNET_log (level, \
 110                _("%s failed at %s:%d: `%s'\n"), \
 111                fun, \
 112                __FILE__, \
 113                __LINE__, \
 114                curl_easy_strerror (rc))
 115
 116
 117 /* *************** Socks protocol definitions (move to TUN?) ****************** */
 118
 119 /**
 120  * Which SOCKS version do we speak?
 121  */
 122 #define SOCKS_VERSION_5 0x05
 123
 124 /**
 125  * Flag to set for 'no authentication'.
 126  */
 127 #define SOCKS_AUTH_NONE 0
 128
 129
 130 /**
 131  * Commands in Socks5.
 132  */
 133 enum Socks5Commands
 134 {
 135   /**
 136    * Establish TCP/IP stream.
 137    */
 138   SOCKS5_CMD_TCP_STREAM = 1,
 139
 140   /**
 141    * Establish TCP port binding.
 142    */
 143   SOCKS5_CMD_TCP_PORT = 2,
 144
 145   /**
 146    * Establish UDP port binding.
 147    */
 148   SOCKS5_CMD_UDP_PORT = 3
 149 };
 150
 151
 152 /**
 153  * Address types in Socks5.
 154  */
 155 enum Socks5AddressType
 156 {
 157   /**
 158    * IPv4 address.
 159    */
 160   SOCKS5_AT_IPV4 = 1,
 161
 162   /**
 163    * IPv4 address.
 164    */
 165   SOCKS5_AT_DOMAINNAME = 3,
 166
 167   /**
 168    * IPv6 address.
 169    */
 170   SOCKS5_AT_IPV6 = 4
 171
 172 };
 173
 174
 175 /**
 176  * Status codes in Socks5 response.
 177  */
 178 enum Socks5StatusCode
 179 {
 180   SOCKS5_STATUS_REQUEST_GRANTED = 0,
 181   SOCKS5_STATUS_GENERAL_FAILURE = 1,
 182   SOCKS5_STATUS_CONNECTION_NOT_ALLOWED_BY_RULE = 2,
 183   SOCKS5_STATUS_NETWORK_UNREACHABLE = 3,
 184   SOCKS5_STATUS_HOST_UNREACHABLE = 4,
 185   SOCKS5_STATUS_CONNECTION_REFUSED_BY_HOST = 5,
 186   SOCKS5_STATUS_TTL_EXPIRED = 6,
 187   SOCKS5_STATUS_COMMAND_NOT_SUPPORTED = 7,
 188   SOCKS5_STATUS_ADDRESS_TYPE_NOT_SUPPORTED = 8
 189 };
 190
 191
 192 /**
 193  * Client hello in Socks5 protocol.
 194  */
 195 struct Socks5ClientHelloMessage
 196 {
 197   /**
 198    * Should be #SOCKS_VERSION_5.
 199    */
 200   uint8_t version;
 201
 202   /**
 203    * How many authentication methods does the client support.
 204    */
 205   uint8_t num_auth_methods;
 206
 207   /* followed by supported authentication methods, 1 byte per method */
 208
 209 };
 210
 211
 212 /**
 213  * Server hello in Socks5 protocol.
 214  */
 215 struct Socks5ServerHelloMessage
 216 {
 217   /**
 218    * Should be #SOCKS_VERSION_5.
 219    */
 220   uint8_t version;
 221
 222   /**
 223    * Chosen authentication method, for us always #SOCKS_AUTH_NONE,
 224    * which skips the authentication step.
 225    */
 226   uint8_t auth_method;
 227 };
 228
 229
 230 /**
 231  * Client socks request in Socks5 protocol.
 232  */
 233 struct Socks5ClientRequestMessage
 234 {
 235   /**
 236    * Should be #SOCKS_VERSION_5.
 237    */
 238   uint8_t version;
 239
 240   /**
 241    * Command code, we only uspport #SOCKS5_CMD_TCP_STREAM.
 242    */
 243   uint8_t command;
 244
 245   /**
 246    * Reserved, always zero.
 247    */
 248   uint8_t resvd;
 249
 250   /**
 251    * Address type, an `enum Socks5AddressType`.
 252    */
 253   uint8_t addr_type;
 254
 255   /*
 256    * Followed by either an ip4/ipv6 address or a domain name with a
 257    * length field (uint8_t) in front (depending on @e addr_type).
 258    * followed by port number in network byte order (uint16_t).
 259    */
 260 };
 261
 262
 263 /**
 264  * Server response to client requests in Socks5 protocol.
 265  */
 266 struct Socks5ServerResponseMessage
 267 {
 268   /**
 269    * Should be #SOCKS_VERSION_5.
 270    */
 271   uint8_t version;
 272
 273   /**
 274    * Status code, an `enum Socks5StatusCode`
 275    */
 276   uint8_t reply;
 277
 278   /**
 279    * Always zero.
 280    */
 281   uint8_t reserved;
 282
 283   /**
 284    * Address type, an `enum Socks5AddressType`.
 285    */
 286   uint8_t addr_type;
 287
 288   /*
 289    * Followed by either an ip4/ipv6 address or a domain name with a
 290    * length field (uint8_t) in front (depending on @e addr_type).
 291    * followed by port number in network byte order (uint16_t).
 292    */
 293
 294 };
 295
 296
 297
 298 /* *********************** Datastructures for HTTP handling ****************** */
 299
 300 /**
 301  * A structure for CA cert/key
 302  */
 303 struct ProxyCA
 304 {
 305   /**
 306    * The certificate
 307    */
 308   gnutls_x509_crt_t cert;
 309
 310   /**
 311    * The private key
 312    */
 313   gnutls_x509_privkey_t key;
 314 };
 315
 316
 317 /**
 318  * Structure for GNS certificates
 319  */
 320 struct ProxyGNSCertificate
 321 {
 322   /**
 323    * The certificate as PEM
 324    */
 325   char cert[MAX_PEM_SIZE];
 326
 327   /**
 328    * The private key as PEM
 329    */
 330   char key[MAX_PEM_SIZE];
 331 };
 332
 333
 334
 335 /**
 336  * A structure for all running Httpds
 337  */
 338 struct MhdHttpList
 339 {
 340   /**
 341    * DLL for httpds
 342    */
 343   struct MhdHttpList *prev;
 344
 345   /**
 346    * DLL for httpds
 347    */
 348   struct MhdHttpList *next;
 349
 350   /**
 351    * the domain name to server (only important for TLS)
 352    */
 353   char *domain;
 354
 355   /**
 356    * The daemon handle
 357    */
 358   struct MHD_Daemon *daemon;
 359
 360   /**
 361    * Optional proxy certificate used
 362    */
 363   struct ProxyGNSCertificate *proxy_cert;
 364
 365   /**
 366    * The task ID
 367    */
 368   struct GNUNET_SCHEDULER_Task *httpd_task;
 369
 370   /**
 371    * is this an ssl daemon?
 372    */
 373   int is_ssl;
 374
 375 };
 376
 377
 378 /* ***************** Datastructures for Socks handling **************** */
 379
 380
 381 /**
 382  * The socks phases.
 383  */
 384 enum SocksPhase
 385 {
 386   /**
 387    * We're waiting to get the client hello.
 388    */
 389   SOCKS5_INIT,
 390
 391   /**
 392    * We're waiting to get the initial request.
 393    */
 394   SOCKS5_REQUEST,
 395
 396   /**
 397    * We are currently resolving the destination.
 398    */
 399   SOCKS5_RESOLVING,
 400
 401   /**
 402    * We're in transfer mode.
 403    */
 404   SOCKS5_DATA_TRANSFER,
 405
 406   /**
 407    * Finish writing the write buffer, then clean up.
 408    */
 409   SOCKS5_WRITE_THEN_CLEANUP,
 410
 411   /**
 412    * Socket has been passed to MHD, do not close it anymore.
 413    */
 414   SOCKS5_SOCKET_WITH_MHD,
 415
 416   /**
 417    * We've started receiving upload data from MHD.
 418    */
 419   SOCKS5_SOCKET_UPLOAD_STARTED,
 420
 421   /**
 422    * We've finished receiving upload data from MHD.
 423    */
 424   SOCKS5_SOCKET_UPLOAD_DONE,
 425
 426   /**
 427    * We've finished uploading data via CURL and can now download.
 428    */
 429   SOCKS5_SOCKET_DOWNLOAD_STARTED,
 430
 431   /**
 432    * We've finished receiving download data from cURL.
 433    */
 434   SOCKS5_SOCKET_DOWNLOAD_DONE
 435 };
 436
 437
 438 /**
 439  * A header list
 440  */
 441 struct HttpResponseHeader
 442 {
 443   /**
 444    * DLL
 445    */
 446   struct HttpResponseHeader *next;
 447
 448   /**
 449    * DLL
 450    */
 451   struct HttpResponseHeader *prev;
 452
 453   /**
 454    * Header type
 455    */
 456   char *type;
 457
 458   /**
 459    * Header value
 460    */
 461   char *value;
 462 };
 463
 464 /**
 465  * A structure for socks requests
 466  */
 467 struct Socks5Request
 468 {
 469
 470   /**
 471    * DLL.
 472    */
 473   struct Socks5Request *next;
 474
 475   /**
 476    * DLL.
 477    */
 478   struct Socks5Request *prev;
 479
 480   /**
 481    * The client socket
 482    */
 483   struct GNUNET_NETWORK_Handle *sock;
 484
 485   /**
 486    * Handle to GNS lookup, during #SOCKS5_RESOLVING phase.
 487    */
 488   struct GNUNET_GNS_LookupWithTldRequest *gns_lookup;
 489
 490   /**
 491    * Client socket read task
 492    */
 493   struct GNUNET_SCHEDULER_Task *rtask;
 494
 495   /**
 496    * Client socket write task
 497    */
 498   struct GNUNET_SCHEDULER_Task *wtask;
 499
 500   /**
 501    * Timeout task
 502    */
 503   struct GNUNET_SCHEDULER_Task *timeout_task;
 504
 505   /**
 506    * Read buffer
 507    */
 508   char rbuf[SOCKS_BUFFERSIZE];
 509
 510   /**
 511    * Write buffer
 512    */
 513   char wbuf[SOCKS_BUFFERSIZE];
 514
 515   /**
 516    * Buffer we use for moving data between MHD and curl (in both directions).
 517    */
 518   char io_buf[IO_BUFFERSIZE];
 519
 520   /**
 521    * MHD HTTP instance handling this request, NULL for none.
 522    */
 523   struct MhdHttpList *hd;
 524
 525   /**
 526    * MHD connection for this request.
 527    */
 528   struct MHD_Connection *con;
 529
 530   /**
 531    * MHD response object for this request.
 532    */
 533   struct MHD_Response *response;
 534
 535   /**
 536    * the domain name to server (only important for TLS)
 537    */
 538   char *domain;
 539
 540   /**
 541    * DNS Legacy Host Name as given by GNS, NULL if not given.
 542    */
 543   char *leho;
 544
 545   /**
 546    * Payload of the (last) DANE record encountered.
 547    */
 548   char *dane_data;
 549
 550   /**
 551    * The URL to fetch
 552    */
 553   char *url;
 554
 555   /**
 556    * Handle to cURL
 557    */
 558   CURL *curl;
 559
 560   /**
 561    * HTTP request headers for the curl request.
 562    */
 563   struct curl_slist *headers;
 564
 565   /**
 566    * DNS->IP mappings resolved through GNS
 567    */
 568   struct curl_slist *hosts;
 569
 570   /**
 571    * HTTP response code to give to MHD for the response.
 572    */
 573   unsigned int response_code;
 574
 575   /**
 576    * Number of bytes in @e dane_data.
 577    */
 578   size_t dane_data_len;
 579
 580   /**
 581    * Number of bytes already in read buffer
 582    */
 583   size_t rbuf_len;
 584
 585   /**
 586    * Number of bytes already in write buffer
 587    */
 588   size_t wbuf_len;
 589
 590   /**
 591    * Number of bytes already in the IO buffer.
 592    */
 593   size_t io_len;
 594
 595   /**
 596    * Once known, what's the target address for the connection?
 597    */
 598   struct sockaddr_storage destination_address;
 599
 600   /**
 601    * The socks state
 602    */
 603   enum SocksPhase state;
 604
 605   /**
 606    * Desired destination port.
 607    */
 608   uint16_t port;
 609
 610   /**
 611    * Headers from response
 612    */
 613   struct HttpResponseHeader *header_head;
 614
 615   /**
 616    * Headers from response
 617    */
 618   struct HttpResponseHeader *header_tail;
 619
 620   /**
 621    * X.509 Certificate status
 622    */
 623   int ssl_checked;
 624
 625   /**
 626    * Was the hostname resolved via GNS?
 627    */
 628   int is_gns;
 629
 630   /**
 631    * Did we suspend MHD processing?
 632    */
 633   int suspended;
 634
 635   /**
 636    * Did we pause CURL processing?
 637    */
 638   int curl_paused;
 639 };
 640
 641
 642
 643 /* *********************** Globals **************************** */
 644
 645
 646 /**
 647  * The port the proxy is running on (default 7777)
 648  */
 649 static uint16_t port = GNUNET_GNS_PROXY_PORT;
 650
 651 /**
 652  * The CA file (pem) to use for the proxy CA
 653  */
 654 static char *cafile_opt;
 655
 656 /**
 657  * The listen socket of the proxy for IPv4
 658  */
 659 static struct GNUNET_NETWORK_Handle *lsock4;
 660
 661 /**
 662  * The listen socket of the proxy for IPv6
 663  */
 664 static struct GNUNET_NETWORK_Handle *lsock6;
 665
 666 /**
 667  * The listen task ID for IPv4
 668  */
 669 static struct GNUNET_SCHEDULER_Task * ltask4;
 670
 671 /**
 672  * The listen task ID for IPv6
 673  */
 674 static struct GNUNET_SCHEDULER_Task * ltask6;
 675
 676 /**
 677  * The cURL download task (curl multi API).
 678  */
 679 static struct GNUNET_SCHEDULER_Task * curl_download_task;
 680
 681 /**
 682  * The cURL multi handle
 683  */
 684 static CURLM *curl_multi;
 685
 686 /**
 687  * Handle to the GNS service
 688  */
 689 static struct GNUNET_GNS_Handle *gns_handle;
 690
 691 /**
 692  * Disable IPv6.
 693  */
 694 static int disable_v6;
 695
 696 /**
 697  * DLL for http/https daemons
 698  */
 699 static struct MhdHttpList *mhd_httpd_head;
 700
 701 /**
 702  * DLL for http/https daemons
 703  */
 704 static struct MhdHttpList *mhd_httpd_tail;
 705
 706 /**
 707  * Daemon for HTTP (we have one per X.509 certificate, and then one for
 708  * all HTTP connections; this is the one for HTTP, not HTTPS).
 709  */
 710 static struct MhdHttpList *httpd;
 711
 712 /**
 713  * DLL of active socks requests.
 714  */
 715 static struct Socks5Request *s5r_head;
 716
 717 /**
 718  * DLL of active socks requests.
 719  */
 720 static struct Socks5Request *s5r_tail;
 721
 722 /**
 723  * The CA for X.509 certificate generation
 724  */
 725 static struct ProxyCA proxy_ca;
 726
 727 /**
 728  * Response we return on cURL failures.
 729  */
 730 static struct MHD_Response *curl_failure_response;
 731
 732 /**
 733  * Our configuration.
 734  */
 735 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 736
 737
 738 /* ************************* Global helpers ********************* */
 739
 740
 741 /**
 742  * Run MHD now, we have extra data ready for the callback.
 743  *
 744  * @param hd the daemon to run now.
 745  */
 746 static void
 747 run_mhd_now (struct MhdHttpList *hd);
 748
 749
 750 /**
 751  * Clean up s5r handles.
 752  *
 753  * @param s5r the handle to destroy
 754  */
 755 static void
 756 cleanup_s5r (struct Socks5Request *s5r)
 757 {
 758   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 759               "Cleaning up socks request\n");
 760   if (NULL != s5r->curl)
 761   {
 762     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 763                 "Cleaning up cURL handle\n");
 764     curl_multi_remove_handle (curl_multi,
 765                               s5r->curl);
 766     curl_easy_cleanup (s5r->curl);
 767     s5r->curl = NULL;
 768   }
 769   if (s5r->suspended)
 770   {
 771     s5r->suspended = GNUNET_NO;
 772     MHD_resume_connection (s5r->con);
 773   }
 774   curl_slist_free_all (s5r->headers);
 775   if (NULL != s5r->hosts)
 776   {
 777     curl_slist_free_all (s5r->hosts);
 778   }
 779   if ( (NULL != s5r->response) &&
 780        (curl_failure_response != s5r->response) )
 781   {
 782     MHD_destroy_response (s5r->response);
 783     s5r->response = NULL;
 784   }
 785   if (NULL != s5r->rtask)
 786   {
 787     GNUNET_SCHEDULER_cancel (s5r->rtask);
 788     s5r->rtask = NULL;
 789   }
 790   if (NULL != s5r->timeout_task)
 791   {
 792     GNUNET_SCHEDULER_cancel (s5r->timeout_task);
 793     s5r->timeout_task = NULL;
 794   }
 795   if (NULL != s5r->wtask)
 796   {
 797     GNUNET_SCHEDULER_cancel (s5r->wtask);
 798     s5r->wtask = NULL;
 799   }
 800   if (NULL != s5r->gns_lookup)
 801   {
 802     GNUNET_GNS_lookup_with_tld_cancel (s5r->gns_lookup);
 803     s5r->gns_lookup = NULL;
 804   }
 805   if (NULL != s5r->sock)
 806   {
 807     if (SOCKS5_SOCKET_WITH_MHD <= s5r->state)
 808       GNUNET_NETWORK_socket_free_memory_only_ (s5r->sock);
 809     else
 810       GNUNET_NETWORK_socket_close (s5r->sock);
 811     s5r->sock = NULL;
 812   }
 813   GNUNET_CONTAINER_DLL_remove (s5r_head,
 814                                s5r_tail,
 815                                s5r);
 816   GNUNET_free_non_null (s5r->domain);
 817   GNUNET_free_non_null (s5r->leho);
 818   GNUNET_free_non_null (s5r->url);
 819   GNUNET_free_non_null (s5r->dane_data);
 820   GNUNET_free (s5r);
 821 }
 822
 823
 824 /* ************************* HTTP handling with cURL *********************** */
 825
 826 static void
 827 curl_download_prepare ();
 828
 829
 830 /**
 831  * Callback for MHD response generation.  This function is called from
 832  * MHD whenever MHD expects to get data back.  Copies data from the
 833  * io_buf, if available.
 834  *
 835  * @param cls closure with our `struct Socks5Request`
 836  * @param pos in buffer
 837  * @param buf where to copy data
 838  * @param max available space in @a buf
 839  * @return number of bytes written to @a buf
 840  */
 841 static ssize_t
 842 mhd_content_cb (void *cls,
 843                 uint64_t pos,
 844                 char* buf,
 845                 size_t max)
 846 {
 847   struct Socks5Request *s5r = cls;
 848   size_t bytes_to_copy;
 849
 850   if ( (SOCKS5_SOCKET_UPLOAD_STARTED == s5r->state) ||
 851        (SOCKS5_SOCKET_UPLOAD_DONE == s5r->state) )
 852   {
 853     /* we're still not done with the upload, do not yet
 854        start the download, the IO buffer is still full
 855        with upload data. */
 856     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 857                 "Pausing MHD download %s%s, not yet ready for download\n",
 858                 s5r->domain,
 859                 s5r->url);
 860     return 0; /* not yet ready for data download */
 861   }
 862   bytes_to_copy = GNUNET_MIN (max,
 863                               s5r->io_len);
 864   if ( (0 == bytes_to_copy) &&
 865        (SOCKS5_SOCKET_DOWNLOAD_DONE != s5r->state) )
 866   {
 867     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 868                 "Pausing MHD download %s%s, no data available\n",
 869                 s5r->domain,
 870                 s5r->url);
 871     if (NULL != s5r->curl)
 872     {
 873       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 874                   "Continuing CURL interaction for %s%s\n",
 875                   s5r->domain,
 876                   s5r->url);
 877       if (GNUNET_YES == s5r->curl_paused)
 878       {
 879         s5r->curl_paused = GNUNET_NO;
 880         curl_easy_pause (s5r->curl,
 881                          CURLPAUSE_CONT);
 882       }
 883       curl_download_prepare ();
 884     }
 885     if (GNUNET_NO == s5r->suspended)
 886     {
 887       MHD_suspend_connection (s5r->con);
 888       s5r->suspended = GNUNET_YES;
 889     }
 890     return 0; /* more data later */
 891   }
 892   if ( (0 == bytes_to_copy) &&
 893        (SOCKS5_SOCKET_DOWNLOAD_DONE == s5r->state) )
 894   {
 895     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 896                 "Completed MHD download %s%s\n",
 897                 s5r->domain,
 898                 s5r->url);
 899     return MHD_CONTENT_READER_END_OF_STREAM;
 900   }
 901   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 902               "Writing %llu/%llu bytes to %s%s\n",
 903               (unsigned long long) bytes_to_copy,
 904               (unsigned long long) s5r->io_len,
 905               s5r->domain,
 906               s5r->url);
 907   GNUNET_memcpy (buf,
 908                  s5r->io_buf,
 909                  bytes_to_copy);
 910   memmove (s5r->io_buf,
 911            &s5r->io_buf[bytes_to_copy],
 912            s5r->io_len - bytes_to_copy);
 913   s5r->io_len -= bytes_to_copy;
 914   if ( (NULL != s5r->curl) &&
 915        (GNUNET_YES == s5r->curl_paused) )
 916   {
 917     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 918                 "Continuing CURL interaction for %s%s\n",
 919                 s5r->domain,
 920                 s5r->url);
 921     s5r->curl_paused = GNUNET_NO;
 922     curl_easy_pause (s5r->curl,
 923                      CURLPAUSE_CONT);
 924   }
 925   return bytes_to_copy;
 926 }
 927
 928
 929 /**
 930  * Check that the website has presented us with a valid X.509 certificate.
 931  * The certificate must either match the domain name or the LEHO name
 932  * (or, if available, the TLSA record).
 933  *
 934  * @param s5r request to check for.
 935  * @return #GNUNET_OK if the certificate is valid
 936  */
 937 static int
 938 check_ssl_certificate (struct Socks5Request *s5r)
 939 {
 940   unsigned int cert_list_size;
 941   const gnutls_datum_t *chainp;
 942   const struct curl_tlssessioninfo *tlsinfo;
 943   char certdn[GNUNET_DNSPARSER_MAX_NAME_LENGTH + 3];
 944   size_t size;
 945   gnutls_x509_crt_t x509_cert;
 946   int rc;
 947   const char *name;
 948
 949   s5r->ssl_checked = GNUNET_YES;
 950   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 951               "Checking X.509 certificate\n");
 952   if (CURLE_OK !=
 953       curl_easy_getinfo (s5r->curl,
 954                          CURLINFO_TLS_SESSION,
 955                          (struct curl_slist **) &tlsinfo))
 956     return GNUNET_SYSERR;
 957   if (CURLSSLBACKEND_GNUTLS != tlsinfo->backend)
 958   {
 959     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 960                 _("Unsupported CURL TLS backend %d\n"),
 961                 tlsinfo->backend);
 962     return GNUNET_SYSERR;
 963   }
 964   chainp = gnutls_certificate_get_peers (tlsinfo->internals,
 965                                          &cert_list_size);
 966   if ( (! chainp) ||
 967        (0 == cert_list_size) )
 968     return GNUNET_SYSERR;
 969
 970   size = sizeof (certdn);
 971   /* initialize an X.509 certificate structure. */
 972   gnutls_x509_crt_init (&x509_cert);
 973   gnutls_x509_crt_import (x509_cert,
 974                           chainp,
 975                           GNUTLS_X509_FMT_DER);
 976
 977   if (0 != (rc = gnutls_x509_crt_get_dn_by_oid (x509_cert,
 978                                                 GNUTLS_OID_X520_COMMON_NAME,
 979                                                 0, /* the first and only one */
 980                                                 0 /* no DER encoding */,
 981                                                 certdn,
 982                                                 &size)))
 983   {
 984     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 985                 _("Failed to fetch CN from cert: %s\n"),
 986                 gnutls_strerror(rc));
 987     gnutls_x509_crt_deinit (x509_cert);
 988     return GNUNET_SYSERR;
 989   }
 990   /* check for TLSA/DANE records */
 991 #if HAVE_GNUTLS_DANE
 992   if (NULL != s5r->dane_data)
 993   {
 994     char *dd[] = { s5r->dane_data, NULL };
 995     int dlen[] = { s5r->dane_data_len, 0};
 996     dane_state_t dane_state;
 997     dane_query_t dane_query;
 998     unsigned int verify;
 999
1000     /* FIXME: add flags to gnutls to NOT read UNBOUND_ROOT_KEY_FILE here! */
1001     if (0 != (rc = dane_state_init (&dane_state,
1002 #ifdef DANE_F_IGNORE_DNSSEC
1003                                     DANE_F_IGNORE_DNSSEC |
1004 #endif
1005                                     DANE_F_IGNORE_LOCAL_RESOLVER)))
1006     {
1007       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1008                   _("Failed to initialize DANE: %s\n"),
1009                   dane_strerror(rc));
1010       gnutls_x509_crt_deinit (x509_cert);
1011       return GNUNET_SYSERR;
1012     }
1013     if (0 != (rc = dane_raw_tlsa (dane_state,
1014                                   &dane_query,
1015                                   dd,
1016                                   dlen,
1017                                   GNUNET_YES,
1018                                   GNUNET_NO)))
1019     {
1020       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1021                   _("Failed to parse DANE record: %s\n"),
1022                   dane_strerror(rc));
1023       dane_state_deinit (dane_state);
1024       gnutls_x509_crt_deinit (x509_cert);
1025       return GNUNET_SYSERR;
1026     }
1027     if (0 != (rc = dane_verify_crt_raw (dane_state,
1028                                         chainp,
1029                                         cert_list_size,
1030                                         gnutls_certificate_type_get (tlsinfo->internals),
1031                                         dane_query,
1032                                         0, 0,
1033                                         &verify)))
1034     {
1035       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1036                   _("Failed to verify TLS connection using DANE: %s\n"),
1037                   dane_strerror(rc));
1038       dane_query_deinit (dane_query);
1039       dane_state_deinit (dane_state);
1040       gnutls_x509_crt_deinit (x509_cert);
1041       return GNUNET_SYSERR;
1042     }
1043     if (0 != verify)
1044     {
1045       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1046                   _("Failed DANE verification failed with GnuTLS verify status code: %u\n"),
1047                   verify);
1048       dane_query_deinit (dane_query);
1049       dane_state_deinit (dane_state);
1050       gnutls_x509_crt_deinit (x509_cert);
1051       return GNUNET_SYSERR;
1052     }
1053     dane_query_deinit (dane_query);
1054     dane_state_deinit (dane_state);
1055     /* success! */
1056   }
1057   else
1058 #endif
1059   {
1060     /* try LEHO or ordinary domain name X509 verification */
1061     name = s5r->domain;
1062     if (NULL != s5r->leho)
1063       name = s5r->leho;
1064     if (NULL != name)
1065     {
1066       if (0 == (rc = gnutls_x509_crt_check_hostname (x509_cert,
1067                                                      name)))
1068       {
1069         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1070                     _("TLS certificate subject name (%s) does not match `%s': %d\n"),
1071                     certdn,
1072                     name,
1073                     rc);
1074         gnutls_x509_crt_deinit (x509_cert);
1075         return GNUNET_SYSERR;
1076       }
1077     }
1078     else
1079     {
1080       /* we did not even have the domain name!? */
1081       GNUNET_break (0);
1082       return GNUNET_SYSERR;
1083     }
1084   }
1085   gnutls_x509_crt_deinit (x509_cert);
1086   return GNUNET_OK;
1087 }
1088
1089
1090 /**
1091  * We're getting an HTTP response header from cURL.  Convert it to the
1092  * MHD response headers.  Mostly copies the headers, but makes special
1093  * adjustments to "Set-Cookie" and "Location" headers as those may need
1094  * to be changed from the LEHO to the domain the browser expects.
1095  *
1096  * @param buffer curl buffer with a single line of header data; not 0-terminated!
1097  * @param size curl blocksize
1098  * @param nmemb curl blocknumber
1099  * @param cls our `struct Socks5Request *`
1100  * @return size of processed bytes
1101  */
1102 static size_t
1103 curl_check_hdr (void *buffer,
1104                 size_t size,
1105                 size_t nmemb,
1106                 void *cls)
1107 {
1108   struct Socks5Request *s5r = cls;
1109   struct HttpResponseHeader *header;
1110   size_t bytes = size * nmemb;
1111   char *ndup;
1112   const char *hdr_type;
1113   const char *cookie_domain;
1114   char *hdr_val;
1115   char *new_cookie_hdr;
1116   char *new_location;
1117   size_t offset;
1118   size_t delta_cdomain;
1119   int domain_matched;
1120   char *tok;
1121
1122   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1123               "Receiving HTTP response header from CURL\n");
1124   /* first, check TLS certificate */
1125   if ( (GNUNET_YES != s5r->ssl_checked) &&
1126        (HTTPS_PORT == s5r->port))
1127   {
1128     if (GNUNET_OK != check_ssl_certificate (s5r))
1129       return 0;
1130   }
1131   ndup = GNUNET_strndup (buffer,
1132                          bytes);
1133   hdr_type = strtok (ndup,
1134                      ":");
1135   if (NULL == hdr_type)
1136   {
1137     GNUNET_free (ndup);
1138     return bytes;
1139   }
1140   hdr_val = strtok (NULL,
1141                     "");
1142   if (NULL == hdr_val)
1143   {
1144     GNUNET_free (ndup);
1145     return bytes;
1146   }
1147   if (' ' == *hdr_val)
1148     hdr_val++;
1149
1150   /* custom logic for certain header types */
1151   new_cookie_hdr = NULL;
1152   if ( (NULL != s5r->leho) &&
1153        (0 == strcasecmp (hdr_type,
1154                          MHD_HTTP_HEADER_SET_COOKIE)) )
1155
1156   {
1157     new_cookie_hdr = GNUNET_malloc (strlen (hdr_val) +
1158                                     strlen (s5r->domain) + 1);
1159     offset = 0;
1160     domain_matched = GNUNET_NO; /* make sure we match domain at most once */
1161     for (tok = strtok (hdr_val, ";"); NULL != tok; tok = strtok (NULL, ";"))
1162     {
1163       if ( (0 == strncasecmp (tok,
1164                               " domain",
1165                               strlen (" domain"))) &&
1166            (GNUNET_NO == domain_matched) )
1167       {
1168         domain_matched = GNUNET_YES;
1169         cookie_domain = tok + strlen (" domain") + 1;
1170         if (strlen (cookie_domain) < strlen (s5r->leho))
1171         {
1172           delta_cdomain = strlen (s5r->leho) - strlen (cookie_domain);
1173           if (0 == strcasecmp (cookie_domain,
1174                                s5r->leho + delta_cdomain))
1175           {
1176             offset += sprintf (new_cookie_hdr + offset,
1177                                " domain=%s;",
1178                                s5r->domain);
1179             continue;
1180           }
1181         }
1182         else if (0 == strcmp (cookie_domain,
1183                               s5r->leho))
1184         {
1185           offset += sprintf (new_cookie_hdr + offset,
1186                              " domain=%s;",
1187                              s5r->domain);
1188           continue;
1189         }
1190         else if ( ('.' == cookie_domain[0]) &&
1191                   (0 == strcmp (&cookie_domain[1],
1192                                 s5r->leho)) )
1193         {
1194           offset += sprintf (new_cookie_hdr + offset,
1195                              " domain=.%s;",
1196                              s5r->domain);
1197           continue;
1198         }
1199         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
1200                     _("Cookie domain `%s' supplied by server is invalid\n"),
1201                     tok);
1202       }
1203       GNUNET_memcpy (new_cookie_hdr + offset,
1204                      tok,
1205                      strlen (tok));
1206       offset += strlen (tok);
1207       new_cookie_hdr[offset++] = ';';
1208     }
1209     hdr_val = new_cookie_hdr;
1210   }
1211
1212   new_location = NULL;
1213   if (0 == strcasecmp (MHD_HTTP_HEADER_TRANSFER_ENCODING,
1214                        hdr_type))
1215   {
1216     /* Ignore transfer encoding, set automatically by MHD if required */
1217     goto cleanup;
1218   }
1219   if (0 == strcasecmp (MHD_HTTP_HEADER_LOCATION,
1220                        hdr_type))
1221   {
1222     char *leho_host;
1223
1224     GNUNET_asprintf (&leho_host,
1225                      (HTTPS_PORT != s5r->port)
1226                      ? "http://%s"
1227                      : "https://%s",
1228                      s5r->leho);
1229     if (0 == strncmp (leho_host,
1230                       hdr_val,
1231                       strlen (leho_host)))
1232     {
1233       GNUNET_asprintf (&new_location,
1234                        "%s%s%s",
1235                        (HTTPS_PORT != s5r->port)
1236                        ? "http://"
1237                        : "https://",
1238                        s5r->domain,
1239                        hdr_val + strlen (leho_host));
1240       hdr_val = new_location;
1241     }
1242     GNUNET_free (leho_host);
1243   }
1244   /* MHD does not allow certain characters in values, remove those */
1245   if (NULL != (tok = strchr (hdr_val, '\n')))
1246     *tok = '\0';
1247   if (NULL != (tok = strchr (hdr_val, '\r')))
1248     *tok = '\0';
1249   if (NULL != (tok = strchr (hdr_val, '\t')))
1250     *tok = '\0';
1251   if (0 != strlen (hdr_val)) /* Rely in MHD to set those */
1252   {
1253     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1254                 "Adding header %s: %s to MHD response\n",
1255                 hdr_type,
1256                 hdr_val);
1257     header = GNUNET_new (struct HttpResponseHeader);
1258     header->type = GNUNET_strdup (hdr_type);
1259     header->value = GNUNET_strdup (hdr_val);
1260     GNUNET_CONTAINER_DLL_insert (s5r->header_head,
1261                                  s5r->header_tail,
1262                                  header);
1263   }
1264  cleanup:
1265   GNUNET_free (ndup);
1266   GNUNET_free_non_null (new_cookie_hdr);
1267   GNUNET_free_non_null (new_location);
1268   return bytes;
1269 }
1270
1271
1272 /**
1273  * Create an MHD response object in @a s5r matching the
1274  * information we got from curl.
1275  *
1276  * @param s5r the request for which we convert the response
1277  * @return #GNUNET_OK on success, #GNUNET_SYSERR if response was
1278  *         already initialized before
1279  */
1280 static int
1281 create_mhd_response_from_s5r (struct Socks5Request *s5r)
1282 {
1283   long resp_code;
1284   double content_length;
1285
1286   if (NULL != s5r->response)
1287   {
1288     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1289                 "Response already set!\n");
1290     return GNUNET_SYSERR;
1291   }
1292
1293   GNUNET_break (CURLE_OK ==
1294                 curl_easy_getinfo (s5r->curl,
1295                                    CURLINFO_RESPONSE_CODE,
1296                                    &resp_code));
1297   GNUNET_break (CURLE_OK ==
1298                 curl_easy_getinfo (s5r->curl,
1299                                    CURLINFO_CONTENT_LENGTH_DOWNLOAD,
1300                                    &content_length));
1301   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1302               "Creating MHD response with code %d and size %d for %s%s\n",
1303               (int) resp_code,
1304               (int) content_length,
1305               s5r->domain,
1306               s5r->url);
1307   s5r->response_code = resp_code;
1308   s5r->response = MHD_create_response_from_callback ((-1 == content_length)
1309                                                      ? MHD_SIZE_UNKNOWN
1310                                                      : content_length,
1311                                                      IO_BUFFERSIZE,
1312                                                      &mhd_content_cb,
1313                                                      s5r,
1314                                                      NULL);
1315   for (struct HttpResponseHeader *header = s5r->header_head;
1316        NULL != header;
1317        header = header->next)
1318   {
1319     GNUNET_break (MHD_YES ==
1320                   MHD_add_response_header (s5r->response,
1321                                            header->type,
1322                                            header->value));
1323
1324   }
1325   if (NULL != s5r->leho)
1326   {
1327     char *cors_hdr;
1328
1329     GNUNET_asprintf (&cors_hdr,
1330                      (HTTPS_PORT == s5r->port)
1331                      ? "https://%s"
1332                      : "http://%s",
1333                      s5r->leho);
1334
1335     GNUNET_break (MHD_YES ==
1336                   MHD_add_response_header (s5r->response,
1337                                            MHD_HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
1338                                            cors_hdr));
1339     GNUNET_free (cors_hdr);
1340   }
1341   /* force connection to be closed after each request, as we
1342      do not support HTTP pipelining (yet, FIXME!) */
1343   /*GNUNET_break (MHD_YES ==
1344     MHD_add_response_header (s5r->response,
1345     MHD_HTTP_HEADER_CONNECTION,
1346     "close"));*/
1347   MHD_resume_connection (s5r->con);
1348   s5r->suspended = GNUNET_NO;
1349   return GNUNET_OK;
1350 }
1351
1352
1353 /**
1354  * Handle response payload data from cURL.  Copies it into our `io_buf` to make
1355  * it available to MHD.
1356  *
1357  * @param ptr pointer to the data
1358  * @param size number of blocks of data
1359  * @param nmemb blocksize
1360  * @param ctx our `struct Socks5Request *`
1361  * @return number of bytes handled
1362  */
1363 static size_t
1364 curl_download_cb (void *ptr,
1365                   size_t size,
1366                   size_t nmemb,
1367                   void* ctx)
1368 {
1369   struct Socks5Request *s5r = ctx;
1370   size_t total = size * nmemb;
1371
1372   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1373               "Receiving %ux%u bytes for `%s%s' from cURL\n",
1374               (unsigned int) size,
1375               (unsigned int) nmemb,
1376               s5r->domain,
1377               s5r->url);
1378   if (NULL == s5r->response)
1379     GNUNET_assert (GNUNET_OK ==
1380                    create_mhd_response_from_s5r (s5r));
1381
1382   if ( (SOCKS5_SOCKET_UPLOAD_STARTED == s5r->state) ||
1383        (SOCKS5_SOCKET_UPLOAD_DONE == s5r->state) )
1384   {
1385     /* we're still not done with the upload, do not yet
1386        start the download, the IO buffer is still full
1387        with upload data. */
1388     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1389                 "Pausing CURL download `%s%s', waiting for UPLOAD to finish\n",
1390                 s5r->domain,
1391                 s5r->url);
1392     s5r->curl_paused = GNUNET_YES;
1393     return CURL_WRITEFUNC_PAUSE; /* not yet ready for data download */
1394   }
1395   if (sizeof (s5r->io_buf) - s5r->io_len < total)
1396   {
1397     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1398                 "Pausing CURL `%s%s' download, not enough space %llu %llu %llu\n",
1399                 s5r->domain,
1400                 s5r->url,
1401                 (unsigned long long) sizeof (s5r->io_buf),
1402                 (unsigned long long) s5r->io_len,
1403                 (unsigned long long) total);
1404     s5r->curl_paused = GNUNET_YES;
1405     return CURL_WRITEFUNC_PAUSE; /* not enough space */
1406   }
1407   GNUNET_memcpy (&s5r->io_buf[s5r->io_len],
1408                  ptr,
1409                  total);
1410   s5r->io_len += total;
1411   if (GNUNET_YES == s5r->suspended)
1412   {
1413     MHD_resume_connection (s5r->con);
1414     s5r->suspended = GNUNET_NO;
1415   }
1416   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1417               "Received %llu bytes of payload via cURL from %s\n",
1418               (unsigned long long) total,
1419               s5r->domain);
1420   if (s5r->io_len == total)
1421     run_mhd_now (s5r->hd);
1422   return total;
1423 }
1424
1425
1426 /**
1427  * cURL callback for uploaded (PUT/POST) data.  Copies it into our `io_buf`
1428  * to make it available to MHD.
1429  *
1430  * @param buf where to write the data
1431  * @param size number of bytes per member
1432  * @param nmemb number of members available in @a buf
1433  * @param cls our `struct Socks5Request` that generated the data
1434  * @return number of bytes copied to @a buf
1435  */
1436 static size_t
1437 curl_upload_cb (void *buf,
1438                 size_t size,
1439                 size_t nmemb,
1440                 void *cls)
1441 {
1442   struct Socks5Request *s5r = cls;
1443   size_t len = size * nmemb;
1444   size_t to_copy;
1445
1446   if ( (0 == s5r->io_len) &&
1447        (SOCKS5_SOCKET_UPLOAD_DONE != s5r->state) )
1448   {
1449     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1450                 "Pausing CURL UPLOAD %s%s, need more data\n",
1451                 s5r->domain,
1452                 s5r->url);
1453     return CURL_READFUNC_PAUSE;
1454   }
1455   if ( (0 == s5r->io_len) &&
1456        (SOCKS5_SOCKET_UPLOAD_DONE == s5r->state) )
1457   {
1458     s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
1459     if (GNUNET_YES == s5r->curl_paused)
1460     {
1461       s5r->curl_paused = GNUNET_NO;
1462       curl_easy_pause (s5r->curl,
1463                        CURLPAUSE_CONT);
1464     }
1465     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1466                 "Completed CURL UPLOAD %s%s\n",
1467                 s5r->domain,
1468                 s5r->url);
1469     return 0; /* upload finished, can now download */
1470   }
1471   if ( (SOCKS5_SOCKET_UPLOAD_STARTED != s5r->state) &&
1472        (SOCKS5_SOCKET_UPLOAD_DONE != s5r->state) )
1473   {
1474     GNUNET_break (0);
1475     return CURL_READFUNC_ABORT;
1476   }
1477   to_copy = GNUNET_MIN (s5r->io_len,
1478                         len);
1479   GNUNET_memcpy (buf,
1480                  s5r->io_buf,
1481                  to_copy);
1482   memmove (s5r->io_buf,
1483            &s5r->io_buf[to_copy],
1484            s5r->io_len - to_copy);
1485   s5r->io_len -= to_copy;
1486   if (s5r->io_len + to_copy == sizeof (s5r->io_buf))
1487     run_mhd_now (s5r->hd); /* got more space for upload now */
1488   return to_copy;
1489 }
1490
1491
1492 /* ************************** main loop of cURL interaction ****************** */
1493
1494
1495 /**
1496  * Task that is run when we are ready to receive more data
1497  * from curl
1498  *
1499  * @param cls closure
1500  */
1501 static void
1502 curl_task_download (void *cls);
1503
1504
1505 /**
1506  * Ask cURL for the select() sets and schedule cURL operations.
1507  */
1508 static void
1509 curl_download_prepare ()
1510 {
1511   CURLMcode mret;
1512   fd_set rs;
1513   fd_set ws;
1514   fd_set es;
1515   int max;
1516   struct GNUNET_NETWORK_FDSet *grs;
1517   struct GNUNET_NETWORK_FDSet *gws;
1518   long to;
1519   struct GNUNET_TIME_Relative rtime;
1520
1521   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1522               "Scheduling CURL interaction\n");
1523   if (NULL != curl_download_task)
1524   {
1525     GNUNET_SCHEDULER_cancel (curl_download_task);
1526     curl_download_task = NULL;
1527   }
1528   max = -1;
1529   FD_ZERO (&rs);
1530   FD_ZERO (&ws);
1531   FD_ZERO (&es);
1532   if (CURLM_OK != (mret = curl_multi_fdset (curl_multi,
1533                                             &rs,
1534                                             &ws,
1535                                             &es,
1536                                             &max)))
1537   {
1538     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1539                 "%s failed at %s:%d: `%s'\n",
1540                 "curl_multi_fdset", __FILE__, __LINE__,
1541                 curl_multi_strerror (mret));
1542     return;
1543   }
1544   to = -1;
1545   GNUNET_break (CURLM_OK ==
1546                 curl_multi_timeout (curl_multi,
1547                                     &to));
1548   if (-1 == to)
1549     rtime = GNUNET_TIME_UNIT_FOREVER_REL;
1550   else
1551     rtime = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
1552                                            to);
1553   if (-1 != max)
1554   {
1555     grs = GNUNET_NETWORK_fdset_create ();
1556     gws = GNUNET_NETWORK_fdset_create ();
1557     GNUNET_NETWORK_fdset_copy_native (grs,
1558                                       &rs,
1559                                       max + 1);
1560     GNUNET_NETWORK_fdset_copy_native (gws,
1561                                       &ws,
1562                                       max + 1);
1563     curl_download_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
1564                                                       rtime,
1565                                                       grs,
1566                                                       gws,
1567                                                       &curl_task_download,
1568                                                       curl_multi);
1569     GNUNET_NETWORK_fdset_destroy (gws);
1570     GNUNET_NETWORK_fdset_destroy (grs);
1571   }
1572   else
1573   {
1574     curl_download_task = GNUNET_SCHEDULER_add_delayed (rtime,
1575                                                        &curl_task_download,
1576                                                        curl_multi);
1577   }
1578 }
1579
1580
1581 /**
1582  * Task that is run when we are ready to receive more data from curl.
1583  *
1584  * @param cls closure, NULL
1585  */
1586 static void
1587 curl_task_download (void *cls)
1588 {
1589   int running;
1590   int msgnum;
1591   struct CURLMsg *msg;
1592   CURLMcode mret;
1593   struct Socks5Request *s5r;
1594
1595   curl_download_task = NULL;
1596   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1597               "Running CURL interaction\n");
1598   do
1599   {
1600     running = 0;
1601     mret = curl_multi_perform (curl_multi,
1602                                &running);
1603     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1604                 "Checking CURL multi status: %d\n",
1605                 mret);
1606     while (NULL != (msg = curl_multi_info_read (curl_multi,
1607                                                 &msgnum)))
1608     {
1609       GNUNET_break (CURLE_OK ==
1610                     curl_easy_getinfo (msg->easy_handle,
1611                                        CURLINFO_PRIVATE,
1612                                        (char **) &s5r ));
1613       if (NULL == s5r)
1614       {
1615         GNUNET_break (0);
1616         continue;
1617       }
1618       switch (msg->msg)
1619       {
1620         case CURLMSG_NONE:
1621           /* documentation says this is not used */
1622           GNUNET_break (0);
1623           break;
1624         case CURLMSG_DONE:
1625           switch (msg->data.result)
1626           {
1627             case CURLE_OK:
1628             case CURLE_GOT_NOTHING:
1629               GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1630                           "CURL download %s%s completed.\n",
1631                           s5r->domain,
1632                           s5r->url);
1633               if (NULL == s5r->response)
1634               {
1635                 GNUNET_assert (GNUNET_OK ==
1636                                create_mhd_response_from_s5r (s5r));
1637               }
1638               s5r->state = SOCKS5_SOCKET_DOWNLOAD_DONE;
1639               if (GNUNET_YES == s5r->suspended)
1640               {
1641                 MHD_resume_connection (s5r->con);
1642                 s5r->suspended = GNUNET_NO;
1643               }
1644               run_mhd_now (s5r->hd);
1645               break;
1646             default:
1647               GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1648                           "Download curl %s%s failed: %s\n",
1649                           s5r->domain,
1650                           s5r->url,
1651                           curl_easy_strerror (msg->data.result));
1652               /* FIXME: indicate error somehow? close MHD connection badly as well? */
1653               s5r->state = SOCKS5_SOCKET_DOWNLOAD_DONE;
1654               if (GNUNET_YES == s5r->suspended)
1655               {
1656                 MHD_resume_connection (s5r->con);
1657                 s5r->suspended = GNUNET_NO;
1658               }
1659               run_mhd_now (s5r->hd);
1660               break;
1661           }
1662           if (NULL == s5r->response)
1663             s5r->response = curl_failure_response;
1664           break;
1665         case CURLMSG_LAST:
1666           /* documentation says this is not used */
1667           GNUNET_break (0);
1668           break;
1669         default:
1670           /* unexpected status code */
1671           GNUNET_break (0);
1672           break;
1673       }
1674     };
1675   } while (mret == CURLM_CALL_MULTI_PERFORM);
1676   if (CURLM_OK != mret)
1677     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
1678                 "%s failed at %s:%d: `%s'\n",
1679                 "curl_multi_perform", __FILE__, __LINE__,
1680                 curl_multi_strerror (mret));
1681   if (0 == running)
1682   {
1683     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1684                 "Suspending cURL multi loop, no more events pending\n");
1685     if (NULL != curl_download_task)
1686     {
1687       GNUNET_SCHEDULER_cancel (curl_download_task);
1688       curl_download_task = NULL;
1689     }
1690     return; /* nothing more in progress */
1691   }
1692   curl_download_prepare ();
1693 }
1694
1695
1696 /* ********************************* MHD response generation ******************* */
1697
1698
1699 /**
1700  * Read HTTP request header field from the request.  Copies the fields
1701  * over to the 'headers' that will be given to curl.  However, 'Host'
1702  * is substituted with the LEHO if present.  We also change the
1703  * 'Connection' header value to "close" as the proxy does not support
1704  * pipelining.
1705  *
1706  * @param cls our `struct Socks5Request`
1707  * @param kind value kind
1708  * @param key field key
1709  * @param value field value
1710  * @return #MHD_YES to continue to iterate
1711  */
1712 static int
1713 con_val_iter (void *cls,
1714               enum MHD_ValueKind kind,
1715               const char *key,
1716               const char *value)
1717 {
1718   struct Socks5Request *s5r = cls;
1719   char *hdr;
1720
1721   if ( (0 == strcasecmp (MHD_HTTP_HEADER_HOST,
1722                          key)) &&
1723        (NULL != s5r->leho) )
1724     value = s5r->leho;
1725   if (0 == strcasecmp (MHD_HTTP_HEADER_CONTENT_LENGTH,
1726                        key))
1727     return MHD_YES;
1728   if (0 == strcasecmp (MHD_HTTP_HEADER_ACCEPT_ENCODING,
1729                        key))
1730     return MHD_YES;
1731   GNUNET_asprintf (&hdr,
1732                    "%s: %s",
1733                    key,
1734                    value);
1735   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1736               "Adding HEADER `%s' to HTTP request\n",
1737               hdr);
1738   s5r->headers = curl_slist_append (s5r->headers,
1739                                     hdr);
1740   GNUNET_free (hdr);
1741   return MHD_YES;
1742 }
1743
1744
1745 /**
1746  * Main MHD callback for handling requests.
1747  *
1748  * @param cls unused
1749  * @param con MHD connection handle
1750  * @param url the url in the request
1751  * @param meth the HTTP method used ("GET", "PUT", etc.)
1752  * @param ver the HTTP version string (i.e. "HTTP/1.1")
1753  * @param upload_data the data being uploaded (excluding HEADERS,
1754  *        for a POST that fits into memory and that is encoded
1755  *        with a supported encoding, the POST data will NOT be
1756  *        given in upload_data and is instead available as
1757  *        part of MHD_get_connection_values; very large POST
1758  *        data *will* be made available incrementally in
1759  *        upload_data)
1760  * @param upload_data_size set initially to the size of the
1761  *        @a upload_data provided; the method must update this
1762  *        value to the number of bytes NOT processed;
1763  * @param con_cls pointer to location where we store the `struct Request`
1764  * @return #MHD_YES if the connection was handled successfully,
1765  *         #MHD_NO if the socket must be closed due to a serious
1766  *         error while handling the request
1767  */
1768 static int
1769 create_response (void *cls,
1770                  struct MHD_Connection *con,
1771                  const char *url,
1772                  const char *meth,
1773                  const char *ver,
1774                  const char *upload_data,
1775                  size_t *upload_data_size,
1776                  void **con_cls)
1777 {
1778   struct Socks5Request *s5r = *con_cls;
1779   char *curlurl;
1780   char ipstring[INET6_ADDRSTRLEN];
1781   char ipaddr[INET6_ADDRSTRLEN + 2];
1782   const struct sockaddr *sa;
1783   const struct sockaddr_in *s4;
1784   const struct sockaddr_in6 *s6;
1785   uint16_t port;
1786   size_t left;
1787
1788   if (NULL == s5r)
1789   {
1790     GNUNET_break (0);
1791     return MHD_NO;
1792   }
1793   s5r->con = con;
1794   /* Fresh connection. */
1795   if (SOCKS5_SOCKET_WITH_MHD == s5r->state)
1796   {
1797     /* first time here, initialize curl handle */
1798     if (s5r->is_gns)
1799     {
1800       sa = (const struct sockaddr *) &s5r->destination_address;
1801       switch (sa->sa_family)
1802       {
1803       case AF_INET:
1804         s4 = (const struct sockaddr_in *) &s5r->destination_address;
1805         if (NULL == inet_ntop (AF_INET,
1806                                &s4->sin_addr,
1807                                ipstring,
1808                                sizeof (ipstring)))
1809         {
1810           GNUNET_break (0);
1811           return MHD_NO;
1812         }
1813         GNUNET_snprintf (ipaddr,
1814                          sizeof (ipaddr),
1815                          "%s",
1816                          ipstring);
1817         port = ntohs (s4->sin_port);
1818         break;
1819       case AF_INET6:
1820         s6 = (const struct sockaddr_in6 *) &s5r->destination_address;
1821         if (NULL == inet_ntop (AF_INET6,
1822                                &s6->sin6_addr,
1823                                ipstring,
1824                                sizeof (ipstring)))
1825         {
1826           GNUNET_break (0);
1827           return MHD_NO;
1828         }
1829         GNUNET_snprintf (ipaddr,
1830                          sizeof (ipaddr),
1831                          "%s",
1832                          ipstring);
1833         port = ntohs (s6->sin6_port);
1834         break;
1835       default:
1836         GNUNET_break (0);
1837         return MHD_NO;
1838       }
1839     }
1840     else
1841     {
1842       port = s5r->port;
1843     }
1844     if (NULL == s5r->curl)
1845       s5r->curl = curl_easy_init ();
1846     if (NULL == s5r->curl)
1847       return MHD_queue_response (con,
1848                                  MHD_HTTP_INTERNAL_SERVER_ERROR,
1849                                  curl_failure_response);
1850     curl_easy_setopt (s5r->curl,
1851                       CURLOPT_HEADERFUNCTION,
1852                       &curl_check_hdr);
1853     curl_easy_setopt (s5r->curl,
1854                       CURLOPT_HEADERDATA,
1855                       s5r);
1856     curl_easy_setopt (s5r->curl,
1857                       CURLOPT_FOLLOWLOCATION,
1858                       0);
1859     if (s5r->is_gns)
1860       curl_easy_setopt (s5r->curl,
1861                         CURLOPT_IPRESOLVE,
1862                         CURL_IPRESOLVE_V4);
1863     curl_easy_setopt (s5r->curl,
1864                       CURLOPT_CONNECTTIMEOUT,
1865                       600L);
1866     curl_easy_setopt (s5r->curl,
1867                       CURLOPT_TIMEOUT,
1868                       600L);
1869     curl_easy_setopt (s5r->curl,
1870                       CURLOPT_NOSIGNAL,
1871                       1L);
1872     curl_easy_setopt (s5r->curl,
1873                       CURLOPT_HTTP_CONTENT_DECODING,
1874                       0);
1875     curl_easy_setopt (s5r->curl,
1876                       CURLOPT_NOSIGNAL,
1877                       1L);
1878     curl_easy_setopt (s5r->curl,
1879                       CURLOPT_PRIVATE,
1880                       s5r);
1881     curl_easy_setopt (s5r->curl,
1882                       CURLOPT_VERBOSE,
1883                       0L);
1884     /**
1885      * Pre-populate cache to resolve Hostname.
1886      * This is necessary as the DNS name in the CURLOPT_URL is used
1887      * for SNI http://de.wikipedia.org/wiki/Server_Name_Indication
1888      */
1889     if (NULL != s5r->leho)
1890     {
1891       char *curl_hosts;
1892
1893       GNUNET_asprintf (&curl_hosts,
1894                        "%s:%d:%s",
1895                        s5r->leho,
1896                        port,
1897                        ipaddr);
1898       s5r->hosts = curl_slist_append (NULL,
1899                                       curl_hosts);
1900       curl_easy_setopt (s5r->curl,
1901                         CURLOPT_RESOLVE,
1902                         s5r->hosts);
1903       GNUNET_free (curl_hosts);
1904     }
1905     if (s5r->is_gns)
1906     {
1907       GNUNET_asprintf (&curlurl,
1908                        (HTTPS_PORT != s5r->port)
1909                        ? "http://%s:%d%s"
1910                        : "https://%s:%d%s",
1911                        (NULL != s5r->leho)
1912                        ? s5r->leho
1913                        : ipaddr,
1914                        port,
1915                        s5r->url);
1916     }
1917     else
1918     {
1919       GNUNET_asprintf (&curlurl,
1920                        (HTTPS_PORT != s5r->port)
1921                        ? "http://%s:%d%s"
1922                        : "https://%s:%d%s",
1923                        s5r->domain,
1924                        port,
1925                        s5r->url);
1926     }
1927     curl_easy_setopt (s5r->curl,
1928                       CURLOPT_URL,
1929                       curlurl);
1930     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
1931                 "Launching %s CURL interaction, fetching `%s'\n",
1932                 (s5r->is_gns) ? "GNS" : "DNS",
1933                 curlurl);
1934     GNUNET_free (curlurl);
1935     if (0 == strcasecmp (meth,
1936                          MHD_HTTP_METHOD_PUT))
1937     {
1938       s5r->state = SOCKS5_SOCKET_UPLOAD_STARTED;
1939       curl_easy_setopt (s5r->curl,
1940                         CURLOPT_UPLOAD,
1941                         1L);
1942       curl_easy_setopt (s5r->curl,
1943                         CURLOPT_WRITEFUNCTION,
1944                         &curl_download_cb);
1945       curl_easy_setopt (s5r->curl,
1946                         CURLOPT_WRITEDATA,
1947                         s5r);
1948       GNUNET_assert (CURLE_OK ==
1949                      curl_easy_setopt (s5r->curl,
1950                                        CURLOPT_READFUNCTION,
1951                                        &curl_upload_cb));
1952       curl_easy_setopt (s5r->curl,
1953                         CURLOPT_READDATA,
1954                         s5r);
1955       {
1956         const char *us;
1957         long upload_size;
1958
1959         us = MHD_lookup_connection_value (con,
1960                                           MHD_HEADER_KIND,
1961                                           MHD_HTTP_HEADER_CONTENT_LENGTH);
1962         if ( (1 == sscanf (us,
1963                            "%ld",
1964                            &upload_size)) &&
1965              (upload_size >= 0) )
1966         {
1967           curl_easy_setopt (s5r->curl,
1968                             CURLOPT_INFILESIZE,
1969                             upload_size);
1970         }
1971       }
1972     }
1973     else if (0 == strcasecmp (meth, MHD_HTTP_METHOD_POST))
1974     {
1975       s5r->state = SOCKS5_SOCKET_UPLOAD_STARTED;
1976       curl_easy_setopt (s5r->curl,
1977                         CURLOPT_POST,
1978                         1L);
1979       curl_easy_setopt (s5r->curl,
1980                         CURLOPT_WRITEFUNCTION,
1981                         &curl_download_cb);
1982       curl_easy_setopt (s5r->curl,
1983                         CURLOPT_WRITEDATA,
1984                         s5r);
1985       curl_easy_setopt (s5r->curl,
1986                         CURLOPT_READFUNCTION,
1987                         &curl_upload_cb);
1988       curl_easy_setopt (s5r->curl,
1989                         CURLOPT_READDATA,
1990                         s5r);
1991       {
1992         const char *us;
1993         long upload_size;
1994
1995         us = MHD_lookup_connection_value (con,
1996                                           MHD_HEADER_KIND,
1997                                           MHD_HTTP_HEADER_CONTENT_LENGTH);
1998         if ( (NULL != us) &&
1999              (1 == sscanf (us,
2000                            "%ld",
2001                            &upload_size)) &&
2002              (upload_size >= 0) )
2003         {
2004           curl_easy_setopt (s5r->curl,
2005                             CURLOPT_INFILESIZE,
2006                             upload_size);
2007         } else {
2008           curl_easy_setopt (s5r->curl,
2009                             CURLOPT_INFILESIZE,
2010                             upload_size);
2011         }
2012       }
2013     }
2014     else if (0 == strcasecmp (meth,
2015                               MHD_HTTP_METHOD_HEAD))
2016     {
2017       s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
2018       curl_easy_setopt (s5r->curl,
2019                         CURLOPT_NOBODY,
2020                         1L);
2021     }
2022     else if (0 == strcasecmp (meth,
2023                               MHD_HTTP_METHOD_OPTIONS))
2024     {
2025       s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
2026       curl_easy_setopt (s5r->curl,
2027                         CURLOPT_CUSTOMREQUEST,
2028                         "OPTIONS");
2029     }
2030     else if (0 == strcasecmp (meth,
2031                               MHD_HTTP_METHOD_GET))
2032     {
2033       s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
2034       curl_easy_setopt (s5r->curl,
2035                         CURLOPT_HTTPGET,
2036                         1L);
2037       curl_easy_setopt (s5r->curl,
2038                         CURLOPT_WRITEFUNCTION,
2039                         &curl_download_cb);
2040       curl_easy_setopt (s5r->curl,
2041                         CURLOPT_WRITEDATA,
2042                         s5r);
2043     }
2044     else if (0 == strcasecmp (meth,
2045                               MHD_HTTP_METHOD_DELETE))
2046     {
2047       s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
2048       curl_easy_setopt (s5r->curl,
2049                         CURLOPT_CUSTOMREQUEST,
2050                         "DELETE");
2051       curl_easy_setopt (s5r->curl,
2052                         CURLOPT_WRITEFUNCTION,
2053                         &curl_download_cb);
2054       curl_easy_setopt (s5r->curl,
2055                         CURLOPT_WRITEDATA,
2056                         s5r);
2057     }
2058     else
2059     {
2060       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2061                   _("Unsupported HTTP method `%s'\n"),
2062                   meth);
2063       curl_easy_cleanup (s5r->curl);
2064       s5r->curl = NULL;
2065       return MHD_NO;
2066     }
2067
2068     if (0 == strcasecmp (ver, MHD_HTTP_VERSION_1_0))
2069     {
2070       curl_easy_setopt (s5r->curl,
2071                         CURLOPT_HTTP_VERSION,
2072                         CURL_HTTP_VERSION_1_0);
2073     }
2074     else if (0 == strcasecmp (ver, MHD_HTTP_VERSION_1_1))
2075     {
2076       curl_easy_setopt (s5r->curl,
2077                         CURLOPT_HTTP_VERSION,
2078                         CURL_HTTP_VERSION_1_1);
2079     }
2080     else
2081     {
2082       curl_easy_setopt (s5r->curl,
2083                         CURLOPT_HTTP_VERSION,
2084                         CURL_HTTP_VERSION_NONE);
2085     }
2086
2087     if (HTTPS_PORT == s5r->port)
2088     {
2089       curl_easy_setopt (s5r->curl,
2090                         CURLOPT_USE_SSL,
2091                         CURLUSESSL_ALL);
2092       if (NULL != s5r->dane_data)
2093         curl_easy_setopt (s5r->curl,
2094                           CURLOPT_SSL_VERIFYPEER,
2095                           0L);
2096       else
2097         curl_easy_setopt (s5r->curl,
2098                           CURLOPT_SSL_VERIFYPEER,
2099                           1L);
2100       /* Disable cURL checking the hostname, as we will check ourselves
2101          as only we have the domain name or the LEHO or the DANE record */
2102       curl_easy_setopt (s5r->curl,
2103                         CURLOPT_SSL_VERIFYHOST,
2104                         0L);
2105     }
2106     else
2107     {
2108       curl_easy_setopt (s5r->curl,
2109                         CURLOPT_USE_SSL,
2110                         CURLUSESSL_NONE);
2111     }
2112
2113     if (CURLM_OK !=
2114         curl_multi_add_handle (curl_multi,
2115                                s5r->curl))
2116     {
2117       GNUNET_break (0);
2118       curl_easy_cleanup (s5r->curl);
2119       s5r->curl = NULL;
2120       return MHD_NO;
2121     }
2122     MHD_get_connection_values (con,
2123                                MHD_HEADER_KIND,
2124                                &con_val_iter,
2125                                s5r);
2126     curl_easy_setopt (s5r->curl,
2127                       CURLOPT_HTTPHEADER,
2128                       s5r->headers);
2129     curl_download_prepare ();
2130     return MHD_YES;
2131   }
2132
2133   /* continuing to process request */
2134   if (0 != *upload_data_size)
2135   {
2136     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2137                 "Processing %u bytes UPLOAD\n",
2138                 (unsigned int) *upload_data_size);
2139
2140     /* FIXME: This must be set or a header with Transfer-Encoding: chunked. Else
2141      * upload callback is not called!
2142      */
2143     curl_easy_setopt (s5r->curl,
2144                       CURLOPT_POSTFIELDSIZE,
2145                       *upload_data_size);
2146
2147     left = GNUNET_MIN (*upload_data_size,
2148                        sizeof (s5r->io_buf) - s5r->io_len);
2149     GNUNET_memcpy (&s5r->io_buf[s5r->io_len],
2150                    upload_data,
2151                    left);
2152     s5r->io_len += left;
2153     *upload_data_size -= left;
2154     GNUNET_assert (NULL != s5r->curl);
2155     if (GNUNET_YES == s5r->curl_paused)
2156     {
2157       s5r->curl_paused = GNUNET_NO;
2158       curl_easy_pause (s5r->curl,
2159                        CURLPAUSE_CONT);
2160     }
2161     return MHD_YES;
2162   }
2163   if (SOCKS5_SOCKET_UPLOAD_STARTED == s5r->state)
2164   {
2165     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2166                 "Finished processing UPLOAD\n");
2167     s5r->state = SOCKS5_SOCKET_UPLOAD_DONE;
2168   }
2169   if (NULL == s5r->response)
2170   {
2171     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2172                 "Waiting for HTTP response for %s%s...\n",
2173                 s5r->domain,
2174                 s5r->url);
2175     MHD_suspend_connection (con);
2176     s5r->suspended = GNUNET_YES;
2177     return MHD_YES;
2178   }
2179   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2180               "Queueing response for %s%s with MHD\n",
2181               s5r->domain,
2182               s5r->url);
2183   run_mhd_now (s5r->hd);
2184   return MHD_queue_response (con,
2185                              s5r->response_code,
2186                              s5r->response);
2187 }
2188
2189
2190 /* ******************** MHD HTTP setup and event loop ******************** */
2191
2192
2193 /**
2194  * Function called when MHD decides that we are done with a request.
2195  *
2196  * @param cls NULL
2197  * @param connection connection handle
2198  * @param con_cls value as set by the last call to
2199  *        the MHD_AccessHandlerCallback, should be our `struct Socks5Request *`
2200  * @param toe reason for request termination (ignored)
2201  */
2202 static void
2203 mhd_completed_cb (void *cls,
2204                   struct MHD_Connection *connection,
2205                   void **con_cls,
2206                   enum MHD_RequestTerminationCode toe)
2207 {
2208   struct Socks5Request *s5r = *con_cls;
2209
2210   if (NULL == s5r)
2211     return;
2212   if (MHD_REQUEST_TERMINATED_COMPLETED_OK != toe)
2213     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2214                 "MHD encountered error handling request: %d\n",
2215                 toe);
2216   if (NULL != s5r->curl)
2217   {
2218     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2219                 "Removing cURL handle (MHD interaction complete)\n");
2220     curl_multi_remove_handle (curl_multi,
2221                               s5r->curl);
2222     curl_slist_free_all (s5r->headers);
2223     s5r->headers = NULL;
2224     curl_easy_reset (s5r->curl);
2225     s5r->rbuf_len = 0;
2226     s5r->wbuf_len = 0;
2227     s5r->io_len = 0;
2228     curl_download_prepare ();
2229   }
2230   if ( (NULL != s5r->response) &&
2231        (curl_failure_response != s5r->response) )
2232     MHD_destroy_response (s5r->response);
2233   for (struct HttpResponseHeader *header = s5r->header_head;
2234        NULL != header;
2235        header = s5r->header_head)
2236   {
2237     GNUNET_CONTAINER_DLL_remove (s5r->header_head,
2238                                  s5r->header_tail,
2239                                  header);
2240     GNUNET_free (header->type);
2241     GNUNET_free (header->value);
2242     GNUNET_free (header);
2243   }
2244   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2245               "Finished request for %s\n",
2246               s5r->url);
2247   GNUNET_free (s5r->url);
2248   s5r->state = SOCKS5_SOCKET_WITH_MHD;
2249   s5r->url = NULL;
2250   s5r->response = NULL;
2251   *con_cls = NULL;
2252 }
2253
2254
2255 /**
2256  * Function called when MHD connection is opened or closed.
2257  *
2258  * @param cls NULL
2259  * @param connection connection handle
2260  * @param con_cls value as set by the last call to
2261  *        the MHD_AccessHandlerCallback, should be our `struct Socks5Request *`
2262  * @param toe connection notification type
2263  */
2264 static void
2265 mhd_connection_cb (void *cls,
2266                    struct MHD_Connection *connection,
2267                    void **con_cls,
2268                    enum MHD_ConnectionNotificationCode cnc)
2269 {
2270   struct Socks5Request *s5r;
2271   const union MHD_ConnectionInfo *ci;
2272   int sock;
2273
2274   switch (cnc)
2275   {
2276     case MHD_CONNECTION_NOTIFY_STARTED:
2277       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connection started...\n");
2278       ci = MHD_get_connection_info (connection,
2279                                     MHD_CONNECTION_INFO_CONNECTION_FD);
2280       if (NULL == ci)
2281       {
2282         GNUNET_break (0);
2283         return;
2284       }
2285       sock = ci->connect_fd;
2286       for (s5r = s5r_head; NULL != s5r; s5r = s5r->next)
2287       {
2288         if (GNUNET_NETWORK_get_fd (s5r->sock) == sock)
2289         {
2290           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2291                       "Context set...\n");
2292           s5r->ssl_checked = GNUNET_NO;
2293           *con_cls = s5r;
2294           break;
2295         }
2296       }
2297       break;
2298     case MHD_CONNECTION_NOTIFY_CLOSED:
2299       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2300                   "Connection closed... cleaning up\n");
2301       s5r = *con_cls;
2302       if (NULL == s5r)
2303       {
2304         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2305                     "Connection stale!\n");
2306         return;
2307       }
2308       cleanup_s5r (s5r);
2309       curl_download_prepare ();
2310       *con_cls = NULL;
2311       break;
2312     default:
2313       GNUNET_break (0);
2314   }
2315 }
2316
2317 /**
2318  * Function called when MHD first processes an incoming connection.
2319  * Gives us the respective URI information.
2320  *
2321  * We use this to associate the `struct MHD_Connection` with our
2322  * internal `struct Socks5Request` data structure (by checking
2323  * for matching sockets).
2324  *
2325  * @param cls the HTTP server handle (a `struct MhdHttpList`)
2326  * @param url the URL that is being requested
2327  * @param connection MHD connection object for the request
2328  * @return the `struct Socks5Request` that this @a connection is for
2329  */
2330 static void *
2331 mhd_log_callback (void *cls,
2332                   const char *url,
2333                   struct MHD_Connection *connection)
2334 {
2335   struct Socks5Request *s5r;
2336   const union MHD_ConnectionInfo *ci;
2337
2338   ci = MHD_get_connection_info (connection,
2339                                 MHD_CONNECTION_INFO_SOCKET_CONTEXT);
2340   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing %s\n", url);
2341   if (NULL == ci)
2342   {
2343     GNUNET_break (0);
2344     return NULL;
2345   }
2346   s5r = ci->socket_context;
2347   if (NULL != s5r->url)
2348   {
2349     GNUNET_break (0);
2350     return NULL;
2351   }
2352   s5r->url = GNUNET_strdup (url);
2353   if (NULL != s5r->timeout_task)
2354   {
2355     GNUNET_SCHEDULER_cancel (s5r->timeout_task);
2356     s5r->timeout_task = NULL;
2357   }
2358   GNUNET_assert (s5r->state == SOCKS5_SOCKET_WITH_MHD);
2359   return s5r;
2360 }
2361
2362
2363 /**
2364  * Kill the given MHD daemon.
2365  *
2366  * @param hd daemon to stop
2367  */
2368 static void
2369 kill_httpd (struct MhdHttpList *hd)
2370 {
2371   GNUNET_CONTAINER_DLL_remove (mhd_httpd_head,
2372                                mhd_httpd_tail,
2373                                hd);
2374   GNUNET_free_non_null (hd->domain);
2375   MHD_stop_daemon (hd->daemon);
2376   if (NULL != hd->httpd_task)
2377   {
2378     GNUNET_SCHEDULER_cancel (hd->httpd_task);
2379     hd->httpd_task = NULL;
2380   }
2381   GNUNET_free_non_null (hd->proxy_cert);
2382   if (hd == httpd)
2383     httpd = NULL;
2384   GNUNET_free (hd);
2385 }
2386
2387
2388 /**
2389  * Task run whenever HTTP server is idle for too long. Kill it.
2390  *
2391  * @param cls the `struct MhdHttpList *`
2392  */
2393 static void
2394 kill_httpd_task (void *cls)
2395 {
2396   struct MhdHttpList *hd = cls;
2397
2398   hd->httpd_task = NULL;
2399   kill_httpd (hd);
2400 }
2401
2402
2403 /**
2404  * Task run whenever HTTP server operations are pending.
2405  *
2406  * @param cls the `struct MhdHttpList *` of the daemon that is being run
2407  */
2408 static void
2409 do_httpd (void *cls);
2410
2411
2412 /**
2413  * Schedule MHD.  This function should be called initially when an
2414  * MHD is first getting its client socket, and will then automatically
2415  * always be called later whenever there is work to be done.
2416  *
2417  * @param hd the daemon to schedule
2418  */
2419 static void
2420 schedule_httpd (struct MhdHttpList *hd)
2421 {
2422   fd_set rs;
2423   fd_set ws;
2424   fd_set es;
2425   struct GNUNET_NETWORK_FDSet *wrs;
2426   struct GNUNET_NETWORK_FDSet *wws;
2427   int max;
2428   int haveto;
2429   MHD_UNSIGNED_LONG_LONG timeout;
2430   struct GNUNET_TIME_Relative tv;
2431
2432   FD_ZERO (&rs);
2433   FD_ZERO (&ws);
2434   FD_ZERO (&es);
2435   max = -1;
2436   if (MHD_YES !=
2437       MHD_get_fdset (hd->daemon,
2438                      &rs,
2439                      &ws,
2440                      &es,
2441                      &max))
2442   {
2443     kill_httpd (hd);
2444     return;
2445   }
2446   haveto = MHD_get_timeout (hd->daemon,
2447                             &timeout);
2448   if (MHD_YES == haveto)
2449     tv.rel_value_us = (uint64_t) timeout * 1000LL;
2450   else
2451     tv = GNUNET_TIME_UNIT_FOREVER_REL;
2452   if (-1 != max)
2453   {
2454     wrs = GNUNET_NETWORK_fdset_create ();
2455     wws = GNUNET_NETWORK_fdset_create ();
2456     GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
2457     GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
2458   }
2459   else
2460   {
2461     wrs = NULL;
2462     wws = NULL;
2463   }
2464   if (NULL != hd->httpd_task)
2465   {
2466     GNUNET_SCHEDULER_cancel (hd->httpd_task);
2467     hd->httpd_task = NULL;
2468   }
2469   if ( (MHD_YES != haveto) &&
2470        (-1 == max) &&
2471        (hd != httpd) )
2472   {
2473     /* daemon is idle, kill after timeout */
2474     hd->httpd_task = GNUNET_SCHEDULER_add_delayed (MHD_CACHE_TIMEOUT,
2475                                                    &kill_httpd_task,
2476                                                    hd);
2477   }
2478   else
2479   {
2480     hd->httpd_task =
2481       GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
2482                                    tv, wrs, wws,
2483                                    &do_httpd, hd);
2484   }
2485   if (NULL != wrs)
2486     GNUNET_NETWORK_fdset_destroy (wrs);
2487   if (NULL != wws)
2488     GNUNET_NETWORK_fdset_destroy (wws);
2489 }
2490
2491
2492 /**
2493  * Task run whenever HTTP server operations are pending.
2494  *
2495  * @param cls the `struct MhdHttpList` of the daemon that is being run
2496  */
2497 static void
2498 do_httpd (void *cls)
2499 {
2500   struct MhdHttpList *hd = cls;
2501
2502   hd->httpd_task = NULL;
2503   MHD_run (hd->daemon);
2504   schedule_httpd (hd);
2505 }
2506
2507
2508 /**
2509  * Run MHD now, we have extra data ready for the callback.
2510  *
2511  * @param hd the daemon to run now.
2512  */
2513 static void
2514 run_mhd_now (struct MhdHttpList *hd)
2515 {
2516   if (NULL != hd->httpd_task)
2517     GNUNET_SCHEDULER_cancel (hd->httpd_task);
2518   hd->httpd_task = GNUNET_SCHEDULER_add_now (&do_httpd,
2519                                              hd);
2520 }
2521
2522
2523 /**
2524  * Read file in filename
2525  *
2526  * @param filename file to read
2527  * @param size pointer where filesize is stored
2528  * @return NULL on error
2529  */
2530 static void*
2531 load_file (const char* filename,
2532            unsigned int* size)
2533 {
2534   void *buffer;
2535   uint64_t fsize;
2536
2537   if (GNUNET_OK !=
2538       GNUNET_DISK_file_size (filename,
2539                              &fsize,
2540                              GNUNET_YES,
2541                              GNUNET_YES))
2542     return NULL;
2543   if (fsize > MAX_PEM_SIZE)
2544     return NULL;
2545   *size = (unsigned int) fsize;
2546   buffer = GNUNET_malloc (*size);
2547   if (fsize !=
2548       GNUNET_DISK_fn_read (filename,
2549                            buffer,
2550                            (size_t) fsize))
2551   {
2552     GNUNET_free (buffer);
2553     return NULL;
2554   }
2555   return buffer;
2556 }
2557
2558
2559 /**
2560  * Load PEM key from file
2561  *
2562  * @param key where to store the data
2563  * @param keyfile path to the PEM file
2564  * @return #GNUNET_OK on success
2565  */
2566 static int
2567 load_key_from_file (gnutls_x509_privkey_t key,
2568                     const char* keyfile)
2569 {
2570   gnutls_datum_t key_data;
2571   int ret;
2572
2573   key_data.data = load_file (keyfile,
2574                              &key_data.size);
2575   if (NULL == key_data.data)
2576     return GNUNET_SYSERR;
2577   ret = gnutls_x509_privkey_import (key, &key_data,
2578                                     GNUTLS_X509_FMT_PEM);
2579   if (GNUTLS_E_SUCCESS != ret)
2580   {
2581     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2582                 _("Unable to import private key from file `%s'\n"),
2583                 keyfile);
2584   }
2585   GNUNET_free_non_null (key_data.data);
2586   return (GNUTLS_E_SUCCESS != ret) ? GNUNET_SYSERR : GNUNET_OK;
2587 }
2588
2589
2590 /**
2591  * Load cert from file
2592  *
2593  * @param crt struct to store data in
2594  * @param certfile path to pem file
2595  * @return #GNUNET_OK on success
2596  */
2597 static int
2598 load_cert_from_file (gnutls_x509_crt_t crt,
2599                      const char* certfile)
2600 {
2601   gnutls_datum_t cert_data;
2602   int ret;
2603
2604   cert_data.data = load_file (certfile,
2605                               &cert_data.size);
2606   if (NULL == cert_data.data)
2607     return GNUNET_SYSERR;
2608   ret = gnutls_x509_crt_import (crt,
2609                                 &cert_data,
2610                                 GNUTLS_X509_FMT_PEM);
2611   if (GNUTLS_E_SUCCESS != ret)
2612   {
2613     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2614                 _("Unable to import certificate from `%s'\n"),
2615                 certfile);
2616   }
2617   GNUNET_free_non_null (cert_data.data);
2618   return (GNUTLS_E_SUCCESS != ret) ? GNUNET_SYSERR : GNUNET_OK;
2619 }
2620
2621
2622 /**
2623  * Generate new certificate for specific name
2624  *
2625  * @param name the subject name to generate a cert for
2626  * @return a struct holding the PEM data, NULL on error
2627  */
2628 static struct ProxyGNSCertificate *
2629 generate_gns_certificate (const char *name)
2630 {
2631   unsigned int serial;
2632   size_t key_buf_size;
2633   size_t cert_buf_size;
2634   gnutls_x509_crt_t request;
2635   time_t etime;
2636   struct tm *tm_data;
2637   struct ProxyGNSCertificate *pgc;
2638
2639   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2640               "Generating x.509 certificate for `%s'\n",
2641               name);
2642   GNUNET_break (GNUTLS_E_SUCCESS == gnutls_x509_crt_init (&request));
2643   GNUNET_break (GNUTLS_E_SUCCESS == gnutls_x509_crt_set_key (request, proxy_ca.key));
2644   pgc = GNUNET_new (struct ProxyGNSCertificate);
2645   gnutls_x509_crt_set_dn_by_oid (request,
2646                                  GNUTLS_OID_X520_COUNTRY_NAME,
2647                                  0,
2648                                  "ZZ",
2649                                  strlen ("ZZ"));
2650   gnutls_x509_crt_set_dn_by_oid (request,
2651                                  GNUTLS_OID_X520_ORGANIZATION_NAME,
2652                                  0,
2653                                  "GNU Name System",
2654                                  strlen ("GNU Name System"));
2655   gnutls_x509_crt_set_dn_by_oid (request,
2656                                  GNUTLS_OID_X520_COMMON_NAME,
2657                                  0,
2658                                  name,
2659                                  strlen (name));
2660   GNUNET_break (GNUTLS_E_SUCCESS ==
2661                 gnutls_x509_crt_set_version (request,
2662                                              3));
2663   gnutls_rnd (GNUTLS_RND_NONCE,
2664               &serial,
2665               sizeof (serial));
2666   gnutls_x509_crt_set_serial (request,
2667                               &serial,
2668                               sizeof (serial));
2669   etime = time (NULL);
2670   tm_data = localtime (&etime);
2671   tm_data->tm_hour--;
2672   etime = mktime(tm_data);
2673   gnutls_x509_crt_set_activation_time (request,
2674                                        etime);
2675   tm_data->tm_year++;
2676   etime = mktime (tm_data);
2677   gnutls_x509_crt_set_expiration_time (request,
2678                                        etime);
2679   gnutls_x509_crt_sign2 (request,
2680                          proxy_ca.cert,
2681                          proxy_ca.key,
2682                          GNUTLS_DIG_SHA512,
2683                          0);
2684   key_buf_size = sizeof (pgc->key);
2685   cert_buf_size = sizeof (pgc->cert);
2686   gnutls_x509_crt_export (request,
2687                           GNUTLS_X509_FMT_PEM,
2688                           pgc->cert,
2689                           &cert_buf_size);
2690   gnutls_x509_privkey_export (proxy_ca.key,
2691                               GNUTLS_X509_FMT_PEM,
2692                               pgc->key,
2693                               &key_buf_size);
2694   gnutls_x509_crt_deinit (request);
2695   return pgc;
2696 }
2697
2698
2699 /**
2700  * Function called by MHD with errors, suppresses them all.
2701  *
2702  * @param cls closure
2703  * @param fm format string (`printf()`-style)
2704  * @param ap arguments to @a fm
2705  */
2706 static void
2707 mhd_error_log_callback (void *cls,
2708                         const char *fm,
2709                         va_list ap)
2710 {
2711   /* do nothing */
2712 }
2713
2714
2715 /**
2716  * Lookup (or create) an TLS MHD instance for a particular domain.
2717  *
2718  * @param domain the domain the TLS daemon has to serve
2719  * @return NULL on error
2720  */
2721 static struct MhdHttpList *
2722 lookup_ssl_httpd (const char* domain)
2723 {
2724   struct MhdHttpList *hd;
2725   struct ProxyGNSCertificate *pgc;
2726
2727   if (NULL == domain)
2728   {
2729     GNUNET_break (0);
2730     return NULL;
2731   }
2732   for (hd = mhd_httpd_head; NULL != hd; hd = hd->next)
2733     if ( (NULL != hd->domain) &&
2734          (0 == strcmp (hd->domain, domain)) )
2735       return hd;
2736   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2737               "Starting fresh MHD HTTPS instance for domain `%s'\n",
2738               domain);
2739   pgc = generate_gns_certificate (domain);
2740   hd = GNUNET_new (struct MhdHttpList);
2741   hd->is_ssl = GNUNET_YES;
2742   hd->domain = GNUNET_strdup (domain);
2743   hd->proxy_cert = pgc;
2744   hd->daemon = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_SSL | MHD_USE_NO_LISTEN_SOCKET | MHD_ALLOW_SUSPEND_RESUME,
2745                                  0,
2746                                  NULL, NULL,
2747                                  &create_response, hd,
2748                                  MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
2749                                  MHD_OPTION_NOTIFY_COMPLETED, &mhd_completed_cb, NULL,
2750                                  MHD_OPTION_NOTIFY_CONNECTION, &mhd_connection_cb, NULL,
2751                                  MHD_OPTION_URI_LOG_CALLBACK, &mhd_log_callback, NULL,
2752                                  MHD_OPTION_EXTERNAL_LOGGER, &mhd_error_log_callback, NULL,
2753                                  MHD_OPTION_HTTPS_MEM_KEY, pgc->key,
2754                                  MHD_OPTION_HTTPS_MEM_CERT, pgc->cert,
2755                                  MHD_OPTION_END);
2756   if (NULL == hd->daemon)
2757   {
2758     GNUNET_free (pgc);
2759     GNUNET_free (hd);
2760     return NULL;
2761   }
2762   GNUNET_CONTAINER_DLL_insert (mhd_httpd_head,
2763                                mhd_httpd_tail,
2764                                hd);
2765   return hd;
2766 }
2767
2768
2769 /**
2770  * Task run when a Socks5Request somehow fails to be associated with
2771  * an MHD connection (i.e. because the client never speaks HTTP after
2772  * the SOCKS5 handshake).  Clean up.
2773  *
2774  * @param cls the `struct Socks5Request *`
2775  */
2776 static void
2777 timeout_s5r_handshake (void *cls)
2778 {
2779   struct Socks5Request *s5r = cls;
2780
2781   s5r->timeout_task = NULL;
2782   cleanup_s5r (s5r);
2783 }
2784
2785
2786 /**
2787  * We're done with the Socks5 protocol, now we need to pass the
2788  * connection data through to the final destination, either
2789  * direct (if the protocol might not be HTTP), or via MHD
2790  * (if the port looks like it should be HTTP).
2791  *
2792  * @param s5r socks request that has reached the final stage
2793  */
2794 static void
2795 setup_data_transfer (struct Socks5Request *s5r)
2796 {
2797   struct MhdHttpList *hd;
2798   int fd;
2799   const struct sockaddr *addr;
2800   socklen_t len;
2801   char *domain;
2802
2803   switch (s5r->port)
2804   {
2805     case HTTPS_PORT:
2806       GNUNET_asprintf (&domain,
2807                        "%s",
2808                        s5r->domain);
2809       hd = lookup_ssl_httpd (domain);
2810       if (NULL == hd)
2811       {
2812         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2813                     _("Failed to start HTTPS server for `%s'\n"),
2814                     s5r->domain);
2815         cleanup_s5r (s5r);
2816         GNUNET_free (domain);
2817         return;
2818       }
2819       break;
2820     case HTTP_PORT:
2821     default:
2822       domain = NULL;
2823       GNUNET_assert (NULL != httpd);
2824       hd = httpd;
2825       break;
2826   }
2827   fd = GNUNET_NETWORK_get_fd (s5r->sock);
2828   addr = GNUNET_NETWORK_get_addr (s5r->sock);
2829   len = GNUNET_NETWORK_get_addrlen (s5r->sock);
2830   s5r->state = SOCKS5_SOCKET_WITH_MHD;
2831   if (MHD_YES !=
2832       MHD_add_connection (hd->daemon,
2833                           fd,
2834                           addr,
2835                           len))
2836   {
2837     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2838                 _("Failed to pass client to MHD\n"));
2839     cleanup_s5r (s5r);
2840     GNUNET_free_non_null (domain);
2841     return;
2842   }
2843   s5r->hd = hd;
2844   schedule_httpd (hd);
2845   s5r->timeout_task = GNUNET_SCHEDULER_add_delayed (HTTP_HANDSHAKE_TIMEOUT,
2846                                                     &timeout_s5r_handshake,
2847                                                     s5r);
2848   GNUNET_free_non_null (domain);
2849 }
2850
2851
2852 /* ********************* SOCKS handling ************************* */
2853
2854
2855 /**
2856  * Write data from buffer to socks5 client, then continue with state machine.
2857  *
2858  * @param cls the closure with the `struct Socks5Request`
2859  */
2860 static void
2861 do_write (void *cls)
2862 {
2863   struct Socks5Request *s5r = cls;
2864   ssize_t len;
2865
2866   s5r->wtask = NULL;
2867   len = GNUNET_NETWORK_socket_send (s5r->sock,
2868                                     s5r->wbuf,
2869                                     s5r->wbuf_len);
2870   if (len <= 0)
2871   {
2872     /* write error: connection closed, shutdown, etc.; just clean up */
2873     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2874                 "Write Error\n");
2875     cleanup_s5r (s5r);
2876     return;
2877   }
2878   memmove (s5r->wbuf,
2879            &s5r->wbuf[len],
2880            s5r->wbuf_len - len);
2881   s5r->wbuf_len -= len;
2882   if (s5r->wbuf_len > 0)
2883   {
2884     /* not done writing */
2885     s5r->wtask =
2886       GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
2887                                       s5r->sock,
2888                                       &do_write, s5r);
2889     return;
2890   }
2891
2892   /* we're done writing, continue with state machine! */
2893
2894   switch (s5r->state)
2895   {
2896     case SOCKS5_INIT:
2897       GNUNET_assert (0);
2898       break;
2899     case SOCKS5_REQUEST:
2900       GNUNET_assert (NULL != s5r->rtask);
2901       break;
2902     case SOCKS5_DATA_TRANSFER:
2903       setup_data_transfer (s5r);
2904       return;
2905     case SOCKS5_WRITE_THEN_CLEANUP:
2906       cleanup_s5r (s5r);
2907       return;
2908     default:
2909       GNUNET_break (0);
2910       break;
2911   }
2912 }
2913
2914
2915 /**
2916  * Return a server response message indicating a failure to the client.
2917  *
2918  * @param s5r request to return failure code for
2919  * @param sc status code to return
2920  */
2921 static void
2922 signal_socks_failure (struct Socks5Request *s5r,
2923                       enum Socks5StatusCode sc)
2924 {
2925   struct Socks5ServerResponseMessage *s_resp;
2926
2927   s_resp = (struct Socks5ServerResponseMessage *) &s5r->wbuf[s5r->wbuf_len];
2928   memset (s_resp, 0, sizeof (struct Socks5ServerResponseMessage));
2929   s_resp->version = SOCKS_VERSION_5;
2930   s_resp->reply = sc;
2931   s5r->state = SOCKS5_WRITE_THEN_CLEANUP;
2932   if (NULL != s5r->wtask)
2933     s5r->wtask =
2934       GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
2935                                       s5r->sock,
2936                                       &do_write, s5r);
2937 }
2938
2939
2940 /**
2941  * Return a server response message indicating success.
2942  *
2943  * @param s5r request to return success status message for
2944  */
2945 static void
2946 signal_socks_success (struct Socks5Request *s5r)
2947 {
2948   struct Socks5ServerResponseMessage *s_resp;
2949
2950   s_resp = (struct Socks5ServerResponseMessage *) &s5r->wbuf[s5r->wbuf_len];
2951   s_resp->version = SOCKS_VERSION_5;
2952   s_resp->reply = SOCKS5_STATUS_REQUEST_GRANTED;
2953   s_resp->reserved = 0;
2954   s_resp->addr_type = SOCKS5_AT_IPV4;
2955   /* zero out IPv4 address and port */
2956   memset (&s_resp[1],
2957           0,
2958           sizeof (struct in_addr) + sizeof (uint16_t));
2959   s5r->wbuf_len += sizeof (struct Socks5ServerResponseMessage) +
2960     sizeof (struct in_addr) + sizeof (uint16_t);
2961   if (NULL == s5r->wtask)
2962     s5r->wtask =
2963       GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
2964                                       s5r->sock,
2965                                       &do_write, s5r);
2966 }
2967
2968
2969 /**
2970  * Process GNS results for target domain.
2971  *
2972  * @param cls the `struct Socks5Request *`
2973  * @param tld #GNUNET_YES if this was a GNS TLD.
2974  * @param rd_count number of records returned
2975  * @param rd record data
2976  */
2977 static void
2978 handle_gns_result (void *cls,
2979                    int tld,
2980                    uint32_t rd_count,
2981                    const struct GNUNET_GNSRECORD_Data *rd)
2982 {
2983   struct Socks5Request *s5r = cls;
2984   const struct GNUNET_GNSRECORD_Data *r;
2985   int got_ip;
2986
2987   s5r->gns_lookup = NULL;
2988   s5r->is_gns = tld;
2989   got_ip = GNUNET_NO;
2990   for (uint32_t i=0;i<rd_count;i++)
2991   {
2992     r = &rd[i];
2993     switch (r->record_type)
2994     {
2995       case GNUNET_DNSPARSER_TYPE_A:
2996         {
2997           struct sockaddr_in *in;
2998
2999           if (sizeof (struct in_addr) != r->data_size)
3000           {
3001             GNUNET_break_op (0);
3002             break;
3003           }
3004           if (GNUNET_YES == got_ip)
3005             break;
3006           if (GNUNET_OK !=
3007               GNUNET_NETWORK_test_pf (PF_INET))
3008             break;
3009           got_ip = GNUNET_YES;
3010           in = (struct sockaddr_in *) &s5r->destination_address;
3011           in->sin_family = AF_INET;
3012           GNUNET_memcpy (&in->sin_addr,
3013                          r->data,
3014                          r->data_size);
3015           in->sin_port = htons (s5r->port);
3016 #if HAVE_SOCKADDR_IN_SIN_LEN
3017           in->sin_len = sizeof (*in);
3018 #endif
3019         }
3020         break;
3021       case GNUNET_DNSPARSER_TYPE_AAAA:
3022         {
3023           struct sockaddr_in6 *in;
3024
3025           if (sizeof (struct in6_addr) != r->data_size)
3026           {
3027             GNUNET_break_op (0);
3028             break;
3029           }
3030           if (GNUNET_YES == got_ip)
3031             break;
3032           if (GNUNET_YES == disable_v6)
3033             break;
3034           if (GNUNET_OK !=
3035               GNUNET_NETWORK_test_pf (PF_INET6))
3036             break;
3037           /* FIXME: allow user to disable IPv6 per configuration option... */
3038           got_ip = GNUNET_YES;
3039           in = (struct sockaddr_in6 *) &s5r->destination_address;
3040           in->sin6_family = AF_INET6;
3041           GNUNET_memcpy (&in->sin6_addr,
3042                          r->data,
3043                          r->data_size);
3044           in->sin6_port = htons (s5r->port);
3045 #if HAVE_SOCKADDR_IN_SIN_LEN
3046           in->sin6_len = sizeof (*in);
3047 #endif
3048         }
3049         break;
3050       case GNUNET_GNSRECORD_TYPE_VPN:
3051         GNUNET_break (0); /* should have been translated within GNS */
3052         break;
3053       case GNUNET_GNSRECORD_TYPE_LEHO:
3054         GNUNET_free_non_null (s5r->leho);
3055         s5r->leho = GNUNET_strndup (r->data,
3056                                     r->data_size);
3057         break;
3058       case GNUNET_GNSRECORD_TYPE_BOX:
3059         {
3060           const struct GNUNET_GNSRECORD_BoxRecord *box;
3061
3062           if (r->data_size < sizeof (struct GNUNET_GNSRECORD_BoxRecord))
3063           {
3064             GNUNET_break_op (0);
3065             break;
3066           }
3067           box = r->data;
3068           if ( (ntohl (box->record_type) != GNUNET_DNSPARSER_TYPE_TLSA) ||
3069                (ntohs (box->protocol) != IPPROTO_TCP) ||
3070                (ntohs (box->service) != s5r->port) )
3071             break; /* BOX record does not apply */
3072           GNUNET_free_non_null (s5r->dane_data);
3073           s5r->dane_data_len = r->data_size - sizeof (struct GNUNET_GNSRECORD_BoxRecord);
3074           s5r->dane_data = GNUNET_malloc (s5r->dane_data_len);
3075           GNUNET_memcpy (s5r->dane_data,
3076                          &box[1],
3077                          s5r->dane_data_len);
3078           break;
3079         }
3080       default:
3081         /* don't care */
3082         break;
3083     }
3084   }
3085   if ( (GNUNET_YES != got_ip) &&
3086        (GNUNET_YES == tld) )
3087   {
3088     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3089                 "Name resolution failed to yield useful IP address.\n");
3090     signal_socks_failure (s5r,
3091                           SOCKS5_STATUS_GENERAL_FAILURE);
3092     return;
3093   }
3094   s5r->state = SOCKS5_DATA_TRANSFER;
3095   signal_socks_success (s5r);
3096 }
3097
3098
3099 /**
3100  * Remove the first @a len bytes from the beginning of the read buffer.
3101  *
3102  * @param s5r the handle clear the read buffer for
3103  * @param len number of bytes in read buffer to advance
3104  */
3105 static void
3106 clear_from_s5r_rbuf (struct Socks5Request *s5r,
3107                      size_t len)
3108 {
3109   GNUNET_assert (len <= s5r->rbuf_len);
3110   memmove (s5r->rbuf,
3111            &s5r->rbuf[len],
3112            s5r->rbuf_len - len);
3113   s5r->rbuf_len -= len;
3114 }
3115
3116
3117 /**
3118  * Read data from incoming Socks5 connection
3119  *
3120  * @param cls the closure with the `struct Socks5Request`
3121  */
3122 static void
3123 do_s5r_read (void *cls)
3124 {
3125   struct Socks5Request *s5r = cls;
3126   const struct Socks5ClientHelloMessage *c_hello;
3127   struct Socks5ServerHelloMessage *s_hello;
3128   const struct Socks5ClientRequestMessage *c_req;
3129   ssize_t rlen;
3130   size_t alen;
3131   const struct GNUNET_SCHEDULER_TaskContext *tc;
3132
3133   s5r->rtask = NULL;
3134   tc = GNUNET_SCHEDULER_get_task_context ();
3135   if ( (NULL != tc->read_ready) &&
3136        (GNUNET_NETWORK_fdset_isset (tc->read_ready,
3137                                     s5r->sock)) )
3138   {
3139     rlen = GNUNET_NETWORK_socket_recv (s5r->sock,
3140                                        &s5r->rbuf[s5r->rbuf_len],
3141                                        sizeof (s5r->rbuf) - s5r->rbuf_len);
3142     if (rlen <= 0)
3143     {
3144       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3145                   "socks5 client disconnected.\n");
3146       cleanup_s5r (s5r);
3147       return;
3148     }
3149     s5r->rbuf_len += rlen;
3150   }
3151   s5r->rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
3152                                               s5r->sock,
3153                                               &do_s5r_read, s5r);
3154   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3155               "Processing %zu bytes of socks data in state %d\n",
3156               s5r->rbuf_len,
3157               s5r->state);
3158   switch (s5r->state)
3159   {
3160     case SOCKS5_INIT:
3161       c_hello = (const struct Socks5ClientHelloMessage*) &s5r->rbuf;
3162       if ( (s5r->rbuf_len < sizeof (struct Socks5ClientHelloMessage)) ||
3163            (s5r->rbuf_len < sizeof (struct Socks5ClientHelloMessage) + c_hello->num_auth_methods) )
3164         return; /* need more data */
3165       if (SOCKS_VERSION_5 != c_hello->version)
3166       {
3167         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3168                     _("Unsupported socks version %d\n"),
3169                     (int) c_hello->version);
3170         cleanup_s5r (s5r);
3171         return;
3172       }
3173       clear_from_s5r_rbuf (s5r,
3174                            sizeof (struct Socks5ClientHelloMessage) + c_hello->num_auth_methods);
3175       GNUNET_assert (0 == s5r->wbuf_len);
3176       s_hello = (struct Socks5ServerHelloMessage *) &s5r->wbuf;
3177       s5r->wbuf_len = sizeof (struct Socks5ServerHelloMessage);
3178       s_hello->version = SOCKS_VERSION_5;
3179       s_hello->auth_method = SOCKS_AUTH_NONE;
3180       GNUNET_assert (NULL == s5r->wtask);
3181       s5r->wtask = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
3182                                                    s5r->sock,
3183                                                    &do_write, s5r);
3184       s5r->state = SOCKS5_REQUEST;
3185       return;
3186     case SOCKS5_REQUEST:
3187       c_req = (const struct Socks5ClientRequestMessage *) &s5r->rbuf;
3188       if (s5r->rbuf_len < sizeof (struct Socks5ClientRequestMessage))
3189         return;
3190       switch (c_req->command)
3191       {
3192         case SOCKS5_CMD_TCP_STREAM:
3193           /* handled below */
3194           break;
3195         default:
3196           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3197                       _("Unsupported socks command %d\n"),
3198                       (int) c_req->command);
3199           signal_socks_failure (s5r,
3200                                 SOCKS5_STATUS_COMMAND_NOT_SUPPORTED);
3201           return;
3202       }
3203       switch (c_req->addr_type)
3204       {
3205         case SOCKS5_AT_IPV4:
3206           {
3207             const struct in_addr *v4 = (const struct in_addr *) &c_req[1];
3208             const uint16_t *port = (const uint16_t *) &v4[1];
3209             struct sockaddr_in *in;
3210
3211             s5r->port = ntohs (*port);
3212             alen = sizeof (struct in_addr);
3213             if (s5r->rbuf_len < sizeof (struct Socks5ClientRequestMessage) +
3214                 alen + sizeof (uint16_t))
3215               return; /* need more data */
3216             in = (struct sockaddr_in *) &s5r->destination_address;
3217             in->sin_family = AF_INET;
3218             in->sin_addr = *v4;
3219             in->sin_port = *port;
3220 #if HAVE_SOCKADDR_IN_SIN_LEN
3221             in->sin_len = sizeof (*in);
3222 #endif
3223             s5r->state = SOCKS5_DATA_TRANSFER;
3224           }
3225           break;
3226         case SOCKS5_AT_IPV6:
3227           {
3228             const struct in6_addr *v6 = (const struct in6_addr *) &c_req[1];
3229             const uint16_t *port = (const uint16_t *) &v6[1];
3230             struct sockaddr_in6 *in;
3231
3232             s5r->port = ntohs (*port);
3233             alen = sizeof (struct in6_addr);
3234             if (s5r->rbuf_len < sizeof (struct Socks5ClientRequestMessage) +
3235                 alen + sizeof (uint16_t))
3236               return; /* need more data */
3237             in = (struct sockaddr_in6 *) &s5r->destination_address;
3238             in->sin6_family = AF_INET6;
3239             in->sin6_addr = *v6;
3240             in->sin6_port = *port;
3241 #if HAVE_SOCKADDR_IN_SIN_LEN
3242             in->sin6_len = sizeof (*in);
3243 #endif
3244             s5r->state = SOCKS5_DATA_TRANSFER;
3245           }
3246           break;
3247         case SOCKS5_AT_DOMAINNAME:
3248           {
3249             const uint8_t *dom_len;
3250             const char *dom_name;
3251             const uint16_t *port;
3252
3253             dom_len = (const uint8_t *) &c_req[1];
3254             alen = *dom_len + 1;
3255             if (s5r->rbuf_len < sizeof (struct Socks5ClientRequestMessage) +
3256                 alen + sizeof (uint16_t))
3257               return; /* need more data */
3258             dom_name = (const char *) &dom_len[1];
3259             port = (const uint16_t*) &dom_name[*dom_len];
3260             s5r->domain = GNUNET_strndup (dom_name,
3261                                           *dom_len);
3262             GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3263                         "Requested connection is to http%s://%s:%d\n",
3264                         (HTTPS_PORT == s5r->port) ? "s" : "",
3265                         s5r->domain,
3266                         ntohs (*port));
3267             s5r->state = SOCKS5_RESOLVING;
3268             s5r->port = ntohs (*port);
3269             s5r->gns_lookup = GNUNET_GNS_lookup_with_tld (gns_handle,
3270                                                           s5r->domain,
3271                                                           GNUNET_DNSPARSER_TYPE_A,
3272                                                           GNUNET_NO /* only cached */,
3273                                                           &handle_gns_result,
3274                                                           s5r);
3275             break;
3276           }
3277         default:
3278           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3279                       _("Unsupported socks address type %d\n"),
3280                       (int) c_req->addr_type);
3281           signal_socks_failure (s5r,
3282                                 SOCKS5_STATUS_ADDRESS_TYPE_NOT_SUPPORTED);
3283           return;
3284       }
3285       clear_from_s5r_rbuf (s5r,
3286                            sizeof (struct Socks5ClientRequestMessage) +
3287                            alen + sizeof (uint16_t));
3288       if (0 != s5r->rbuf_len)
3289       {
3290         /* read more bytes than healthy, why did the client send more!? */
3291         GNUNET_break_op (0);
3292         signal_socks_failure (s5r,
3293                               SOCKS5_STATUS_GENERAL_FAILURE);
3294         return;
3295       }
3296       if (SOCKS5_DATA_TRANSFER == s5r->state)
3297       {
3298         /* if we are not waiting for GNS resolution, signal success */
3299         signal_socks_success (s5r);
3300       }
3301       /* We are done reading right now */
3302       GNUNET_SCHEDULER_cancel (s5r->rtask);
3303       s5r->rtask = NULL;
3304       return;
3305     case SOCKS5_RESOLVING:
3306       GNUNET_assert (0);
3307       return;
3308     case SOCKS5_DATA_TRANSFER:
3309       GNUNET_assert (0);
3310       return;
3311     default:
3312       GNUNET_assert (0);
3313       return;
3314   }
3315 }
3316
3317
3318 /**
3319  * Accept new incoming connections
3320  *
3321  * @param cls the closure with the lsock4 or lsock6
3322  * @param tc the scheduler context
3323  */
3324 static void
3325 do_accept (void *cls)
3326 {
3327   struct GNUNET_NETWORK_Handle *lsock = cls;
3328   struct GNUNET_NETWORK_Handle *s;
3329   struct Socks5Request *s5r;
3330
3331   GNUNET_assert (NULL != lsock);
3332   if (lsock == lsock4)
3333     ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
3334                                             lsock,
3335                                             &do_accept,
3336                                             lsock);
3337   else if (lsock == lsock6)
3338     ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
3339                                             lsock,
3340                                             &do_accept,
3341                                             lsock);
3342   else
3343     GNUNET_assert (0);
3344   s = GNUNET_NETWORK_socket_accept (lsock,
3345                                     NULL,
3346                                     NULL);
3347   if (NULL == s)
3348   {
3349     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
3350                          "accept");
3351     return;
3352   }
3353   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3354               "Got an inbound connection, waiting for data\n");
3355   s5r = GNUNET_new (struct Socks5Request);
3356   GNUNET_CONTAINER_DLL_insert (s5r_head,
3357                                s5r_tail,
3358                                s5r);
3359   s5r->sock = s;
3360   s5r->state = SOCKS5_INIT;
3361   s5r->rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
3362                                               s5r->sock,
3363                                               &do_s5r_read,
3364                                               s5r);
3365 }
3366
3367
3368 /* ******************* General / main code ********************* */
3369
3370
3371 /**
3372  * Task run on shutdown
3373  *
3374  * @param cls closure
3375  */
3376 static void
3377 do_shutdown (void *cls)
3378 {
3379   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3380               "Shutting down...\n");
3381   /* MHD requires resuming before destroying the daemons */
3382   for (struct Socks5Request *s5r = s5r_head;
3383        NULL != s5r;
3384        s5r = s5r->next)
3385   {
3386     if (s5r->suspended)
3387     {
3388       s5r->suspended = GNUNET_NO;
3389       MHD_resume_connection (s5r->con);
3390     }
3391   }
3392   while (NULL != mhd_httpd_head)
3393     kill_httpd (mhd_httpd_head);
3394   while (NULL != s5r_head)
3395     cleanup_s5r (s5r_head);
3396   if (NULL != lsock4)
3397   {
3398     GNUNET_NETWORK_socket_close (lsock4);
3399     lsock4 = NULL;
3400   }
3401   if (NULL != lsock6)
3402   {
3403     GNUNET_NETWORK_socket_close (lsock6);
3404     lsock6 = NULL;
3405   }
3406   if (NULL != curl_multi)
3407   {
3408     curl_multi_cleanup (curl_multi);
3409     curl_multi = NULL;
3410   }
3411   if (NULL != gns_handle)
3412   {
3413     GNUNET_GNS_disconnect (gns_handle);
3414     gns_handle = NULL;
3415   }
3416   if (NULL != curl_download_task)
3417   {
3418     GNUNET_SCHEDULER_cancel (curl_download_task);
3419     curl_download_task = NULL;
3420   }
3421   if (NULL != ltask4)
3422   {
3423     GNUNET_SCHEDULER_cancel (ltask4);
3424     ltask4 = NULL;
3425   }
3426   if (NULL != ltask6)
3427   {
3428     GNUNET_SCHEDULER_cancel (ltask6);
3429     ltask6 = NULL;
3430   }
3431   gnutls_x509_crt_deinit (proxy_ca.cert);
3432   gnutls_x509_privkey_deinit (proxy_ca.key);
3433   gnutls_global_deinit ();
3434 }
3435
3436
3437 /**
3438  * Create an IPv4 listen socket bound to our port.
3439  *
3440  * @return NULL on error
3441  */
3442 static struct GNUNET_NETWORK_Handle *
3443 bind_v4 ()
3444 {
3445   struct GNUNET_NETWORK_Handle *ls;
3446   struct sockaddr_in sa4;
3447   int eno;
3448
3449   memset (&sa4, 0, sizeof (sa4));
3450   sa4.sin_family = AF_INET;
3451   sa4.sin_port = htons (port);
3452 #if HAVE_SOCKADDR_IN_SIN_LEN
3453   sa4.sin_len = sizeof (sa4);
3454 #endif
3455   ls = GNUNET_NETWORK_socket_create (AF_INET,
3456                                      SOCK_STREAM,
3457                                      0);
3458   if (NULL == ls)
3459     return NULL;
3460   if (GNUNET_OK !=
3461       GNUNET_NETWORK_socket_bind (ls,
3462                                   (const struct sockaddr *) &sa4,
3463                                   sizeof (sa4)))
3464   {
3465     eno = errno;
3466     GNUNET_NETWORK_socket_close (ls);
3467     errno = eno;
3468     return NULL;
3469   }
3470   return ls;
3471 }
3472
3473
3474 /**
3475  * Create an IPv6 listen socket bound to our port.
3476  *
3477  * @return NULL on error
3478  */
3479 static struct GNUNET_NETWORK_Handle *
3480 bind_v6 ()
3481 {
3482   struct GNUNET_NETWORK_Handle *ls;
3483   struct sockaddr_in6 sa6;
3484   int eno;
3485
3486   memset (&sa6, 0, sizeof (sa6));
3487   sa6.sin6_family = AF_INET6;
3488   sa6.sin6_port = htons (port);
3489 #if HAVE_SOCKADDR_IN_SIN_LEN
3490   sa6.sin6_len = sizeof (sa6);
3491 #endif
3492   ls = GNUNET_NETWORK_socket_create (AF_INET6,
3493                                      SOCK_STREAM,
3494                                      0);
3495   if (NULL == ls)
3496     return NULL;
3497   if (GNUNET_OK !=
3498       GNUNET_NETWORK_socket_bind (ls,
3499                                   (const struct sockaddr *) &sa6,
3500                                   sizeof (sa6)))
3501   {
3502     eno = errno;
3503     GNUNET_NETWORK_socket_close (ls);
3504     errno = eno;
3505     return NULL;
3506   }
3507   return ls;
3508 }
3509
3510
3511 /**
3512  * Main function that will be run
3513  *
3514  * @param cls closure
3515  * @param args remaining command-line arguments
3516  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
3517  * @param c configuration
3518  */
3519 static void
3520 run (void *cls,
3521      char *const *args,
3522      const char *cfgfile,
3523      const struct GNUNET_CONFIGURATION_Handle *c)
3524 {
3525   char* cafile_cfg = NULL;
3526   char* cafile;
3527   struct MhdHttpList *hd;
3528
3529   cfg = c;
3530
3531   if (NULL == (curl_multi = curl_multi_init ()))
3532   {
3533     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3534                 "Failed to create cURL multi handle!\n");
3535     return;
3536   }
3537   cafile = cafile_opt;
3538   if (NULL == cafile)
3539   {
3540     if (GNUNET_OK !=
3541         GNUNET_CONFIGURATION_get_value_filename (cfg,
3542                                                  "gns-proxy",
3543                                                  "PROXY_CACERT",
3544                                                  &cafile_cfg))
3545     {
3546       GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
3547                                  "gns-proxy",
3548                                  "PROXY_CACERT");
3549       return;
3550     }
3551     cafile = cafile_cfg;
3552   }
3553   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3554               "Using `%s' as CA\n",
3555               cafile);
3556
3557   gnutls_global_init ();
3558   gnutls_x509_crt_init (&proxy_ca.cert);
3559   gnutls_x509_privkey_init (&proxy_ca.key);
3560
3561   if ( (GNUNET_OK !=
3562         load_cert_from_file (proxy_ca.cert,
3563                              cafile)) ||
3564        (GNUNET_OK !=
3565         load_key_from_file (proxy_ca.key,
3566                             cafile)) )
3567   {
3568     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3569                 _("Failed to load X.509 key and certificate from `%s'\n"),
3570                 cafile);
3571     gnutls_x509_crt_deinit (proxy_ca.cert);
3572     gnutls_x509_privkey_deinit (proxy_ca.key);
3573     gnutls_global_deinit ();
3574     GNUNET_free_non_null (cafile_cfg);
3575     return;
3576   }
3577   GNUNET_free_non_null (cafile_cfg);
3578   if (NULL == (gns_handle = GNUNET_GNS_connect (cfg)))
3579   {
3580     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3581                 "Unable to connect to GNS!\n");
3582     gnutls_x509_crt_deinit (proxy_ca.cert);
3583     gnutls_x509_privkey_deinit (proxy_ca.key);
3584     gnutls_global_deinit ();
3585     return;
3586   }
3587   GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
3588                                  NULL);
3589
3590   /* Open listen socket for socks proxy */
3591   lsock6 = bind_v6 ();
3592   if (NULL == lsock6)
3593   {
3594     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
3595                          "bind");
3596   }
3597   else
3598   {
3599     if (GNUNET_OK !=
3600         GNUNET_NETWORK_socket_listen (lsock6,
3601                                       5))
3602     {
3603       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
3604                            "listen");
3605       GNUNET_NETWORK_socket_close (lsock6);
3606       lsock6 = NULL;
3607     }
3608     else
3609     {
3610       ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
3611                                               lsock6,
3612                                               &do_accept,
3613                                               lsock6);
3614     }
3615   }
3616   lsock4 = bind_v4 ();
3617   if (NULL == lsock4)
3618   {
3619     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
3620                          "bind");
3621   }
3622   else
3623   {
3624     if (GNUNET_OK !=
3625         GNUNET_NETWORK_socket_listen (lsock4,
3626                                       5))
3627     {
3628       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
3629                            "listen");
3630       GNUNET_NETWORK_socket_close (lsock4);
3631       lsock4 = NULL;
3632     }
3633     else
3634     {
3635       ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
3636                                               lsock4,
3637                                               &do_accept,
3638                                               lsock4);
3639     }
3640   }
3641   if ( (NULL == lsock4) &&
3642        (NULL == lsock6) )
3643   {
3644     GNUNET_SCHEDULER_shutdown ();
3645     return;
3646   }
3647   if (0 != curl_global_init (CURL_GLOBAL_WIN32))
3648   {
3649     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3650                 "cURL global init failed!\n");
3651     GNUNET_SCHEDULER_shutdown ();
3652     return;
3653   }
3654   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3655               "Proxy listens on port %u\n",
3656               (unsigned int) port);
3657
3658   /* start MHD daemon for HTTP */
3659   hd = GNUNET_new (struct MhdHttpList);
3660   hd->daemon = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_NO_LISTEN_SOCKET | MHD_ALLOW_SUSPEND_RESUME,
3661                                  0,
3662                                  NULL, NULL,
3663                                  &create_response, hd,
3664                                  MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
3665                                  MHD_OPTION_NOTIFY_COMPLETED, &mhd_completed_cb, NULL,
3666                                  MHD_OPTION_NOTIFY_CONNECTION, &mhd_connection_cb, NULL,
3667                                  MHD_OPTION_URI_LOG_CALLBACK, &mhd_log_callback, NULL,
3668                                  MHD_OPTION_END);
3669   if (NULL == hd->daemon)
3670   {
3671     GNUNET_free (hd);
3672     GNUNET_SCHEDULER_shutdown ();
3673     return;
3674   }
3675   httpd = hd;
3676   GNUNET_CONTAINER_DLL_insert (mhd_httpd_head,
3677                                mhd_httpd_tail,
3678                                hd);
3679 }
3680
3681
3682 /**
3683  * The main function for gnunet-gns-proxy.
3684  *
3685  * @param argc number of arguments from the command line
3686  * @param argv command line arguments
3687  * @return 0 ok, 1 on error
3688  */
3689 int
3690 main (int argc,
3691       char *const *argv)
3692 {
3693   struct GNUNET_GETOPT_CommandLineOption options[] = {
3694     GNUNET_GETOPT_option_uint16 ('p',
3695                                  "port",
3696                                  NULL,
3697                                  gettext_noop ("listen on specified port (default: 7777)"),
3698                                  &port),
3699     GNUNET_GETOPT_option_string ('a',
3700                                  "authority",
3701                                  NULL,
3702                                  gettext_noop ("pem file to use as CA"),
3703                                  &cafile_opt),
3704     GNUNET_GETOPT_option_flag ('6',
3705                                "disable-ivp6",
3706                                gettext_noop ("disable use of IPv6"),
3707                                &disable_v6),
3708
3709     GNUNET_GETOPT_OPTION_END
3710   };
3711   static const char* page =
3712     "<html><head><title>gnunet-gns-proxy</title>"
3713     "</head><body>cURL fail</body></html>";
3714   int ret;
3715
3716   if (GNUNET_OK !=
3717       GNUNET_STRINGS_get_utf8_args (argc, argv,
3718                                     &argc, &argv))
3719     return 2;
3720   GNUNET_log_setup ("gnunet-gns-proxy",
3721                     "WARNING",
3722                     NULL);
3723   curl_failure_response
3724     = MHD_create_response_from_buffer (strlen (page),
3725                                        (void *) page,
3726                                        MHD_RESPMEM_PERSISTENT);
3727
3728   ret =
3729     (GNUNET_OK ==
3730      GNUNET_PROGRAM_run (argc, argv,
3731                          "gnunet-gns-proxy",
3732                          _("GNUnet GNS proxy"),
3733                          options,
3734                          &run, NULL)) ? 0 : 1;
3735   MHD_destroy_response (curl_failure_response);
3736   GNUNET_free_non_null ((char *) argv);
3737   return ret;
3738 }
3739
3740 /* end of gnunet-gns-proxy.c */