{

ProtocolState = BaseState;

_Content = NULL;

// By default, we set the standard CGI environment strings.

// (This is primarily beneficial because it lets the caller use Ruby's CGI classes.)

// The caller can switch this off in Ruby code, which greatly improves performance.

bSetEnvironmentStrings = true;

// This flag was added by Kirk Haines (thanks, Kirk). It preserves the original

// behavior with respect to POST content, which was to accumulate it in a buffer

// allocated and managed in this class. Kirk's mods allow callers to specify that

// POST content be submitted directly to user code piece by piece as we receive it,

// instead of buffering it here. To get the latter behavior, user code must call

// dont_accumulate_post.

bAccumulatePost = true;

const char *cookie,

const char *ifnonematch,

const char *contenttype,

const char *query_string,

const char *path_info,

const char *request_uri,

const char *protocol,

int post_length,

const char *post_content,

const char *hdrblock,

int hdrblocksize,

int content_chunked)

{

cerr << "UNIMPLEMENTED ProcessRequest" << endl;

{

if (ProtocolState == EndState)

return;

if ((length > 0) && !data)

throw std::runtime_error ("bad args consuming http data");

while (length > 0) {

//----------------------------------- BaseState

// Initialize for a new request. Don't consume any data.

// For anal-retentive security we may want to bzero the header block.

if (ProtocolState == BaseState) {

ProtocolState = PreheaderState;

nLeadingBlanks = 0;

HeaderLinePos = 0;

HeaderBlockPos = 0;

ContentLength = 0;

ContentChunked = 0;

TrailerProcessing = 0;

ContentPos = 0;

Chunk_req_received = 0;

foundsemi = 0;

foundslashr = 0;

chunklen = 0;

bRequestSeen = false;

bContentLengthSeen = false;

if (_Content) {

free ((void*)_Content);

_Content = NULL;

}

RequestMethod = NULL;

#ifdef OS_WIN32

Cookie.erase(Cookie.begin(),Cookie.end());

IfNoneMatch.erase(IfNoneMatch.begin(),IfNoneMatch.end());

ContentType.erase(ContentType.begin(),ContentType.end());

PathInfo.erase(PathInfo.begin(),PathInfo.end());

RequestUri.erase(RequestUri.begin(),RequestUri.end());

QueryString.erase(QueryString.begin(),QueryString.end());

Protocol.erase(Protocol.begin(),Protocol.end());

#else

Cookie.clear();

IfNoneMatch.clear();

ContentType.clear();

PathInfo.clear();

RequestUri.clear();

QueryString.clear();

Protocol.clear();

#endif

if (bSetEnvironmentStrings) {

unsetenv ("REQUEST_METHOD");

unsetenv ("HTTP_COOKIE");

unsetenv ("IF_NONE_MATCH");

unsetenv ("CONTENT_TYPE");

unsetenv ("PATH_INFO");

unsetenv ("REQUEST_URI");

unsetenv ("QUERY_STRING");

unsetenv ("PROTOCOL");

}

}

//----------------------------------- PreheaderState

// Consume blank lines (but not too many of them)

while ((ProtocolState == PreheaderState) && (length > 0)) {

if ((*data == '\r') || (*data == '\n')) {

data++;

length--;

nLeadingBlanks++;

if (nLeadingBlanks > MaxLeadingBlanks) {

// TODO, log this.

goto fail_connection;

}

}

else

ProtocolState = HeaderState;

//sleep(30);

}

//----------------------------------- HeaderState

// Read HTTP headers.

// This processing depends on the fact that the end

// of the data buffer we receive will have a null terminator

// just after the last byte indicated by the length parameter.

// Cf notes in ConnectionDescriptor::Read.

while ((ProtocolState == HeaderState) && (length > 0)) {

if (*data == '\n') {

HeaderLine [HeaderLinePos] = 0;

if (!_InterpretHeaderLine (HeaderLine))

goto send_error;

if (HeaderLinePos == 0) {

if (ContentLength > 0) {

if (_Content)

free (_Content);

_Content = NULL;

if (bAccumulatePost) {

_Content = (char*) malloc (ContentLength + 1);

if (!_Content)

throw std::runtime_error ("resource exhaustion");

}

ContentPos = 0;

ProtocolState = ReadingContentState;

}

else if (ContentChunked){

if (_Content){

free (_Content);

}

_Content = NULL;

ContentPos = 0;

ProtocolState = ReadingChunkLen;

//clear our header buffer, reset flags

memset(chunklen_s, '\0',10);

foundsemi = 0;

foundslashr = 0;

foundslashn = 0;

chunklen = 0;

ContentChunked = 0;

}

else{

if(TrailerProcessing){

ContentLength = ContentPos;

Chunk_req_received = 1;

}

// We will come to here for GET or Chunked POST.

ProtocolState = DispatchState;

}

}

HeaderLinePos = 0;

data++;

length--;

}

else if (*data == '\r') {

// ignore \r

data++;

length--;

}

else {

const char *nl = strpbrk (data, "\r\n");

int len = nl ? (nl - data) : length;

if ((size_t)(HeaderLinePos + len) >= sizeof(HeaderLine)) {

// TODO, log this

goto fail_connection;

}

memcpy (HeaderLine + HeaderLinePos, data, len);

data += len;

length -= len;

HeaderLinePos += len;

}

}

//----------------------------------- ReadingContentState

// Read POST content.

while ((ProtocolState == ReadingContentState) && (length > 0)) {

int len = ContentLength - ContentPos;

if (len > length){

len = length;

}

if (bAccumulatePost)

memcpy (_Content + ContentPos, data, len);

else

ReceivePostData (data, len);

data += len;

length -= len;

ContentPos += len;

if (ContentPos == ContentLength) {

if (bAccumulatePost){

_Content[ContentPos] = 0;

}

ProtocolState = DispatchState;

}

}

int chunklen_pos = 0;

//----------------------------------- ReadingChunkLen

// Read POST chunked content.

while ((ProtocolState == ReadingChunkLen) && length > 0)

{

if(*data == ';')

{

//The standards say that there can be a semi-colon after the chunk length, plus some data;

foundsemi = 1;

}

else if(*data == '\r')

{

foundslashr =1;

}

else if(*data == '\n')

{

//If we find a slash n without a slash r then this message is malformatted

if(! foundslashr)

{

goto send_error;

}

foundslashn = 1;

}

else

{

if( ! foundsemi )

{

chunklen_s[chunklen_pos] = *data;

chunklen_pos++;

}

}

data = data+1;

length--;

if (foundslashn)

{

//convert the length to a long

chunklen = (int)strtol ( chunklen_s, NULL, 16 );

if (chunklen == 0 )

{

ProtocolState = HeaderState;

}

else

{

ProtocolState = ReadingChunkedContent;

}

}

}

int readamount =0;

int readischunk=0;

//----------------------------------- ReadingChunkedContent

// Read POST chunked content.

while ((ProtocolState == ReadingChunkedContent && length > 0))

{

if(length <= chunklen)

{

readamount = length;

chunklen-=length;

}

else

{

readischunk = 1;

readamount = chunklen;

}

char *_temp_content = NULL;

//copy to temp variable so we don't overwrite _Content with null if we can't alloc.

_temp_content = (char*) realloc(_Content, ContentPos + readamount + 1);

if (!_temp_content){

// free(_Content);

// _Content = NULL;

throw std::runtime_error ("resource exhaustion");

}

_Content = _temp_content;

memcpy(_Content + ContentPos, data, readamount);

ContentPos += readamount;

_Content[ContentPos] = '\0';

data += readamount;

length -= readamount;

//If we just read the entire chunk then we can expect the next

// two characters to be \r\n

if(readischunk)

{

if(*data != '\r')

{

goto send_error;

}

data++;

length--;

if(*data != '\n')

{

goto send_error;

}

data++;

length--;

ProtocolState = ReadingChunkLen;

memset(chunklen_s, '\0',10); //clear our header buffer.

foundsemi = 0;

foundslashr = 0;

chunklen = 0;

foundslashn = 0;

}

}

//----------------------------------- DispatchState

if (ProtocolState == DispatchState) {

ProcessRequest (RequestMethod,

Cookie.c_str(),

IfNoneMatch.c_str(),

ContentType.c_str(),

QueryString.c_str(),

PathInfo.c_str(),

RequestUri.c_str(),

Protocol.c_str(),

ContentLength,

_Content,

HeaderBlock,

HeaderBlockPos,

Chunk_req_received);

ProtocolState = BaseState;

}

}

return;

fail_connection:

// For protocol errors or security violations- kill the connection dead.

CloseConnection (false);

ProtocolState = EndState;

return;

send_error:

// for HTTP-level errors that will send back a response to the client.

CloseConnection (true);

ProtocolState = EndState;

return;

{

/* Return T/F to indicate whether we should continue processing

if (!header) // an assert, really.

throw std::runtime_error ("bad arg interpreting headers");

if (!bRequestSeen) {

bRequestSeen = true;

return _InterpretRequest (header);

}

if (!strncasecmp (header, "content-length:", 15)) {

if (bContentLengthSeen) {

// TODO, log this. There are some attacks that depend

// on sending more than one content-length header.

_SendError (RESPONSE_CODE_406);

return false;

}

bContentLengthSeen = true;

const char *s = header + 15;

while (*s && ((*s==' ') || (*s=='\t')))

s++;

ContentLength = atoi (s);

if (ContentLength > MaxContentLength) {

// TODO, log this.

_SendError (RESPONSE_CODE_406);

return false;

}

}

else if (!strncasecmp (header, "cookie:", 7)) {

const char *s = header + 7;

while (*s && ((*s==' ') || (*s=='\t')))

s++;

Cookie = s;

if (bSetEnvironmentStrings)

setenv ("HTTP_COOKIE", s, true);

}

else if (!strncasecmp (header, "If-none-match:", 14)) {

const char *s = header + 14;

while (*s && ((*s==' ') || (*s=='\t')))

s++;

IfNoneMatch = s;

if (bSetEnvironmentStrings)

setenv ("IF_NONE_MATCH", s, true);

}

else if (!strncasecmp (header, "Content-type:", 13)) {

//If we receive this header after we have processed chunked data

//send an error.

if(TrailerProcessing){

_SendError (RESPONSE_CODE_406);

return false;

}

const char *s = header + 13;

while (*s && ((*s==' ') || (*s=='\t')))

s++;

ContentType = s;

if (bSetEnvironmentStrings)

setenv ("CONTENT_TYPE", s, true);

}

else if (!strncasecmp (header, "Transfer-Encoding:", 18)) {

if(TrailerProcessing){

_SendError (RESPONSE_CODE_406);

return false;

}

const char *s = header + 18;

while (*s && ((*s==' ') || (*s=='\t')))

s++;

if (!strncasecmp (s, "chunked", 7)){

TrailerProcessing = 1;

ContentChunked = 1;

}

}

else if (!strncasecmp (header, "Trailer:", 8)) {

if(TrailerProcessing){

_SendError (RESPONSE_CODE_406);

return false;

}

}

// Copy the incoming header into a block

if ((HeaderBlockPos + strlen(header) + 1) < HeaderBlockSize) {

int len = strlen(header);

memcpy (HeaderBlock+HeaderBlockPos, header, len);

HeaderBlockPos += len;

HeaderBlock [HeaderBlockPos++] = 0;

}

else {

// TODO, log this.

_SendError (RESPONSE_CODE_406);

return false;

}

return true;

{

/* Return T/F to indicate whether we should continue processing

const char *blank = strchr (header, ' ');

if (!blank) {

_SendError (RESPONSE_CODE_406);

return false;

}

if (!_DetectVerbAndSetEnvString (header, blank - header))

return false;

blank++;

if (*blank != '/') {

_SendError (RESPONSE_CODE_406);

return false;

}

const char *blank2 = strchr (blank, ' ');

if (!blank2) {

_SendError (RESPONSE_CODE_406);

return false;

}

if (strcasecmp (blank2 + 1, "HTTP/1.0") && strcasecmp (blank2 + 1, "HTTP/1.1")) {

_SendError (RESPONSE_CODE_505);

return false;

}

string prot (blank2+1);

Protocol = prot.c_str();

// Here, the request starts at blank and ends just before blank2.

// Find the query-string (?) and/or fragment (#,;), if either are present.

const char *questionmark = strchr (blank, '?');

if (questionmark && (questionmark >= blank2))

questionmark = NULL;

// const char *fragment = strpbrk ((questionmark ? (questionmark+1) : blank), "#;");

const char *fragment = strpbrk ((questionmark ? (questionmark+1) : blank), "#");

if (fragment && (fragment >= blank2))

fragment = NULL;

if (questionmark) {

string req (blank, questionmark - blank);

PathInfo = req.c_str();

RequestUri = req.c_str();

string qs (questionmark+1, fragment ? (fragment - (questionmark+1)) : (blank2 - (questionmark+1)));

QueryString = qs.c_str();

if (bSetEnvironmentStrings) {

setenv ("PATH_INFO", req.c_str(), true);

setenv ("REQUEST_URI", req.c_str(), true);

setenv ("QUERY_STRING", qs.c_str(), true);

setenv ("PROTOCOL", prot.c_str(), true);

}

}

else if (fragment) {

string req (blank, fragment - blank);

PathInfo = req.c_str();

RequestUri = req.c_str();

#ifdef OS_WIN32

QueryString.erase(QueryString.begin(),QueryString.end());

#else

QueryString.clear();

#endif

if (bSetEnvironmentStrings) {

setenv ("PATH_INFO", req.c_str(), true);

setenv ("REQUEST_URI", req.c_str(), true);

setenv ("QUERY_STRING", "", true);

setenv ("PROTOCOL", prot.c_str(), true);

}

}

else {

string req (blank, blank2 - blank);

PathInfo = req.c_str();

RequestUri = req.c_str();

#ifdef OS_WIN32

QueryString.erase(QueryString.begin(),QueryString.end());

#else

QueryString.clear();

#endif

if (bSetEnvironmentStrings) {

setenv ("PATH_INFO", req.c_str(), true);

setenv ("REQUEST_URI", req.c_str(), true);

setenv ("QUERY_STRING", "", true);

setenv ("PROTOCOL", prot.c_str(), true);

}

}

return true;

{

/* Helper method for _InterpretRequest.

static const char *verbs[] = {

"GET",

"POST",

"PUT",

"DELETE",

"HEAD"

};

int n_verbs = sizeof(verbs) / sizeof(const char*);

// Warning, this algorithm is vulnerable to head-matches,

// so compare the longer head-matching strings first.

// We could fix this if we included the blank in the search

// string but then we'd have to lop it off in the env string.

// ALSO NOTICE the early return on success.

for (int i=0; i < n_verbs; i++) {

if (!strncasecmp (request, verbs[i], verblength) && (strlen(verbs[i]) == (size_t)verblength)) {

RequestMethod = verbs[i];

if (bSetEnvironmentStrings)

setenv ("REQUEST_METHOD", verbs[i], 1);

return true;

}

}

_SendError (RESPONSE_CODE_406);

return false;

{

stringstream ss;

ss << "HTTP/1.1 " << header << "\r\n";

ss << "Connection: close\r\n";

ss << "Content-Type: text/plain\r\n";

ss << "\r\n";

SendData (ss.str().c_str(), ss.str().length());