/*
Eat remaining input incase last request did not consume all data
*/
static void consumeLastRequest(HttpConn *conn)
{
char junk[4096];
if (conn->state >= HTTP_STATE_FIRST) {
while (!httpIsEof(conn) && !httpRequestExpired(conn, 0)) {
if (httpRead(conn, junk, sizeof(junk)) <= 0) {
break;
}
}
}
if (HTTP_STATE_CONNECTED <= conn->state && conn->state < HTTP_STATE_COMPLETE) {
conn->keepAliveCount = 0;
}
}
static int doRequest(HttpConn *conn, cchar *url, MprList *files)
{
MprFile *outFile;
cchar *path;
assert(url && *url);
if (issueRequest(conn, url, files) < 0) {
if (conn->rx && conn->rx->status) {
reportResponse(conn, url);
}
return MPR_ERR_CANT_CONNECT;
}
if (app->outFilename) {
path = app->loadThreads > 1 ? sfmt("%s-%s.tmp", app->outFilename, mprGetCurrentThreadName()): app->outFilename;
if ((outFile = mprOpenFile(path, O_CREAT | O_WRONLY | O_TRUNC | O_TEXT, 0664)) == 0) {
mprLog("error http", 0, "Cannot open %s", path);
return MPR_ERR_CANT_OPEN;
}
} else {
outFile = mprGetStdout();
}
mprAddRoot(outFile);
readBody(conn, outFile);
while (conn->state < HTTP_STATE_COMPLETE && !httpRequestExpired(conn, -1)) {
readBody(conn, outFile);
httpWait(conn, 0, -1);
}
if (conn->state < HTTP_STATE_COMPLETE && !conn->error) {
httpError(conn, HTTP_ABORT | HTTP_CODE_REQUEST_TIMEOUT, "Request timed out");
}
if (app->outFilename) {
mprCloseFile(outFile);
}
mprRemoveRoot(outFile);
reportResponse(conn, url);
httpDestroyRx(conn->rx);
httpDestroyTx(conn->tx);
return 0;
}
/*
Wait for the connection to reach a given state.
Should only be used on the client side.
@param state Desired state. Set to zero if you want to wait for one I/O event.
@param timeout Timeout in msec. If timeout is zero, wait forever. If timeout is < 0, use default inactivity
and duration timeouts.
*/
PUBLIC int httpWait(HttpConn *conn, int state, MprTicks timeout)
{
HttpLimits *limits;
MprTicks delay, start;
int64 dispatcherMark;
int justOne;
limits = conn->limits;
if (conn->endpoint) {
assert(!conn->endpoint);
return MPR_ERR_BAD_STATE;
}
if (conn->state <= HTTP_STATE_BEGIN) {
return MPR_ERR_BAD_STATE;
}
if (state == 0) {
/* Wait for just one I/O event */
state = HTTP_STATE_FINALIZED;
justOne = 1;
} else {
justOne = 0;
}
if (conn->error) {
if (conn->state >= state) {
return 0;
}
return MPR_ERR_BAD_STATE;
}
if (timeout < 0) {
timeout = limits->requestTimeout;
} else if (timeout == 0) {
timeout = MPR_MAX_TIMEOUT;
}
if (state > HTTP_STATE_CONTENT) {
httpFinalizeOutput(conn);
}
start = conn->http->now;
dispatcherMark = mprGetEventMark(conn->dispatcher);
while (conn->state < state && !conn->error && !mprIsSocketEof(conn->sock)) {
if (httpRequestExpired(conn, -1)) {
return MPR_ERR_TIMEOUT;
}
httpEnableConnEvents(conn);
delay = min(limits->inactivityTimeout, mprGetRemainingTicks(start, timeout));
delay = max(delay, 0);
mprWaitForEvent(conn->dispatcher, delay, dispatcherMark);
if (justOne || (mprGetRemainingTicks(start, timeout) <= 0)) {
break;
}
dispatcherMark = mprGetEventMark(conn->dispatcher);
}
if (conn->error) {
return MPR_ERR_NOT_READY;
}
if (conn->state < state) {
if (mprGetRemainingTicks(start, timeout) <= 0) {
return MPR_ERR_TIMEOUT;
}
if (!justOne) {
return MPR_ERR_CANT_READ;
}
}
conn->lastActivity = conn->http->now;
return 0;
}
/*
Read data. If sync mode, this will block. If async, will never block.
Will return what data is available up to the requested size.
Timeout in milliseconds to wait. Set to -1 to use the default inactivity timeout. Set to zero to wait forever.
Returns a count of bytes read. Returns zero if no data. EOF if returns zero and conn->state is > HTTP_STATE_CONTENT.
*/
PUBLIC ssize httpReadBlock(HttpConn *conn, char *buf, ssize size, MprTicks timeout, int flags)
{
HttpPacket *packet;
HttpQueue *q;
HttpLimits *limits;
MprBuf *content;
MprTicks start, delay;
ssize nbytes, len;
int64 dispatcherMark;
q = conn->readq;
assert(q->count >= 0);
assert(size >= 0);
limits = conn->limits;
if (flags == 0) {
flags = conn->async ? HTTP_NON_BLOCK : HTTP_BLOCK;
}
if (timeout < 0) {
timeout = limits->inactivityTimeout;
} else if (timeout == 0) {
timeout = MPR_MAX_TIMEOUT;
}
if (flags & HTTP_BLOCK) {
start = conn->http->now;
dispatcherMark = mprGetEventMark(conn->dispatcher);
while (q->count <= 0 && !conn->error && (conn->state <= HTTP_STATE_CONTENT)) {
if (httpRequestExpired(conn, -1)) {
break;
}
delay = min(limits->inactivityTimeout, mprGetRemainingTicks(start, timeout));
httpEnableConnEvents(conn);
mprWaitForEvent(conn->dispatcher, delay, dispatcherMark);
if (mprGetRemainingTicks(start, timeout) <= 0) {
break;
}
dispatcherMark = mprGetEventMark(conn->dispatcher);
}
}
for (nbytes = 0; size > 0 && q->count > 0; ) {
if ((packet = q->first) == 0) {
break;
}
content = packet->content;
len = mprGetBufLength(content);
len = min(len, size);
assert(len <= q->count);
if (len > 0) {
len = mprGetBlockFromBuf(content, buf, len);
assert(len <= q->count);
}
buf += len;
size -= len;
q->count -= len;
assert(q->count >= 0);
nbytes += len;
if (mprGetBufLength(content) == 0) {
httpGetPacket(q);
}
if (flags & HTTP_NON_BLOCK) {
break;
}
}
assert(q->count >= 0);
if (nbytes < size) {
buf[nbytes] = '\0';
}
return nbytes;
}
/*
Wait for the connection to reach a given state.
Should only be used on the client side.
@param state Desired state. Set to zero if you want to wait for one I/O event.
@param timeout Timeout in msec. If timeout is zero, wait forever. If timeout is < 0, use default inactivity
and duration timeouts.
*/
PUBLIC int httpWait(HttpStream *stream, int state, MprTicks timeout)
{
HttpLimits *limits;
MprTicks delay, start;
int64 dispatcherMark;
int justOne;
limits = stream->limits;
if (httpServerStream(stream)) {
return MPR_ERR_BAD_STATE;
}
if (stream->state <= HTTP_STATE_BEGIN) {
return MPR_ERR_BAD_STATE;
}
if (state == 0) {
/* Wait for just one I/O event */
state = HTTP_STATE_FINALIZED;
justOne = 1;
} else {
justOne = 0;
}
if (stream->error) {
if (stream->state >= state) {
return 0;
}
return MPR_ERR_BAD_STATE;
}
if (timeout < 0) {
timeout = limits->requestTimeout;
} else if (timeout == 0) {
timeout = MPR_MAX_TIMEOUT;
}
if (state > HTTP_STATE_CONTENT) {
httpFinalizeOutput(stream);
}
start = stream->http->now;
dispatcherMark = mprGetEventMark(stream->dispatcher);
// TODO - how does this work with http2?
while (stream->state < state && !stream->error && !mprIsSocketEof(stream->sock)) {
if (httpRequestExpired(stream, -1)) {
return MPR_ERR_TIMEOUT;
}
// TODO - review
httpEnableNetEvents(stream->net);
delay = min(limits->inactivityTimeout, mprGetRemainingTicks(start, timeout));
delay = max(delay, 0);
mprWaitForEvent(stream->dispatcher, delay, dispatcherMark);
if (justOne || (mprGetRemainingTicks(start, timeout) <= 0)) {
break;
}
dispatcherMark = mprGetEventMark(stream->dispatcher);
}
if (stream->error) {
return MPR_ERR_NOT_READY;
}
if (stream->state < state) {
if (mprGetRemainingTicks(start, timeout) <= 0) {
return MPR_ERR_TIMEOUT;
}
if (!justOne) {
return MPR_ERR_CANT_READ;
}
}
stream->lastActivity = stream->http->now;
return 0;
}
