/*
SIGUSR2 will toggle trace from level 2 to 6
*/
static void traceHandler(void *ignored, MprSignal *sp)
{
int level;
level = mprGetLogLevel() > 2 ? 2 : 6;
mprLog(0, "Change log level to %d", level);
mprSetLogLevel(level);
}
/*
SIGUSR2 will toggle trace from level 2 to 4
*/
static void traceHandler(void *ignored, MprSignal *sp)
{
int level;
level = mprGetLogLevel() > 2 ? 2 : 4;
mprLog("info appweb", 0, "Change log and trace level to %d", level);
mprSetLogLevel(level);
httpSetTraceLevel(level);
}
int maSetupTrace(MaHost *host, cchar *ext)
{
if (host->traceLevel > mprGetLogLevel(host)) {
return 0;
}
if (ext) {
if (host->traceInclude && !mprLookupHash(host->traceInclude, ext)) {
return 0;
}
if (host->traceExclude && mprLookupHash(host->traceExclude, ext)) {
return 0;
}
}
return host->traceMask;
}
/*
Trace output first part of output received from the cgi process
*/
static void traceCGIData(MprCmd *cmd, char *src, ssize size)
{
char dest[512];
int index, i;
if (mprGetLogLevel() >= 5) {
mprDebug("http cgi", 5, "CGI: process wrote (leading %zd bytes) => \n", min(sizeof(dest), size));
for (index = 0; index < size; ) {
for (i = 0; i < (sizeof(dest) - 1) && index < size; i++) {
dest[i] = src[index];
index++;
}
dest[i] = '\0';
mprDebug("http cgi", 5, "%s", dest);
}
}
}
void mprLog(MprCtx ctx, int level, const char *fmt, ...)
{
va_list args;
char *buf;
if (level > mprGetLogLevel(ctx)) {
return;
}
va_start(args, fmt);
mprAllocVsprintf(MPR_LOC_ARGS(ctx), &buf, 0, fmt, args);
va_end(args);
logOutput(MPR_LOC_ARGS(ctx), MPR_LOG_SRC, level, buf);
va_end(args);
mprFree(buf);
}
/*
Handle IO on the connection. Initially the conn->dispatcher will be set to the server->dispatcher and the first
I/O event will be handled on the server thread (or main thread). A request handler may create a new
conn->dispatcher and transfer execution to a worker thread if required.
*/
PUBLIC void httpIO(HttpConn *conn, int eventMask)
{
MprSocket *sp;
sp = conn->sock;
if (conn->destroyed) {
/* Connection has been destroyed */
return;
}
if (conn->state < HTTP_STATE_PARSED && mprShouldDenyNewRequests()) {
httpDestroyConn(conn);
return;
}
assert(conn->tx);
assert(conn->rx);
#if DEPRECATED || 1
/* Just IO state asserting */
if (conn->io) {
assert(!conn->io);
return;
}
conn->io = 1;
#endif
if ((eventMask & MPR_WRITABLE) && conn->connectorq) {
httpResumeQueue(conn->connectorq);
}
if (eventMask & MPR_READABLE) {
readPeerData(conn);
}
if (sp->secured && !conn->secure) {
conn->secure = 1;
if (sp->peerCert) {
httpTrace(conn, "connection.ssl", "context", "msg:'Connection secured with peer certificate'," \
"secure:true,cipher:'%s',peerName:'%s',subject:'%s',issuer:'%s',session:'%s'",
sp->cipher, sp->peerName, sp->peerCert, sp->peerCertIssuer, sp->session);
} else {
httpTrace(conn, "connection.ssl", "context",
"msg:'Connection secured without peer certificate',secure:true,cipher:'%s',session:'%s'",
sp->cipher, sp->session);
}
if (mprGetLogLevel() >= 5) {
mprLog("info http ssl", 5, "SSL State: %s", mprGetSocketState(sp));
}
}
/*
Process one or more complete requests in the packet
*/
do {
/* This is and must be the only place httpProtocol is ever called */
httpProtocol(conn);
} while (conn->endpoint && conn->state == HTTP_STATE_COMPLETE && prepForNext(conn));
/*
When a request completes, prepForNext will reset the state to HTTP_STATE_BEGIN
*/
if (conn->state < HTTP_STATE_PARSED && conn->endpoint && (mprIsSocketEof(conn->sock) || (conn->keepAliveCount <= 0))) {
httpDestroyConn(conn);
} else if (!mprIsSocketEof(conn->sock) && conn->async && !conn->delay) {
httpEnableConnEvents(conn);
}
conn->io = 0;
}
/*
function get level(): Number
*/
static EjsNumber *lf_level(Ejs *ejs, EjsObj *unused, int argc, EjsObj **argv)
{
return ejsCreateNumber(ejs, mprGetLogLevel(ejs));
}
PUBLIC void httpWriteHeaders(HttpQueue *q, HttpPacket *packet)
{
Http *http;
HttpConn *conn;
HttpTx *tx;
HttpUri *parsedUri;
MprKey *kp;
MprBuf *buf;
int level;
assert(packet->flags == HTTP_PACKET_HEADER);
conn = q->conn;
http = conn->http;
tx = conn->tx;
buf = packet->content;
if (tx->flags & HTTP_TX_HEADERS_CREATED) {
return;
}
tx->flags |= HTTP_TX_HEADERS_CREATED;
tx->responded = 1;
if (conn->headersCallback) {
/* Must be before headers below */
(conn->headersCallback)(conn->headersCallbackArg);
}
if (tx->flags & HTTP_TX_USE_OWN_HEADERS && !conn->error) {
conn->keepAliveCount = 0;
return;
}
setHeaders(conn, packet);
if (conn->endpoint) {
mprPutStringToBuf(buf, conn->protocol);
mprPutCharToBuf(buf, ' ');
mprPutIntToBuf(buf, tx->status);
mprPutCharToBuf(buf, ' ');
mprPutStringToBuf(buf, httpLookupStatus(http, tx->status));
} else {
mprPutStringToBuf(buf, tx->method);
mprPutCharToBuf(buf, ' ');
parsedUri = tx->parsedUri;
if (http->proxyHost && *http->proxyHost) {
if (parsedUri->query && *parsedUri->query) {
mprPutToBuf(buf, "http://%s:%d%s?%s %s", http->proxyHost, http->proxyPort,
parsedUri->path, parsedUri->query, conn->protocol);
} else {
mprPutToBuf(buf, "http://%s:%d%s %s", http->proxyHost, http->proxyPort, parsedUri->path,
conn->protocol);
}
} else {
if (parsedUri->query && *parsedUri->query) {
mprPutToBuf(buf, "%s?%s %s", parsedUri->path, parsedUri->query, conn->protocol);
} else {
mprPutStringToBuf(buf, parsedUri->path);
mprPutCharToBuf(buf, ' ');
mprPutStringToBuf(buf, conn->protocol);
}
}
}
if ((level = httpShouldTrace(conn, HTTP_TRACE_TX, HTTP_TRACE_FIRST, tx->ext)) >= mprGetLogLevel(tx)) {
mprAddNullToBuf(buf);
mprLog(level, " %s", mprGetBufStart(buf));
}
mprPutStringToBuf(buf, "\r\n");
/*
Output headers
*/
kp = mprGetFirstKey(conn->tx->headers);
while (kp) {
mprPutStringToBuf(packet->content, kp->key);
mprPutStringToBuf(packet->content, ": ");
if (kp->data) {
mprPutStringToBuf(packet->content, kp->data);
}
mprPutStringToBuf(packet->content, "\r\n");
kp = mprGetNextKey(conn->tx->headers, kp);
}
/*
By omitting the "\r\n" delimiter after the headers, chunks can emit "\r\nSize\r\n" as a single chunk delimiter
*/
if (tx->length >= 0 || tx->chunkSize <= 0) {
mprPutStringToBuf(buf, "\r\n");
}
if (tx->altBody) {
/* Error responses are emitted here */
mprPutStringToBuf(buf, tx->altBody);
httpDiscardQueueData(tx->queue[HTTP_QUEUE_TX]->nextQ, 0);
}
tx->headerSize = mprGetBufLength(buf);
tx->flags |= HTTP_TX_HEADERS_CREATED;
q->count += httpGetPacketLength(packet);
}