luna - curl/tests/server/sws.c

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