int httpConnect(HttpConn *conn, cchar *method, cchar *url, struct MprSsl *ssl)
{
mprAssert(conn);
mprAssert(method && *method);
mprAssert(url && *url);
if (conn->endpoint) {
httpError(conn, HTTP_CODE_BAD_GATEWAY, "Can't call connect in a server");
return MPR_ERR_BAD_STATE;
}
mprLog(4, "Http: client request: %s %s", method, url);
if (conn->tx == 0 || conn->state != HTTP_STATE_BEGIN) {
/* WARNING: this will erase headers */
httpPrepClientConn(conn, 0);
}
mprAssert(conn->state == HTTP_STATE_BEGIN);
httpSetState(conn, HTTP_STATE_CONNECTED);
conn->setCredentials = 0;
conn->tx->method = supper(method);
#if BIT_DEBUG
conn->startTime = conn->http->now;
conn->startTicks = mprGetTicks();
#endif
if (openConnection(conn, url, ssl) == 0) {
return MPR_ERR_CANT_OPEN;
}
httpCreateTxPipeline(conn, conn->http->clientRoute);
if (setClientHeaders(conn) < 0) {
return MPR_ERR_CANT_INITIALIZE;
}
return 0;
}
PUBLIC int httpConnect(HttpConn *conn, cchar *method, cchar *uri, struct MprSsl *ssl)
{
assert(conn);
assert(method && *method);
assert(uri && *uri);
if (httpServerConn(conn)) {
httpError(conn, HTTP_CODE_BAD_GATEWAY, "Cannot call connect in a server");
return MPR_ERR_BAD_STATE;
}
if (conn->tx == 0 || conn->state != HTTP_STATE_BEGIN) {
/* WARNING: this will erase headers */
httpPrepClientConn(conn, 0);
}
assert(conn->state == HTTP_STATE_BEGIN);
conn->tx->parsedUri = httpCreateUri(uri, HTTP_COMPLETE_URI_PATH);
if (openConnection(conn, ssl) == 0) {
return MPR_ERR_CANT_OPEN;
}
conn->authRequested = 0;
conn->tx->method = supper(method);
conn->startMark = mprGetHiResTicks();
/*
The receive pipeline is created when parsing the response in parseIncoming()
*/
httpCreateTxPipeline(conn, conn->http->clientRoute);
httpSetState(conn, HTTP_STATE_CONNECTED);
setDefaultHeaders(conn);
return 0;
}
static void commonPrep(HttpConn *conn)
{
if (conn->timeoutEvent) {
mprRemoveEvent(conn->timeoutEvent);
conn->timeoutEvent = 0;
}
conn->lastActivity = conn->http->now;
conn->error = 0;
conn->errorMsg = 0;
conn->state = 0;
conn->authRequested = 0;
httpSetState(conn, HTTP_STATE_BEGIN);
httpInitSchedulerQueue(conn->serviceq);
}
/*
Called by connectors (ONLY) when writing the transmission is complete
*/
PUBLIC void httpFinalizeConnector(HttpConn *conn)
{
HttpTx *tx;
tx = conn->tx;
tx->finalizedConnector = 1;
tx->finalizedOutput = 1;
/*
Use case: server calling finalize in a timer. Must notify for close event in ejs.web/test/request/events.tst
*/
/* Cannot do this if there is still data to read */
if (tx->finalized && conn->rx->eof) {
httpSetState(conn, HTTP_STATE_FINALIZED);
}
}
/*
Create a new connection object
*/
PUBLIC HttpConn *httpCreateConn(HttpEndpoint *endpoint, MprDispatcher *dispatcher)
{
HttpConn *conn;
HttpHost *host;
HttpRoute *route;
if ((conn = mprAllocObj(HttpConn, manageConn)) == 0) {
return 0;
}
conn->protocol = HTTP->protocol;
conn->http = HTTP;
conn->port = -1;
conn->retries = HTTP_RETRIES;
conn->endpoint = endpoint;
conn->lastActivity = HTTP->now;
conn->ioCallback = httpIOEvent;
if (endpoint) {
conn->notifier = endpoint->notifier;
host = mprGetFirstItem(endpoint->hosts);
if (host && (route = host->defaultRoute) != 0) {
conn->limits = route->limits;
conn->trace = route->trace;
} else {
conn->limits = HTTP->serverLimits;
conn->trace = HTTP->trace;
}
} else {
conn->limits = HTTP->clientLimits;
conn->trace = HTTP->trace;
}
conn->keepAliveCount = conn->limits->keepAliveMax;
conn->serviceq = httpCreateQueueHead(conn, "serviceq");
if (dispatcher) {
conn->dispatcher = dispatcher;
} else if (endpoint) {
conn->dispatcher = endpoint->dispatcher;
} else {
conn->dispatcher = mprGetDispatcher();
}
conn->rx = httpCreateRx(conn);
conn->tx = httpCreateTx(conn, NULL);
httpSetState(conn, HTTP_STATE_BEGIN);
httpAddConn(conn);
return conn;
}
/*
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;
}
/*
Accept a new client connection on a new socket. If multithreaded, this will come in on a worker thread
dedicated to this connection. This is called from the listen wait handler.
*/
HttpConn *httpAcceptConn(HttpEndpoint *endpoint, MprEvent *event)
{
HttpConn *conn;
MprSocket *sock;
MprDispatcher *dispatcher;
MprEvent e;
int level;
mprAssert(endpoint);
mprAssert(event);
/*
This will block in sync mode until a connection arrives
*/
if ((sock = mprAcceptSocket(endpoint->sock)) == 0) {
if (endpoint->sock->handler) {
mprEnableSocketEvents(endpoint->sock, MPR_READABLE);
}
return 0;
}
if (endpoint->ssl) {
if (mprUpgradeSocket(sock, endpoint->ssl, 1) < 0) {
mprCloseSocket(sock, 0);
return 0;
}
}
if (endpoint->sock->handler) {
/* Re-enable events on the listen socket */
mprEnableSocketEvents(endpoint->sock, MPR_READABLE);
}
dispatcher = event->dispatcher;
if (mprShouldDenyNewRequests()) {
mprCloseSocket(sock, 0);
return 0;
}
if ((conn = httpCreateConn(endpoint->http, endpoint, dispatcher)) == 0) {
mprCloseSocket(sock, 0);
return 0;
}
conn->notifier = endpoint->notifier;
conn->async = endpoint->async;
conn->endpoint = endpoint;
conn->sock = sock;
conn->port = sock->port;
conn->ip = sclone(sock->ip);
conn->secure = (endpoint->ssl != 0);
if (!httpValidateLimits(endpoint, HTTP_VALIDATE_OPEN_CONN, conn)) {
conn->endpoint = 0;
httpDestroyConn(conn);
return 0;
}
mprAssert(conn->state == HTTP_STATE_BEGIN);
httpSetState(conn, HTTP_STATE_CONNECTED);
if ((level = httpShouldTrace(conn, HTTP_TRACE_RX, HTTP_TRACE_CONN, NULL)) >= 0) {
mprLog(level, "### Incoming connection from %s:%d to %s:%d %s",
conn->ip, conn->port, sock->acceptIp, sock->acceptPort, conn->secure ? "(secure)" : "");
}
e.mask = MPR_READABLE;
e.timestamp = conn->http->now;
(conn->ioCallback)(conn, &e);
return conn;
}
PUBLIC int httpConnect(HttpStream *stream, cchar *method, cchar *url, MprSsl *ssl)
{
HttpNet *net;
HttpTx *tx;
HttpUri *uri;
cchar *ip, *protocol;
int port;
assert(stream);
assert(method && *method);
assert(url && *url);
net = stream->net;
if (httpServerStream(stream)) {
mprLog("client error", 0, "Cannot call httpConnect() in a server");
return MPR_ERR_BAD_STATE;
}
if (net->protocol <= 0) {
mprLog("client error", 0, "HTTP protocol to use has not been defined");
return MPR_ERR_BAD_STATE;
}
if (stream->tx == 0 || stream->state != HTTP_STATE_BEGIN) {
httpResetClientStream(stream, 0);
}
tx = stream->tx;
tx->method = supper(method);
stream->authRequested = 0;
stream->startMark = mprGetHiResTicks();
if ((uri = tx->parsedUri = httpCreateUri(url, HTTP_COMPLETE_URI_PATH)) == 0) {
return MPR_ERR_BAD_ARGS;
}
ssl = uri->secure ? (ssl ? ssl : mprCreateSsl(0)) : 0;
httpGetUriAddress(uri, &ip, &port);
if (net->sock) {
if (net->error) {
mprCloseSocket(net->sock, 0);
net->sock = 0;
} else if (canUse(net, stream, uri, ssl, ip, port)) {
httpLog(net->trace, "client.connection.reuse", "context", "reuse:%d", stream->keepAliveCount);
} else {
if (net->protocol >= 2) {
if (mprGetListLength(net->streams) > 1) {
httpError(stream, HTTP_CODE_COMMS_ERROR, "Cannot use network for %s due to other existing requests", ip);
return MPR_ERR_CANT_FIND;
}
} else {
mprCloseSocket(net->sock, 0);
net->sock = 0;
}
}
}
if (!net->sock) {
if (httpConnectNet(net, ip, port, ssl) < 0) {
return MPR_ERR_CANT_CONNECT;
}
stream->net = net;
stream->sock = net->sock;
stream->ip = net->ip;
stream->port = net->port;
stream->keepAliveCount = (net->protocol >= 2) ? 0 : stream->limits->keepAliveMax;
#if ME_HTTP_WEB_SOCKETS
if (net->protocol == 1 && uri->webSockets && httpUpgradeWebSocket(stream) < 0) {
stream->errorMsg = net->errorMsg = net->sock->errorMsg;
return 0;
}
#endif
}
httpCreatePipeline(stream);
setDefaultHeaders(stream);
httpSetState(stream, HTTP_STATE_CONNECTED);
protocol = net->protocol < 2 ? "HTTP/1.1" : "HTTP/2";
httpLog(net->trace, "client.request", "request", "method='%s', url='%s', protocol='%s'", tx->method, url, protocol);
return 0;
}
/*
Accept a new client connection on a new socket.
This will come in on a worker thread with a new dispatcher dedicated to this connection.
*/
PUBLIC HttpConn *httpAcceptConn(HttpEndpoint *endpoint, MprEvent *event)
{
Http *http;
HttpConn *conn;
HttpAddress *address;
MprSocket *sock;
int64 value;
assert(event);
assert(event->dispatcher);
assert(endpoint);
sock = event->sock;
http = endpoint->http;
if (mprShouldDenyNewRequests()) {
mprCloseSocket(sock, 0);
return 0;
}
if ((conn = httpCreateConn(endpoint, event->dispatcher)) == 0) {
mprCloseSocket(sock, 0);
return 0;
}
conn->notifier = endpoint->notifier;
conn->async = endpoint->async;
conn->endpoint = endpoint;
conn->sock = sock;
conn->port = sock->port;
conn->ip = sclone(sock->ip);
if ((value = httpMonitorEvent(conn, HTTP_COUNTER_ACTIVE_CONNECTIONS, 1)) > conn->limits->connectionsMax) {
httpTrace(conn, "connection.accept.error", "error", "msg:'Too many concurrent connections',active:%d,max:%d",
(int) value, conn->limits->connectionsMax);
httpDestroyConn(conn);
return 0;
}
if (mprGetHashLength(http->addresses) > conn->limits->clientMax) {
httpTrace(conn, "connection.accept.error", "error", "msg:'Too many concurrent clients',active:%d,max:%d",
mprGetHashLength(http->addresses), conn->limits->clientMax);
httpDestroyConn(conn);
return 0;
}
address = conn->address;
if (address && address->banUntil) {
if (address->banUntil < http->now) {
httpTrace(conn, "monitor.ban.stop", "context", "client:'%s'", conn->ip);
address->banUntil = 0;
} else {
if (address->banStatus) {
httpError(conn, HTTP_CLOSE | address->banStatus,
"Connection refused, client banned: %s", address->banMsg ? address->banMsg : "");
} else {
httpDestroyConn(conn);
return 0;
}
}
}
if (endpoint->ssl) {
if (mprUpgradeSocket(sock, endpoint->ssl, 0) < 0) {
httpDisconnect(conn);
httpTrace(conn, "connection.upgrade.error", "error", "msg:'Cannot upgrade socket. %s'", sock->errorMsg);
httpMonitorEvent(conn, HTTP_COUNTER_SSL_ERRORS, 1);
httpDestroyConn(conn);
return 0;
}
}
assert(conn->state == HTTP_STATE_BEGIN);
httpSetState(conn, HTTP_STATE_CONNECTED);
httpTrace(conn, "connection.accept.new", "context", "peer:'%s',endpoint:'%s:%d'",
conn->ip, sock->acceptIp, sock->acceptPort);
event->mask = MPR_READABLE;
event->timestamp = conn->http->now;
(conn->ioCallback)(conn, event);
return conn;
}
