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 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();
}
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::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
}
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 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 ClientProxy::setupQtProxyFromConfig()
{
Mirall::MirallConfigFile cfg;
int proxyType = QNetworkProxy::DefaultProxy;
QNetworkProxy proxy;
// if there is no config file, default to system proxy.
if( cfg.exists() ) {
proxyType = cfg.proxyType();
proxy = proxyFromConfig(cfg);
}
switch(proxyType) {
case QNetworkProxy::NoProxy:
QNetworkProxyFactory::setUseSystemConfiguration(false);
QNetworkProxy::setApplicationProxy(QNetworkProxy::NoProxy);
break;
case QNetworkProxy::DefaultProxy:
QNetworkProxyFactory::setUseSystemConfiguration(true);
break;
case QNetworkProxy::Socks5Proxy:
proxy.setType(QNetworkProxy::Socks5Proxy);
QNetworkProxyFactory::setUseSystemConfiguration(false);
QNetworkProxy::setApplicationProxy(proxy);
break;
case QNetworkProxy::HttpProxy:
proxy.setType(QNetworkProxy::HttpProxy);
QNetworkProxyFactory::setUseSystemConfiguration(false);
QNetworkProxy::setApplicationProxy(proxy);
break;
default:
break;
}
}
bool OptionsModel::getProxySettings(QNetworkProxy& proxy) const
{
// Directly query current base proxy, because
// GUI settings can be overridden with -proxy.
proxyType curProxy;
if (GetProxy(NET_IPV4, curProxy)) {
if (curProxy.second == 5) {
proxy.setType(QNetworkProxy::Socks5Proxy);
proxy.setHostName(QString::fromStdString(curProxy.first.ToStringIP()));
proxy.setPort(curProxy.first.GetPort());
return true;
}
else
return false;
}
else
proxy.setType(QNetworkProxy::NoProxy);
return true;
}
void HTTPTransport::setProperty( const QString& aProperty, const QString& aValue )
{
FUNCTION_CALL_TRACE;
if( aProperty == HTTPNUMBEROFRESENDATTEMPTSPROP )
{
LOG_DEBUG( "Setting property" << aProperty <<":" << aValue );
iMaxNumberOfResendAttempts = aValue.toInt();
}
else if( aProperty == HTTPPROXYHOSTPROP )
{
LOG_DEBUG( "Setting property" << aProperty <<":" << aValue );
QNetworkProxy proxy = iManager->proxy();
proxy.setType( QNetworkProxy::HttpProxy );
proxy.setHostName(aValue);
iManager->setProxy(proxy);
}
else if( aProperty == HTTPPROXYPORTPROP )
{
LOG_DEBUG( "Setting property" << aProperty <<":" << aValue );
QNetworkProxy proxy = iManager->proxy();
proxy.setType( QNetworkProxy::HttpProxy );
proxy.setPort( aValue.toInt() );
iManager->setProxy(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 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);
}
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;
}
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);
}
}
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
UrlFactory::_tryCorrectGoogleVersions(QNetworkAccessManager* networkManager)
{
QMutexLocker locker(&_googleVersionMutex);
if (_googleVersionRetrieved) {
return;
}
_googleVersionRetrieved = true;
if(networkManager)
{
QNetworkRequest qheader;
QNetworkProxy proxy = networkManager->proxy();
QNetworkProxy tProxy;
tProxy.setType(QNetworkProxy::DefaultProxy);
networkManager->setProxy(tProxy);
QSslConfiguration conf = qheader.sslConfiguration();
conf.setPeerVerifyMode(QSslSocket::VerifyNone);
qheader.setSslConfiguration(conf);
QString url = "http://maps.google.com/maps/api/js?v=3.2&sensor=false";
qheader.setUrl(QUrl(url));
QByteArray ua;
ua.append(getQGCMapEngine()->userAgent());
qheader.setRawHeader("User-Agent", ua);
_googleReply = networkManager->get(qheader);
connect(_googleReply, &QNetworkReply::finished, this, &UrlFactory::_googleVersionCompleted);
connect(_googleReply, &QNetworkReply::destroyed, this, &UrlFactory::_replyDestroyed);
connect(_googleReply, static_cast<void (QNetworkReply::*)(QNetworkReply::NetworkError)>(&QNetworkReply::error),
this, &UrlFactory::_networkReplyError);
networkManager->setProxy(proxy);
}
}
bool QHttpSocketEngine::initialize(QAbstractSocket::SocketType type, QAbstractSocket::NetworkLayerProtocol protocol)
{
Q_D(QHttpSocketEngine);
if (type != QAbstractSocket::TcpSocket)
return false;
setProtocol(protocol);
setSocketType(type);
d->socket = new QTcpSocket(this);
// Explicitly disable proxying on the proxy socket itself to avoid
// unwanted recursion.
QNetworkProxy proxy;
proxy.setType(QNetworkProxy::NoProxy);
d->socket->setProxy(proxy);
// Intercept all the signals.
connect(d->socket, SIGNAL(connected()),
this, SLOT(slotSocketConnected()));
connect(d->socket, SIGNAL(disconnected()),
this, SLOT(slotSocketDisconnected()));
connect(d->socket, SIGNAL(readyRead()),
this, SLOT(slotSocketReadNotification()));
connect(d->socket, SIGNAL(readyRead()),
this, SLOT(slotSocketReadNotification()));
connect(d->socket, SIGNAL(bytesWritten(qint64)),
this, SLOT(slotSocketBytesWritten()));
connect(d->socket, SIGNAL(error(QAbstractSocket::SocketError)),
this, SLOT(slotSocketError(QAbstractSocket::SocketError)));
connect(d->socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)),
this, SLOT(slotSocketStateChanged(QAbstractSocket::SocketState)));
return true;
}
static void setupNetwork(GlobalSettings *settings)
{
QNetworkProxy proxy;
if (settings->isEnabled(GlobalSettings::Proxy)) {
QString proxyHost(settings->value(GlobalSettings::ProxyHost).toString());
int proxyPort = settings->value(GlobalSettings::ProxyPort).toInt();
proxy.setType(QNetworkProxy::HttpProxy);
proxy.setHostName(proxyHost);
proxy.setPort(proxyPort);
QNetworkProxy::setApplicationProxy(proxy);
qWarning() << "Using proxy host" << proxyHost << "on port" << proxyPort;
}
// Set Internet Access Point
QNetworkConfigurationManager mgr;
QList<QNetworkConfiguration> activeConfigs = mgr.allConfigurations();
if (activeConfigs.count() <= 0)
return;
QNetworkConfiguration cfg = activeConfigs.at(0);
foreach(QNetworkConfiguration config, activeConfigs) {
if (config.type() == QNetworkConfiguration::UserChoice) {
cfg = config;
break;
}
}
g_networkSession = new QNetworkSession(cfg);
g_networkSession->open();
g_networkSession->waitForOpened(-1);
}
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 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);
}
void MainWindow::on_loadVaaigaAtulau_settings(){
QSettings thisappsettin("SFMSLDevelopement","VaaigaAtulau");
thisappsettin.beginGroup("VaaigaAtulauSettings");
QString HomeURL = thisappsettin.value("homeUrl").toString();
QString ProxyServerUse = thisappsettin.value("ProxyServer").toString();
QString ProxyTypeUse = thisappsettin.value("ProxyType").toString();
int Enableproxy = thisappsettin.value("EnableProxy").toInt();
int ProxyPortUse = thisappsettin.value("ProxyPort").toInt();
thisappsettin.endGroup();
MainWindow::HomeUrlSettingValue.append(HomeURL);
if(Enableproxy == 1){
sockproxy.setHostName(ProxyServerUse);
sockproxy.setPort(ProxyPortUse);
}
if (QString::compare(ProxyTypeUse,"sock5")){
sockproxy.setType(QNetworkProxy::Socks5Proxy);
QNetworkProxy::setApplicationProxy(sockproxy);
}
}
void NetworkAccessManager::load()
{
m_cookieJar->load();
QString path = QDesktopServices::storageLocation(QDesktopServices::DataLocation) + "/";
QDir dir;
if(!dir.mkpath(path))
{
return;
}
QFile file(path + "trustedDomains");
if(!file.open(QIODevice::ReadOnly))
{
return;
}
QByteArray array;
while(!(array = file.readLine()).isEmpty())
{
QString urlString = QString::fromUtf8(array.data()).trimmed();
addTrustedDomain(QUrl(urlString));
}
file.close();
//YEW
QNetworkProxy proxy;
proxy.setType(QNetworkProxy::HttpProxy);
proxy.setHostName("10.39.100.2");
proxy.setPort(8080);
this->setProxy(proxy);
}
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()));
}
MultipleBotConnection::CatchChallengerClient * MultipleBotConnection::createClient()
{
if(haveEnError)
{
connectTimer.stop();
return NULL;
}
CatchChallengerClient * client=new CatchChallengerClient;
QSslSocket *sslSocket=new QSslSocket();
QNetworkProxy proxyObject;
if(!proxy().isEmpty())
{
proxyObject.setType(QNetworkProxy::Socks5Proxy);
proxyObject.setHostName(proxy());
proxyObject.setPort(proxyport());
sslSocket->setProxy(proxyObject);
}
client->sslSocket=sslSocket;
sslSocketToCatchChallengerClient[client->sslSocket]=client;
client->socket=new CatchChallenger::ConnectedSocket(client->sslSocket);
client->api=new CatchChallenger::Api_client_real(client->socket,false);
if(!connect(sslSocket,static_cast<void(QSslSocket::*)(const QList<QSslError> &errors)>(&QSslSocket::sslErrors),this,&MultipleBotConnection::sslErrors,Qt::QueuedConnection))
abort();
if(!connect(sslSocket,static_cast<void(QSslSocket::*)(QAbstractSocket::SocketError)>(&QSslSocket::error),this,&MultipleBotConnection::newSocketError))
abort();
sslSocket->connectToHost(host(),port());
connectTheExternalSocket(client);
return client;
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QApplication::setOrganizationName("K0l40a");
QApplication::setApplicationName("wlan-navi");
QSettings settings;
QVariant value = settings.value("http.proxy");
if (value.isValid()) {
QUrl url(value.toString(), QUrl::TolerantMode);
QNetworkProxy proxy;
proxy.setType(QNetworkProxy::HttpProxy);
proxy.setHostName(url.host());
proxy.setPort(url.port(8080));
QNetworkProxy::setApplicationProxy(proxy);
}
MainWindow mw;
mw.setAttribute(Qt::WA_Maemo5StackedWindow);
#if defined(Q_OS_SYMBIAN) || defined(Q_WS_MAEMO_5) || defined(Q_WS_SIMULATOR)
mw.showMaximized();
#else
mw.show();
#endif
return a.exec();
}
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 DefaultConnection::processConnectionError(const QString &AError)
{
if (FChangeProxyType && FSocket.proxy().type()==QNetworkProxy::HttpProxy)
{
QNetworkProxy socksProxy = FSocket.proxy();
socksProxy.setType(QNetworkProxy::Socks5Proxy);
FSocket.setProxy(socksProxy);
connectSocketToHost(FHost,FPort);
}
else if (FRecords.isEmpty())
{
if (FSocket.state()!=QSslSocket::ConnectedState || FSSLError)
{
setError(AError);
emit disconnected();
}
else
{
setError(AError);
}
}
else
{
connectToNextHost();
}
}
DialogHttpUpdate::DialogHttpUpdate(const QUrl& cfgUrl, bool display, QWidget *mdiMain)
{
//Save Proxy settings with QSettings
QSettings settings(qApp->organizationName(), qApp->applicationName());
if (!settings.contains("Update/automatic"))
settings.setValue("Update/automatic", true);
if (!settings.contains("Proxy/behindProxy"))
settings.setValue("Proxy/behindProxy", false);
if (!settings.contains("Proxy/HostName"))
settings.setValue("Proxy/HostName", "");
if (!settings.contains("Proxy/Port"))
settings.setValue("Proxy/Port", "");
if (!settings.contains("Proxy/Password"))
settings.setValue("Proxy/Password", "");
if (!settings.contains("Proxy/User"))
settings.setValue("Proxy/User", "");
//QNetworkManager
d = new HttpUpdater(mdiMain, display, this);
//configure proxy
bool bl = settings.value("Proxy/behindProxy").toBool();
if (bl)
{
QNetworkProxy proxy;
proxy.setType(QNetworkProxy::HttpCachingProxy);
proxy.setHostName(settings.value("Proxy/HostName").toString());
proxy.setPort(settings.value("Proxy/Port").toInt());
d->manager.setProxy(proxy);
}
//check if updates are available
d->getXml(cfgUrl);
}
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");
}
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;
}
