void setup(const QUrl &_uri, const HttpHeaders &_headers, const QHostAddress &connectAddr = QHostAddress(), int connectPort = -1, int _maxRedirects = -1, const QString &connectHostToTrust = QString())
{
assert(!method.isEmpty());
QUrl uri = _uri;
if(connectPort != -1)
uri.setPort(connectPort);
else if(uri.port() == -1)
{
if(uri.scheme() == "https")
uri.setPort(443);
else
uri.setPort(80);
}
HttpHeaders headers = _headers;
checkHosts += uri.host(QUrl::FullyEncoded);
if(!connectAddr.isNull())
{
curl_slist_free_all(dnsCache);
if(!connectHostToTrust.isEmpty())
checkHosts += connectHostToTrust;
QByteArray cacheEntry = uri.host(QUrl::FullyEncoded).toUtf8() + ':' + QByteArray::number(uri.port()) + ':' + connectAddr.toString().toUtf8();
dnsCache = curl_slist_append(dnsCache, cacheEntry.data());
curl_easy_setopt(easy, CURLOPT_RESOLVE, dnsCache);
}
curl_easy_setopt(easy, CURLOPT_URL, uri.toEncoded().data());
bool chunked = false;
if(headers.contains("Content-Length"))
{
curl_off_t content_len = (curl_off_t)headers.get("Content-Length").toLongLong();
/*if(method == "POST")
curl_easy_setopt(easy, CURLOPT_POSTFIELDSIZE_LARGE, content_len);
else*/
curl_easy_setopt(easy, CURLOPT_INFILESIZE_LARGE, content_len);
// curl will set this for us
headers.removeAll("Content-Length");
}
else
{
if(expectBody)
chunked = true;
else if(alwaysSetBody)
curl_easy_setopt(easy, CURLOPT_INFILESIZE_LARGE, (curl_off_t)0);
}
curl_slist_free_all(headersList);
foreach(const HttpHeader &h, headers)
{
QByteArray i = h.first + ": " + h.second;
headersList = curl_slist_append(headersList, i.data());
}
void applyHeaders(const HttpHeaders &in, HttpHeaders *out)
{
*out += HttpHeader("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0");
QByteArray origin;
if(in.contains("Origin"))
origin = in.get("Origin");
else
origin = "*";
*out += HttpHeader("Access-Control-Allow-Origin", origin);
*out += HttpHeader("Access-Control-Allow-Credentials", "true");
}
void start(const QVariant &vrequest, Mode mode)
{
outSeq = 0;
ZurlRequestPacket request;
if(!request.fromVariant(vrequest))
{
log_warning("failed to parse zurl request");
QVariantHash vhash = vrequest.toHash();
rid = vhash.value("id").toByteArray();
assert(!rid.isEmpty()); // app layer ensures this
receiver = vhash.value("sender").toByteArray();
bool cancel = vhash.value("cancel").toBool();
if(!receiver.isEmpty() && !cancel)
{
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
}
else
{
cleanup();
QMetaObject::invokeMethod(q, "finished", Qt::QueuedConnection);
}
return;
}
rid = request.id;
receiver = request.sender;
outCredits = 0;
userData = request.userData;
quiet = false;
sentHeader = false;
stuffToRead = false;
bytesReceived = 0;
ignorePolicies = request.ignorePolicies;
// streaming only allowed on streaming interface
if(mode == Worker::Stream)
outStream = request.stream;
else
outStream = false;
// some required fields
if(request.method.isEmpty() || request.uri.isEmpty())
{
log_warning("missing request method or missing uri");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
log_info("IN id=%s, %s %s", request.id.data(), qPrintable(request.method), request.uri.toEncoded().data());
// inbound streaming must start with sequence number of 0
if(mode == Worker::Stream && request.more && request.seq != 0)
{
log_warning("streamed input must start with seq 0");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
// fire and forget
if(mode == Worker::Stream && receiver.isEmpty())
quiet = true;
// can't use these two together
if(mode == Worker::Single && request.more)
{
log_warning("cannot use streamed input on router interface");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
bodySent = false;
inSeq = request.seq;
if(!isAllowed(request.uri.host()) || (!request.connectHost.isEmpty() && !isAllowed(request.connectHost)))
{
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "policy-violation"));
return;
}
hreq = new HttpRequest(dns, this);
connect(hreq, SIGNAL(nextAddress(const QHostAddress &)), SLOT(req_nextAddress(const QHostAddress &)));
connect(hreq, SIGNAL(readyRead()), SLOT(req_readyRead()));
connect(hreq, SIGNAL(bytesWritten(int)), SLOT(req_bytesWritten(int)));
connect(hreq, SIGNAL(error()), SLOT(req_error()));
maxResponseSize = request.maxSize;
if(!request.connectHost.isEmpty())
hreq->setConnectHost(request.connectHost);
hreq->setIgnoreTlsErrors(request.ignoreTlsErrors);
if(request.credits != -1)
outCredits += request.credits;
HttpHeaders headers = request.headers;
// ensure content-length (or overwrite it, if not streaming input)
if((request.method == "POST" || request.method == "PUT") && (!headers.contains("content-length") || !request.more))
headers += HttpHeader("Content-Length", QByteArray::number(request.body.size()));
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), SLOT(timer_timeout()));
timer->setSingleShot(true);
timer->start(config->sessionTimeout * 1000);
hreq->start(request.method, request.uri, headers);
// note: unlike follow-up requests, the initial request is assumed to have a body.
// if no body field is present, we act as if it is present but empty.
if(!request.body.isEmpty())
{
if(request.more && !request.headers.contains("content-length"))
{
log_warning("streamed input requires content-length");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "length-required"));
return;
}
hreq->writeBody(request.body);
}
if(!request.more)
{
bodySent = true;
hreq->endBody();
}
else
{
// send cts
ZurlResponsePacket resp;
resp.credits = config->sessionBufferSize;
writeResponse(resp);
}
}
void start(const QVariant &vrequest, Mode mode)
{
outSeq = 0;
outCredits = 0;
quiet = false;
ZhttpRequestPacket request;
if(!request.fromVariant(vrequest))
{
log_warning("failed to parse zurl request");
QVariantHash vhash = vrequest.toHash();
rid = vhash.value("id").toByteArray();
toAddress = vhash.value("from").toByteArray();
QByteArray type = vhash.value("type").toByteArray();
if(!toAddress.isEmpty() && type != "error" && type != "cancel")
{
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
}
else
{
cleanup();
QMetaObject::invokeMethod(q, "finished", Qt::QueuedConnection);
}
return;
}
rid = request.id;
toAddress = request.from;
userData = request.userData;
sentHeader = false;
stuffToRead = false;
bytesReceived = 0;
ignorePolicies = request.ignorePolicies;
if(request.uri.isEmpty())
{
log_warning("missing request uri");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
QString scheme = request.uri.scheme();
if(scheme == "https" || scheme == "http")
{
transport = HttpTransport;
}
else if(scheme == "wss" || scheme == "ws")
{
transport = WebSocketTransport;
}
else
{
log_warning("unsupported scheme");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
if(transport == WebSocketTransport && mode != Worker::Stream)
{
log_warning("websocket must be used from stream interface");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
int defaultPort;
if(scheme == "https" || scheme == "wss")
defaultPort = 443;
else // http || wss
defaultPort = 80;
HttpHeaders headers = request.headers;
if(transport == HttpTransport)
{
// fire and forget
if(mode == Worker::Stream && (rid.isEmpty() || toAddress.isEmpty()))
quiet = true;
// streaming only allowed on streaming interface
if(mode == Worker::Stream)
outStream = request.stream;
else
outStream = false;
if(request.method.isEmpty())
{
log_warning("missing request method");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
log_info("IN id=%s, %s %s", request.id.data(), qPrintable(request.method), request.uri.toEncoded().data());
// inbound streaming must start with sequence number of 0
if(mode == Worker::Stream && request.more && request.seq != 0)
{
log_warning("streamed input must start with seq 0");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
// can't use these two together
if(mode == Worker::Single && request.more)
{
log_warning("cannot use streamed input on router interface");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
bodySent = false;
inSeq = request.seq;
if(!isAllowed(request.uri.host()) || (!request.connectHost.isEmpty() && !isAllowed(request.connectHost)))
{
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "policy-violation"));
return;
}
QByteArray hostHeader = request.uri.host().toUtf8();
// only tack on the port if it isn't being overridden
int port = request.uri.port(defaultPort);
if(request.connectPort == -1 && port != defaultPort)
hostHeader += ":" + QByteArray::number(port);
headers.removeAll("Host");
headers += HttpHeader("Host", hostHeader);
hreq = new HttpRequest(dns, this);
connect(hreq, SIGNAL(nextAddress(const QHostAddress &)), SLOT(req_nextAddress(const QHostAddress &)));
connect(hreq, SIGNAL(readyRead()), SLOT(req_readyRead()));
connect(hreq, SIGNAL(bytesWritten(int)), SLOT(req_bytesWritten(int)));
connect(hreq, SIGNAL(error()), SLOT(req_error()));
maxResponseSize = request.maxSize;
sessionTimeout = request.timeout;
if(!request.connectHost.isEmpty())
hreq->setConnectHost(request.connectHost);
if(request.connectPort != -1)
request.uri.setPort(request.connectPort);
hreq->setIgnoreTlsErrors(request.ignoreTlsErrors);
if(request.followRedirects)
hreq->setFollowRedirects(8);
if(request.credits != -1)
outCredits += request.credits;
}
else // WebSocketTransport
{
log_info("IN id=%s, %s", request.id.data(), request.uri.toEncoded().data());
// inbound streaming must start with sequence number of 0
if(request.seq != 0)
{
log_warning("websocket input must start with seq 0");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
if(toAddress.isEmpty())
{
log_warning("websocket input must provide from address");
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "bad-request"));
return;
}
inSeq = request.seq;
if(!isAllowed(request.uri.host()) || (!request.connectHost.isEmpty() && !isAllowed(request.connectHost)))
{
QMetaObject::invokeMethod(this, "respondError", Qt::QueuedConnection, Q_ARG(QByteArray, "policy-violation"));
return;
}
QByteArray hostHeader = request.uri.host().toUtf8();
// only tack on the port if it isn't being overridden
int port = request.uri.port(defaultPort);
if(request.connectPort == -1 && port != defaultPort)
hostHeader += ":" + QByteArray::number(port);
headers.removeAll("Host");
headers += HttpHeader("Host", hostHeader);
ws = new WebSocket(dns, this);
connect(ws, SIGNAL(nextAddress(const QHostAddress &)), SLOT(req_nextAddress(const QHostAddress &)));
connect(ws, SIGNAL(connected()), SLOT(ws_connected()));
connect(ws, SIGNAL(readyRead()), SLOT(ws_readyRead()));
connect(ws, SIGNAL(framesWritten(int)), SLOT(ws_framesWritten(int)));
connect(ws, SIGNAL(peerClosing()), SLOT(ws_peerClosing()));
connect(ws, SIGNAL(closed()), SLOT(ws_closed()));
connect(ws, SIGNAL(error()), SLOT(ws_error()));
if(!request.connectHost.isEmpty())
ws->setConnectHost(request.connectHost);
if(request.connectPort != -1)
request.uri.setPort(request.connectPort);
ws->setIgnoreTlsErrors(request.ignoreTlsErrors);
ws->setMaxFrameSize(config->sessionBufferSize);
if(request.credits != -1)
outCredits += request.credits;
}
httpActivityTimer = new QTimer(this);
connect(httpActivityTimer, SIGNAL(timeout()), SLOT(httpActivity_timeout()));
httpActivityTimer->setSingleShot(true);
httpActivityTimer->start(config->activityTimeout * 1000);
if(sessionTimeout != -1)
{
httpSessionTimer = new QTimer(this);
connect(httpSessionTimer, SIGNAL(timeout()), SLOT(httpSession_timeout()));
httpSessionTimer->setSingleShot(true);
httpSessionTimer->start(sessionTimeout);
}
if(transport == WebSocketTransport || (transport == HttpTransport && mode == Worker::Stream))
{
expireTimer = new QTimer(this);
connect(expireTimer, SIGNAL(timeout()), SLOT(expire_timeout()));
expireTimer->setSingleShot(true);
expireTimer->start(SESSION_EXPIRE);
keepAliveTimer = new QTimer(this);
connect(keepAliveTimer, SIGNAL(timeout()), SLOT(keepAlive_timeout()));
keepAliveTimer->start(SESSION_EXPIRE / 2);
}
if(transport == HttpTransport)
{
if(!request.body.isEmpty() && !request.more && !headers.contains("Content-Length"))
headers += HttpHeader("Content-Length", QByteArray::number(request.body.size()));
bool hasOrMightHaveBody = (!request.body.isEmpty() || request.more);
hreq->start(request.method, request.uri, headers, hasOrMightHaveBody);
if(hasOrMightHaveBody)
{
if(!request.body.isEmpty())
hreq->writeBody(request.body);
if(!request.more)
{
bodySent = true;
hreq->endBody();
}
}
else
bodySent = true;
if(mode == Stream)
{
if(request.more)
{
// send cts
ZhttpResponsePacket resp;
resp.type = ZhttpResponsePacket::Credit;
resp.credits = config->sessionBufferSize;
writeResponse(resp);
}
else
{
// send ack
ZhttpResponsePacket resp;
resp.type = ZhttpResponsePacket::KeepAlive;
writeResponse(resp);
}
}
}
else // WebSocketTransport
{
ws->start(request.uri, headers);
}
}