/*
This formats a response and sets the altBody. The response is not HTML escaped.
This is the lowest level for formatResponse.
*/
PUBLIC ssize httpFormatResponsev(HttpConn *conn, cchar *fmt, va_list args)
{
HttpTx *tx;
char *body;
tx = conn->tx;
tx->responded = 1;
body = fmt ? sfmtv(fmt, args) : conn->errorMsg;
tx->altBody = body;
tx->length = slen(tx->altBody);
tx->flags |= HTTP_TX_NO_BODY;
httpDiscardData(conn, HTTP_QUEUE_TX);
return (ssize) tx->length;
}
/*
Steal the socket object from a connection. This disconnects the socket from management by the Http service.
It is the callers responsibility to call mprCloseSocket when required.
Harder than it looks. We clone the socket, steal the socket handle and set the connection socket handle to invalid.
This preserves the HttpConn.sock object for the connection and returns a new MprSocket for the caller.
*/
PUBLIC MprSocket *httpStealSocket(HttpConn *conn)
{
MprSocket *sock;
assert(conn->sock);
assert(!conn->destroyed);
if (!conn->destroyed && !conn->borrowed) {
lock(conn->http);
sock = mprCloneSocket(conn->sock);
(void) mprStealSocketHandle(conn->sock);
mprRemoveSocketHandler(conn->sock);
httpRemoveConn(conn);
httpDiscardData(conn, HTTP_QUEUE_TX);
httpDiscardData(conn, HTTP_QUEUE_RX);
httpSetState(conn, HTTP_STATE_COMPLETE);
/* This will cause httpIOEvent to regard this as a client connection and not destroy this connection */
conn->endpoint = 0;
conn->async = 0;
unlock(conn->http);
return sock;
}
return 0;
}
PUBLIC void httpOmitBody(HttpConn *conn)
{
HttpTx *tx;
tx = conn->tx;
if (!tx) {
return;
}
tx->flags |= HTTP_TX_NO_BODY;
tx->length = -1;
if (tx->flags & HTTP_TX_HEADERS_CREATED) {
/* Connectors will detect this also and disconnect */
} else {
httpDiscardData(conn, HTTP_QUEUE_TX);
}
}
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);
}
/*
Set headers for httpWriteHeaders. This defines standard headers.
*/
static void setHeaders(HttpConn *conn, HttpPacket *packet)
{
HttpRx *rx;
HttpTx *tx;
HttpRoute *route;
HttpRange *range;
MprKeyValue *item;
MprOff length;
cchar *mimeType;
int next;
assert(packet->flags == HTTP_PACKET_HEADER);
rx = conn->rx;
tx = conn->tx;
route = rx->route;
/*
Mandatory headers that must be defined here use httpSetHeader which overwrites existing values.
*/
httpAddHeaderString(conn, "Date", conn->http->currentDate);
if (tx->ext && route) {
if ((mimeType = (char*) mprLookupMime(route->mimeTypes, tx->ext)) != 0) {
if (conn->error) {
httpAddHeaderString(conn, "Content-Type", "text/html");
} else {
httpAddHeaderString(conn, "Content-Type", mimeType);
}
}
}
if (tx->etag) {
httpAddHeader(conn, "ETag", "%s", tx->etag);
}
length = tx->length > 0 ? tx->length : 0;
if (rx->flags & HTTP_HEAD) {
conn->tx->flags |= HTTP_TX_NO_BODY;
httpDiscardData(conn, HTTP_QUEUE_TX);
if (tx->chunkSize <= 0) {
httpAddHeader(conn, "Content-Length", "%Ld", length);
}
} else if (tx->length < 0 && tx->chunkSize > 0) {
httpSetHeaderString(conn, "Transfer-Encoding", "chunked");
} else if (conn->endpoint) {
/* Server must not emit a content length header for 1XX, 204 and 304 status */
if (!((100 <= tx->status && tx->status <= 199) || tx->status == 204 ||
tx->status == 304 || tx->flags & HTTP_TX_NO_LENGTH)) {
httpAddHeader(conn, "Content-Length", "%Ld", length);
}
} else if (tx->length > 0) {
/* client with body */
httpAddHeader(conn, "Content-Length", "%Ld", length);
}
if (tx->outputRanges) {
if (tx->outputRanges->next == 0) {
range = tx->outputRanges;
if (tx->entityLength > 0) {
httpSetHeader(conn, "Content-Range", "bytes %Ld-%Ld/%Ld", range->start, range->end - 1, tx->entityLength);
} else {
httpSetHeader(conn, "Content-Range", "bytes %Ld-%Ld/*", range->start, range->end - 1);
}
} else {
httpSetHeader(conn, "Content-Type", "multipart/byteranges; boundary=%s", tx->rangeBoundary);
}
httpSetHeader(conn, "Accept-Ranges", "bytes");
}
if (conn->endpoint) {
if (!(route->flags & HTTP_ROUTE_STEALTH)) {
httpAddHeaderString(conn, "Server", conn->http->software);
}
/*
If keepAliveCount == 1
*/
if (--conn->keepAliveCount > 0) {
assert(conn->keepAliveCount >= 1);
httpAddHeaderString(conn, "Connection", "Keep-Alive");
httpAddHeader(conn, "Keep-Alive", "timeout=%Ld, max=%d", conn->limits->inactivityTimeout / 1000, conn->keepAliveCount);
} else {
/* Tell the peer to close the connection */
httpAddHeaderString(conn, "Connection", "close");
}
if (route->flags & HTTP_ROUTE_CORS) {
setCorsHeaders(conn);
}
/*
Apply response headers
*/
for (ITERATE_ITEMS(route->headers, item, next)) {
if (item->flags == HTTP_ROUTE_ADD_HEADER) {
httpAddHeaderString(conn, item->key, item->value);
} else if (item->flags == HTTP_ROUTE_APPEND_HEADER) {
httpAppendHeaderString(conn, item->key, item->value);
} else if (item->flags == HTTP_ROUTE_REMOVE_HEADER) {
httpRemoveHeader(conn, item->key);
} else if (item->flags == HTTP_ROUTE_SET_HEADER) {
httpSetHeaderString(conn, item->key, item->value);
}
}
}
}
