static void browserToCgiService(HttpQueue *q)
{
HttpConn *conn;
HttpPacket *packet;
Cgi *cgi;
MprCmd *cmd;
MprBuf *buf;
ssize rc, len;
int err;
if ((cgi = q->queueData) == 0) {
return;
}
assert(q == cgi->writeq);
cmd = cgi->cmd;
assert(cmd);
conn = cgi->conn;
for (packet = httpGetPacket(q); packet; packet = httpGetPacket(q)) {
if ((buf = packet->content) == 0) {
/* End packet */
continue;
}
len = mprGetBufLength(buf);
rc = mprWriteCmd(cmd, MPR_CMD_STDIN, mprGetBufStart(buf), len);
if (rc < 0) {
err = mprGetError();
if (err == EINTR) {
continue;
} else if (err == EAGAIN || err == EWOULDBLOCK) {
httpPutBackPacket(q, packet);
break;
}
mprLog(2, "CGI: write to gateway failed for %d bytes, rc %d, errno %d", len, rc, mprGetOsError());
mprCloseCmdFd(cmd, MPR_CMD_STDIN);
httpDiscardQueueData(q, 1);
httpError(conn, HTTP_CODE_BAD_GATEWAY, "Cannot write body data to CGI gateway");
break;
}
mprTrace(6, "CGI: browserToCgiService %d/%d, qmax %d", rc, len, q->max);
mprAdjustBufStart(buf, rc);
if (mprGetBufLength(buf) > 0) {
httpPutBackPacket(q, packet);
break;
}
}
if (q->count > 0) {
/* Wait for writable event so cgiCallback can recall this routine */
mprEnableCmdEvents(cmd, MPR_CMD_STDIN);
} else if (conn->rx->eof) {
mprCloseCmdFd(cmd, MPR_CMD_STDIN);
} else {
mprDisableCmdEvents(cmd, MPR_CMD_STDIN);
}
}
/*
The service callback will be invoked to service outgoing packets on the service queue. It will only be called
once all incoming data has been received and then there after when the downstream queues drain sufficiently to
absorb more data. This routine may flow control if the downstream stage cannot accept all the file data. It will
then be re-called as required to send more data.
*/
static void outgoingFileService(HttpQueue *q)
{
HttpConn *conn;
HttpTx *tx;
HttpPacket *packet;
bool usingSend;
int rc;
conn = q->conn;
tx = conn->tx;
usingSend = (tx->connector == conn->http->sendConnector);
for (packet = httpGetPacket(q); packet; packet = httpGetPacket(q)) {
if (!usingSend && !tx->outputRanges && packet->esize) {
if ((rc = prepPacket(q, packet)) < 0) {
return;
} else if (rc == 0) {
mprLog(7, "OutgoingFileService downstream full, putback");
httpPutBackPacket(q, packet);
return;
}
mprLog(7, "OutgoingFileService readData %d", rc);
}
httpPutPacketToNext(q, packet);
}
mprLog(7, "OutgoingFileService complete");
}
/*
Prepare a data packet for sending downstream. This involves reading file data into a suitably sized packet. Return
the 1 if the packet was sent entirely, return zero if the packet could not be completely sent. Return a negative
error code for write errors. This may split the packet if it exceeds the downstreams maximum packet size.
*/
static int prepPacket(HttpQueue *q, HttpPacket *packet)
{
HttpQueue *nextQ;
ssize size, nbytes;
nextQ = q->nextQ;
if (packet->esize > nextQ->packetSize) {
httpPutBackPacket(q, httpSplitPacket(packet, nextQ->packetSize));
size = nextQ->packetSize;
} else {
size = (ssize) packet->esize;
}
if ((size + nextQ->count) > nextQ->max) {
/*
The downstream queue is full, so disable the queue and service downstream queue.
Will re-enable via a writable event on the connection.
*/
httpSuspendQueue(q);
if (!(nextQ->flags & HTTP_QUEUE_SUSPENDED)) {
httpScheduleQueue(nextQ);
}
return 0;
}
if ((nbytes = readFileData(q, packet, q->ioPos, size)) != size) {
return MPR_ERR_CANT_READ;
}
q->ioPos += nbytes;
return 1;
}
PUBLIC void httpDefaultOutgoingServiceStage(HttpQueue *q)
{
HttpPacket *packet;
for (packet = httpGetPacket(q); packet; packet = httpGetPacket(q)) {
if (!httpWillNextQueueAcceptPacket(q, packet)) {
httpPutBackPacket(q, packet);
return;
}
httpPutPacketToNext(q, packet);
}
}
static void outgoingProxyService(HttpQueue *q)
{
HttpPacket *packet;
for (packet = httpGetPacket(q); packet; packet = httpGetPacket(q)) {
if (packet->flags & HTTP_PACKET_DATA) {
if (!httpWillNextQueueAcceptPacket(q, packet)) {
mprTrace(7, "OutgoingProxyService downstream full, putback");
httpPutBackPacket(q, packet);
return;
}
}
httpPutPacketToNext(q, packet);
}
}
static void outgoingRangeService(HttpQueue *q)
{
HttpPacket *packet;
HttpStream *stream;
HttpTx *tx;
stream = q->stream;
tx = stream->tx;
if (!(q->flags & HTTP_QUEUE_SERVICED)) {
/*
The httpContentNotModified routine can set outputRanges to zero if returning not-modified.
*/
if (!fixRangeLength(stream, q)) {
if (!q->servicing) {
httpRemoveQueue(q);
}
tx->outputRanges = 0;
tx->status = HTTP_CODE_OK;
}
}
for (packet = httpGetPacket(q); packet; packet = httpGetPacket(q)) {
if (packet->flags & HTTP_PACKET_DATA) {
if ((packet = selectBytes(q, packet)) == 0) {
continue;
}
} else if (packet->flags & HTTP_PACKET_END) {
if (tx->rangeBoundary) {
httpPutPacketToNext(q, createFinalRangePacket(stream));
}
}
if (!httpWillNextQueueAcceptPacket(q, packet)) {
httpPutBackPacket(q, packet);
return;
}
httpPutPacketToNext(q, packet);
}
}
/*
The service callback will be invoked to service outgoing packets on the service queue. It will only be called
once all incoming data has been received and then when the downstream queues drain sufficiently to absorb
more data. This routine may flow control if the downstream stage cannot accept all the file data. It will
then be re-called as required to send more data.
*/
static void outgoingFileService(HttpQueue *q)
{
HttpConn *conn;
HttpTx *tx;
HttpPacket *packet;
bool usingSend;
int rc;
conn = q->conn;
tx = conn->tx;
usingSend = (tx->connector == conn->http->sendConnector);
for (packet = httpGetPacket(q); packet; packet = httpGetPacket(q)) {
if (!usingSend && !tx->outputRanges && packet->esize) {
if ((rc = prepPacket(q, packet)) < 0) {
return;
} else if (rc == 0) {
httpPutBackPacket(q, packet);
return;
}
}
httpPutPacketToNext(q, packet);
}
}
/*
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 HttpPacket *selectBytes(HttpQueue *q, HttpPacket *packet)
{
HttpRange *range;
HttpStream *stream;
HttpTx *tx;
MprOff endPacket, length, gap, span;
ssize count;
stream = q->stream;
tx = stream->tx;
if ((range = tx->currentRange) == 0) {
return 0;
}
/*
Process the data packet over multiple ranges ranges until all the data is processed or discarded.
*/
while (range && packet) {
length = httpGetPacketLength(packet);
if (length <= 0) {
return 0;
}
endPacket = tx->rangePos + length;
if (endPacket < range->start) {
/* Packet is before the next range, so discard the entire packet and seek forwards */
tx->rangePos += length;
return 0;
} else if (tx->rangePos < range->start) {
/* Packet starts before range so skip some data, but some packet data is in range */
gap = (range->start - tx->rangePos);
tx->rangePos += gap;
if (gap < length) {
httpAdjustPacketStart(packet, (ssize) gap);
}
if (tx->rangePos >= range->end) {
range = tx->currentRange = range->next;
}
/* Keep going and examine next range */
} else {
/* In range */
assert(range->start <= tx->rangePos && tx->rangePos < range->end);
span = min(length, (range->end - tx->rangePos));
span = max(span, 0);
count = (ssize) min(span, q->nextQ->packetSize);
assert(count > 0);
if (length > count) {
/* Split packet if packet extends past range */
httpPutBackPacket(q, httpSplitPacket(packet, count));
}
if (tx->rangeBoundary) {
httpPutPacketToNext(q, createRangePacket(stream, range));
}
tx->rangePos += count;
if (tx->rangePos >= range->end) {
tx->currentRange = range->next;
}
break;
}
}
return packet;
}
