tests/server/sws.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2017, Daniel Stenberg, <daniel@haxx.se>, et al.
   9  *
  10  * This software is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution. The terms
  12  * are also available at https://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ***************************************************************************/
  22 #include "server_setup.h"
  23
  24 /* sws.c: simple (silly?) web server
  25
  26    This code was originally graciously donated to the project by Juergen
  27    Wilke. Thanks a bunch!
  28
  29  */
  30
  31 #ifdef HAVE_SIGNAL_H
  32 #include <signal.h>
  33 #endif
  34 #ifdef HAVE_NETINET_IN_H
  35 #include <netinet/in.h>
  36 #endif
  37 #ifdef HAVE_NETINET_IN6_H
  38 #include <netinet/in6.h>
  39 #endif
  40 #ifdef HAVE_ARPA_INET_H
  41 #include <arpa/inet.h>
  42 #endif
  43 #ifdef HAVE_NETDB_H
  44 #include <netdb.h>
  45 #endif
  46 #ifdef HAVE_NETINET_TCP_H
  47 #include <netinet/tcp.h> /* for TCP_NODELAY */
  48 #endif
  49
  50 #define ENABLE_CURLX_PRINTF
  51 /* make the curlx header define all printf() functions to use the curlx_*
  52    versions instead */
  53 #include "curlx.h" /* from the private lib dir */
  54 #include "getpart.h"
  55 #include "inet_pton.h"
  56 #include "util.h"
  57 #include "server_sockaddr.h"
  58
  59 /* include memdebug.h last */
  60 #include "memdebug.h"
  61
  62 #ifdef USE_WINSOCK
  63 #undef  EINTR
  64 #define EINTR    4 /* errno.h value */
  65 #undef  EAGAIN
  66 #define EAGAIN  11 /* errno.h value */
  67 #undef  ERANGE
  68 #define ERANGE  34 /* errno.h value */
  69 #endif
  70
  71 static enum {
  72   socket_domain_inet = AF_INET
  73 #ifdef ENABLE_IPV6
  74   , socket_domain_inet6 = AF_INET6
  75 #endif
  76 #ifdef USE_UNIX_SOCKETS
  77   , socket_domain_unix = AF_UNIX
  78 #endif
  79 } socket_domain = AF_INET;
  80 static bool use_gopher = FALSE;
  81 static int serverlogslocked = 0;
  82 static bool is_proxy = FALSE;
  83
  84 #define REQBUFSIZ 150000
  85 #define REQBUFSIZ_TXT "149999"
  86
  87 static long prevtestno = -1;    /* previous test number we served */
  88 static long prevpartno = -1;    /* previous part number we served */
  89 static bool prevbounce = FALSE; /* instructs the server to increase the part
  90                                    number for a test in case the identical
  91                                    testno+partno request shows up again */
  92
  93 #define RCMD_NORMALREQ 0 /* default request, use the tests file normally */
  94 #define RCMD_IDLE      1 /* told to sit idle */
  95 #define RCMD_STREAM    2 /* told to stream */
  96
  97 struct httprequest {
  98   char reqbuf[REQBUFSIZ]; /* buffer area for the incoming request */
  99   bool connect_request; /* if a CONNECT */
 100   unsigned short connect_port; /* the port number CONNECT used */
 101   size_t checkindex; /* where to start checking of the request */
 102   size_t offset;     /* size of the incoming request */
 103   long testno;       /* test number found in the request */
 104   long partno;       /* part number found in the request */
 105   bool open;      /* keep connection open info, as found in the request */
 106   bool auth_req;  /* authentication required, don't wait for body unless
 107                      there's an Authorization header */
 108   bool auth;      /* Authorization header present in the incoming request */
 109   size_t cl;      /* Content-Length of the incoming request */
 110   bool digest;    /* Authorization digest header found */
 111   bool ntlm;      /* Authorization ntlm header found */
 112   int writedelay; /* if non-zero, delay this number of seconds between
 113                      writes in the response */
 114   int pipe;       /* if non-zero, expect this many requests to do a "piped"
 115                      request/response */
 116   int skip;       /* if non-zero, the server is instructed to not read this
 117                      many bytes from a PUT/POST request. Ie the client sends N
 118                      bytes said in Content-Length, but the server only reads N
 119                      - skip bytes. */
 120   int rcmd;       /* doing a special command, see defines above */
 121   int prot_version;  /* HTTP version * 10 */
 122   bool pipelining;   /* true if request is pipelined */
 123   int callcount;  /* times ProcessRequest() gets called */
 124   bool connmon;   /* monitor the state of the connection, log disconnects */
 125   bool upgrade;   /* test case allows upgrade to http2 */
 126   bool upgrade_request; /* upgrade request found and allowed */
 127   int done_processing;
 128 };
 129
 130 #define MAX_SOCKETS 1024
 131
 132 static curl_socket_t all_sockets[MAX_SOCKETS];
 133 static size_t num_sockets = 0;
 134
 135 static int ProcessRequest(struct httprequest *req);
 136 static void storerequest(const char *reqbuf, size_t totalsize);
 137
 138 #define DEFAULT_PORT 8999
 139
 140 #ifndef DEFAULT_LOGFILE
 141 #define DEFAULT_LOGFILE "log/sws.log"
 142 #endif
 143
 144 const char *serverlogfile = DEFAULT_LOGFILE;
 145
 146 #define SWSVERSION "curl test suite HTTP server/0.1"
 147
 148 #define REQUEST_DUMP  "log/server.input"
 149 #define RESPONSE_DUMP "log/server.response"
 150
 151 /* when told to run as proxy, we store the logs in different files so that
 152    they can co-exist with the same program running as a "server" */
 153 #define REQUEST_PROXY_DUMP  "log/proxy.input"
 154 #define RESPONSE_PROXY_DUMP "log/proxy.response"
 155
 156 /* very-big-path support */
 157 #define MAXDOCNAMELEN 140000
 158 #define MAXDOCNAMELEN_TXT "139999"
 159
 160 #define REQUEST_KEYWORD_SIZE 256
 161 #define REQUEST_KEYWORD_SIZE_TXT "255"
 162
 163 #define CMD_AUTH_REQUIRED "auth_required"
 164
 165 /* 'idle' means that it will accept the request fine but never respond
 166    any data. Just keep the connection alive. */
 167 #define CMD_IDLE "idle"
 168
 169 /* 'stream' means to send a never-ending stream of data */
 170 #define CMD_STREAM "stream"
 171
 172 /* 'connection-monitor' will output when a server/proxy connection gets
 173    disconnected as for some cases it is important that it gets done at the
 174    proper point - like with NTLM */
 175 #define CMD_CONNECTIONMONITOR "connection-monitor"
 176
 177 /* upgrade to http2 */
 178 #define CMD_UPGRADE "upgrade"
 179
 180 #define END_OF_HEADERS "\r\n\r\n"
 181
 182 enum {
 183   DOCNUMBER_NOTHING = -4,
 184   DOCNUMBER_QUIT    = -3,
 185   DOCNUMBER_WERULEZ = -2,
 186   DOCNUMBER_404     = -1
 187 };
 188
 189 static const char *end_of_headers = END_OF_HEADERS;
 190
 191 /* sent as reply to a QUIT */
 192 static const char *docquit =
 193 "HTTP/1.1 200 Goodbye" END_OF_HEADERS;
 194
 195 /* send back this on 404 file not found */
 196 static const char *doc404 = "HTTP/1.1 404 Not Found\r\n"
 197     "Server: " SWSVERSION "\r\n"
 198     "Connection: close\r\n"
 199     "Content-Type: text/html"
 200     END_OF_HEADERS
 201     "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n"
 202     "<HTML><HEAD>\n"
 203     "<TITLE>404 Not Found</TITLE>\n"
 204     "</HEAD><BODY>\n"
 205     "<H1>Not Found</H1>\n"
 206     "The requested URL was not found on this server.\n"
 207     "<P><HR><ADDRESS>" SWSVERSION "</ADDRESS>\n" "</BODY></HTML>\n";
 208
 209 /* do-nothing macro replacement for systems which lack siginterrupt() */
 210
 211 #ifndef HAVE_SIGINTERRUPT
 212 #define siginterrupt(x,y) do {} while(0)
 213 #endif
 214
 215 /* vars used to keep around previous signal handlers */
 216
 217 typedef RETSIGTYPE (*SIGHANDLER_T)(int);
 218
 219 #ifdef SIGHUP
 220 static SIGHANDLER_T old_sighup_handler  = SIG_ERR;
 221 #endif
 222
 223 #ifdef SIGPIPE
 224 static SIGHANDLER_T old_sigpipe_handler = SIG_ERR;
 225 #endif
 226
 227 #ifdef SIGALRM
 228 static SIGHANDLER_T old_sigalrm_handler = SIG_ERR;
 229 #endif
 230
 231 #ifdef SIGINT
 232 static SIGHANDLER_T old_sigint_handler  = SIG_ERR;
 233 #endif
 234
 235 #ifdef SIGTERM
 236 static SIGHANDLER_T old_sigterm_handler = SIG_ERR;
 237 #endif
 238
 239 #if defined(SIGBREAK) && defined(WIN32)
 240 static SIGHANDLER_T old_sigbreak_handler = SIG_ERR;
 241 #endif
 242
 243 /* var which if set indicates that the program should finish execution */
 244
 245 SIG_ATOMIC_T got_exit_signal = 0;
 246
 247 /* if next is set indicates the first signal handled in exit_signal_handler */
 248
 249 static volatile int exit_signal = 0;
 250
 251 /* signal handler that will be triggered to indicate that the program
 252   should finish its execution in a controlled manner as soon as possible.
 253   The first time this is called it will set got_exit_signal to one and
 254   store in exit_signal the signal that triggered its execution. */
 255
 256 static RETSIGTYPE exit_signal_handler(int signum)
 257 {
 258   int old_errno = errno;
 259   if(got_exit_signal == 0) {
 260     got_exit_signal = 1;
 261     exit_signal = signum;
 262   }
 263   (void)signal(signum, exit_signal_handler);
 264   errno = old_errno;
 265 }
 266
 267 static void install_signal_handlers(void)
 268 {
 269 #ifdef SIGHUP
 270   /* ignore SIGHUP signal */
 271   old_sighup_handler = signal(SIGHUP, SIG_IGN);
 272   if(old_sighup_handler == SIG_ERR)
 273     logmsg("cannot install SIGHUP handler: %s", strerror(errno));
 274 #endif
 275 #ifdef SIGPIPE
 276   /* ignore SIGPIPE signal */
 277   old_sigpipe_handler = signal(SIGPIPE, SIG_IGN);
 278   if(old_sigpipe_handler == SIG_ERR)
 279     logmsg("cannot install SIGPIPE handler: %s", strerror(errno));
 280 #endif
 281 #ifdef SIGALRM
 282   /* ignore SIGALRM signal */
 283   old_sigalrm_handler = signal(SIGALRM, SIG_IGN);
 284   if(old_sigalrm_handler == SIG_ERR)
 285     logmsg("cannot install SIGALRM handler: %s", strerror(errno));
 286 #endif
 287 #ifdef SIGINT
 288   /* handle SIGINT signal with our exit_signal_handler */
 289   old_sigint_handler = signal(SIGINT, exit_signal_handler);
 290   if(old_sigint_handler == SIG_ERR)
 291     logmsg("cannot install SIGINT handler: %s", strerror(errno));
 292   else
 293     siginterrupt(SIGINT, 1);
 294 #endif
 295 #ifdef SIGTERM
 296   /* handle SIGTERM signal with our exit_signal_handler */
 297   old_sigterm_handler = signal(SIGTERM, exit_signal_handler);
 298   if(old_sigterm_handler == SIG_ERR)
 299     logmsg("cannot install SIGTERM handler: %s", strerror(errno));
 300   else
 301     siginterrupt(SIGTERM, 1);
 302 #endif
 303 #if defined(SIGBREAK) && defined(WIN32)
 304   /* handle SIGBREAK signal with our exit_signal_handler */
 305   old_sigbreak_handler = signal(SIGBREAK, exit_signal_handler);
 306   if(old_sigbreak_handler == SIG_ERR)
 307     logmsg("cannot install SIGBREAK handler: %s", strerror(errno));
 308   else
 309     siginterrupt(SIGBREAK, 1);
 310 #endif
 311 }
 312
 313 static void restore_signal_handlers(void)
 314 {
 315 #ifdef SIGHUP
 316   if(SIG_ERR != old_sighup_handler)
 317     (void)signal(SIGHUP, old_sighup_handler);
 318 #endif
 319 #ifdef SIGPIPE
 320   if(SIG_ERR != old_sigpipe_handler)
 321     (void)signal(SIGPIPE, old_sigpipe_handler);
 322 #endif
 323 #ifdef SIGALRM
 324   if(SIG_ERR != old_sigalrm_handler)
 325     (void)signal(SIGALRM, old_sigalrm_handler);
 326 #endif
 327 #ifdef SIGINT
 328   if(SIG_ERR != old_sigint_handler)
 329     (void)signal(SIGINT, old_sigint_handler);
 330 #endif
 331 #ifdef SIGTERM
 332   if(SIG_ERR != old_sigterm_handler)
 333     (void)signal(SIGTERM, old_sigterm_handler);
 334 #endif
 335 #if defined(SIGBREAK) && defined(WIN32)
 336   if(SIG_ERR != old_sigbreak_handler)
 337     (void)signal(SIGBREAK, old_sigbreak_handler);
 338 #endif
 339 }
 340
 341 /* returns true if the current socket is an IP one */
 342 static bool socket_domain_is_ip(void)
 343 {
 344   switch(socket_domain) {
 345   case AF_INET:
 346 #ifdef ENABLE_IPV6
 347   case AF_INET6:
 348 #endif
 349     return true;
 350   default:
 351   /* case AF_UNIX: */
 352     return false;
 353   }
 354 }
 355
 356 /* based on the testno, parse the correct server commands */
 357 static int parse_servercmd(struct httprequest *req)
 358 {
 359   FILE *stream;
 360   char *filename;
 361   int error;
 362
 363   filename = test2file(req->testno);
 364
 365   stream = fopen(filename, "rb");
 366   if(!stream) {
 367     error = errno;
 368     logmsg("fopen() failed with error: %d %s", error, strerror(error));
 369     logmsg("  [1] Error opening file: %s", filename);
 370     logmsg("  Couldn't open test file %ld", req->testno);
 371     req->open = FALSE; /* closes connection */
 372     return 1; /* done */
 373   }
 374   else {
 375     char *orgcmd = NULL;
 376     char *cmd = NULL;
 377     size_t cmdsize = 0;
 378     int num = 0;
 379
 380     /* get the custom server control "commands" */
 381     error = getpart(&orgcmd, &cmdsize, "reply", "servercmd", stream);
 382     fclose(stream);
 383     if(error) {
 384       logmsg("getpart() failed with error: %d", error);
 385       req->open = FALSE; /* closes connection */
 386       return 1; /* done */
 387     }
 388
 389     req->connmon = FALSE;
 390
 391     cmd = orgcmd;
 392     while(cmd && cmdsize) {
 393       char *check;
 394
 395       if(!strncmp(CMD_AUTH_REQUIRED, cmd, strlen(CMD_AUTH_REQUIRED))) {
 396         logmsg("instructed to require authorization header");
 397         req->auth_req = TRUE;
 398       }
 399       else if(!strncmp(CMD_IDLE, cmd, strlen(CMD_IDLE))) {
 400         logmsg("instructed to idle");
 401         req->rcmd = RCMD_IDLE;
 402         req->open = TRUE;
 403       }
 404       else if(!strncmp(CMD_STREAM, cmd, strlen(CMD_STREAM))) {
 405         logmsg("instructed to stream");
 406         req->rcmd = RCMD_STREAM;
 407       }
 408       else if(!strncmp(CMD_CONNECTIONMONITOR, cmd,
 409                        strlen(CMD_CONNECTIONMONITOR))) {
 410         logmsg("enabled connection monitoring");
 411         req->connmon = TRUE;
 412       }
 413       else if(!strncmp(CMD_UPGRADE, cmd, strlen(CMD_UPGRADE))) {
 414         logmsg("enabled upgrade to http2");
 415         req->upgrade = TRUE;
 416       }
 417       else if(1 == sscanf(cmd, "pipe: %d", &num)) {
 418         logmsg("instructed to allow a pipe size of %d", num);
 419         if(num < 0)
 420           logmsg("negative pipe size ignored");
 421         else if(num > 0)
 422           req->pipe = num-1; /* decrease by one since we don't count the
 423                                 first request in this number */
 424       }
 425       else if(1 == sscanf(cmd, "skip: %d", &num)) {
 426         logmsg("instructed to skip this number of bytes %d", num);
 427         req->skip = num;
 428       }
 429       else if(1 == sscanf(cmd, "writedelay: %d", &num)) {
 430         logmsg("instructed to delay %d secs between packets", num);
 431         req->writedelay = num;
 432       }
 433       else {
 434         logmsg("Unknown <servercmd> instruction found: %s", cmd);
 435       }
 436       /* try to deal with CRLF or just LF */
 437       check = strchr(cmd, '\r');
 438       if(!check)
 439         check = strchr(cmd, '\n');
 440
 441       if(check) {
 442         /* get to the letter following the newline */
 443         while((*check == '\r') || (*check == '\n'))
 444           check++;
 445
 446         if(!*check)
 447           /* if we reached a zero, get out */
 448           break;
 449         cmd = check;
 450       }
 451       else
 452         break;
 453     }
 454     free(orgcmd);
 455   }
 456
 457   return 0; /* OK! */
 458 }
 459
 460 static int ProcessRequest(struct httprequest *req)
 461 {
 462   char *line = &req->reqbuf[req->checkindex];
 463   bool chunked = FALSE;
 464   static char request[REQUEST_KEYWORD_SIZE];
 465   static char doc[MAXDOCNAMELEN];
 466   char logbuf[456];
 467   int prot_major, prot_minor;
 468   char *end = strstr(line, end_of_headers);
 469
 470   req->callcount++;
 471
 472   logmsg("Process %d bytes request%s", req->offset,
 473          req->callcount > 1?" [CONTINUED]":"");
 474
 475   /* try to figure out the request characteristics as soon as possible, but
 476      only once! */
 477
 478   if(use_gopher &&
 479      (req->testno == DOCNUMBER_NOTHING) &&
 480      !strncmp("/verifiedserver", line, 15)) {
 481     logmsg("Are-we-friendly question received");
 482     req->testno = DOCNUMBER_WERULEZ;
 483     return 1; /* done */
 484   }
 485
 486   else if((req->testno == DOCNUMBER_NOTHING) &&
 487      sscanf(line,
 488             "%" REQUEST_KEYWORD_SIZE_TXT"s %" MAXDOCNAMELEN_TXT "s HTTP/%d.%d",
 489             request,
 490             doc,
 491             &prot_major,
 492             &prot_minor) == 4) {
 493     char *ptr;
 494
 495     req->prot_version = prot_major*10 + prot_minor;
 496
 497     /* find the last slash */
 498     ptr = strrchr(doc, '/');
 499
 500     /* get the number after it */
 501     if(ptr) {
 502       if((strlen(doc) + strlen(request)) < 400)
 503         snprintf(logbuf, sizeof(logbuf), "Got request: %s %s HTTP/%d.%d",
 504                  request, doc, prot_major, prot_minor);
 505       else
 506         snprintf(logbuf, sizeof(logbuf), "Got a *HUGE* request HTTP/%d.%d",
 507                  prot_major, prot_minor);
 508       logmsg("%s", logbuf);
 509
 510       if(!strncmp("/verifiedserver", ptr, 15)) {
 511         logmsg("Are-we-friendly question received");
 512         req->testno = DOCNUMBER_WERULEZ;
 513         return 1; /* done */
 514       }
 515
 516       if(!strncmp("/quit", ptr, 5)) {
 517         logmsg("Request-to-quit received");
 518         req->testno = DOCNUMBER_QUIT;
 519         return 1; /* done */
 520       }
 521
 522       ptr++; /* skip the slash */
 523
 524       /* skip all non-numericals following the slash */
 525       while(*ptr && !ISDIGIT(*ptr))
 526         ptr++;
 527
 528       req->testno = strtol(ptr, &ptr, 10);
 529
 530       if(req->testno > 10000) {
 531         req->partno = req->testno % 10000;
 532         req->testno /= 10000;
 533       }
 534       else
 535         req->partno = 0;
 536
 537       if(req->testno) {
 538
 539         snprintf(logbuf, sizeof(logbuf), "Requested test number %ld part %ld",
 540                  req->testno, req->partno);
 541         logmsg("%s", logbuf);
 542
 543         /* find and parse <servercmd> for this test */
 544         parse_servercmd(req);
 545       }
 546       else
 547         req->testno = DOCNUMBER_NOTHING;
 548
 549     }
 550
 551     if(req->testno == DOCNUMBER_NOTHING) {
 552       /* didn't find any in the first scan, try alternative test case
 553          number placements */
 554
 555       if(sscanf(req->reqbuf, "CONNECT %" MAXDOCNAMELEN_TXT "s HTTP/%d.%d",
 556                 doc, &prot_major, &prot_minor) == 3) {
 557         char *portp = NULL;
 558         unsigned long part = 0;
 559
 560         snprintf(logbuf, sizeof(logbuf),
 561                  "Received a CONNECT %s HTTP/%d.%d request",
 562                  doc, prot_major, prot_minor);
 563         logmsg("%s", logbuf);
 564
 565         req->connect_request = TRUE;
 566
 567         if(req->prot_version == 10)
 568           req->open = FALSE; /* HTTP 1.0 closes connection by default */
 569
 570         if(doc[0] == '[') {
 571           char *p = &doc[1];
 572           /* scan through the hexgroups and store the value of the last group
 573              in the 'part' variable and use as test case number!! */
 574           while(*p && (ISXDIGIT(*p) || (*p == ':') || (*p == '.'))) {
 575             char *endp;
 576             part = strtoul(p, &endp, 16);
 577             if(ISXDIGIT(*p))
 578               p = endp;
 579             else
 580               p++;
 581           }
 582           if(*p != ']')
 583             logmsg("Invalid CONNECT IPv6 address format");
 584           else if(*(p + 1) != ':')
 585             logmsg("Invalid CONNECT IPv6 port format");
 586           else
 587             portp = p + 1;
 588
 589           req->testno = part;
 590         }
 591         else
 592           portp = strchr(doc, ':');
 593
 594         if(portp && (*(portp + 1) != '\0') && ISDIGIT(*(portp + 1))) {
 595           unsigned long ulnum = strtoul(portp + 1, NULL, 10);
 596           if(!ulnum || (ulnum > 65535UL))
 597             logmsg("Invalid CONNECT port received");
 598           else
 599             req->connect_port = curlx_ultous(ulnum);
 600
 601         }
 602         logmsg("Port number: %d, test case number: %ld",
 603                req->connect_port, req->testno);
 604       }
 605     }
 606
 607     if(req->testno == DOCNUMBER_NOTHING) {
 608       /* check for a Testno: header with the test case number */
 609       char *testno = strstr(line, "\nTestno: ");
 610       if(testno) {
 611         req->testno = strtol(&testno[9], NULL, 10);
 612         logmsg("Found test number %d in Testno: header!", req->testno);
 613       }
 614     }
 615     if(req->testno == DOCNUMBER_NOTHING) {
 616       /* Still no test case number. Try to get the the number off the last dot
 617          instead, IE we consider the TLD to be the test number. Test 123 can
 618          then be written as "example.com.123". */
 619
 620       /* find the last dot */
 621       ptr = strrchr(doc, '.');
 622
 623       /* get the number after it */
 624       if(ptr) {
 625         ptr++; /* skip the dot */
 626
 627         req->testno = strtol(ptr, &ptr, 10);
 628
 629         if(req->testno > 10000) {
 630           req->partno = req->testno % 10000;
 631           req->testno /= 10000;
 632
 633           logmsg("found test %d in requested host name", req->testno);
 634
 635         }
 636         else
 637           req->partno = 0;
 638
 639         snprintf(logbuf, sizeof(logbuf),
 640                  "Requested test number %ld part %ld (from host name)",
 641                  req->testno, req->partno);
 642         logmsg("%s", logbuf);
 643
 644       }
 645
 646       if(!req->testno) {
 647         logmsg("Did not find test number in PATH");
 648         req->testno = DOCNUMBER_404;
 649       }
 650       else
 651         parse_servercmd(req);
 652     }
 653   }
 654   else if((req->offset >= 3) && (req->testno == DOCNUMBER_NOTHING)) {
 655     logmsg("** Unusual request. Starts with %02x %02x %02x",
 656            line[0], line[1], line[2]);
 657   }
 658
 659   if(!end) {
 660     /* we don't have a complete request yet! */
 661     logmsg("request not complete yet");
 662     return 0; /* not complete yet */
 663   }
 664   logmsg("- request found to be complete");
 665
 666   if(use_gopher) {
 667     /* when using gopher we cannot check the request until the entire
 668        thing has been received */
 669     char *ptr;
 670
 671     /* find the last slash in the line */
 672     ptr = strrchr(line, '/');
 673
 674     if(ptr) {
 675       ptr++; /* skip the slash */
 676
 677       /* skip all non-numericals following the slash */
 678       while(*ptr && !ISDIGIT(*ptr))
 679         ptr++;
 680
 681       req->testno = strtol(ptr, &ptr, 10);
 682
 683       if(req->testno > 10000) {
 684         req->partno = req->testno % 10000;
 685         req->testno /= 10000;
 686       }
 687       else
 688         req->partno = 0;
 689
 690       snprintf(logbuf, sizeof(logbuf),
 691                "Requested GOPHER test number %ld part %ld",
 692                req->testno, req->partno);
 693       logmsg("%s", logbuf);
 694     }
 695   }
 696
 697   if(req->pipe)
 698     /* we do have a full set, advance the checkindex to after the end of the
 699        headers, for the pipelining case mostly */
 700     req->checkindex += (end - line) + strlen(end_of_headers);
 701
 702   /* **** Persistence ****
 703    *
 704    * If the request is a HTTP/1.0 one, we close the connection unconditionally
 705    * when we're done.
 706    *
 707    * If the request is a HTTP/1.1 one, we MUST check for a "Connection:"
 708    * header that might say "close". If it does, we close a connection when
 709    * this request is processed. Otherwise, we keep the connection alive for X
 710    * seconds.
 711    */
 712
 713   do {
 714     if(got_exit_signal)
 715       return 1; /* done */
 716
 717     if((req->cl == 0) && strncasecompare("Content-Length:", line, 15)) {
 718       /* If we don't ignore content-length, we read it and we read the whole
 719          request including the body before we return. If we've been told to
 720          ignore the content-length, we will return as soon as all headers
 721          have been received */
 722       char *endptr;
 723       char *ptr = line + 15;
 724       unsigned long clen = 0;
 725       while(*ptr && ISSPACE(*ptr))
 726         ptr++;
 727       endptr = ptr;
 728       errno = 0;
 729       clen = strtoul(ptr, &endptr, 10);
 730       if((ptr == endptr) || !ISSPACE(*endptr) || (ERANGE == errno)) {
 731         /* this assumes that a zero Content-Length is valid */
 732         logmsg("Found invalid Content-Length: (%s) in the request", ptr);
 733         req->open = FALSE; /* closes connection */
 734         return 1; /* done */
 735       }
 736       req->cl = clen - req->skip;
 737
 738       logmsg("Found Content-Length: %lu in the request", clen);
 739       if(req->skip)
 740         logmsg("... but will abort after %zu bytes", req->cl);
 741       break;
 742     }
 743     else if(strncasecompare("Transfer-Encoding: chunked", line,
 744                             strlen("Transfer-Encoding: chunked"))) {
 745       /* chunked data coming in */
 746       chunked = TRUE;
 747     }
 748
 749     if(chunked) {
 750       if(strstr(req->reqbuf, "\r\n0\r\n\r\n"))
 751         /* end of chunks reached */
 752         return 1; /* done */
 753       else
 754         return 0; /* not done */
 755     }
 756
 757     line = strchr(line, '\n');
 758     if(line)
 759       line++;
 760
 761   } while(line);
 762
 763   if(!req->auth && strstr(req->reqbuf, "Authorization:")) {
 764     req->auth = TRUE; /* Authorization: header present! */
 765     if(req->auth_req)
 766       logmsg("Authorization header found, as required");
 767   }
 768
 769   if(strstr(req->reqbuf, "Authorization: Negotiate")) {
 770     /* Negotiate iterations */
 771     static long prev_testno = -1;
 772     static long prev_partno = -1;
 773     logmsg("Negotiate: prev_testno: %d, prev_partno: %d",
 774             prev_testno, prev_partno);
 775     if(req->testno != prev_testno) {
 776       prev_testno = req->testno;
 777       prev_partno = req->partno;
 778     }
 779     prev_partno += 1;
 780     req->partno = prev_partno;
 781   }
 782   else if(!req->digest && strstr(req->reqbuf, "Authorization: Digest")) {
 783     /* If the client is passing this Digest-header, we set the part number
 784        to 1000. Not only to spice up the complexity of this, but to make
 785        Digest stuff to work in the test suite. */
 786     req->partno += 1000;
 787     req->digest = TRUE; /* header found */
 788     logmsg("Received Digest request, sending back data %ld", req->partno);
 789   }
 790   else if(!req->ntlm &&
 791           strstr(req->reqbuf, "Authorization: NTLM TlRMTVNTUAAD")) {
 792     /* If the client is passing this type-3 NTLM header */
 793     req->partno += 1002;
 794     req->ntlm = TRUE; /* NTLM found */
 795     logmsg("Received NTLM type-3, sending back data %ld", req->partno);
 796     if(req->cl) {
 797       logmsg("  Expecting %zu POSTed bytes", req->cl);
 798     }
 799   }
 800   else if(!req->ntlm &&
 801           strstr(req->reqbuf, "Authorization: NTLM TlRMTVNTUAAB")) {
 802     /* If the client is passing this type-1 NTLM header */
 803     req->partno += 1001;
 804     req->ntlm = TRUE; /* NTLM found */
 805     logmsg("Received NTLM type-1, sending back data %ld", req->partno);
 806   }
 807   else if((req->partno >= 1000) &&
 808           strstr(req->reqbuf, "Authorization: Basic")) {
 809     /* If the client is passing this Basic-header and the part number is
 810        already >=1000, we add 1 to the part number.  This allows simple Basic
 811        authentication negotiation to work in the test suite. */
 812     req->partno += 1;
 813     logmsg("Received Basic request, sending back data %ld", req->partno);
 814   }
 815   if(strstr(req->reqbuf, "Connection: close"))
 816     req->open = FALSE; /* close connection after this request */
 817
 818   if(!req->pipe &&
 819      req->open &&
 820      req->prot_version >= 11 &&
 821      end &&
 822      req->reqbuf + req->offset > end + strlen(end_of_headers) &&
 823      !req->cl &&
 824      (!strncmp(req->reqbuf, "GET", strlen("GET")) ||
 825       !strncmp(req->reqbuf, "HEAD", strlen("HEAD")))) {
 826     /* If we have a persistent connection, HTTP version >= 1.1
 827        and GET/HEAD request, enable pipelining. */
 828     req->checkindex = (end - req->reqbuf) + strlen(end_of_headers);
 829     req->pipelining = TRUE;
 830   }
 831
 832   while(req->pipe) {
 833     if(got_exit_signal)
 834       return 1; /* done */
 835     /* scan for more header ends within this chunk */
 836     line = &req->reqbuf[req->checkindex];
 837     end = strstr(line, end_of_headers);
 838     if(!end)
 839       break;
 840     req->checkindex += (end - line) + strlen(end_of_headers);
 841     req->pipe--;
 842   }
 843
 844   /* If authentication is required and no auth was provided, end now. This
 845      makes the server NOT wait for PUT/POST data and you can then make the
 846      test case send a rejection before any such data has been sent. Test case
 847      154 uses this.*/
 848   if(req->auth_req && !req->auth) {
 849     logmsg("Return early due to auth requested by none provided");
 850     return 1; /* done */
 851   }
 852
 853   if(req->upgrade && strstr(req->reqbuf, "Upgrade:")) {
 854     /* we allow upgrade and there was one! */
 855     logmsg("Found Upgrade: in request and allows it");
 856     req->upgrade_request = TRUE;
 857   }
 858
 859   if(req->cl > 0) {
 860     if(req->cl <= req->offset - (end - req->reqbuf) - strlen(end_of_headers))
 861       return 1; /* done */
 862     else
 863       return 0; /* not complete yet */
 864   }
 865
 866   return 1; /* done */
 867 }
 868
 869 /* store the entire request in a file */
 870 static void storerequest(const char *reqbuf, size_t totalsize)
 871 {
 872   int res;
 873   int error = 0;
 874   size_t written;
 875   size_t writeleft;
 876   FILE *dump;
 877   const char *dumpfile = is_proxy?REQUEST_PROXY_DUMP:REQUEST_DUMP;
 878
 879   if(reqbuf == NULL)
 880     return;
 881   if(totalsize == 0)
 882     return;
 883
 884   do {
 885     dump = fopen(dumpfile, "ab");
 886   } while((dump == NULL) && ((error = errno) == EINTR));
 887   if(dump == NULL) {
 888     logmsg("[2] Error opening file %s error: %d %s",
 889            dumpfile, error, strerror(error));
 890     logmsg("Failed to write request input ");
 891     return;
 892   }
 893
 894   writeleft = totalsize;
 895   do {
 896     written = fwrite(&reqbuf[totalsize-writeleft],
 897                      1, writeleft, dump);
 898     if(got_exit_signal)
 899       goto storerequest_cleanup;
 900     if(written > 0)
 901       writeleft -= written;
 902   } while((writeleft > 0) && ((error = errno) == EINTR));
 903
 904   if(writeleft == 0)
 905     logmsg("Wrote request (%zu bytes) input to %s", totalsize, dumpfile);
 906   else if(writeleft > 0) {
 907     logmsg("Error writing file %s error: %d %s",
 908            dumpfile, error, strerror(error));
 909     logmsg("Wrote only (%zu bytes) of (%zu bytes) request input to %s",
 910            totalsize-writeleft, totalsize, dumpfile);
 911   }
 912
 913 storerequest_cleanup:
 914
 915   do {
 916     res = fclose(dump);
 917   } while(res && ((error = errno) == EINTR));
 918   if(res)
 919     logmsg("Error closing file %s error: %d %s",
 920            dumpfile, error, strerror(error));
 921 }
 922
 923 static void init_httprequest(struct httprequest *req)
 924 {
 925   /* Pipelining is already set, so do not initialize it here. Only initialize
 926      checkindex and offset if pipelining is not set, since in a pipeline they
 927      need to be inherited from the previous request. */
 928   if(!req->pipelining) {
 929     req->checkindex = 0;
 930     req->offset = 0;
 931   }
 932   req->testno = DOCNUMBER_NOTHING;
 933   req->partno = 0;
 934   req->connect_request = FALSE;
 935   req->open = TRUE;
 936   req->auth_req = FALSE;
 937   req->auth = FALSE;
 938   req->cl = 0;
 939   req->digest = FALSE;
 940   req->ntlm = FALSE;
 941   req->pipe = 0;
 942   req->skip = 0;
 943   req->writedelay = 0;
 944   req->rcmd = RCMD_NORMALREQ;
 945   req->prot_version = 0;
 946   req->callcount = 0;
 947   req->connect_port = 0;
 948   req->done_processing = 0;
 949   req->upgrade = 0;
 950   req->upgrade_request = 0;
 951 }
 952
 953 /* returns 1 if the connection should be serviced again immediately, 0 if there
 954    is no data waiting, or < 0 if it should be closed */
 955 static int get_request(curl_socket_t sock, struct httprequest *req)
 956 {
 957   int error;
 958   int fail = 0;
 959   char *reqbuf = req->reqbuf;
 960   ssize_t got = 0;
 961   int overflow = 0;
 962
 963   char *pipereq = NULL;
 964   size_t pipereq_length = 0;
 965
 966   if(req->pipelining) {
 967     pipereq = reqbuf + req->checkindex;
 968     pipereq_length = req->offset - req->checkindex;
 969
 970     /* Now that we've got the pipelining info we can reset the
 971        pipelining-related vars which were skipped in init_httprequest */
 972     req->pipelining = FALSE;
 973     req->checkindex = 0;
 974     req->offset = 0;
 975   }
 976
 977   if(req->offset >= REQBUFSIZ-1) {
 978     /* buffer is already full; do nothing */
 979     overflow = 1;
 980   }
 981   else {
 982     if(pipereq_length && pipereq) {
 983       memmove(reqbuf, pipereq, pipereq_length);
 984       got = curlx_uztosz(pipereq_length);
 985       pipereq_length = 0;
 986     }
 987     else {
 988       if(req->skip)
 989         /* we are instructed to not read the entire thing, so we make sure to
 990            only read what we're supposed to and NOT read the enire thing the
 991            client wants to send! */
 992         got = sread(sock, reqbuf + req->offset, req->cl);
 993       else
 994         got = sread(sock, reqbuf + req->offset, REQBUFSIZ-1 - req->offset);
 995     }
 996     if(got_exit_signal)
 997       return -1;
 998     if(got == 0) {
 999       logmsg("Connection closed by client");
1000       fail = 1;
1001     }
1002     else if(got < 0) {
1003       error = SOCKERRNO;
1004       if(EAGAIN == error || EWOULDBLOCK == error) {
1005         /* nothing to read at the moment */
1006         return 0;
1007       }
1008       logmsg("recv() returned error: (%d) %s", error, strerror(error));
1009       fail = 1;
1010     }
1011     if(fail) {
1012       /* dump the request received so far to the external file */
1013       reqbuf[req->offset] = '\0';
1014       storerequest(reqbuf, req->offset);
1015       return -1;
1016     }
1017
1018     logmsg("Read %zd bytes", got);
1019
1020     req->offset += (size_t)got;
1021     reqbuf[req->offset] = '\0';
1022
1023     req->done_processing = ProcessRequest(req);
1024     if(got_exit_signal)
1025       return -1;
1026     if(req->done_processing && req->pipe) {
1027       logmsg("Waiting for another piped request");
1028       req->done_processing = 0;
1029       req->pipe--;
1030     }
1031   }
1032
1033   if(overflow || (req->offset == REQBUFSIZ-1 && got > 0)) {
1034     logmsg("Request would overflow buffer, closing connection");
1035     /* dump request received so far to external file anyway */
1036     reqbuf[REQBUFSIZ-1] = '\0';
1037     fail = 1;
1038   }
1039   else if(req->offset > REQBUFSIZ-1) {
1040     logmsg("Request buffer overflow, closing connection");
1041     /* dump request received so far to external file anyway */
1042     reqbuf[REQBUFSIZ-1] = '\0';
1043     fail = 1;
1044   }
1045   else
1046     reqbuf[req->offset] = '\0';
1047
1048   /* at the end of a request dump it to an external file */
1049   if(fail || req->done_processing)
1050     storerequest(reqbuf, req->pipelining ? req->checkindex : req->offset);
1051   if(got_exit_signal)
1052     return -1;
1053
1054   return fail ? -1 : 1;
1055 }
1056
1057 /* returns -1 on failure */
1058 static int send_doc(curl_socket_t sock, struct httprequest *req)
1059 {
1060   ssize_t written;
1061   size_t count;
1062   const char *buffer;
1063   char *ptr = NULL;
1064   FILE *stream;
1065   char *cmd = NULL;
1066   size_t cmdsize = 0;
1067   FILE *dump;
1068   bool persistant = TRUE;
1069   bool sendfailure = FALSE;
1070   size_t responsesize;
1071   int error = 0;
1072   int res;
1073   const char *responsedump = is_proxy?RESPONSE_PROXY_DUMP:RESPONSE_DUMP;
1074   static char weare[256];
1075
1076   switch(req->rcmd) {
1077   default:
1078   case RCMD_NORMALREQ:
1079     break; /* continue with business as usual */
1080   case RCMD_STREAM:
1081 #define STREAMTHIS "a string to stream 01234567890\n"
1082     count = strlen(STREAMTHIS);
1083     for(;;) {
1084       written = swrite(sock, STREAMTHIS, count);
1085       if(got_exit_signal)
1086         return -1;
1087       if(written != (ssize_t)count) {
1088         logmsg("Stopped streaming");
1089         break;
1090       }
1091     }
1092     return -1;
1093   case RCMD_IDLE:
1094     /* Do nothing. Sit idle. Pretend it rains. */
1095     return 0;
1096   }
1097
1098   req->open = FALSE;
1099
1100   if(req->testno < 0) {
1101     size_t msglen;
1102     char msgbuf[64];
1103
1104     switch(req->testno) {
1105     case DOCNUMBER_QUIT:
1106       logmsg("Replying to QUIT");
1107       buffer = docquit;
1108       break;
1109     case DOCNUMBER_WERULEZ:
1110       /* we got a "friends?" question, reply back that we sure are */
1111       logmsg("Identifying ourselves as friends");
1112       snprintf(msgbuf, sizeof(msgbuf), "WE ROOLZ: %ld\r\n", (long)getpid());
1113       msglen = strlen(msgbuf);
1114       if(use_gopher)
1115         snprintf(weare, sizeof(weare), "%s", msgbuf);
1116       else
1117         snprintf(weare, sizeof(weare),
1118                  "HTTP/1.1 200 OK\r\nContent-Length: %zu\r\n\r\n%s",
1119                  msglen, msgbuf);
1120       buffer = weare;
1121       break;
1122     case DOCNUMBER_404:
1123     default:
1124       logmsg("Replying to with a 404");
1125       buffer = doc404;
1126       break;
1127     }
1128
1129     count = strlen(buffer);
1130   }
1131   else {
1132     char partbuf[80];
1133     char *filename = test2file(req->testno);
1134
1135     /* select the <data> tag for "normal" requests and the <connect> one
1136        for CONNECT requests (within the <reply> section) */
1137     const char *section = req->connect_request?"connect":"data";
1138
1139     if(req->partno)
1140       snprintf(partbuf, sizeof(partbuf), "%s%ld", section, req->partno);
1141     else
1142       snprintf(partbuf, sizeof(partbuf), "%s", section);
1143
1144     logmsg("Send response test%ld section <%s>", req->testno, partbuf);
1145
1146     stream = fopen(filename, "rb");
1147     if(!stream) {
1148       error = errno;
1149       logmsg("fopen() failed with error: %d %s", error, strerror(error));
1150       logmsg("  [3] Error opening file: %s", filename);
1151       return 0;
1152     }
1153     else {
1154       error = getpart(&ptr, &count, "reply", partbuf, stream);
1155       fclose(stream);
1156       if(error) {
1157         logmsg("getpart() failed with error: %d", error);
1158         return 0;
1159       }
1160       buffer = ptr;
1161     }
1162
1163     if(got_exit_signal) {
1164       free(ptr);
1165       return -1;
1166     }
1167
1168     /* re-open the same file again */
1169     stream = fopen(filename, "rb");
1170     if(!stream) {
1171       error = errno;
1172       logmsg("fopen() failed with error: %d %s", error, strerror(error));
1173       logmsg("  [4] Error opening file: %s", filename);
1174       free(ptr);
1175       return 0;
1176     }
1177     else {
1178       /* get the custom server control "commands" */
1179       error = getpart(&cmd, &cmdsize, "reply", "postcmd", stream);
1180       fclose(stream);
1181       if(error) {
1182         logmsg("getpart() failed with error: %d", error);
1183         free(ptr);
1184         return 0;
1185       }
1186     }
1187   }
1188
1189   if(got_exit_signal) {
1190     free(ptr);
1191     free(cmd);
1192     return -1;
1193   }
1194
1195   /* If the word 'swsclose' is present anywhere in the reply chunk, the
1196      connection will be closed after the data has been sent to the requesting
1197      client... */
1198   if(strstr(buffer, "swsclose") || !count) {
1199     persistant = FALSE;
1200     logmsg("connection close instruction \"swsclose\" found in response");
1201   }
1202   if(strstr(buffer, "swsbounce")) {
1203     prevbounce = TRUE;
1204     logmsg("enable \"swsbounce\" in the next request");
1205   }
1206   else
1207     prevbounce = FALSE;
1208
1209   dump = fopen(responsedump, "ab");
1210   if(!dump) {
1211     error = errno;
1212     logmsg("fopen() failed with error: %d %s", error, strerror(error));
1213     logmsg("  [5] Error opening file: %s", responsedump);
1214     free(ptr);
1215     free(cmd);
1216     return -1;
1217   }
1218
1219   responsesize = count;
1220   do {
1221     /* Ok, we send no more than N bytes at a time, just to make sure that
1222        larger chunks are split up so that the client will need to do multiple
1223        recv() calls to get it and thus we exercise that code better */
1224     size_t num = count;
1225     if(num > 20)
1226       num = 20;
1227
1228     retry:
1229     written = swrite(sock, buffer, num);
1230     if(written < 0) {
1231       if((EWOULDBLOCK == SOCKERRNO) || (EAGAIN == SOCKERRNO)) {
1232         wait_ms(10);
1233         goto retry;
1234       }
1235       sendfailure = TRUE;
1236       break;
1237     }
1238
1239     /* write to file as well */
1240     fwrite(buffer, 1, (size_t)written, dump);
1241
1242     count -= written;
1243     buffer += written;
1244
1245     if(req->writedelay) {
1246       int quarters = req->writedelay * 4;
1247       logmsg("Pausing %d seconds", req->writedelay);
1248       while((quarters > 0) && !got_exit_signal) {
1249         quarters--;
1250         wait_ms(250);
1251       }
1252     }
1253   } while((count > 0) && !got_exit_signal);
1254
1255   do {
1256     res = fclose(dump);
1257   } while(res && ((error = errno) == EINTR));
1258   if(res)
1259     logmsg("Error closing file %s error: %d %s",
1260            responsedump, error, strerror(error));
1261
1262   if(got_exit_signal) {
1263     free(ptr);
1264     free(cmd);
1265     return -1;
1266   }
1267
1268   if(sendfailure) {
1269     logmsg("Sending response failed. Only (%zu bytes) of (%zu bytes) "
1270            "were sent",
1271            responsesize-count, responsesize);
1272     free(ptr);
1273     free(cmd);
1274     return -1;
1275   }
1276
1277   logmsg("Response sent (%zu bytes) and written to %s",
1278          responsesize, responsedump);
1279   free(ptr);
1280
1281   if(cmdsize > 0) {
1282     char command[32];
1283     int quarters;
1284     int num;
1285     ptr = cmd;
1286     do {
1287       if(2 == sscanf(ptr, "%31s %d", command, &num)) {
1288         if(!strcmp("wait", command)) {
1289           logmsg("Told to sleep for %d seconds", num);
1290           quarters = num * 4;
1291           while((quarters > 0) && !got_exit_signal) {
1292             quarters--;
1293             res = wait_ms(250);
1294             if(res) {
1295               /* should not happen */
1296               error = errno;
1297               logmsg("wait_ms() failed with error: (%d) %s",
1298                      error, strerror(error));
1299               break;
1300             }
1301           }
1302           if(!quarters)
1303             logmsg("Continuing after sleeping %d seconds", num);
1304         }
1305         else
1306           logmsg("Unknown command in reply command section");
1307       }
1308       ptr = strchr(ptr, '\n');
1309       if(ptr)
1310         ptr++;
1311       else
1312         ptr = NULL;
1313     } while(ptr && *ptr);
1314   }
1315   free(cmd);
1316   req->open = use_gopher?FALSE:persistant;
1317
1318   prevtestno = req->testno;
1319   prevpartno = req->partno;
1320
1321   return 0;
1322 }
1323
1324 static curl_socket_t connect_to(const char *ipaddr, unsigned short port)
1325 {
1326   srvr_sockaddr_union_t serveraddr;
1327   curl_socket_t serverfd;
1328   int error;
1329   int rc = 0;
1330   const char *op_br = "";
1331   const char *cl_br = "";
1332
1333 #ifdef ENABLE_IPV6
1334   if(socket_domain == AF_INET6) {
1335     op_br = "[";
1336     cl_br = "]";
1337   }
1338 #endif
1339
1340   if(!ipaddr)
1341     return CURL_SOCKET_BAD;
1342
1343   logmsg("about to connect to %s%s%s:%hu",
1344          op_br, ipaddr, cl_br, port);
1345
1346
1347   serverfd = socket(socket_domain, SOCK_STREAM, 0);
1348   if(CURL_SOCKET_BAD == serverfd) {
1349     error = SOCKERRNO;
1350     logmsg("Error creating socket for server connection: (%d) %s",
1351            error, strerror(error));
1352     return CURL_SOCKET_BAD;
1353   }
1354
1355 #ifdef TCP_NODELAY
1356   if(socket_domain_is_ip()) {
1357     /* Disable the Nagle algorithm */
1358     curl_socklen_t flag = 1;
1359     if(0 != setsockopt(serverfd, IPPROTO_TCP, TCP_NODELAY,
1360                        (void *)&flag, sizeof(flag)))
1361       logmsg("====> TCP_NODELAY for server connection failed");
1362   }
1363 #endif
1364
1365   switch(socket_domain) {
1366   case AF_INET:
1367     memset(&serveraddr.sa4, 0, sizeof(serveraddr.sa4));
1368     serveraddr.sa4.sin_family = AF_INET;
1369     serveraddr.sa4.sin_port = htons(port);
1370     if(Curl_inet_pton(AF_INET, ipaddr, &serveraddr.sa4.sin_addr) < 1) {
1371       logmsg("Error inet_pton failed AF_INET conversion of '%s'", ipaddr);
1372       sclose(serverfd);
1373       return CURL_SOCKET_BAD;
1374     }
1375
1376     rc = connect(serverfd, &serveraddr.sa, sizeof(serveraddr.sa4));
1377     break;
1378 #ifdef ENABLE_IPV6
1379   case AF_INET6:
1380     memset(&serveraddr.sa6, 0, sizeof(serveraddr.sa6));
1381     serveraddr.sa6.sin6_family = AF_INET6;
1382     serveraddr.sa6.sin6_port = htons(port);
1383     if(Curl_inet_pton(AF_INET6, ipaddr, &serveraddr.sa6.sin6_addr) < 1) {
1384       logmsg("Error inet_pton failed AF_INET6 conversion of '%s'", ipaddr);
1385       sclose(serverfd);
1386       return CURL_SOCKET_BAD;
1387     }
1388
1389     rc = connect(serverfd, &serveraddr.sa, sizeof(serveraddr.sa6));
1390     break;
1391 #endif /* ENABLE_IPV6 */
1392 #ifdef USE_UNIX_SOCKETS
1393   case AF_UNIX:
1394     logmsg("Proxying through Unix socket is not (yet?) supported.");
1395     return CURL_SOCKET_BAD;
1396 #endif /* USE_UNIX_SOCKETS */
1397   }
1398
1399   if(got_exit_signal) {
1400     sclose(serverfd);
1401     return CURL_SOCKET_BAD;
1402   }
1403
1404   if(rc) {
1405     error = SOCKERRNO;
1406     logmsg("Error connecting to server port %hu: (%d) %s",
1407            port, error, strerror(error));
1408     sclose(serverfd);
1409     return CURL_SOCKET_BAD;
1410   }
1411
1412   logmsg("connected fine to %s%s%s:%hu, now tunnel",
1413          op_br, ipaddr, cl_br, port);
1414
1415   return serverfd;
1416 }
1417
1418 /*
1419  * A CONNECT has been received, a CONNECT response has been sent.
1420  *
1421  * This function needs to connect to the server, and then pass data between
1422  * the client and the server back and forth until the connection is closed by
1423  * either end.
1424  *
1425  * When doing FTP through a CONNECT proxy, we expect that the data connection
1426  * will be setup while the first connect is still being kept up. Therefore we
1427  * must accept a new connection and deal with it appropriately.
1428  */
1429
1430 #define data_or_ctrl(x) ((x)?"DATA":"CTRL")
1431
1432 #define CTRL  0
1433 #define DATA  1
1434
1435 static void http_connect(curl_socket_t *infdp,
1436                          curl_socket_t rootfd,
1437                          const char *ipaddr,
1438                          unsigned short ipport)
1439 {
1440   curl_socket_t serverfd[2] = {CURL_SOCKET_BAD, CURL_SOCKET_BAD};
1441   curl_socket_t clientfd[2] = {CURL_SOCKET_BAD, CURL_SOCKET_BAD};
1442   ssize_t toc[2] = {0, 0}; /* number of bytes to client */
1443   ssize_t tos[2] = {0, 0}; /* number of bytes to server */
1444   char readclient[2][256];
1445   char readserver[2][256];
1446   bool poll_client_rd[2] = { TRUE, TRUE };
1447   bool poll_server_rd[2] = { TRUE, TRUE };
1448   bool poll_client_wr[2] = { TRUE, TRUE };
1449   bool poll_server_wr[2] = { TRUE, TRUE };
1450   bool primary = FALSE;
1451   bool secondary = FALSE;
1452   int max_tunnel_idx; /* CTRL or DATA */
1453   int loop;
1454   int i;
1455   int timeout_count = 0;
1456
1457   /* primary tunnel client endpoint already connected */
1458   clientfd[CTRL] = *infdp;
1459
1460   /* Sleep here to make sure the client reads CONNECT response's
1461      'end of headers' separate from the server data that follows.
1462      This is done to prevent triggering libcurl known bug #39. */
1463   for(loop = 2; (loop > 0) && !got_exit_signal; loop--)
1464     wait_ms(250);
1465   if(got_exit_signal)
1466     goto http_connect_cleanup;
1467
1468   serverfd[CTRL] = connect_to(ipaddr, ipport);
1469   if(serverfd[CTRL] == CURL_SOCKET_BAD)
1470     goto http_connect_cleanup;
1471
1472   /* Primary tunnel socket endpoints are now connected. Tunnel data back and
1473      forth over the primary tunnel until client or server breaks the primary
1474      tunnel, simultaneously allowing establishment, operation and teardown of
1475      a secondary tunnel that may be used for passive FTP data connection. */
1476
1477   max_tunnel_idx = CTRL;
1478   primary = TRUE;
1479
1480   while(!got_exit_signal) {
1481
1482     fd_set input;
1483     fd_set output;
1484     struct timeval timeout = {1, 0}; /* 1000 ms */
1485     ssize_t rc;
1486     curl_socket_t maxfd = (curl_socket_t)-1;
1487
1488     FD_ZERO(&input);
1489     FD_ZERO(&output);
1490
1491     if((clientfd[DATA] == CURL_SOCKET_BAD) &&
1492        (serverfd[DATA] == CURL_SOCKET_BAD) &&
1493        poll_client_rd[CTRL] && poll_client_wr[CTRL] &&
1494        poll_server_rd[CTRL] && poll_server_wr[CTRL]) {
1495       /* listener socket is monitored to allow client to establish
1496          secondary tunnel only when this tunnel is not established
1497          and primary one is fully operational */
1498       FD_SET(rootfd, &input);
1499       maxfd = rootfd;
1500     }
1501
1502     /* set tunnel sockets to wait for */
1503     for(i = 0; i <= max_tunnel_idx; i++) {
1504       /* client side socket monitoring */
1505       if(clientfd[i] != CURL_SOCKET_BAD) {
1506         if(poll_client_rd[i]) {
1507           /* unless told not to do so, monitor readability */
1508           FD_SET(clientfd[i], &input);
1509           if(clientfd[i] > maxfd)
1510             maxfd = clientfd[i];
1511         }
1512         if(poll_client_wr[i] && toc[i]) {
1513           /* unless told not to do so, monitor writability
1514              if there is data ready to be sent to client */
1515           FD_SET(clientfd[i], &output);
1516           if(clientfd[i] > maxfd)
1517             maxfd = clientfd[i];
1518         }
1519       }
1520       /* server side socket monitoring */
1521       if(serverfd[i] != CURL_SOCKET_BAD) {
1522         if(poll_server_rd[i]) {
1523           /* unless told not to do so, monitor readability */
1524           FD_SET(serverfd[i], &input);
1525           if(serverfd[i] > maxfd)
1526             maxfd = serverfd[i];
1527         }
1528         if(poll_server_wr[i] && tos[i]) {
1529           /* unless told not to do so, monitor writability
1530              if there is data ready to be sent to server */
1531           FD_SET(serverfd[i], &output);
1532           if(serverfd[i] > maxfd)
1533             maxfd = serverfd[i];
1534         }
1535       }
1536     }
1537     if(got_exit_signal)
1538       break;
1539
1540     rc = select((int)maxfd + 1, &input, &output, NULL, &timeout);
1541
1542     if(rc > 0) {
1543       /* socket action */
1544       bool tcp_fin_wr;
1545       timeout_count = 0;
1546
1547       if(got_exit_signal)
1548         break;
1549
1550       tcp_fin_wr = FALSE;
1551
1552       /* ---------------------------------------------------------- */
1553
1554       /* passive mode FTP may establish a secondary tunnel */
1555       if((clientfd[DATA] == CURL_SOCKET_BAD) &&
1556          (serverfd[DATA] == CURL_SOCKET_BAD) && FD_ISSET(rootfd, &input)) {
1557         /* a new connection on listener socket (most likely from client) */
1558         curl_socket_t datafd = accept(rootfd, NULL, NULL);
1559         if(datafd != CURL_SOCKET_BAD) {
1560           struct httprequest req2;
1561           int err = 0;
1562           memset(&req2, 0, sizeof(req2));
1563           logmsg("====> Client connect DATA");
1564 #ifdef TCP_NODELAY
1565           if(socket_domain_is_ip()) {
1566             /* Disable the Nagle algorithm */
1567             curl_socklen_t flag = 1;
1568             if(0 != setsockopt(datafd, IPPROTO_TCP, TCP_NODELAY,
1569                                (void *)&flag, sizeof(flag)))
1570               logmsg("====> TCP_NODELAY for client DATA connection failed");
1571           }
1572 #endif
1573           req2.pipelining = FALSE;
1574           init_httprequest(&req2);
1575           while(!req2.done_processing) {
1576             err = get_request(datafd, &req2);
1577             if(err < 0) {
1578               /* this socket must be closed, done or not */
1579               break;
1580             }
1581           }
1582
1583           /* skip this and close the socket if err < 0 */
1584           if(err >= 0) {
1585             err = send_doc(datafd, &req2);
1586             if(!err && req2.connect_request) {
1587               /* sleep to prevent triggering libcurl known bug #39. */
1588               for(loop = 2; (loop > 0) && !got_exit_signal; loop--)
1589                 wait_ms(250);
1590               if(!got_exit_signal) {
1591                 /* connect to the server */
1592                 serverfd[DATA] = connect_to(ipaddr, req2.connect_port);
1593                 if(serverfd[DATA] != CURL_SOCKET_BAD) {
1594                   /* secondary tunnel established, now we have two
1595                      connections */
1596                   poll_client_rd[DATA] = TRUE;
1597                   poll_client_wr[DATA] = TRUE;
1598                   poll_server_rd[DATA] = TRUE;
1599                   poll_server_wr[DATA] = TRUE;
1600                   max_tunnel_idx = DATA;
1601                   secondary = TRUE;
1602                   toc[DATA] = 0;
1603                   tos[DATA] = 0;
1604                   clientfd[DATA] = datafd;
1605                   datafd = CURL_SOCKET_BAD;
1606                 }
1607               }
1608             }
1609           }
1610           if(datafd != CURL_SOCKET_BAD) {
1611             /* secondary tunnel not established */
1612             shutdown(datafd, SHUT_RDWR);
1613             sclose(datafd);
1614           }
1615         }
1616         if(got_exit_signal)
1617           break;
1618       }
1619
1620       /* ---------------------------------------------------------- */
1621
1622       /* react to tunnel endpoint readable/writable notifications */
1623       for(i = 0; i <= max_tunnel_idx; i++) {
1624         size_t len;
1625         if(clientfd[i] != CURL_SOCKET_BAD) {
1626           len = sizeof(readclient[i]) - tos[i];
1627           if(len && FD_ISSET(clientfd[i], &input)) {
1628             /* read from client */
1629             rc = sread(clientfd[i], &readclient[i][tos[i]], len);
1630             if(rc <= 0) {
1631               logmsg("[%s] got %zd, STOP READING client", data_or_ctrl(i), rc);
1632               shutdown(clientfd[i], SHUT_RD);
1633               poll_client_rd[i] = FALSE;
1634             }
1635             else {
1636               logmsg("[%s] READ %zd bytes from client", data_or_ctrl(i), rc);
1637               logmsg("[%s] READ \"%s\"", data_or_ctrl(i),
1638                      data_to_hex(&readclient[i][tos[i]], rc));
1639               tos[i] += rc;
1640             }
1641           }
1642         }
1643         if(serverfd[i] != CURL_SOCKET_BAD) {
1644           len = sizeof(readserver[i])-toc[i];
1645           if(len && FD_ISSET(serverfd[i], &input)) {
1646             /* read from server */
1647             rc = sread(serverfd[i], &readserver[i][toc[i]], len);
1648             if(rc <= 0) {
1649               logmsg("[%s] got %zd, STOP READING server", data_or_ctrl(i), rc);
1650               shutdown(serverfd[i], SHUT_RD);
1651               poll_server_rd[i] = FALSE;
1652             }
1653             else {
1654               logmsg("[%s] READ %zd bytes from server", data_or_ctrl(i), rc);
1655               logmsg("[%s] READ \"%s\"", data_or_ctrl(i),
1656                      data_to_hex(&readserver[i][toc[i]], rc));
1657               toc[i] += rc;
1658             }
1659           }
1660         }
1661         if(clientfd[i] != CURL_SOCKET_BAD) {
1662           if(toc[i] && FD_ISSET(clientfd[i], &output)) {
1663             /* write to client */
1664             rc = swrite(clientfd[i], readserver[i], toc[i]);
1665             if(rc <= 0) {
1666               logmsg("[%s] got %zd, STOP WRITING client", data_or_ctrl(i), rc);
1667               shutdown(clientfd[i], SHUT_WR);
1668               poll_client_wr[i] = FALSE;
1669               tcp_fin_wr = TRUE;
1670             }
1671             else {
1672               logmsg("[%s] SENT %zd bytes to client", data_or_ctrl(i), rc);
1673               logmsg("[%s] SENT \"%s\"", data_or_ctrl(i),
1674                      data_to_hex(readserver[i], rc));
1675               if(toc[i] - rc)
1676                 memmove(&readserver[i][0], &readserver[i][rc], toc[i]-rc);
1677               toc[i] -= rc;
1678             }
1679           }
1680         }
1681         if(serverfd[i] != CURL_SOCKET_BAD) {
1682           if(tos[i] && FD_ISSET(serverfd[i], &output)) {
1683             /* write to server */
1684             rc = swrite(serverfd[i], readclient[i], tos[i]);
1685             if(rc <= 0) {
1686               logmsg("[%s] got %zd, STOP WRITING server", data_or_ctrl(i), rc);
1687               shutdown(serverfd[i], SHUT_WR);
1688               poll_server_wr[i] = FALSE;
1689               tcp_fin_wr = TRUE;
1690             }
1691             else {
1692               logmsg("[%s] SENT %zd bytes to server", data_or_ctrl(i), rc);
1693               logmsg("[%s] SENT \"%s\"", data_or_ctrl(i),
1694                      data_to_hex(readclient[i], rc));
1695               if(tos[i] - rc)
1696                 memmove(&readclient[i][0], &readclient[i][rc], tos[i]-rc);
1697               tos[i] -= rc;
1698             }
1699           }
1700         }
1701       }
1702       if(got_exit_signal)
1703         break;
1704
1705       /* ---------------------------------------------------------- */
1706
1707       /* endpoint read/write disabling, endpoint closing and tunnel teardown */
1708       for(i = 0; i <= max_tunnel_idx; i++) {
1709         for(loop = 2; loop > 0; loop--) {
1710           /* loop twice to satisfy condition interdependencies without
1711              having to await select timeout or another socket event */
1712           if(clientfd[i] != CURL_SOCKET_BAD) {
1713             if(poll_client_rd[i] && !poll_server_wr[i]) {
1714               logmsg("[%s] DISABLED READING client", data_or_ctrl(i));
1715               shutdown(clientfd[i], SHUT_RD);
1716               poll_client_rd[i] = FALSE;
1717             }
1718             if(poll_client_wr[i] && !poll_server_rd[i] && !toc[i]) {
1719               logmsg("[%s] DISABLED WRITING client", data_or_ctrl(i));
1720               shutdown(clientfd[i], SHUT_WR);
1721               poll_client_wr[i] = FALSE;
1722               tcp_fin_wr = TRUE;
1723             }
1724           }
1725           if(serverfd[i] != CURL_SOCKET_BAD) {
1726             if(poll_server_rd[i] && !poll_client_wr[i]) {
1727               logmsg("[%s] DISABLED READING server", data_or_ctrl(i));
1728               shutdown(serverfd[i], SHUT_RD);
1729               poll_server_rd[i] = FALSE;
1730             }
1731             if(poll_server_wr[i] && !poll_client_rd[i] && !tos[i]) {
1732               logmsg("[%s] DISABLED WRITING server", data_or_ctrl(i));
1733               shutdown(serverfd[i], SHUT_WR);
1734               poll_server_wr[i] = FALSE;
1735               tcp_fin_wr = TRUE;
1736             }
1737           }
1738         }
1739       }
1740
1741       if(tcp_fin_wr)
1742         /* allow kernel to place FIN bit packet on the wire */
1743         wait_ms(250);
1744
1745       /* socket clearing */
1746       for(i = 0; i <= max_tunnel_idx; i++) {
1747         for(loop = 2; loop > 0; loop--) {
1748           if(clientfd[i] != CURL_SOCKET_BAD) {
1749             if(!poll_client_wr[i] && !poll_client_rd[i]) {
1750               logmsg("[%s] CLOSING client socket", data_or_ctrl(i));
1751               sclose(clientfd[i]);
1752               clientfd[i] = CURL_SOCKET_BAD;
1753               if(serverfd[i] == CURL_SOCKET_BAD) {
1754                 logmsg("[%s] ENDING", data_or_ctrl(i));
1755                 if(i == DATA)
1756                   secondary = FALSE;
1757                 else
1758                   primary = FALSE;
1759               }
1760             }
1761           }
1762           if(serverfd[i] != CURL_SOCKET_BAD) {
1763             if(!poll_server_wr[i] && !poll_server_rd[i]) {
1764               logmsg("[%s] CLOSING server socket", data_or_ctrl(i));
1765               sclose(serverfd[i]);
1766               serverfd[i] = CURL_SOCKET_BAD;
1767               if(clientfd[i] == CURL_SOCKET_BAD) {
1768                 logmsg("[%s] ENDING", data_or_ctrl(i));
1769                 if(i == DATA)
1770                   secondary = FALSE;
1771                 else
1772                   primary = FALSE;
1773               }
1774             }
1775           }
1776         }
1777       }
1778
1779       /* ---------------------------------------------------------- */
1780
1781       max_tunnel_idx = secondary ? DATA : CTRL;
1782
1783       if(!primary)
1784         /* exit loop upon primary tunnel teardown */
1785         break;
1786
1787     } /* (rc > 0) */
1788     else {
1789       timeout_count++;
1790       if(timeout_count > 5) {
1791         logmsg("CONNECT proxy timeout after %d idle seconds!", timeout_count);
1792         break;
1793       }
1794     }
1795   }
1796
1797 http_connect_cleanup:
1798
1799   for(i = DATA; i >= CTRL; i--) {
1800     if(serverfd[i] != CURL_SOCKET_BAD) {
1801       logmsg("[%s] CLOSING server socket (cleanup)", data_or_ctrl(i));
1802       shutdown(serverfd[i], SHUT_RDWR);
1803       sclose(serverfd[i]);
1804     }
1805     if(clientfd[i] != CURL_SOCKET_BAD) {
1806       logmsg("[%s] CLOSING client socket (cleanup)", data_or_ctrl(i));
1807       shutdown(clientfd[i], SHUT_RDWR);
1808       sclose(clientfd[i]);
1809     }
1810     if((serverfd[i] != CURL_SOCKET_BAD) ||
1811        (clientfd[i] != CURL_SOCKET_BAD)) {
1812       logmsg("[%s] ABORTING", data_or_ctrl(i));
1813     }
1814   }
1815
1816   *infdp = CURL_SOCKET_BAD;
1817 }
1818
1819 static void http2(struct httprequest *req)
1820 {
1821   (void)req;
1822   logmsg("switched to http2");
1823   /* left to implement */
1824 }
1825
1826
1827 /* returns a socket handle, or 0 if there are no more waiting sockets,
1828    or < 0 if there was an error */
1829 static curl_socket_t accept_connection(curl_socket_t sock)
1830 {
1831   curl_socket_t msgsock = CURL_SOCKET_BAD;
1832   int error;
1833   int flag = 1;
1834
1835   if(MAX_SOCKETS == num_sockets) {
1836     logmsg("Too many open sockets!");
1837     return CURL_SOCKET_BAD;
1838   }
1839
1840   msgsock = accept(sock, NULL, NULL);
1841
1842   if(got_exit_signal) {
1843     if(CURL_SOCKET_BAD != msgsock)
1844       sclose(msgsock);
1845     return CURL_SOCKET_BAD;
1846   }
1847
1848   if(CURL_SOCKET_BAD == msgsock) {
1849     error = SOCKERRNO;
1850     if(EAGAIN == error || EWOULDBLOCK == error) {
1851       /* nothing to accept */
1852       return 0;
1853     }
1854     logmsg("MAJOR ERROR: accept() failed with error: (%d) %s",
1855            error, strerror(error));
1856     return CURL_SOCKET_BAD;
1857   }
1858
1859   if(0 != curlx_nonblock(msgsock, TRUE)) {
1860     error = SOCKERRNO;
1861     logmsg("curlx_nonblock failed with error: (%d) %s",
1862            error, strerror(error));
1863     sclose(msgsock);
1864     return CURL_SOCKET_BAD;
1865   }
1866
1867   if(0 != setsockopt(msgsock, SOL_SOCKET, SO_KEEPALIVE,
1868                      (void *)&flag, sizeof(flag))) {
1869     error = SOCKERRNO;
1870     logmsg("setsockopt(SO_KEEPALIVE) failed with error: (%d) %s",
1871            error, strerror(error));
1872     sclose(msgsock);
1873     return CURL_SOCKET_BAD;
1874   }
1875
1876   /*
1877   ** As soon as this server accepts a connection from the test harness it
1878   ** must set the server logs advisor read lock to indicate that server
1879   ** logs should not be read until this lock is removed by this server.
1880   */
1881
1882   if(!serverlogslocked)
1883     set_advisor_read_lock(SERVERLOGS_LOCK);
1884   serverlogslocked += 1;
1885
1886   logmsg("====> Client connect");
1887
1888   all_sockets[num_sockets] = msgsock;
1889   num_sockets += 1;
1890
1891 #ifdef TCP_NODELAY
1892   if(socket_domain_is_ip()) {
1893     /*
1894      * Disable the Nagle algorithm to make it easier to send out a large
1895      * response in many small segments to torture the clients more.
1896      */
1897     if(0 != setsockopt(msgsock, IPPROTO_TCP, TCP_NODELAY,
1898                        (void *)&flag, sizeof(flag)))
1899       logmsg("====> TCP_NODELAY failed");
1900   }
1901 #endif
1902
1903   return msgsock;
1904 }
1905
1906 /* returns 1 if the connection should be serviced again immediately, 0 if there
1907    is no data waiting, or < 0 if it should be closed */
1908 static int service_connection(curl_socket_t msgsock, struct httprequest *req,
1909                               curl_socket_t listensock,
1910                               const char *connecthost)
1911 {
1912   if(got_exit_signal)
1913     return -1;
1914
1915   while(!req->done_processing) {
1916     int rc = get_request(msgsock, req);
1917     if(rc <= 0) {
1918       /* Nothing further to read now, possibly because the socket was closed */
1919       return rc;
1920     }
1921   }
1922
1923   if(prevbounce) {
1924     /* bounce treatment requested */
1925     if((req->testno == prevtestno) &&
1926        (req->partno == prevpartno)) {
1927       req->partno++;
1928       logmsg("BOUNCE part number to %ld", req->partno);
1929     }
1930     else {
1931       prevbounce = FALSE;
1932       prevtestno = -1;
1933       prevpartno = -1;
1934     }
1935   }
1936
1937   send_doc(msgsock, req);
1938   if(got_exit_signal)
1939     return -1;
1940
1941   if(req->testno < 0) {
1942     logmsg("special request received, no persistency");
1943     return -1;
1944   }
1945   if(!req->open) {
1946     logmsg("instructed to close connection after server-reply");
1947     return -1;
1948   }
1949
1950   if(req->connect_request) {
1951     /* a CONNECT request, setup and talk the tunnel */
1952     if(!is_proxy) {
1953       logmsg("received CONNECT but isn't running as proxy!");
1954       return 1;
1955     }
1956     else {
1957       http_connect(&msgsock, listensock, connecthost, req->connect_port);
1958       return -1;
1959     }
1960   }
1961
1962   if(req->upgrade_request) {
1963     /* an upgrade request, switch to http2 here */
1964     http2(req);
1965     return -1;
1966   }
1967
1968   /* if we got a CONNECT, loop and get another request as well! */
1969
1970   if(req->open) {
1971     logmsg("=> persistant connection request ended, awaits new request\n");
1972     return 1;
1973   }
1974
1975   return -1;
1976 }
1977
1978 int main(int argc, char *argv[])
1979 {
1980   srvr_sockaddr_union_t me;
1981   curl_socket_t sock = CURL_SOCKET_BAD;
1982   int wrotepidfile = 0;
1983   int flag;
1984   unsigned short port = DEFAULT_PORT;
1985 #ifdef USE_UNIX_SOCKETS
1986   const char *unix_socket = NULL;
1987   bool unlink_socket = false;
1988 #endif
1989   const char *pidname = ".http.pid";
1990   struct httprequest req;
1991   int rc = 0;
1992   int error;
1993   int arg = 1;
1994   long pid;
1995   const char *connecthost = "127.0.0.1";
1996   const char *socket_type = "IPv4";
1997   char port_str[11];
1998   const char *location_str = port_str;
1999
2000   /* a default CONNECT port is basically pointless but still ... */
2001   size_t socket_idx;
2002
2003   memset(&req, 0, sizeof(req));
2004
2005   while(argc>arg) {
2006     if(!strcmp("--version", argv[arg])) {
2007       puts("sws IPv4"
2008 #ifdef ENABLE_IPV6
2009              "/IPv6"
2010 #endif
2011 #ifdef USE_UNIX_SOCKETS
2012              "/unix"
2013 #endif
2014           );
2015       return 0;
2016     }
2017     else if(!strcmp("--pidfile", argv[arg])) {
2018       arg++;
2019       if(argc>arg)
2020         pidname = argv[arg++];
2021     }
2022     else if(!strcmp("--logfile", argv[arg])) {
2023       arg++;
2024       if(argc>arg)
2025         serverlogfile = argv[arg++];
2026     }
2027     else if(!strcmp("--gopher", argv[arg])) {
2028       arg++;
2029       use_gopher = TRUE;
2030       end_of_headers = "\r\n"; /* gopher style is much simpler */
2031     }
2032     else if(!strcmp("--ipv4", argv[arg])) {
2033       socket_type = "IPv4";
2034       socket_domain = AF_INET;
2035       location_str = port_str;
2036       arg++;
2037     }
2038     else if(!strcmp("--ipv6", argv[arg])) {
2039 #ifdef ENABLE_IPV6
2040       socket_type = "IPv6";
2041       socket_domain = AF_INET6;
2042       location_str = port_str;
2043 #endif
2044       arg++;
2045     }
2046     else if(!strcmp("--unix-socket", argv[arg])) {
2047       arg++;
2048       if(argc>arg) {
2049 #ifdef USE_UNIX_SOCKETS
2050         unix_socket = argv[arg];
2051         if(strlen(unix_socket) >= sizeof(me.sau.sun_path)) {
2052           fprintf(stderr, "sws: socket path must be shorter than %zu chars\n",
2053                   sizeof(me.sau.sun_path));
2054           return 0;
2055         }
2056         socket_type = "unix";
2057         socket_domain = AF_UNIX;
2058         location_str = unix_socket;
2059 #endif
2060         arg++;
2061       }
2062     }
2063     else if(!strcmp("--port", argv[arg])) {
2064       arg++;
2065       if(argc>arg) {
2066         char *endptr;
2067         unsigned long ulnum = strtoul(argv[arg], &endptr, 10);
2068         if((endptr != argv[arg] + strlen(argv[arg])) ||
2069            (ulnum < 1025UL) || (ulnum > 65535UL)) {
2070           fprintf(stderr, "sws: invalid --port argument (%s)\n",
2071                   argv[arg]);
2072           return 0;
2073         }
2074         port = curlx_ultous(ulnum);
2075         arg++;
2076       }
2077     }
2078     else if(!strcmp("--srcdir", argv[arg])) {
2079       arg++;
2080       if(argc>arg) {
2081         path = argv[arg];
2082         arg++;
2083       }
2084     }
2085     else if(!strcmp("--connect", argv[arg])) {
2086       /* The connect host IP number that the proxy will connect to no matter
2087          what the client asks for, but also use this as a hint that we run as
2088          a proxy and do a few different internal choices */
2089       arg++;
2090       if(argc>arg) {
2091         connecthost = argv[arg];
2092         arg++;
2093         is_proxy = TRUE;
2094         logmsg("Run as proxy, CONNECT to host %s", connecthost);
2095       }
2096     }
2097     else {
2098       puts("Usage: sws [option]\n"
2099            " --version\n"
2100            " --logfile [file]\n"
2101            " --pidfile [file]\n"
2102            " --ipv4\n"
2103            " --ipv6\n"
2104            " --unix-socket [file]\n"
2105            " --port [port]\n"
2106            " --srcdir [path]\n"
2107            " --connect [ip4-addr]\n"
2108            " --gopher");
2109       return 0;
2110     }
2111   }
2112
2113   snprintf(port_str, sizeof(port_str), "port %hu", port);
2114
2115 #ifdef WIN32
2116   win32_init();
2117   atexit(win32_cleanup);
2118 #endif
2119
2120   install_signal_handlers();
2121
2122   pid = (long)getpid();
2123
2124   sock = socket(socket_domain, SOCK_STREAM, 0);
2125
2126   all_sockets[0] = sock;
2127   num_sockets = 1;
2128
2129   if(CURL_SOCKET_BAD == sock) {
2130     error = SOCKERRNO;
2131     logmsg("Error creating socket: (%d) %s",
2132            error, strerror(error));
2133     goto sws_cleanup;
2134   }
2135
2136   flag = 1;
2137   if(0 != setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
2138                      (void *)&flag, sizeof(flag))) {
2139     error = SOCKERRNO;
2140     logmsg("setsockopt(SO_REUSEADDR) failed with error: (%d) %s",
2141            error, strerror(error));
2142     goto sws_cleanup;
2143   }
2144   if(0 != curlx_nonblock(sock, TRUE)) {
2145     error = SOCKERRNO;
2146     logmsg("curlx_nonblock failed with error: (%d) %s",
2147            error, strerror(error));
2148     goto sws_cleanup;
2149   }
2150
2151   switch(socket_domain) {
2152   case AF_INET:
2153     memset(&me.sa4, 0, sizeof(me.sa4));
2154     me.sa4.sin_family = AF_INET;
2155     me.sa4.sin_addr.s_addr = INADDR_ANY;
2156     me.sa4.sin_port = htons(port);
2157     rc = bind(sock, &me.sa, sizeof(me.sa4));
2158     break;
2159 #ifdef ENABLE_IPV6
2160   case AF_INET6:
2161     memset(&me.sa6, 0, sizeof(me.sa6));
2162     me.sa6.sin6_family = AF_INET6;
2163     me.sa6.sin6_addr = in6addr_any;
2164     me.sa6.sin6_port = htons(port);
2165     rc = bind(sock, &me.sa, sizeof(me.sa6));
2166     break;
2167 #endif /* ENABLE_IPV6 */
2168 #ifdef USE_UNIX_SOCKETS
2169   case AF_UNIX:
2170     memset(&me.sau, 0, sizeof(me.sau));
2171     me.sau.sun_family = AF_UNIX;
2172     strncpy(me.sau.sun_path, unix_socket, sizeof(me.sau.sun_path));
2173     rc = bind(sock, &me.sa, sizeof(me.sau));
2174     if(0 != rc && errno == EADDRINUSE) {
2175       struct stat statbuf;
2176       /* socket already exists. Perhaps it is stale? */
2177       int unixfd = socket(AF_UNIX, SOCK_STREAM, 0);
2178       if(CURL_SOCKET_BAD == unixfd) {
2179         error = SOCKERRNO;
2180         logmsg("Error binding socket, failed to create socket at %s: (%d) %s",
2181                unix_socket, error, strerror(error));
2182         goto sws_cleanup;
2183       }
2184       /* check whether the server is alive */
2185       rc = connect(unixfd, &me.sa, sizeof(me.sau));
2186       error = errno;
2187       close(unixfd);
2188       if(ECONNREFUSED != error) {
2189         logmsg("Error binding socket, failed to connect to %s: (%d) %s",
2190                unix_socket, error, strerror(error));
2191         goto sws_cleanup;
2192       }
2193       /* socket server is not alive, now check if it was actually a socket.
2194        * Systems which have Unix sockets will also have lstat */
2195       rc = lstat(unix_socket, &statbuf);
2196       if(0 != rc) {
2197         logmsg("Error binding socket, failed to stat %s: (%d) %s",
2198                unix_socket, errno, strerror(errno));
2199         goto sws_cleanup;
2200       }
2201       if((statbuf.st_mode & S_IFSOCK) != S_IFSOCK) {
2202         logmsg("Error binding socket, failed to stat %s: (%d) %s",
2203                unix_socket, error, strerror(error));
2204         goto sws_cleanup;
2205       }
2206       /* dead socket, cleanup and retry bind */
2207       rc = unlink(unix_socket);
2208       if(0 != rc) {
2209         logmsg("Error binding socket, failed to unlink %s: (%d) %s",
2210                unix_socket, errno, strerror(errno));
2211         goto sws_cleanup;
2212       }
2213       /* stale socket is gone, retry bind */
2214       rc = bind(sock, &me.sa, sizeof(me.sau));
2215     }
2216     break;
2217 #endif /* USE_UNIX_SOCKETS */
2218   }
2219   if(0 != rc) {
2220     error = SOCKERRNO;
2221     logmsg("Error binding socket on %s: (%d) %s",
2222            location_str, error, strerror(error));
2223     goto sws_cleanup;
2224   }
2225
2226   logmsg("Running %s %s version on %s",
2227          use_gopher?"GOPHER":"HTTP", socket_type, location_str);
2228
2229   /* start accepting connections */
2230   rc = listen(sock, 5);
2231   if(0 != rc) {
2232     error = SOCKERRNO;
2233     logmsg("listen() failed with error: (%d) %s",
2234            error, strerror(error));
2235     goto sws_cleanup;
2236   }
2237
2238 #ifdef USE_UNIX_SOCKETS
2239   /* listen succeeds, so let's assume a valid listening Unix socket */
2240   unlink_socket = true;
2241 #endif
2242
2243   /*
2244   ** As soon as this server writes its pid file the test harness will
2245   ** attempt to connect to this server and initiate its verification.
2246   */
2247
2248   wrotepidfile = write_pidfile(pidname);
2249   if(!wrotepidfile)
2250     goto sws_cleanup;
2251
2252   /* initialization of httprequest struct is done before get_request(), but
2253      the pipelining struct field must be initialized previously to FALSE
2254      every time a new connection arrives. */
2255
2256   req.pipelining = FALSE;
2257   init_httprequest(&req);
2258
2259   for(;;) {
2260     fd_set input;
2261     fd_set output;
2262     struct timeval timeout = {0, 250000L}; /* 250 ms */
2263     curl_socket_t maxfd = (curl_socket_t)-1;
2264
2265     /* Clear out closed sockets */
2266     for(socket_idx = num_sockets - 1; socket_idx >= 1; --socket_idx) {
2267       if(CURL_SOCKET_BAD == all_sockets[socket_idx]) {
2268         char *dst = (char *) (all_sockets + socket_idx);
2269         char *src = (char *) (all_sockets + socket_idx + 1);
2270         char *end = (char *) (all_sockets + num_sockets);
2271         memmove(dst, src, end - src);
2272         num_sockets -= 1;
2273       }
2274     }
2275
2276     if(got_exit_signal)
2277       goto sws_cleanup;
2278
2279     /* Set up for select */
2280     FD_ZERO(&input);
2281     FD_ZERO(&output);
2282
2283     for(socket_idx = 0; socket_idx < num_sockets; ++socket_idx) {
2284       /* Listen on all sockets */
2285       FD_SET(all_sockets[socket_idx], &input);
2286       if(all_sockets[socket_idx] > maxfd)
2287         maxfd = all_sockets[socket_idx];
2288     }
2289
2290     if(got_exit_signal)
2291       goto sws_cleanup;
2292
2293     rc = select((int)maxfd + 1, &input, &output, NULL, &timeout);
2294     if(rc < 0) {
2295       error = SOCKERRNO;
2296       logmsg("select() failed with error: (%d) %s",
2297              error, strerror(error));
2298       goto sws_cleanup;
2299     }
2300
2301     if(got_exit_signal)
2302       goto sws_cleanup;
2303
2304     if(rc == 0) {
2305       /* Timed out - try again */
2306       continue;
2307     }
2308
2309     /* Check if the listening socket is ready to accept */
2310     if(FD_ISSET(all_sockets[0], &input)) {
2311       /* Service all queued connections */
2312       curl_socket_t msgsock;
2313       do {
2314         msgsock = accept_connection(sock);
2315         logmsg("accept_connection %d returned %d", sock, msgsock);
2316         if(CURL_SOCKET_BAD == msgsock)
2317           goto sws_cleanup;
2318       } while(msgsock > 0);
2319     }
2320
2321     /* Service all connections that are ready */
2322     for(socket_idx = 1; socket_idx < num_sockets; ++socket_idx) {
2323       if(FD_ISSET(all_sockets[socket_idx], &input)) {
2324         if(got_exit_signal)
2325           goto sws_cleanup;
2326
2327         /* Service this connection until it has nothing available */
2328         do {
2329           rc = service_connection(all_sockets[socket_idx], &req, sock,
2330                                   connecthost);
2331           if(got_exit_signal)
2332             goto sws_cleanup;
2333
2334           if(rc < 0) {
2335             logmsg("====> Client disconnect %d", req.connmon);
2336
2337             if(req.connmon) {
2338               const char *keepopen = "[DISCONNECT]\n";
2339               storerequest(keepopen, strlen(keepopen));
2340             }
2341
2342             if(!req.open)
2343               /* When instructed to close connection after server-reply we
2344                  wait a very small amount of time before doing so. If this
2345                  is not done client might get an ECONNRESET before reading
2346                  a single byte of server-reply. */
2347               wait_ms(50);
2348
2349             if(all_sockets[socket_idx] != CURL_SOCKET_BAD) {
2350               sclose(all_sockets[socket_idx]);
2351               all_sockets[socket_idx] = CURL_SOCKET_BAD;
2352             }
2353
2354             serverlogslocked -= 1;
2355             if(!serverlogslocked)
2356               clear_advisor_read_lock(SERVERLOGS_LOCK);
2357
2358             if(req.testno == DOCNUMBER_QUIT)
2359               goto sws_cleanup;
2360           }
2361
2362           /* Reset the request, unless we're still in the middle of reading */
2363           if(rc != 0)
2364             init_httprequest(&req);
2365         } while(rc > 0);
2366       }
2367     }
2368
2369     if(got_exit_signal)
2370       goto sws_cleanup;
2371   }
2372
2373 sws_cleanup:
2374
2375   for(socket_idx = 1; socket_idx < num_sockets; ++socket_idx)
2376     if((all_sockets[socket_idx] != sock) &&
2377      (all_sockets[socket_idx] != CURL_SOCKET_BAD))
2378       sclose(all_sockets[socket_idx]);
2379
2380   if(sock != CURL_SOCKET_BAD)
2381     sclose(sock);
2382
2383 #ifdef USE_UNIX_SOCKETS
2384   if(unlink_socket && socket_domain == AF_UNIX) {
2385     rc = unlink(unix_socket);
2386     logmsg("unlink(%s) = %d (%s)", unix_socket, rc, strerror(rc));
2387   }
2388 #endif
2389
2390   if(got_exit_signal)
2391     logmsg("signalled to die");
2392
2393   if(wrotepidfile)
2394     unlink(pidname);
2395
2396   if(serverlogslocked) {
2397     serverlogslocked = 0;
2398     clear_advisor_read_lock(SERVERLOGS_LOCK);
2399   }
2400
2401   restore_signal_handlers();
2402
2403   if(got_exit_signal) {
2404     logmsg("========> %s sws (%s pid: %ld) exits with signal (%d)",
2405            socket_type, location_str, pid, exit_signal);
2406     /*
2407      * To properly set the return status of the process we
2408      * must raise the same signal SIGINT or SIGTERM that we
2409      * caught and let the old handler take care of it.
2410      */
2411     raise(exit_signal);
2412   }
2413
2414   logmsg("========> sws quits");
2415   return 0;
2416 }
2417