HttpRequestHandler.cpp

#include "HttpRequestHandler.h"
#include "Exceptions.h"
#include "ProxyCredentialsHandler.h"
#include <QEventLoop>
#include <QNetworkProxy>
#include <QHttpMultiPart>

HttpRequestHandler::HttpRequestHandler(QObject* parent)
	: QObject(parent)
	, nmgr_()
	, headers_()
{
	headers_.insert("User-Agent", "GSvar");

	//basic authentification
	connect(&nmgr_, &QNetworkAccessManager::authenticationRequired, this, &HttpRequestHandler::authenticationRequired, Qt::DirectConnection);


	//SSL error handling
	connect(&nmgr_, SIGNAL(sslErrors(QNetworkReply*, const QList<QSslError> &)), this, SLOT(handleSslErrors(QNetworkReply*, const QList<QSslError>&)));

	//proxy handling
	QNetworkProxyFactory::setUseSystemConfiguration(true);
	connect(&nmgr_, &QNetworkAccessManager::proxyAuthenticationRequired, &ProxyCredentialsHandler::instance(), &ProxyCredentialsHandler::proxyAuthenticationRequired, Qt::DirectConnection);
}

const HttpHeaders& HttpRequestHandler::headers() const
{
	return headers_;
}

void HttpRequestHandler::setHeader(const QByteArray& key, const QByteArray& value)
{
	headers_.insert(key, value);
}

void HttpRequestHandler::setCredentials(QString user, QString password)
{
	user_ = user;
	password_ = password;
}

ServerReply HttpRequestHandler::head(QString url, const HttpHeaders& add_headers)
{
 //request
	QNetworkRequest request;
	request.setDecompressedSafetyCheckThreshold(-1);
 request.setUrl(url);
 for(auto it=headers_.begin(); it!=headers_.end(); ++it)
 {
 request.setRawHeader(it.key(), it.value());
 }
 for(auto it=add_headers.begin(); it!=add_headers.end(); ++it)
 {
 request.setRawHeader(it.key(), it.value());
 }

 //query
	QScopedPointer<QNetworkReply> reply(nmgr_.head(request));

 //make the loop process the reply immediately
 QEventLoop loop;
	connect(reply.data(), SIGNAL(finished()), &loop, SLOT(quit()));
 loop.exec();

	ServerReply output;
	for (const QByteArray& line : reply->rawHeaderList())
	{
		output.headers.insert(line, reply->rawHeader(line));
	}
 output.status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
	output.body = reply->readAll();
 if (reply->error()!=QNetworkReply::NoError)
 {
 THROW_HTTP(HttpException, "HTTP Error: " + networkErrorAsString(reply->error()) + "\nIODevice Error: " + reply->errorString(), output.status_code, output.headers, output.body);
 }

 return output;
}

ServerReply HttpRequestHandler::get(QString url, const HttpHeaders& add_headers)
{
 //request
	QNetworkRequest request;
	request.setDecompressedSafetyCheckThreshold(-1);
 request.setUrl(url);
 for(auto it=headers_.begin(); it!=headers_.end(); ++it)
 {
 request.setRawHeader(it.key(), it.value());
 }
 for(auto it=add_headers.begin(); it!=add_headers.end(); ++it)
 {
 request.setRawHeader(it.key(), it.value());
 }
	request.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);

 ServerReply output;
	const int max_retry_attempts = 5;
	for (int i=1; i<=max_retry_attempts; ++i)
 {
 //query
		QScopedPointer<QNetworkReply> reply(nmgr_.get(request));
		reply->setReadBufferSize(0);

 //make the loop process the reply immediately
 QEventLoop loop;
		connect(reply.data(), SIGNAL(finished()), &loop, SLOT(quit()));
 loop.exec();

		//output
		output.clear();
		for (const QByteArray& line: reply->rawHeaderList())
 {
			output.headers.insert(line, reply->rawHeader(line));
 }
 output.status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
 output.body = reply->readAll();
		if (reply->error()!=QNetworkReply::NoError && reply->error()!=QNetworkReply::RemoteHostClosedError)
 {
			if (i == max_retry_attempts)
 {
				THROW_HTTP(HttpException, "HTTP Error: " + networkErrorAsString(reply->error()) + "\nDevice Error: " + reply->errorString()+ "\nReply: " + output.body, output.status_code, output.headers, output.body);
			}
			else continue;
 }

		break;
 }
 return output;
}

