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       curl_easy_setopt (s5r->curl,
2030                         CURLOPT_WRITEFUNCTION,
2031                         &curl_download_cb);
2032       curl_easy_setopt (s5r->curl,
2033                         CURLOPT_WRITEDATA,
2034                         s5r);
2035
2036     }
2037     else if (0 == strcasecmp (meth,
2038                               MHD_HTTP_METHOD_GET))
2039     {
2040       s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
2041       curl_easy_setopt (s5r->curl,
2042                         CURLOPT_HTTPGET,
2043                         1L);
2044       curl_easy_setopt (s5r->curl,
2045                         CURLOPT_WRITEFUNCTION,
2046                         &curl_download_cb);
2047       curl_easy_setopt (s5r->curl,
2048                         CURLOPT_WRITEDATA,
2049                         s5r);
2050     }
2051     else if (0 == strcasecmp (meth,
2052                               MHD_HTTP_METHOD_DELETE))
2053     {
2054       s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
2055       curl_easy_setopt (s5r->curl,
2056                         CURLOPT_CUSTOMREQUEST,
2057                         "DELETE");
2058       curl_easy_setopt (s5r->curl,
2059                         CURLOPT_WRITEFUNCTION,
2060                         &curl_download_cb);
2061       curl_easy_setopt (s5r->curl,
2062                         CURLOPT_WRITEDATA,
2063                         s5r);
2064     }
2065     else
2066     {
2067       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2068                   _("Unsupported HTTP method `%s'\n"),
2069                   meth);
2070       curl_easy_cleanup (s5r->curl);
2071       s5r->curl = NULL;
2072       return MHD_NO;
2073     }
2074
2075     if (0 == strcasecmp (ver, MHD_HTTP_VERSION_1_0))
2076     {
2077       curl_easy_setopt (s5r->curl,
2078                         CURLOPT_HTTP_VERSION,
2079                         CURL_HTTP_VERSION_1_0);
2080     }
2081     else if (0 == strcasecmp (ver, MHD_HTTP_VERSION_1_1))
2082     {
2083       curl_easy_setopt (s5r->curl,
2084                         CURLOPT_HTTP_VERSION,
2085                         CURL_HTTP_VERSION_1_1);
2086     }
2087     else
2088     {
2089       curl_easy_setopt (s5r->curl,
2090                         CURLOPT_HTTP_VERSION,
2091                         CURL_HTTP_VERSION_NONE);
2092     }
2093
2094     if (HTTPS_PORT == s5r->port)
2095     {
2096       curl_easy_setopt (s5r->curl,
2097                         CURLOPT_USE_SSL,
2098                         CURLUSESSL_ALL);
2099       if (NULL != s5r->dane_data)
2100         curl_easy_setopt (s5r->curl,
2101                           CURLOPT_SSL_VERIFYPEER,
2102                           0L);
2103       else
2104         curl_easy_setopt (s5r->curl,
2105                           CURLOPT_SSL_VERIFYPEER,
2106                           1L);
2107       /* Disable cURL checking the hostname, as we will check ourselves
2108          as only we have the domain name or the LEHO or the DANE record */
2109       curl_easy_setopt (s5r->curl,
2110                         CURLOPT_SSL_VERIFYHOST,
2111                         0L);
2112     }
2113     else
2114     {
2115       curl_easy_setopt (s5r->curl,
2116                         CURLOPT_USE_SSL,
2117                         CURLUSESSL_NONE);
2118     }
2119
2120     if (CURLM_OK !=
2121         curl_multi_add_handle (curl_multi,
2122                                s5r->curl))
2123     {
2124       GNUNET_break (0);
2125       curl_easy_cleanup (s5r->curl);
2126       s5r->curl = NULL;
2127       return MHD_NO;
2128     }
2129     MHD_get_connection_values (con,
2130                                MHD_HEADER_KIND,
2131                                &con_val_iter,
2132                                s5r);
2133     curl_easy_setopt (s5r->curl,
2134                       CURLOPT_HTTPHEADER,
2135                       s5r->headers);
2136     curl_download_prepare ();
2137     return MHD_YES;
2138   }
2139
2140   /* continuing to process request */
2141   if (0 != *upload_data_size)
2142   {
2143     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2144                 "Processing %u bytes UPLOAD\n",
2145                 (unsigned int) *upload_data_size);
2146
2147     /* FIXME: This must be set or a header with Transfer-Encoding: chunked. Else
2148      * upload callback is not called!
2149      */
2150     curl_easy_setopt (s5r->curl,
2151                       CURLOPT_POSTFIELDSIZE,
2152                       *upload_data_size);
2153
2154     left = GNUNET_MIN (*upload_data_size,
2155                        sizeof (s5r->io_buf) - s5r->io_len);
2156     GNUNET_memcpy (&s5r->io_buf[s5r->io_len],
2157                    upload_data,
2158                    left);
2159     s5r->io_len += left;
2160     *upload_data_size -= left;
2161     GNUNET_assert (NULL != s5r->curl);
2162     if (GNUNET_YES == s5r->curl_paused)
2163     {
2164       s5r->curl_paused = GNUNET_NO;
2165       curl_easy_pause (s5r->curl,
2166                        CURLPAUSE_CONT);
2167     }
2168     return MHD_YES;
2169   }
2170   if (SOCKS5_SOCKET_UPLOAD_STARTED == s5r->state)
2171   {
2172     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2173                 "Finished processing UPLOAD\n");
2174     s5r->state = SOCKS5_SOCKET_UPLOAD_DONE;
2175   }
2176   if (NULL == s5r->response)
2177   {
2178     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2179                 "Waiting for HTTP response for %s%s...\n",
2180                 s5r->domain,
2181                 s5r->url);
2182     MHD_suspend_connection (con);
2183     s5r->suspended = GNUNET_YES;
2184     return MHD_YES;
2185   }
2186   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2187               "Queueing response for %s%s with MHD\n",
2188               s5r->domain,
2189               s5r->url);
2190   run_mhd_now (s5r->hd);
2191   return MHD_queue_response (con,
2192                              s5r->response_code,
2193                              s5r->response);
2194 }
2195
2196
2197 /* ******************** MHD HTTP setup and event loop ******************** */
2198
2199
2200 /**
2201  * Function called when MHD decides that we are done with a request.
2202  *
2203  * @param cls NULL
2204  * @param connection connection handle
2205  * @param con_cls value as set by the last call to
2206  *        the MHD_AccessHandlerCallback, should be our `struct Socks5Request *`
2207  * @param toe reason for request termination (ignored)
2208  */
2209 static void
2210 mhd_completed_cb (void *cls,
2211                   struct MHD_Connection *connection,
2212                   void **con_cls,
2213                   enum MHD_RequestTerminationCode toe)
2214 {
2215   struct Socks5Request *s5r = *con_cls;
2216
2217   if (NULL == s5r)
2218     return;
2219   if (MHD_REQUEST_TERMINATED_COMPLETED_OK != toe)
2220     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
2221                 "MHD encountered error handling request: %d\n",
2222                 toe);
2223   if (NULL != s5r->curl)
2224   {
2225     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2226                 "Removing cURL handle (MHD interaction complete)\n");
2227     curl_multi_remove_handle (curl_multi,
2228                               s5r->curl);
2229     curl_slist_free_all (s5r->headers);
2230     s5r->headers = NULL;
2231     curl_easy_reset (s5r->curl);
2232     s5r->rbuf_len = 0;
2233     s5r->wbuf_len = 0;
2234     s5r->io_len = 0;
2235     curl_download_prepare ();
2236   }
2237   if ( (NULL != s5r->response) &&
2238        (curl_failure_response != s5r->response) )
2239     MHD_destroy_response (s5r->response);
2240   for (struct HttpResponseHeader *header = s5r->header_head;
2241        NULL != header;
2242        header = s5r->header_head)
2243   {
2244     GNUNET_CONTAINER_DLL_remove (s5r->header_head,
2245                                  s5r->header_tail,
2246                                  header);
2247     GNUNET_free (header->type);
2248     GNUNET_free (header->value);
2249     GNUNET_free (header);
2250   }
2251   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2252               "Finished request for %s\n",
2253               s5r->url);
2254   GNUNET_free (s5r->url);
2255   s5r->state = SOCKS5_SOCKET_WITH_MHD;
2256   s5r->url = NULL;
2257   s5r->response = NULL;
2258   *con_cls = NULL;
2259 }
2260
2261
2262 /**
2263  * Function called when MHD connection is opened or closed.
2264  *
2265  * @param cls NULL
2266  * @param connection connection handle
2267  * @param con_cls value as set by the last call to
2268  *        the MHD_AccessHandlerCallback, should be our `struct Socks5Request *`
2269  * @param toe connection notification type
2270  */
2271 static void
2272 mhd_connection_cb (void *cls,
2273                    struct MHD_Connection *connection,
2274                    void **con_cls,
2275                    enum MHD_ConnectionNotificationCode cnc)
2276 {
2277   struct Socks5Request *s5r;
2278   const union MHD_ConnectionInfo *ci;
2279   int sock;
2280
2281   switch (cnc)
2282   {
2283     case MHD_CONNECTION_NOTIFY_STARTED:
2284       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connection started...\n");
2285       ci = MHD_get_connection_info (connection,
2286                                     MHD_CONNECTION_INFO_CONNECTION_FD);
2287       if (NULL == ci)
2288       {
2289         GNUNET_break (0);
2290         return;
2291       }
2292       sock = ci->connect_fd;
2293       for (s5r = s5r_head; NULL != s5r; s5r = s5r->next)
2294       {
2295         if (GNUNET_NETWORK_get_fd (s5r->sock) == sock)
2296         {
2297           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2298                       "Context set...\n");
2299           s5r->ssl_checked = GNUNET_NO;
2300           *con_cls = s5r;
2301           break;
2302         }
2303       }
2304       break;
2305     case MHD_CONNECTION_NOTIFY_CLOSED:
2306       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2307                   "Connection closed... cleaning up\n");
2308       s5r = *con_cls;
2309       if (NULL == s5r)
2310       {
2311         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2312                     "Connection stale!\n");
2313         return;
2314       }
2315       cleanup_s5r (s5r);
2316       curl_download_prepare ();
2317       *con_cls = NULL;
2318       break;
2319     default:
2320       GNUNET_break (0);
2321   }
2322 }
2323
2324 /**
2325  * Function called when MHD first processes an incoming connection.
2326  * Gives us the respective URI information.
2327  *
2328  * We use this to associate the `struct MHD_Connection` with our
2329  * internal `struct Socks5Request` data structure (by checking
2330  * for matching sockets).
2331  *
2332  * @param cls the HTTP server handle (a `struct MhdHttpList`)
2333  * @param url the URL that is being requested
2334  * @param connection MHD connection object for the request
2335  * @return the `struct Socks5Request` that this @a connection is for
2336  */
2337 static void *
2338 mhd_log_callback (void *cls,
2339                   const char *url,
2340                   struct MHD_Connection *connection)
2341 {
2342   struct Socks5Request *s5r;
2343   const union MHD_ConnectionInfo *ci;
2344
2345   ci = MHD_get_connection_info (connection,
2346                                 MHD_CONNECTION_INFO_SOCKET_CONTEXT);
2347   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing %s\n", url);
2348   if (NULL == ci)
2349   {
2350     GNUNET_break (0);
2351     return NULL;
2352   }
2353   s5r = ci->socket_context;
2354   if (NULL != s5r->url)
2355   {
2356     GNUNET_break (0);
2357     return NULL;
2358   }
2359   s5r->url = GNUNET_strdup (url);
2360   if (NULL != s5r->timeout_task)
2361   {
2362     GNUNET_SCHEDULER_cancel (s5r->timeout_task);
2363     s5r->timeout_task = NULL;
2364   }
2365   GNUNET_assert (s5r->state == SOCKS5_SOCKET_WITH_MHD);
2366   return s5r;
2367 }
2368
2369
2370 /**
2371  * Kill the given MHD daemon.
2372  *
2373  * @param hd daemon to stop
2374  */
2375 static void
2376 kill_httpd (struct MhdHttpList *hd)
2377 {
2378   GNUNET_CONTAINER_DLL_remove (mhd_httpd_head,
2379                                mhd_httpd_tail,
2380                                hd);
2381   GNUNET_free_non_null (hd->domain);
2382   MHD_stop_daemon (hd->daemon);
2383   if (NULL != hd->httpd_task)
2384   {
2385     GNUNET_SCHEDULER_cancel (hd->httpd_task);
2386     hd->httpd_task = NULL;
2387   }
2388   GNUNET_free_non_null (hd->proxy_cert);
2389   if (hd == httpd)
2390     httpd = NULL;
2391   GNUNET_free (hd);
2392 }
2393
2394
2395 /**
2396  * Task run whenever HTTP server is idle for too long. Kill it.
2397  *
2398  * @param cls the `struct MhdHttpList *`
2399  */
2400 static void
2401 kill_httpd_task (void *cls)
2402 {
2403   struct MhdHttpList *hd = cls;
2404
2405   hd->httpd_task = NULL;
2406   kill_httpd (hd);
2407 }
2408
2409
2410 /**
2411  * Task run whenever HTTP server operations are pending.
2412  *
2413  * @param cls the `struct MhdHttpList *` of the daemon that is being run
2414  */
2415 static void
2416 do_httpd (void *cls);
2417
2418
2419 /**
2420  * Schedule MHD.  This function should be called initially when an
2421  * MHD is first getting its client socket, and will then automatically
2422  * always be called later whenever there is work to be done.
2423  *
2424  * @param hd the daemon to schedule
2425  */
2426 static void
2427 schedule_httpd (struct MhdHttpList *hd)
2428 {
2429   fd_set rs;
2430   fd_set ws;
2431   fd_set es;
2432   struct GNUNET_NETWORK_FDSet *wrs;
2433   struct GNUNET_NETWORK_FDSet *wws;
2434   int max;
2435   int haveto;
2436   MHD_UNSIGNED_LONG_LONG timeout;
2437   struct GNUNET_TIME_Relative tv;
2438
2439   FD_ZERO (&rs);
2440   FD_ZERO (&ws);
2441   FD_ZERO (&es);
2442   max = -1;
2443   if (MHD_YES !=
2444       MHD_get_fdset (hd->daemon,
2445                      &rs,
2446                      &ws,
2447                      &es,
2448                      &max))
2449   {
2450     kill_httpd (hd);
2451     return;
2452   }
2453   haveto = MHD_get_timeout (hd->daemon,
2454                             &timeout);
2455   if (MHD_YES == haveto)
2456     tv.rel_value_us = (uint64_t) timeout * 1000LL;
2457   else
2458     tv = GNUNET_TIME_UNIT_FOREVER_REL;
2459   if (-1 != max)
2460   {
2461     wrs = GNUNET_NETWORK_fdset_create ();
2462     wws = GNUNET_NETWORK_fdset_create ();
2463     GNUNET_NETWORK_fdset_copy_native (wrs, &rs, max + 1);
2464     GNUNET_NETWORK_fdset_copy_native (wws, &ws, max + 1);
2465   }
2466   else
2467   {
2468     wrs = NULL;
2469     wws = NULL;
2470   }
2471   if (NULL != hd->httpd_task)
2472   {
2473     GNUNET_SCHEDULER_cancel (hd->httpd_task);
2474     hd->httpd_task = NULL;
2475   }
2476   if ( (MHD_YES != haveto) &&
2477        (-1 == max) &&
2478        (hd != httpd) )
2479   {
2480     /* daemon is idle, kill after timeout */
2481     hd->httpd_task = GNUNET_SCHEDULER_add_delayed (MHD_CACHE_TIMEOUT,
2482                                                    &kill_httpd_task,
2483                                                    hd);
2484   }
2485   else
2486   {
2487     hd->httpd_task =
2488       GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
2489                                    tv, wrs, wws,
2490                                    &do_httpd, hd);
2491   }
2492   if (NULL != wrs)
2493     GNUNET_NETWORK_fdset_destroy (wrs);
2494   if (NULL != wws)
2495     GNUNET_NETWORK_fdset_destroy (wws);
2496 }
2497
2498
2499 /**
2500  * Task run whenever HTTP server operations are pending.
2501  *
2502  * @param cls the `struct MhdHttpList` of the daemon that is being run
2503  */
2504 static void
2505 do_httpd (void *cls)
2506 {
2507   struct MhdHttpList *hd = cls;
2508
2509   hd->httpd_task = NULL;
2510   MHD_run (hd->daemon);
2511   schedule_httpd (hd);
2512 }
2513
2514
2515 /**
2516  * Run MHD now, we have extra data ready for the callback.
2517  *
2518  * @param hd the daemon to run now.
2519  */
2520 static void
2521 run_mhd_now (struct MhdHttpList *hd)
2522 {
2523   if (NULL != hd->httpd_task)
2524     GNUNET_SCHEDULER_cancel (hd->httpd_task);
2525   hd->httpd_task = GNUNET_SCHEDULER_add_now (&do_httpd,
2526                                              hd);
2527 }
2528
2529
2530 /**
2531  * Read file in filename
2532  *
2533  * @param filename file to read
2534  * @param size pointer where filesize is stored
2535  * @return NULL on error
2536  */
2537 static void*
2538 load_file (const char* filename,
2539            unsigned int* size)
2540 {
2541   void *buffer;
2542   uint64_t fsize;
2543
2544   if (GNUNET_OK !=
2545       GNUNET_DISK_file_size (filename,
2546                              &fsize,
2547                              GNUNET_YES,
2548                              GNUNET_YES))
2549     return NULL;
2550   if (fsize > MAX_PEM_SIZE)
2551     return NULL;
2552   *size = (unsigned int) fsize;
2553   buffer = GNUNET_malloc (*size);
2554   if (fsize !=
2555       GNUNET_DISK_fn_read (filename,
2556                            buffer,
2557                            (size_t) fsize))
2558   {
2559     GNUNET_free (buffer);
2560     return NULL;
2561   }
2562   return buffer;
2563 }
2564
2565
2566 /**
2567  * Load PEM key from file
2568  *
2569  * @param key where to store the data
2570  * @param keyfile path to the PEM file
2571  * @return #GNUNET_OK on success
2572  */
2573 static int
2574 load_key_from_file (gnutls_x509_privkey_t key,
2575                     const char* keyfile)
2576 {
2577   gnutls_datum_t key_data;
2578   int ret;
2579
2580   key_data.data = load_file (keyfile,
2581                              &key_data.size);
2582   if (NULL == key_data.data)
2583     return GNUNET_SYSERR;
2584   ret = gnutls_x509_privkey_import (key, &key_data,
2585                                     GNUTLS_X509_FMT_PEM);
2586   if (GNUTLS_E_SUCCESS != ret)
2587   {
2588     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2589                 _("Unable to import private key from file `%s'\n"),
2590                 keyfile);
2591   }
2592   GNUNET_free_non_null (key_data.data);
2593   return (GNUTLS_E_SUCCESS != ret) ? GNUNET_SYSERR : GNUNET_OK;
2594 }
2595
2596
2597 /**
2598  * Load cert from file
2599  *
2600  * @param crt struct to store data in
2601  * @param certfile path to pem file
2602  * @return #GNUNET_OK on success
2603  */
2604 static int
2605 load_cert_from_file (gnutls_x509_crt_t crt,
2606                      const char* certfile)
2607 {
2608   gnutls_datum_t cert_data;
2609   int ret;
2610
2611   cert_data.data = load_file (certfile,
2612                               &cert_data.size);
2613   if (NULL == cert_data.data)
2614     return GNUNET_SYSERR;
2615   ret = gnutls_x509_crt_import (crt,
2616                                 &cert_data,
2617                                 GNUTLS_X509_FMT_PEM);
2618   if (GNUTLS_E_SUCCESS != ret)
2619   {
2620     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2621                 _("Unable to import certificate from `%s'\n"),
2622                 certfile);
2623   }
2624   GNUNET_free_non_null (cert_data.data);
2625   return (GNUTLS_E_SUCCESS != ret) ? GNUNET_SYSERR : GNUNET_OK;
2626 }
2627
2628
2629 /**
2630  * Generate new certificate for specific name
2631  *
2632  * @param name the subject name to generate a cert for
2633  * @return a struct holding the PEM data, NULL on error
2634  */
2635 static struct ProxyGNSCertificate *
2636 generate_gns_certificate (const char *name)
2637 {
2638   unsigned int serial;
2639   size_t key_buf_size;
2640   size_t cert_buf_size;
2641   gnutls_x509_crt_t request;
2642   time_t etime;
2643   struct tm *tm_data;
2644   struct ProxyGNSCertificate *pgc;
2645
2646   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2647               "Generating x.509 certificate for `%s'\n",
2648               name);
2649   GNUNET_break (GNUTLS_E_SUCCESS == gnutls_x509_crt_init (&request));
2650   GNUNET_break (GNUTLS_E_SUCCESS == gnutls_x509_crt_set_key (request, proxy_ca.key));
2651   pgc = GNUNET_new (struct ProxyGNSCertificate);
2652   gnutls_x509_crt_set_dn_by_oid (request,
2653                                  GNUTLS_OID_X520_COUNTRY_NAME,
2654                                  0,
2655                                  "ZZ",
2656                                  strlen ("ZZ"));
2657   gnutls_x509_crt_set_dn_by_oid (request,
2658                                  GNUTLS_OID_X520_ORGANIZATION_NAME,
2659                                  0,
2660                                  "GNU Name System",
2661                                  strlen ("GNU Name System"));
2662   gnutls_x509_crt_set_dn_by_oid (request,
2663                                  GNUTLS_OID_X520_COMMON_NAME,
2664                                  0,
2665                                  name,
2666                                  strlen (name));
2667   GNUNET_break (GNUTLS_E_SUCCESS ==
2668                 gnutls_x509_crt_set_version (request,
2669                                              3));
2670   gnutls_rnd (GNUTLS_RND_NONCE,
2671               &serial,
2672               sizeof (serial));
2673   gnutls_x509_crt_set_serial (request,
2674                               &serial,
2675                               sizeof (serial));
2676   etime = time (NULL);
2677   tm_data = localtime (&etime);
2678   tm_data->tm_hour--;
2679   etime = mktime(tm_data);
2680   gnutls_x509_crt_set_activation_time (request,
2681                                        etime);
2682   tm_data->tm_year++;
2683   etime = mktime (tm_data);
2684   gnutls_x509_crt_set_expiration_time (request,
2685                                        etime);
2686   gnutls_x509_crt_sign2 (request,
2687                          proxy_ca.cert,
2688                          proxy_ca.key,
2689                          GNUTLS_DIG_SHA512,
2690                          0);
2691   key_buf_size = sizeof (pgc->key);
2692   cert_buf_size = sizeof (pgc->cert);
2693   gnutls_x509_crt_export (request,
2694                           GNUTLS_X509_FMT_PEM,
2695                           pgc->cert,
2696                           &cert_buf_size);
2697   gnutls_x509_privkey_export (proxy_ca.key,
2698                               GNUTLS_X509_FMT_PEM,
2699                               pgc->key,
2700                               &key_buf_size);
2701   gnutls_x509_crt_deinit (request);
2702   return pgc;
2703 }
2704
2705
2706 /**
2707  * Function called by MHD with errors, suppresses them all.
2708  *
2709  * @param cls closure
2710  * @param fm format string (`printf()`-style)
2711  * @param ap arguments to @a fm
2712  */
2713 static void
2714 mhd_error_log_callback (void *cls,
2715                         const char *fm,
2716                         va_list ap)
2717 {
2718   /* do nothing */
2719 }
2720
2721
2722 /**
2723  * Lookup (or create) an TLS MHD instance for a particular domain.
2724  *
2725  * @param domain the domain the TLS daemon has to serve
2726  * @return NULL on error
2727  */
2728 static struct MhdHttpList *
2729 lookup_ssl_httpd (const char* domain)
2730 {
2731   struct MhdHttpList *hd;
2732   struct ProxyGNSCertificate *pgc;
2733
2734   if (NULL == domain)
2735   {
2736     GNUNET_break (0);
2737     return NULL;
2738   }
2739   for (hd = mhd_httpd_head; NULL != hd; hd = hd->next)
2740     if ( (NULL != hd->domain) &&
2741          (0 == strcmp (hd->domain, domain)) )
2742       return hd;
2743   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2744               "Starting fresh MHD HTTPS instance for domain `%s'\n",
2745               domain);
2746   pgc = generate_gns_certificate (domain);
2747   hd = GNUNET_new (struct MhdHttpList);
2748   hd->is_ssl = GNUNET_YES;
2749   hd->domain = GNUNET_strdup (domain);
2750   hd->proxy_cert = pgc;
2751   hd->daemon = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_SSL | MHD_USE_NO_LISTEN_SOCKET | MHD_ALLOW_SUSPEND_RESUME,
2752                                  0,
2753                                  NULL, NULL,
2754                                  &create_response, hd,
2755                                  MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
2756                                  MHD_OPTION_NOTIFY_COMPLETED, &mhd_completed_cb, NULL,
2757                                  MHD_OPTION_NOTIFY_CONNECTION, &mhd_connection_cb, NULL,
2758                                  MHD_OPTION_URI_LOG_CALLBACK, &mhd_log_callback, NULL,
2759                                  MHD_OPTION_EXTERNAL_LOGGER, &mhd_error_log_callback, NULL,
2760                                  MHD_OPTION_HTTPS_MEM_KEY, pgc->key,
2761                                  MHD_OPTION_HTTPS_MEM_CERT, pgc->cert,
2762                                  MHD_OPTION_END);
2763   if (NULL == hd->daemon)
2764   {
2765     GNUNET_free (pgc);
2766     GNUNET_free (hd);
2767     return NULL;
2768   }
2769   GNUNET_CONTAINER_DLL_insert (mhd_httpd_head,
2770                                mhd_httpd_tail,
2771                                hd);
2772   return hd;
2773 }
2774
2775
2776 /**
2777  * Task run when a Socks5Request somehow fails to be associated with
2778  * an MHD connection (i.e. because the client never speaks HTTP after
2779  * the SOCKS5 handshake).  Clean up.
2780  *
2781  * @param cls the `struct Socks5Request *`
2782  */
2783 static void
2784 timeout_s5r_handshake (void *cls)
2785 {
2786   struct Socks5Request *s5r = cls;
2787
2788   s5r->timeout_task = NULL;
2789   cleanup_s5r (s5r);
2790 }
2791
2792
2793 /**
2794  * We're done with the Socks5 protocol, now we need to pass the
2795  * connection data through to the final destination, either
2796  * direct (if the protocol might not be HTTP), or via MHD
2797  * (if the port looks like it should be HTTP).
2798  *
2799  * @param s5r socks request that has reached the final stage
2800  */
2801 static void
2802 setup_data_transfer (struct Socks5Request *s5r)
2803 {
2804   struct MhdHttpList *hd;
2805   int fd;
2806   const struct sockaddr *addr;
2807   socklen_t len;
2808   char *domain;
2809
2810   switch (s5r->port)
2811   {
2812     case HTTPS_PORT:
2813       GNUNET_asprintf (&domain,
2814                        "%s",
2815                        s5r->domain);
2816       hd = lookup_ssl_httpd (domain);
2817       if (NULL == hd)
2818       {
2819         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2820                     _("Failed to start HTTPS server for `%s'\n"),
2821                     s5r->domain);
2822         cleanup_s5r (s5r);
2823         GNUNET_free (domain);
2824         return;
2825       }
2826       break;
2827     case HTTP_PORT:
2828     default:
2829       domain = NULL;
2830       GNUNET_assert (NULL != httpd);
2831       hd = httpd;
2832       break;
2833   }
2834   fd = GNUNET_NETWORK_get_fd (s5r->sock);
2835   addr = GNUNET_NETWORK_get_addr (s5r->sock);
2836   len = GNUNET_NETWORK_get_addrlen (s5r->sock);
2837   s5r->state = SOCKS5_SOCKET_WITH_MHD;
2838   if (MHD_YES !=
2839       MHD_add_connection (hd->daemon,
2840                           fd,
2841                           addr,
2842                           len))
2843   {
2844     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
2845                 _("Failed to pass client to MHD\n"));
2846     cleanup_s5r (s5r);
2847     GNUNET_free_non_null (domain);
2848     return;
2849   }
2850   s5r->hd = hd;
2851   schedule_httpd (hd);
2852   s5r->timeout_task = GNUNET_SCHEDULER_add_delayed (HTTP_HANDSHAKE_TIMEOUT,
2853                                                     &timeout_s5r_handshake,
2854                                                     s5r);
2855   GNUNET_free_non_null (domain);
2856 }
2857
2858
2859 /* ********************* SOCKS handling ************************* */
2860
2861
2862 /**
2863  * Write data from buffer to socks5 client, then continue with state machine.
2864  *
2865  * @param cls the closure with the `struct Socks5Request`
2866  */
2867 static void
2868 do_write (void *cls)
2869 {
2870   struct Socks5Request *s5r = cls;
2871   ssize_t len;
2872
2873   s5r->wtask = NULL;
2874   len = GNUNET_NETWORK_socket_send (s5r->sock,
2875                                     s5r->wbuf,
2876                                     s5r->wbuf_len);
2877   if (len <= 0)
2878   {
2879     /* write error: connection closed, shutdown, etc.; just clean up */
2880     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
2881                 "Write Error\n");
2882     cleanup_s5r (s5r);
2883     return;
2884   }
2885   memmove (s5r->wbuf,
2886            &s5r->wbuf[len],
2887            s5r->wbuf_len - len);
2888   s5r->wbuf_len -= len;
2889   if (s5r->wbuf_len > 0)
2890   {
2891     /* not done writing */
2892     s5r->wtask =
2893       GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
2894                                       s5r->sock,
2895                                       &do_write, s5r);
2896     return;
2897   }
2898
2899   /* we're done writing, continue with state machine! */
2900
2901   switch (s5r->state)
2902   {
2903     case SOCKS5_INIT:
2904       GNUNET_assert (0);
2905       break;
2906     case SOCKS5_REQUEST:
2907       GNUNET_assert (NULL != s5r->rtask);
2908       break;
2909     case SOCKS5_DATA_TRANSFER:
2910       setup_data_transfer (s5r);
2911       return;
2912     case SOCKS5_WRITE_THEN_CLEANUP:
2913       cleanup_s5r (s5r);
2914       return;
2915     default:
2916       GNUNET_break (0);
2917       break;
2918   }
2919 }
2920
2921
2922 /**
2923  * Return a server response message indicating a failure to the client.
2924  *
2925  * @param s5r request to return failure code for
2926  * @param sc status code to return
2927  */
2928 static void
2929 signal_socks_failure (struct Socks5Request *s5r,
2930                       enum Socks5StatusCode sc)
2931 {
2932   struct Socks5ServerResponseMessage *s_resp;
2933
2934   s_resp = (struct Socks5ServerResponseMessage *) &s5r->wbuf[s5r->wbuf_len];
2935   memset (s_resp, 0, sizeof (struct Socks5ServerResponseMessage));
2936   s_resp->version = SOCKS_VERSION_5;
2937   s_resp->reply = sc;
2938   s5r->state = SOCKS5_WRITE_THEN_CLEANUP;
2939   if (NULL != s5r->wtask)
2940     s5r->wtask =
2941       GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
2942                                       s5r->sock,
2943                                       &do_write, s5r);
2944 }
2945
2946
2947 /**
2948  * Return a server response message indicating success.
2949  *
2950  * @param s5r request to return success status message for
2951  */
2952 static void
2953 signal_socks_success (struct Socks5Request *s5r)
2954 {
2955   struct Socks5ServerResponseMessage *s_resp;
2956
2957   s_resp = (struct Socks5ServerResponseMessage *) &s5r->wbuf[s5r->wbuf_len];
2958   s_resp->version = SOCKS_VERSION_5;
2959   s_resp->reply = SOCKS5_STATUS_REQUEST_GRANTED;
2960   s_resp->reserved = 0;
2961   s_resp->addr_type = SOCKS5_AT_IPV4;
2962   /* zero out IPv4 address and port */
2963   memset (&s_resp[1],
2964           0,
2965           sizeof (struct in_addr) + sizeof (uint16_t));
2966   s5r->wbuf_len += sizeof (struct Socks5ServerResponseMessage) +
2967     sizeof (struct in_addr) + sizeof (uint16_t);
2968   if (NULL == s5r->wtask)
2969     s5r->wtask =
2970       GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
2971                                       s5r->sock,
2972                                       &do_write, s5r);
2973 }
2974
2975
2976 /**
2977  * Process GNS results for target domain.
2978  *
2979  * @param cls the `struct Socks5Request *`
2980  * @param tld #GNUNET_YES if this was a GNS TLD.
2981  * @param rd_count number of records returned
2982  * @param rd record data
2983  */
2984 static void
2985 handle_gns_result (void *cls,
2986                    int tld,
2987                    uint32_t rd_count,
2988                    const struct GNUNET_GNSRECORD_Data *rd)
2989 {
2990   struct Socks5Request *s5r = cls;
2991   const struct GNUNET_GNSRECORD_Data *r;
2992   int got_ip;
2993
2994   s5r->gns_lookup = NULL;
2995   s5r->is_gns = tld;
2996   got_ip = GNUNET_NO;
2997   for (uint32_t i=0;i<rd_count;i++)
2998   {
2999     r = &rd[i];
3000     switch (r->record_type)
3001     {
3002       case GNUNET_DNSPARSER_TYPE_A:
3003         {
3004           struct sockaddr_in *in;
3005
3006           if (sizeof (struct in_addr) != r->data_size)
3007           {
3008             GNUNET_break_op (0);
3009             break;
3010           }
3011           if (GNUNET_YES == got_ip)
3012             break;
3013           if (GNUNET_OK !=
3014               GNUNET_NETWORK_test_pf (PF_INET))
3015             break;
3016           got_ip = GNUNET_YES;
3017           in = (struct sockaddr_in *) &s5r->destination_address;
3018           in->sin_family = AF_INET;
3019           GNUNET_memcpy (&in->sin_addr,
3020                          r->data,
3021                          r->data_size);
3022           in->sin_port = htons (s5r->port);
3023 #if HAVE_SOCKADDR_IN_SIN_LEN
3024           in->sin_len = sizeof (*in);
3025 #endif
3026         }
3027         break;
3028       case GNUNET_DNSPARSER_TYPE_AAAA:
3029         {
3030           struct sockaddr_in6 *in;
3031
3032           if (sizeof (struct in6_addr) != r->data_size)
3033           {
3034             GNUNET_break_op (0);
3035             break;
3036           }
3037           if (GNUNET_YES == got_ip)
3038             break;
3039           if (GNUNET_YES == disable_v6)
3040             break;
3041           if (GNUNET_OK !=
3042               GNUNET_NETWORK_test_pf (PF_INET6))
3043             break;
3044           /* FIXME: allow user to disable IPv6 per configuration option... */
3045           got_ip = GNUNET_YES;
3046           in = (struct sockaddr_in6 *) &s5r->destination_address;
3047           in->sin6_family = AF_INET6;
3048           GNUNET_memcpy (&in->sin6_addr,
3049                          r->data,
3050                          r->data_size);
3051           in->sin6_port = htons (s5r->port);
3052 #if HAVE_SOCKADDR_IN_SIN_LEN
3053           in->sin6_len = sizeof (*in);
3054 #endif
3055         }
3056         break;
3057       case GNUNET_GNSRECORD_TYPE_VPN:
3058         GNUNET_break (0); /* should have been translated within GNS */
3059         break;
3060       case GNUNET_GNSRECORD_TYPE_LEHO:
3061         GNUNET_free_non_null (s5r->leho);
3062         s5r->leho = GNUNET_strndup (r->data,
3063                                     r->data_size);
3064         break;
3065       case GNUNET_GNSRECORD_TYPE_BOX:
3066         {
3067           const struct GNUNET_GNSRECORD_BoxRecord *box;
3068
3069           if (r->data_size < sizeof (struct GNUNET_GNSRECORD_BoxRecord))
3070           {
3071             GNUNET_break_op (0);
3072             break;
3073           }
3074           box = r->data;
3075           if ( (ntohl (box->record_type) != GNUNET_DNSPARSER_TYPE_TLSA) ||
3076                (ntohs (box->protocol) != IPPROTO_TCP) ||
3077                (ntohs (box->service) != s5r->port) )
3078             break; /* BOX record does not apply */
3079           GNUNET_free_non_null (s5r->dane_data);
3080           s5r->dane_data_len = r->data_size - sizeof (struct GNUNET_GNSRECORD_BoxRecord);
3081           s5r->dane_data = GNUNET_malloc (s5r->dane_data_len);
3082           GNUNET_memcpy (s5r->dane_data,
3083                          &box[1],
3084                          s5r->dane_data_len);
3085           break;
3086         }
3087       default:
3088         /* don't care */
3089         break;
3090     }
3091   }
3092   if ( (GNUNET_YES != got_ip) &&
3093        (GNUNET_YES == tld) )
3094   {
3095     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3096                 "Name resolution failed to yield useful IP address.\n");
3097     signal_socks_failure (s5r,
3098                           SOCKS5_STATUS_GENERAL_FAILURE);
3099     return;
3100   }
3101   s5r->state = SOCKS5_DATA_TRANSFER;
3102   signal_socks_success (s5r);
3103 }
3104
3105
3106 /**
3107  * Remove the first @a len bytes from the beginning of the read buffer.
3108  *
3109  * @param s5r the handle clear the read buffer for
3110  * @param len number of bytes in read buffer to advance
3111  */
3112 static void
3113 clear_from_s5r_rbuf (struct Socks5Request *s5r,
3114                      size_t len)
3115 {
3116   GNUNET_assert (len <= s5r->rbuf_len);
3117   memmove (s5r->rbuf,
3118            &s5r->rbuf[len],
3119            s5r->rbuf_len - len);
3120   s5r->rbuf_len -= len;
3121 }
3122
3123
3124 /**
3125  * Read data from incoming Socks5 connection
3126  *
3127  * @param cls the closure with the `struct Socks5Request`
3128  */
3129 static void
3130 do_s5r_read (void *cls)
3131 {
3132   struct Socks5Request *s5r = cls;
3133   const struct Socks5ClientHelloMessage *c_hello;
3134   struct Socks5ServerHelloMessage *s_hello;
3135   const struct Socks5ClientRequestMessage *c_req;
3136   ssize_t rlen;
3137   size_t alen;
3138   const struct GNUNET_SCHEDULER_TaskContext *tc;
3139
3140   s5r->rtask = NULL;
3141   tc = GNUNET_SCHEDULER_get_task_context ();
3142   if ( (NULL != tc->read_ready) &&
3143        (GNUNET_NETWORK_fdset_isset (tc->read_ready,
3144                                     s5r->sock)) )
3145   {
3146     rlen = GNUNET_NETWORK_socket_recv (s5r->sock,
3147                                        &s5r->rbuf[s5r->rbuf_len],
3148                                        sizeof (s5r->rbuf) - s5r->rbuf_len);
3149     if (rlen <= 0)
3150     {
3151       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3152                   "socks5 client disconnected.\n");
3153       cleanup_s5r (s5r);
3154       return;
3155     }
3156     s5r->rbuf_len += rlen;
3157   }
3158   s5r->rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
3159                                               s5r->sock,
3160                                               &do_s5r_read, s5r);
3161   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3162               "Processing %zu bytes of socks data in state %d\n",
3163               s5r->rbuf_len,
3164               s5r->state);
3165   switch (s5r->state)
3166   {
3167     case SOCKS5_INIT:
3168       c_hello = (const struct Socks5ClientHelloMessage*) &s5r->rbuf;
3169       if ( (s5r->rbuf_len < sizeof (struct Socks5ClientHelloMessage)) ||
3170            (s5r->rbuf_len < sizeof (struct Socks5ClientHelloMessage) + c_hello->num_auth_methods) )
3171         return; /* need more data */
3172       if (SOCKS_VERSION_5 != c_hello->version)
3173       {
3174         GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3175                     _("Unsupported socks version %d\n"),
3176                     (int) c_hello->version);
3177         cleanup_s5r (s5r);
3178         return;
3179       }
3180       clear_from_s5r_rbuf (s5r,
3181                            sizeof (struct Socks5ClientHelloMessage) + c_hello->num_auth_methods);
3182       GNUNET_assert (0 == s5r->wbuf_len);
3183       s_hello = (struct Socks5ServerHelloMessage *) &s5r->wbuf;
3184       s5r->wbuf_len = sizeof (struct Socks5ServerHelloMessage);
3185       s_hello->version = SOCKS_VERSION_5;
3186       s_hello->auth_method = SOCKS_AUTH_NONE;
3187       GNUNET_assert (NULL == s5r->wtask);
3188       s5r->wtask = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_FOREVER_REL,
3189                                                    s5r->sock,
3190                                                    &do_write, s5r);
3191       s5r->state = SOCKS5_REQUEST;
3192       return;
3193     case SOCKS5_REQUEST:
3194       c_req = (const struct Socks5ClientRequestMessage *) &s5r->rbuf;
3195       if (s5r->rbuf_len < sizeof (struct Socks5ClientRequestMessage))
3196         return;
3197       switch (c_req->command)
3198       {
3199         case SOCKS5_CMD_TCP_STREAM:
3200           /* handled below */
3201           break;
3202         default:
3203           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3204                       _("Unsupported socks command %d\n"),
3205                       (int) c_req->command);
3206           signal_socks_failure (s5r,
3207                                 SOCKS5_STATUS_COMMAND_NOT_SUPPORTED);
3208           return;
3209       }
3210       switch (c_req->addr_type)
3211       {
3212         case SOCKS5_AT_IPV4:
3213           {
3214             const struct in_addr *v4 = (const struct in_addr *) &c_req[1];
3215             const uint16_t *port = (const uint16_t *) &v4[1];
3216             struct sockaddr_in *in;
3217
3218             s5r->port = ntohs (*port);
3219             alen = sizeof (struct in_addr);
3220             if (s5r->rbuf_len < sizeof (struct Socks5ClientRequestMessage) +
3221                 alen + sizeof (uint16_t))
3222               return; /* need more data */
3223             in = (struct sockaddr_in *) &s5r->destination_address;
3224             in->sin_family = AF_INET;
3225             in->sin_addr = *v4;
3226             in->sin_port = *port;
3227 #if HAVE_SOCKADDR_IN_SIN_LEN
3228             in->sin_len = sizeof (*in);
3229 #endif
3230             s5r->state = SOCKS5_DATA_TRANSFER;
3231           }
3232           break;
3233         case SOCKS5_AT_IPV6:
3234           {
3235             const struct in6_addr *v6 = (const struct in6_addr *) &c_req[1];
3236             const uint16_t *port = (const uint16_t *) &v6[1];
3237             struct sockaddr_in6 *in;
3238
3239             s5r->port = ntohs (*port);
3240             alen = sizeof (struct in6_addr);
3241             if (s5r->rbuf_len < sizeof (struct Socks5ClientRequestMessage) +
3242                 alen + sizeof (uint16_t))
3243               return; /* need more data */
3244             in = (struct sockaddr_in6 *) &s5r->destination_address;
3245             in->sin6_family = AF_INET6;
3246             in->sin6_addr = *v6;
3247             in->sin6_port = *port;
3248 #if HAVE_SOCKADDR_IN_SIN_LEN
3249             in->sin6_len = sizeof (*in);
3250 #endif
3251             s5r->state = SOCKS5_DATA_TRANSFER;
3252           }
3253           break;
3254         case SOCKS5_AT_DOMAINNAME:
3255           {
3256             const uint8_t *dom_len;
3257             const char *dom_name;
3258             const uint16_t *port;
3259
3260             dom_len = (const uint8_t *) &c_req[1];
3261             alen = *dom_len + 1;
3262             if (s5r->rbuf_len < sizeof (struct Socks5ClientRequestMessage) +
3263                 alen + sizeof (uint16_t))
3264               return; /* need more data */
3265             dom_name = (const char *) &dom_len[1];
3266             port = (const uint16_t*) &dom_name[*dom_len];
3267             s5r->domain = GNUNET_strndup (dom_name,
3268                                           *dom_len);
3269             GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3270                         "Requested connection is to http%s://%s:%d\n",
3271                         (HTTPS_PORT == s5r->port) ? "s" : "",
3272                         s5r->domain,
3273                         ntohs (*port));
3274             s5r->state = SOCKS5_RESOLVING;
3275             s5r->port = ntohs (*port);
3276             s5r->gns_lookup = GNUNET_GNS_lookup_with_tld (gns_handle,
3277                                                           s5r->domain,
3278                                                           GNUNET_DNSPARSER_TYPE_A,
3279                                                           GNUNET_NO /* only cached */,
3280                                                           &handle_gns_result,
3281                                                           s5r);
3282             break;
3283           }
3284         default:
3285           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3286                       _("Unsupported socks address type %d\n"),
3287                       (int) c_req->addr_type);
3288           signal_socks_failure (s5r,
3289                                 SOCKS5_STATUS_ADDRESS_TYPE_NOT_SUPPORTED);
3290           return;
3291       }
3292       clear_from_s5r_rbuf (s5r,
3293                            sizeof (struct Socks5ClientRequestMessage) +
3294                            alen + sizeof (uint16_t));
3295       if (0 != s5r->rbuf_len)
3296       {
3297         /* read more bytes than healthy, why did the client send more!? */
3298         GNUNET_break_op (0);
3299         signal_socks_failure (s5r,
3300                               SOCKS5_STATUS_GENERAL_FAILURE);
3301         return;
3302       }
3303       if (SOCKS5_DATA_TRANSFER == s5r->state)
3304       {
3305         /* if we are not waiting for GNS resolution, signal success */
3306         signal_socks_success (s5r);
3307       }
3308       /* We are done reading right now */
3309       GNUNET_SCHEDULER_cancel (s5r->rtask);
3310       s5r->rtask = NULL;
3311       return;
3312     case SOCKS5_RESOLVING:
3313       GNUNET_assert (0);
3314       return;
3315     case SOCKS5_DATA_TRANSFER:
3316       GNUNET_assert (0);
3317       return;
3318     default:
3319       GNUNET_assert (0);
3320       return;
3321   }
3322 }
3323
3324
3325 /**
3326  * Accept new incoming connections
3327  *
3328  * @param cls the closure with the lsock4 or lsock6
3329  * @param tc the scheduler context
3330  */
3331 static void
3332 do_accept (void *cls)
3333 {
3334   struct GNUNET_NETWORK_Handle *lsock = cls;
3335   struct GNUNET_NETWORK_Handle *s;
3336   struct Socks5Request *s5r;
3337
3338   GNUNET_assert (NULL != lsock);
3339   if (lsock == lsock4)
3340     ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
3341                                             lsock,
3342                                             &do_accept,
3343                                             lsock);
3344   else if (lsock == lsock6)
3345     ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
3346                                             lsock,
3347                                             &do_accept,
3348                                             lsock);
3349   else
3350     GNUNET_assert (0);
3351   s = GNUNET_NETWORK_socket_accept (lsock,
3352                                     NULL,
3353                                     NULL);
3354   if (NULL == s)
3355   {
3356     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
3357                          "accept");
3358     return;
3359   }
3360   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3361               "Got an inbound connection, waiting for data\n");
3362   s5r = GNUNET_new (struct Socks5Request);
3363   GNUNET_CONTAINER_DLL_insert (s5r_head,
3364                                s5r_tail,
3365                                s5r);
3366   s5r->sock = s;
3367   s5r->state = SOCKS5_INIT;
3368   s5r->rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
3369                                               s5r->sock,
3370                                               &do_s5r_read,
3371                                               s5r);
3372 }
3373
3374
3375 /* ******************* General / main code ********************* */
3376
3377
3378 /**
3379  * Task run on shutdown
3380  *
3381  * @param cls closure
3382  */
3383 static void
3384 do_shutdown (void *cls)
3385 {
3386   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
3387               "Shutting down...\n");
3388   /* MHD requires resuming before destroying the daemons */
3389   for (struct Socks5Request *s5r = s5r_head;
3390        NULL != s5r;
3391        s5r = s5r->next)
3392   {
3393     if (s5r->suspended)
3394     {
3395       s5r->suspended = GNUNET_NO;
3396       MHD_resume_connection (s5r->con);
3397     }
3398   }
3399   while (NULL != mhd_httpd_head)
3400     kill_httpd (mhd_httpd_head);
3401   while (NULL != s5r_head)
3402     cleanup_s5r (s5r_head);
3403   if (NULL != lsock4)
3404   {
3405     GNUNET_NETWORK_socket_close (lsock4);
3406     lsock4 = NULL;
3407   }
3408   if (NULL != lsock6)
3409   {
3410     GNUNET_NETWORK_socket_close (lsock6);
3411     lsock6 = NULL;
3412   }
3413   if (NULL != curl_multi)
3414   {
3415     curl_multi_cleanup (curl_multi);
3416     curl_multi = NULL;
3417   }
3418   if (NULL != gns_handle)
3419   {
3420     GNUNET_GNS_disconnect (gns_handle);
3421     gns_handle = NULL;
3422   }
3423   if (NULL != curl_download_task)
3424   {
3425     GNUNET_SCHEDULER_cancel (curl_download_task);
3426     curl_download_task = NULL;
3427   }
3428   if (NULL != ltask4)
3429   {
3430     GNUNET_SCHEDULER_cancel (ltask4);
3431     ltask4 = NULL;
3432   }
3433   if (NULL != ltask6)
3434   {
3435     GNUNET_SCHEDULER_cancel (ltask6);
3436     ltask6 = NULL;
3437   }
3438   gnutls_x509_crt_deinit (proxy_ca.cert);
3439   gnutls_x509_privkey_deinit (proxy_ca.key);
3440   gnutls_global_deinit ();
3441 }
3442
3443
3444 /**
3445  * Create an IPv4 listen socket bound to our port.
3446  *
3447  * @return NULL on error
3448  */
3449 static struct GNUNET_NETWORK_Handle *
3450 bind_v4 ()
3451 {
3452   struct GNUNET_NETWORK_Handle *ls;
3453   struct sockaddr_in sa4;
3454   int eno;
3455
3456   memset (&sa4, 0, sizeof (sa4));
3457   sa4.sin_family = AF_INET;
3458   sa4.sin_port = htons (port);
3459 #if HAVE_SOCKADDR_IN_SIN_LEN
3460   sa4.sin_len = sizeof (sa4);
3461 #endif
3462   ls = GNUNET_NETWORK_socket_create (AF_INET,
3463                                      SOCK_STREAM,
3464                                      0);
3465   if (NULL == ls)
3466     return NULL;
3467   if (GNUNET_OK !=
3468       GNUNET_NETWORK_socket_bind (ls,
3469                                   (const struct sockaddr *) &sa4,
3470                                   sizeof (sa4)))
3471   {
3472     eno = errno;
3473     GNUNET_NETWORK_socket_close (ls);
3474     errno = eno;
3475     return NULL;
3476   }
3477   return ls;
3478 }
3479
3480
3481 /**
3482  * Create an IPv6 listen socket bound to our port.
3483  *
3484  * @return NULL on error
3485  */
3486 static struct GNUNET_NETWORK_Handle *
3487 bind_v6 ()
3488 {
3489   struct GNUNET_NETWORK_Handle *ls;
3490   struct sockaddr_in6 sa6;
3491   int eno;
3492
3493   memset (&sa6, 0, sizeof (sa6));
3494   sa6.sin6_family = AF_INET6;
3495   sa6.sin6_port = htons (port);
3496 #if HAVE_SOCKADDR_IN_SIN_LEN
3497   sa6.sin6_len = sizeof (sa6);
3498 #endif
3499   ls = GNUNET_NETWORK_socket_create (AF_INET6,
3500                                      SOCK_STREAM,
3501                                      0);
3502   if (NULL == ls)
3503     return NULL;
3504   if (GNUNET_OK !=
3505       GNUNET_NETWORK_socket_bind (ls,
3506                                   (const struct sockaddr *) &sa6,
3507                                   sizeof (sa6)))
3508   {
3509     eno = errno;
3510     GNUNET_NETWORK_socket_close (ls);
3511     errno = eno;
3512     return NULL;
3513   }
3514   return ls;
3515 }
3516
3517
3518 /**
3519  * Main function that will be run
3520  *
3521  * @param cls closure
3522  * @param args remaining command-line arguments
3523  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
3524  * @param c configuration
3525  */
3526 static void
3527 run (void *cls,
3528      char *const *args,
3529      const char *cfgfile,
3530      const struct GNUNET_CONFIGURATION_Handle *c)
3531 {
3532   char* cafile_cfg = NULL;
3533   char* cafile;
3534   struct MhdHttpList *hd;
3535
3536   cfg = c;
3537
3538   if (NULL == (curl_multi = curl_multi_init ()))
3539   {
3540     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3541                 "Failed to create cURL multi handle!\n");
3542     return;
3543   }
3544   cafile = cafile_opt;
3545   if (NULL == cafile)
3546   {
3547     if (GNUNET_OK !=
3548         GNUNET_CONFIGURATION_get_value_filename (cfg,
3549                                                  "gns-proxy",
3550                                                  "PROXY_CACERT",
3551                                                  &cafile_cfg))
3552     {
3553       GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
3554                                  "gns-proxy",
3555                                  "PROXY_CACERT");
3556       return;
3557     }
3558     cafile = cafile_cfg;
3559   }
3560   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3561               "Using `%s' as CA\n",
3562               cafile);
3563
3564   gnutls_global_init ();
3565   gnutls_x509_crt_init (&proxy_ca.cert);
3566   gnutls_x509_privkey_init (&proxy_ca.key);
3567
3568   if ( (GNUNET_OK !=
3569         load_cert_from_file (proxy_ca.cert,
3570                              cafile)) ||
3571        (GNUNET_OK !=
3572         load_key_from_file (proxy_ca.key,
3573                             cafile)) )
3574   {
3575     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3576                 _("Failed to load X.509 key and certificate from `%s'\n"),
3577                 cafile);
3578     gnutls_x509_crt_deinit (proxy_ca.cert);
3579     gnutls_x509_privkey_deinit (proxy_ca.key);
3580     gnutls_global_deinit ();
3581     GNUNET_free_non_null (cafile_cfg);
3582     return;
3583   }
3584   GNUNET_free_non_null (cafile_cfg);
3585   if (NULL == (gns_handle = GNUNET_GNS_connect (cfg)))
3586   {
3587     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3588                 "Unable to connect to GNS!\n");
3589     gnutls_x509_crt_deinit (proxy_ca.cert);
3590     gnutls_x509_privkey_deinit (proxy_ca.key);
3591     gnutls_global_deinit ();
3592     return;
3593   }
3594   GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
3595                                  NULL);
3596
3597   /* Open listen socket for socks proxy */
3598   lsock6 = bind_v6 ();
3599   if (NULL == lsock6)
3600   {
3601     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
3602                          "bind");
3603   }
3604   else
3605   {
3606     if (GNUNET_OK !=
3607         GNUNET_NETWORK_socket_listen (lsock6,
3608                                       5))
3609     {
3610       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
3611                            "listen");
3612       GNUNET_NETWORK_socket_close (lsock6);
3613       lsock6 = NULL;
3614     }
3615     else
3616     {
3617       ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
3618                                               lsock6,
3619                                               &do_accept,
3620                                               lsock6);
3621     }
3622   }
3623   lsock4 = bind_v4 ();
3624   if (NULL == lsock4)
3625   {
3626     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
3627                          "bind");
3628   }
3629   else
3630   {
3631     if (GNUNET_OK !=
3632         GNUNET_NETWORK_socket_listen (lsock4,
3633                                       5))
3634     {
3635       GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
3636                            "listen");
3637       GNUNET_NETWORK_socket_close (lsock4);
3638       lsock4 = NULL;
3639     }
3640     else
3641     {
3642       ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
3643                                               lsock4,
3644                                               &do_accept,
3645                                               lsock4);
3646     }
3647   }
3648   if ( (NULL == lsock4) &&
3649        (NULL == lsock6) )
3650   {
3651     GNUNET_SCHEDULER_shutdown ();
3652     return;
3653   }
3654   if (0 != curl_global_init (CURL_GLOBAL_WIN32))
3655   {
3656     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
3657                 "cURL global init failed!\n");
3658     GNUNET_SCHEDULER_shutdown ();
3659     return;
3660   }
3661   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
3662               "Proxy listens on port %u\n",
3663               (unsigned int) port);
3664
3665   /* start MHD daemon for HTTP */
3666   hd = GNUNET_new (struct MhdHttpList);
3667   hd->daemon = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_NO_LISTEN_SOCKET | MHD_ALLOW_SUSPEND_RESUME,
3668                                  0,
3669                                  NULL, NULL,
3670                                  &create_response, hd,
3671                                  MHD_OPTION_CONNECTION_TIMEOUT, (unsigned int) 16,
3672                                  MHD_OPTION_NOTIFY_COMPLETED, &mhd_completed_cb, NULL,
3673                                  MHD_OPTION_NOTIFY_CONNECTION, &mhd_connection_cb, NULL,
3674                                  MHD_OPTION_URI_LOG_CALLBACK, &mhd_log_callback, NULL,
3675                                  MHD_OPTION_END);
3676   if (NULL == hd->daemon)
3677   {
3678     GNUNET_free (hd);
3679     GNUNET_SCHEDULER_shutdown ();
3680     return;
3681   }
3682   httpd = hd;
3683   GNUNET_CONTAINER_DLL_insert (mhd_httpd_head,
3684                                mhd_httpd_tail,
3685                                hd);
3686 }
3687
3688
3689 /**
3690  * The main function for gnunet-gns-proxy.
3691  *
3692  * @param argc number of arguments from the command line
3693  * @param argv command line arguments
3694  * @return 0 ok, 1 on error
3695  */
3696 int
3697 main (int argc,
3698       char *const *argv)
3699 {
3700   struct GNUNET_GETOPT_CommandLineOption options[] = {
3701     GNUNET_GETOPT_option_uint16 ('p',
3702                                  "port",
3703                                  NULL,
3704                                  gettext_noop ("listen on specified port (default: 7777)"),
3705                                  &port),
3706     GNUNET_GETOPT_option_string ('a',
3707                                  "authority",
3708                                  NULL,
3709                                  gettext_noop ("pem file to use as CA"),
3710                                  &cafile_opt),
3711     GNUNET_GETOPT_option_flag ('6',
3712                                "disable-ivp6",
3713                                gettext_noop ("disable use of IPv6"),
3714                                &disable_v6),
3715
3716     GNUNET_GETOPT_OPTION_END
3717   };
3718   static const char* page =
3719     "<html><head><title>gnunet-gns-proxy</title>"
3720     "</head><body>cURL fail</body></html>";
3721   int ret;
3722
3723   if (GNUNET_OK !=
3724       GNUNET_STRINGS_get_utf8_args (argc, argv,
3725                                     &argc, &argv))
3726     return 2;
3727   GNUNET_log_setup ("gnunet-gns-proxy",
3728                     "WARNING",
3729                     NULL);
3730   curl_failure_response
3731     = MHD_create_response_from_buffer (strlen (page),
3732                                        (void *) page,
3733                                        MHD_RESPMEM_PERSISTENT);
3734
3735   ret =
3736     (GNUNET_OK ==
3737      GNUNET_PROGRAM_run (argc, argv,
3738                          "gnunet-gns-proxy",
3739                          _("GNUnet GNS proxy"),
3740                          options,
3741                          &run, NULL)) ? 0 : 1;
3742   MHD_destroy_response (curl_failure_response);
3743   GNUNET_free_non_null ((char *) argv);
3744   return ret;
3745 }
3746
3747 /* end of gnunet-gns-proxy.c */