2002-09-03 13:52:59 +02:00
|
|
|
/***************************************************************************
|
2004-05-28 11:52:15 +02:00
|
|
|
* _ _ ____ _
|
|
|
|
* Project ___| | | | _ \| |
|
|
|
|
* / __| | | | |_) | |
|
|
|
|
* | (__| |_| | _ <| |___
|
2002-05-21 10:22:00 +02:00
|
|
|
* \___|\___/|_| \_\_____|
|
|
|
|
*
|
2007-02-14 01:28:01 +01:00
|
|
|
* Copyright (C) 1998 - 2007, Daniel Stenberg, <daniel@haxx.se>, et al.
|
2002-05-21 10:22:00 +02:00
|
|
|
*
|
2002-09-03 13:52:59 +02:00
|
|
|
* This software is licensed as described in the file COPYING, which
|
|
|
|
* you should have received as part of this distribution. The terms
|
|
|
|
* are also available at http://curl.haxx.se/docs/copyright.html.
|
2004-05-28 11:52:15 +02:00
|
|
|
*
|
2002-05-21 10:22:00 +02:00
|
|
|
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
|
|
|
|
* copies of the Software, and permit persons to whom the Software is
|
2002-09-03 13:52:59 +02:00
|
|
|
* furnished to do so, under the terms of the COPYING file.
|
2002-05-21 10:22:00 +02:00
|
|
|
*
|
|
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
|
|
* KIND, either express or implied.
|
|
|
|
*
|
|
|
|
* $Id$
|
2002-09-03 13:52:59 +02:00
|
|
|
***************************************************************************/
|
2002-05-21 10:22:00 +02:00
|
|
|
|
|
|
|
/* sws.c: simple (silly?) web server
|
|
|
|
|
2002-12-13 17:20:07 +01:00
|
|
|
This code was originally graciously donated to the project by Juergen
|
2002-05-21 10:22:00 +02:00
|
|
|
Wilke. Thanks a bunch!
|
2002-12-13 17:20:07 +01:00
|
|
|
|
2002-05-21 10:22:00 +02:00
|
|
|
*/
|
2003-10-09 10:12:43 +02:00
|
|
|
#include "setup.h" /* portability help from the lib directory */
|
2002-02-07 10:39:15 +01:00
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
2003-07-20 01:44:22 +02:00
|
|
|
#include <stdarg.h>
|
2002-02-07 10:39:15 +01:00
|
|
|
#include <signal.h>
|
2002-03-06 10:40:06 +01:00
|
|
|
#include <time.h>
|
2002-02-07 10:39:15 +01:00
|
|
|
#include <sys/time.h>
|
|
|
|
#include <sys/types.h>
|
2005-05-19 11:55:53 +02:00
|
|
|
#include <ctype.h>
|
2004-04-17 13:38:41 +02:00
|
|
|
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
2004-03-05 09:32:11 +01:00
|
|
|
#ifdef HAVE_SYS_SOCKET_H
|
2002-02-07 10:39:15 +01:00
|
|
|
#include <sys/socket.h>
|
2004-03-05 09:32:11 +01:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_NETINET_IN_H
|
2002-02-07 10:39:15 +01:00
|
|
|
#include <netinet/in.h>
|
2004-03-05 09:32:11 +01:00
|
|
|
#endif
|
2003-03-15 15:47:09 +01:00
|
|
|
#ifdef _XOPEN_SOURCE_EXTENDED
|
|
|
|
/* This define is "almost" required to build on HPUX 11 */
|
2004-05-28 11:52:15 +02:00
|
|
|
#include <arpa/inet.h>
|
2003-03-15 15:47:09 +01:00
|
|
|
#endif
|
2004-03-09 09:38:25 +01:00
|
|
|
#ifdef HAVE_NETDB_H
|
2002-02-07 10:39:15 +01:00
|
|
|
#include <netdb.h>
|
2004-03-09 09:38:25 +01:00
|
|
|
#endif
|
2007-10-02 12:13:37 +02:00
|
|
|
#ifdef HAVE_NETINET_TCP_H
|
|
|
|
#include <netinet/tcp.h> /* for TCP_NODELAY */
|
|
|
|
#endif
|
2002-02-22 14:54:06 +01:00
|
|
|
|
2005-05-01 14:56:09 +02:00
|
|
|
#define ENABLE_CURLX_PRINTF
|
|
|
|
/* make the curlx header define all printf() functions to use the curlx_*
|
|
|
|
versions instead */
|
2004-10-08 00:57:24 +02:00
|
|
|
#include "curlx.h" /* from the private lib dir */
|
2004-02-20 08:19:18 +01:00
|
|
|
#include "getpart.h"
|
2005-05-01 01:30:55 +02:00
|
|
|
#include "util.h"
|
2004-02-20 08:19:18 +01:00
|
|
|
|
2004-11-29 13:10:09 +01:00
|
|
|
/* include memdebug.h last */
|
|
|
|
#include "memdebug.h"
|
|
|
|
|
2006-04-10 15:11:52 +02:00
|
|
|
#if !defined(CURL_SWS_FORK_ENABLED) && defined(HAVE_FORK)
|
2006-01-02 13:19:12 +01:00
|
|
|
/*
|
|
|
|
* The normal sws build for the plain standard curl test suite has no use for
|
|
|
|
* fork(), but if you feel wild and crazy and want to setup some more exotic
|
|
|
|
* tests. Define this and run...
|
|
|
|
*/
|
2006-04-10 15:11:52 +02:00
|
|
|
#define CURL_SWS_FORK_ENABLED
|
|
|
|
#endif
|
2006-01-02 13:19:12 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
#define REQBUFSIZ 150000
|
|
|
|
#define REQBUFSIZ_TXT "149999"
|
|
|
|
|
2004-03-31 13:50:44 +02:00
|
|
|
long prevtestno=-1; /* previous test number we served */
|
|
|
|
long prevpartno=-1; /* previous part number we served */
|
|
|
|
bool prevbounce; /* instructs the server to increase the part number for
|
|
|
|
a test in case the identical testno+partno request
|
|
|
|
shows up again */
|
|
|
|
|
2006-01-02 13:19:12 +01:00
|
|
|
#define RCMD_NORMALREQ 0 /* default request, use the tests file normally */
|
|
|
|
#define RCMD_IDLE 1 /* told to sit idle */
|
|
|
|
#define RCMD_STREAM 2 /* told to stream */
|
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
struct httprequest {
|
|
|
|
char reqbuf[REQBUFSIZ]; /* buffer area for the incoming request */
|
2006-09-08 13:56:56 +02:00
|
|
|
int checkindex; /* where to start checking of the request */
|
2004-03-05 09:32:11 +01:00
|
|
|
int offset; /* size of the incoming request */
|
2004-03-23 09:50:28 +01:00
|
|
|
long testno; /* test number found in the request */
|
2004-03-31 13:50:44 +02:00
|
|
|
long partno; /* part number found in the request */
|
2004-03-05 09:32:11 +01:00
|
|
|
int open; /* keep connection open info, as found in the request */
|
|
|
|
bool auth_req; /* authentication required, don't wait for body unless
|
|
|
|
there's an Authorization header */
|
|
|
|
bool auth; /* Authorization header present in the incoming request */
|
|
|
|
size_t cl; /* Content-Length of the incoming request */
|
|
|
|
bool digest; /* Authorization digest header found */
|
|
|
|
bool ntlm; /* Authorization ntlm header found */
|
2006-09-08 13:56:56 +02:00
|
|
|
int pipe; /* if non-zero, expect this many requests to do a "piped"
|
|
|
|
request/response */
|
2006-01-02 13:19:12 +01:00
|
|
|
int rcmd; /* doing a special command, see defines above */
|
2004-03-05 09:32:11 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
int ProcessRequest(struct httprequest *req);
|
2004-02-20 08:19:18 +01:00
|
|
|
void storerequest(char *reqbuf);
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2002-02-07 13:40:06 +01:00
|
|
|
#define DEFAULT_PORT 8999
|
2002-02-07 10:39:15 +01:00
|
|
|
|
|
|
|
#ifndef DEFAULT_LOGFILE
|
2002-02-22 11:40:05 +01:00
|
|
|
#define DEFAULT_LOGFILE "log/sws.log"
|
2002-02-07 10:39:15 +01:00
|
|
|
#endif
|
|
|
|
|
2005-05-01 01:30:55 +02:00
|
|
|
const char *serverlogfile = DEFAULT_LOGFILE;
|
|
|
|
|
2003-10-09 10:12:43 +02:00
|
|
|
#define SWSVERSION "cURL test suite HTTP server/0.1"
|
2002-02-07 13:40:06 +01:00
|
|
|
|
2002-12-10 13:59:16 +01:00
|
|
|
#define REQUEST_DUMP "log/server.input"
|
|
|
|
#define RESPONSE_DUMP "log/server.response"
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
/* very-big-path support */
|
|
|
|
#define MAXDOCNAMELEN 140000
|
|
|
|
#define MAXDOCNAMELEN_TXT "139999"
|
|
|
|
|
|
|
|
#define REQUEST_KEYWORD_SIZE 256
|
|
|
|
|
|
|
|
#define CMD_AUTH_REQUIRED "auth_required"
|
|
|
|
|
2006-01-02 13:19:12 +01:00
|
|
|
/* 'idle' means that it will accept the request fine but never respond
|
|
|
|
any data. Just keep the connection alive. */
|
|
|
|
#define CMD_IDLE "idle"
|
|
|
|
|
|
|
|
/* 'stream' means to send a never-ending stream of data */
|
|
|
|
#define CMD_STREAM "stream"
|
|
|
|
|
2004-04-17 13:38:41 +02:00
|
|
|
#define END_OF_HEADERS "\r\n\r\n"
|
|
|
|
|
2002-12-13 17:20:07 +01:00
|
|
|
enum {
|
2004-03-05 09:32:11 +01:00
|
|
|
DOCNUMBER_NOTHING = -7,
|
2003-07-01 17:21:42 +02:00
|
|
|
DOCNUMBER_QUIT = -6,
|
2002-12-13 17:20:07 +01:00
|
|
|
DOCNUMBER_BADCONNECT = -5,
|
|
|
|
DOCNUMBER_INTERNAL= -4,
|
|
|
|
DOCNUMBER_CONNECT = -3,
|
|
|
|
DOCNUMBER_WERULEZ = -2,
|
|
|
|
DOCNUMBER_404 = -1
|
|
|
|
};
|
|
|
|
|
2003-07-01 17:21:42 +02:00
|
|
|
|
|
|
|
/* sent as reply to a QUIT */
|
|
|
|
static const char *docquit =
|
2004-04-17 13:38:41 +02:00
|
|
|
"HTTP/1.1 200 Goodbye" END_OF_HEADERS;
|
2003-07-01 17:21:42 +02:00
|
|
|
|
2002-12-13 17:20:07 +01:00
|
|
|
/* sent as reply to a CONNECT */
|
|
|
|
static const char *docconnect =
|
2004-04-17 13:38:41 +02:00
|
|
|
"HTTP/1.1 200 Mighty fine indeed" END_OF_HEADERS;
|
2002-12-13 17:20:07 +01:00
|
|
|
|
|
|
|
/* sent as reply to a "bad" CONNECT */
|
|
|
|
static const char *docbadconnect =
|
2004-04-17 13:38:41 +02:00
|
|
|
"HTTP/1.1 501 Forbidden you fool" END_OF_HEADERS;
|
2002-12-13 17:20:07 +01:00
|
|
|
|
|
|
|
/* send back this on 404 file not found */
|
2004-04-17 13:38:41 +02:00
|
|
|
static const char *doc404 = "HTTP/1.1 404 Not Found\r\n"
|
|
|
|
"Server: " SWSVERSION "\r\n"
|
|
|
|
"Connection: close\r\n"
|
|
|
|
"Content-Type: text/html"
|
|
|
|
END_OF_HEADERS
|
2002-02-07 10:39:15 +01:00
|
|
|
"<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n"
|
|
|
|
"<HTML><HEAD>\n"
|
|
|
|
"<TITLE>404 Not Found</TITLE>\n"
|
|
|
|
"</HEAD><BODY>\n"
|
|
|
|
"<H1>Not Found</H1>\n"
|
|
|
|
"The requested URL was not found on this server.\n"
|
2003-10-09 10:12:43 +02:00
|
|
|
"<P><HR><ADDRESS>" SWSVERSION "</ADDRESS>\n" "</BODY></HTML>\n";
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
#ifdef SIGPIPE
|
2004-04-17 13:38:41 +02:00
|
|
|
static volatile int sigpipe; /* Why? It's not used */
|
2002-05-17 10:15:33 +02:00
|
|
|
#endif
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
#ifdef SIGPIPE
|
2002-02-07 10:39:15 +01:00
|
|
|
static void sigpipe_handler(int sig)
|
|
|
|
{
|
2002-05-17 10:15:33 +02:00
|
|
|
(void)sig; /* prevent warning */
|
|
|
|
sigpipe = 1;
|
2002-02-07 10:39:15 +01:00
|
|
|
}
|
2002-05-17 10:15:33 +02:00
|
|
|
#endif
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
int ProcessRequest(struct httprequest *req)
|
|
|
|
{
|
2006-09-08 13:56:56 +02:00
|
|
|
char *line=&req->reqbuf[req->checkindex];
|
2004-03-05 09:32:11 +01:00
|
|
|
char chunked=FALSE;
|
|
|
|
static char request[REQUEST_KEYWORD_SIZE];
|
|
|
|
static char doc[MAXDOCNAMELEN];
|
|
|
|
char logbuf[256];
|
|
|
|
int prot_major, prot_minor;
|
2002-02-07 10:39:15 +01:00
|
|
|
char *end;
|
2007-02-19 03:03:58 +01:00
|
|
|
int error;
|
2006-09-08 13:56:56 +02:00
|
|
|
end = strstr(line, END_OF_HEADERS);
|
|
|
|
|
|
|
|
logmsg("ProcessRequest() called");
|
2004-03-05 09:32:11 +01:00
|
|
|
|
|
|
|
/* try to figure out the request characteristics as soon as possible, but
|
|
|
|
only once! */
|
|
|
|
if((req->testno == DOCNUMBER_NOTHING) &&
|
|
|
|
sscanf(line, "%" REQBUFSIZ_TXT"s %" MAXDOCNAMELEN_TXT "s HTTP/%d.%d",
|
|
|
|
request,
|
|
|
|
doc,
|
|
|
|
&prot_major,
|
|
|
|
&prot_minor) == 4) {
|
|
|
|
char *ptr;
|
|
|
|
|
|
|
|
/* find the last slash */
|
|
|
|
ptr = strrchr(doc, '/');
|
|
|
|
|
|
|
|
/* get the number after it */
|
|
|
|
if(ptr) {
|
|
|
|
FILE *stream;
|
|
|
|
char *filename;
|
|
|
|
|
|
|
|
if((strlen(doc) + strlen(request)) < 200)
|
|
|
|
sprintf(logbuf, "Got request: %s %s HTTP/%d.%d",
|
|
|
|
request, doc, prot_major, prot_minor);
|
|
|
|
else
|
|
|
|
sprintf(logbuf, "Got a *HUGE* request HTTP/%d.%d",
|
|
|
|
prot_major, prot_minor);
|
2006-02-18 23:27:01 +01:00
|
|
|
logmsg("%s", logbuf);
|
2004-05-28 11:52:15 +02:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
if(!strncmp("/verifiedserver", ptr, 15)) {
|
|
|
|
logmsg("Are-we-friendly question received");
|
|
|
|
req->testno = DOCNUMBER_WERULEZ;
|
|
|
|
return 1; /* done */
|
|
|
|
}
|
|
|
|
|
2006-10-23 21:16:19 +02:00
|
|
|
if(!strncmp("/quit", ptr, 5)) {
|
2004-03-05 09:32:11 +01:00
|
|
|
logmsg("Request-to-quit received");
|
|
|
|
req->testno = DOCNUMBER_QUIT;
|
|
|
|
return 1; /* done */
|
|
|
|
}
|
|
|
|
|
|
|
|
ptr++; /* skip the slash */
|
|
|
|
|
2005-05-18 22:01:01 +02:00
|
|
|
/* skip all non-numericals following the slash */
|
2006-10-23 21:14:54 +02:00
|
|
|
while(*ptr && !ISDIGIT(*ptr))
|
2005-05-18 22:01:01 +02:00
|
|
|
ptr++;
|
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
req->testno = strtol(ptr, &ptr, 10);
|
|
|
|
|
|
|
|
if(req->testno > 10000) {
|
|
|
|
req->partno = req->testno % 10000;
|
|
|
|
req->testno /= 10000;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
req->partno = 0;
|
|
|
|
|
2004-04-17 13:38:41 +02:00
|
|
|
sprintf(logbuf, "Requested test number %ld part %ld",
|
2004-03-05 09:32:11 +01:00
|
|
|
req->testno, req->partno);
|
|
|
|
|
2006-02-18 23:27:01 +01:00
|
|
|
logmsg("%s", logbuf);
|
2004-03-05 09:32:11 +01:00
|
|
|
|
|
|
|
filename = test2file(req->testno);
|
|
|
|
|
|
|
|
stream=fopen(filename, "rb");
|
|
|
|
if(!stream) {
|
2007-02-19 03:03:58 +01:00
|
|
|
error = ERRNO;
|
|
|
|
logmsg("fopen() failed with error: %d %s", error, strerror(error));
|
|
|
|
logmsg("Error opening file: %s", filename);
|
2004-03-05 09:32:11 +01:00
|
|
|
logmsg("Couldn't open test file %d", req->testno);
|
2004-12-09 10:58:25 +01:00
|
|
|
req->open = FALSE; /* closes connection */
|
2005-05-18 22:01:01 +02:00
|
|
|
return 1; /* done */
|
2004-03-05 09:32:11 +01:00
|
|
|
}
|
2004-05-28 11:52:15 +02:00
|
|
|
else {
|
2004-03-31 13:50:44 +02:00
|
|
|
char *cmd = NULL;
|
|
|
|
size_t cmdsize = 0;
|
2006-09-08 13:56:56 +02:00
|
|
|
int num=0;
|
2004-03-31 13:50:44 +02:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
/* get the custom server control "commands" */
|
|
|
|
cmd = (char *)spitout(stream, "reply", "servercmd", &cmdsize);
|
|
|
|
fclose(stream);
|
|
|
|
|
|
|
|
if(cmdsize) {
|
|
|
|
logmsg("Found a reply-servercmd section!");
|
|
|
|
|
|
|
|
if(!strncmp(CMD_AUTH_REQUIRED, cmd, strlen(CMD_AUTH_REQUIRED))) {
|
|
|
|
logmsg("instructed to require authorization header");
|
|
|
|
req->auth_req = TRUE;
|
|
|
|
}
|
2006-01-02 13:19:12 +01:00
|
|
|
else if(!strncmp(CMD_IDLE, cmd, strlen(CMD_IDLE))) {
|
|
|
|
logmsg("instructed to idle");
|
|
|
|
req->rcmd = RCMD_IDLE;
|
|
|
|
req->open = TRUE;
|
|
|
|
}
|
|
|
|
else if(!strncmp(CMD_STREAM, cmd, strlen(CMD_STREAM))) {
|
|
|
|
logmsg("instructed to stream");
|
|
|
|
req->rcmd = RCMD_STREAM;
|
|
|
|
}
|
2006-09-08 13:56:56 +02:00
|
|
|
else if(1 == sscanf(cmd, "pipe: %d", &num)) {
|
|
|
|
logmsg("instructed to allow a pipe size %d", num);
|
|
|
|
req->pipe = num-1; /* decrease by one since we don't count the
|
|
|
|
first request in this number */
|
|
|
|
}
|
2004-03-31 13:50:44 +02:00
|
|
|
free(cmd);
|
2004-03-05 09:32:11 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if(sscanf(req->reqbuf, "CONNECT %" MAXDOCNAMELEN_TXT "s HTTP/%d.%d",
|
|
|
|
doc, &prot_major, &prot_minor) == 3) {
|
2006-02-25 19:57:20 +01:00
|
|
|
sprintf(logbuf, "Received a CONNECT %s HTTP/%d.%d request",
|
2004-03-05 09:32:11 +01:00
|
|
|
doc, prot_major, prot_minor);
|
2006-02-18 23:27:01 +01:00
|
|
|
logmsg("%s", logbuf);
|
2004-03-05 09:32:11 +01:00
|
|
|
|
|
|
|
if(prot_major*10+prot_minor == 10)
|
|
|
|
req->open = FALSE; /* HTTP 1.0 closes connection by default */
|
|
|
|
|
|
|
|
if(!strncmp(doc, "bad", 3))
|
|
|
|
/* if the host name starts with bad, we fake an error here */
|
|
|
|
req->testno = DOCNUMBER_BADCONNECT;
|
|
|
|
else if(!strncmp(doc, "test", 4)) {
|
2004-12-02 18:11:09 +01:00
|
|
|
/* if the host name starts with test, the port number used in the
|
|
|
|
CONNECT line will be used as test number! */
|
2006-05-10 11:53:52 +02:00
|
|
|
char *portp = strchr(doc, ':');
|
|
|
|
if(portp)
|
|
|
|
req->testno = atoi(portp+1);
|
2004-03-05 09:32:11 +01:00
|
|
|
else
|
|
|
|
req->testno = DOCNUMBER_CONNECT;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
req->testno = DOCNUMBER_CONNECT;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
logmsg("Did not find test number in PATH");
|
|
|
|
req->testno = DOCNUMBER_404;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2006-09-08 13:56:56 +02:00
|
|
|
if(!end) {
|
2002-02-07 10:39:15 +01:00
|
|
|
/* we don't have a complete request yet! */
|
2006-09-08 13:56:56 +02:00
|
|
|
logmsg("ProcessRequest returned without a complete request");
|
2002-02-07 10:39:15 +01:00
|
|
|
return 0;
|
2006-09-08 13:56:56 +02:00
|
|
|
}
|
|
|
|
logmsg("ProcessRequest found a complete request");
|
|
|
|
|
|
|
|
if(req->pipe)
|
|
|
|
/* we do have a full set, advance the checkindex to after the end of the
|
|
|
|
headers, for the pipelining case mostly */
|
|
|
|
req->checkindex += (end - line) + strlen(END_OF_HEADERS);
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2002-02-07 13:52:04 +01:00
|
|
|
/* **** Persistancy ****
|
|
|
|
*
|
|
|
|
* If the request is a HTTP/1.0 one, we close the connection unconditionally
|
|
|
|
* when we're done.
|
|
|
|
*
|
|
|
|
* If the request is a HTTP/1.1 one, we MUST check for a "Connection:"
|
|
|
|
* header that might say "close". If it does, we close a connection when
|
|
|
|
* this request is processed. Otherwise, we keep the connection alive for X
|
|
|
|
* seconds.
|
|
|
|
*/
|
|
|
|
|
2002-02-07 10:39:15 +01:00
|
|
|
do {
|
2004-10-08 00:57:24 +02:00
|
|
|
if(!req->cl && curlx_strnequal("Content-Length:", line, 15)) {
|
2004-03-05 09:32:11 +01:00
|
|
|
/* If we don't ignore content-length, we read it and we read the whole
|
|
|
|
request including the body before we return. If we've been told to
|
|
|
|
ignore the content-length, we will return as soon as all headers
|
|
|
|
have been received */
|
|
|
|
req->cl = strtol(line+15, &line, 10);
|
|
|
|
|
2005-03-29 00:15:17 +02:00
|
|
|
logmsg("Found Content-Length: %d in the request", req->cl);
|
2002-12-10 13:59:16 +01:00
|
|
|
break;
|
|
|
|
}
|
2004-10-08 00:57:24 +02:00
|
|
|
else if(curlx_strnequal("Transfer-Encoding: chunked", line,
|
|
|
|
strlen("Transfer-Encoding: chunked"))) {
|
2002-12-10 13:59:16 +01:00
|
|
|
/* chunked data coming in */
|
|
|
|
chunked = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(chunked) {
|
2005-09-07 12:51:37 +02:00
|
|
|
if(strstr(req->reqbuf, "\r\n0\r\n\r\n"))
|
2002-12-10 13:59:16 +01:00
|
|
|
/* end of chunks reached */
|
|
|
|
return 1; /* done */
|
|
|
|
else
|
|
|
|
return 0; /* not done */
|
|
|
|
}
|
2002-02-07 10:39:15 +01:00
|
|
|
|
|
|
|
line = strchr(line, '\n');
|
|
|
|
if(line)
|
|
|
|
line++;
|
|
|
|
} while(line);
|
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
if(!req->auth && strstr(req->reqbuf, "Authorization:")) {
|
|
|
|
req->auth = TRUE; /* Authorization: header present! */
|
|
|
|
if(req->auth_req)
|
|
|
|
logmsg("Authorization header found, as required");
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!req->digest && strstr(req->reqbuf, "Authorization: Digest")) {
|
|
|
|
/* If the client is passing this Digest-header, we set the part number
|
|
|
|
to 1000. Not only to spice up the complexity of this, but to make
|
|
|
|
Digest stuff to work in the test suite. */
|
|
|
|
req->partno += 1000;
|
|
|
|
req->digest = TRUE; /* header found */
|
|
|
|
logmsg("Received Digest request, sending back data %d", req->partno);
|
|
|
|
}
|
|
|
|
else if(!req->ntlm &&
|
|
|
|
strstr(req->reqbuf, "Authorization: NTLM TlRMTVNTUAAD")) {
|
|
|
|
/* If the client is passing this type-3 NTLM header */
|
|
|
|
req->partno += 1002;
|
|
|
|
req->ntlm = TRUE; /* NTLM found */
|
2006-01-02 13:19:12 +01:00
|
|
|
logmsg("Received NTLM type-3, sending back data %d", req->partno);
|
2005-03-29 00:15:17 +02:00
|
|
|
if(req->cl) {
|
|
|
|
logmsg(" Expecting %d POSTed bytes", req->cl);
|
|
|
|
}
|
2004-03-05 09:32:11 +01:00
|
|
|
}
|
|
|
|
else if(!req->ntlm &&
|
|
|
|
strstr(req->reqbuf, "Authorization: NTLM TlRMTVNTUAAB")) {
|
|
|
|
/* If the client is passing this type-1 NTLM header */
|
|
|
|
req->partno += 1001;
|
|
|
|
req->ntlm = TRUE; /* NTLM found */
|
|
|
|
logmsg("Received NTLM type-1, sending back data %d", req->partno);
|
|
|
|
}
|
|
|
|
if(strstr(req->reqbuf, "Connection: close"))
|
|
|
|
req->open = FALSE; /* close connection after this request */
|
2004-03-31 13:50:44 +02:00
|
|
|
|
2006-09-08 13:56:56 +02:00
|
|
|
while(req->pipe) {
|
|
|
|
/* scan for more header ends within this chunk */
|
|
|
|
line = &req->reqbuf[req->checkindex];
|
|
|
|
end = strstr(line, END_OF_HEADERS);
|
|
|
|
if(!end)
|
|
|
|
break;
|
|
|
|
req->checkindex += (end - line) + strlen(END_OF_HEADERS);
|
|
|
|
req->pipe--;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-03-29 00:15:17 +02:00
|
|
|
/* If authentication is required and no auth was provided, end now. This
|
|
|
|
makes the server NOT wait for PUT/POST data and you can then make the
|
|
|
|
test case send a rejection before any such data has been sent. Test case
|
|
|
|
154 uses this.*/
|
|
|
|
if(req->auth_req && !req->auth)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if(req->cl) {
|
2004-03-05 09:32:11 +01:00
|
|
|
if(req->cl <= strlen(end+strlen(END_OF_HEADERS)))
|
2002-02-07 10:39:15 +01:00
|
|
|
return 1; /* done */
|
|
|
|
else
|
|
|
|
return 0; /* not complete yet */
|
|
|
|
}
|
2006-09-08 13:56:56 +02:00
|
|
|
|
2002-02-07 10:39:15 +01:00
|
|
|
return 1; /* done */
|
|
|
|
}
|
|
|
|
|
2002-02-07 13:40:06 +01:00
|
|
|
/* store the entire request in a file */
|
|
|
|
void storerequest(char *reqbuf)
|
|
|
|
{
|
2007-02-14 01:28:01 +01:00
|
|
|
int error;
|
|
|
|
ssize_t written;
|
|
|
|
ssize_t writeleft;
|
|
|
|
ssize_t totalsize;
|
2002-02-07 13:40:06 +01:00
|
|
|
FILE *dump;
|
|
|
|
|
2007-02-14 01:28:01 +01:00
|
|
|
if (reqbuf == NULL)
|
|
|
|
return;
|
2002-02-07 13:40:06 +01:00
|
|
|
|
2007-02-14 14:46:08 +01:00
|
|
|
totalsize = (ssize_t)strlen(reqbuf);
|
2007-02-14 01:28:01 +01:00
|
|
|
if (totalsize == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
do {
|
|
|
|
dump = fopen(REQUEST_DUMP, "ab");
|
2007-02-16 17:01:19 +01:00
|
|
|
} while ((dump == NULL) && ((error = ERRNO) == EINTR));
|
2007-02-14 01:28:01 +01:00
|
|
|
if (dump == NULL) {
|
2007-10-10 01:24:28 +02:00
|
|
|
logmsg("Error opening file %s error: %d %s",
|
|
|
|
REQUEST_DUMP, error, strerror(error));
|
2007-02-14 01:28:01 +01:00
|
|
|
logmsg("Failed to write request input to " REQUEST_DUMP);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
writeleft = totalsize;
|
|
|
|
do {
|
2007-02-14 14:46:08 +01:00
|
|
|
written = (ssize_t)fwrite((void *) &reqbuf[totalsize-writeleft],
|
|
|
|
1, (size_t)writeleft, dump);
|
2007-02-14 01:28:01 +01:00
|
|
|
if (written > 0)
|
|
|
|
writeleft -= written;
|
2007-02-16 17:01:19 +01:00
|
|
|
} while ((writeleft > 0) && ((error = ERRNO) == EINTR));
|
2007-02-14 01:28:01 +01:00
|
|
|
|
|
|
|
fclose(dump); /* close it ASAP */
|
|
|
|
|
|
|
|
if (writeleft > 0) {
|
2007-10-10 01:24:28 +02:00
|
|
|
logmsg("Error writing file %s error: %d %s",
|
|
|
|
REQUEST_DUMP, error, strerror(error));
|
2007-02-14 01:28:01 +01:00
|
|
|
logmsg("Wrote only (%d bytes) of (%d bytes) request input to %s",
|
|
|
|
totalsize-writeleft, totalsize, REQUEST_DUMP);
|
2003-04-03 15:43:15 +02:00
|
|
|
}
|
|
|
|
else {
|
2007-02-14 01:28:01 +01:00
|
|
|
logmsg("Wrote request (%d bytes) input to " REQUEST_DUMP,
|
|
|
|
totalsize);
|
2002-02-07 13:40:06 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
/* return 0 on success, non-zero on failure */
|
2006-07-18 00:44:40 +02:00
|
|
|
static int get_request(curl_socket_t sock, struct httprequest *req)
|
2004-03-05 09:32:11 +01:00
|
|
|
{
|
|
|
|
int fail= FALSE;
|
|
|
|
char *reqbuf = req->reqbuf;
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
/*** Init the httpreqest structure properly for the upcoming request ***/
|
|
|
|
memset(req, 0, sizeof(struct httprequest));
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
/* here's what should not be 0 from the start */
|
|
|
|
req->testno = DOCNUMBER_NOTHING; /* safe default */
|
|
|
|
req->open = TRUE; /* connection should remain open and wait for more
|
|
|
|
commands */
|
2006-09-08 13:56:56 +02:00
|
|
|
req->pipe = 0;
|
2002-02-22 14:54:06 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
/*** end of httprequest init ***/
|
2003-07-20 01:44:22 +02:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
while (req->offset < REQBUFSIZ) {
|
2006-07-12 08:52:40 +02:00
|
|
|
ssize_t got = sread(sock, reqbuf + req->offset, REQBUFSIZ - req->offset);
|
2002-02-07 10:39:15 +01:00
|
|
|
if (got <= 0) {
|
|
|
|
if (got < 0) {
|
2007-02-16 17:01:19 +01:00
|
|
|
logmsg("recv() returned error: %d", SOCKERRNO);
|
2002-12-13 17:20:07 +01:00
|
|
|
return DOCNUMBER_INTERNAL;
|
2002-02-07 10:39:15 +01:00
|
|
|
}
|
|
|
|
logmsg("Connection closed by client");
|
2004-06-21 16:00:11 +02:00
|
|
|
reqbuf[req->offset]=0;
|
|
|
|
|
|
|
|
/* dump the request receivied so far to the external file */
|
|
|
|
storerequest(reqbuf);
|
2002-12-13 17:20:07 +01:00
|
|
|
return DOCNUMBER_INTERNAL;
|
2002-02-07 10:39:15 +01:00
|
|
|
}
|
2006-09-08 13:56:56 +02:00
|
|
|
|
|
|
|
logmsg("Read %d bytes", got);
|
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
req->offset += got;
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
reqbuf[req->offset] = 0;
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2006-09-08 13:56:56 +02:00
|
|
|
if(ProcessRequest(req)) {
|
|
|
|
if(req->pipe--) {
|
|
|
|
logmsg("Waiting for another piped request");
|
|
|
|
continue;
|
|
|
|
}
|
2002-02-07 10:39:15 +01:00
|
|
|
break;
|
2006-09-08 13:56:56 +02:00
|
|
|
}
|
2002-02-07 10:39:15 +01:00
|
|
|
}
|
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
if (req->offset >= REQBUFSIZ) {
|
2002-02-07 10:39:15 +01:00
|
|
|
logmsg("Request buffer overflow, closing connection");
|
2004-01-30 10:27:27 +01:00
|
|
|
reqbuf[REQBUFSIZ-1]=0;
|
2004-03-05 09:32:11 +01:00
|
|
|
fail = TRUE;
|
|
|
|
/* dump the request to an external file anyway */
|
2002-02-07 10:39:15 +01:00
|
|
|
}
|
2004-03-05 09:32:11 +01:00
|
|
|
else
|
|
|
|
reqbuf[req->offset]=0;
|
2004-05-28 11:52:15 +02:00
|
|
|
|
2002-02-07 13:40:06 +01:00
|
|
|
/* dump the request to an external file */
|
|
|
|
storerequest(reqbuf);
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
return fail; /* success */
|
2002-02-07 10:39:15 +01:00
|
|
|
}
|
|
|
|
|
2003-07-20 01:44:22 +02:00
|
|
|
/* returns -1 on failure */
|
2006-07-18 00:44:40 +02:00
|
|
|
static int send_doc(curl_socket_t sock, struct httprequest *req)
|
2002-02-07 10:39:15 +01:00
|
|
|
{
|
2006-07-12 07:19:00 +02:00
|
|
|
ssize_t written;
|
2004-03-23 09:50:28 +01:00
|
|
|
size_t count;
|
2002-05-17 10:15:33 +02:00
|
|
|
const char *buffer;
|
2002-02-07 10:39:15 +01:00
|
|
|
char *ptr;
|
|
|
|
FILE *stream;
|
2002-02-25 12:11:03 +01:00
|
|
|
char *cmd=NULL;
|
2004-03-23 09:50:28 +01:00
|
|
|
size_t cmdsize=0;
|
2002-12-10 13:59:16 +01:00
|
|
|
FILE *dump;
|
2003-07-20 01:44:22 +02:00
|
|
|
int persistant = TRUE;
|
2004-04-30 07:51:37 +02:00
|
|
|
size_t responsesize;
|
2007-02-19 03:03:58 +01:00
|
|
|
int error;
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2003-03-15 17:39:15 +01:00
|
|
|
static char weare[256];
|
|
|
|
|
2002-02-22 14:54:06 +01:00
|
|
|
char partbuf[80]="data";
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
logmsg("Send response number %d part %d", req->testno, req->partno);
|
2003-07-20 01:44:22 +02:00
|
|
|
|
2006-01-02 13:19:12 +01:00
|
|
|
switch(req->rcmd) {
|
|
|
|
default:
|
|
|
|
case RCMD_NORMALREQ:
|
|
|
|
break; /* continue with business as usual */
|
|
|
|
case RCMD_STREAM:
|
|
|
|
#define STREAMTHIS "a string to stream 01234567890\n"
|
|
|
|
count = strlen(STREAMTHIS);
|
|
|
|
while(1) {
|
|
|
|
written = swrite(sock, STREAMTHIS, count);
|
2006-07-12 11:03:48 +02:00
|
|
|
if(written != (ssize_t)count) {
|
2006-01-02 13:19:12 +01:00
|
|
|
logmsg("Stopped streaming");
|
2006-01-03 13:18:22 +01:00
|
|
|
break;
|
2006-01-02 13:19:12 +01:00
|
|
|
}
|
|
|
|
}
|
2006-01-03 13:18:22 +01:00
|
|
|
return -1;
|
2006-01-02 13:19:12 +01:00
|
|
|
case RCMD_IDLE:
|
|
|
|
/* Do nothing. Sit idle. Pretend it rains. */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
req->open = FALSE;
|
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
if(req->testno < 0) {
|
2006-11-25 14:32:04 +01:00
|
|
|
size_t msglen;
|
|
|
|
char msgbuf[64];
|
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
switch(req->testno) {
|
2003-07-01 17:21:42 +02:00
|
|
|
case DOCNUMBER_QUIT:
|
|
|
|
logmsg("Replying to QUIT");
|
|
|
|
buffer = docquit;
|
|
|
|
break;
|
2002-12-13 17:20:07 +01:00
|
|
|
case DOCNUMBER_WERULEZ:
|
2002-02-19 02:04:46 +01:00
|
|
|
/* we got a "friends?" question, reply back that we sure are */
|
2002-12-13 17:20:07 +01:00
|
|
|
logmsg("Identifying ourselves as friends");
|
2006-11-25 14:32:04 +01:00
|
|
|
sprintf(msgbuf, "WE ROOLZ: %d\r\n", (int)getpid());
|
|
|
|
msglen = strlen(msgbuf);
|
|
|
|
sprintf(weare, "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\n%s",
|
|
|
|
msglen, msgbuf);
|
2003-03-15 17:39:15 +01:00
|
|
|
buffer = weare;
|
2002-12-13 17:20:07 +01:00
|
|
|
break;
|
|
|
|
case DOCNUMBER_INTERNAL:
|
|
|
|
logmsg("Bailing out due to internal error");
|
|
|
|
return -1;
|
|
|
|
case DOCNUMBER_CONNECT:
|
|
|
|
logmsg("Replying to CONNECT");
|
|
|
|
buffer = docconnect;
|
|
|
|
break;
|
|
|
|
case DOCNUMBER_BADCONNECT:
|
|
|
|
logmsg("Replying to a bad CONNECT");
|
|
|
|
buffer = docbadconnect;
|
|
|
|
break;
|
|
|
|
case DOCNUMBER_404:
|
|
|
|
default:
|
|
|
|
logmsg("Replying to with a 404");
|
2002-02-19 02:04:46 +01:00
|
|
|
buffer = doc404;
|
2002-12-13 17:20:07 +01:00
|
|
|
break;
|
|
|
|
}
|
2002-02-07 10:39:15 +01:00
|
|
|
ptr = NULL;
|
|
|
|
stream=NULL;
|
2002-02-22 16:40:17 +01:00
|
|
|
|
|
|
|
count = strlen(buffer);
|
2002-02-07 10:39:15 +01:00
|
|
|
}
|
|
|
|
else {
|
2004-03-05 09:32:11 +01:00
|
|
|
char *filename = test2file(req->testno);
|
2002-12-10 13:59:16 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
if(0 != req->partno)
|
2004-03-31 13:50:44 +02:00
|
|
|
sprintf(partbuf, "data%ld", req->partno);
|
2002-02-07 10:39:15 +01:00
|
|
|
|
|
|
|
stream=fopen(filename, "rb");
|
|
|
|
if(!stream) {
|
2007-02-19 03:03:58 +01:00
|
|
|
error = ERRNO;
|
|
|
|
logmsg("fopen() failed with error: %d %s", error, strerror(error));
|
|
|
|
logmsg("Error opening file: %s", filename);
|
2002-02-07 10:39:15 +01:00
|
|
|
logmsg("Couldn't open test file");
|
|
|
|
return 0;
|
|
|
|
}
|
2002-02-25 12:11:03 +01:00
|
|
|
else {
|
2002-05-17 10:15:33 +02:00
|
|
|
buffer = spitout(stream, "reply", partbuf, &count);
|
|
|
|
ptr = (char *)buffer;
|
2002-02-25 12:11:03 +01:00
|
|
|
fclose(stream);
|
2002-02-22 14:54:06 +01:00
|
|
|
}
|
|
|
|
|
2002-02-25 12:11:03 +01:00
|
|
|
/* re-open the same file again */
|
|
|
|
stream=fopen(filename, "rb");
|
|
|
|
if(!stream) {
|
2007-02-19 03:03:58 +01:00
|
|
|
error = ERRNO;
|
|
|
|
logmsg("fopen() failed with error: %d %s", error, strerror(error));
|
|
|
|
logmsg("Error opening file: %s", filename);
|
2002-02-25 12:11:03 +01:00
|
|
|
logmsg("Couldn't open test file");
|
|
|
|
return 0;
|
|
|
|
}
|
2004-05-28 11:52:15 +02:00
|
|
|
else {
|
2002-02-25 12:11:03 +01:00
|
|
|
/* get the custom server control "commands" */
|
2002-05-17 10:15:33 +02:00
|
|
|
cmd = (char *)spitout(stream, "reply", "postcmd", &cmdsize);
|
2002-02-25 12:11:03 +01:00
|
|
|
fclose(stream);
|
|
|
|
}
|
2002-02-07 10:39:15 +01:00
|
|
|
}
|
|
|
|
|
2002-12-10 13:59:16 +01:00
|
|
|
dump = fopen(RESPONSE_DUMP, "ab"); /* b is for windows-preparing */
|
|
|
|
if(!dump) {
|
2007-02-19 03:03:58 +01:00
|
|
|
error = ERRNO;
|
|
|
|
logmsg("fopen() failed with error: %d %s", error, strerror(error));
|
|
|
|
logmsg("Error opening file: %s", RESPONSE_DUMP);
|
2002-12-10 13:59:16 +01:00
|
|
|
logmsg("couldn't create logfile: " RESPONSE_DUMP);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2003-07-20 01:44:22 +02:00
|
|
|
/* If the word 'swsclose' is present anywhere in the reply chunk, the
|
|
|
|
connection will be closed after the data has been sent to the requesting
|
|
|
|
client... */
|
|
|
|
if(strstr(buffer, "swsclose") || !count) {
|
|
|
|
persistant = FALSE;
|
2004-04-17 13:38:41 +02:00
|
|
|
logmsg("connection close instruction \"swsclose\" found in response");
|
2003-07-20 01:44:22 +02:00
|
|
|
}
|
2004-03-31 13:50:44 +02:00
|
|
|
if(strstr(buffer, "swsbounce")) {
|
|
|
|
prevbounce = TRUE;
|
|
|
|
logmsg("enable \"swsbounce\" in the next request");
|
|
|
|
}
|
|
|
|
else
|
|
|
|
prevbounce = FALSE;
|
2003-07-20 01:44:22 +02:00
|
|
|
|
2004-04-30 07:51:37 +02:00
|
|
|
|
|
|
|
responsesize = count;
|
2002-02-07 10:39:15 +01:00
|
|
|
do {
|
2007-10-02 12:13:37 +02:00
|
|
|
/* Ok, we send no more than 200 bytes at a time, just to make sure that
|
|
|
|
larger chunks are split up so that the client will need to do multiple
|
|
|
|
recv() calls to get it and thus we exercise that code better */
|
2007-10-04 04:09:33 +02:00
|
|
|
size_t num = count;
|
2007-10-02 12:13:37 +02:00
|
|
|
if(num > 200)
|
|
|
|
num = 200;
|
|
|
|
written = swrite(sock, buffer, num);
|
2002-02-07 10:39:15 +01:00
|
|
|
if (written < 0) {
|
2007-10-04 04:09:33 +02:00
|
|
|
fclose(dump);
|
2002-12-10 13:59:16 +01:00
|
|
|
logmsg("Sending response failed and we bailed out!");
|
2002-02-07 10:39:15 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2007-10-02 12:13:37 +02:00
|
|
|
else {
|
|
|
|
logmsg("Sent off %d bytes", written);
|
|
|
|
}
|
2002-12-10 13:59:16 +01:00
|
|
|
/* write to file as well */
|
|
|
|
fwrite(buffer, 1, written, dump);
|
|
|
|
|
2002-02-07 10:39:15 +01:00
|
|
|
count -= written;
|
|
|
|
buffer += written;
|
|
|
|
} while(count>0);
|
|
|
|
|
2002-12-10 13:59:16 +01:00
|
|
|
fclose(dump);
|
|
|
|
|
2004-06-22 08:44:14 +02:00
|
|
|
logmsg("Response sent (%d bytes) and written to " RESPONSE_DUMP,
|
|
|
|
responsesize);
|
2002-12-10 13:59:16 +01:00
|
|
|
|
2002-02-07 10:39:15 +01:00
|
|
|
if(ptr)
|
|
|
|
free(ptr);
|
2002-02-25 12:11:03 +01:00
|
|
|
|
|
|
|
if(cmdsize > 0 ) {
|
|
|
|
char command[32];
|
|
|
|
int num;
|
2006-05-10 11:53:52 +02:00
|
|
|
ptr=cmd;
|
2002-02-25 12:11:03 +01:00
|
|
|
do {
|
|
|
|
if(2 == sscanf(ptr, "%31s %d", command, &num)) {
|
2004-04-21 08:56:54 +02:00
|
|
|
if(!strcmp("wait", command)) {
|
|
|
|
logmsg("Told to sleep for %d seconds", num);
|
2002-02-25 12:11:03 +01:00
|
|
|
sleep(num); /* wait this many seconds */
|
2004-04-21 08:56:54 +02:00
|
|
|
}
|
2002-12-10 13:59:16 +01:00
|
|
|
else
|
2002-02-25 12:11:03 +01:00
|
|
|
logmsg("Unknown command in reply command section");
|
|
|
|
}
|
|
|
|
ptr = strchr(ptr, '\n');
|
|
|
|
if(ptr)
|
|
|
|
ptr++;
|
|
|
|
else
|
|
|
|
ptr = NULL;
|
|
|
|
} while(ptr && *ptr);
|
|
|
|
}
|
|
|
|
if(cmd)
|
|
|
|
free(cmd);
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
req->open = persistant;
|
2003-07-20 01:44:22 +02:00
|
|
|
|
2004-03-31 13:50:44 +02:00
|
|
|
prevtestno = req->testno;
|
|
|
|
prevpartno = req->partno;
|
|
|
|
|
2002-02-07 10:39:15 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2004-12-11 22:41:00 +01:00
|
|
|
char use_ipv6=FALSE;
|
|
|
|
|
2002-02-07 10:39:15 +01:00
|
|
|
int main(int argc, char *argv[])
|
|
|
|
{
|
2002-02-22 14:54:06 +01:00
|
|
|
struct sockaddr_in me;
|
2004-12-11 22:41:00 +01:00
|
|
|
#ifdef ENABLE_IPV6
|
|
|
|
struct sockaddr_in6 me6;
|
|
|
|
#endif /* ENABLE_IPV6 */
|
2005-09-15 22:22:43 +02:00
|
|
|
curl_socket_t sock, msgsock;
|
|
|
|
int flag;
|
2002-02-22 14:54:06 +01:00
|
|
|
unsigned short port = DEFAULT_PORT;
|
2002-02-25 11:27:29 +01:00
|
|
|
FILE *pidfile;
|
2004-12-14 22:52:16 +01:00
|
|
|
char *pidname= (char *)".http.pid";
|
2004-03-05 09:32:11 +01:00
|
|
|
struct httprequest req;
|
2004-12-11 22:41:00 +01:00
|
|
|
int rc;
|
2007-02-19 04:59:41 +01:00
|
|
|
int error;
|
2004-12-14 22:52:16 +01:00
|
|
|
int arg=1;
|
2006-04-10 15:11:52 +02:00
|
|
|
#ifdef CURL_SWS_FORK_ENABLED
|
|
|
|
bool use_fork = FALSE;
|
|
|
|
#endif
|
2004-05-28 11:52:15 +02:00
|
|
|
|
2004-12-14 22:52:16 +01:00
|
|
|
while(argc>arg) {
|
2004-12-11 22:41:00 +01:00
|
|
|
if(!strcmp("--version", argv[arg])) {
|
2006-04-10 15:11:52 +02:00
|
|
|
printf("sws IPv4%s"
|
|
|
|
#ifdef CURL_SWS_FORK_ENABLED
|
|
|
|
" FORK"
|
|
|
|
#endif
|
|
|
|
"\n"
|
|
|
|
,
|
2004-12-11 22:41:00 +01:00
|
|
|
#ifdef ENABLE_IPV6
|
|
|
|
"/IPv6"
|
|
|
|
#else
|
|
|
|
""
|
|
|
|
#endif
|
|
|
|
);
|
|
|
|
return 0;
|
|
|
|
}
|
2004-12-14 22:52:16 +01:00
|
|
|
else if(!strcmp("--pidfile", argv[arg])) {
|
|
|
|
arg++;
|
|
|
|
if(argc>arg)
|
|
|
|
pidname = argv[arg++];
|
|
|
|
}
|
|
|
|
else if(!strcmp("--ipv6", argv[arg])) {
|
2004-12-11 22:41:00 +01:00
|
|
|
#ifdef ENABLE_IPV6
|
|
|
|
use_ipv6=TRUE;
|
|
|
|
#endif
|
|
|
|
arg++;
|
|
|
|
}
|
2006-04-10 15:11:52 +02:00
|
|
|
#ifdef CURL_SWS_FORK_ENABLED
|
|
|
|
else if(!strcmp("--fork", argv[arg])) {
|
|
|
|
use_fork=TRUE;
|
|
|
|
arg++;
|
|
|
|
}
|
|
|
|
#endif
|
2004-12-14 22:52:16 +01:00
|
|
|
else if(argc>arg) {
|
2004-12-11 22:41:00 +01:00
|
|
|
|
|
|
|
if(atoi(argv[arg]))
|
|
|
|
port = (unsigned short)atoi(argv[arg++]);
|
|
|
|
|
|
|
|
if(argc>arg)
|
2004-12-14 22:52:16 +01:00
|
|
|
path = argv[arg++];
|
2004-02-12 15:40:08 +01:00
|
|
|
}
|
|
|
|
}
|
2004-05-28 11:52:15 +02:00
|
|
|
|
2006-10-11 18:01:16 +02:00
|
|
|
#ifdef WIN32
|
2004-03-05 09:32:11 +01:00
|
|
|
win32_init();
|
2004-04-17 13:38:41 +02:00
|
|
|
atexit(win32_cleanup);
|
|
|
|
#else
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
#ifdef SIGPIPE
|
2002-02-25 12:11:03 +01:00
|
|
|
#ifdef HAVE_SIGNAL
|
2002-02-22 14:54:06 +01:00
|
|
|
signal(SIGPIPE, sigpipe_handler);
|
2003-10-30 08:32:04 +01:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_SIGINTERRUPT
|
2002-02-22 14:54:06 +01:00
|
|
|
siginterrupt(SIGPIPE, 1);
|
2004-03-05 09:32:11 +01:00
|
|
|
#endif
|
2004-04-17 13:38:41 +02:00
|
|
|
#endif
|
2002-02-25 12:11:03 +01:00
|
|
|
#endif
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-12-11 22:41:00 +01:00
|
|
|
#ifdef ENABLE_IPV6
|
|
|
|
if(!use_ipv6)
|
|
|
|
#endif
|
|
|
|
sock = socket(AF_INET, SOCK_STREAM, 0);
|
|
|
|
#ifdef ENABLE_IPV6
|
|
|
|
else
|
|
|
|
sock = socket(AF_INET6, SOCK_STREAM, 0);
|
|
|
|
#endif
|
|
|
|
|
2006-07-18 00:44:40 +02:00
|
|
|
if (CURL_SOCKET_BAD == sock) {
|
2007-02-16 17:01:19 +01:00
|
|
|
logmsg("Error opening socket: %d", SOCKERRNO);
|
2006-08-14 19:00:08 +02:00
|
|
|
return 1;
|
2002-02-22 14:54:06 +01:00
|
|
|
}
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2002-02-22 14:54:06 +01:00
|
|
|
flag = 1;
|
2006-09-08 13:56:56 +02:00
|
|
|
if (0 != setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
|
2006-07-18 00:44:40 +02:00
|
|
|
(void *) &flag, sizeof(flag))) {
|
2007-02-16 17:01:19 +01:00
|
|
|
logmsg("setsockopt(SO_REUSEADDR) failed: %d", SOCKERRNO);
|
2006-07-18 00:44:40 +02:00
|
|
|
sclose(sock);
|
2006-08-14 19:00:08 +02:00
|
|
|
return 1;
|
2002-02-22 14:54:06 +01:00
|
|
|
}
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-12-11 22:41:00 +01:00
|
|
|
#ifdef ENABLE_IPV6
|
|
|
|
if(!use_ipv6) {
|
|
|
|
#endif
|
2006-07-18 00:44:40 +02:00
|
|
|
memset(&me, 0, sizeof(me));
|
2004-12-11 22:41:00 +01:00
|
|
|
me.sin_family = AF_INET;
|
|
|
|
me.sin_addr.s_addr = INADDR_ANY;
|
|
|
|
me.sin_port = htons(port);
|
|
|
|
rc = bind(sock, (struct sockaddr *) &me, sizeof(me));
|
|
|
|
#ifdef ENABLE_IPV6
|
|
|
|
}
|
|
|
|
else {
|
2006-07-18 00:44:40 +02:00
|
|
|
memset(&me6, 0, sizeof(me6));
|
2004-12-11 22:41:00 +01:00
|
|
|
me6.sin6_family = AF_INET6;
|
|
|
|
me6.sin6_addr = in6addr_any;
|
|
|
|
me6.sin6_port = htons(port);
|
|
|
|
rc = bind(sock, (struct sockaddr *) &me6, sizeof(me6));
|
|
|
|
}
|
|
|
|
#endif /* ENABLE_IPV6 */
|
2006-07-18 00:44:40 +02:00
|
|
|
if(0 != rc) {
|
2007-02-16 17:01:19 +01:00
|
|
|
logmsg("Error binding socket: %d", SOCKERRNO);
|
2006-07-18 00:44:40 +02:00
|
|
|
sclose(sock);
|
2006-08-14 19:00:08 +02:00
|
|
|
return 1;
|
2002-02-22 14:54:06 +01:00
|
|
|
}
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-12-14 22:52:16 +01:00
|
|
|
pidfile = fopen(pidname, "w");
|
2002-02-25 11:27:29 +01:00
|
|
|
if(pidfile) {
|
|
|
|
fprintf(pidfile, "%d\n", (int)getpid());
|
|
|
|
fclose(pidfile);
|
|
|
|
}
|
2006-07-18 00:44:40 +02:00
|
|
|
else {
|
2007-02-19 03:03:58 +01:00
|
|
|
error = ERRNO;
|
|
|
|
logmsg("fopen() failed with error: %d %s", error, strerror(error));
|
|
|
|
logmsg("Error opening file: %s", pidname);
|
|
|
|
logmsg("Couldn't write pid file");
|
2006-07-19 17:26:28 +02:00
|
|
|
sclose(sock);
|
2006-08-14 19:00:08 +02:00
|
|
|
return 1;
|
2006-07-18 00:44:40 +02:00
|
|
|
}
|
2002-02-25 11:27:29 +01:00
|
|
|
|
2005-04-27 14:27:23 +02:00
|
|
|
logmsg("Running IPv%d version on port %d",
|
2004-12-11 22:41:00 +01:00
|
|
|
#ifdef ENABLE_IPV6
|
|
|
|
(use_ipv6?6:4)
|
|
|
|
#else
|
|
|
|
4
|
|
|
|
#endif
|
2005-08-18 10:47:56 +02:00
|
|
|
, port );
|
2004-12-11 22:41:00 +01:00
|
|
|
|
2002-02-22 14:54:06 +01:00
|
|
|
/* start accepting connections */
|
2006-07-18 00:44:40 +02:00
|
|
|
rc = listen(sock, 5);
|
|
|
|
if(0 != rc) {
|
2007-02-16 17:01:19 +01:00
|
|
|
logmsg("listen() failed with error: %d", SOCKERRNO);
|
2006-07-18 00:44:40 +02:00
|
|
|
sclose(sock);
|
2006-08-14 19:00:08 +02:00
|
|
|
return 1;
|
2006-07-18 00:44:40 +02:00
|
|
|
}
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2002-05-17 10:15:33 +02:00
|
|
|
while (1) {
|
2002-02-22 14:54:06 +01:00
|
|
|
msgsock = accept(sock, NULL, NULL);
|
2004-05-28 11:52:15 +02:00
|
|
|
|
2006-07-18 00:44:40 +02:00
|
|
|
if (CURL_SOCKET_BAD == msgsock) {
|
2007-02-16 17:01:19 +01:00
|
|
|
printf("MAJOR ERROR: accept() failed with error: %d\n", SOCKERRNO);
|
2006-01-02 13:19:12 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CURL_SWS_FORK_ENABLED
|
2006-04-10 15:11:52 +02:00
|
|
|
if(use_fork) {
|
|
|
|
/* The fork enabled version just forks off the child and don't care
|
|
|
|
about it anymore, so don't assume otherwise. Beware and don't do
|
|
|
|
this at home. */
|
|
|
|
rc = fork();
|
|
|
|
if(-1 == rc) {
|
|
|
|
printf("MAJOR ERROR: fork() failed!\n");
|
|
|
|
break;
|
|
|
|
}
|
2006-01-02 13:19:12 +01:00
|
|
|
}
|
2006-04-10 15:11:52 +02:00
|
|
|
else
|
|
|
|
/* not a fork, just set rc so the following proceeds nicely */
|
|
|
|
rc = 0;
|
2006-01-02 13:19:12 +01:00
|
|
|
/* 0 is returned to the child */
|
|
|
|
if(0 == rc) {
|
|
|
|
#endif
|
2004-06-22 08:44:14 +02:00
|
|
|
logmsg("====> Client connect");
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2007-10-04 01:38:07 +02:00
|
|
|
#ifdef TCP_NODELAY
|
2007-10-02 12:13:37 +02:00
|
|
|
/*
|
|
|
|
* Disable the Nagle algorithm to make it easier to send out a large
|
|
|
|
* response in many small segments to torture the clients more.
|
|
|
|
*/
|
2007-10-04 01:38:07 +02:00
|
|
|
flag = 1;
|
2007-10-02 12:13:37 +02:00
|
|
|
if (setsockopt(msgsock, IPPROTO_TCP, TCP_NODELAY,
|
2007-10-04 01:38:07 +02:00
|
|
|
(void *)&flag, sizeof(flag)) == -1) {
|
2007-10-02 12:13:37 +02:00
|
|
|
logmsg("====> TCP_NODELAY failed");
|
|
|
|
}
|
2007-10-04 01:38:07 +02:00
|
|
|
#endif
|
2007-10-02 12:13:37 +02:00
|
|
|
|
|
|
|
do {
|
2004-03-05 09:32:11 +01:00
|
|
|
if(get_request(msgsock, &req))
|
|
|
|
/* non-zero means error, break out of loop */
|
|
|
|
break;
|
2002-12-13 17:20:07 +01:00
|
|
|
|
2004-03-31 13:50:44 +02:00
|
|
|
if(prevbounce) {
|
|
|
|
/* bounce treatment requested */
|
|
|
|
if((req.testno == prevtestno) &&
|
|
|
|
(req.partno == prevpartno)) {
|
|
|
|
req.partno++;
|
|
|
|
logmsg("BOUNCE part number to %ld", req.partno);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
send_doc(msgsock, &req);
|
2003-07-20 01:44:22 +02:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
if((req.testno < 0) && (req.testno != DOCNUMBER_CONNECT)) {
|
2003-07-20 01:44:22 +02:00
|
|
|
logmsg("special request received, no persistancy");
|
|
|
|
break;
|
|
|
|
}
|
2004-03-05 09:32:11 +01:00
|
|
|
if(!req.open) {
|
2003-07-20 01:44:22 +02:00
|
|
|
logmsg("instructed to close connection after server-reply");
|
|
|
|
break;
|
|
|
|
}
|
2002-12-13 17:20:07 +01:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
if(req.open)
|
2005-03-29 00:15:17 +02:00
|
|
|
logmsg("=> persistant connection request ended, awaits new request");
|
2002-12-13 17:20:07 +01:00
|
|
|
/* if we got a CONNECT, loop and get another request as well! */
|
2004-03-05 09:32:11 +01:00
|
|
|
} while(req.open || (req.testno == DOCNUMBER_CONNECT));
|
2002-02-07 10:39:15 +01:00
|
|
|
|
2004-06-22 08:44:14 +02:00
|
|
|
logmsg("====> Client disconnect");
|
2003-10-09 10:12:43 +02:00
|
|
|
sclose(msgsock);
|
2003-07-01 17:21:42 +02:00
|
|
|
|
2004-03-05 09:32:11 +01:00
|
|
|
if (req.testno == DOCNUMBER_QUIT)
|
2003-07-01 17:21:42 +02:00
|
|
|
break;
|
2006-01-02 13:19:12 +01:00
|
|
|
#ifdef CURL_SWS_FORK_ENABLED
|
|
|
|
}
|
|
|
|
#endif
|
2002-02-22 14:54:06 +01:00
|
|
|
}
|
2004-05-28 11:52:15 +02:00
|
|
|
|
2003-10-09 10:12:43 +02:00
|
|
|
sclose(sock);
|
2004-05-28 11:52:15 +02:00
|
|
|
|
2002-02-22 14:54:06 +01:00
|
|
|
return 0;
|
2002-02-07 10:39:15 +01:00
|
|
|
}
|
|
|
|
|