static void runHttpHeaderTest(TestRunner& tr)
{
tr.group("HttpHeader");
tr.test("Bicapitalization");
{
// test bicapitalization of http headers
const char* tests[] = {
"", "",
"a", "A",
"-", "-",
"a--a", "A--A",
"-aa-", "-Aa-",
"-aa", "-Aa",
"aa-", "Aa-",
"aaa-zzz", "Aaa-Zzz",
"ThIs-a-BICaPitAlized-hEADer", "This-A-Bicapitalized-Header",
"Message-ID", "Message-Id",
NULL
};
for(int i = 0; tests[i] != NULL; i +=2)
{
char* bic = strdup(tests[i]);
HttpHeader::biCapitalize(bic);
assertStrCmp(bic, tests[i+1]);
free(bic);
}
}
tr.passIfNoException();
tr.test("HttpRequestHeader parse");
{
HttpRequestHeader header;
header.setDate();
header.setMethod("GET");
header.setPath("/");
header.setVersion("HTTP/1.1");
header.setField("host", "localhost:80");
header.setField("Content-Type", "text/html");
header.setField("Connection", "close");
string date;
string expect;
expect.append("GET / HTTP/1.1\r\n");
expect.append("Connection: close\r\n");
expect.append("Content-Type: text/html\r\n");
expect.append("Date: ");
header.getField("Date", date);
expect.append(date);
expect.append("\r\n");
expect.append("Host: localhost:80\r\n");
expect.append("\r\n");
string str = header.toString();
assertStrCmp(str.c_str(), expect.c_str());
HttpRequestHeader header2;
header2.parse(str);
string str2 = header2.toString();
assertStrCmp(str2.c_str(), expect.c_str());
}
tr.passIfNoException();
tr.test("HttpResponseHeader parse");
{
HttpResponseHeader header;
header.setDate();
header.setVersion("HTTP/1.1");
header.setStatus(404, "Not Found");
header.setField("host", "localhost:80");
header.setField("Content-Type", "text/html");
header.setField("Connection", "close");
string date;
string expect;
expect.append("HTTP/1.1 404 Not Found\r\n");
expect.append("Connection: close\r\n");
expect.append("Content-Type: text/html\r\n");
expect.append("Date: ");
header.getField("Date", date);
expect.append(date);
expect.append("\r\n");
expect.append("Host: localhost:80\r\n");
expect.append("\r\n");
string str = header.toString();
assertStrCmp(str.c_str(), expect.c_str());
HttpResponseHeader header2;
header2.parse(str);
string str2 = header2.toString();
assertStrCmp(str2.c_str(), expect.c_str());
}
tr.passIfNoException();
tr.test("Multiple fields with same name");
{
HttpResponseHeader header;
header.setDate();
header.setVersion("HTTP/1.1");
header.setStatus(404, "Not Found");
header.setField("host", "localhost:80");
header.setField("Content-Type", "text/html");
header.setField("Connection", "close");
header.addField("Set-Cookie", "cookie1=value1; max-age=0; path=/");
header.addField("Set-Cookie", "cookie2=value2; max-age=0; path=/");
header.addField("Set-Cookie", "cookie3=value3; max-age=0; path=/");
string date;
string expect;
expect.append("HTTP/1.1 404 Not Found\r\n");
expect.append("Connection: close\r\n");
expect.append("Content-Type: text/html\r\n");
expect.append("Date: ");
header.getField("Date", date);
expect.append(date);
expect.append("\r\n");
expect.append("Host: localhost:80\r\n");
expect.append("Set-Cookie: cookie1=value1; max-age=0; path=/\r\n");
expect.append("Set-Cookie: cookie2=value2; max-age=0; path=/\r\n");
expect.append("Set-Cookie: cookie3=value3; max-age=0; path=/\r\n");
expect.append("\r\n");
string str = header.toString();
assertStrCmp(str.c_str(), expect.c_str());
HttpResponseHeader header2;
header2.parse(str);
string str2 = header2.toString();
assertStrCmp(str2.c_str(), expect.c_str());
}
tr.passIfNoException();
tr.test("hasContentType");
{
HttpResponseHeader header;
header.clearFields();
header.setField("Content-Type", "text/html");
assert(header.hasContentType("text/html"));
header.clearFields();
header.setField("Content-Type", "text/html; params");
assert(header.hasContentType("text/html"));
header.clearFields();
header.setField("Content-Type", "text/html; params");
assert(!header.hasContentType("text/plain"));
}
tr.passIfNoException();
tr.ungroup();
}
void HttpConnectionServicer::serviceConnection(Connection* c)
{
// wrap connection, set default timeouts to 30 seconds
HttpConnection hc(c, false);
hc.setReadTimeout(30000);
hc.setWriteTimeout(30000);
// monitor connection
if(!mConnectionMonitor.isNull())
{
mConnectionMonitor->beforeServicingConnection(&hc);
}
// create request
HttpRequest* request = hc.createRequest();
HttpRequestHeader* reqHeader = request->getHeader();
// create response
HttpResponse* response = request->createResponse();
HttpResponseHeader* resHeader = response->getHeader();
// handle keep-alive (HTTP/1.1 keep-alive is on by default)
bool keepAlive = true;
bool noerror = true;
while(keepAlive && noerror)
{
// set defaults
resHeader->setVersion("HTTP/1.1");
resHeader->setDate();
resHeader->setField("Server", mServerName);
// monitor request waiting
if(!mConnectionMonitor.isNull())
{
mConnectionMonitor->beforeRequest(&hc);
}
// receive request header
if((noerror = request->receiveHeader()))
{
// begin new request state
hc.getRequestState()->beginRequest();
// monitor received request
if(!mConnectionMonitor.isNull())
{
mConnectionMonitor->beforeServicingRequest(
&hc, request, response);
}
// do request modification
if(mRequestModifier != NULL)
{
mRequestModifier->modifyRequest(request);
}
// check http version
bool version10 = (strcmp(reqHeader->getVersion(), "HTTP/1.0") == 0);
bool version11 = (strcmp(reqHeader->getVersion(), "HTTP/1.1") == 0);
// only version 1.0 and 1.1 supported
if(version10 || version11)
{
// set response version according to request version
resHeader->setVersion(reqHeader->getVersion());
// use proxy'd host field if one was used
// else use host field if one was used
string host;
if(reqHeader->getField("X-Forwarded-Host", host) ||
reqHeader->getField("Host", host))
{
resHeader->setField("Host", host);
}
// get connection header
string connHeader;
if(reqHeader->getField("Connection", connHeader))
{
if(strcasecmp(connHeader.c_str(), "close") == 0)
{
keepAlive = false;
}
else if(strcasecmp(connHeader.c_str(), "keep-alive") == 0)
{
keepAlive = true;
}
}
else if(version10)
{
// if HTTP/1.0 and no keep-alive header, keep-alive is off
keepAlive = false;
}
// get request path and normalize it
const char* inPath = reqHeader->getPath();
char outPath[strlen(inPath) + 2];
HttpRequestServicer::normalizePath(inPath, outPath);
// find appropriate request servicer for path
HttpRequestServicer* hrs = NULL;
// find secure/non-secure servicer
hrs = findRequestServicer(host, outPath, hc.isSecure());
if(hrs != NULL)
{
// service request
hrs->serviceRequest(request, response);
// turn off keep-alive if response has close connection field
if(keepAlive)
{
if(resHeader->getField("Connection", connHeader) &&
strcasecmp(connHeader.c_str(), "close") == 0)
{
keepAlive = false;
}
}
// if servicer closed connection, turn off keep-alive
if(keepAlive && c->isClosed())
{
keepAlive = false;
}
}
else
{
// no servicer, so send 404 Not Found
const char* html =
"<html><body><h2>404 Not Found</h2></body></html>";
resHeader->setStatus(404, "Not Found");
resHeader->setField("Content-Type", "text/html");
resHeader->setField("Content-Length", 48);
resHeader->setField("Connection", "close");
if((noerror = response->sendHeader()))
{
ByteArrayInputStream is(html, 48);
noerror = response->sendBody(&is);
}
}
}
else
{
// send 505 HTTP Version Not Supported
const char* html =
"<html><body>"
"<h2>505 HTTP Version Not Supported</h2>"
"</body></html>";
resHeader->setStatus(505, "HTTP Version Not Supported");
resHeader->setField("Content-Type", "text/html");
resHeader->setField("Content-Length", 65);
resHeader->setField("Connection", "close");
if((noerror = response->sendHeader()))
{
ByteArrayInputStream is(html, 65);
noerror = response->sendBody(&is);
}
}
// monitor serviced request
if(!mConnectionMonitor.isNull())
{
mConnectionMonitor->afterServicingRequest(
&hc, request, response);
}
}
else
{
// begin new request state
hc.getRequestState()->beginRequest();
// monitor request error
if(!mConnectionMonitor.isNull())
{
mConnectionMonitor->beforeRequestError(
&hc, request, response);
}
// exception occurred while receiving header
ExceptionRef e = Exception::get();
// if no header then drop through and close connection
if(e->isType("monarch.http.NoHeader"))
{
keepAlive = false;
}
// for bad header or request set 400
else if(e->isType("monarch.http.BadHeader") ||
e->isType("monarch.http.BadRequest"))
{
// send 400 Bad Request
const char* html =
"<html><body><h2>400 Bad Request</h2></body></html>";
response->getHeader()->setStatus(400, "Bad Request");
response->getHeader()->setField("Content-Type", "text/html");
response->getHeader()->setField("Content-Length", 50);
response->getHeader()->setField("Connection", "close");
if(response->sendHeader())
{
ByteArrayInputStream is(html, 50);
response->sendBody(&is);
}
}
// if the exception was an interruption, then send a 503
else if(e->isType("monarch.io.InterruptedException") ||
e->isType("monarch.rt.Interrupted"))
{
// send 503 Service Unavailable
const char* html =
"<html><body><h2>503 Service Unavailable</h2></body></html>";
resHeader->setStatus(503, "Service Unavailable");
resHeader->setField("Content-Type", "text/html");
resHeader->setField("Content-Length", 58);
resHeader->setField("Connection", "close");
if((noerror = response->sendHeader()))
{
ByteArrayInputStream is(html, 58);
noerror = response->sendBody(&is);
}
}
// if the exception was not a socket error then send an internal
// server error response
else if(!e->isType("monarch.net.Socket", true))
{
// send 500 Internal Server Error
const char* html =
"<html><body><h2>500 Internal Server Error</h2></body></html>";
resHeader->setStatus(500, "Internal Server Error");
resHeader->setField("Content-Type", "text/html");
resHeader->setField("Content-Length", 60);
resHeader->setField("Connection", "close");
if((noerror = response->sendHeader()))
{
ByteArrayInputStream is(html, 60);
noerror = response->sendBody(&is);
}
}
else
{
// log socket error
if(e->getDetails()->hasMember("error"))
{
// build error string
string error;
DynamicObjectIterator i =
e->getDetails()["error"].getIterator();
while(i->hasNext())
{
error.append(i->next()->getString());
if(i->hasNext())
{
error.push_back(',');
}
}
MO_CAT_ERROR(MO_HTTP_CAT,
"Connection error: ['%s','%s','%s']",
e->getMessage(), e->getType(), error.c_str());
}
else
{
MO_CAT_ERROR(MO_HTTP_CAT,
"Connection error: ['%s','%s']",
e->getMessage(), e->getType());
}
}
// monitor request error
if(!mConnectionMonitor.isNull())
{
mConnectionMonitor->afterRequestError(
&hc, request, response, e);
}
}
// monitor request
if(!mConnectionMonitor.isNull())
{
mConnectionMonitor->afterRequest(&hc);
}
if(keepAlive && noerror)
{
// set keep-alive timeout (defaults to 5 minutes)
hc.setReadTimeout(1000 * 60 * 5);
// clear request and response header fields
reqHeader->clearFields();
resHeader->clearFields();
resHeader->clearStatus();
}
}
// clean up request and response
delete request;
delete response;
// monitor connection
if(!mConnectionMonitor.isNull())
{
mConnectionMonitor->afterServicingConnection(&hc);
}
// close connection
hc.close();
}
