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