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());
}
QUrl
ContentTreeView::ContentNode2QUrl(ContentNode *node)
{
QUrl u;
if (node->is_group()) {
u.setPort(node->type());
u.setPath(QString::fromStdString(node->ParseAsGroup()->title()));
} else if (node->is_layer()) {
u.setPort(node->type());
u.setPath(QString::fromStdString(node->ParseAsLayer()->path()));
} else {
// undefined
}
return u;
}
void RtspSocket::stream(QUrl url,QString chid, bool aud)
{
qDebug("Start Streaming");
audioEnabled = aud;
channelid = chid;
if(url.port() == -1 || url.port()==0 )
url.setPort(554);
QDEBUG << url.toString();
qWarning() << tr("Stream: ") + url.toString();
if( state == statePlay || state == statePlaying || state == stateTeardown )
{
state = stateTeardown;
// set this after the teardown message
_url = url;
} else
{
_url = url;
// restart the state machine
state = stateInit;
}
slotStateMachine();
}
CddbConnection(cddb_disc_t *d) : disc(0) {
connection = cddb_new();
if (connection) {
cddb_cache_disable(connection);
cddb_set_server_name(connection, Settings::self()->cddbHost().toLatin1().constData());
cddb_set_server_port(connection, Settings::self()->cddbPort());
disc=cddb_disc_clone(d);
#ifdef ENABLE_KDE_SUPPORT
QString proxy=KProtocolManager::proxyFor("http");
if (!proxy.isEmpty()) {
QUrl url(proxy);
cddb_set_http_proxy_server_name(connection, url.host().toLatin1().constData());
cddb_set_http_proxy_server_port(connection, url.port());
cddb_http_proxy_enable(connection);
}
#else
QUrl url;
url.setHost(Settings::self()->cddbHost());
url.setPort(Settings::self()->cddbPort());
QList<QNetworkProxy> proxies=NetworkProxyFactory::self()->queryProxy(QNetworkProxyQuery(url));
foreach (const QNetworkProxy &p, proxies) {
if (QNetworkProxy::HttpProxy==p.type() && 0!=p.port()) {
cddb_set_http_proxy_server_name(connection, p.hostName().toLatin1().constData());
cddb_set_http_proxy_server_port(connection, p.port());
cddb_http_proxy_enable(connection);
break;
}
}
#endif
}
}
void WebInspectorWidget::webPageSelected(int index)
{
QObject *obj = ui->webPageComboBox->itemData(index, ObjectModel::ObjectRole).value<QObject*>();
// Wk 1, local
if (QWebPage *page = qobject_cast<QWebPage*>(obj)) {
page->settings()->setAttribute(QWebSettings::DeveloperExtrasEnabled, true);
ui->webInspector->setPage(page);
// webinspector needs a show event to actually show anything, just setting the page is not enough...
ui->webInspector->hide();
ui->webInspector->show();
ui->stack->setCurrentWidget(ui->wk1LocalPage);
}
else if (ui->webPageComboBox->itemData(index, WebViewModel::WebKitVersionRole).toInt() == 2) {
const QUrl serverUrl = Endpoint::instance()->serverAddress();
if (serverUrl.scheme() == QLatin1String("tcp")) {
QUrl inspectorUrl;
inspectorUrl.setScheme(QStringLiteral("http"));
inspectorUrl.setHost(serverUrl.host());
inspectorUrl.setPort(Endpoint::defaultPort() + 1);
ui->webView->setUrl(inspectorUrl);
ui->stack->setCurrentWidget(ui->wk2Page);
}
}
// WK1, remote
else {
ui->stack->setCurrentWidget(ui->wk1RemotePage);
}
}
void AccessManager::slotAuthenticationRequired(QNetworkReply *reply, QAuthenticator *authenticator)
{
#ifndef TOKEN_AUTH_ONLY
// do not handle 401 created by the networkjobs. We may want
// to eventually exempt some, but for now we need
// it only for other things, e.g. the browser. Would we handle
// network jobs, this would break the wizard logic
if (reply->property("doNotHandleAuth").toBool()) {
return;
}
QUrl url = reply->url();
// show only scheme, host and port
QUrl reducedUrl;
reducedUrl.setScheme(url.scheme());
reducedUrl.setHost(url.host());
reducedUrl.setPort(url.port());
AuthenticationDialog dialog(authenticator->realm(), reducedUrl.toString());
if (dialog.exec() == QDialog::Accepted) {
authenticator->setUser(dialog.user());
authenticator->setPassword(dialog.password());
}
#else
Q_UNUSED(reply) Q_UNUSED(authenticator)
Q_ASSERT(!"OCC::AccessManager::slotAuthenticationRequired called");
#endif
}
void QNetworkAccessHttpBackend::open()
{
QUrl url = request().url();
bool encrypt = url.scheme() == QLatin1String("https");
setAttribute(QNetworkRequest::ConnectionEncryptedAttribute, encrypt);
// set the port number in the reply if it wasn't set
url.setPort(url.port(encrypt ? DefaultHttpsPort : DefaultHttpPort));
// check if we have an open connection to this host
QByteArray cacheKey = makeCacheKey(this->url());
QNetworkAccessCache *cache = QNetworkAccessManagerPrivate::getCache(this);
if ((http = static_cast<QNetworkAccessHttpBackendCache *>(cache->requestEntryNow(cacheKey))) == 0) {
// no entry in cache; create an object
http = new QNetworkAccessHttpBackendCache(url.host(), url.port(), encrypt);
#ifndef QT_NO_NETWORKPROXY
QNetworkProxy networkProxy = proxy();
if (encrypt || networkProxy.type() == QNetworkProxy::HttpProxy)
http->setTransparentProxy(networkProxy);
else
http->setCacheProxy(networkProxy);
#endif
cache->addEntry(cacheKey, http);
}
setupConnection();
postRequest();
}
KJob *UPnPRouter::sendSoapQuery(const QString & query,const QString & soapact,const QString & controlurl)
{
// if port is not set, 0 will be returned
// thanks to Diego R. Brogna for spotting this bug
if (location.port()<=0)
location.setPort(80);
QUrl address;
address.setScheme(QString("http"));
address.setHost(location.host());
address.setPort(location.port());
address.setPath(controlurl);
KIO::TransferJob *req = KIO::http_post( address, query.toLatin1(), KIO::HideProgressInfo );
req->addMetaData("content-type", QString("text/xml"));
req->addMetaData("UserAgent", QString("Konversation UPnP"));
req->addMetaData("customHTTPHeader", QString("SOAPAction: ") + soapact);
soap_data_out[req] = QByteArray();
soap_data_in[req] = QByteArray();
connect(req, &KIO::TransferJob::data, this, &UPnPRouter::recvSoapData);
connect(req, &KIO::TransferJob::dataReq, this, &UPnPRouter::sendSoapData);
connect(req, &KIO::TransferJob::result, this, &UPnPRouter::onRequestFinished);
return req;
}
void MumbleDBus::getCurrentUrl(const QDBusMessage &msg) {
if (!g.sh || !g.sh->isRunning() || ! g.uiSession) {
QDBusConnection::sessionBus().send(msg.createErrorReply(QLatin1String("net.sourceforge.mumble.Error.connection"), QLatin1String("Not connected")));
return;
}
QString host, user, pw;
unsigned short port;
QUrl u;
g.sh->getConnectionInfo(host, port, user, pw);
u.setScheme(QLatin1String("mumble"));
u.setHost(host);
u.setPort(port);
u.setUserName(user);
#if QT_VERSION >= 0x050000
QUrlQuery query;
query.addQueryItem(QLatin1String("version"), QLatin1String("1.2.0"));
u.setQuery(query);
#else
u.addQueryItem(QLatin1String("version"), QLatin1String("1.2.0"));
#endif
QStringList path;
Channel *c = ClientUser::get(g.uiSession)->cChannel;
while (c->cParent) {
path.prepend(c->qsName);
c = c->cParent;
}
u.setPath(path.join(QLatin1String("/")));
QDBusConnection::sessionBus().send(msg.createReply(QString::fromLatin1(u.toEncoded())));
}
void PatMainWindow::setRubyProxyEnvironment(const QNetworkProxy &t_proxy)
{
OS_ASSERT(t_proxy.type() == QNetworkProxy::NoProxy || t_proxy.type() == QNetworkProxy::HttpProxy);
if (t_proxy.type() == QNetworkProxy::NoProxy)
{
LOG(Info, "Clearing proxy environment variables");
bool set = qputenv("HTTP_PROXY", QByteArray());
OS_ASSERT(set);
set = qputenv("HTTP_PROXY_USER", QByteArray());
OS_ASSERT(set);
set = qputenv("HTTP_PROXY_PASS", QByteArray());
OS_ASSERT(set);
set = qputenv("HTTP_USER", QByteArray());
OS_ASSERT(set);
set = qputenv("HTTP_PASS", QByteArray());
OS_ASSERT(set);
} else if (t_proxy.type() == QNetworkProxy::HttpProxy) {
LOG(Info, "Clearing proxy environment variables");
QUrl urlsimple;
urlsimple.setHost(t_proxy.hostName());
urlsimple.setPort(t_proxy.port());
urlsimple.setScheme("http");
bool set = qputenv("HTTP_PROXY", urlsimple.toString().toLatin1());
OS_ASSERT(set);
set = qputenv("HTTP_PROXY_USER", t_proxy.user().toLatin1());
OS_ASSERT(set);
set = qputenv("HTTP_PROXY_PASS", t_proxy.password().toLatin1());
OS_ASSERT(set);
set = qputenv("HTTP_USER", t_proxy.user().toLatin1());
OS_ASSERT(set);
set = qputenv("HTTP_PASS", t_proxy.password().toLatin1());
OS_ASSERT(set);
}
}
void TcpAddress::Init(const QString &ip, int port)
{
bool valid = true;
if(port < 0 || port > 65535) {
qWarning() << "Invalid port:" << port;
valid = false;
}
QHostAddress host(ip);
if(host.toString() != ip) {
qWarning() << "Invalid IP:" << ip;
valid = false;
}
if(host == QHostAddress::Null) {
host = QHostAddress::Any;
}
QUrl url;
url.setScheme(Scheme);
url.setHost(ip);
url.setPort(port);
_data = new TcpAddressData(url, host, port, valid);
}
static QUrl getApiUrl(BtsApi_private *p, const QString &method, const QueryList &querylist = QueryList())
{
assertClient(p);
QUrl res;
res.setScheme("http");
res.setHost(p->client->getHost());
res.setPort(p->client->getPort());
if(!p->client->getUserName().isEmpty())
res.setUserName(p->client->getUserName());
if(!p->client->getPassword().isEmpty())
res.setPassword(p->client->getPassword());
res.setPath("/api");
QUrlQuery urlQuery;
urlQuery.addQueryItem("method", method);
for(const QueryPair &qp: querylist)
{
if(qp.second.isNull())
urlQuery.addQueryItem(qp.first, "");
else
urlQuery.addQueryItem(qp.first, qp.second);
}
res.setQuery(urlQuery);
return res;
}
void TsFactory::TestMakeParser()
{
try
{
//test postgis uri
QUrl postgisUri;
postgisUri.setScheme("postgis");
postgisUri.setHost("localhost");
postgisUri.setPort(5432);
postgisUri.setUserName("postgres");
postgisUri.setPassword("postgres");
postgisUri.setPath("/basedeteste");
terrama2::core::DataSetItem unknownTypeItem(terrama2::core::DataSetItem::UNKNOWN_TYPE);
//FIXME: create a DataSetItem kind for ParserPostgis
// terrama2::collector::ParserPtr parser = terrama2::collector::Factory::makeParser(unknownTypeItem);
// terrama2::collector::ParserPostgis* parserPostgis = dynamic_cast<terrama2::collector::ParserPostgis*>(parser.get());
// QVERIFY(parserPostgis);
QUrl fileUri;
fileUri.setScheme("file");
fileUri.setPath("/tmp");
terrama2::collector::ParserPtr parser = terrama2::collector::Factory::makeParser(unknownTypeItem);
terrama2::collector::ParserOGR* parserOGR = dynamic_cast<terrama2::collector::ParserOGR*>(parser.get());
QVERIFY(parserOGR);
terrama2::core::DataSetItem pcdInpeTypeItem(terrama2::core::DataSetItem::PCD_INPE_TYPE);
parser = terrama2::collector::Factory::makeParser(pcdInpeTypeItem);
terrama2::collector::ParserPcdInpe* parserPdcInpe = dynamic_cast<terrama2::collector::ParserPcdInpe*>(parser.get());
QVERIFY(parserPdcInpe);
terrama2::core::DataSetItem pcdToaTypeItem(terrama2::core::DataSetItem::PCD_TOA5_TYPE);
parser = terrama2::collector::Factory::makeParser(pcdToaTypeItem);
terrama2::collector::ParserPcdToa5* parserPdctoa5 = dynamic_cast<terrama2::collector::ParserPcdToa5*>(parser.get());
QVERIFY(parserPdctoa5);
terrama2::core::DataSetItem firePointTypeItem(terrama2::core::DataSetItem::FIRE_POINTS_TYPE);
parser = terrama2::collector::Factory::makeParser(firePointTypeItem);
terrama2::collector::ParserFirePoint* parserFirePoint = dynamic_cast<terrama2::collector::ParserFirePoint*>(parser.get());
QVERIFY(parserFirePoint);
try
{
terrama2::core::DataSetItem diseaseTypeItem(terrama2::core::DataSetItem::DISEASE_OCCURRENCE_TYPE);
parser = terrama2::collector::Factory::makeParser(diseaseTypeItem);
QFAIL(NO_EXCEPTION_THROWN);
}
catch(terrama2::collector::ConflictingParserTypeSchemeException& e)
{
}
}
catch(...)
{
QFAIL(NO_EXCEPTION_EXPECTED);
}
}
static QByteArray makeCacheKey(QUrl &url, QNetworkProxy *proxy)
{
QString result;
QUrl copy = url;
QString scheme = copy.scheme().toLower();
bool isEncrypted = scheme == QLatin1String("https");
copy.setPort(copy.port(isEncrypted ? 443 : 80));
if (scheme == QLatin1String("preconnect-http")) {
copy.setScheme(QLatin1String("http"));
} else if (scheme == QLatin1String("preconnect-https")) {
copy.setScheme(QLatin1String("https"));
}
result = copy.toString(QUrl::RemoveUserInfo | QUrl::RemovePath |
QUrl::RemoveQuery | QUrl::RemoveFragment | QUrl::FullyEncoded);
#ifndef QT_NO_NETWORKPROXY
if (proxy && proxy->type() != QNetworkProxy::NoProxy) {
QUrl key;
switch (proxy->type()) {
case QNetworkProxy::Socks5Proxy:
key.setScheme(QLatin1String("proxy-socks5"));
break;
case QNetworkProxy::HttpProxy:
case QNetworkProxy::HttpCachingProxy:
key.setScheme(QLatin1String("proxy-http"));
break;
default:
break;
}
if (!key.scheme().isEmpty()) {
key.setUserName(proxy->user());
key.setHost(proxy->hostName());
key.setPort(proxy->port());
key.setQuery(result);
result = key.toString(QUrl::FullyEncoded);
}
}
#else
Q_UNUSED(proxy)
#endif
return "http-connection:" + result.toLatin1();
}
void TsDataRetrieverFTP::TestOKDownloadFile()
{
try
{
QUrl url;
url.setHost("ftp.dgi.inpe.br");
url.setPath("/focos_operacao/");
url.setScheme("FTP");
url.setPort(21);
url.setUserName("queimadas");
url.setPassword("inpe_2012");
curl_global_init(CURL_GLOBAL_ALL);
//DataProvider information
terrama2::core::DataProvider* dataProvider = new terrama2::core::DataProvider();
terrama2::core::DataProviderPtr dataProviderPtr(dataProvider);
dataProvider->uri = url.url().toStdString();
dataProvider->intent = terrama2::core::DataProviderIntent::COLLECTOR_INTENT;
dataProvider->dataProviderType = "FTP";
dataProvider->active = true;
//empty filter
terrama2::core::Filter filter;
std::string path;
std::string mask = "exporta_20160501_0230.csv";
MockCurlWrapper mock_;
ON_CALL(mock_, verifyURL(_)).WillByDefault(Return(CURLE_OK));
ON_CALL(mock_, getDownloadFiles(_,_,_)).WillByDefault(Return(CURLE_OK));
try
{
terrama2::core::DataRetrieverFTP retrieverFTP(dataProviderPtr, std::move(mock_));
auto remover = std::make_shared<terrama2::core::FileRemover>();
path = retrieverFTP.retrieveData(mask, filter, remover);
}
catch(...)
{
QFAIL("Unexpected exception!");
}
curl_global_cleanup();
}
catch(const terrama2::Exception& e)
{
QFAIL(boost::get_error_info< terrama2::ErrorDescription >(e)->toStdString().c_str());
}
catch(...)
{
QFAIL("Unexpected exception!");
}
return;
}
QUrl AxisCamera::endpoint() const
{
QUrl url;
url.setHost(_address.toString());
url.setScheme("http");
url.setPort(_port);
return url;
}
QUrl QQmlWebSocketServer::url() const
{
QUrl url;
url.setPort(m_port);
url.setHost(m_host);
url.setScheme("ws");
return url;
}
void ConnectPage::launchClient()
{
QUrl url;
url.setScheme("tcp");
url.setHost(ui->host->text());
url.setPort(ui->port->value());
ClientLauncher::launchDetached(url);
}
static QUrl localHostUrl(quint16 port)
{
QUrl url;
url.setScheme(QStringLiteral("http"));
url.setHost(QStringLiteral("127.0.0.1"));
url.setPort(port);
return url;
}
static QByteArray makeCacheKey(const QUrl &url)
{
QUrl copy = url;
bool isEncrypted = url.scheme() == QLatin1String("https");
copy.setPort(url.port(isEncrypted ? DefaultHttpsPort : DefaultHttpPort));
return "http-connection:" + copy.toEncoded(QUrl::RemovePassword | QUrl::RemovePath |
QUrl::RemoveQuery | QUrl::RemoveFragment);
}
QUrl HttpServer::url() const
{
QUrl url;
url.setPort(m_port);
url.setHost("localhost");
url.setScheme("http");
return url;
}
static QByteArray makeCacheKey(const QUrl &url)
{
QUrl copy = url;
copy.setPort(url.port(DefaultFtpPort));
return "ftp-connection:" +
copy.toEncoded(QUrl::RemovePassword | QUrl::RemovePath | QUrl::RemoveQuery |
QUrl::RemoveFragment);
}
QUrl TestHTTPServer::baseUrl() const
{
QUrl url;
url.setScheme(QStringLiteral("http"));
url.setHost(QStringLiteral("127.0.0.1"));
url.setPort(server.serverPort());
return url;
}
void TsDataRetrieverFTP::TestFailUriInvalid()
{
try
{
QUrl url;
url.setHost("ftp.dgi.inpe.br");
url.setPath("/operacao/");
url.setScheme("FTP");
url.setPort(21);
url.setUserName("queimadas");
url.setPassword("inpe_2012");
curl_global_init(CURL_GLOBAL_ALL);
//DataProvider information
terrama2::core::DataProvider* dataProvider = new terrama2::core::DataProvider();
terrama2::core::DataProviderPtr dataProviderPtr(dataProvider);
dataProvider->uri = url.url().toStdString();
dataProvider->intent = terrama2::core::DataProviderIntent::COLLECTOR_INTENT;
dataProvider->dataProviderType = "FTP";
dataProvider->active = true;
//empty filter
terrama2::core::Filter filter;
MockCurlWrapper mock_;
ON_CALL(mock_, verifyURL(_)).WillByDefault(Return(CURLE_COULDNT_RESOLVE_HOST));
try
{
terrama2::core::DataRetrieverFTP retrieverFTP(dataProviderPtr, std::move(mock_));
QFAIL("Exception expected!");
}
catch(const terrama2::core::DataRetrieverException& e)
{
}
curl_global_cleanup();
}
catch(const terrama2::Exception& e)
{
QFAIL(boost::get_error_info< terrama2::ErrorDescription >(e)->toStdString().c_str());
}
catch(...)
{
QFAIL("Unexpected exception!");
}
return;
}
static void setApplicationProxy(QUrl url)
{
if (!url.isEmpty())
{
if (url.port() == -1)
url.setPort(8080);
QNetworkProxy proxy(QNetworkProxy::HttpProxy, url.host(), url.port(), url.userName(), url.password());
QNetworkProxy::setApplicationProxy(proxy);
}
}
/*!
Returns the URL of the WAP gateway (including port, login and password).
\code
QWapAccount acc(...)
...
QUrl gateway = acc.gateway();
QString password = gateway.password();
QString username = gateway.userName();
\endcode
\sa setGateway(), QUrl
*/
QUrl QWapAccount::gateway() const
{
QUrl url;
url.setHost( d->conf->value( QLatin1String("Wap/Gateway") ).toString());
url.setUserName( d->conf->value( QLatin1String("Wap/UserName") ).toString() );
url.setPassword( d->conf->value( QLatin1String("Wap/Password") ).toString() );
url.setPort( d->conf->value( QLatin1String("Wap/Port")).toInt() );
return url;
}
QUrl Session::url(const QString& path) const
{
QUrl url;
url.setScheme("http");
url.setHost(m_host);
url.setPort(EDAM_PORT);
QString uid = m_data.getProperty("Uid").toString();
url.setPath(QString("/shard/%1/%2").arg(uid).arg(path));
return url;
}
QScriptValue QWebSecurityOriginPointerToScriptValue(QScriptEngine *engine, QWebSecurityOrigin* const &item)
{
QScriptValue obj = engine->newObject();
QUrl url = QUrl();
url.setHost(item->host());
url.setPort(item->port());
url.setScheme(item->scheme());
obj.setProperty("_url", qPrintable(url.toString()));
return obj;
}
QUrl SessionListingModel::sessionUrl(int index) const
{
const Session &s = m_filtered.at(index);
QUrl url;
url.setScheme("drawpile");
url.setHost(s.host);
if(s.port != DRAWPILE_PROTO_DEFAULT_PORT)
url.setPort(s.port);
url.setPath("/" + s.id);
return url;
}
QUrl ServicesDbTestUtils::getDbModifyUrl()
{
// read the DB values from the DB config file.
Settings s = _readDbConfig();
QUrl result;
result.setScheme("hootapidb");
result.setHost(s.get("DB_HOST").toString());
result.setPort(s.get("DB_PORT").toInt());
result.setUserName(s.get("DB_USER").toString());
result.setPassword(s.get("DB_PASSWORD").toString());
result.setPath("/" + s.get("DB_NAME").toString() + "/testMap");
return result;
}
