static void cgiToBrowserService(HttpQueue *q)
{
HttpConn *conn;
MprCmd *cmd;
Cgi *cgi;
if ((cgi = q->queueData) == 0) {
return;
}
conn = q->conn;
assert(q == conn->writeq);
cmd = cgi->cmd;
/*
This will copy outgoing packets downstream toward the network connector and on to the browser.
This may disable the CGI queue if the downstream net connector queue overflows because the socket
is full. In that case, httpEnableConnEvents will setup to listen for writable events. When the
socket is writable again, the connector will drain its queue which will re-enable this queue
and schedule it for service again.
*/
httpDefaultOutgoingServiceStage(q);
if (q->count < q->low) {
mprEnableCmdOutputEvents(cmd, 1);
} else if (q->count > q->max && conn->tx->writeBlocked) {
httpSuspendQueue(conn->writeq);
}
}
/*
Return true if the next queue will accept this packet. If not, then disable the queue's service procedure.
This may split the packet if it exceeds the downstreams maximum packet size.
*/
PUBLIC bool httpWillNextQueueAcceptPacket(HttpQueue *q, HttpPacket *packet)
{
HttpQueue *nextQ;
ssize size;
nextQ = q->nextQ;
size = httpGetPacketLength(packet);
if (size <= nextQ->packetSize && (size + nextQ->count) <= nextQ->max) {
return 1;
}
if (httpResizePacket(q, packet, 0) < 0) {
return 0;
}
size = httpGetPacketLength(packet);
assert(size <= nextQ->packetSize);
/*
Packet size is now acceptable. Accept the packet if the queue is mostly empty (< low) or if the
packet will fit entirely under the max or if the queue.
NOTE: queue maximums are advisory. We choose to potentially overflow the max here to optimize the case where
the queue may have say one byte and a max size packet would overflow by 1.
*/
if (nextQ->count < nextQ->low || (size + nextQ->count) <= nextQ->max) {
return 1;
}
/*
The downstream queue cannot accept this packet, so disable queue and mark the downstream queue as full and service
*/
httpSuspendQueue(q);
if (!(nextQ->flags & HTTP_QUEUE_SUSPENDED)) {
httpScheduleQueue(nextQ);
}
return 0;
}
/*
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;
}
/*
Return true if the next queue will accept a certain amount of data. If not, then disable the queue's service procedure.
Will not split the packet.
*/
PUBLIC bool httpWillNextQueueAcceptSize(HttpQueue *q, ssize size)
{
HttpQueue *nextQ;
nextQ = q->nextQ;
if (size <= nextQ->packetSize && (size + nextQ->count) <= nextQ->max) {
return 1;
}
httpSuspendQueue(q);
if (!(nextQ->flags & HTTP_QUEUE_SUSPENDED)) {
httpScheduleQueue(nextQ);
}
return 0;
}