/*
Read the output data from the CGI script and return it to the client. This is called by the MPR in response to
I/O events from the CGI process for stdout/stderr data from the CGI script and for EOF from the CGI's stdin.
IMPORTANT: This event runs on the connection's dispatcher. (ie. single threaded and safe)
*/
static void cgiCallback(MprCmd *cmd, int channel, void *data)
{
HttpConn *conn;
Cgi *cgi;
int suspended;
if ((cgi = data) == 0) {
return;
}
if ((conn = cgi->conn) == 0) {
return;
}
conn->lastActivity = conn->http->now;
switch (channel) {
case MPR_CMD_STDIN:
/* Stdin can absorb more data */
httpResumeQueue(cgi->writeq);
break;
case MPR_CMD_STDOUT:
case MPR_CMD_STDERR:
readFromCgi(cgi, channel);
break;
default:
/* Child death notification */
if (cmd->status != 0) {
httpError(cgi->conn, HTTP_CODE_BAD_GATEWAY, "Bad CGI process termination");
}
break;
}
if (cgi->location) {
httpRedirect(conn, conn->tx->status, cgi->location);
}
if (cmd->complete || cgi->location) {
cgi->location = 0;
httpFinalize(conn);
mprCreateEvent(conn->dispatcher, "cgiComplete", 0, httpIOEvent, conn, 0);
return;
}
suspended = httpIsQueueSuspended(conn->writeq);
assert(!suspended || conn->tx->writeBlocked);
mprEnableCmdOutputEvents(cmd, !suspended);
mprCreateEvent(conn->dispatcher, "cgi", 0, httpIOEvent, conn, 0);
}
/*
Read the output data from the CGI script and return it to the client. This is called by the MPR in response to
I/O events from the CGI process for stdout/stderr data from the CGI script and for EOF from the CGI's stdin.
IMPORTANT: This event runs on the connection's dispatcher. (ie. single threaded and safe)
*/
static void cgiCallback(MprCmd *cmd, int channel, void *data)
{
HttpConn *conn;
Cgi *cgi;
int suspended;
if ((cgi = data) == 0) {
return;
}
if ((conn = cgi->conn) == 0) {
return;
}
conn->lastActivity = conn->http->now;
mprTrace(6, "CGI: cgiCallback event channel %d", channel);
switch (channel) {
case MPR_CMD_STDIN:
/* Stdin can absorb more data */
httpResumeQueue(cgi->writeq);
break;
case MPR_CMD_STDOUT:
case MPR_CMD_STDERR:
readFromCgi(cgi, channel);
break;
default:
/* Child death notification */
break;
}
if (cgi->location) {
httpRedirect(conn, conn->tx->status, cgi->location);
}
if (cmd->complete || cgi->location) {
cgi->location = 0;
httpFinalize(conn);
mprCreateEvent(conn->dispatcher, "cgiComplete", 0, httpIOEvent, conn, 0);
return;
}
suspended = httpIsQueueSuspended(conn->writeq);
mprTrace(6, "CGI: %s CGI: cgiCallback. Conn->writeq %d", suspended ? "DISABLE" : "ENABLE", conn->writeq->count);
assert(!suspended || conn->tx->writeBlocked);
mprEnableCmdOutputEvents(cmd, !suspended);
mprCreateEvent(conn->dispatcher, "cgi", 0, httpIOEvent, conn, 0);
}
/*
Write a block of data. This is the lowest level write routine for data. This will buffer the data and flush if
the queue buffer is full. Flushing is done by calling httpFlushQueue which will service queues as required. This
may call the queue outgoing service routine and disable downstream queues if they are overfull.
This routine will always accept the data and never return "short".
*/
PUBLIC ssize httpWriteBlock(HttpQueue *q, cchar *buf, ssize len, int flags)
{
HttpPacket *packet;
HttpConn *conn;
HttpTx *tx;
ssize totalWritten, packetSize, thisWrite;
assert(q == q->conn->writeq);
conn = q->conn;
tx = conn->tx;
if (flags == 0) {
flags = HTTP_BUFFER;
}
if (tx == 0 || tx->finalizedOutput) {
return MPR_ERR_CANT_WRITE;
}
tx->responded = 1;
for (totalWritten = 0; len > 0; ) {
mprTrace(7, "httpWriteBlock q_count %d, q_max %d", q->count, q->max);
if (conn->state >= HTTP_STATE_FINALIZED) {
return MPR_ERR_CANT_WRITE;
}
if (q->last && q->last != q->first && q->last->flags & HTTP_PACKET_DATA && mprGetBufSpace(q->last->content) > 0) {
packet = q->last;
} else {
packetSize = (tx->chunkSize > 0) ? tx->chunkSize : q->packetSize;
if ((packet = httpCreateDataPacket(packetSize)) == 0) {
return MPR_ERR_MEMORY;
}
httpPutForService(q, packet, HTTP_DELAY_SERVICE);
}
assert(mprGetBufSpace(packet->content) > 0);
thisWrite = min(len, mprGetBufSpace(packet->content));
if (flags & (HTTP_BLOCK | HTTP_NON_BLOCK)) {
thisWrite = min(thisWrite, q->max - q->count);
}
if (thisWrite > 0) {
if ((thisWrite = mprPutBlockToBuf(packet->content, buf, thisWrite)) == 0) {
return MPR_ERR_MEMORY;
}
buf += thisWrite;
len -= thisWrite;
q->count += thisWrite;
totalWritten += thisWrite;
}
if (q->count >= q->max) {
httpFlushQueue(q, 0);
if (q->count >= q->max) {
if (flags & HTTP_NON_BLOCK) {
break;
} else if (flags & HTTP_BLOCK) {
while (q->count >= q->max && !tx->finalized) {
if (!mprWaitForSingleIO((int) conn->sock->fd, MPR_WRITABLE, conn->limits->inactivityTimeout)) {
return MPR_ERR_TIMEOUT;
}
httpResumeQueue(conn->connectorq);
httpServiceQueues(conn);
}
}
}
}
}
if (conn->error) {
return MPR_ERR_CANT_WRITE;
}
return totalWritten;
}
/*
Handle IO on the connection. Initially the conn->dispatcher will be set to the server->dispatcher and the first
I/O event will be handled on the server thread (or main thread). A request handler may create a new
conn->dispatcher and transfer execution to a worker thread if required.
*/
PUBLIC void httpIO(HttpConn *conn, int eventMask)
{
MprSocket *sp;
sp = conn->sock;
if (conn->destroyed) {
/* Connection has been destroyed */
return;
}
if (conn->state < HTTP_STATE_PARSED && mprShouldDenyNewRequests()) {
httpDestroyConn(conn);
return;
}
assert(conn->tx);
assert(conn->rx);
#if DEPRECATED || 1
/* Just IO state asserting */
if (conn->io) {
assert(!conn->io);
return;
}
conn->io = 1;
#endif
if ((eventMask & MPR_WRITABLE) && conn->connectorq) {
httpResumeQueue(conn->connectorq);
}
if (eventMask & MPR_READABLE) {
readPeerData(conn);
}
if (sp->secured && !conn->secure) {
conn->secure = 1;
if (sp->peerCert) {
httpTrace(conn, "connection.ssl", "context", "msg:'Connection secured with peer certificate'," \
"secure:true,cipher:'%s',peerName:'%s',subject:'%s',issuer:'%s',session:'%s'",
sp->cipher, sp->peerName, sp->peerCert, sp->peerCertIssuer, sp->session);
} else {
httpTrace(conn, "connection.ssl", "context",
"msg:'Connection secured without peer certificate',secure:true,cipher:'%s',session:'%s'",
sp->cipher, sp->session);
}
if (mprGetLogLevel() >= 5) {
mprLog("info http ssl", 5, "SSL State: %s", mprGetSocketState(sp));
}
}
/*
Process one or more complete requests in the packet
*/
do {
/* This is and must be the only place httpProtocol is ever called */
httpProtocol(conn);
} while (conn->endpoint && conn->state == HTTP_STATE_COMPLETE && prepForNext(conn));
/*
When a request completes, prepForNext will reset the state to HTTP_STATE_BEGIN
*/
if (conn->state < HTTP_STATE_PARSED && conn->endpoint && (mprIsSocketEof(conn->sock) || (conn->keepAliveCount <= 0))) {
httpDestroyConn(conn);
} else if (!mprIsSocketEof(conn->sock) && conn->async && !conn->delay) {
httpEnableConnEvents(conn);
}
conn->io = 0;
}
