static QNetworkProxy proxyFromDictionary(CFDictionaryRef dict, QNetworkProxy::ProxyType type,
CFStringRef enableKey, CFStringRef hostKey,
CFStringRef portKey)
{
CFNumberRef protoEnabled;
CFNumberRef protoPort;
CFStringRef protoHost;
if (enableKey
&& (protoEnabled = (CFNumberRef)CFDictionaryGetValue(dict, enableKey))
&& (protoHost = (CFStringRef)CFDictionaryGetValue(dict, hostKey))
&& (protoPort = (CFNumberRef)CFDictionaryGetValue(dict, portKey))) {
int enabled;
if (CFNumberGetValue(protoEnabled, kCFNumberIntType, &enabled) && enabled) {
QString host = QCFString::toQString(protoHost);
int port;
CFNumberGetValue(protoPort, kCFNumberIntType, &port);
return QNetworkProxy(type, host, port);
}
}
// proxy not enabled
return QNetworkProxy();
}
QList<QNetworkProxy> PackageManagerProxyFactory::queryProxy(const QNetworkProxyQuery &query)
{
const Settings &settings = m_core->settings();
QList<QNetworkProxy> list;
if (settings.proxyType() == Settings::SystemProxy) {
#if defined(Q_OS_UNIX) && !defined(Q_OS_OSX)
QUrl proxyUrl = QUrl::fromUserInput(QString::fromUtf8(qgetenv("http_proxy")));
if (proxyUrl.isValid()) {
return list << QNetworkProxy(QNetworkProxy::HttpProxy, proxyUrl.host(), proxyUrl.port(),
proxyUrl.userName(), proxyUrl.password());
}
#endif
return QNetworkProxyFactory::systemProxyForQuery(query);
}
if ((settings.proxyType() == Settings::NoProxy))
return list << QNetworkProxy(QNetworkProxy::NoProxy);
if (query.queryType() == QNetworkProxyQuery::UrlRequest) {
if (query.url().scheme() == QLatin1String("ftp"))
return list << settings.ftpProxy();
if ((query.url().scheme() == QLatin1String("http"))
|| (query.url().scheme() == QLatin1String("https"))) {
return list << settings.httpProxy();
}
}
return list << QNetworkProxy(QNetworkProxy::DefaultProxy);
}
QList<QNetworkProxy> NetworkAutomaticProxy::getProxy(const QString &url, const QString &host)
{
QScriptValueList arguments;
arguments << m_engine.toScriptValue(url) << m_engine.toScriptValue(host);
const QScriptValue result = m_findProxy.call(m_engine.globalObject(), arguments);
if (result.isError())
{
return m_proxies[QLatin1String("ERROR")];
}
const QString configuration = result.toString().remove(QLatin1Char(' '));
if (!m_proxies.value(configuration).isEmpty())
{
return m_proxies[configuration];
}
// proxy format: "PROXY host:port; PROXY host:port", "PROXY host:port; SOCKS host:port" etc.
// can be combination of DIRECT, PROXY, SOCKS
const QStringList proxies = configuration.split(QLatin1Char(';'));
QList<QNetworkProxy> proxiesForQuery;
for (int i = 0; i < proxies.count(); ++i)
{
const QStringList proxy = proxies.at(i).split(QLatin1Char(':'));
QString proxyHost = proxy.at(0);
if (proxy.count() == 2 && proxyHost.indexOf(QLatin1String("PROXY"), Qt::CaseInsensitive) == 0)
{
proxiesForQuery << QNetworkProxy(QNetworkProxy::HttpProxy, proxyHost.replace(0, 5, QString()), proxy.at(1).toInt());
continue;
}
if (proxy.count() == 2 && proxyHost.indexOf(QLatin1String("SOCKS"), Qt::CaseInsensitive) == 0)
{
proxiesForQuery << QNetworkProxy(QNetworkProxy::Socks5Proxy, proxyHost.replace(0, 5, QString()), proxy.at(1).toInt());
continue;
}
if (proxy.count() == 1 && proxyHost.indexOf(QLatin1String("DIRECT"), Qt::CaseInsensitive) == 0)
{
proxiesForQuery << QNetworkProxy(QNetworkProxy::NoProxy);
continue;
}
Console::addMessage(QCoreApplication::translate("main", "Failed to parse entry of proxy auto-config (PAC):\n%1").arg(proxies.at(i)), NetworkCategory, ErrorLevel);
return m_proxies[QLatin1String("ERROR")];
}
m_proxies.insert(configuration, proxiesForQuery);
return m_proxies[configuration];
}
QList< QNetworkProxy >
NetworkProxyFactory::queryProxy( const QNetworkProxyQuery& query )
{
tDebug() << Q_FUNC_INFO << "query.peerHostName() = " << query.peerHostName() << ", m_noProxyHosts = " << m_noProxyHosts;
QList< QNetworkProxy > proxies;
QString hostname = query.peerHostName();
if ( m_proxy.hostName().isEmpty() || hostname.isEmpty() || m_noProxyHosts.contains( hostname ) || TomahawkSettings::instance()->proxyType() == QNetworkProxy::NoProxy )
proxies << QNetworkProxy( QNetworkProxy::DefaultProxy ) << QNetworkProxy( QNetworkProxy::NoProxy );
else
proxies << m_proxy << QNetworkProxy( QNetworkProxy::DefaultProxy ) << QNetworkProxy( QNetworkProxy::NoProxy );
tDebug() << Q_FUNC_INFO << " proxies size = " << proxies.size();
return proxies;
}
void jConnection::loadProxySettings()
{
DEBUG() << Q_FUNC_INFO;
createSocket();
QSettings settings(QSettings::defaultFormat(), QSettings::UserScope, "qutim/qutim."+m_profile_name+"/jabber."+m_account_name, "accountsettings");
settings.beginGroup("proxy");
int proxy_type = settings.value("type",0).toInt();
int proxy_port = settings.value("port",0).toInt();
QString proxy_host = settings.value("host","").toString();
bool proxy_auth = settings.value("auth",false).toBool();
QString proxy_user = settings.value("user","").toString();
QString proxy_pass = settings.value("password","").toString();
settings.endGroup();
switch(proxy_type)
{
case 0:{ // No Proxy
m_proxy = QNetworkProxy(QNetworkProxy::NoProxy);
m_socket->setProxy(m_proxy);
break;
}
case 1:{ // HTTP
m_proxy = QNetworkProxy(QNetworkProxy::HttpProxy, proxy_host, proxy_port);
if (proxy_auth)
{
m_proxy.setUser(proxy_user);
m_proxy.setPassword(proxy_pass);
}
m_socket->setProxy(m_proxy);
break;}
case 2:{ // SOCKS5
m_proxy = QNetworkProxy(QNetworkProxy::Socks5Proxy, proxy_host, proxy_port);
m_socket->setProxy(m_proxy);
if (proxy_auth)
{
m_proxy.setUser(proxy_user);
m_proxy.setPassword(proxy_pass);
}
break;
}
case 3: // BOSH
// Really don not know what is it
// so it would be equal to no proxy
default:{
m_proxy = QNetworkProxy(QNetworkProxy::DefaultProxy);
m_socket->setProxy(m_proxy);
break;
}
}
}
IConnectionProxy ConnectionManager::proxyById(const QUuid &AProxyId) const
{
static const IConnectionProxy noProxy = {" "+tr("<No Proxy>"), QNetworkProxy(QNetworkProxy::NoProxy) };
if (!AProxyId.isNull())
{
OptionsNode pnode;
QList<QUuid> plist = proxyList();
if (plist.contains(AProxyId))
pnode = Options::node(OPV_PROXY_ITEM,AProxyId.toString());
else if (plist.contains(defaultProxy()))
pnode = Options::node(OPV_PROXY_ITEM,defaultProxy().toString());
if (!pnode.isNull())
{
IConnectionProxy proxy;
proxy.name = pnode.value("name").toString();
proxy.proxy.setType((QNetworkProxy::ProxyType)pnode.value("type").toInt());
proxy.proxy.setHostName(pnode.value("host").toString());
proxy.proxy.setPort(pnode.value("port").toInt());
proxy.proxy.setUser(pnode.value("user").toString());
proxy.proxy.setPassword(Options::decrypt(pnode.value("pass").toByteArray()).toString());
return proxy;
}
}
return noProxy;
}
QNetworkProxy SocksStreams::accountNetworkProxy(const Jid &AStreamJid) const
{
QNetworkProxy proxy(QNetworkProxy::NoProxy);
IXmppStream *stream = FXmppStreams!=NULL ? FXmppStreams->xmppStream(AStreamJid) : NULL;
IDefaultConnection *connection = stream!=NULL ? qobject_cast<IDefaultConnection *>(stream->connection()->instance()) : NULL;
return connection!=NULL ? connection->proxy() : QNetworkProxy(QNetworkProxy::NoProxy);
}
/*!
\since 4.1
Returns the network proxy for this socket.
By default QNetworkProxy::DefaultProxy is used.
\sa setProxy(), QNetworkProxy
*/
QNetworkProxy QTcpServer::proxy() const
{
Q_D(const QTcpServer);
if (d->proxy)
return *d->proxy;
return QNetworkProxy();
}
static QNetworkProxy proxyFromDictionary(CFDictionaryRef dict)
{
QNetworkProxy::ProxyType proxyType = QNetworkProxy::DefaultProxy;
QString hostName;
quint16 port = 0;
QString user;
QString password;
CFStringRef cfProxyType = (CFStringRef)CFDictionaryGetValue(dict, kCFProxyTypeKey);
if (CFStringCompare(cfProxyType, kCFProxyTypeNone, 0) == kCFCompareEqualTo) {
proxyType = QNetworkProxy::NoProxy;
} else if (CFStringCompare(cfProxyType, kCFProxyTypeFTP, 0) == kCFCompareEqualTo) {
proxyType = QNetworkProxy::FtpCachingProxy;
} else if (CFStringCompare(cfProxyType, kCFProxyTypeHTTP, 0) == kCFCompareEqualTo) {
proxyType = QNetworkProxy::HttpProxy;
} else if (CFStringCompare(cfProxyType, kCFProxyTypeHTTPS, 0) == kCFCompareEqualTo) {
proxyType = QNetworkProxy::HttpProxy;
} else if (CFStringCompare(cfProxyType, kCFProxyTypeSOCKS, 0) == kCFCompareEqualTo) {
proxyType = QNetworkProxy::Socks5Proxy;
}
hostName = QCFString::toQString((CFStringRef)CFDictionaryGetValue(dict, kCFProxyHostNameKey));
user = QCFString::toQString((CFStringRef)CFDictionaryGetValue(dict, kCFProxyUsernameKey));
password = QCFString::toQString((CFStringRef)CFDictionaryGetValue(dict, kCFProxyPasswordKey));
CFNumberRef portNumber = (CFNumberRef)CFDictionaryGetValue(dict, kCFProxyPortNumberKey);
if (portNumber) {
CFNumberGetValue(portNumber, kCFNumberSInt16Type, &port);
}
return QNetworkProxy(proxyType, hostName, port, user, password);
}
void Translator::translate(const QString &text, const QString &language, QObject *sender) {
qDebug() << "Translator::translate() " + text;
Configuration *config = Configuration::getInstance();
QUrl translatorUrl("http://ajax.googleapis.com/ajax/services/language/translate");
QString request = "?v=1.0&q=" + QUrl::toPercentEncoding(text) + "&format=html&langpair=%7C" + language;
QHttpRequestHeader header;
header.setRequest("GET", translatorUrl.path() + request);
header.setValue("Host", translatorUrl.host());
header.setValue("Referer", "Qwit");
if (config->useProxy) {
http->setProxy(config->proxyAddress, config->proxyPort, config->proxyUsername, config->proxyPassword);
} else {
http->setProxy(QNetworkProxy(QNetworkProxy::NoProxy));
}
if(translatorUrl.toString().indexOf("https") == 0) {
http->setHost(translatorUrl.host(), QHttp::ConnectionModeHttps, translatorUrl.port(443));
} else {
http->setHost(translatorUrl.host(), QHttp::ConnectionModeHttp, translatorUrl.port(80));
}
buffer = new QBuffer(this);
buffer->open(QIODevice::WriteOnly);
int requestId = http->request(header, 0, buffer);
requestSender[requestId] = sender;
}
/*! \internal
Resolve the proxy to its final value.
*/
QNetworkProxy QTcpServerPrivate::resolveProxy(const QHostAddress &address, quint16 port)
{
if (address == QHostAddress::LocalHost ||
address == QHostAddress::LocalHostIPv6)
return QNetworkProxy::NoProxy;
QList<QNetworkProxy> proxies;
if (proxy.type() != QNetworkProxy::DefaultProxy) {
// a non-default proxy was set with setProxy
proxies << proxy;
} else {
// try the application settings instead
QNetworkProxyQuery query(port, QString(), QNetworkProxyQuery::TcpServer);
proxies = QNetworkProxyFactory::proxyForQuery(query);
}
// return the first that we can use
foreach (const QNetworkProxy &p, proxies) {
if (p.capabilities() & QNetworkProxy::ListeningCapability)
return p;
}
// no proxy found
// DefaultProxy will raise an error
return QNetworkProxy(QNetworkProxy::DefaultProxy);
}
/*!
\since 4.5
Sets the proxy factory for this class to be \a factory. A proxy
factory is used to determine a more specific list of proxies to be
used for a given request, instead of trying to use the same proxy
value for all requests.
All queries sent by QNetworkAccessManager will have type
QNetworkProxyQuery::UrlRequest.
For example, a proxy factory could apply the following rules:
\list
\o if the target address is in the local network (for example,
if the hostname contains no dots or if it's an IP address in
the organization's range), return QNetworkProxy::NoProxy
\o if the request is FTP, return an FTP proxy
\o if the request is HTTP or HTTPS, then return an HTTP proxy
\o otherwise, return a SOCKSv5 proxy server
\endlist
The lifetime of the object \a factory will be managed by
QNetworkAccessManager. It will delete the object when necessary.
\note If a specific proxy is set with setProxy(), the factory will not
be used.
\sa proxyFactory(), setProxy(), QNetworkProxyQuery
*/
void QNetworkAccessManager::setProxyFactory(QNetworkProxyFactory *factory)
{
Q_D(QNetworkAccessManager);
delete d->proxyFactory;
d->proxyFactory = factory;
d->proxy = QNetworkProxy();
}
void JamendoBrowser::GetList(QString comefrom, QString text)
{
if(proxy->hasVariable("proxyEnabled") && proxy->getVariable("proxyEnabled") == "true") {
manager.setProxy(QNetworkProxy(QNetworkProxy::HttpProxy,
proxy->getVariable("proxyHost"),
proxy->getVariable("proxyPort").toInt(),
proxy->getVariable("proxyUser"),
proxy->getVariable("proxyPassword")));
}
if(!comefrom.size()) comefrom = "http://api.jamendo.com/get2/id+name+rating+url+weight/tag/plain/?order=rating_desc";
comefrom += "&n=50";
reply = manager.get(QNetworkRequest(QUrl(comefrom)));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(slotError(QNetworkReply::NetworkError)));
if (text.size()) switch(listType) {
case LIST_GENRE:
_tag.tag0.genre = text; break;
case LIST_ARTIST:
_tag.tag0.artist = text; break;
case LIST_ALBUM:
_tag.tag0.album = text; break;
case LIST_NONE:
default:
;
}
}
void setApplicationProxyFactory(QNetworkProxyFactory *factory)
{
QMutexLocker lock(&mutex);
if (applicationLevelProxy)
*applicationLevelProxy = QNetworkProxy();
delete applicationLevelProxyFactory;
applicationLevelProxyFactory = factory;
}
QList<QNetworkProxy> queryProxy(const QNetworkProxyQuery &query = QNetworkProxyQuery())
{
QList<QNetworkProxy> plist;
#if defined(__WINSCW__)
plist.push_back(QNetworkProxy(QNetworkProxy::HttpProxy,QString("dawebproxy01.americas.nokia.com"), 8080));
#endif
QUrl proxyUrl = urlFromUserInput(qgetenv("http_proxy"));
if (proxyUrl.isValid() && !proxyUrl.host().isEmpty()) {
int proxyPort = (proxyUrl.port() > 0) ? proxyUrl.port() : 8080;
plist.push_back(QNetworkProxy(QNetworkProxy::HttpProxy, proxyUrl.host(), proxyPort));
}
plist.append(systemProxyForQuery(query));
return plist;
};
QNetworkProxy NetworkProxyDialog::createProxy(const QSettings &t_settings)
{
QNetworkProxy::ProxyType type = static_cast<QNetworkProxy::ProxyType>(t_settings.value("networkproxy_type", QNetworkProxy::NoProxy).toInt());
QString hostname = t_settings.value("networkproxy_hostname").toString();
int port = t_settings.value("networkproxy_port").toInt();
QString user = t_settings.value("networkproxy_user").toString();
return QNetworkProxy(type, hostname, port, user, "");
}
void WebPage::applyProxy()
{
QUrl proxyUrl(qgetenv("http_proxy"));
if (proxyUrl.isValid() && !proxyUrl.host().isEmpty()) {
int proxyPort = (proxyUrl.port() > 0) ? proxyUrl.port() : 8080;
networkAccessManager()->setProxy(QNetworkProxy(QNetworkProxy::HttpProxy, proxyUrl.host(), proxyPort));
}
}
QNetworkProxy ProgramSettings::getProxySettings(const ProgramSettings &programSettings)
{
if (programSettings.useProxy)
{
QString userName;
QString password;
if (programSettings.proxyRequiresAuthorization)
{
userName = programSettings.proxyUserName;
password = programSettings.proxyPassword;
}
return QNetworkProxy(programSettings.proxyType, programSettings.proxyHost, programSettings.getProxyPort(), userName, password);
}
else
return QNetworkProxy(QNetworkProxy::DefaultProxy);
}
void Composer::connectToHost(){
if(socket->state() != QAbstractSocket::ClosingState
&& socket->state() != QAbstractSocket::UnconnectedState){
qDebug()<<"already connected";
socket->abort();
}
socket->setProxy(QNetworkProxy(QNetworkProxy::HttpProxy,_proxyHost,_proxyPort));
socket->connectToHost(ui->server->text(),ui->port->text().toInt());
}
QList<QNetworkProxy> PackageManagerProxyFactory::queryProxy(const QNetworkProxyQuery &query)
{
const Settings &settings = m_core->settings();
QList<QNetworkProxy> list;
if (settings.proxyType() == Settings::SystemProxy) {
QList<QNetworkProxy> systemProxies = systemProxyForQuery(query);
auto proxyIter = systemProxies.begin();
for (; proxyIter != systemProxies.end(); ++proxyIter) {
QNetworkProxy &proxy = *proxyIter;
auto p = std::find_if(m_proxyCredentials.constBegin(), m_proxyCredentials.constEnd(),
FindProxyCredential(proxy.hostName(), proxy.port()));
if (p != m_proxyCredentials.constEnd()) {
proxy.setUser(p->user);
proxy.setPassword(p->password);
}
}
return systemProxies;
}
if ((settings.proxyType() == Settings::NoProxy))
return list << QNetworkProxy(QNetworkProxy::NoProxy);
if (query.queryType() == QNetworkProxyQuery::UrlRequest) {
QNetworkProxy proxy;
if (query.url().scheme() == QLatin1String("ftp")) {
proxy = settings.ftpProxy();
} else if (query.url().scheme() == QLatin1String("http")
|| query.url().scheme() == QLatin1String("https")) {
proxy = settings.httpProxy();
}
auto p = std::find_if(m_proxyCredentials.constBegin(), m_proxyCredentials.constEnd(),
FindProxyCredential(proxy.hostName(), proxy.port()));
if (p != m_proxyCredentials.constEnd()) {
proxy.setUser(p->user);
proxy.setPassword(p->password);
}
return list << proxy;
}
return list << QNetworkProxy(QNetworkProxy::DefaultProxy);
}
static QList<QNetworkProxy> parseServerList(const QNetworkProxyQuery &query, const QStringList &proxyList)
{
// Reference documentation from Microsoft:
// http://msdn.microsoft.com/en-us/library/aa383912(VS.85).aspx
//
// According to the website, the proxy server list is
// one or more of the space- or semicolon-separated strings in the format:
// ([<scheme>=][<scheme>"://"]<server>[":"<port>])
QList<QNetworkProxy> result;
foreach (const QString &entry, proxyList) {
int server = 0;
int pos = entry.indexOf(QLatin1Char('='));
if (pos != -1) {
QStringRef scheme = entry.leftRef(pos);
if (scheme != query.protocolTag())
continue;
server = pos + 1;
}
QNetworkProxy::ProxyType proxyType = QNetworkProxy::HttpProxy;
quint16 port = 8080;
pos = entry.indexOf(QLatin1String("://"), server);
if (pos != -1) {
QStringRef scheme = entry.midRef(server, pos - server);
if (scheme == QLatin1String("http") || scheme == QLatin1String("https")) {
// no-op
// defaults are above
} else if (scheme == QLatin1String("socks") || scheme == QLatin1String("socks5")) {
proxyType = QNetworkProxy::Socks5Proxy;
port = 1080;
} else {
// unknown proxy type
continue;
}
server = pos + 3;
}
pos = entry.indexOf(QLatin1Char(':'), server);
if (pos != -1) {
bool ok;
uint value = entry.mid(pos + 1).toUInt(&ok);
if (!ok || value > 65535)
continue; // invalid port number
port = value;
} else {
pos = entry.length();
}
result << QNetworkProxy(proxyType, entry.mid(server, pos - server), port);
}
QGeoMappingManagerEngineOsm::QGeoMappingManagerEngineOsm(const QMap<QString, QVariant> ¶meters, QGeoServiceProvider::Error *error, QString *errorString)
: QGeoTiledMappingManagerEngine(parameters),
m_parameters(parameters)
{
Q_UNUSED(error)
Q_UNUSED(errorString)
setTileSize(QSize(256,256));
setMinimumZoomLevel(0.0);
setMaximumZoomLevel(18.0);
m_tyleStyleId = "1";
QList<QGraphicsGeoMap::MapType> types;
types << QGraphicsGeoMap::StreetMap;
types << QGraphicsGeoMap::TerrainMap; // used for cyclemap
types << TRANSITMAP;
setSupportedMapTypes(types);
m_nam = new QNetworkAccessManager(this);
#ifdef USE_NETWORK_CACHE
m_cache = new QNetworkDiskCache(this);
QDir dir = QDir::temp();
dir.mkdir("maptiles-osm");
dir.cd("maptiles-osm");
m_cache->setCacheDirectory(dir.path());
#endif
QList<QString> keys = m_parameters.keys();
if (keys.contains("mapping.proxy")) {
QString proxy = m_parameters.value("mapping.proxy").toString();
if (!proxy.isEmpty())
m_nam->setProxy(QNetworkProxy(QNetworkProxy::HttpProxy, proxy, 8080));
}
#ifdef USE_NETWORK_CACHE
if (keys.contains("mapping.cache.directory")) {
QString cacheDir = m_parameters.value("mapping.cache.directory").toString();
if (!cacheDir.isEmpty())
m_cache->setCacheDirectory(cacheDir);
}
if (keys.contains("mapping.cache.size")) {
bool ok = false;
qint64 cacheSize = m_parameters.value("mapping.cache.size").toString().toLongLong(&ok);
if (ok)
m_cache->setMaximumCacheSize(cacheSize);
}
m_nam->setCache(m_cache);
#endif
}
int main(int argc, char**argv)
{
QCoreApplication app(argc, argv);
// create it
QAbstractSocketEngine *socketEngine =
QAbstractSocketEngine::createSocketEngine(QAbstractSocket::TcpSocket, QNetworkProxy(QNetworkProxy::NoProxy), 0);
if (!socketEngine) {
qDebug() << "could not create engine";
exit(1);
}
// initialize it
bool initialized = socketEngine->initialize(QAbstractSocket::TcpSocket, QAbstractSocket::IPv4Protocol);
if (!initialized) {
qDebug() << "not able to initialize engine";
exit(1);
}
// wait for connected
int r = socketEngine->connectToHost(QHostAddress("74.125.77.99"), 80); // google
bool readyToRead = false;
bool readyToWrite = false;
socketEngine->waitForReadOrWrite(&readyToRead, &readyToWrite, true, true, 10*1000);
if (r <= 0) //timeout or error
exit(1);
if (readyToWrite) {
// write the request
QByteArray request("GET /robots.txt HTTP/1.0\r\n\r\n");
int ret = socketEngine->write(request.constData(), request.length());
if (ret == request.length()) {
// read the response in a loop
do {
bool waitReadResult = socketEngine->waitForRead(10*1000);
int available = socketEngine->bytesAvailable();
if (waitReadResult == true && available == 0) {
// disconnected
exit(0);
}
qFill(buf, buf + bufsize, 0);
ret = socketEngine->read(buf, available);
if (ret > 0) {
printf("%s", buf);
} else {
// some failure when reading
exit(1);
}
} while (1);
} else {
qDebug() << "failed writing";
}
} else {
qDebug() << "failed connecting";
}
delete socketEngine;
}
void MainWindow::setProxy(const QString& host, int port, const QString& username, const QString& password)
{
if (m_https)
{
QNetworkProxy proxy = QNetworkProxy(QNetworkProxy::HttpProxy, host, port);
proxy.setUser(username);
proxy.setPassword(password);
m_https->setProxy(proxy);
}
}
NetworkAutomaticProxy::NetworkAutomaticProxy()
{
m_proxies.insert(QLatin1String("ERROR"), QList<QNetworkProxy>() << QNetworkProxy(QNetworkProxy::DefaultProxy));
m_proxies.insert(QLatin1String("DIRECT"), QList<QNetworkProxy>() << QNetworkProxy(QNetworkProxy::NoProxy));
m_engine.globalObject().setProperty(QLatin1String("alert"), m_engine.newFunction(alert));
m_engine.globalObject().setProperty(QLatin1String("shExpMatch"), m_engine.newFunction(shExpMatch));
m_engine.globalObject().setProperty(QLatin1String("dnsDomainIs"), m_engine.newFunction(dnsDomainIs));
m_engine.globalObject().setProperty(QLatin1String("isInNet"), m_engine.newFunction(isInNet));
m_engine.globalObject().setProperty(QLatin1String("myIpAddress"), m_engine.newFunction(myIpAddress));
m_engine.globalObject().setProperty(QLatin1String("dnsResolve"), m_engine.newFunction(dnsResolve));
m_engine.globalObject().setProperty(QLatin1String("isPlainHostName"), m_engine.newFunction(isPlainHostName));
m_engine.globalObject().setProperty(QLatin1String("isResolvable"), m_engine.newFunction(isResolvable));
m_engine.globalObject().setProperty(QLatin1String("localHostOrDomainIs"), m_engine.newFunction(localHostOrDomainIs));
m_engine.globalObject().setProperty(QLatin1String("dnsDomainLevels"), m_engine.newFunction(dnsDomainLevels));
m_engine.globalObject().setProperty(QLatin1String("weekdayRange"), m_engine.newFunction(weekdayRange));
m_engine.globalObject().setProperty(QLatin1String("dateRange"), m_engine.newFunction(dateRange));
m_engine.globalObject().setProperty(QLatin1String("timeRange"), m_engine.newFunction(timeRange));
}
void tst_QTcpServer::init()
{
QFETCH_GLOBAL(bool, setProxy);
if (setProxy) {
QFETCH_GLOBAL(int, proxyType);
if (proxyType == QNetworkProxy::Socks5Proxy) {
QNetworkProxy::setApplicationProxy(QNetworkProxy(QNetworkProxy::Socks5Proxy, QtNetworkSettings::serverName(), 1080));
}
}
}
void NetworkAccessManager::setProxy(const QString& proxyUrl)
{
QUrl url(proxyUrl);
QNetworkProxy::ProxyType type = QNetworkProxy::HttpProxy;
#ifdef U_NAM_DEBUG
qDebug() << Q_FUNC_INFO << "Setting proxy to: " << url.scheme() << url.host() << url.port();
#endif
if (url.scheme() == "socks5") type = QNetworkProxy::Socks5Proxy;
QNetworkAccessManager::setProxy(QNetworkProxy(type, url.host(), url.port(), url.userName(), url.password()));
}
void tst_QUdpSocket::init()
{
QFETCH_GLOBAL(bool, setProxy);
if (setProxy) {
#ifdef TEST_QNETWORK_PROXY
QFETCH_GLOBAL(int, proxyType);
if (proxyType == QNetworkProxy::Socks5Proxy) {
QNetworkProxy::setApplicationProxy(QNetworkProxy(QNetworkProxy::Socks5Proxy, QtNetworkSettings::serverName(), 1080));
}
#endif
}
}
void UpdateDialog::showOptionDialog(){
OptionsDialog i(this);
i.exec();
QSettings settings("config/updater.ini", QSettings::IniFormat);
QNetworkProxy p(QNetworkProxy::HttpProxy,settings.value("HTTP/address").toString(),settings.value("HTTP/port").toInt(),settings.value("HTTP/if").toString(),settings.value("HTTP/password").toString());
if(settings.value("CustomProxy",false).toBool()){
dl_manager.setProxy(p);
}else{
dl_manager.setProxy(QNetworkProxy(QNetworkProxy::DefaultProxy));
}
repositories_list = settings.value("repositories").toStringList();
}
bool DataModelGUI::updateMIRIAM(CMIRIAMResources & miriamResources)
{
bool success = true;
mpMiriamResources = &miriamResources;
QNetworkAccessManager *manager = new QNetworkAccessManager(this);
QString server = FROM_UTF8(CCopasiRootContainer::getConfiguration()->getProxyServer());
// if we have a proxy server use it
if (!server.isEmpty())
{
int port = CCopasiRootContainer::getConfiguration()->getProxyPort();
QString user = FROM_UTF8(CCopasiRootContainer::getConfiguration()->getProxyUser());
QString pass = FROM_UTF8(CCopasiRootContainer::getConfiguration()->getProxyPassword());
// if we have a username, but no password stored (which would be in clear text), then
// ask for password.
if (!user.isEmpty() && pass.isEmpty())
{
bool flag = false;
QString temp = QInputDialog::getText(
(QWidget*)((CQCopasiApplication*)qApp)->getMainWindow(),
QString("Enter proxy password"),
QString("You specified a proxy username, but no pasword, please enter the proxy password"),
QLineEdit::Password,
QString(""),
&flag
);
if (flag)
pass = temp;
}
manager->setProxy(QNetworkProxy(QNetworkProxy::HttpProxy, server, port, user, pass));
}
// start progress dialog
mpProgressBar = CProgressBar::create();
mpProgressBar->setName("MIRIAM Resources Update...");
mDownloadedBytes = 0; mDownloadedTotalBytes = 100;
mUpdateItem = ((CProcessReport*)mpProgressBar)->addItem("Download MIRIAM info", mDownloadedBytes, &mDownloadedTotalBytes);
connect(manager, SIGNAL(finished(QNetworkReply*)),
this, SLOT(miriamDownloadFinished(QNetworkReply*)));
QNetworkReply* reply = manager->get(QNetworkRequest(QUrl("http://www.ebi.ac.uk/miriam/main/export/xml/")));
connect(reply, SIGNAL(downloadProgress(qint64, qint64)),
this, SLOT(miriamDownloadProgress(qint64, qint64)));
return success;
}
