#include "setup.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <signal.h>
#include <time.h>
#include <sys/time.h>
#include <sys/types.h>
#include <ctype.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#ifdef HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#ifdef _XOPEN_SOURCE_EXTENDED
#include <arpa/inet.h>
#endif
#ifdef HAVE_NETDB_H
#include <netdb.h>
#endif
#define ENABLE_CURLX_PRINTF
#include "curlx.h"
#include "getpart.h"
#include "util.h"
#include "memdebug.h"
#if !defined(CURL_SWS_FORK_ENABLED) && defined(HAVE_FORK)
#define CURL_SWS_FORK_ENABLED
#endif
#define REQBUFSIZ 150000
#define REQBUFSIZ_TXT "149999"
long prevtestno=-1;
long prevpartno=-1;
bool prevbounce;
#define RCMD_NORMALREQ 0
#define RCMD_IDLE 1
#define RCMD_STREAM 2
struct httprequest {
char reqbuf[REQBUFSIZ];
int checkindex;
int offset;
long testno;
long partno;
int open;
bool auth_req;
bool auth;
size_t cl;
bool digest;
bool ntlm;
int pipe;
int rcmd;
};
int ProcessRequest(struct httprequest *req);
void storerequest(char *reqbuf);
#define DEFAULT_PORT 8999
#ifndef DEFAULT_LOGFILE
#define DEFAULT_LOGFILE "log/sws.log"
#endif
const char *serverlogfile = DEFAULT_LOGFILE;
#define SWSVERSION "cURL test suite HTTP server/0.1"
#define REQUEST_DUMP "log/server.input"
#define RESPONSE_DUMP "log/server.response"
#define MAXDOCNAMELEN 140000
#define MAXDOCNAMELEN_TXT "139999"
#define REQUEST_KEYWORD_SIZE 256
#define CMD_AUTH_REQUIRED "auth_required"
#define CMD_IDLE "idle"
#define CMD_STREAM "stream"
#define END_OF_HEADERS "\r\n\r\n"
enum {
DOCNUMBER_NOTHING = -7,
DOCNUMBER_QUIT = -6,
DOCNUMBER_BADCONNECT = -5,
DOCNUMBER_INTERNAL= -4,
DOCNUMBER_CONNECT = -3,
DOCNUMBER_WERULEZ = -2,
DOCNUMBER_404 = -1
};
static const char *docquit =
"HTTP/1.1 200 Goodbye" END_OF_HEADERS;
static const char *docconnect =
"HTTP/1.1 200 Mighty fine indeed" END_OF_HEADERS;
static const char *docbadconnect =
"HTTP/1.1 501 Forbidden you fool" END_OF_HEADERS;
static const char *doc404 = "HTTP/1.1 404 Not Found\r\n"
"Server: " SWSVERSION "\r\n"
"Connection: close\r\n"
"Content-Type: text/html"
END_OF_HEADERS
"<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n"
"<HTML><HEAD>\n"
"<TITLE>404 Not Found</TITLE>\n"
"</HEAD><BODY>\n"
"<H1>Not Found</H1>\n"
"The requested URL was not found on this server.\n"
"<P><HR><ADDRESS>" SWSVERSION "</ADDRESS>\n" "</BODY></HTML>\n";
#ifdef SIGPIPE
static volatile int sigpipe;
#endif
#ifdef SIGPIPE
static void sigpipe_handler(int sig)
{
(void)sig;
sigpipe = 1;
}
#endif
int ProcessRequest(struct httprequest *req)
{
char *line=&req->reqbuf[req->checkindex];
char chunked=FALSE;
static char request[REQUEST_KEYWORD_SIZE];
static char doc[MAXDOCNAMELEN];
char logbuf[256];
int prot_major, prot_minor;
char *end;
int error;
end = strstr(line, END_OF_HEADERS);
logmsg("ProcessRequest() called");
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;
ptr = strrchr(doc, '/');
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);
logmsg("%s", logbuf);
if(!strncmp("/verifiedserver", ptr, 15)) {
logmsg("Are-we-friendly question received");
req->testno = DOCNUMBER_WERULEZ;
return 1;
}
if(!strncmp("/quit", ptr, 5)) {
logmsg("Request-to-quit received");
req->testno = DOCNUMBER_QUIT;
return 1;
}
ptr++;
while(*ptr && !ISDIGIT(*ptr))
ptr++;
req->testno = strtol(ptr, &ptr, 10);
if(req->testno > 10000) {
req->partno = req->testno % 10000;
req->testno /= 10000;
}
else
req->partno = 0;
sprintf(logbuf, "Requested test number %ld part %ld",
req->testno, req->partno);
logmsg("%s", logbuf);
filename = test2file(req->testno);
stream=fopen(filename, "rb");
if(!stream) {
error = ERRNO;
logmsg("fopen() failed with error: %d %s", error, strerror(error));
logmsg("Error opening file: %s", filename);
logmsg("Couldn't open test file %d", req->testno);
req->open = FALSE;
return 1;
}
else {
char *cmd = NULL;
size_t cmdsize = 0;
int num=0;
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;
}
else if(!strncmp(CMD_IDLE, cmd, strlen(CMD_IDLE))) {
logmsg("instructed to idle");
req->rcmd = RCMD_IDLE;
req->open = TRUE;
}
else if(!strncmp(CMD_STREAM, cmd, strlen(CMD_STREAM))) {
logmsg("instructed to stream");
req->rcmd = RCMD_STREAM;
}
else if(1 == sscanf(cmd, "pipe: %d", &num)) {
logmsg("instructed to allow a pipe size %d", num);
req->pipe = num-1;
}
free(cmd);
}
}
}
else {
if(sscanf(req->reqbuf, "CONNECT %" MAXDOCNAMELEN_TXT "s HTTP/%d.%d",
doc, &prot_major, &prot_minor) == 3) {
sprintf(logbuf, "Received a CONNECT %s HTTP/%d.%d request",
doc, prot_major, prot_minor);
logmsg("%s", logbuf);
if(prot_major*10+prot_minor == 10)
req->open = FALSE;
if(!strncmp(doc, "bad", 3))
req->testno = DOCNUMBER_BADCONNECT;
else if(!strncmp(doc, "test", 4)) {
char *portp = strchr(doc, ':');
if(portp)
req->testno = atoi(portp+1);
else
req->testno = DOCNUMBER_CONNECT;
}
else
req->testno = DOCNUMBER_CONNECT;
}
else {
logmsg("Did not find test number in PATH");
req->testno = DOCNUMBER_404;
}
}
}
if(!end) {
logmsg("ProcessRequest returned without a complete request");
return 0;
}
logmsg("ProcessRequest found a complete request");
if(req->pipe)
req->checkindex += (end - line) + strlen(END_OF_HEADERS);
do {
if(!req->cl && curlx_strnequal("Content-Length:", line, 15)) {
req->cl = strtol(line+15, &line, 10);
logmsg("Found Content-Length: %d in the request", req->cl);
break;
}
else if(curlx_strnequal("Transfer-Encoding: chunked", line,
strlen("Transfer-Encoding: chunked"))) {
chunked = TRUE;
}
if(chunked) {
if(strstr(req->reqbuf, "\r\n0\r\n\r\n"))
return 1;
else
return 0;
}
line = strchr(line, '\n');
if(line)
line++;
} while(line);
if(!req->auth && strstr(req->reqbuf, "Authorization:")) {
req->auth = TRUE;
if(req->auth_req)
logmsg("Authorization header found, as required");
}
if(!req->digest && strstr(req->reqbuf, "Authorization: Digest")) {
req->partno += 1000;
req->digest = TRUE;
logmsg("Received Digest request, sending back data %d", req->partno);
}
else if(!req->ntlm &&
strstr(req->reqbuf, "Authorization: NTLM TlRMTVNTUAAD")) {
req->partno += 1002;
req->ntlm = TRUE;
logmsg("Received NTLM type-3, sending back data %d", req->partno);
if(req->cl) {
logmsg(" Expecting %d POSTed bytes", req->cl);
}
}
else if(!req->ntlm &&
strstr(req->reqbuf, "Authorization: NTLM TlRMTVNTUAAB")) {
req->partno += 1001;
req->ntlm = TRUE;
logmsg("Received NTLM type-1, sending back data %d", req->partno);
}
if(strstr(req->reqbuf, "Connection: close"))
req->open = FALSE;
while(req->pipe) {
line = &req->reqbuf[req->checkindex];
end = strstr(line, END_OF_HEADERS);
if(!end)
break;
req->checkindex += (end - line) + strlen(END_OF_HEADERS);
req->pipe--;
}
if(req->auth_req && !req->auth)
return 1;
if(req->cl) {
if(req->cl <= strlen(end+strlen(END_OF_HEADERS)))
return 1;
else
return 0;
}
return 1;
}
void storerequest(char *reqbuf)
{
int error;
ssize_t written;
ssize_t writeleft;
ssize_t totalsize;
FILE *dump;
if (reqbuf == NULL)
return;
totalsize = (ssize_t)strlen(reqbuf);
if (totalsize == 0)
return;
do {
dump = fopen(REQUEST_DUMP, "ab");
} while ((dump == NULL) && ((error = ERRNO) == EINTR));
if (dump == NULL) {
logmsg("Error opening file %s error: %d", REQUEST_DUMP, error);
logmsg("Failed to write request input to " REQUEST_DUMP);
return;
}
writeleft = totalsize;
do {
written = (ssize_t)fwrite((void *) &reqbuf[totalsize-writeleft],
1, (size_t)writeleft, dump);
if (written > 0)
writeleft -= written;
} while ((writeleft > 0) && ((error = ERRNO) == EINTR));
fclose(dump);
if (writeleft > 0) {
logmsg("Error writing file %s error: %d", REQUEST_DUMP, error);
logmsg("Wrote only (%d bytes) of (%d bytes) request input to %s",
totalsize-writeleft, totalsize, REQUEST_DUMP);
}
else {
logmsg("Wrote request (%d bytes) input to " REQUEST_DUMP,
totalsize);
}
}
static int get_request(curl_socket_t sock, struct httprequest *req)
{
int fail= FALSE;
char *reqbuf = req->reqbuf;
memset(req, 0, sizeof(struct httprequest));
req->testno = DOCNUMBER_NOTHING;
req->open = TRUE;
req->pipe = 0;
while (req->offset < REQBUFSIZ) {
ssize_t got = sread(sock, reqbuf + req->offset, REQBUFSIZ - req->offset);
if (got <= 0) {
if (got < 0) {
logmsg("recv() returned error: %d", SOCKERRNO);
return DOCNUMBER_INTERNAL;
}
logmsg("Connection closed by client");
reqbuf[req->offset]=0;
storerequest(reqbuf);
return DOCNUMBER_INTERNAL;
}
logmsg("Read %d bytes", got);
req->offset += got;
reqbuf[req->offset] = 0;
if(ProcessRequest(req)) {
if(req->pipe--) {
logmsg("Waiting for another piped request");
continue;
}
break;
}
}
if (req->offset >= REQBUFSIZ) {
logmsg("Request buffer overflow, closing connection");
reqbuf[REQBUFSIZ-1]=0;
fail = TRUE;
}
else
reqbuf[req->offset]=0;
storerequest(reqbuf);
return fail;
}
static int send_doc(curl_socket_t sock, struct httprequest *req)
{
ssize_t written;
size_t count;
const char *buffer;
char *ptr;
FILE *stream;
char *cmd=NULL;
size_t cmdsize=0;
FILE *dump;
int persistant = TRUE;
size_t responsesize;
int error;
static char weare[256];
char partbuf[80]="data";
logmsg("Send response number %d part %d", req->testno, req->partno);
switch(req->rcmd) {
default:
case RCMD_NORMALREQ:
break;
case RCMD_STREAM:
#define STREAMTHIS "a string to stream 01234567890\n"
count = strlen(STREAMTHIS);
while(1) {
written = swrite(sock, STREAMTHIS, count);
if(written != (ssize_t)count) {
logmsg("Stopped streaming");
break;
}
}
return -1;
case RCMD_IDLE:
return 0;
}
req->open = FALSE;
if(req->testno < 0) {
size_t msglen;
char msgbuf[64];
switch(req->testno) {
case DOCNUMBER_QUIT:
logmsg("Replying to QUIT");
buffer = docquit;
break;
case DOCNUMBER_WERULEZ:
logmsg("Identifying ourselves as friends");
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);
buffer = weare;
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");
buffer = doc404;
break;
}
ptr = NULL;
stream=NULL;
count = strlen(buffer);
}
else {
char *filename = test2file(req->testno);
if(0 != req->partno)
sprintf(partbuf, "data%ld", req->partno);
stream=fopen(filename, "rb");
if(!stream) {
error = ERRNO;
logmsg("fopen() failed with error: %d %s", error, strerror(error));
logmsg("Error opening file: %s", filename);
logmsg("Couldn't open test file");
return 0;
}
else {
buffer = spitout(stream, "reply", partbuf, &count);
ptr = (char *)buffer;
fclose(stream);
}
stream=fopen(filename, "rb");
if(!stream) {
error = ERRNO;
logmsg("fopen() failed with error: %d %s", error, strerror(error));
logmsg("Error opening file: %s", filename);
logmsg("Couldn't open test file");
return 0;
}
else {
cmd = (char *)spitout(stream, "reply", "postcmd", &cmdsize);
fclose(stream);
}
}
dump = fopen(RESPONSE_DUMP, "ab");
if(!dump) {
error = ERRNO;
logmsg("fopen() failed with error: %d %s", error, strerror(error));
logmsg("Error opening file: %s", RESPONSE_DUMP);
logmsg("couldn't create logfile: " RESPONSE_DUMP);
return -1;
}
if(strstr(buffer, "swsclose") || !count) {
persistant = FALSE;
logmsg("connection close instruction \"swsclose\" found in response");
}
if(strstr(buffer, "swsbounce")) {
prevbounce = TRUE;
logmsg("enable \"swsbounce\" in the next request");
}
else
prevbounce = FALSE;
responsesize = count;
do {
written = swrite(sock, buffer, count);
if (written < 0) {
logmsg("Sending response failed and we bailed out!");
return -1;
}
fwrite(buffer, 1, written, dump);
count -= written;
buffer += written;
} while(count>0);
fclose(dump);
logmsg("Response sent (%d bytes) and written to " RESPONSE_DUMP,
responsesize);
if(ptr)
free(ptr);
if(cmdsize > 0 ) {
char command[32];
int num;
ptr=cmd;
do {
if(2 == sscanf(ptr, "%31s %d", command, &num)) {
if(!strcmp("wait", command)) {
logmsg("Told to sleep for %d seconds", num);
sleep(num);
}
else
logmsg("Unknown command in reply command section");
}
ptr = strchr(ptr, '\n');
if(ptr)
ptr++;
else
ptr = NULL;
} while(ptr && *ptr);
}
if(cmd)
free(cmd);
req->open = persistant;
prevtestno = req->testno;
prevpartno = req->partno;
return 0;
}
char use_ipv6=FALSE;
int main(int argc, char *argv[])
{
struct sockaddr_in me;
#ifdef ENABLE_IPV6
struct sockaddr_in6 me6;
#endif
curl_socket_t sock, msgsock;
int flag;
unsigned short port = DEFAULT_PORT;
FILE *pidfile;
char *pidname= (char *)".http.pid";
struct httprequest req;
int rc;
int error;
int arg=1;
#ifdef CURL_SWS_FORK_ENABLED
bool use_fork = FALSE;
#endif
while(argc>arg) {
if(!strcmp("--version", argv[arg])) {
printf("sws IPv4%s"
#ifdef CURL_SWS_FORK_ENABLED
" FORK"
#endif
"\n"
,
#ifdef ENABLE_IPV6
"/IPv6"
#else
""
#endif
);
return 0;
}
else if(!strcmp("--pidfile", argv[arg])) {
arg++;
if(argc>arg)
pidname = argv[arg++];
}
else if(!strcmp("--ipv6", argv[arg])) {
#ifdef ENABLE_IPV6
use_ipv6=TRUE;
#endif
arg++;
}
#ifdef CURL_SWS_FORK_ENABLED
else if(!strcmp("--fork", argv[arg])) {
use_fork=TRUE;
arg++;
}
#endif
else if(argc>arg) {
if(atoi(argv[arg]))
port = (unsigned short)atoi(argv[arg++]);
if(argc>arg)
path = argv[arg++];
}
}
#ifdef WIN32
win32_init();
atexit(win32_cleanup);
#else
#ifdef SIGPIPE
#ifdef HAVE_SIGNAL
signal(SIGPIPE, sigpipe_handler);
#endif
#ifdef HAVE_SIGINTERRUPT
siginterrupt(SIGPIPE, 1);
#endif
#endif
#endif
#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
if (CURL_SOCKET_BAD == sock) {
logmsg("Error opening socket: %d", SOCKERRNO);
return 1;
}
flag = 1;
if (0 != setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
(void *) &flag, sizeof(flag))) {
logmsg("setsockopt(SO_REUSEADDR) failed: %d", SOCKERRNO);
sclose(sock);
return 1;
}
#ifdef ENABLE_IPV6
if(!use_ipv6) {
#endif
memset(&me, 0, sizeof(me));
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 {
memset(&me6, 0, sizeof(me6));
me6.sin6_family = AF_INET6;
me6.sin6_addr = in6addr_any;
me6.sin6_port = htons(port);
rc = bind(sock, (struct sockaddr *) &me6, sizeof(me6));
}
#endif
if(0 != rc) {
logmsg("Error binding socket: %d", SOCKERRNO);
sclose(sock);
return 1;
}
pidfile = fopen(pidname, "w");
if(pidfile) {
fprintf(pidfile, "%d\n", (int)getpid());
fclose(pidfile);
}
else {
error = ERRNO;
logmsg("fopen() failed with error: %d %s", error, strerror(error));
logmsg("Error opening file: %s", pidname);
logmsg("Couldn't write pid file");
sclose(sock);
return 1;
}
logmsg("Running IPv%d version on port %d",
#ifdef ENABLE_IPV6
(use_ipv6?6:4)
#else
4
#endif
, port );
rc = listen(sock, 5);
if(0 != rc) {
logmsg("listen() failed with error: %d", SOCKERRNO);
sclose(sock);
return 1;
}
while (1) {
msgsock = accept(sock, NULL, NULL);
if (CURL_SOCKET_BAD == msgsock) {
printf("MAJOR ERROR: accept() failed with error: %d\n", SOCKERRNO);
break;
}
#ifdef CURL_SWS_FORK_ENABLED
if(use_fork) {
rc = fork();
if(-1 == rc) {
printf("MAJOR ERROR: fork() failed!\n");
break;
}
}
else
rc = 0;
if(0 == rc) {
#endif
logmsg("====> Client connect");
do {
if(get_request(msgsock, &req))
break;
if(prevbounce) {
if((req.testno == prevtestno) &&
(req.partno == prevpartno)) {
req.partno++;
logmsg("BOUNCE part number to %ld", req.partno);
}
}
send_doc(msgsock, &req);
if((req.testno < 0) && (req.testno != DOCNUMBER_CONNECT)) {
logmsg("special request received, no persistancy");
break;
}
if(!req.open) {
logmsg("instructed to close connection after server-reply");
break;
}
if(req.open)
logmsg("=> persistant connection request ended, awaits new request");
} while(req.open || (req.testno == DOCNUMBER_CONNECT));
logmsg("====> Client disconnect");
sclose(msgsock);
if (req.testno == DOCNUMBER_QUIT)
break;
#ifdef CURL_SWS_FORK_ENABLED
}
#endif
}
sclose(sock);
return 0;
}