/*
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");
}
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 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);
}
}
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);
}
}
/*
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 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);
}
}
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 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;
}
/*
Process the content data.
Returns < 0 on error
== 0 when more data is needed
== 1 when data successfully written
*/
static int processUploadData(HttpQueue *q)
{
HttpConn *conn;
HttpPacket *packet;
MprBuf *content;
Upload *up;
ssize size, dataLen;
bool pureData;
char *data, *bp, *key;
conn = q->conn;
up = q->queueData;
content = q->first->content;
packet = 0;
size = mprGetBufLength(content);
if (size < up->boundaryLen) {
/* Incomplete boundary. Return and get more data */
return 0;
}
bp = getBoundary(mprGetBufStart(content), size, up->boundary, up->boundaryLen, &pureData);
if (bp == 0) {
if (up->clientFilename) {
/*
No signature found yet. probably more data to come. Must handle split boundaries.
*/
data = mprGetBufStart(content);
dataLen = pureData ? size : (size - (up->boundaryLen - 1));
if (dataLen > 0) {
if (writeToFile(q, mprGetBufStart(content), dataLen) < 0) {
return MPR_ERR_CANT_WRITE;
}
}
mprAdjustBufStart(content, dataLen);
return 0; /* Get more data */
}
}
data = mprGetBufStart(content);
dataLen = (bp) ? (bp - data) : mprGetBufLength(content);
if (dataLen > 0) {
mprAdjustBufStart(content, dataLen);
/*
This is the CRLF before the boundary
*/
if (dataLen >= 2 && data[dataLen - 2] == '\r' && data[dataLen - 1] == '\n') {
dataLen -= 2;
}
if (up->clientFilename) {
/*
Write the last bit of file data and add to the list of files and define environment variables
*/
if (writeToFile(q, data, dataLen) < 0) {
return MPR_ERR_CANT_WRITE;
}
defineFileFields(q, up);
} else {
/*
Normal string form data variables
*/
data[dataLen] = '\0';
#if KEEP
httpTrace(conn, "request.upload.variables", "context", "'%s':'%s'", up->name, data);
#endif
key = mprUriDecode(up->name);
data = mprUriDecode(data);
httpSetParam(conn, key, data);
if (packet == 0) {
packet = httpCreatePacket(ME_MAX_BUFFER);
}
if (httpGetPacketLength(packet) > 0) {
/*
Need to add www-form-urlencoding separators
*/
mprPutCharToBuf(packet->content, '&');
} else {
conn->rx->mimeType = sclone("application/x-www-form-urlencoded");
}
mprPutToBuf(packet->content, "%s=%s", up->name, data);
}
}
if (up->clientFilename) {
/*
Now have all the data (we've seen the boundary)
*/
mprCloseFile(up->file);
up->file = 0;
up->clientFilename = 0;
}
if (packet) {
httpPutPacketToNext(q, packet);
}
up->contentState = HTTP_UPLOAD_BOUNDARY;
return 0;
}
/*
Incoming data acceptance routine. The service queue is used, but not a service routine as the data is processed
immediately. Partial data is buffered on the service queue until a correct mime boundary is seen.
*/
static void incomingUpload(HttpQueue *q, HttpPacket *packet)
{
HttpConn *conn;
HttpRx *rx;
MprBuf *content;
Upload *up;
char *line, *nextTok;
ssize count;
int done, rc;
assert(packet);
conn = q->conn;
rx = conn->rx;
up = q->queueData;
if (conn->error) {
return;
}
if (httpGetPacketLength(packet) == 0) {
if (up->contentState != HTTP_UPLOAD_CONTENT_END) {
httpError(conn, HTTP_CODE_BAD_REQUEST, "Client supplied insufficient upload data");
}
httpPutPacketToNext(q, packet);
return;
}
/*
Put the packet data onto the service queue for buffering. This aggregates input data incase we don't have
a complete mime record yet.
*/
httpJoinPacketForService(q, packet, 0);
packet = q->first;
content = packet->content;
count = httpGetPacketLength(packet);
for (done = 0, line = 0; !done; ) {
if (up->contentState == HTTP_UPLOAD_BOUNDARY || up->contentState == HTTP_UPLOAD_CONTENT_HEADER) {
/*
Parse the next input line
*/
line = mprGetBufStart(content);
if ((nextTok = memchr(line, '\n', mprGetBufLength(content))) == 0) {
/* Incomplete line */
break;
}
*nextTok++ = '\0';
mprAdjustBufStart(content, (int) (nextTok - line));
line = strim(line, "\r", MPR_TRIM_END);
}
switch (up->contentState) {
case HTTP_UPLOAD_BOUNDARY:
if (processUploadBoundary(q, line) < 0) {
done++;
}
break;
case HTTP_UPLOAD_CONTENT_HEADER:
if (processUploadHeader(q, line) < 0) {
done++;
}
break;
case HTTP_UPLOAD_CONTENT_DATA:
rc = processUploadData(q);
if (rc < 0) {
done++;
}
if (httpGetPacketLength(packet) < up->boundaryLen) {
/* Incomplete boundary - return to get more data */
done++;
}
break;
case HTTP_UPLOAD_CONTENT_END:
done++;
break;
}
}
q->count -= (count - httpGetPacketLength(packet));
assert(q->count >= 0);
if (httpGetPacketLength(packet) == 0) {
/*
Quicker to remove the buffer so the packets don't have to be joined the next time
*/
httpGetPacket(q);
} else {
/*
Compact the buffer to prevent memory growth. There is often residual data after the boundary for the next block.
*/
if (packet != rx->headerPacket) {
mprCompactBuf(content);
}
}
}