int mprPutBlockToBuf(MprBuf *bp, cchar *str, int size)
{
int thisLen, bytes, space;
mprAssert(str);
mprAssert(size >= 0);
/*
Add the max we can in one copy
*/
bytes = 0;
while (size > 0) {
space = mprGetBufSpace(bp);
thisLen = min(space, size);
if (thisLen <= 0) {
if (mprGrowBuf(bp, size) < 0) {
break;
}
space = mprGetBufSpace(bp);
thisLen = min(space, size);
}
memcpy(bp->end, str, thisLen);
str += thisLen;
bp->end += thisLen;
size -= thisLen;
bytes += thisLen;
}
if (bp->end < bp->endbuf) {
*((char*) bp->end) = (char) '\0';
}
return bytes;
}
/*
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;
}
/*
* Get the packet into which to read data. This may be owned by the connection or if mid-request, may be owned by the
* request. Also return in *bytesToRead the length of data to attempt to read.
*/
static inline MaPacket *getPacket(MaConn *conn, int *bytesToRead)
{
MaPacket *packet;
MaRequest *req;
MprBuf *content;
MprOff remaining;
int len;
req = conn->request;
len = MA_BUFSIZE;
/*
* The input packet may have pipelined headers and data left from the prior request. It may also have incomplete
* chunk boundary data.
*/
if ((packet = conn->input) == NULL) {
conn->input = packet = maCreateConnPacket(conn, len);
} else {
content = packet->content;
mprResetBufIfEmpty(content);
if (req) {
/*
* Don't read more than the remainingContent unless chunked. We do this to minimize requests split
* across packets.
*/
if (req->remainingContent) {
remaining = req->remainingContent;
if (req->flags & MA_REQ_CHUNKED) {
remaining = max(remaining, MA_BUFSIZE);
}
len = (int) min(remaining, MAXINT);
}
len = min(len, MA_BUFSIZE);
mprAssert(len > 0);
if (mprGetBufSpace(content) < len) {
mprGrowBuf(content, len);
}
} else {
/*
* Still reading the request headers
*/
if (mprGetBufLength(content) >= conn->http->limits.maxHeader) {
maFailConnection(conn, MPR_HTTP_CODE_REQUEST_TOO_LARGE, "Header too big");
return 0;
}
if (mprGetBufSpace(content) < MA_BUFSIZE) {
mprGrowBuf(content, MA_BUFSIZE);
}
len = mprGetBufSpace(content);
}
}
mprAssert(len > 0);
*bytesToRead = len;
return packet;
}
/*
* Default callback routine for the mprRunCmd routines. Uses may supply their own callback instead of this routine.
* The callback is run whenever there is I/O to read/write to the CGI gateway.
*/
static int cmdCallback(MprCmd *cmd, int channel, void *data)
{
MprBuf *buf;
int len, space;
/*
* Note: stdin, stdout and stderr are named from the client's perspective
*/
buf = 0;
switch (channel) {
case MPR_CMD_STDIN:
return 0;
case MPR_CMD_STDOUT:
buf = cmd->stdoutBuf;
break;
case MPR_CMD_STDERR:
buf = cmd->stderrBuf;
break;
}
/*
* Read and aggregate the result into a single string
*/
space = mprGetBufSpace(buf);
if (space < (MPR_BUFSIZE / 4)) {
if (mprGrowBuf(buf, MPR_BUFSIZE) < 0) {
mprCloseCmdFd(cmd, channel);
return 0;
}
space = mprGetBufSpace(buf);
}
len = mprReadCmdPipe(cmd, channel, mprGetBufEnd(buf), space);
if (len <= 0) {
if (len == 0 || (len < 0 && !(errno == EAGAIN || errno == EWOULDBLOCK))) {
if (channel == MPR_CMD_STDOUT && cmd->flags & MPR_CMD_ERR) {
/*
* Now that stdout is complete, enable stderr to receive an EOF or any error output.
* This is serialized to eliminate both stdin and stdout events on different threads at the same time.
* Do before closing as the stderr event may come on another thread and we want to ensure avoid locking.
*/
mprCloseCmdFd(cmd, channel);
} else {
mprCloseCmdFd(cmd, channel);
}
return 0;
}
} else {
mprAdjustBufEnd(buf, len);
}
return 0;
}
/*
Populate a packet with file data. Return the number of bytes read or a negative error code. Will not return with
a short read.
*/
static ssize readFileData(HttpQueue *q, HttpPacket *packet, MprOff pos, ssize size)
{
HttpConn *conn;
HttpTx *tx;
ssize nbytes;
// int btint = 0;
conn = q->conn;
tx = conn->tx;
if (packet->content == 0 && (packet->content = mprCreateBuf(size, -1)) == 0) {
return MPR_ERR_MEMORY;
}
assure(size <= mprGetBufSpace(packet->content));
mprLog(7, "readFileData size %d, pos %Ld", size, pos);
if (pos >= 0) {
mprSeekFile(tx->file, SEEK_SET, pos);
}
if ((nbytes = mprReadFile(tx->file, mprGetBufStart(packet->content), size)) != size) {
/*
As we may have sent some data already to the client, the only thing we can do is abort and hope the client
notices the short data.
*/
httpError(conn, HTTP_CODE_SERVICE_UNAVAILABLE, "Can't read file %s", tx->filename);
return MPR_ERR_CANT_READ;
}
mprAdjustBufEnd(packet->content, nbytes);
packet->esize -= nbytes;
assure(packet->esize == 0);
return nbytes;
}
/*
Read the required number of bytes into the response content buffer. Count < 0 means transfer the entire content.
Returns the number of bytes read. Returns null on EOF.
*/
static ssize readHttpData(Ejs *ejs, EjsHttp *hp, ssize count)
{
MprBuf *buf;
HttpConn *conn;
ssize len, space, nbytes;
conn = hp->conn;
buf = hp->responseContent;
mprResetBufIfEmpty(buf);
while (count < 0 || mprGetBufLength(buf) < count) {
len = (count < 0) ? BIT_MAX_BUFFER : (count - mprGetBufLength(buf));
space = mprGetBufSpace(buf);
if (space < len) {
mprGrowBuf(buf, len - space);
}
if ((nbytes = httpRead(conn, mprGetBufEnd(buf), len)) < 0) {
ejsThrowIOError(ejs, "Cannot read required data");
return MPR_ERR_CANT_READ;
}
mprAdjustBufEnd(buf, nbytes);
if (hp->conn->async || (nbytes == 0 && conn->state > HTTP_STATE_CONTENT)) {
break;
}
}
if (count < 0) {
return mprGetBufLength(buf);
}
return min(count, mprGetBufLength(buf));
}
/*
Default callback routine for the mprRunCmd routines. Uses may supply their own callback instead of this routine.
The callback is run whenever there is I/O to read/write to the CGI gateway.
*/
static void defaultCmdCallback(MprCmd *cmd, int channel, void *data)
{
MprBuf *buf;
ssize len, space;
int errCode;
/*
Note: stdin, stdout and stderr are named from the client's perspective
*/
buf = 0;
switch (channel) {
case MPR_CMD_STDIN:
return;
case MPR_CMD_STDOUT:
buf = cmd->stdoutBuf;
break;
case MPR_CMD_STDERR:
buf = cmd->stderrBuf;
break;
default:
/* Child death notification */
return;
}
/*
Read and aggregate the result into a single string
*/
space = mprGetBufSpace(buf);
if (space < (ME_BUFSIZE / 4)) {
if (mprGrowBuf(buf, ME_BUFSIZE) < 0) {
mprCloseCmdFd(cmd, channel);
return;
}
space = mprGetBufSpace(buf);
}
len = mprReadCmd(cmd, channel, mprGetBufEnd(buf), space);
errCode = mprGetError();
if (len <= 0) {
if (len == 0 || (len < 0 && !(errCode == EAGAIN || errCode == EWOULDBLOCK))) {
mprCloseCmdFd(cmd, channel);
return;
}
} else {
mprAdjustBufEnd(buf, len);
}
mprAddNullToBuf(buf);
mprEnableCmdEvents(cmd, channel);
}
int mprPuts(MprFile *file, const char *writeBuf, uint count)
{
MprBuf *bp;
char *buf;
int total, bytes, len;
mprAssert(file);
/*
* Buffer output and flush when full.
*/
if (file->buf == 0) {
file->buf = mprCreateBuf(file, MPR_BUFSIZE, 0);
if (file->buf == 0) {
return MPR_ERR_CANT_ALLOCATE;
}
}
bp = file->buf;
if (mprGetBufLength(bp) > 0 && mprGetBufSpace(bp) < (int) count) {
len = mprGetBufLength(bp);
if (mprWrite(file, mprGetBufStart(bp), len) != len) {
return MPR_ERR_CANT_WRITE;
}
mprFlushBuf(bp);
}
total = 0;
buf = (char*) writeBuf;
while (count > 0) {
bytes = mprPutBlockToBuf(bp, buf, count);
if (bytes <= 0) {
return MPR_ERR_CANT_ALLOCATE;
}
count -= bytes;
buf += bytes;
total += bytes;
mprAddNullToBuf(bp);
if (count > 0) {
len = mprGetBufLength(bp);
if (mprWrite(file, mprGetBufStart(bp), len) != len) {
return MPR_ERR_CANT_WRITE;
}
mprFlushBuf(bp);
}
}
return total;
}
static int getPostData(MprCtx ctx, MprBuf *buf)
{
char *contentLength;
int bytes, len, space;
if ((contentLength = getenv("CONTENT_LENGTH")) != 0) {
len = atoi(contentLength);
} else {
len = MAXINT;
}
while (len > 0) {
space = mprGetBufSpace(buf);
if (space < MPR_BUFSIZE) {
if (mprGrowBuf(buf, MPR_BUFSIZE) < 0) {
error(mpr, "Couldn't allocate memory to read post data");
return -1;
}
}
space = mprGetBufSpace(buf);
bytes = (int) read(0, mprGetBufEnd(buf), space);
if (bytes < 0) {
error(mpr, "Couldn't read CGI input %d", errno);
return -1;
} else if (bytes == 0) {
/* EOF */
if (len > 0) {
error(mpr, "Missing content (length %s)", contentLength);
}
break;
}
mprAdjustBufEnd(buf, bytes);
len -= bytes;
}
mprAddNullToBuf(buf);
return 0;
}
/*
Put a string to the file. This will put the file into buffered mode.
*/
PUBLIC ssize mprPutFileString(MprFile *file, cchar *str)
{
MprBuf *bp;
ssize total, bytes, count;
char *buf;
assert(file);
count = slen(str);
/*
Buffer output and flush when full.
*/
if (file->buf == 0) {
file->buf = mprCreateBuf(ME_MAX_BUFFER, 0);
if (file->buf == 0) {
return MPR_ERR_CANT_ALLOCATE;
}
}
bp = file->buf;
if (mprGetBufLength(bp) > 0 && mprGetBufSpace(bp) < count) {
mprFlushFile(file);
}
total = 0;
buf = (char*) str;
while (count > 0) {
bytes = mprPutBlockToBuf(bp, buf, count);
if (bytes < 0) {
return MPR_ERR_CANT_ALLOCATE;
} else if (bytes == 0) {
if (mprFlushFile(file) < 0) {
return MPR_ERR_CANT_WRITE;
}
continue;
}
count -= bytes;
buf += bytes;
total += bytes;
file->pos += (MprOff) bytes;
}
return total;
}
/*
Fill the read buffer. Return the new buffer length. Only called when the buffer is empty.
*/
static ssize fillBuf(MprFile *file)
{
MprFileSystem *fs;
MprBuf *bp;
ssize len;
bp = file->buf;
fs = file->fileSystem;
assert(mprGetBufLength(bp) == 0);
mprFlushBuf(bp);
len = fs->readFile(file, mprGetBufStart(bp), mprGetBufSpace(bp));
if (len <= 0) {
return len;
}
mprAdjustBufEnd(bp, len);
return len;
}
/*
* Emit all headers
*/
static void emitHeaders()
{
MprHash *hp;
int len;
hp = mprGetFirstHash(responseHeaders);
while (hp) {
len = strlen(hp->key) + strlen(hp->data) + 4;
if (mprGetBufSpace(headerOutput) < len) {
flushOutput(headerOutput);
}
mprPutStringToBuf(headerOutput, hp->key);
mprPutStringToBuf(headerOutput, ": ");
mprPutStringToBuf(headerOutput, hp->data);
mprPutStringToBuf(headerOutput, "\r\n");
hp = mprGetNextHash(responseHeaders, hp);
}
mprPutStringToBuf(headerOutput, "\r\n");
flushOutput(headerOutput);
headersEmitted = 1;
}
int mprPutFmtToBuf(MprBuf *bp, cchar *fmt, ...)
{
va_list ap;
char *buf;
int rc, space;
if (fmt == 0) {
return 0;
}
va_start(ap, fmt);
space = mprGetBufSpace(bp);
/*
* Add max that the buffer can grow
*/
space += (bp->maxsize - bp->buflen);
buf = mprVasprintf(bp, space, fmt, ap);
rc = mprPutStringToBuf(bp, buf);
mprFree(buf);
va_end(ap);
return rc;
}
/*
Get another character. We read and buffer blocks of data if we need more data to parse.
*/
static int getNextChar(MprXml *xp)
{
MprBuf *inBuf;
ssize l;
int c;
inBuf = xp->inBuf;
if (mprGetBufLength(inBuf) <= 0) {
/*
Flush to reset the servp/endp pointers to the start of the buffer so we can do a maximal read
*/
mprFlushBuf(inBuf);
l = (xp->readFn)(xp, xp->inputArg, mprGetBufStart(inBuf), mprGetBufSpace(inBuf));
if (l <= 0) {
return -1;
}
mprAdjustBufEnd(inBuf, l);
}
c = mprGetCharFromBuf(inBuf);
if (c == '\n') {
xp->lineNumber++;
}
return c;
}
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);
}
}
}
static void cgiEvent(MaQueue *q, MprCmd *cmd, int channel)
{
MaConn *conn;
MaResponse *resp;
MprBuf *buf;
int space, nbytes, err;
mprLog(cmd, 6, "CGI callback channel %d", channel);
buf = 0;
conn = q->conn;
resp = conn->response;
mprAssert(resp);
cmd->lastActivity = mprGetTime(cmd);
switch (channel) {
case MPR_CMD_STDIN:
writeToCGI(q->pair);
return;
case MPR_CMD_STDOUT:
buf = cmd->stdoutBuf;
break;
case MPR_CMD_STDERR:
buf = cmd->stderrBuf;
break;
}
mprAssert(buf);
mprResetBufIfEmpty(buf);
/*
Come here for CGI stdout, stderr events. ie. reading data from the CGI program.
*/
while (mprGetCmdFd(cmd, channel) >= 0) {
/*
Read as much data from the CGI as possible
*/
do {
if ((space = mprGetBufSpace(buf)) == 0) {
mprGrowBuf(buf, MA_BUFSIZE);
if ((space = mprGetBufSpace(buf)) == 0) {
break;
}
}
nbytes = mprReadCmdPipe(cmd, channel, mprGetBufEnd(buf), space);
mprLog(q, 5, "CGI: read from gateway %d on channel %d. errno %d", nbytes, channel,
nbytes >= 0 ? 0 : mprGetOsError());
if (nbytes < 0) {
err = mprGetError();
if (err == EINTR) {
continue;
} else if (err == EAGAIN || err == EWOULDBLOCK) {
break;
}
mprLog(cmd, 5, "CGI read error %d for %", mprGetError(), (channel == MPR_CMD_STDOUT) ? "stdout" : "stderr");
mprCloseCmdFd(cmd, channel);
} else if (nbytes == 0) {
/*
This may reap the terminated child and thus clear cmd->process if both stderr and stdout are closed.
*/
mprLog(cmd, 5, "CGI EOF for %s", (channel == MPR_CMD_STDOUT) ? "stdout" : "stderr");
mprCloseCmdFd(cmd, channel);
break;
} else {
mprLog(cmd, 5, "CGI read %d bytes from %s", nbytes, (channel == MPR_CMD_STDOUT) ? "stdout" : "stderr");
mprAdjustBufEnd(buf, nbytes);
traceData(cmd, mprGetBufStart(buf), nbytes);
}
} while ((space = mprGetBufSpace(buf)) > 0);
if (mprGetBufLength(buf) == 0) {
return;
}
if (channel == MPR_CMD_STDERR) {
/*
If we have an error message, send that to the client
*/
if (mprGetBufLength(buf) > 0) {
mprAddNullToBuf(buf);
mprLog(conn, 4, mprGetBufStart(buf));
if (writeToClient(q, cmd, buf, channel) < 0) {
return;
}
maSetResponseCode(conn, MPR_HTTP_CODE_SERVICE_UNAVAILABLE);
cmd->userFlags |= MA_CGI_SEEN_HEADER;
cmd->status = 0;
}
} else {
if (!(cmd->userFlags & MA_CGI_SEEN_HEADER) && !parseHeader(conn, cmd)) {
return;
}
if (cmd->userFlags & MA_CGI_SEEN_HEADER) {
if (writeToClient(q, cmd, buf, channel) < 0) {
return;
}
}
}
}
}
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);
}
}
}
/*
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;
}