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