/*
* Accept a new client connection. If multithreaded, this will come in on a worker thread dedicated to this connection.
* This is called from the listen wait handler.
*/
int maAcceptConn(MprSocket *sock, MaServer *server, cchar *ip, int port)
{
MaHostAddress *address;
MaHost *host;
MaConn *conn;
MprSocket *listenSock;
MprHeap *arena;
int rc;
mprAssert(server);
mprAssert(sock);
mprAssert(ip);
mprAssert(port > 0);
rc = 0;
listenSock = sock->listenSock;
mprLog(server, 4, "New connection from %s:%d for %s:%d %s",
ip, port, listenSock->ipAddr, listenSock->port, listenSock->sslSocket ? "(secure)" : "");
/*
* Map the address onto a suitable host to initially serve the request initially until we can parse the Host header.
*/
address = (MaHostAddress*) maLookupHostAddress(server, listenSock->ipAddr, listenSock->port);
if (address == 0 || (host = mprGetFirstItem(address->vhosts)) == 0) {
mprError(server, "No host configured for request %s:%d", listenSock->ipAddr, listenSock->port);
mprFree(sock);
return 1;
}
arena = mprAllocHeap(host, "conn", 1, 0, NULL);
if (arena == 0) {
mprError(server, "Can't create connect arena object. Insufficient memory.");
mprFree(sock);
return 1;
}
conn = createConn(arena, host, sock, ip, port, address);
if (conn == 0) {
mprError(server, "Can't create connect object. Insufficient memory.");
mprFree(sock);
mprFree(arena);
return 1;
}
conn->arena = arena;
if (maAddConn(host, conn) < 0) {
mprFree(sock);
#if BLD_FEATURE_MULTITHREAD
mprEnableSocketEvents(listenSock);
#endif
mprFree(arena);
return 1;
}
mprSetSocketCallback(conn->sock, (MprSocketProc) ioEvent, conn, MPR_READABLE, MPR_NORMAL_PRIORITY);
#if BLD_FEATURE_MULTITHREAD
mprEnableSocketEvents(listenSock);
#endif
return rc;
}
/*
* Parse the request headers. Return true if the header parsed.
*/
static bool parseHeaders(MaConn *conn, MaPacket *packet)
{
MaHostAddress *address;
MaRequest *req;
MaHost *host, *hp;
MaLimits *limits;
MprBuf *content;
char keyBuf[MPR_MAX_STRING];
char *key, *value, *cp, *tok;
int count, keepAlive;
req = conn->request;
host = req->host;
content = packet->content;
conn->request->headerPacket = packet;
limits = &conn->http->limits;
keepAlive = 0;
strcpy(keyBuf, "HTTP_");
mprAssert(strstr((char*) content->start, "\r\n"));
for (count = 0; content->start[0] != '\r' && !conn->connectionFailed; count++) {
if (count >= limits->maxNumHeaders) {
maFailConnection(conn, MPR_HTTP_CODE_BAD_REQUEST, "Too many headers");
return 0;
}
if ((key = getToken(conn, ":")) == 0 || *key == '\0') {
maFailConnection(conn, MPR_HTTP_CODE_BAD_REQUEST, "Bad header format");
return 0;
}
value = getToken(conn, "\r\n");
while (isspace((int) *value)) {
value++;
}
if (conn->requestFailed) {
continue;
}
mprStrUpper(key);
for (cp = key; *cp; cp++) {
if (*cp == '-') {
*cp = '_';
}
}
mprLog(req, 8, "Key %s, value %s", key, value);
if (strspn(key, "%<>/\\") > 0) {
maFailConnection(conn, MPR_HTTP_CODE_BAD_REQUEST, "Bad header key value");
continue;
}
/*
* Define the header with a "HTTP_" prefix
*/
mprStrcpy(&keyBuf[5], sizeof(keyBuf) - 5, key);
mprAddDuplicateHash(req->headers, keyBuf, value);
switch (key[0]) {
case 'A':
if (strcmp(key, "AUTHORIZATION") == 0) {
value = mprStrdup(req, value);
req->authType = mprStrTok(value, " \t", &tok);
req->authDetails = tok;
} else if (strcmp(key, "ACCEPT_CHARSET") == 0) {
req->acceptCharset = value;
} else if (strcmp(key, "ACCEPT") == 0) {
req->accept = value;
} else if (strcmp(key, "ACCEPT_ENCODING") == 0) {
req->acceptEncoding = value;
}
break;
case 'C':
if (strcmp(key, "CONTENT_LENGTH") == 0) {
if (req->length >= 0) {
maFailConnection(conn, MPR_HTTP_CODE_BAD_REQUEST, "Mulitple content length headers");
continue;
}
req->length = mprAtoi(value, 10);
if (req->length < 0) {
maFailConnection(conn, MPR_HTTP_CODE_BAD_REQUEST, "Bad content length");
continue;
}
if (req->length >= host->limits->maxBody) {
maFailConnection(conn, MPR_HTTP_CODE_REQUEST_TOO_LARGE,
"Request content length %Ld is too big. Limit %Ld", req->length, host->limits->maxBody);
continue;
}
mprAssert(req->length >= 0);
req->remainingContent = req->length;
req->contentLengthStr = value;
} else if (strcmp(key, "CONTENT_RANGE") == 0) {
/*
* This headers specifies the range of any posted body data
* Format is: Content-Range: bytes n1-n2/length
* Where n1 is first byte pos and n2 is last byte pos
*/
char *sp;
int start, end, size;
start = end = size = -1;
sp = value;
while (*sp && !isdigit((int) *sp)) {
sp++;
}
if (*sp) {
start = (int) mprAtoi(sp, 10);
if ((sp = strchr(sp, '-')) != 0) {
end = (int) mprAtoi(++sp, 10);
}
if ((sp = strchr(sp, '/')) != 0) {
/*
* Note this is not the content length transmitted, but the original size of the input of which
* the client is transmitting only a portion.
*/
size = (int) mprAtoi(++sp, 10);
}
}
if (start < 0 || end < 0 || size < 0 || end <= start) {
maFailRequest(conn, MPR_HTTP_CODE_RANGE_NOT_SATISFIABLE, "Bad content range");
continue;
}
req->inputRange = maCreateRange(conn, start, end);
} else if (strcmp(key, "CONTENT_TYPE") == 0) {
req->mimeType = value;
req->form = strstr(value, "application/x-www-form-urlencoded") != 0;
} else if (strcmp(key, "COOKIE") == 0) {
if (req->cookie && *req->cookie) {
req->cookie = mprStrcat(req, -1, req->cookie, "; ", value, NULL);
} else {
req->cookie = value;
}
} else if (strcmp(key, "CONNECTION") == 0) {
req->connection = value;
if (mprStrcmpAnyCase(value, "KEEP-ALIVE") == 0) {
keepAlive++;
} else if (mprStrcmpAnyCase(value, "CLOSE") == 0) {
conn->keepAliveCount = 0;
}
if (!host->keepAlive) {
conn->keepAliveCount = 0;
}
}
break;
case 'F':
req->forwarded = value;
break;
case 'H':
if (strcmp(key, "HOST") == 0) {
req->hostName = value;
address = conn->address;
if (maIsNamedVirtualHostAddress(address)) {
hp = maLookupVirtualHost(address, value);
if (hp == 0) {
maFailRequest(conn, 404, "No host to serve request. Searching for %s", value);
mprLog(conn, 1, "Can't find virtual host %s", value);
continue;
}
req->host = hp;
/*
* Reassign this request to a new host
*/
maRemoveConn(host, conn);
host = hp;
conn->host = hp;
maAddConn(hp, conn);
}
}
break;
case 'I':
if ((strcmp(key, "IF_MODIFIED_SINCE") == 0) || (strcmp(key, "IF_UNMODIFIED_SINCE") == 0)) {
MprTime newDate = 0;
char *cp;
bool ifModified = (key[3] == 'M');
if ((cp = strchr(value, ';')) != 0) {
*cp = '\0';
}
if (mprParseTime(conn, &newDate, value, MPR_UTC_TIMEZONE, NULL) < 0) {
mprAssert(0);
break;
}
if (newDate) {
setIfModifiedDate(conn, newDate, ifModified);
req->flags |= MA_REQ_IF_MODIFIED;
}
} else if ((strcmp(key, "IF_MATCH") == 0) || (strcmp(key, "IF_NONE_MATCH") == 0)) {
char *word, *tok;
bool ifMatch = key[3] == 'M';
if ((tok = strchr(value, ';')) != 0) {
*tok = '\0';
}
req->ifMatch = ifMatch;
req->flags |= MA_REQ_IF_MODIFIED;
value = mprStrdup(conn, value);
word = mprStrTok(value, " ,", &tok);
while (word) {
addMatchEtag(conn, word);
word = mprStrTok(0, " ,", &tok);
}
} else if (strcmp(key, "IF_RANGE") == 0) {
char *word, *tok;
if ((tok = strchr(value, ';')) != 0) {
*tok = '\0';
}
req->ifMatch = 1;
req->flags |= MA_REQ_IF_MODIFIED;
value = mprStrdup(conn, value);
word = mprStrTok(value, " ,", &tok);
while (word) {
addMatchEtag(conn, word);
word = mprStrTok(0, " ,", &tok);
}
}
break;
case 'P':
if (strcmp(key, "PRAGMA") == 0) {
req->pragma = value;
}
break;
case 'R':
if (strcmp(key, "RANGE") == 0) {
if (!parseRange(conn, value)) {
maFailRequest(conn, MPR_HTTP_CODE_RANGE_NOT_SATISFIABLE, "Bad range");
}
} else if (strcmp(key, "REFERER") == 0) {
/* NOTE: yes the header is misspelt in the spec */
req->referer = value;
}
break;
case 'T':
if (strcmp(key, "TRANSFER_ENCODING") == 0) {
mprStrLower(value);
if (strcmp(value, "chunked") == 0) {
req->flags |= MA_REQ_CHUNKED;
/*
* This will be revised by the chunk filter as chunks are processed and will be set to zero when the
* last chunk has been received.
*/
req->remainingContent = MAXINT;
}
}
break;
#if BLD_DEBUG
case 'X':
if (strcmp(key, "X_APPWEB_CHUNK_SIZE") == 0) {
mprStrUpper(value);
conn->response->chunkSize = atoi(value);
if (conn->response->chunkSize <= 0) {
conn->response->chunkSize = 0;
} else if (conn->response->chunkSize > conn->http->limits.maxChunkSize) {
conn->response->chunkSize = conn->http->limits.maxChunkSize;
}
}
break;
#endif
case 'U':
if (strcmp(key, "USER_AGENT") == 0) {
req->userAgent = value;
}
break;
}
}
if (conn->protocol == 0 && !keepAlive) {
conn->keepAliveCount = 0;
}
if (!(req->flags & MA_REQ_CHUNKED)) {
/*
* Step over "\r\n" after headers. As an optimization, don't do this if chunked so chunking can parse a single
* chunk delimiter of "\r\nSIZE ...\r\n"
*/
mprAdjustBufStart(content, 2);
}
mprLog(conn, 3, "Select host \"%s\"", conn->host->name);
if (maSetRequestUri(conn, req->url, "") < 0) {
maFailConnection(conn, MPR_HTTP_CODE_BAD_REQUEST, "Bad URI format");
return 0;
}
if (conn->host->secure) {
req->parsedUri->scheme = mprStrdup(req, "https");
}
req->parsedUri->port = conn->sock->port;
req->parsedUri->host = req->hostName ? req->hostName : conn->host->name;
return 1;
}
