/*
Get the packet into which to read data. Return in *size the length of data to attempt to read.
*/
static HttpPacket *getPacket(HttpConn *conn, ssize *size)
{
HttpPacket *packet;
MprBuf *content;
ssize psize;
if ((packet = conn->input) == NULL) {
/*
Boost the size of the packet if we have already read a largish amount of data
*/
psize = (conn->rx && conn->rx->bytesRead > ME_MAX_BUFFER) ? ME_MAX_BUFFER * 8 : ME_MAX_BUFFER;
conn->input = packet = httpCreateDataPacket(psize);
} else {
content = packet->content;
mprResetBufIfEmpty(content);
if (mprGetBufSpace(content) < ME_MAX_BUFFER && mprGrowBuf(content, ME_MAX_BUFFER) < 0) {
conn->keepAliveCount = 0;
conn->state = HTTP_STATE_BEGIN;
return 0;
}
}
*size = mprGetBufSpace(packet->content);
assert(*size > 0);
return packet;
}
static ssize doOutput(HttpQueue *q, cchar *data, ssize len)
{
HttpPacket *packet;
ssize count;
count = min(len, q->max - q->count);
count = min(count, q->packetSize);
packet = httpCreateDataPacket(count);
mprPutBlockToBuf(packet->content, data, len);
httpPutForService(q, packet, HTTP_SCHEDULE_QUEUE);
return count;
}
static void handleTraceMethod(HttpStream *stream)
{
HttpTx *tx;
HttpQueue *q;
HttpPacket *traceData;
tx = stream->tx;
q = stream->writeq;
/*
Create a dummy set of headers to use as the response body. Then reset so the connector will create
the headers in the normal fashion. Need to be careful not to have a content length in the headers in the body.
*/
tx->flags |= HTTP_TX_NO_LENGTH;
httpDiscardData(stream, HTTP_QUEUE_TX);
traceData = httpCreateDataPacket(q->packetSize);
httpCreateHeaders1(q, traceData);
tx->flags &= ~(HTTP_TX_NO_LENGTH | HTTP_TX_HEADERS_CREATED);
httpSetContentType(stream, "message/http");
httpPutPacketToNext(q, traceData);
httpFinalize(stream);
}
/*
This will be enabled when caching is enabled for the route and there is no acceptable cache data to use.
OR - manual caching has been enabled.
*/
static void outgoingCacheFilterService(HttpQueue *q)
{
HttpPacket *packet, *data;
HttpConn *conn;
HttpTx *tx;
MprKey *kp;
cchar *cachedData;
ssize size;
int foundDataPacket;
conn = q->conn;
tx = conn->tx;
foundDataPacket = 0;
cachedData = 0;
if (tx->status < 200 || tx->status > 299) {
tx->cacheBuffer = 0;
}
/*
This routine will save cached responses to tx->cacheBuffer.
It will also send cached data if the X-SendCache header is present. Normal caching is done by cacheHandler
*/
if (mprLookupKey(conn->tx->headers, "X-SendCache") != 0) {
if (fetchCachedResponse(conn)) {
mprLog(3, "cacheFilter: write cached content for '%s'", conn->rx->uri);
cachedData = setHeadersFromCache(conn, tx->cachedContent);
tx->length = slen(cachedData);
}
}
for (packet = httpGetPacket(q); packet; packet = httpGetPacket(q)) {
if (!httpWillNextQueueAcceptPacket(q, packet)) {
httpPutBackPacket(q, packet);
return;
}
if (packet->flags & HTTP_PACKET_HEADER) {
if (!cachedData && tx->cacheBuffer) {
/*
Add defined headers to the start of the cache buffer. Separate with a double newline.
*/
mprPutFmtToBuf(tx->cacheBuffer, "X-Status: %d\n", tx->status);
for (kp = 0; (kp = mprGetNextKey(tx->headers, kp)) != 0; ) {
mprPutFmtToBuf(tx->cacheBuffer, "%s: %s\n", kp->key, kp->data);
}
mprPutCharToBuf(tx->cacheBuffer, '\n');
}
} else if (packet->flags & HTTP_PACKET_DATA) {
if (cachedData) {
/*
Using X-SendCache. Replace the data with the cached response.
*/
mprFlushBuf(packet->content);
mprPutBlockToBuf(packet->content, cachedData, (ssize) tx->length);
} else if (tx->cacheBuffer) {
/*
Save the response packet to the cache buffer. Will write below in saveCachedResponse.
*/
size = mprGetBufLength(packet->content);
if ((tx->cacheBufferLength + size) < conn->limits->cacheItemSize) {
mprPutBlockToBuf(tx->cacheBuffer, mprGetBufStart(packet->content), mprGetBufLength(packet->content));
tx->cacheBufferLength += size;
} else {
tx->cacheBuffer = 0;
mprLog(3, "cacheFilter: Item too big to cache %d bytes, limit %d", tx->cacheBufferLength + size,
conn->limits->cacheItemSize);
}
}
foundDataPacket = 1;
} else if (packet->flags & HTTP_PACKET_END) {
if (cachedData && !foundDataPacket) {
/*
Using X-SendCache but there was no data packet to replace. So do the write here
*/
data = httpCreateDataPacket((ssize) tx->length);
mprPutBlockToBuf(data->content, cachedData, (ssize) tx->length);
httpPutPacketToNext(q, data);
} else if (tx->cacheBuffer) {
/*
Save the cache buffer to the cache store
*/
saveCachedResponse(conn);
}
}
httpPutPacketToNext(q, packet);
}
}
static void readFromCgi(Cgi *cgi, int channel)
{
HttpConn *conn;
HttpPacket *packet;
HttpTx *tx;
HttpQueue *q, *writeq;
MprCmd *cmd;
ssize nbytes;
int err;
cmd = cgi->cmd;
conn = cgi->conn;
tx = conn->tx;
q = cgi->readq;
writeq = conn->writeq;
assert(conn->sock);
assert(conn->state > HTTP_STATE_BEGIN);
if (tx->finalized) {
mprCloseCmdFd(cmd, channel);
}
while (mprGetCmdFd(cmd, channel) >= 0 && !tx->finalized && writeq->count < writeq->max) {
if ((packet = cgi->headers) != 0) {
if (mprGetBufSpace(packet->content) < ME_MAX_BUFFER && mprGrowBuf(packet->content, ME_MAX_BUFFER) < 0) {
break;
}
} else if ((packet = httpCreateDataPacket(ME_MAX_BUFFER)) == 0) {
break;
}
nbytes = mprReadCmd(cmd, channel, mprGetBufEnd(packet->content), ME_MAX_BUFFER);
if (nbytes < 0) {
err = mprGetError();
if (err == EINTR) {
continue;
} else if (err == EAGAIN || err == EWOULDBLOCK) {
break;
}
mprCloseCmdFd(cmd, channel);
break;
} else if (nbytes == 0) {
mprCloseCmdFd(cmd, channel);
break;
} else {
traceData(cmd, mprGetBufEnd(packet->content), nbytes);
mprAdjustBufEnd(packet->content, nbytes);
}
if (channel == MPR_CMD_STDERR) {
mprLog("error cgi", 0, "CGI failed uri=\"%s\", details: %s", conn->rx->uri, mprGetBufStart(packet->content));
httpSetStatus(conn, HTTP_CODE_SERVICE_UNAVAILABLE);
cgi->seenHeader = 1;
}
if (!cgi->seenHeader) {
if (!parseCgiHeaders(cgi, packet)) {
cgi->headers = packet;
return;
}
cgi->headers = 0;
cgi->seenHeader = 1;
}
if (!tx->finalizedOutput && httpGetPacketLength(packet) > 0) {
/* Put the data to the CGI readq, then cgiToBrowserService will take care of it */
httpPutPacket(q, packet);
}
}
}
static void processProxy(HttpQueue *q)
{
int count = 50000;
q->max = 65536;
#if USE0
/*
May overflow q->max
*/
while (sofar < count) {
httpWrite(q, "%d aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n", sofar++);
}
httpFinalizeOutput(q->conn);
sofar = 0;
#endif
#if USE1
httpWrite(q, "%d aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n", sofar++);
if (sofar == count) {
httpFinalizeOutput(q->conn);
sofar = 0;
}
#endif
#if USE2
while (sofar < count && q->count < (q->max * 3 / 4)) {
/* NOTE: httpWrite may do internal flush if count > max */
httpWrite(q, "%d aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n", sofar++);
}
if (sofar == count) {
httpFinalizeOutput(q->conn);
sofar = 0;
}
#endif
#if USE3
/*
MANUAL FLOW CONTROL
*/
HttpPacket *packet;
int i, size;
size = 1024;
for (; sofar < count && q->count < q->max; sofar++) {
packet = httpCreateDataPacket(size);
for (i = 1; i < size - 1; i++) {
mprPutCharToBuf(packet->content, 'a');
}
mprPutCharToBuf(packet->content, '\n');
httpPutForService(q, packet, HTTP_DELAY_SERVICE);
}
if (sofar == count) {
httpFinalizeOutput(q->conn);
sofar = 0;
}
#endif
#if USE4 || 1
httpStealConn(q->conn);
#endif
}
/*
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;
}
static void readFromCgi(Cgi *cgi, int channel)
{
HttpConn *conn;
HttpPacket *packet;
HttpTx *tx;
HttpQueue *q, *writeq;
MprCmd *cmd;
ssize nbytes;
int err;
cmd = cgi->cmd;
conn = cgi->conn;
tx = conn->tx;
q = cgi->readq;
writeq = conn->writeq;
assert(conn->sock);
assert(conn->state > HTTP_STATE_BEGIN);
if (tx->finalized) {
mprCloseCmdFd(cmd, channel);
}
while (mprGetCmdFd(cmd, channel) >= 0 && !tx->finalized && writeq->count < writeq->max) {
if ((packet = cgi->headers) != 0) {
if (mprGetBufSpace(packet->content) < ME_MAX_BUFFER && mprGrowBuf(packet->content, ME_MAX_BUFFER) < 0) {
break;
}
} else if ((packet = httpCreateDataPacket(ME_MAX_BUFFER)) == 0) {
break;
}
nbytes = mprReadCmd(cmd, channel, mprGetBufEnd(packet->content), ME_MAX_BUFFER);
if (nbytes < 0) {
err = mprGetError();
if (err == EINTR) {
continue;
} else if (err == EAGAIN || err == EWOULDBLOCK) {
break;
}
mprTrace(6, "CGI: Gateway read error %d for %s", err, (channel == MPR_CMD_STDOUT) ? "stdout" : "stderr");
mprCloseCmdFd(cmd, channel);
break;
} else if (nbytes == 0) {
mprTrace(6, "CGI: Gateway EOF for %s, pid %d", (channel == MPR_CMD_STDOUT) ? "stdout" : "stderr", cmd->pid);
mprCloseCmdFd(cmd, channel);
break;
} else {
mprTrace(6, "CGI: Gateway read %d bytes from %s", nbytes, (channel == MPR_CMD_STDOUT) ? "stdout" : "stderr");
traceData(cmd, mprGetBufEnd(packet->content), nbytes);
mprAdjustBufEnd(packet->content, nbytes);
}
if (channel == MPR_CMD_STDERR) {
// FUTURE - should be an option to keep going despite stderr output
mprError("CGI: Error for \"%s\"\n\n%s", conn->rx->uri, mprGetBufStart(packet->content));
httpSetStatus(conn, HTTP_CODE_SERVICE_UNAVAILABLE);
cgi->seenHeader = 1;
}
if (!cgi->seenHeader) {
if (!parseCgiHeaders(cgi, packet)) {
cgi->headers = packet;
return;
}
cgi->headers = 0;
cgi->seenHeader = 1;
}
if (!tx->finalizedOutput && httpGetPacketLength(packet) > 0) {
/* Put the data to the CGI readq, then cgiToBrowserService will take care of it */
httpPutPacket(q, packet);
}
}
}
