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