/*
Destroy a connection. This removes the connection from the list of connections.
*/
PUBLIC void httpDestroyConn(HttpConn *conn)
{
if (!conn->destroyed && !conn->borrowed) {
HTTP_NOTIFY(conn, HTTP_EVENT_DESTROY, 0);
if (httpServerConn(conn)) {
httpMonitorEvent(conn, HTTP_COUNTER_ACTIVE_CONNECTIONS, -1);
if (conn->activeRequest) {
httpMonitorEvent(conn, HTTP_COUNTER_ACTIVE_REQUESTS, -1);
conn->activeRequest = 0;
}
}
httpRemoveConn(conn);
conn->input = 0;
if (conn->tx) {
httpClosePipeline(conn);
}
if (conn->sock) {
mprCloseSocket(conn->sock, 0);
}
if (conn->dispatcher && conn->dispatcher->flags & MPR_DISPATCHER_AUTO) {
mprDestroyDispatcher(conn->dispatcher);
}
conn->destroyed = 1;
}
}
PUBLIC void httpSetConnNotifier(HttpConn *conn, HttpNotifier notifier)
{
conn->notifier = notifier;
if (conn->readq->first) {
/* Test first rather than count because we want a readable event for the end packet */
HTTP_NOTIFY(conn, HTTP_EVENT_READABLE, 0);
}
}
PUBLIC void httpSetState(HttpConn *conn, int targetState)
{
int state;
if (targetState == conn->state) {
return;
}
if (targetState < conn->state) {
/* Prevent regressions */
return;
}
for (state = conn->state + 1; state <= targetState; state++) {
conn->state = state;
HTTP_NOTIFY(conn, HTTP_EVENT_STATE, state);
}
}
static void incomingEjs(HttpQueue *q, HttpPacket *packet)
{
HttpConn *conn;
HttpRx *rx;
conn = q->conn;
rx = conn->rx;
if (httpGetPacketLength(packet) == 0) {
if (rx->remainingContent > 0) {
httpError(conn, HTTP_CODE_BAD_REQUEST, "Client supplied insufficient body data");
}
httpPutForService(q, packet, 0);
} else {
httpJoinPacketForService(q, packet, 0);
}
HTTP_NOTIFY(q->conn, HTTP_EVENT_READABLE, 0);
}
/*
Incoming data routine. Simply transfer the data upstream to the next filter or handler.
*/
static void incoming(HttpQueue *q, HttpPacket *packet)
{
assert(q);
assert(packet);
if (q->nextQ->put) {
httpPutPacketToNext(q, packet);
} else {
/* This queue is the last queue in the pipeline */
if (httpGetPacketLength(packet) > 0) {
if (packet->flags & HTTP_PACKET_SOLO) {
httpPutForService(q, packet, HTTP_DELAY_SERVICE);
} else {
httpJoinPacketForService(q, packet, 0);
}
} else {
/* Zero length packet means eof */
httpPutForService(q, packet, HTTP_DELAY_SERVICE);
}
HTTP_NOTIFY(q->conn, HTTP_EVENT_READABLE, 0);
}
}
/*
The current request has an error and cannot complete as normal. This call sets the Http response status and
overrides the normal output with an alternate error message. If the output has alread started (headers sent), then
the connection MUST be closed so the client can get some indication the request failed.
*/
static void errorv(HttpConn *conn, int flags, cchar *fmt, va_list args)
{
HttpRx *rx;
HttpTx *tx;
cchar *uri;
int status;
assert(fmt);
rx = conn->rx;
tx = conn->tx;
if (conn == 0) {
return;
}
status = flags & HTTP_CODE_MASK;
if (status == 0) {
status = HTTP_CODE_INTERNAL_SERVER_ERROR;
}
if (flags & (HTTP_ABORT | HTTP_CLOSE)) {
conn->keepAliveCount = 0;
}
if (flags & HTTP_ABORT) {
conn->connError = 1;
if (rx) {
rx->eof = 1;
}
}
if (!conn->error) {
conn->error = 1;
httpOmitBody(conn);
conn->errorMsg = formatErrorv(conn, status, fmt, args);
mprLog(2, "Error: %s", conn->errorMsg);
HTTP_NOTIFY(conn, HTTP_EVENT_ERROR, 0);
if (conn->endpoint) {
if (status == HTTP_CODE_NOT_FOUND) {
httpMonitorEvent(conn, HTTP_COUNTER_NOT_FOUND_ERRORS, 1);
}
httpMonitorEvent(conn, HTTP_COUNTER_ERRORS, 1);
}
httpAddHeaderString(conn, "Cache-Control", "no-cache");
if (conn->endpoint && tx && rx) {
if (tx->flags & HTTP_TX_HEADERS_CREATED) {
/*
If the response headers have been sent, must let the other side of the failure ... aborting
the request is the only way as the status has been sent.
*/
flags |= HTTP_ABORT;
} else {
if (rx->route && (uri = httpLookupRouteErrorDocument(rx->route, tx->status)) && !smatch(uri, rx->uri)) {
errorRedirect(conn, uri);
} else {
makeAltBody(conn, status);
}
}
}
httpFinalize(conn);
}
if (flags & HTTP_ABORT) {
httpDisconnect(conn);
}
}