ServerReply HttpRequestHandler::put(QString url, const QByteArray& data, const HttpHeaders& add_headers)
{
	//request
	QNetworkRequest request;
	request.setDecompressedSafetyCheckThreshold(-1);
	request.setUrl(url);
	for(auto it=headers_.begin(); it!=headers_.end(); ++it)
	{
		request.setRawHeader(it.key(), it.value());
	}
	for(auto it=add_headers.begin(); it!=add_headers.end(); ++it)
	{
		request.setRawHeader(it.key(), it.value());
	}

	//query
	QScopedPointer<QNetworkReply> reply(nmgr_.put(request, data));

	//make the loop process the reply immediately
	QEventLoop loop;
	connect(reply.data(), SIGNAL(finished()), &loop, SLOT(quit()));
	loop.exec();

 //output
 ServerReply output;
	for (const QByteArray& line : reply->rawHeaderList())
	{
		output.headers.insert(line, reply->rawHeader(line));
	}
 output.status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
 output.body = reply->readAll();
 if (reply->error()!=QNetworkReply::NoError)
 {
 THROW_HTTP(HttpException, "HTTP Error: " + networkErrorAsString(reply->error()) + "\nIODevice Error: " + reply->errorString(), output.status_code, output.headers, output.body);
	}

 return output;
}

ServerReply HttpRequestHandler::post(QString url, const QByteArray& data, const HttpHeaders& add_headers)
{
 //request
 QNetworkRequest request;
	request.setDecompressedSafetyCheckThreshold(-1);
	request.setUrl(url);
 for(auto it=headers_.begin(); it!=headers_.end(); ++it)
 {
 request.setRawHeader(it.key(), it.value());
 }
 for(auto it=add_headers.begin(); it!=add_headers.end(); ++it)
 {
 request.setRawHeader(it.key(), it.value());
 }

 //query
	QScopedPointer<QNetworkReply> reply(nmgr_.post(request, data));

 //make the loop process the reply immediately
 QEventLoop loop;
	connect(reply.data(), SIGNAL(finished()), &loop, SLOT(quit()));
 loop.exec();

 //output
 ServerReply output;
	for (const QByteArray& line : reply->rawHeaderList())
	{
		output.headers.insert(line, reply->rawHeader(line));
	}
 output.status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
	output.body = reply->readAll();
 if (reply->error()!=QNetworkReply::NoError)
 {
		THROW_HTTP(HttpException, "HTTP Error: " + networkErrorAsString(reply->error()) + "\nDevice error: " + reply->errorString() + "\nReply: " + output.body, output.status_code, output.headers, output.body);
 }

 return output;
}

ServerReply HttpRequestHandler::post(QString url, QHttpMultiPart* parts, const HttpHeaders& add_headers)
{
 //request
	QNetworkRequest request;
	request.setDecompressedSafetyCheckThreshold(-1);
 request.setUrl(url);
 for(auto it=headers_.begin(); it!=headers_.end(); ++it)
 {
 request.setRawHeader(it.key(), it.value());
 }
 for(auto it=add_headers.begin(); it!=add_headers.end(); ++it)
 {
 request.setRawHeader(it.key(), it.value());
 }

 //query
	QScopedPointer<QNetworkReply> reply(nmgr_.post(request, parts));

 //make the loop process the reply immediately
 QEventLoop loop;
	connect(reply.data(), SIGNAL(finished()), &loop, SLOT(quit()));
 loop.exec();

 //output
 ServerReply output;
	for (const QByteArray& line : reply->rawHeaderList())
	{
		output.headers.insert(line, reply->rawHeader(line));
	}
 output.status_code = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
 output.body = reply->readAll();
 if (reply->error()!=QNetworkReply::NoError)
 {
 THROW_HTTP(HttpException, "HTTP Error: " + networkErrorAsString(reply->error()) + "\nIODevice Error: " + reply->errorString(), output.status_code, output.headers, output.body);
 }

 return output;
}

QString HttpRequestHandler::proxyForUrl(QString url)
{
	QList<QNetworkProxy> proxies = QNetworkProxyFactory::systemProxyForQuery(QNetworkProxyQuery(url));
	if (!proxies.isEmpty())
	{
		return proxies[0].hostName().toLower().trimmed();
	}

	return "";
}

