// method to optimize deep searches for exception type base names
static ExceptionRef _getCauseOfType(ExceptionRef& e, const char* type, int n)
{
ExceptionRef rval(NULL);
// check this exception's type
if(strncmp(e->getType(), type, n) == 0)
{
rval = e;
}
// check this exception's cause
else if(!e->getCause().isNull())
{
rval = _getCauseOfType(e->getCause(), type, n);
}
return rval;
}
DynamicObject Exception::convertToDynamicObject(ExceptionRef& e)
{
DynamicObject dyno;
dyno["message"] = e->getMessage();
dyno["type"] = e->getType();
if(!e->getCause().isNull())
{
dyno["cause"] = convertToDynamicObject(e->getCause());
}
if(!(*e).mDetails->isNull())
{
dyno["details"] = e->getDetails();
}
return dyno;
}
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();
}
