void DownloadThread::applyProxySettings() {
QNetworkProxy proxy;
const Preferences pref;
if (pref.isProxyEnabled()) {
// Proxy enabled
proxy.setHostName(pref.getProxyIp());
proxy.setPort(pref.getProxyPort());
// Default proxy type is HTTP, we must change if it is SOCKS5
const int proxy_type = pref.getProxyType();
if (proxy_type == Proxy::SOCKS5 || proxy_type == Proxy::SOCKS5_PW) {
qDebug() << Q_FUNC_INFO << "using SOCKS proxy";
proxy.setType(QNetworkProxy::Socks5Proxy);
} else {
qDebug() << Q_FUNC_INFO << "using HTTP proxy";
proxy.setType(QNetworkProxy::HttpProxy);
}
// Authentication?
if (pref.isProxyAuthEnabled()) {
qDebug("Proxy requires authentication, authenticating");
proxy.setUser(pref.getProxyUsername());
proxy.setPassword(pref.getProxyPassword());
}
} else {
proxy.setType(QNetworkProxy::NoProxy);
}
m_networkManager.setProxy(proxy);
}
QNetworkProxy AWebservice::defaultProxy (bool webkit)
{
QSettings settings;
QNetworkProxy proxy;
if (settings.value("proxy/enabled", false).toInt() != false)
{
if (webkit == true && settings.value("proxy/enabled_webkit", true).toInt() == false)
return proxy;
QString proxy_type = settings.value("proxy/type", "HTTP").toString();
if (proxy_type == "HTTP")
proxy.setType(QNetworkProxy::HttpCachingProxy);
else if (proxy_type == "SOCKS 5")
proxy.setType(QNetworkProxy::Socks5Proxy);
else if (proxy_type == "CONNECT")
proxy.setType(QNetworkProxy::HttpProxy);
else
proxy.setType(QNetworkProxy::DefaultProxy);
if (proxy.type() != QNetworkProxy::DefaultProxy)
{
proxy.setHostName (settings.value("proxy/host", "").toString());
proxy.setPort (settings.value("proxy/port", 0 ).toInt());
proxy.setUser (settings.value("proxy/login", "").toString());
proxy.setPassword (settings.value("proxy/password", "").toString());
}
}
return proxy;
}
void NetworkAccessManager::SetProxy(const QString& server, int Port, bool IsHttp, const QString& name, const QString& password, const QString& callback)
{
if(server.isEmpty() || Port<=0)
{
CaptureManager->setProxy(QNetworkProxy::NoProxy);
}else
{
QNetworkProxy proxy;
if(IsHttp)
{
proxy.setType(QNetworkProxy::HttpProxy);
}else
{
proxy.setType(QNetworkProxy::Socks5Proxy);
}
proxy.setHostName(server);
proxy.setPort(Port);
proxy.setUser(name);
proxy.setPassword(password);
CaptureManager->setProxy(proxy);
}
Worker->SetScript(callback);
Worker->RunSubScript();
}
void Logic::SetUp()
{
qDebug("SetUp begin");
settingObject = new QSettings("setting.ini",QSettings::IniFormat,0);
settingObject->beginGroup("Proxy");
if(settingObject->value("UseProxy","0").toString() == "1")
{
QNetworkProxy proxy;
proxy.setType(QNetworkProxy::HttpProxy);
proxy.setHostName(settingObject->value("ProxyServer","0").toString());
proxy.setPort(settingObject->value("ProxyPort","0").toInt());
proxy.setUser(settingObject->value("ProxyUserName","0").toString());
proxy.setPassword(settingObject->value("ProxyPassword","0").toString());
QNetworkProxy::setApplicationProxy(proxy);
}
// else
// {
// QNetworkProxy proxy;
// QNetworkProxy::setApplicationProxy(proxy);
// }
settingObject->endGroup();
settingObject->beginGroup("Message");
CountReceiveMessage = settingObject->value("CountMessage", "0").toInt();
qDebug("CountReceiveMessage: " + settingObject->value("CountMessage", "0").toString().toLatin1());
CountSentMessage = settingObject->value("CountSendMessage","0").toInt();
settingObject->endGroup();
qDebug("SetUp end");
}
void ThreadHandler::loadSettings() {
settings->beginGroup("options");
autoClose = settings->value("automatic_close", false).toBool();
maxDownloads = settings->value("concurrent_downloads", 1).toInt();
settings->endGroup();
settings->beginGroup("network");
QNetworkProxy proxy;
if (settings->value("use_proxy", false).toBool()) {
proxy.setType((QNetworkProxy::ProxyType)(settings->value("proxy_type", QNetworkProxy::HttpProxy).toInt()));
proxy.setHostName(settings->value("proxy_hostname", "").toString());
proxy.setPort(settings->value("proxy_port", 0).toUInt());
if (settings->value("proxy_auth", false).toBool()) {
proxy.setUser(settings->value("proxy_user", "").toString());
proxy.setPassword(settings->value("proxy_pass", "").toString());
}
}
else {
proxy.setType(QNetworkProxy::NoProxy);
}
QNetworkProxy::setApplicationProxy(proxy);
settings->endGroup();
}
Server::Server(QWidget *parent)
: QDialog(parent), tcpServer(0), networkSession(0)
{
tcpServer = new QTcpServer(this);
Configuration conf(QCoreApplication::applicationDirPath()+CONFIGURATION_PATH);
if(conf.integer("USE_PROXY") == 1){
QNetworkProxy proxy;
proxy.setType(QNetworkProxy::HttpProxy);
proxy.setHostName(conf.string("PROXY_HOST"));
proxy.setPort(conf.integer("PROXY_PORT"));
if(conf.string("PROXY_LOGIN")!="") proxy.setUser(conf.string("PROXY_LOGIN"));
if(conf.string("PROXY_PASSWORD")!="") proxy.setPassword(conf.string("PROXY_PASSWORD"));
tcpServer->setProxy(proxy);
}
if (!tcpServer->listen(QHostAddress::Any,11000)) {
qDebug(QString("Unable to start the server: "+tcpServer->errorString()+".").toLatin1());
return;
}
QString ipAddress;
qDebug(QString("The server is running on\n\nIP: "+ipAddress+"\nport: 11000").toLatin1());
messageSize = 0;
QObject::connect(tcpServer, SIGNAL(newConnection()), this, SLOT(newConnected()));
}
void settings::restore()
{
QSettings settings("saschawillems", "glcapsviewer");
submitterName = settings.value("global/submitterName", "").toString();
proxyDns = settings.value("proxy/dns", "").toString();
proxyPort = settings.value("proxy/port", "").toString();
proxyUserName = settings.value("proxy/user", "").toString();
proxyUserPassword = settings.value("proxy/password", "").toString();
proxyEnabled = settings.value("proxy/enabled", "").toBool();
// Apply proxy settings
if (proxyEnabled) {
QNetworkProxy proxy;
proxy.setType(QNetworkProxy::Socks5Proxy);
proxy.setHostName(proxyDns);
if (!proxyPort.isEmpty()) {
proxy.setPort(proxyPort.toInt());
}
else {
proxy.setPort(80);
}
proxy.setUser(proxyUserName);
proxy.setPassword(proxyUserPassword);
QNetworkProxy::setApplicationProxy(proxy);
}
else {
QNetworkProxy::setApplicationProxy(QNetworkProxy::NoProxy);
}
}
void NetworkAccessManager::loadSettings()
{
QSettings settings;
settings.beginGroup(QLatin1String("proxy"));
QNetworkProxy proxy;
if (settings.value(QLatin1String("enabled"), false).toBool()) {
if (settings.value(QLatin1String("type"), 0).toInt() == 0)
proxy.setType(QNetworkProxy::Socks5Proxy);
else
proxy.setType(QNetworkProxy::HttpProxy);
proxy.setHostName(settings.value(QLatin1String("hostName")).toString());
proxy.setPort(settings.value(QLatin1String("port"), 1080).toInt());
proxy.setUser(settings.value(QLatin1String("userName")).toString());
proxy.setPassword(settings.value(QLatin1String("password")).toString());
}
setProxy(proxy);
settings.endGroup();
#ifndef QT_NO_OPENSSL
QSslConfiguration sslCfg = QSslConfiguration::defaultConfiguration();
QList<QSslCertificate> ca_list = sslCfg.caCertificates();
QList<QSslCertificate> ca_new = QSslCertificate::fromData(settings.value(QLatin1String("CaCertificates")).toByteArray());
ca_list += ca_new;
sslCfg.setCaCertificates(ca_list);
QSslConfiguration::setDefaultConfiguration(sslCfg);
#endif
}
void KNetwork::loadSettings()
{
#if 1
QNetworkDiskCache *diskCache = new QNetworkDiskCache(this);
QString location = QDesktopServices::storageLocation(QDesktopServices::CacheLocation);
diskCache->setCacheDirectory(location);
setCache(diskCache);
#endif
QNetworkProxy proxy;
KDocument doc;
if (doc.openDocument(QDesktopServices::storageLocation(QDesktopServices::DataLocation) + "/" + ENGINE_CONFIG_FILE))
{
if (doc.getValue("kludget/network/enableProxy", "0").toInt() != 0)
{
QString host = doc.getValue("kludget/network/proxyHost", "");
QString port = "";
if (host.indexOf(":") != -1)
{
QStringList tmp = host.split(":");
host = tmp.at(0);
port = tmp.at(1);
}
proxy = QNetworkProxy::HttpProxy;
proxy.setHostName(host);
proxy.setPort(port.toInt());
proxy.setUser(doc.getValue("kludget/network/proxyUser", ""));
proxy.setPassword(Util::decrypt(doc.getValue("kludget/network/proxyPassword", "")));
}
}
setProxy(proxy);
}
void PBSystemTab::checkProxy()
{
bool ok;
int port;
// If no proxy set
if ( pcbsd::Utils::getProxyURL().isEmpty() )
return;
QNetworkProxy proxy;
if ( pcbsd::Utils::getProxyType() == "SOCKS5" )
proxy.setType(QNetworkProxy::Socks5Proxy);
else
proxy.setType(QNetworkProxy::HttpProxy);
proxy.setHostName(pcbsd::Utils::getProxyURL());
port = pcbsd::Utils::getProxyPort().toInt(&ok);
if ( ! pcbsd::Utils::getProxyPort().isEmpty() && ok )
proxy.setPort(port);
if ( ! pcbsd::Utils::getProxyUser().isEmpty() )
proxy.setUser(pcbsd::Utils::getProxyUser());
if ( ! pcbsd::Utils::getProxyPass().isEmpty() )
proxy.setPassword(pcbsd::Utils::getProxyPass());
QNetworkProxy::setApplicationProxy(proxy);
}
void QtMarbleConfigDialog::syncSettings()
{
d->m_settings.sync();
QNetworkProxy proxy;
// Make sure that no proxy is used for an empty string or the default value:
if ( proxyUrl().isEmpty() || proxyUrl() == "http://" ) {
proxy.setType( QNetworkProxy::NoProxy );
} else {
if ( proxyType() == Marble::Socks5Proxy ) {
proxy.setType( QNetworkProxy::Socks5Proxy );
}
else if ( proxyType() == Marble::HttpProxy ) {
proxy.setType( QNetworkProxy::HttpProxy );
}
else {
mDebug() << "Unknown proxy type! Using Http Proxy instead.";
proxy.setType( QNetworkProxy::HttpProxy );
}
}
proxy.setHostName( proxyUrl() );
proxy.setPort( proxyPort() );
if ( proxyAuth() ) {
proxy.setUser( proxyUser() );
proxy.setPassword( proxyPass() );
}
QNetworkProxy::setApplicationProxy(proxy);
}
void YafOAuth::authenticate()
{
if(!m_view)
{
initializeWebView();
}
GeneralSettings generalSettings;
WebMounter::getSettingStorage()->getData(generalSettings);
if(generalSettings.m_proxyAddress.length())
{
QNetworkProxy proxy;
proxy.setType(QNetworkProxy::HttpProxy);
proxy.setHostName(generalSettings.m_proxyAddress.left(generalSettings.m_proxyAddress.lastIndexOf(":")));
QString portStr = generalSettings.m_proxyAddress.right(generalSettings.m_proxyAddress.length() - generalSettings.m_proxyAddress.lastIndexOf(":")-1);
proxy.setPort(portStr.toInt());
proxy.setUser(generalSettings.m_proxyLogin);
proxy.setPassword(generalSettings.m_proxyPassword);
m_view->page()->networkAccessManager()->setProxy(proxy);
}
m_view->load(QUrl("https://oauth.yandex.ru/authorize?response_type=token&client_id=e56c86e3da064686bbac48edbfb00fae"));
m_view->show();
//if (!_oAuthTimer->isActive())
// _oAuthTimer->start(20*1000);
}
void BrowserApplication::loadSettings()
{
QSettings settings;
settings.beginGroup(QLatin1String("websettings"));
QWebEngineSettings *defaultSettings = QWebEngineSettings::globalSettings();
QWebEngineProfile *defaultProfile = QWebEngineProfile::defaultProfile();
QString standardFontFamily = defaultSettings->fontFamily(QWebEngineSettings::StandardFont);
int standardFontSize = defaultSettings->fontSize(QWebEngineSettings::DefaultFontSize);
QFont standardFont = QFont(standardFontFamily, standardFontSize);
standardFont = qvariant_cast<QFont>(settings.value(QLatin1String("standardFont"), standardFont));
defaultSettings->setFontFamily(QWebEngineSettings::StandardFont, standardFont.family());
defaultSettings->setFontSize(QWebEngineSettings::DefaultFontSize, standardFont.pointSize());
QString fixedFontFamily = defaultSettings->fontFamily(QWebEngineSettings::FixedFont);
int fixedFontSize = defaultSettings->fontSize(QWebEngineSettings::DefaultFixedFontSize);
QFont fixedFont = QFont(fixedFontFamily, fixedFontSize);
fixedFont = qvariant_cast<QFont>(settings.value(QLatin1String("fixedFont"), fixedFont));
defaultSettings->setFontFamily(QWebEngineSettings::FixedFont, fixedFont.family());
defaultSettings->setFontSize(QWebEngineSettings::DefaultFixedFontSize, fixedFont.pointSize());
defaultSettings->setAttribute(QWebEngineSettings::JavascriptEnabled, settings.value(QLatin1String("enableJavascript"), true).toBool());
defaultSettings->setAttribute(QWebEngineSettings::ScrollAnimatorEnabled, settings.value(QLatin1String("enableScrollAnimator"), true).toBool());
defaultSettings->setAttribute(QWebEngineSettings::PluginsEnabled, settings.value(QLatin1String("enablePlugins"), true).toBool());
defaultSettings->setAttribute(QWebEngineSettings::FullScreenSupportEnabled, true);
if (! sawStyleSheetCommandLineOption) {
m_stylesheetFilename = settings.value(QLatin1String("userStyleSheetFile")).toString();
m_stylesheetRules = settings.value(QLatin1String("userStyleSheetRules")).toString();
emit reloadStyleSheet();
}
if (! m_stylesheetFilename.isEmpty()) {
m_fileSystemWatcher->addPath(m_stylesheetFilename);
connect(m_fileSystemWatcher, &QFileSystemWatcher::fileChanged,
this, &BrowserApplication::reloadStylesheet);
}
defaultProfile->setHttpUserAgent(settings.value(QLatin1String("httpUserAgent")).toString());
defaultProfile->setHttpAcceptLanguage(settings.value(QLatin1String("httpAcceptLanguage")).toString());
settings.endGroup();
settings.beginGroup(QLatin1String("proxy"));
QNetworkProxy proxy;
if (settings.value(QLatin1String("enabled"), false).toBool()) {
if (settings.value(QLatin1String("type"), 0).toInt() == 0)
proxy = QNetworkProxy::Socks5Proxy;
else
proxy = QNetworkProxy::HttpProxy;
proxy.setHostName(settings.value(QLatin1String("hostName")).toString());
proxy.setPort(settings.value(QLatin1String("port"), 1080).toInt());
proxy.setUser(settings.value(QLatin1String("userName")).toString());
proxy.setPassword(settings.value(QLatin1String("password")).toString());
}
QNetworkProxy::setApplicationProxy(proxy);
settings.endGroup();
}
static QNetworkProxy SetProxy(int type, QString host, unsigned int port, QString name, QString pass)
{
QNetworkProxy proxy;
switch (type)
{
case 0:
QNetworkProxy::setApplicationProxy(QNetworkProxy::NoProxy);
return proxy;
case 1:
proxy.setType(QNetworkProxy::Socks5Proxy);
break;
case 2:
proxy.setType(QNetworkProxy::HttpProxy);
break;
case 3:
proxy.setType(QNetworkProxy::HttpCachingProxy);
break;
case 4:
proxy.setType(QNetworkProxy::FtpCachingProxy);
break;
default:
return proxy;
}
proxy.setHostName(host);
proxy.setPort(port);
proxy.setUser(name);
proxy.setPassword(pass);
QNetworkProxy::setApplicationProxy(proxy);
return proxy;
}
void Net::DownloadManager::applyProxySettings()
{
const auto *proxyManager = ProxyConfigurationManager::instance();
const ProxyConfiguration proxyConfig = proxyManager->proxyConfiguration();
QNetworkProxy proxy;
if (!proxyManager->isProxyOnlyForTorrents() && (proxyConfig.type != ProxyType::None)) {
// Proxy enabled
proxy.setHostName(proxyConfig.ip);
proxy.setPort(proxyConfig.port);
// Default proxy type is HTTP, we must change if it is SOCKS5
if ((proxyConfig.type == ProxyType::SOCKS5) || (proxyConfig.type == ProxyType::SOCKS5_PW)) {
qDebug() << Q_FUNC_INFO << "using SOCKS proxy";
proxy.setType(QNetworkProxy::Socks5Proxy);
}
else {
qDebug() << Q_FUNC_INFO << "using HTTP proxy";
proxy.setType(QNetworkProxy::HttpProxy);
}
// Authentication?
if (proxyManager->isAuthenticationRequired()) {
qDebug("Proxy requires authentication, authenticating...");
proxy.setUser(proxyConfig.username);
proxy.setPassword(proxyConfig.password);
}
}
else {
proxy.setType(QNetworkProxy::NoProxy);
}
m_networkManager.setProxy(proxy);
}
bool connection::getProxy()
{
bool success = true;
//QSettings settings(QSettings::defaultFormat(), QSettings::UserScope, "qutim/qutim."+m_profile_name, "icqsettings");
QSettings settings(QSettings::defaultFormat(), QSettings::UserScope, "qutim/qutim."+m_profile_name+"/ICQ."+icqUin, "accountsettings");
if ( settings.value("connection/useproxy", false).toBool() )
{
quint16 proxyType = settings.value("proxy/proxyType", 0).toInt();
if ( proxyType )
{
QNetworkProxy connectionProxy;
switch( proxyType )
{
case 1:
connectionProxy.setType(QNetworkProxy::HttpProxy);
break;
case 2:
connectionProxy.setType(QNetworkProxy::Socks5Proxy);
break;
default:
break;
}
QString hostN = settings.value("proxy/host").toString();
QHostAddress addr(hostN);
if ( addr.isNull() )
{
success = false;
QHostInfo::lookupHost(hostN, const_cast<connection*>(this), SLOT(dnsResults(QHostInfo)));
}
connectionProxy.setHostName(hostN);
connectionProxy.setPort(settings.value("proxy/port", 1).toInt());
if ( settings.value("proxy/auth", false).toBool() )
{
connectionProxy.setUser(settings.value("proxy/user").toString());
connectionProxy.setPassword(settings.value("proxy/pass").toString());
}
setCurrentProxy(connectionProxy);
// currentProxy.setType(connectionProxy.type());
// currentProxy.setHostName(connectionProxy.hostName());
// currentProxy.setHostName("gggg");
// currentProxy.setPort(connectionProxy.port());
// currentProxy.setUser(connectionProxy.user());
// currentProxy.setPassword(connectionProxy.password());
}
// else {
// currentProxy.setType(QNetworkProxy::HttpCachingProxy);
// }
}
// currentProxy.setType(QNetworkProxy::NoProxy);
return success;
}
QList<QNetworkProxy> NetworkProxyFactory::queryProxy(
const QNetworkProxyQuery& query) {
QMutexLocker l(&mutex_);
QNetworkProxy ret;
switch (mode_) {
case Mode_System:
#ifdef Q_OS_LINUX
Q_UNUSED(query);
if (env_url_.isEmpty()) {
ret.setType(QNetworkProxy::NoProxy);
} else {
ret.setHostName(env_url_.host());
ret.setPort(env_url_.port());
ret.setUser(env_url_.userName());
ret.setPassword(env_url_.password());
if (env_url_.scheme().startsWith("http"))
ret.setType(QNetworkProxy::HttpProxy);
else
ret.setType(QNetworkProxy::Socks5Proxy);
qLog(Debug) << "Using proxy URL:" << env_url_;
}
break;
#else
return systemProxyForQuery(query);
#endif
case Mode_Direct:
ret.setType(QNetworkProxy::NoProxy);
break;
case Mode_Manual:
ret.setType(type_);
ret.setHostName(hostname_);
ret.setPort(port_);
if (use_authentication_) {
ret.setUser(username_);
ret.setPassword(password_);
}
break;
}
return QList<QNetworkProxy>() << ret;
}
void NetworkConfig::SetupProxy() {
QNetworkProxy proxy;
proxy.setType(local_to_qt_proxy(g.s.ptProxyType));
proxy.setHostName(g.s.qsProxyHost);
proxy.setPort(g.s.usProxyPort);
proxy.setUser(g.s.qsProxyUsername);
proxy.setPassword(g.s.qsProxyPassword);
QNetworkProxy::setApplicationProxy(proxy);
}
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);
}
}
void load()
{
QNetworkProxy proxy;
proxy.setType((QNetworkProxy::ProxyType)Config::getValue<int>("/Network/Proxy/Type", QNetworkProxy::NoProxy));
proxy.setHostName(Config::getValue<QString>("/Network/Proxy/HostName"));
proxy.setPort(Config::getValue<quint16>("/Network/Proxy/Port"));
proxy.setUser(Config::getValue<QString>("/Network/Proxy/User"));
proxy.setPassword(Config::getValue<QString>("/Network/Proxy/Password"));
QNetworkProxy::setApplicationProxy(proxy);
}
void Utility::setApplicationProxy(int type, QString location, QString port, QString username, QString password)
{
QNetworkProxy proxy;
proxy.setType((QNetworkProxy::ProxyType)type);
proxy.setHostName(location);
proxy.setPort(port.toUShort ());
proxy.setUser (username);
proxy.setPassword (password);
QNetworkProxy::setApplicationProxy(proxy);
}
void NetworkAccessManager::loadSettings()
{
QSettings settings;
settings.beginGroup(QLatin1String("proxy"));
QNetworkProxy proxy;
if (settings.value(QLatin1String("enabled"), false).toBool()) {
int proxyType = settings.value(QLatin1String("type"), 0).toInt();
if (proxyType == 0)
proxy = QNetworkProxy::Socks5Proxy;
else if (proxyType == 1)
proxy = QNetworkProxy::HttpProxy;
else { // 2
proxy.setType(QNetworkProxy::HttpCachingProxy);
#if QT_VERSION >= 0x040500
proxy.setCapabilities(QNetworkProxy::CachingCapability | QNetworkProxy::HostNameLookupCapability);
#endif
}
proxy.setHostName(settings.value(QLatin1String("hostName")).toString());
proxy.setPort(settings.value(QLatin1String("port"), 1080).toInt());
proxy.setUser(settings.value(QLatin1String("userName")).toString());
proxy.setPassword(settings.value(QLatin1String("password")).toString());
}
#if QT_VERSION >= 0x040500
NetworkProxyFactory *proxyFactory = new NetworkProxyFactory;
if (proxy.type() == QNetworkProxy::HttpCachingProxy) {
proxyFactory->setHttpProxy(proxy);
proxyFactory->setGlobalProxy(QNetworkProxy::DefaultProxy);
} else {
proxyFactory->setHttpProxy(QNetworkProxy::DefaultProxy);
proxyFactory->setGlobalProxy(proxy);
}
setProxyFactory(proxyFactory);
#else
setProxy(proxy);
#endif
settings.endGroup();
#ifndef QT_NO_OPENSSL
QSslConfiguration sslCfg = QSslConfiguration::defaultConfiguration();
QList<QSslCertificate> ca_list = sslCfg.caCertificates();
QList<QSslCertificate> ca_new = QSslCertificate::fromData(settings.value(QLatin1String("CaCertificates")).toByteArray());
ca_list += ca_new;
sslCfg.setCaCertificates(ca_list);
QSslConfiguration::setDefaultConfiguration(sslCfg);
#endif
settings.beginGroup(QLatin1String("network"));
QStringList acceptList = settings.value(QLatin1String("acceptLanguages"),
AcceptLanguageDialog::defaultAcceptList()).toStringList();
acceptLanguage = AcceptLanguageDialog::httpString(acceptList);
settings.endGroup();
}
void ignnetwork::setProxy(const QVariant &config){
/* json parsing */
QJsonParseError *err = new QJsonParseError();
QJsonDocument json = QJsonDocument::fromVariant(config);
if (err->error != 0) {
qDebug() << err->errorString();
exit (1);
}
QJsonObject jObject = json.object();
QVariantMap set_proxy = jObject.toVariantMap();
if(set_proxy["type"].toString() != ""){
QNetworkProxy proxy;
QString proxy_type = set_proxy["type"].toString();
if(proxy_type == "http"){
proxy.setType(QNetworkProxy::HttpProxy);
}
else if(proxy_type == "socks5"){
proxy.setType(QNetworkProxy::Socks5Proxy);
}
else if(proxy_type == "ftp"){
proxy.setType(QNetworkProxy::FtpCachingProxy);
}
else if(proxy_type == "httpCaching"){
proxy.setType(QNetworkProxy::HttpCachingProxy);
}
else{
qDebug()<<"Please input your type proxy (http,socks5,ftp,httpCaching)!";
}
if(set_proxy["url"].toString() != ""){
QString url = set_proxy["url"].toString();
QStringList url_proxy = url.split(":");
proxy.setHostName(url_proxy.at(0));
proxy.setPort(url_proxy.at(1).toInt());
}
else{
qDebug()<<"Please input your hostname:port Ex: 127.0.0.1:8080!";
}
if(set_proxy["username"].toString() != ""){
proxy.setUser(set_proxy["username"].toString());
}
if(set_proxy["password"].toString() != ""){
proxy.setPassword(set_proxy["password"].toString());
}
QNetworkProxy::setApplicationProxy(proxy);
}
}
void proxyDialog::slot_ok()
{
QNetworkProxy proxy;
proxy.setUser(ui->user->text());
proxy.setPort(ui->port->text().toInt());
proxy.setPassword(ui->password->text());
proxy.setHostName(ui->name->text());
proxy.setType((QNetworkProxy::ProxyType)ui->type->currentIndex());
emit data_ok(proxy);
hide();
}
EventHandler::EventHandler(AbstractPluginSession *ps, MClientPlugin *mp)
: MClientEventHandler(ps, mp) {
_socketReader = new SocketReader(ps->session(), this);
QString cfg = QString("config/");
// Host settings
QString host = _config->value(cfg+"connection/host", "mume.org").toString();
int port = _config->value(cfg+"connection/port", "23").toInt();
_autoConnect = _config->value(cfg+"connection/autoconnect", true).toBool();
// Proxy settings
QString proxy_host = _config->value(cfg+"proxy/host",
"proxy.example.com").toString();
int proxy_port = _config->value(cfg+"proxy/port", "0").toInt();
QString proxy_user = _config->value(cfg+"proxy/proxy_user",
"").toString();
QString proxy_pass = _config->value(cfg+"proxy/proxy_pass",
"").toString();
if(proxy_port != 0 && !proxy_host.isEmpty()) {
QNetworkProxy* proxy = new QNetworkProxy();
//proxy->setType(QNetworkProxy::Socks5Proxy);
proxy->setHostName(proxy_host);
proxy->setPort(proxy_port);
proxy->setUser(proxy_user);
proxy->setPassword(proxy_pass);
_socketReader->proxy(proxy);
qDebug() << "* added proxy" << proxy_host << proxy_port
<< "to SocketReader";
}
_socketReader->host(host);
_socketReader->port(port);
// Signals and slots
connect(this, SIGNAL(connectToHost()), _socketReader, SLOT(connectToHost()));
connect(this, SIGNAL(closeSocket()), _socketReader, SLOT(closeSocket()));
connect(this, SIGNAL(sendToSocket(const QByteArray &)),
_socketReader, SLOT(sendToSocket(const QByteArray &)));
connect(_socketReader, SIGNAL(socketReadData(const QByteArray &)),
SLOT(socketReadData(const QByteArray &)));
connect(_socketReader, SIGNAL(displayMessage(const QString &)),
SLOT(displayMessage(const QString &)));
connect(_socketReader, SIGNAL(socketOpened()),
SLOT(socketOpened()));
connect(_socketReader, SIGNAL(socketClosed()),
SLOT(socketClosed()));
}
bool SeimiServerHandler::handleRequest(Pillow::HttpConnection *connection){
QString method = connection->requestMethod();
QString path = connection->requestPath();
if(method == "GET"){
connection->writeResponse(405, Pillow::HttpHeaderCollection(),"Method 'GET' is not supprot,please use 'POST'");
return true;
}
if(path != "/doload"){
return false;
}
QEventLoop eventLoop;
SeimiPage *seimiPage=new SeimiPage(this);
QString url = connection->requestParamValue(urlP);
int renderTime = connection->requestParamValue(renderTimeP).toInt();
QString proxyStr = connection->requestParamValue(proxyP);
if(!proxyStr.isEmpty()){
QRegularExpression re("(?<protocol>http|https|socket)://(?:(?<user>\\w*):(?<password>\\w*)@)?(?<host>[\\w.]+)(:(?<port>\\d+))?");
QRegularExpressionMatch match = re.match(proxyStr);
if(match.hasMatch()){
QNetworkProxy proxy;
if(match.captured("protocol") == "socket"){
proxy.setType(QNetworkProxy::Socks5Proxy);
}else{
proxy.setType(QNetworkProxy::HttpProxy);
}
proxy.setHostName(match.captured("host"));
proxy.setPort(match.captured("port").toInt()==0?80:match.captured("port").toInt());
proxy.setUser(match.captured("user"));
proxy.setPassword(match.captured("password"));
seimiPage->setProxy(proxy);
}else {
qWarning("[seimi] proxy pattern error, proxy = %s",proxyStr.toUtf8().constData());
}
}
QString jscript = connection->requestParamValue(scriptP);
QString postParamJson = connection->requestParamValue(postParamP);
seimiPage->setScript(jscript);
seimiPage->setPostParam(postParamJson);
qInfo("[seimi] TargetUrl:%s ,RenderTime(ms):%d",url.toUtf8().constData(),renderTime);
int useCookieFlag = connection->requestParamValue(useCookieP).toInt();
seimiPage->setUseCookie(useCookieFlag==1);
QObject::connect(seimiPage,SIGNAL(loadOver()),&eventLoop,SLOT(quit()));
seimiPage->toLoad(url,renderTime);
eventLoop.exec();
Pillow::HttpHeaderCollection headers;
headers << Pillow::HttpHeader("Content-Type", "text/html;charset=utf-8");
connection->writeResponse(200, headers,seimiPage->getContent().toUtf8());
seimiPage->deleteLater();
return true;
}
void NetworkAccessManager::loadSettings()
{
if (is_proxy_)
{
return;
}
if (proxy_manager_ != 0)
{
proxy_manager_.reset();
}
if (proxy_exceptions_ != 0)
{
proxy_exceptions_.reset();
}
QSettings settings;
settings.beginGroup(QLatin1String("proxy"));
QNetworkProxy proxy;
if (settings.value(QLatin1String("enabled"), false).toBool())
{
if (settings.value(QLatin1String("type"), 0).toInt() == 0)
{
proxy = QNetworkProxy::Socks5Proxy;
}
else
{
proxy = QNetworkProxy::HttpProxy;
}
proxy.setHostName(settings.value(QLatin1String("hostName")).toString());
proxy.setPort(settings.value(QLatin1String("port"), 1080).toInt());
proxy.setUser(settings.value(QLatin1String("userName")).toString());
proxy.setPassword(settings.value(QLatin1String("password")).toString());
if (settings.value(QLatin1String("useExceptions"), false).toBool())
{
proxy_exceptions_.reset(new QStringList);
QString exc = settings.value(QLatin1String("Exceptions")).toString();
QStringList list = exc.split(QChar(';'));
foreach(QString str, list)
{
*proxy_exceptions_ << str.trimmed();
}
}
use_proxy_ = true;
proxy_manager_.reset(new NetworkAccessManager(0, true));
proxy_manager_->setCookieJar(new CookieJar);
proxy_manager_->setProxy(proxy);
}
QNetworkProxy ClientProxy::proxyFromConfig(const MirallConfigFile& cfg)
{
QNetworkProxy proxy;
if (cfg.proxyHostName().isEmpty())
return QNetworkProxy();
proxy.setHostName(cfg.proxyHostName());
proxy.setPort(cfg.proxyPort());
if (cfg.proxyNeedsAuth()) {
proxy.setUser(cfg.proxyUser());
proxy.setPassword(cfg.proxyPassword());
}
return proxy;
}
void CMainWindow::setProxy(const rho::String& host, const rho::String& port, const rho::String& login, const rho::String& password)
{
if (host.length()) {
QNetworkProxy proxy;
proxy.setType(QNetworkProxy::HttpCachingProxy);
proxy.setHostName(host.c_str());
if (port.length())
proxy.setPort(atoi(port.c_str()));
if (login.length())
proxy.setUser(login.c_str());
if (password.length())
proxy.setPassword(password.c_str());
CRhodesProxyFactory::getInstance()->setProxy(proxy);
}
}
void CWizXmlRpcServer::setProxy(const QString& host, int port, const QString& userName, const QString& password)
{
QNetworkProxy proxy = m_network->proxy();
if (host.isEmpty()) {
proxy.setType(QNetworkProxy::DefaultProxy);
} else {
proxy.setHostName(host);
proxy.setPort(port);
proxy.setUser(userName);
proxy.setPassword(password);
proxy.setType(QNetworkProxy::HttpProxy);
}
m_network->setProxy(proxy);
}