void HttpRequestHandler::handleSslErrors(QNetworkReply* reply, const QList<QSslError>& errors)
{
	foreach(const QSslError& error, errors)
	{
		qDebug() << "ignore error" << error.errorString();
 }
 reply->ignoreSslErrors(errors);
}

void HttpRequestHandler::authenticationRequired(QNetworkReply* reply, QAuthenticator* authenticator)
{
	if (user_.isEmpty() && password_.isEmpty()) THROW(NetworkException, "Basic authtification reqested, but no credentials set for URL: " + reply->url().toString());

	authenticator->setUser(user_);
	authenticator->setPassword(password_);
}

QString HttpRequestHandler::networkErrorAsString(QNetworkReply::NetworkError error)
{

 switch(error)
 {
 case QNetworkReply::NetworkError::NoError: return "";

 // network layer errors [relating to the destination server] (1-99):
 case QNetworkReply::NetworkError::ConnectionRefusedError: return "Connection refused";
 case QNetworkReply::NetworkError::RemoteHostClosedError: return "Remote host closed the connection";
 case QNetworkReply::NetworkError::HostNotFoundError: return "Host not found";
 case QNetworkReply::NetworkError::TimeoutError: return "Connection timeout has been reached";
 case QNetworkReply::NetworkError::OperationCanceledError: return "Operation has been canceled";
 case QNetworkReply::NetworkError::SslHandshakeFailedError: return "SSL handshake failed";
 case QNetworkReply::NetworkError::TemporaryNetworkFailureError: return "Temporary network failure";
 case QNetworkReply::NetworkError::NetworkSessionFailedError: return "Network session failed";
 case QNetworkReply::NetworkError::BackgroundRequestNotAllowedError: return "Background request not allowed";
 case QNetworkReply::NetworkError::TooManyRedirectsError: return "Too many redirects";
 case QNetworkReply::NetworkError::InsecureRedirectError: return "Insecure redirect";
 case QNetworkReply::NetworkError::UnknownNetworkError: return "Unknown network error";

 // proxy errors (101-199):
 case QNetworkReply::NetworkError::ProxyConnectionRefusedError: return "Proxy connection has been refused";
 case QNetworkReply::NetworkError::ProxyConnectionClosedError: return "Proxy connection has been closed";
 case QNetworkReply::NetworkError::ProxyNotFoundError: return "Proxy not found";
 case QNetworkReply::NetworkError::ProxyTimeoutError: return "Proxy timeout";
 case QNetworkReply::NetworkError::ProxyAuthenticationRequiredError: return "Proxy authentication required";
 case QNetworkReply::NetworkError::UnknownProxyError: return "Unknown proxy error";

 // content errors (201-299):
 case QNetworkReply::NetworkError::ContentAccessDenied: return "Content access denied";
 case QNetworkReply::NetworkError::ContentOperationNotPermittedError: return "Content operation not permitted";
 case QNetworkReply::NetworkError::ContentNotFoundError: return "Content not found";
 case QNetworkReply::NetworkError::AuthenticationRequiredError: return "Authentication required";
 case QNetworkReply::NetworkError::ContentReSendError: return "Content ReSend";

 case QNetworkReply::NetworkError::ContentConflictError: return "Content conflict";
 case QNetworkReply::NetworkError::ContentGoneError: return "Content gone";
 case QNetworkReply::NetworkError::UnknownContentError: return "Unknown content error";

 // protocol errors
 case QNetworkReply::NetworkError::ProtocolUnknownError: return "Protocol unknown";
 case QNetworkReply::NetworkError::ProtocolInvalidOperationError: return "Protocol invalid operation";
 case QNetworkReply::NetworkError::ProtocolFailure: return "Protocol failure";

 // Server side errors (401-499)
 case QNetworkReply::NetworkError::InternalServerError: return "Internal server error";
 case QNetworkReply::NetworkError::OperationNotImplementedError: return "Operation not implemented";
 case QNetworkReply::NetworkError::ServiceUnavailableError: return "Service unavailable";
 case QNetworkReply::NetworkError::UnknownServerError: return "Unknown server error";
 default: return "Unknown network error";
 }
}