[Feature][ZXW-88]merge P50 version
Only Configure: No
Affected branch: master
Affected module: unknown
Is it affected on both ZXIC and MTK: only ZXIC
Self-test: Yes
Doc Update: No
Change-Id: I34667719d9e0e7e29e8e4368848601cde0a48408
diff --git a/ap/lib/libcurl/curl-7.86.0/tests/server/sws.c b/ap/lib/libcurl/curl-7.86.0/tests/server/sws.c
new file mode 100755
index 0000000..55c1c1d
--- /dev/null
+++ b/ap/lib/libcurl/curl-7.86.0/tests/server/sws.c
@@ -0,0 +1,2387 @@
+/***************************************************************************
+ * _ _ ____ _
+ * Project ___| | | | _ \| |
+ * / __| | | | |_) | |
+ * | (__| |_| | _ <| |___
+ * \___|\___/|_| \_\_____|
+ *
+ * Copyright (C) 1998 - 2022, Daniel Stenberg, <daniel@haxx.se>, et al.
+ *
+ * This software is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution. The terms
+ * are also available at https://curl.se/docs/copyright.html.
+ *
+ * You may opt to use, copy, modify, merge, publish, distribute and/or sell
+ * copies of the Software, and permit persons to whom the Software is
+ * furnished to do so, under the terms of the COPYING file.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ * SPDX-License-Identifier: curl
+ *
+ ***************************************************************************/
+#include "server_setup.h"
+
+/* sws.c: simple (silly?) web server
+
+ This code was originally graciously donated to the project by Juergen
+ Wilke. Thanks a bunch!
+
+ */
+
+#ifdef HAVE_SIGNAL_H
+#include <signal.h>
+#endif
+#ifdef HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+#ifdef HAVE_NETINET_IN6_H
+#include <netinet/in6.h>
+#endif
+#ifdef HAVE_ARPA_INET_H
+#include <arpa/inet.h>
+#endif
+#ifdef HAVE_NETDB_H
+#include <netdb.h>
+#endif
+#ifdef HAVE_NETINET_TCP_H
+#include <netinet/tcp.h> /* for TCP_NODELAY */
+#endif
+
+#define ENABLE_CURLX_PRINTF
+/* make the curlx header define all printf() functions to use the curlx_*
+ versions instead */
+#include "curlx.h" /* from the private lib dir */
+#include "getpart.h"
+#include "inet_pton.h"
+#include "util.h"
+#include "server_sockaddr.h"
+
+/* include memdebug.h last */
+#include "memdebug.h"
+
+#ifdef USE_WINSOCK
+#undef EINTR
+#define EINTR 4 /* errno.h value */
+#undef EAGAIN
+#define EAGAIN 11 /* errno.h value */
+#undef ERANGE
+#define ERANGE 34 /* errno.h value */
+#endif
+
+static enum {
+ socket_domain_inet = AF_INET
+#ifdef ENABLE_IPV6
+ , socket_domain_inet6 = AF_INET6
+#endif
+#ifdef USE_UNIX_SOCKETS
+ , socket_domain_unix = AF_UNIX
+#endif
+} socket_domain = AF_INET;
+static bool use_gopher = FALSE;
+static int serverlogslocked = 0;
+static bool is_proxy = FALSE;
+
+#define REQBUFSIZ (2*1024*1024)
+
+#define MAX_SLEEP_TIME_MS 250
+
+static long prevtestno = -1; /* previous test number we served */
+static long prevpartno = -1; /* previous part number we served */
+static bool prevbounce = FALSE; /* instructs the server to increase the part
+ number for a test in case the identical
+ testno+partno request shows up again */
+
+#define RCMD_NORMALREQ 0 /* default request, use the tests file normally */
+#define RCMD_IDLE 1 /* told to sit idle */
+#define RCMD_STREAM 2 /* told to stream */
+
+struct httprequest {
+ char reqbuf[REQBUFSIZ]; /* buffer area for the incoming request */
+ bool connect_request; /* if a CONNECT */
+ unsigned short connect_port; /* the port number CONNECT used */
+ size_t checkindex; /* where to start checking of the request */
+ size_t offset; /* size of the incoming request */
+ long testno; /* test number found in the request */
+ long partno; /* part number found in the request */
+ bool open; /* keep connection open info, as found in the request */
+ bool auth_req; /* authentication required, don't wait for body unless
+ there's an Authorization header */
+ bool auth; /* Authorization header present in the incoming request */
+ size_t cl; /* Content-Length of the incoming request */
+ bool digest; /* Authorization digest header found */
+ bool ntlm; /* Authorization ntlm header found */
+ int writedelay; /* if non-zero, delay this number of milliseconds between
+ writes in the response */
+ int skip; /* if non-zero, the server is instructed to not read this
+ many bytes from a PUT/POST request. Ie the client sends N
+ bytes said in Content-Length, but the server only reads N
+ - skip bytes. */
+ int rcmd; /* doing a special command, see defines above */
+ int prot_version; /* HTTP version * 10 */
+ int callcount; /* times ProcessRequest() gets called */
+ bool skipall; /* skip all incoming data */
+ bool noexpect; /* refuse Expect: (don't read the body) */
+ bool connmon; /* monitor the state of the connection, log disconnects */
+ bool upgrade; /* test case allows upgrade */
+ bool upgrade_request; /* upgrade request found and allowed */
+ bool close; /* similar to swsclose in response: close connection after
+ response is sent */
+ int done_processing;
+};
+
+#define MAX_SOCKETS 1024
+
+static curl_socket_t all_sockets[MAX_SOCKETS];
+static size_t num_sockets = 0;
+
+static int ProcessRequest(struct httprequest *req);
+static void storerequest(const char *reqbuf, size_t totalsize);
+
+#define DEFAULT_PORT 8999
+
+#ifndef DEFAULT_LOGFILE
+#define DEFAULT_LOGFILE "log/sws.log"
+#endif
+
+const char *serverlogfile = DEFAULT_LOGFILE;
+
+#define SWSVERSION "curl test suite HTTP server/0.1"
+
+#define REQUEST_DUMP "log/server.input"
+#define RESPONSE_DUMP "log/server.response"
+
+/* when told to run as proxy, we store the logs in different files so that
+ they can co-exist with the same program running as a "server" */
+#define REQUEST_PROXY_DUMP "log/proxy.input"
+#define RESPONSE_PROXY_DUMP "log/proxy.response"
+
+/* file in which additional instructions may be found */
+#define DEFAULT_CMDFILE "log/ftpserver.cmd"
+const char *cmdfile = DEFAULT_CMDFILE;
+
+/* very-big-path support */
+#define MAXDOCNAMELEN 140000
+#define MAXDOCNAMELEN_TXT "139999"
+
+#define REQUEST_KEYWORD_SIZE 256
+#define REQUEST_KEYWORD_SIZE_TXT "255"
+
+#define CMD_AUTH_REQUIRED "auth_required"
+
+/* 'idle' means that it will accept the request fine but never respond
+ any data. Just keep the connection alive. */
+#define CMD_IDLE "idle"
+
+/* 'stream' means to send a never-ending stream of data */
+#define CMD_STREAM "stream"
+
+/* 'connection-monitor' will output when a server/proxy connection gets
+ disconnected as for some cases it is important that it gets done at the
+ proper point - like with NTLM */
+#define CMD_CONNECTIONMONITOR "connection-monitor"
+
+/* upgrade to http2/websocket/xxxx */
+#define CMD_UPGRADE "upgrade"
+
+/* close connection */
+#define CMD_SWSCLOSE "swsclose"
+
+/* deny Expect: requests */
+#define CMD_NOEXPECT "no-expect"
+
+#define END_OF_HEADERS "\r\n\r\n"
+
+enum {
+ DOCNUMBER_NOTHING = -4,
+ DOCNUMBER_QUIT = -3,
+ DOCNUMBER_WERULEZ = -2,
+ DOCNUMBER_404 = -1
+};
+
+static const char *end_of_headers = END_OF_HEADERS;
+
+/* sent as reply to a QUIT */
+static const char *docquit =
+"HTTP/1.1 200 Goodbye" END_OF_HEADERS;
+
+/* send back this on 404 file not found */
+static const char *doc404 = "HTTP/1.1 404 Not Found\r\n"
+ "Server: " SWSVERSION "\r\n"
+ "Connection: close\r\n"
+ "Content-Type: text/html"
+ END_OF_HEADERS
+ "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n"
+ "<HTML><HEAD>\n"
+ "<TITLE>404 Not Found</TITLE>\n"
+ "</HEAD><BODY>\n"
+ "<H1>Not Found</H1>\n"
+ "The requested URL was not found on this server.\n"
+ "<P><HR><ADDRESS>" SWSVERSION "</ADDRESS>\n" "</BODY></HTML>\n";
+
+/* work around for handling trailing headers */
+static int already_recv_zeroed_chunk = FALSE;
+
+/* returns true if the current socket is an IP one */
+static bool socket_domain_is_ip(void)
+{
+ switch(socket_domain) {
+ case AF_INET:
+#ifdef ENABLE_IPV6
+ case AF_INET6:
+#endif
+ return true;
+ default:
+ /* case AF_UNIX: */
+ return false;
+ }
+}
+
+/* parse the file on disk that might have a test number for us */
+static int parse_cmdfile(struct httprequest *req)
+{
+ FILE *f = fopen(cmdfile, FOPEN_READTEXT);
+ if(f) {
+ int testnum = DOCNUMBER_NOTHING;
+ char buf[256];
+ while(fgets(buf, sizeof(buf), f)) {
+ if(1 == sscanf(buf, "Testnum %d", &testnum)) {
+ logmsg("[%s] cmdfile says testnum %d", cmdfile, testnum);
+ req->testno = testnum;
+ }
+ }
+ fclose(f);
+ }
+ return 0;
+}
+
+/* based on the testno, parse the correct server commands */
+static int parse_servercmd(struct httprequest *req)
+{
+ FILE *stream;
+ int error;
+
+ stream = test2fopen(req->testno);
+ req->close = FALSE;
+ req->connmon = FALSE;
+
+ if(!stream) {
+ error = errno;
+ logmsg("fopen() failed with error: %d %s", error, strerror(error));
+ logmsg(" Couldn't open test file %ld", req->testno);
+ req->open = FALSE; /* closes connection */
+ return 1; /* done */
+ }
+ else {
+ char *orgcmd = NULL;
+ char *cmd = NULL;
+ size_t cmdsize = 0;
+ int num = 0;
+
+ /* get the custom server control "commands" */
+ error = getpart(&orgcmd, &cmdsize, "reply", "servercmd", stream);
+ fclose(stream);
+ if(error) {
+ logmsg("getpart() failed with error: %d", error);
+ req->open = FALSE; /* closes connection */
+ return 1; /* done */
+ }
+
+ cmd = orgcmd;
+ while(cmd && cmdsize) {
+ char *check;
+
+ if(!strncmp(CMD_AUTH_REQUIRED, cmd, strlen(CMD_AUTH_REQUIRED))) {
+ logmsg("instructed to require authorization header");
+ req->auth_req = TRUE;
+ }
+ else if(!strncmp(CMD_IDLE, cmd, strlen(CMD_IDLE))) {
+ logmsg("instructed to idle");
+ req->rcmd = RCMD_IDLE;
+ req->open = TRUE;
+ }
+ else if(!strncmp(CMD_STREAM, cmd, strlen(CMD_STREAM))) {
+ logmsg("instructed to stream");
+ req->rcmd = RCMD_STREAM;
+ }
+ else if(!strncmp(CMD_CONNECTIONMONITOR, cmd,
+ strlen(CMD_CONNECTIONMONITOR))) {
+ logmsg("enabled connection monitoring");
+ req->connmon = TRUE;
+ }
+ else if(!strncmp(CMD_UPGRADE, cmd, strlen(CMD_UPGRADE))) {
+ logmsg("enabled upgrade");
+ req->upgrade = TRUE;
+ }
+ else if(!strncmp(CMD_SWSCLOSE, cmd, strlen(CMD_SWSCLOSE))) {
+ logmsg("swsclose: close this connection after response");
+ req->close = TRUE;
+ }
+ else if(1 == sscanf(cmd, "skip: %d", &num)) {
+ logmsg("instructed to skip this number of bytes %d", num);
+ req->skip = num;
+ }
+ else if(!strncmp(CMD_NOEXPECT, cmd, strlen(CMD_NOEXPECT))) {
+ logmsg("instructed to reject Expect: 100-continue");
+ req->noexpect = TRUE;
+ }
+ else if(1 == sscanf(cmd, "writedelay: %d", &num)) {
+ logmsg("instructed to delay %d msecs between packets", num);
+ req->writedelay = num;
+ }
+ else {
+ logmsg("Unknown <servercmd> instruction found: %s", cmd);
+ }
+ /* try to deal with CRLF or just LF */
+ check = strchr(cmd, '\r');
+ if(!check)
+ check = strchr(cmd, '\n');
+
+ if(check) {
+ /* get to the letter following the newline */
+ while((*check == '\r') || (*check == '\n'))
+ check++;
+
+ if(!*check)
+ /* if we reached a zero, get out */
+ break;
+ cmd = check;
+ }
+ else
+ break;
+ }
+ free(orgcmd);
+ }
+
+ return 0; /* OK! */
+}
+
+static int ProcessRequest(struct httprequest *req)
+{
+ char *line = &req->reqbuf[req->checkindex];
+ bool chunked = FALSE;
+ static char request[REQUEST_KEYWORD_SIZE];
+ char logbuf[456];
+ int prot_major = 0;
+ int prot_minor = 0;
+ char *end = strstr(line, end_of_headers);
+
+ req->callcount++;
+
+ logmsg("Process %d bytes request%s", req->offset,
+ req->callcount > 1?" [CONTINUED]":"");
+
+ /* try to figure out the request characteristics as soon as possible, but
+ only once! */
+
+ if(use_gopher &&
+ (req->testno == DOCNUMBER_NOTHING) &&
+ !strncmp("/verifiedserver", line, 15)) {
+ logmsg("Are-we-friendly question received");
+ req->testno = DOCNUMBER_WERULEZ;
+ return 1; /* done */
+ }
+
+ else if(req->testno == DOCNUMBER_NOTHING) {
+ char *http;
+ bool fine = FALSE;
+ char *httppath = NULL;
+ size_t npath = 0; /* httppath length */
+
+ if(sscanf(line,
+ "%" REQUEST_KEYWORD_SIZE_TXT"s ", request)) {
+ http = strstr(line + strlen(request), "HTTP/");
+
+ if(http && sscanf(http, "HTTP/%d.%d",
+ &prot_major,
+ &prot_minor) == 2) {
+ /* between the request keyword and HTTP/ there's a path */
+ httppath = line + strlen(request);
+ npath = http - httppath;
+
+ /* trim leading spaces */
+ while(npath && ISSPACE(*httppath)) {
+ httppath++;
+ npath--;
+ }
+ /* trim ending spaces */
+ while(npath && ISSPACE(httppath[npath - 1])) {
+ npath--;
+ }
+ if(npath)
+ fine = TRUE;
+ }
+ }
+
+ if(fine) {
+ char *ptr;
+
+ req->prot_version = prot_major*10 + prot_minor;
+
+ /* find the last slash */
+ ptr = &httppath[npath];
+ while(ptr >= httppath) {
+ if(*ptr == '/')
+ break;
+ ptr--;
+ }
+
+ /* get the number after it */
+ if(*ptr == '/') {
+ if((npath + strlen(request)) < 400)
+ msnprintf(logbuf, sizeof(logbuf), "Got request: %s %.*s HTTP/%d.%d",
+ request, npath, httppath, prot_major, prot_minor);
+ else
+ msnprintf(logbuf, sizeof(logbuf), "Got a *HUGE* request HTTP/%d.%d",
+ prot_major, prot_minor);
+ logmsg("%s", logbuf);
+
+ if(!strncmp("/verifiedserver", ptr, 15)) {
+ logmsg("Are-we-friendly question received");
+ req->testno = DOCNUMBER_WERULEZ;
+ return 1; /* done */
+ }
+
+ if(!strncmp("/quit", ptr, 5)) {
+ logmsg("Request-to-quit received");
+ req->testno = DOCNUMBER_QUIT;
+ return 1; /* done */
+ }
+
+ ptr++; /* skip the slash */
+
+ req->testno = strtol(ptr, &ptr, 10);
+
+ if(req->testno > 10000) {
+ req->partno = req->testno % 10000;
+ req->testno /= 10000;
+ }
+ else
+ req->partno = 0;
+
+ if(req->testno) {
+
+ msnprintf(logbuf, sizeof(logbuf), "Serve test number %ld part %ld",
+ req->testno, req->partno);
+ logmsg("%s", logbuf);
+ }
+ else {
+ logmsg("No test number in path");
+ req->testno = DOCNUMBER_NOTHING;
+ }
+
+ }
+
+ if(req->testno == DOCNUMBER_NOTHING) {
+ /* didn't find any in the first scan, try alternative test case
+ number placements */
+ static char doc[MAXDOCNAMELEN];
+ if(sscanf(req->reqbuf, "CONNECT %" MAXDOCNAMELEN_TXT "s HTTP/%d.%d",
+ doc, &prot_major, &prot_minor) == 3) {
+ char *portp = NULL;
+
+ msnprintf(logbuf, sizeof(logbuf),
+ "Received a CONNECT %s HTTP/%d.%d request",
+ doc, prot_major, prot_minor);
+ logmsg("%s", logbuf);
+
+ req->connect_request = TRUE;
+
+ if(req->prot_version == 10)
+ req->open = FALSE; /* HTTP 1.0 closes connection by default */
+
+ if(doc[0] == '[') {
+ char *p = &doc[1];
+ unsigned long part = 0;
+ /* scan through the hexgroups and store the value of the last group
+ in the 'part' variable and use as test case number!! */
+ while(*p && (ISXDIGIT(*p) || (*p == ':') || (*p == '.'))) {
+ char *endp;
+ part = strtoul(p, &endp, 16);
+ if(ISXDIGIT(*p))
+ p = endp;
+ else
+ p++;
+ }
+ if(*p != ']')
+ logmsg("Invalid CONNECT IPv6 address format");
+ else if(*(p + 1) != ':')
+ logmsg("Invalid CONNECT IPv6 port format");
+ else
+ portp = p + 1;
+
+ req->testno = part;
+ }
+ else
+ portp = strchr(doc, ':');
+
+ if(portp && (*(portp + 1) != '\0') && ISDIGIT(*(portp + 1))) {
+ unsigned long ulnum = strtoul(portp + 1, NULL, 10);
+ if(!ulnum || (ulnum > 65535UL))
+ logmsg("Invalid CONNECT port received");
+ else
+ req->connect_port = curlx_ultous(ulnum);
+
+ }
+ logmsg("Port number: %d, test case number: %ld",
+ req->connect_port, req->testno);
+ }
+ }
+
+ if(req->testno == DOCNUMBER_NOTHING)
+ /* might get the test number */
+ parse_cmdfile(req);
+
+ if(req->testno == DOCNUMBER_NOTHING) {
+ logmsg("Did not find test number in PATH");
+ req->testno = DOCNUMBER_404;
+ }
+ else
+ parse_servercmd(req);
+ }
+ else if((req->offset >= 3)) {
+ unsigned char *l = (unsigned char *)line;
+ logmsg("** Unusual request. Starts with %02x %02x %02x (%c%c%c)",
+ l[0], l[1], l[2], l[0], l[1], l[2]);
+ }
+ }
+
+ if(!end) {
+ /* we don't have a complete request yet! */
+ logmsg("request not complete yet");
+ return 0; /* not complete yet */
+ }
+ logmsg("- request found to be complete (%d)", req->testno);
+
+ if(req->testno == DOCNUMBER_NOTHING) {
+ /* check for a Testno: header with the test case number */
+ char *testno = strstr(line, "\nTestno: ");
+ if(testno) {
+ req->testno = strtol(&testno[9], NULL, 10);
+ logmsg("Found test number %d in Testno: header!", req->testno);
+ }
+ else {
+ logmsg("No Testno: header");
+ }
+ }
+
+ /* find and parse <servercmd> for this test */
+ parse_servercmd(req);
+
+ if(use_gopher) {
+ /* when using gopher we cannot check the request until the entire
+ thing has been received */
+ char *ptr;
+
+ /* find the last slash in the line */
+ ptr = strrchr(line, '/');
+
+ if(ptr) {
+ ptr++; /* skip the slash */
+
+ /* skip all non-numericals following the slash */
+ while(*ptr && !ISDIGIT(*ptr))
+ ptr++;
+
+ req->testno = strtol(ptr, &ptr, 10);
+
+ if(req->testno > 10000) {
+ req->partno = req->testno % 10000;
+ req->testno /= 10000;
+ }
+ else
+ req->partno = 0;
+
+ msnprintf(logbuf, sizeof(logbuf),
+ "Requested GOPHER test number %ld part %ld",
+ req->testno, req->partno);
+ logmsg("%s", logbuf);
+ }
+ }
+
+ /* **** Persistence ****
+ *
+ * If the request is a HTTP/1.0 one, we close the connection unconditionally
+ * when we're done.
+ *
+ * If the request is a HTTP/1.1 one, we MUST check for a "Connection:"
+ * header that might say "close". If it does, we close a connection when
+ * this request is processed. Otherwise, we keep the connection alive for X
+ * seconds.
+ */
+
+ do {
+ if(got_exit_signal)
+ return 1; /* done */
+
+ if((req->cl == 0) && strncasecompare("Content-Length:", line, 15)) {
+ /* If we don't ignore content-length, we read it and we read the whole
+ request including the body before we return. If we've been told to
+ ignore the content-length, we will return as soon as all headers
+ have been received */
+ char *endptr;
+ char *ptr = line + 15;
+ unsigned long clen = 0;
+ while(*ptr && ISSPACE(*ptr))
+ ptr++;
+ endptr = ptr;
+ errno = 0;
+ clen = strtoul(ptr, &endptr, 10);
+ if((ptr == endptr) || !ISSPACE(*endptr) || (ERANGE == errno)) {
+ /* this assumes that a zero Content-Length is valid */
+ logmsg("Found invalid Content-Length: (%s) in the request", ptr);
+ req->open = FALSE; /* closes connection */
+ return 1; /* done */
+ }
+ if(req->skipall)
+ req->cl = 0;
+ else
+ req->cl = clen - req->skip;
+
+ logmsg("Found Content-Length: %lu in the request", clen);
+ if(req->skip)
+ logmsg("... but will abort after %zu bytes", req->cl);
+ }
+ else if(strncasecompare("Transfer-Encoding: chunked", line,
+ strlen("Transfer-Encoding: chunked"))) {
+ /* chunked data coming in */
+ chunked = TRUE;
+ }
+ else if(req->noexpect &&
+ strncasecompare("Expect: 100-continue", line,
+ strlen("Expect: 100-continue"))) {
+ if(req->cl)
+ req->cl = 0;
+ req->skipall = TRUE;
+ logmsg("Found Expect: 100-continue, ignore body");
+ }
+
+ if(chunked) {
+ if(strstr(req->reqbuf, "\r\n0\r\n\r\n")) {
+ /* end of chunks reached */
+ return 1; /* done */
+ }
+ else if(strstr(req->reqbuf, "\r\n0\r\n")) {
+ char *last_crlf_char = strstr(req->reqbuf, "\r\n\r\n");
+ while(TRUE) {
+ if(!strstr(last_crlf_char + 4, "\r\n\r\n"))
+ break;
+ last_crlf_char = strstr(last_crlf_char + 4, "\r\n\r\n");
+ }
+ if(last_crlf_char &&
+ last_crlf_char > strstr(req->reqbuf, "\r\n0\r\n"))
+ return 1;
+ already_recv_zeroed_chunk = TRUE;
+ return 0;
+ }
+ else if(already_recv_zeroed_chunk && strstr(req->reqbuf, "\r\n\r\n"))
+ return 1;
+ else
+ return 0; /* not done */
+ }
+
+ line = strchr(line, '\n');
+ if(line)
+ line++;
+
+ } while(line);
+
+ if(!req->auth && strstr(req->reqbuf, "Authorization:")) {
+ req->auth = TRUE; /* Authorization: header present! */
+ if(req->auth_req)
+ logmsg("Authorization header found, as required");
+ }
+
+ if(strstr(req->reqbuf, "Authorization: Negotiate")) {
+ /* Negotiate iterations */
+ static long prev_testno = -1;
+ static long prev_partno = -1;
+ logmsg("Negotiate: prev_testno: %d, prev_partno: %d",
+ prev_testno, prev_partno);
+ if(req->testno != prev_testno) {
+ prev_testno = req->testno;
+ prev_partno = req->partno;
+ }
+ prev_partno += 1;
+ req->partno = prev_partno;
+ }
+ else if(!req->digest && strstr(req->reqbuf, "Authorization: Digest")) {
+ /* If the client is passing this Digest-header, we set the part number
+ to 1000. Not only to spice up the complexity of this, but to make
+ Digest stuff to work in the test suite. */
+ req->partno += 1000;
+ req->digest = TRUE; /* header found */
+ logmsg("Received Digest request, sending back data %ld", req->partno);
+ }
+ else if(!req->ntlm &&
+ strstr(req->reqbuf, "Authorization: NTLM TlRMTVNTUAAD")) {
+ /* If the client is passing this type-3 NTLM header */
+ req->partno += 1002;
+ req->ntlm = TRUE; /* NTLM found */
+ logmsg("Received NTLM type-3, sending back data %ld", req->partno);
+ if(req->cl) {
+ logmsg(" Expecting %zu POSTed bytes", req->cl);
+ }
+ }
+ else if(!req->ntlm &&
+ strstr(req->reqbuf, "Authorization: NTLM TlRMTVNTUAAB")) {
+ /* If the client is passing this type-1 NTLM header */
+ req->partno += 1001;
+ req->ntlm = TRUE; /* NTLM found */
+ logmsg("Received NTLM type-1, sending back data %ld", req->partno);
+ }
+ else if((req->partno >= 1000) &&
+ strstr(req->reqbuf, "Authorization: Basic")) {
+ /* If the client is passing this Basic-header and the part number is
+ already >=1000, we add 1 to the part number. This allows simple Basic
+ authentication negotiation to work in the test suite. */
+ req->partno += 1;
+ logmsg("Received Basic request, sending back data %ld", req->partno);
+ }
+ if(strstr(req->reqbuf, "Connection: close"))
+ req->open = FALSE; /* close connection after this request */
+
+ if(req->open &&
+ req->prot_version >= 11 &&
+ req->reqbuf + req->offset > end + strlen(end_of_headers) &&
+ !req->cl &&
+ (!strncmp(req->reqbuf, "GET", strlen("GET")) ||
+ !strncmp(req->reqbuf, "HEAD", strlen("HEAD")))) {
+ /* If we have a persistent connection, HTTP version >= 1.1
+ and GET/HEAD request, enable pipelining. */
+ req->checkindex = (end - req->reqbuf) + strlen(end_of_headers);
+ }
+
+ /* If authentication is required and no auth was provided, end now. This
+ makes the server NOT wait for PUT/POST data and you can then make the
+ test case send a rejection before any such data has been sent. Test case
+ 154 uses this.*/
+ if(req->auth_req && !req->auth) {
+ logmsg("Return early due to auth requested by none provided");
+ return 1; /* done */
+ }
+
+ if(req->upgrade && strstr(req->reqbuf, "Upgrade:")) {
+ /* we allow upgrade and there was one! */
+ logmsg("Found Upgrade: in request and allow it");
+ req->upgrade_request = TRUE;
+ return 0; /* not done */
+ }
+
+ if(req->cl > 0) {
+ if(req->cl <= req->offset - (end - req->reqbuf) - strlen(end_of_headers))
+ return 1; /* done */
+ else
+ return 0; /* not complete yet */
+ }
+
+ return 1; /* done */
+}
+
+/* store the entire request in a file */
+static void storerequest(const char *reqbuf, size_t totalsize)
+{
+ int res;
+ int error = 0;
+ size_t written;
+ size_t writeleft;
+ FILE *dump;
+ const char *dumpfile = is_proxy?REQUEST_PROXY_DUMP:REQUEST_DUMP;
+
+ if(!reqbuf)
+ return;
+ if(totalsize == 0)
+ return;
+
+ do {
+ dump = fopen(dumpfile, "ab");
+ } while(!dump && ((error = errno) == EINTR));
+ if(!dump) {
+ logmsg("[2] Error opening file %s error: %d %s",
+ dumpfile, error, strerror(error));
+ logmsg("Failed to write request input ");
+ return;
+ }
+
+ writeleft = totalsize;
+ do {
+ written = fwrite(&reqbuf[totalsize-writeleft],
+ 1, writeleft, dump);
+ if(got_exit_signal)
+ goto storerequest_cleanup;
+ if(written > 0)
+ writeleft -= written;
+ } while((writeleft > 0) && ((error = errno) == EINTR));
+
+ if(writeleft == 0)
+ logmsg("Wrote request (%zu bytes) input to %s", totalsize, dumpfile);
+ else if(writeleft > 0) {
+ logmsg("Error writing file %s error: %d %s",
+ dumpfile, error, strerror(error));
+ logmsg("Wrote only (%zu bytes) of (%zu bytes) request input to %s",
+ totalsize-writeleft, totalsize, dumpfile);
+ }
+
+storerequest_cleanup:
+
+ do {
+ res = fclose(dump);
+ } while(res && ((error = errno) == EINTR));
+ if(res)
+ logmsg("Error closing file %s error: %d %s",
+ dumpfile, error, strerror(error));
+}
+
+static void init_httprequest(struct httprequest *req)
+{
+ req->checkindex = 0;
+ req->offset = 0;
+ req->testno = DOCNUMBER_NOTHING;
+ req->partno = 0;
+ req->connect_request = FALSE;
+ req->open = TRUE;
+ req->auth_req = FALSE;
+ req->auth = FALSE;
+ req->cl = 0;
+ req->digest = FALSE;
+ req->ntlm = FALSE;
+ req->skip = 0;
+ req->skipall = FALSE;
+ req->noexpect = FALSE;
+ req->writedelay = 0;
+ req->rcmd = RCMD_NORMALREQ;
+ req->prot_version = 0;
+ req->callcount = 0;
+ req->connect_port = 0;
+ req->done_processing = 0;
+ req->upgrade = 0;
+ req->upgrade_request = 0;
+}
+
+static int send_doc(curl_socket_t sock, struct httprequest *req);
+
+/* returns 1 if the connection should be serviced again immediately, 0 if there
+ is no data waiting, or < 0 if it should be closed */
+static int get_request(curl_socket_t sock, struct httprequest *req)
+{
+ int fail = 0;
+ char *reqbuf = req->reqbuf;
+ ssize_t got = 0;
+ int overflow = 0;
+
+ if(req->upgrade_request) {
+ /* upgraded connection, work it differently until end of connection */
+ logmsg("Upgraded connection, this is a no longer HTTP/1");
+ send_doc(sock, req);
+
+ /* dump the request received so far to the external file */
+ reqbuf[req->offset] = '\0';
+ storerequest(reqbuf, req->offset);
+ req->offset = 0;
+
+ /* read websocket traffic */
+ do {
+
+ got = sread(sock, reqbuf + req->offset, REQBUFSIZ - req->offset);
+ if(got > 0)
+ req->offset += got;
+ logmsg("Got: %d", (int)got);
+
+ if((got == -1) && ((EAGAIN == errno) || (EWOULDBLOCK == errno))) {
+ int rc;
+ fd_set input;
+ fd_set output;
+ struct timeval timeout = {1, 0}; /* 1000 ms */
+
+ FD_ZERO(&input);
+ FD_ZERO(&output);
+ got = 0;
+ FD_SET(sock, &input);
+ do {
+ logmsg("Wait until readable");
+ rc = select((int)sock + 1, &input, &output, NULL, &timeout);
+ } while(rc < 0 && errno == EINTR && !got_exit_signal);
+ logmsg("readable %d", rc);
+ if(rc)
+ got = 1;
+ }
+ } while(got > 0);
+
+ if(req->offset) {
+ logmsg("log the websocket traffic");
+ /* dump the incoming websocket traffic to the external file */
+ reqbuf[req->offset] = '\0';
+ storerequest(reqbuf, req->offset);
+ req->offset = 0;
+ }
+ init_httprequest(req);
+
+ return -1;
+ }
+
+ if(req->offset >= REQBUFSIZ-1) {
+ /* buffer is already full; do nothing */
+ overflow = 1;
+ }
+ else {
+ if(req->skip)
+ /* we are instructed to not read the entire thing, so we make sure to
+ only read what we're supposed to and NOT read the entire thing the
+ client wants to send! */
+ got = sread(sock, reqbuf + req->offset, req->cl);
+ else
+ got = sread(sock, reqbuf + req->offset, REQBUFSIZ-1 - req->offset);
+
+ if(got_exit_signal)
+ return -1;
+ if(got == 0) {
+ logmsg("Connection closed by client");
+ fail = 1;
+ }
+ else if(got < 0) {
+ int error = SOCKERRNO;
+ if(EAGAIN == error || EWOULDBLOCK == error) {
+ /* nothing to read at the moment */
+ return 0;
+ }
+ logmsg("recv() returned error: (%d) %s", error, strerror(error));
+ fail = 1;
+ }
+ if(fail) {
+ /* dump the request received so far to the external file */
+ reqbuf[req->offset] = '\0';
+ storerequest(reqbuf, req->offset);
+ return -1;
+ }
+
+ logmsg("Read %zd bytes", got);
+
+ req->offset += (size_t)got;
+ reqbuf[req->offset] = '\0';
+
+ req->done_processing = ProcessRequest(req);
+ if(got_exit_signal)
+ return -1;
+ }
+
+ if(overflow || (req->offset == REQBUFSIZ-1 && got > 0)) {
+ logmsg("Request would overflow buffer, closing connection");
+ /* dump request received so far to external file anyway */
+ reqbuf[REQBUFSIZ-1] = '\0';
+ fail = 1;
+ }
+ else if(req->offset > REQBUFSIZ-1) {
+ logmsg("Request buffer overflow, closing connection");
+ /* dump request received so far to external file anyway */
+ reqbuf[REQBUFSIZ-1] = '\0';
+ fail = 1;
+ }
+ else
+ reqbuf[req->offset] = '\0';
+
+ /* at the end of a request dump it to an external file */
+ if(fail || req->done_processing)
+ storerequest(reqbuf, req->offset);
+ if(got_exit_signal)
+ return -1;
+
+ return fail ? -1 : 1;
+}
+
+/* returns -1 on failure */
+static int send_doc(curl_socket_t sock, struct httprequest *req)
+{
+ ssize_t written;
+ size_t count;
+ const char *buffer;
+ char *ptr = NULL;
+ FILE *stream;
+ char *cmd = NULL;
+ size_t cmdsize = 0;
+ FILE *dump;
+ bool persistent = TRUE;
+ bool sendfailure = FALSE;
+ size_t responsesize;
+ int error = 0;
+ int res;
+ const char *responsedump = is_proxy?RESPONSE_PROXY_DUMP:RESPONSE_DUMP;
+ static char weare[256];
+
+ switch(req->rcmd) {
+ default:
+ case RCMD_NORMALREQ:
+ break; /* continue with business as usual */
+ case RCMD_STREAM:
+#define STREAMTHIS "a string to stream 01234567890\n"
+ count = strlen(STREAMTHIS);
+ for(;;) {
+ written = swrite(sock, STREAMTHIS, count);
+ if(got_exit_signal)
+ return -1;
+ if(written != (ssize_t)count) {
+ logmsg("Stopped streaming");
+ break;
+ }
+ }
+ return -1;
+ case RCMD_IDLE:
+ /* Do nothing. Sit idle. Pretend it rains. */
+ return 0;
+ }
+
+ req->open = FALSE;
+
+ if(req->testno < 0) {
+ size_t msglen;
+ char msgbuf[64];
+
+ switch(req->testno) {
+ case DOCNUMBER_QUIT:
+ logmsg("Replying to QUIT");
+ buffer = docquit;
+ break;
+ case DOCNUMBER_WERULEZ:
+ /* we got a "friends?" question, reply back that we sure are */
+ logmsg("Identifying ourselves as friends");
+ msnprintf(msgbuf, sizeof(msgbuf), "WE ROOLZ: %"
+ CURL_FORMAT_CURL_OFF_T "\r\n", our_getpid());
+ msglen = strlen(msgbuf);
+ if(use_gopher)
+ msnprintf(weare, sizeof(weare), "%s", msgbuf);
+ else
+ msnprintf(weare, sizeof(weare),
+ "HTTP/1.1 200 OK\r\nContent-Length: %zu\r\n\r\n%s",
+ msglen, msgbuf);
+ buffer = weare;
+ break;
+ case DOCNUMBER_404:
+ default:
+ logmsg("Replying to with a 404");
+ buffer = doc404;
+ break;
+ }
+
+ count = strlen(buffer);
+ }
+ else {
+ char partbuf[80];
+
+ /* select the <data> tag for "normal" requests and the <connect> one
+ for CONNECT requests (within the <reply> section) */
+ const char *section = req->connect_request?"connect":"data";
+
+ if(req->partno)
+ msnprintf(partbuf, sizeof(partbuf), "%s%ld", section, req->partno);
+ else
+ msnprintf(partbuf, sizeof(partbuf), "%s", section);
+
+ logmsg("Send response test%ld section <%s>", req->testno, partbuf);
+
+ stream = test2fopen(req->testno);
+ if(!stream) {
+ error = errno;
+ logmsg("fopen() failed with error: %d %s", error, strerror(error));
+ return 0;
+ }
+ else {
+ error = getpart(&ptr, &count, "reply", partbuf, stream);
+ fclose(stream);
+ if(error) {
+ logmsg("getpart() failed with error: %d", error);
+ return 0;
+ }
+ buffer = ptr;
+ }
+
+ if(got_exit_signal) {
+ free(ptr);
+ return -1;
+ }
+
+ /* re-open the same file again */
+ stream = test2fopen(req->testno);
+ if(!stream) {
+ error = errno;
+ logmsg("fopen() failed with error: %d %s", error, strerror(error));
+ free(ptr);
+ return 0;
+ }
+ else {
+ /* get the custom server control "commands" */
+ error = getpart(&cmd, &cmdsize, "reply", "postcmd", stream);
+ fclose(stream);
+ if(error) {
+ logmsg("getpart() failed with error: %d", error);
+ free(ptr);
+ return 0;
+ }
+ }
+ }
+
+ if(got_exit_signal) {
+ free(ptr);
+ free(cmd);
+ return -1;
+ }
+
+ /* If the word 'swsclose' is present anywhere in the reply chunk, the
+ connection will be closed after the data has been sent to the requesting
+ client... */
+ if(strstr(buffer, "swsclose") || !count || req->close) {
+ persistent = FALSE;
+ logmsg("connection close instruction \"swsclose\" found in response");
+ }
+ if(strstr(buffer, "swsbounce")) {
+ prevbounce = TRUE;
+ logmsg("enable \"swsbounce\" in the next request");
+ }
+ else
+ prevbounce = FALSE;
+
+ dump = fopen(responsedump, "ab");
+ if(!dump) {
+ error = errno;
+ logmsg("fopen() failed with error: %d %s", error, strerror(error));
+ logmsg(" [5] Error opening file: %s", responsedump);
+ free(ptr);
+ free(cmd);
+ return -1;
+ }
+
+ responsesize = count;
+ do {
+ /* Ok, we send no more than N bytes at a time, just to make sure that
+ larger chunks are split up so that the client will need to do multiple
+ recv() calls to get it and thus we exercise that code better */
+ size_t num = count;
+ if(num > 20)
+ num = 20;
+
+ retry:
+ written = swrite(sock, buffer, num);
+ if(written < 0) {
+ if((EWOULDBLOCK == SOCKERRNO) || (EAGAIN == SOCKERRNO)) {
+ wait_ms(10);
+ goto retry;
+ }
+ sendfailure = TRUE;
+ break;
+ }
+
+ /* write to file as well */
+ fwrite(buffer, 1, (size_t)written, dump);
+
+ count -= written;
+ buffer += written;
+
+ if(req->writedelay) {
+ int msecs_left = req->writedelay;
+ int intervals = msecs_left / MAX_SLEEP_TIME_MS;
+ if(msecs_left%MAX_SLEEP_TIME_MS)
+ intervals++;
+ logmsg("Pausing %d milliseconds after writing %d bytes",
+ msecs_left, written);
+ while((intervals > 0) && !got_exit_signal) {
+ int sleep_time = msecs_left > MAX_SLEEP_TIME_MS ?
+ MAX_SLEEP_TIME_MS : msecs_left;
+ intervals--;
+ wait_ms(sleep_time);
+ msecs_left -= sleep_time;
+ }
+ }
+ } while((count > 0) && !got_exit_signal);
+
+ do {
+ res = fclose(dump);
+ } while(res && ((error = errno) == EINTR));
+ if(res)
+ logmsg("Error closing file %s error: %d %s",
+ responsedump, error, strerror(error));
+
+ if(got_exit_signal) {
+ free(ptr);
+ free(cmd);
+ return -1;
+ }
+
+ if(sendfailure) {
+ logmsg("Sending response failed. Only (%zu bytes) of (%zu bytes) "
+ "were sent",
+ responsesize-count, responsesize);
+ prevtestno = req->testno;
+ prevpartno = req->partno;
+ free(ptr);
+ free(cmd);
+ return -1;
+ }
+
+ logmsg("Response sent (%zu bytes) and written to %s",
+ responsesize, responsedump);
+ free(ptr);
+
+ if(cmdsize > 0) {
+ char command[32];
+ int quarters;
+ int num;
+ ptr = cmd;
+ do {
+ if(2 == sscanf(ptr, "%31s %d", command, &num)) {
+ if(!strcmp("wait", command)) {
+ logmsg("Told to sleep for %d seconds", num);
+ quarters = num * 4;
+ while((quarters > 0) && !got_exit_signal) {
+ quarters--;
+ res = wait_ms(250);
+ if(res) {
+ /* should not happen */
+ error = errno;
+ logmsg("wait_ms() failed with error: (%d) %s",
+ error, strerror(error));
+ break;
+ }
+ }
+ if(!quarters)
+ logmsg("Continuing after sleeping %d seconds", num);
+ }
+ else
+ logmsg("Unknown command in reply command section");
+ }
+ ptr = strchr(ptr, '\n');
+ if(ptr)
+ ptr++;
+ else
+ ptr = NULL;
+ } while(ptr && *ptr);
+ }
+ free(cmd);
+ req->open = use_gopher?FALSE:persistent;
+
+ prevtestno = req->testno;
+ prevpartno = req->partno;
+
+ return 0;
+}
+
+static curl_socket_t connect_to(const char *ipaddr, unsigned short port)
+{
+ srvr_sockaddr_union_t serveraddr;
+ curl_socket_t serverfd;
+ int error;
+ int rc = 0;
+ const char *op_br = "";
+ const char *cl_br = "";
+
+#ifdef ENABLE_IPV6
+ if(socket_domain == AF_INET6) {
+ op_br = "[";
+ cl_br = "]";
+ }
+#endif
+
+ if(!ipaddr)
+ return CURL_SOCKET_BAD;
+
+ logmsg("about to connect to %s%s%s:%hu",
+ op_br, ipaddr, cl_br, port);
+
+
+ serverfd = socket(socket_domain, SOCK_STREAM, 0);
+ if(CURL_SOCKET_BAD == serverfd) {
+ error = SOCKERRNO;
+ logmsg("Error creating socket for server connection: (%d) %s",
+ error, strerror(error));
+ return CURL_SOCKET_BAD;
+ }
+
+#ifdef TCP_NODELAY
+ if(socket_domain_is_ip()) {
+ /* Disable the Nagle algorithm */
+ curl_socklen_t flag = 1;
+ if(0 != setsockopt(serverfd, IPPROTO_TCP, TCP_NODELAY,
+ (void *)&flag, sizeof(flag)))
+ logmsg("====> TCP_NODELAY for server connection failed");
+ }
+#endif
+
+ switch(socket_domain) {
+ case AF_INET:
+ memset(&serveraddr.sa4, 0, sizeof(serveraddr.sa4));
+ serveraddr.sa4.sin_family = AF_INET;
+ serveraddr.sa4.sin_port = htons(port);
+ if(Curl_inet_pton(AF_INET, ipaddr, &serveraddr.sa4.sin_addr) < 1) {
+ logmsg("Error inet_pton failed AF_INET conversion of '%s'", ipaddr);
+ sclose(serverfd);
+ return CURL_SOCKET_BAD;
+ }
+
+ rc = connect(serverfd, &serveraddr.sa, sizeof(serveraddr.sa4));
+ break;
+#ifdef ENABLE_IPV6
+ case AF_INET6:
+ memset(&serveraddr.sa6, 0, sizeof(serveraddr.sa6));
+ serveraddr.sa6.sin6_family = AF_INET6;
+ serveraddr.sa6.sin6_port = htons(port);
+ if(Curl_inet_pton(AF_INET6, ipaddr, &serveraddr.sa6.sin6_addr) < 1) {
+ logmsg("Error inet_pton failed AF_INET6 conversion of '%s'", ipaddr);
+ sclose(serverfd);
+ return CURL_SOCKET_BAD;
+ }
+
+ rc = connect(serverfd, &serveraddr.sa, sizeof(serveraddr.sa6));
+ break;
+#endif /* ENABLE_IPV6 */
+#ifdef USE_UNIX_SOCKETS
+ case AF_UNIX:
+ logmsg("Proxying through Unix socket is not (yet?) supported.");
+ return CURL_SOCKET_BAD;
+#endif /* USE_UNIX_SOCKETS */
+ }
+
+ if(got_exit_signal) {
+ sclose(serverfd);
+ return CURL_SOCKET_BAD;
+ }
+
+ if(rc) {
+ error = SOCKERRNO;
+ logmsg("Error connecting to server port %hu: (%d) %s",
+ port, error, strerror(error));
+ sclose(serverfd);
+ return CURL_SOCKET_BAD;
+ }
+
+ logmsg("connected fine to %s%s%s:%hu, now tunnel",
+ op_br, ipaddr, cl_br, port);
+
+ return serverfd;
+}
+
+/*
+ * A CONNECT has been received, a CONNECT response has been sent.
+ *
+ * This function needs to connect to the server, and then pass data between
+ * the client and the server back and forth until the connection is closed by
+ * either end.
+ *
+ * When doing FTP through a CONNECT proxy, we expect that the data connection
+ * will be setup while the first connect is still being kept up. Therefore we
+ * must accept a new connection and deal with it appropriately.
+ */
+
+#define data_or_ctrl(x) ((x)?"DATA":"CTRL")
+
+#define CTRL 0
+#define DATA 1
+
+static void http_connect(curl_socket_t *infdp,
+ curl_socket_t rootfd,
+ const char *ipaddr,
+ unsigned short ipport)
+{
+ curl_socket_t serverfd[2] = {CURL_SOCKET_BAD, CURL_SOCKET_BAD};
+ curl_socket_t clientfd[2] = {CURL_SOCKET_BAD, CURL_SOCKET_BAD};
+ ssize_t toc[2] = {0, 0}; /* number of bytes to client */
+ ssize_t tos[2] = {0, 0}; /* number of bytes to server */
+ char readclient[2][256];
+ char readserver[2][256];
+ bool poll_client_rd[2] = { TRUE, TRUE };
+ bool poll_server_rd[2] = { TRUE, TRUE };
+ bool poll_client_wr[2] = { TRUE, TRUE };
+ bool poll_server_wr[2] = { TRUE, TRUE };
+ bool primary = FALSE;
+ bool secondary = FALSE;
+ int max_tunnel_idx; /* CTRL or DATA */
+ int loop;
+ int i;
+ int timeout_count = 0;
+
+ /* primary tunnel client endpoint already connected */
+ clientfd[CTRL] = *infdp;
+
+ /* Sleep here to make sure the client reads CONNECT response's
+ 'end of headers' separate from the server data that follows.
+ This is done to prevent triggering libcurl known bug #39. */
+ for(loop = 2; (loop > 0) && !got_exit_signal; loop--)
+ wait_ms(250);
+ if(got_exit_signal)
+ goto http_connect_cleanup;
+
+ serverfd[CTRL] = connect_to(ipaddr, ipport);
+ if(serverfd[CTRL] == CURL_SOCKET_BAD)
+ goto http_connect_cleanup;
+
+ /* Primary tunnel socket endpoints are now connected. Tunnel data back and
+ forth over the primary tunnel until client or server breaks the primary
+ tunnel, simultaneously allowing establishment, operation and teardown of
+ a secondary tunnel that may be used for passive FTP data connection. */
+
+ max_tunnel_idx = CTRL;
+ primary = TRUE;
+
+ while(!got_exit_signal) {
+
+ fd_set input;
+ fd_set output;
+ struct timeval timeout = {1, 0}; /* 1000 ms */
+ ssize_t rc;
+ curl_socket_t maxfd = (curl_socket_t)-1;
+
+ FD_ZERO(&input);
+ FD_ZERO(&output);
+
+ if((clientfd[DATA] == CURL_SOCKET_BAD) &&
+ (serverfd[DATA] == CURL_SOCKET_BAD) &&
+ poll_client_rd[CTRL] && poll_client_wr[CTRL] &&
+ poll_server_rd[CTRL] && poll_server_wr[CTRL]) {
+ /* listener socket is monitored to allow client to establish
+ secondary tunnel only when this tunnel is not established
+ and primary one is fully operational */
+ FD_SET(rootfd, &input);
+ maxfd = rootfd;
+ }
+
+ /* set tunnel sockets to wait for */
+ for(i = 0; i <= max_tunnel_idx; i++) {
+ /* client side socket monitoring */
+ if(clientfd[i] != CURL_SOCKET_BAD) {
+ if(poll_client_rd[i]) {
+ /* unless told not to do so, monitor readability */
+ FD_SET(clientfd[i], &input);
+ if(clientfd[i] > maxfd)
+ maxfd = clientfd[i];
+ }
+ if(poll_client_wr[i] && toc[i]) {
+ /* unless told not to do so, monitor writability
+ if there is data ready to be sent to client */
+ FD_SET(clientfd[i], &output);
+ if(clientfd[i] > maxfd)
+ maxfd = clientfd[i];
+ }
+ }
+ /* server side socket monitoring */
+ if(serverfd[i] != CURL_SOCKET_BAD) {
+ if(poll_server_rd[i]) {
+ /* unless told not to do so, monitor readability */
+ FD_SET(serverfd[i], &input);
+ if(serverfd[i] > maxfd)
+ maxfd = serverfd[i];
+ }
+ if(poll_server_wr[i] && tos[i]) {
+ /* unless told not to do so, monitor writability
+ if there is data ready to be sent to server */
+ FD_SET(serverfd[i], &output);
+ if(serverfd[i] > maxfd)
+ maxfd = serverfd[i];
+ }
+ }
+ }
+ if(got_exit_signal)
+ break;
+
+ do {
+ rc = select((int)maxfd + 1, &input, &output, NULL, &timeout);
+ } while(rc < 0 && errno == EINTR && !got_exit_signal);
+
+ if(got_exit_signal)
+ break;
+
+ if(rc > 0) {
+ /* socket action */
+ bool tcp_fin_wr = FALSE;
+ timeout_count = 0;
+
+ /* ---------------------------------------------------------- */
+
+ /* passive mode FTP may establish a secondary tunnel */
+ if((clientfd[DATA] == CURL_SOCKET_BAD) &&
+ (serverfd[DATA] == CURL_SOCKET_BAD) && FD_ISSET(rootfd, &input)) {
+ /* a new connection on listener socket (most likely from client) */
+ curl_socket_t datafd = accept(rootfd, NULL, NULL);
+ if(datafd != CURL_SOCKET_BAD) {
+ static struct httprequest *req2;
+ int err = 0;
+ if(!req2) {
+ req2 = malloc(sizeof(*req2));
+ if(!req2)
+ exit(1);
+ }
+ memset(req2, 0, sizeof(*req2));
+ logmsg("====> Client connect DATA");
+#ifdef TCP_NODELAY
+ if(socket_domain_is_ip()) {
+ /* Disable the Nagle algorithm */
+ curl_socklen_t flag = 1;
+ if(0 != setsockopt(datafd, IPPROTO_TCP, TCP_NODELAY,
+ (void *)&flag, sizeof(flag)))
+ logmsg("====> TCP_NODELAY for client DATA connection failed");
+ }
+#endif
+ init_httprequest(req2);
+ while(!req2->done_processing) {
+ err = get_request(datafd, req2);
+ if(err < 0) {
+ /* this socket must be closed, done or not */
+ break;
+ }
+ }
+
+ /* skip this and close the socket if err < 0 */
+ if(err >= 0) {
+ err = send_doc(datafd, req2);
+ if(!err && req2->connect_request) {
+ /* sleep to prevent triggering libcurl known bug #39. */
+ for(loop = 2; (loop > 0) && !got_exit_signal; loop--)
+ wait_ms(250);
+ if(!got_exit_signal) {
+ /* connect to the server */
+ serverfd[DATA] = connect_to(ipaddr, req2->connect_port);
+ if(serverfd[DATA] != CURL_SOCKET_BAD) {
+ /* secondary tunnel established, now we have two
+ connections */
+ poll_client_rd[DATA] = TRUE;
+ poll_client_wr[DATA] = TRUE;
+ poll_server_rd[DATA] = TRUE;
+ poll_server_wr[DATA] = TRUE;
+ max_tunnel_idx = DATA;
+ secondary = TRUE;
+ toc[DATA] = 0;
+ tos[DATA] = 0;
+ clientfd[DATA] = datafd;
+ datafd = CURL_SOCKET_BAD;
+ }
+ }
+ }
+ }
+ if(datafd != CURL_SOCKET_BAD) {
+ /* secondary tunnel not established */
+ shutdown(datafd, SHUT_RDWR);
+ sclose(datafd);
+ }
+ }
+ if(got_exit_signal)
+ break;
+ }
+
+ /* ---------------------------------------------------------- */
+
+ /* react to tunnel endpoint readable/writable notifications */
+ for(i = 0; i <= max_tunnel_idx; i++) {
+ size_t len;
+ if(clientfd[i] != CURL_SOCKET_BAD) {
+ len = sizeof(readclient[i]) - tos[i];
+ if(len && FD_ISSET(clientfd[i], &input)) {
+ /* read from client */
+ rc = sread(clientfd[i], &readclient[i][tos[i]], len);
+ if(rc <= 0) {
+ logmsg("[%s] got %zd, STOP READING client", data_or_ctrl(i), rc);
+ shutdown(clientfd[i], SHUT_RD);
+ poll_client_rd[i] = FALSE;
+ }
+ else {
+ logmsg("[%s] READ %zd bytes from client", data_or_ctrl(i), rc);
+ logmsg("[%s] READ \"%s\"", data_or_ctrl(i),
+ data_to_hex(&readclient[i][tos[i]], rc));
+ tos[i] += rc;
+ }
+ }
+ }
+ if(serverfd[i] != CURL_SOCKET_BAD) {
+ len = sizeof(readserver[i])-toc[i];
+ if(len && FD_ISSET(serverfd[i], &input)) {
+ /* read from server */
+ rc = sread(serverfd[i], &readserver[i][toc[i]], len);
+ if(rc <= 0) {
+ logmsg("[%s] got %zd, STOP READING server", data_or_ctrl(i), rc);
+ shutdown(serverfd[i], SHUT_RD);
+ poll_server_rd[i] = FALSE;
+ }
+ else {
+ logmsg("[%s] READ %zd bytes from server", data_or_ctrl(i), rc);
+ logmsg("[%s] READ \"%s\"", data_or_ctrl(i),
+ data_to_hex(&readserver[i][toc[i]], rc));
+ toc[i] += rc;
+ }
+ }
+ }
+ if(clientfd[i] != CURL_SOCKET_BAD) {
+ if(toc[i] && FD_ISSET(clientfd[i], &output)) {
+ /* write to client */
+ rc = swrite(clientfd[i], readserver[i], toc[i]);
+ if(rc <= 0) {
+ logmsg("[%s] got %zd, STOP WRITING client", data_or_ctrl(i), rc);
+ shutdown(clientfd[i], SHUT_WR);
+ poll_client_wr[i] = FALSE;
+ tcp_fin_wr = TRUE;
+ }
+ else {
+ logmsg("[%s] SENT %zd bytes to client", data_or_ctrl(i), rc);
+ logmsg("[%s] SENT \"%s\"", data_or_ctrl(i),
+ data_to_hex(readserver[i], rc));
+ if(toc[i] - rc)
+ memmove(&readserver[i][0], &readserver[i][rc], toc[i]-rc);
+ toc[i] -= rc;
+ }
+ }
+ }
+ if(serverfd[i] != CURL_SOCKET_BAD) {
+ if(tos[i] && FD_ISSET(serverfd[i], &output)) {
+ /* write to server */
+ rc = swrite(serverfd[i], readclient[i], tos[i]);
+ if(rc <= 0) {
+ logmsg("[%s] got %zd, STOP WRITING server", data_or_ctrl(i), rc);
+ shutdown(serverfd[i], SHUT_WR);
+ poll_server_wr[i] = FALSE;
+ tcp_fin_wr = TRUE;
+ }
+ else {
+ logmsg("[%s] SENT %zd bytes to server", data_or_ctrl(i), rc);
+ logmsg("[%s] SENT \"%s\"", data_or_ctrl(i),
+ data_to_hex(readclient[i], rc));
+ if(tos[i] - rc)
+ memmove(&readclient[i][0], &readclient[i][rc], tos[i]-rc);
+ tos[i] -= rc;
+ }
+ }
+ }
+ }
+ if(got_exit_signal)
+ break;
+
+ /* ---------------------------------------------------------- */
+
+ /* endpoint read/write disabling, endpoint closing and tunnel teardown */
+ for(i = 0; i <= max_tunnel_idx; i++) {
+ for(loop = 2; loop > 0; loop--) {
+ /* loop twice to satisfy condition interdependencies without
+ having to await select timeout or another socket event */
+ if(clientfd[i] != CURL_SOCKET_BAD) {
+ if(poll_client_rd[i] && !poll_server_wr[i]) {
+ logmsg("[%s] DISABLED READING client", data_or_ctrl(i));
+ shutdown(clientfd[i], SHUT_RD);
+ poll_client_rd[i] = FALSE;
+ }
+ if(poll_client_wr[i] && !poll_server_rd[i] && !toc[i]) {
+ logmsg("[%s] DISABLED WRITING client", data_or_ctrl(i));
+ shutdown(clientfd[i], SHUT_WR);
+ poll_client_wr[i] = FALSE;
+ tcp_fin_wr = TRUE;
+ }
+ }
+ if(serverfd[i] != CURL_SOCKET_BAD) {
+ if(poll_server_rd[i] && !poll_client_wr[i]) {
+ logmsg("[%s] DISABLED READING server", data_or_ctrl(i));
+ shutdown(serverfd[i], SHUT_RD);
+ poll_server_rd[i] = FALSE;
+ }
+ if(poll_server_wr[i] && !poll_client_rd[i] && !tos[i]) {
+ logmsg("[%s] DISABLED WRITING server", data_or_ctrl(i));
+ shutdown(serverfd[i], SHUT_WR);
+ poll_server_wr[i] = FALSE;
+ tcp_fin_wr = TRUE;
+ }
+ }
+ }
+ }
+
+ if(tcp_fin_wr)
+ /* allow kernel to place FIN bit packet on the wire */
+ wait_ms(250);
+
+ /* socket clearing */
+ for(i = 0; i <= max_tunnel_idx; i++) {
+ for(loop = 2; loop > 0; loop--) {
+ if(clientfd[i] != CURL_SOCKET_BAD) {
+ if(!poll_client_wr[i] && !poll_client_rd[i]) {
+ logmsg("[%s] CLOSING client socket", data_or_ctrl(i));
+ sclose(clientfd[i]);
+ clientfd[i] = CURL_SOCKET_BAD;
+ if(serverfd[i] == CURL_SOCKET_BAD) {
+ logmsg("[%s] ENDING", data_or_ctrl(i));
+ if(i == DATA)
+ secondary = FALSE;
+ else
+ primary = FALSE;
+ }
+ }
+ }
+ if(serverfd[i] != CURL_SOCKET_BAD) {
+ if(!poll_server_wr[i] && !poll_server_rd[i]) {
+ logmsg("[%s] CLOSING server socket", data_or_ctrl(i));
+ sclose(serverfd[i]);
+ serverfd[i] = CURL_SOCKET_BAD;
+ if(clientfd[i] == CURL_SOCKET_BAD) {
+ logmsg("[%s] ENDING", data_or_ctrl(i));
+ if(i == DATA)
+ secondary = FALSE;
+ else
+ primary = FALSE;
+ }
+ }
+ }
+ }
+ }
+
+ /* ---------------------------------------------------------- */
+
+ max_tunnel_idx = secondary ? DATA : CTRL;
+
+ if(!primary)
+ /* exit loop upon primary tunnel teardown */
+ break;
+
+ } /* (rc > 0) */
+ else {
+ timeout_count++;
+ if(timeout_count > 5) {
+ logmsg("CONNECT proxy timeout after %d idle seconds!", timeout_count);
+ break;
+ }
+ }
+ }
+
+http_connect_cleanup:
+
+ for(i = DATA; i >= CTRL; i--) {
+ if(serverfd[i] != CURL_SOCKET_BAD) {
+ logmsg("[%s] CLOSING server socket (cleanup)", data_or_ctrl(i));
+ shutdown(serverfd[i], SHUT_RDWR);
+ sclose(serverfd[i]);
+ }
+ if(clientfd[i] != CURL_SOCKET_BAD) {
+ logmsg("[%s] CLOSING client socket (cleanup)", data_or_ctrl(i));
+ shutdown(clientfd[i], SHUT_RDWR);
+ sclose(clientfd[i]);
+ }
+ if((serverfd[i] != CURL_SOCKET_BAD) ||
+ (clientfd[i] != CURL_SOCKET_BAD)) {
+ logmsg("[%s] ABORTING", data_or_ctrl(i));
+ }
+ }
+
+ *infdp = CURL_SOCKET_BAD;
+}
+
+static void http_upgrade(struct httprequest *req)
+{
+ (void)req;
+ logmsg("Upgraded to ... %u", req->upgrade_request);
+ /* left to implement */
+}
+
+
+/* returns a socket handle, or 0 if there are no more waiting sockets,
+ or < 0 if there was an error */
+static curl_socket_t accept_connection(curl_socket_t sock)
+{
+ curl_socket_t msgsock = CURL_SOCKET_BAD;
+ int error;
+ int flag = 1;
+
+ if(MAX_SOCKETS == num_sockets) {
+ logmsg("Too many open sockets!");
+ return CURL_SOCKET_BAD;
+ }
+
+ msgsock = accept(sock, NULL, NULL);
+
+ if(got_exit_signal) {
+ if(CURL_SOCKET_BAD != msgsock)
+ sclose(msgsock);
+ return CURL_SOCKET_BAD;
+ }
+
+ if(CURL_SOCKET_BAD == msgsock) {
+ error = SOCKERRNO;
+ if(EAGAIN == error || EWOULDBLOCK == error) {
+ /* nothing to accept */
+ return 0;
+ }
+ logmsg("MAJOR ERROR: accept() failed with error: (%d) %s",
+ error, strerror(error));
+ return CURL_SOCKET_BAD;
+ }
+
+ if(0 != curlx_nonblock(msgsock, TRUE)) {
+ error = SOCKERRNO;
+ logmsg("curlx_nonblock failed with error: (%d) %s",
+ error, strerror(error));
+ sclose(msgsock);
+ return CURL_SOCKET_BAD;
+ }
+
+ if(0 != setsockopt(msgsock, SOL_SOCKET, SO_KEEPALIVE,
+ (void *)&flag, sizeof(flag))) {
+ error = SOCKERRNO;
+ logmsg("setsockopt(SO_KEEPALIVE) failed with error: (%d) %s",
+ error, strerror(error));
+ sclose(msgsock);
+ return CURL_SOCKET_BAD;
+ }
+
+ /*
+ ** As soon as this server accepts a connection from the test harness it
+ ** must set the server logs advisor read lock to indicate that server
+ ** logs should not be read until this lock is removed by this server.
+ */
+
+ if(!serverlogslocked)
+ set_advisor_read_lock(SERVERLOGS_LOCK);
+ serverlogslocked += 1;
+
+ logmsg("====> Client connect");
+
+ all_sockets[num_sockets] = msgsock;
+ num_sockets += 1;
+
+#ifdef TCP_NODELAY
+ if(socket_domain_is_ip()) {
+ /*
+ * Disable the Nagle algorithm to make it easier to send out a large
+ * response in many small segments to torture the clients more.
+ */
+ if(0 != setsockopt(msgsock, IPPROTO_TCP, TCP_NODELAY,
+ (void *)&flag, sizeof(flag)))
+ logmsg("====> TCP_NODELAY failed");
+ }
+#endif
+
+ return msgsock;
+}
+
+/* returns 1 if the connection should be serviced again immediately, 0 if there
+ is no data waiting, or < 0 if it should be closed */
+static int service_connection(curl_socket_t msgsock, struct httprequest *req,
+ curl_socket_t listensock,
+ const char *connecthost)
+{
+ if(got_exit_signal)
+ return -1;
+
+ while(!req->done_processing) {
+ int rc = get_request(msgsock, req);
+ if(rc <= 0) {
+ /* Nothing further to read now, possibly because the socket was closed */
+ return rc;
+ }
+ }
+
+ if(prevbounce) {
+ /* bounce treatment requested */
+ if((req->testno == prevtestno) &&
+ (req->partno == prevpartno)) {
+ req->partno++;
+ logmsg("BOUNCE part number to %ld", req->partno);
+ }
+ else {
+ prevbounce = FALSE;
+ prevtestno = -1;
+ prevpartno = -1;
+ }
+ }
+
+ send_doc(msgsock, req);
+ if(got_exit_signal)
+ return -1;
+
+ if(req->testno < 0) {
+ logmsg("special request received, no persistency");
+ return -1;
+ }
+ if(!req->open) {
+ logmsg("instructed to close connection after server-reply");
+ return -1;
+ }
+
+ if(req->connect_request) {
+ /* a CONNECT request, setup and talk the tunnel */
+ if(!is_proxy) {
+ logmsg("received CONNECT but isn't running as proxy!");
+ return 1;
+ }
+ else {
+ http_connect(&msgsock, listensock, connecthost, req->connect_port);
+ return -1;
+ }
+ }
+
+ if(req->upgrade_request) {
+ /* an upgrade request, switch to another protocol here */
+ http_upgrade(req);
+ return 1;
+ }
+
+ /* if we got a CONNECT, loop and get another request as well! */
+
+ if(req->open) {
+ logmsg("=> persistent connection request ended, awaits new request\n");
+ return 1;
+ }
+
+ return -1;
+}
+
+int main(int argc, char *argv[])
+{
+ srvr_sockaddr_union_t me;
+ curl_socket_t sock = CURL_SOCKET_BAD;
+ int wrotepidfile = 0;
+ int wroteportfile = 0;
+ int flag;
+ unsigned short port = DEFAULT_PORT;
+#ifdef USE_UNIX_SOCKETS
+ const char *unix_socket = NULL;
+ bool unlink_socket = false;
+#endif
+ const char *pidname = ".http.pid";
+ const char *portname = ".http.port";
+ struct httprequest *req = NULL;
+ int rc = 0;
+ int error;
+ int arg = 1;
+ const char *connecthost = "127.0.0.1";
+ const char *socket_type = "IPv4";
+ char port_str[11];
+ const char *location_str = port_str;
+
+ /* a default CONNECT port is basically pointless but still ... */
+ size_t socket_idx;
+
+ while(argc>arg) {
+ if(!strcmp("--version", argv[arg])) {
+ puts("sws IPv4"
+#ifdef ENABLE_IPV6
+ "/IPv6"
+#endif
+#ifdef USE_UNIX_SOCKETS
+ "/unix"
+#endif
+ );
+ return 0;
+ }
+ else if(!strcmp("--pidfile", argv[arg])) {
+ arg++;
+ if(argc>arg)
+ pidname = argv[arg++];
+ }
+ else if(!strcmp("--portfile", argv[arg])) {
+ arg++;
+ if(argc>arg)
+ portname = argv[arg++];
+ }
+ else if(!strcmp("--logfile", argv[arg])) {
+ arg++;
+ if(argc>arg)
+ serverlogfile = argv[arg++];
+ }
+ else if(!strcmp("--cmdfile", argv[arg])) {
+ arg++;
+ if(argc>arg)
+ cmdfile = argv[arg++];
+ }
+ else if(!strcmp("--gopher", argv[arg])) {
+ arg++;
+ use_gopher = TRUE;
+ end_of_headers = "\r\n"; /* gopher style is much simpler */
+ }
+ else if(!strcmp("--ipv4", argv[arg])) {
+ socket_type = "IPv4";
+ socket_domain = AF_INET;
+ location_str = port_str;
+ arg++;
+ }
+ else if(!strcmp("--ipv6", argv[arg])) {
+#ifdef ENABLE_IPV6
+ socket_type = "IPv6";
+ socket_domain = AF_INET6;
+ location_str = port_str;
+#endif
+ arg++;
+ }
+ else if(!strcmp("--unix-socket", argv[arg])) {
+ arg++;
+ if(argc>arg) {
+#ifdef USE_UNIX_SOCKETS
+ unix_socket = argv[arg];
+ if(strlen(unix_socket) >= sizeof(me.sau.sun_path)) {
+ fprintf(stderr, "sws: socket path must be shorter than %zu chars\n",
+ sizeof(me.sau.sun_path));
+ return 0;
+ }
+ socket_type = "unix";
+ socket_domain = AF_UNIX;
+ location_str = unix_socket;
+#endif
+ arg++;
+ }
+ }
+ else if(!strcmp("--port", argv[arg])) {
+ arg++;
+ if(argc>arg) {
+ char *endptr;
+ unsigned long ulnum = strtoul(argv[arg], &endptr, 10);
+ if((endptr != argv[arg] + strlen(argv[arg])) ||
+ (ulnum && ((ulnum < 1025UL) || (ulnum > 65535UL)))) {
+ fprintf(stderr, "sws: invalid --port argument (%s)\n",
+ argv[arg]);
+ return 0;
+ }
+ port = curlx_ultous(ulnum);
+ arg++;
+ }
+ }
+ else if(!strcmp("--srcdir", argv[arg])) {
+ arg++;
+ if(argc>arg) {
+ path = argv[arg];
+ arg++;
+ }
+ }
+ else if(!strcmp("--connect", argv[arg])) {
+ /* The connect host IP number that the proxy will connect to no matter
+ what the client asks for, but also use this as a hint that we run as
+ a proxy and do a few different internal choices */
+ arg++;
+ if(argc>arg) {
+ connecthost = argv[arg];
+ arg++;
+ is_proxy = TRUE;
+ logmsg("Run as proxy, CONNECT to host %s", connecthost);
+ }
+ }
+ else {
+ puts("Usage: sws [option]\n"
+ " --version\n"
+ " --logfile [file]\n"
+ " --pidfile [file]\n"
+ " --portfile [file]\n"
+ " --ipv4\n"
+ " --ipv6\n"
+ " --unix-socket [file]\n"
+ " --port [port]\n"
+ " --srcdir [path]\n"
+ " --connect [ip4-addr]\n"
+ " --gopher");
+ return 0;
+ }
+ }
+
+#ifdef WIN32
+ win32_init();
+ atexit(win32_cleanup);
+#endif
+
+ install_signal_handlers(false);
+
+ req = calloc(1, sizeof(*req));
+ if(!req)
+ goto sws_cleanup;
+
+ sock = socket(socket_domain, SOCK_STREAM, 0);
+
+ all_sockets[0] = sock;
+ num_sockets = 1;
+
+ if(CURL_SOCKET_BAD == sock) {
+ error = SOCKERRNO;
+ logmsg("Error creating socket: (%d) %s",
+ error, strerror(error));
+ goto sws_cleanup;
+ }
+
+ flag = 1;
+ if(0 != setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
+ (void *)&flag, sizeof(flag))) {
+ error = SOCKERRNO;
+ logmsg("setsockopt(SO_REUSEADDR) failed with error: (%d) %s",
+ error, strerror(error));
+ goto sws_cleanup;
+ }
+ if(0 != curlx_nonblock(sock, TRUE)) {
+ error = SOCKERRNO;
+ logmsg("curlx_nonblock failed with error: (%d) %s",
+ error, strerror(error));
+ goto sws_cleanup;
+ }
+
+ switch(socket_domain) {
+ case AF_INET:
+ memset(&me.sa4, 0, sizeof(me.sa4));
+ me.sa4.sin_family = AF_INET;
+ me.sa4.sin_addr.s_addr = INADDR_ANY;
+ me.sa4.sin_port = htons(port);
+ rc = bind(sock, &me.sa, sizeof(me.sa4));
+ break;
+#ifdef ENABLE_IPV6
+ case AF_INET6:
+ memset(&me.sa6, 0, sizeof(me.sa6));
+ me.sa6.sin6_family = AF_INET6;
+ me.sa6.sin6_addr = in6addr_any;
+ me.sa6.sin6_port = htons(port);
+ rc = bind(sock, &me.sa, sizeof(me.sa6));
+ break;
+#endif /* ENABLE_IPV6 */
+#ifdef USE_UNIX_SOCKETS
+ case AF_UNIX:
+ rc = bind_unix_socket(sock, unix_socket, &me.sau);
+#endif /* USE_UNIX_SOCKETS */
+ }
+ if(0 != rc) {
+ error = SOCKERRNO;
+ logmsg("Error binding socket: (%d) %s", error, strerror(error));
+ goto sws_cleanup;
+ }
+
+ if(!port) {
+ /* The system was supposed to choose a port number, figure out which
+ port we actually got and update the listener port value with it. */
+ curl_socklen_t la_size;
+ srvr_sockaddr_union_t localaddr;
+#ifdef ENABLE_IPV6
+ if(socket_domain != AF_INET6)
+#endif
+ la_size = sizeof(localaddr.sa4);
+#ifdef ENABLE_IPV6
+ else
+ la_size = sizeof(localaddr.sa6);
+#endif
+ memset(&localaddr.sa, 0, (size_t)la_size);
+ if(getsockname(sock, &localaddr.sa, &la_size) < 0) {
+ error = SOCKERRNO;
+ logmsg("getsockname() failed with error: (%d) %s",
+ error, strerror(error));
+ sclose(sock);
+ goto sws_cleanup;
+ }
+ switch(localaddr.sa.sa_family) {
+ case AF_INET:
+ port = ntohs(localaddr.sa4.sin_port);
+ break;
+#ifdef ENABLE_IPV6
+ case AF_INET6:
+ port = ntohs(localaddr.sa6.sin6_port);
+ break;
+#endif
+ default:
+ break;
+ }
+ if(!port) {
+ /* Real failure, listener port shall not be zero beyond this point. */
+ logmsg("Apparently getsockname() succeeded, with listener port zero.");
+ logmsg("A valid reason for this failure is a binary built without");
+ logmsg("proper network library linkage. This might not be the only");
+ logmsg("reason, but double check it before anything else.");
+ sclose(sock);
+ goto sws_cleanup;
+ }
+ }
+#ifdef USE_UNIX_SOCKETS
+ if(socket_domain != AF_UNIX)
+#endif
+ msnprintf(port_str, sizeof(port_str), "port %hu", port);
+
+ logmsg("Running %s %s version on %s",
+ use_gopher?"GOPHER":"HTTP", socket_type, location_str);
+
+ /* start accepting connections */
+ rc = listen(sock, 5);
+ if(0 != rc) {
+ error = SOCKERRNO;
+ logmsg("listen() failed with error: (%d) %s",
+ error, strerror(error));
+ goto sws_cleanup;
+ }
+
+#ifdef USE_UNIX_SOCKETS
+ /* listen succeeds, so let's assume a valid listening Unix socket */
+ unlink_socket = true;
+#endif
+
+ /*
+ ** As soon as this server writes its pid file the test harness will
+ ** attempt to connect to this server and initiate its verification.
+ */
+
+ wrotepidfile = write_pidfile(pidname);
+ if(!wrotepidfile)
+ goto sws_cleanup;
+
+ wroteportfile = write_portfile(portname, port);
+ if(!wroteportfile)
+ goto sws_cleanup;
+
+ /* initialization of httprequest struct is done before get_request(), but
+ the pipelining struct field must be initialized previously to FALSE
+ every time a new connection arrives. */
+
+ init_httprequest(req);
+
+ for(;;) {
+ fd_set input;
+ fd_set output;
+ struct timeval timeout = {0, 250000L}; /* 250 ms */
+ curl_socket_t maxfd = (curl_socket_t)-1;
+ int active;
+
+ /* Clear out closed sockets */
+ for(socket_idx = num_sockets - 1; socket_idx >= 1; --socket_idx) {
+ if(CURL_SOCKET_BAD == all_sockets[socket_idx]) {
+ char *dst = (char *) (all_sockets + socket_idx);
+ char *src = (char *) (all_sockets + socket_idx + 1);
+ char *end = (char *) (all_sockets + num_sockets);
+ memmove(dst, src, end - src);
+ num_sockets -= 1;
+ }
+ }
+
+ if(got_exit_signal)
+ goto sws_cleanup;
+
+ /* Set up for select */
+ FD_ZERO(&input);
+ FD_ZERO(&output);
+
+ for(socket_idx = 0; socket_idx < num_sockets; ++socket_idx) {
+ /* Listen on all sockets */
+ FD_SET(all_sockets[socket_idx], &input);
+ if(all_sockets[socket_idx] > maxfd)
+ maxfd = all_sockets[socket_idx];
+ }
+
+ if(got_exit_signal)
+ goto sws_cleanup;
+
+ do {
+ rc = select((int)maxfd + 1, &input, &output, NULL, &timeout);
+ } while(rc < 0 && errno == EINTR && !got_exit_signal);
+
+ if(got_exit_signal)
+ goto sws_cleanup;
+
+ if(rc < 0) {
+ error = SOCKERRNO;
+ logmsg("select() failed with error: (%d) %s",
+ error, strerror(error));
+ goto sws_cleanup;
+ }
+
+ if(rc == 0) {
+ /* Timed out - try again */
+ continue;
+ }
+ active = rc; /* a positive number */
+
+ /* Check if the listening socket is ready to accept */
+ if(FD_ISSET(all_sockets[0], &input)) {
+ /* Service all queued connections */
+ curl_socket_t msgsock;
+ do {
+ msgsock = accept_connection(sock);
+ logmsg("accept_connection %d returned %d", sock, msgsock);
+ if(CURL_SOCKET_BAD == msgsock)
+ goto sws_cleanup;
+ } while(msgsock > 0);
+ active--;
+ }
+
+ /* Service all connections that are ready */
+ for(socket_idx = 1; (socket_idx < num_sockets) && active; ++socket_idx) {
+ if(FD_ISSET(all_sockets[socket_idx], &input)) {
+ active--;
+ if(got_exit_signal)
+ goto sws_cleanup;
+
+ /* Service this connection until it has nothing available */
+ do {
+ rc = service_connection(all_sockets[socket_idx], req, sock,
+ connecthost);
+ if(got_exit_signal)
+ goto sws_cleanup;
+
+ if(rc < 0) {
+ logmsg("====> Client disconnect %d", req->connmon);
+
+ if(req->connmon) {
+ const char *keepopen = "[DISCONNECT]\n";
+ storerequest(keepopen, strlen(keepopen));
+ }
+
+ if(!req->open)
+ /* When instructed to close connection after server-reply we
+ wait a very small amount of time before doing so. If this
+ is not done client might get an ECONNRESET before reading
+ a single byte of server-reply. */
+ wait_ms(50);
+
+ if(all_sockets[socket_idx] != CURL_SOCKET_BAD) {
+ sclose(all_sockets[socket_idx]);
+ all_sockets[socket_idx] = CURL_SOCKET_BAD;
+ }
+
+ serverlogslocked -= 1;
+ if(!serverlogslocked)
+ clear_advisor_read_lock(SERVERLOGS_LOCK);
+
+ if(req->testno == DOCNUMBER_QUIT)
+ goto sws_cleanup;
+ }
+
+ /* Reset the request, unless we're still in the middle of reading */
+ if(rc && !req->upgrade_request)
+ init_httprequest(req);
+ } while(rc > 0);
+ }
+ }
+
+ if(got_exit_signal)
+ goto sws_cleanup;
+ }
+
+sws_cleanup:
+
+ for(socket_idx = 1; socket_idx < num_sockets; ++socket_idx)
+ if((all_sockets[socket_idx] != sock) &&
+ (all_sockets[socket_idx] != CURL_SOCKET_BAD))
+ sclose(all_sockets[socket_idx]);
+
+ if(sock != CURL_SOCKET_BAD)
+ sclose(sock);
+
+#ifdef USE_UNIX_SOCKETS
+ if(unlink_socket && socket_domain == AF_UNIX) {
+ rc = unlink(unix_socket);
+ logmsg("unlink(%s) = %d (%s)", unix_socket, rc, strerror(rc));
+ }
+#endif
+
+ free(req);
+
+ if(got_exit_signal)
+ logmsg("signalled to die");
+
+ if(wrotepidfile)
+ unlink(pidname);
+ if(wroteportfile)
+ unlink(portname);
+
+ if(serverlogslocked) {
+ serverlogslocked = 0;
+ clear_advisor_read_lock(SERVERLOGS_LOCK);
+ }
+
+ restore_signal_handlers(false);
+
+ if(got_exit_signal) {
+ logmsg("========> %s sws (%s pid: %ld) exits with signal (%d)",
+ socket_type, location_str, (long)getpid(), exit_signal);
+ /*
+ * To properly set the return status of the process we
+ * must raise the same signal SIGINT or SIGTERM that we
+ * caught and let the old handler take care of it.
+ */
+ raise(exit_signal);
+ }
+
+ logmsg("========> sws quits");
+ return 0;
+}