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); } }
/** Slot connected to proxy authentication required */ void HttpDownloaderPrivate::proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *authenticator) { LOG("Proxy authentication required: " + proxy.hostName()); const QString &host = proxy.hostName(); m_AuthTimes.insert(host, m_AuthTimes.value(host, 0) + 1); if (m_AuthTimes.value(host) > MAX_AUTHENTIFICATION_TRIES) { LOG_ERROR("Proxy authentication max tries achieved. " + host); return; } if (!proxy.user().isEmpty() && !proxy.password().isEmpty()) { authenticator->setUser(proxy.user()); authenticator->setPassword(proxy.password()); } else { // Ask user for identification Utils::BasicLoginDialog dlg; dlg.setModal(true); dlg.setTitle(tr("Proxy authentication required")); // TODO: manage icon // dlg.setToggleViewIcon(core().icon(ICONEYES)); if (dlg.exec()==QDialog::Accepted) { authenticator->setUser(dlg.login()); authenticator->setPassword(dlg.password()); } } // TODO: manage ServerEngineStatus here }
void AccessManager::slotProxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *authenticator) { Q_UNUSED(authenticator); qDebug() << Q_FUNC_INFO << proxy.type(); // We put in the password here and in ClientProxy in the proxy itself. if (!proxy.user().isEmpty() || !proxy.password().isEmpty()) { authenticator->setUser(proxy.user()); authenticator->setPassword(proxy.password()); } }
void ownCloudFolder::setProxy() { if( _csync_ctx ) { /* Store proxy */ QUrl proxyUrl(ownCloudInfo::instance()->webdavUrl()); QList<QNetworkProxy> proxies = QNetworkProxyFactory::proxyForQuery(proxyUrl); // We set at least one in Application Q_ASSERT(proxies.count() > 0); QNetworkProxy proxy = proxies.first(); if (proxy.type() == QNetworkProxy::NoProxy) { qDebug() << "Passing NO proxy to csync for" << proxyUrl; } else { qDebug() << "Passing" << proxy.hostName() << "of proxy type " << proxy.type() << " to csync for" << proxyUrl; } int proxyPort = proxy.port(); csync_set_module_property(_csync_ctx, "proxy_type", (char*) proxyTypeToCStr(proxy.type()) ); csync_set_module_property(_csync_ctx, "proxy_host", proxy.hostName().toUtf8().data() ); csync_set_module_property(_csync_ctx, "proxy_port", &proxyPort ); csync_set_module_property(_csync_ctx, "proxy_user", proxy.user().toUtf8().data() ); csync_set_module_property(_csync_ctx, "proxy_pwd" , proxy.password().toUtf8().data() ); csync_set_module_property(_csync_ctx, "csync_context", _csync_ctx); } }
void ClientProxy::setCSyncProxy( const QUrl& url, CSYNC *csync_ctx ) { /* Store proxy */ QList<QNetworkProxy> proxies = QNetworkProxyFactory::proxyForQuery(QNetworkProxyQuery(url)); // We set at least one in Application Q_ASSERT(proxies.count() > 0); QNetworkProxy proxy = proxies.first(); if (proxy.type() == QNetworkProxy::NoProxy) { qDebug() << "Passing NO proxy to csync for" << url.toString(); } else { qDebug() << "Passing" << proxy.hostName() << "of proxy type " << proxy.type() << " to csync for" << url.toString(); } const char *proxy_type = proxyTypeToCStr(proxy.type()); const char* proxy_host = proxy.hostName().toUtf8().data(); int proxy_port = proxy.port(); const char *proxy_user = proxy.user().toUtf8().data(); const char *proxy_pwd = proxy.password().toUtf8().data(); csync_set_module_property( csync_ctx, "proxy_type", (void*)proxy_type ); csync_set_module_property( csync_ctx, "proxy_host", (void*)proxy_host ); csync_set_module_property( csync_ctx, "proxy_port", (void*)&proxy_port ); csync_set_module_property( csync_ctx, "proxy_user", (void*)proxy_user ); csync_set_module_property( csync_ctx, "proxy_pwd", (void*)proxy_pwd ); }
void AbstractSocketSubclass::aSlot(const QNetworkProxy &proxy, QAuthenticator *authenticator) { if (authenticator != 0) { authenticator->setUser(proxy.user()); authenticator->setPassword(proxy.password()); } }
void ProxyPreferencesWidget::autoDetectProxy() { LOG("Trying to find system proxy."); QNetworkProxy proxy; // QNetworkProxyFactory::setUseSystemConfiguration(true); QNetworkProxyQuery npq(QUrl("http://www.google.com")); QList<QNetworkProxy> listOfProxies = QNetworkProxyFactory::systemProxyForQuery(npq); foreach(const QNetworkProxy &p, listOfProxies) { if (p.type()==QNetworkProxy::HttpProxy && !p.hostName().isEmpty()) { LOG("Using proxy " + p.hostName()); proxy = p; break; } } if (proxy.hostName().isEmpty()) { ui->proxyHostName->clear(); ui->proxyPort->setValue(0); ui->proxyUserName->clear(); ui->proxyUserPassword->clear(); } else { ui->proxyHostName->setText(proxy.hostName()); ui->proxyPort->setValue(proxy.port()); ui->proxyUserName->setText(proxy.user()); ui->proxyUserPassword->setText(proxy.password()); } }
QNetworkAuthenticationCredential QNetworkAccessAuthenticationManager::fetchCachedProxyCredentials(const QNetworkProxy &p, const QAuthenticator *authenticator) { QNetworkProxy proxy = p; if (proxy.type() == QNetworkProxy::DefaultProxy) { proxy = QNetworkProxy::applicationProxy(); } if (!proxy.password().isEmpty()) return QNetworkAuthenticationCredential(); // no need to set credentials if it already has them QString realm; if (authenticator) realm = authenticator->realm(); QMutexLocker mutexLocker(&mutex); QByteArray cacheKey = proxyAuthenticationKey(proxy, realm); if (cacheKey.isEmpty()) return QNetworkAuthenticationCredential(); if (!authenticationCache.hasEntry(cacheKey)) return QNetworkAuthenticationCredential(); QNetworkAuthenticationCache *auth = static_cast<QNetworkAuthenticationCache *>(authenticationCache.requestEntryNow(cacheKey)); QNetworkAuthenticationCredential cred = *auth->findClosestMatch(QString()); authenticationCache.releaseEntry(cacheKey); // proxy cache credentials always have exactly one item Q_ASSERT_X(!cred.isNull(), "QNetworkAccessManager", "Internal inconsistency: found a cache key for a proxy, but it's empty"); return cred; }
void ClientProxy::setCSyncProxy( const QUrl& url, CSYNC *csync_ctx ) { #ifdef USE_NEON /* Store proxy */ QList<QNetworkProxy> proxies = QNetworkProxyFactory::proxyForQuery(QNetworkProxyQuery(url)); // We set at least one in Application Q_ASSERT(proxies.count() > 0); if (proxies.count() == 0) { qDebug() << Q_FUNC_INFO << "No proxy!"; return; } QNetworkProxy proxy = proxies.first(); if (proxy.type() == QNetworkProxy::NoProxy) { qDebug() << "Passing NO proxy to csync for" << url.toString(); } else { qDebug() << "Passing" << proxy.hostName() << "of proxy type " << proxy.type() << " to csync for" << url.toString(); } csync_set_module_property( csync_ctx, "proxy_type", (void*)(proxyTypeToCStr(proxy.type()))); csync_set_module_property( csync_ctx, "proxy_host", proxy.hostName().toUtf8().data()); int proxy_port = proxy.port(); csync_set_module_property( csync_ctx, "proxy_port", &proxy_port ); csync_set_module_property( csync_ctx, "proxy_user", proxy.user().toUtf8().data()); csync_set_module_property( csync_ctx, "proxy_pwd", proxy.password().toUtf8().data()); #else Q_UNUSED(url); Q_UNUSED(csync_ctx); #endif }
void NetworkManager::proxyAuthentication(const QString &proxyHost, QAuthenticator *auth, QWidget *parent) { const QNetworkProxy proxy = QNetworkProxy::applicationProxy(); if (!proxy.user().isEmpty() && !proxy.password().isEmpty()) { auth->setUser(proxy.user()); auth->setPassword(proxy.password()); return; } QDialog* dialog = new QDialog(parent); dialog->setWindowTitle(tr("Proxy authorisation required")); QFormLayout* formLa = new QFormLayout(dialog); QLabel* label = new QLabel(dialog); QLabel* userLab = new QLabel(dialog); QLabel* passLab = new QLabel(dialog); userLab->setText(tr("Username: "******"Password: "******"A username and password are being requested by proxy %1. ").arg(proxyHost)); formLa->addRow(label); formLa->addRow(userLab, user); formLa->addRow(passLab, pass); formLa->addWidget(box); if (dialog->exec() != QDialog::Accepted) { *auth = QAuthenticator(); delete dialog; return; } auth->setUser(user->text()); auth->setPassword(pass->text()); delete dialog; }
void Proxy::Init() { if (CONF->UsingProxy()) { QNetworkProxy ps = CONF->GetProxy(); SetProxy(CONF->ProxyType(), ps.hostName(), ps.port(), ps.user(), ps.password()); } }
void connection::setCurrentProxy(QNetworkProxy &proxyToCopy) { currentProxy.setType(proxyToCopy.type()); currentProxy.setHostName(proxyToCopy.hostName()); currentProxy.setPort(proxyToCopy.port()); currentProxy.setUser(proxyToCopy.user()); currentProxy.setPassword(proxyToCopy.password()); }
void save() { QNetworkProxy proxy = QNetworkProxy::applicationProxy(); Config::setValue("/Network/Proxy/Type", proxy.type()); Config::setValue("/Network/Proxy/HostName", proxy.hostName()); Config::setValue("/Network/Proxy/Port", proxy.port()); Config::setValue("/Network/Proxy/User", proxy.user()); Config::setValue("/Network/Proxy/Password", proxy.password()); }
void QHttpSocketEngine::setProxy(const QNetworkProxy &proxy) { Q_D(QHttpSocketEngine); d->proxy = proxy; QString user = proxy.user(); if (!user.isEmpty()) d->authenticator.setUser(user); QString password = proxy.password(); if (!password.isEmpty()) d->authenticator.setPassword(password); }
NetworkSettingsDialog::NetworkSettingsDialog(QWidget *parent) : QDialog(parent), ui(new Ui::NetworkSettingsDialog) { ui->setupUi(this); QValidator *val = new QIntValidator(this); ui->proxyportEdit->setValidator(val); QNetworkProxy proxy = QNetworkProxy::applicationProxy(); if (proxy.type() != proxy.NoProxy) { ui->proxyhostEdit->setText(proxy.hostName()); ui->proxyportEdit->setText(QString::number(proxy.port())); ui->proxyuserEdit->setText(proxy.user()); ui->proxypassEdit->setText(proxy.password()); } }
QNetworkReply *NetworkAccessManager::createRequest(QNetworkAccessManager::Operation operation, const QNetworkRequest &request, QIODevice *outgoingData) { QNetworkRequest localRequest = request; QNetworkProxy localProxy = QNetworkProxy::applicationProxy(); if (localProxy.type() != QNetworkProxy::NoProxy) { QString authCredentials = QString("%1:%2") .arg(localProxy.user()) .arg(localProxy.password()); localRequest.setRawHeader("Proxy-Authorization", QByteArray("Basic ") + authCredentials.toLocal8Bit().toBase64()); } localRequest.setRawHeader("User-Agent", "Skhaz Crawler 1.0"); localRequest.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, true); localRequest.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::AlwaysNetwork); return QNetworkAccessManager::createRequest(operation, localRequest, outgoingData); }
void ProxyPreferencesWidget::setDataToUi() { ui->proxyHostName->clear(); ui->proxyPort->setValue(0); ui->proxyUserName->clear(); ui->proxyUserPassword->clear(); const QString &proxyString = settings()->value(Core::Constants::S_PROXY).toString(); if (!proxyString.isEmpty()) { QNetworkProxy proxy; if (!Utils::Serializer::deserializeProxy(proxyString, proxy)) { LOG_ERROR("Proxy serialized string corrupted"); return; } ui->proxyHostName->setText(proxy.hostName()); ui->proxyPort->setValue(proxy.port()); ui->proxyUserName->setText(proxy.user()); ui->proxyUserPassword->setText(proxy.password()); } }
Proxy::Proxy(QWidget *parent) : QDialog(parent), ui(new Ui::Proxy) { this->ui->setupUi(this); this->ui->comboBox->addItem("None"); this->ui->comboBox->addItem("Socks 5"); this->ui->comboBox->addItem("Http"); this->ui->comboBox->addItem("Http (caching proxy)"); this->ui->comboBox->addItem("Ftp"); this->ui->comboBox->setCurrentIndex(CONF->ProxyType()); if (CONF->UsingProxy()) { QNetworkProxy ps = CONF->GetProxy(); this->ui->checkBox->setChecked(true); this->ui->lineEdit->setText(ps.hostName()); this->ui->lineEdit_2->setText(QString::number(ps.port())); this->ui->lineEdit_3->setText(ps.user()); this->ui->lineEdit_4->setText(ps.password()); } }
void EnrichmentDialog::initEditorPage() { http = new QHttp(this); connect(http, SIGNAL(done(bool)), this, SLOT(updateForm(bool))); http->setHost("mathtran.org"); QNetworkProxy proxy = QNetworkProxy::applicationProxy(); if (!proxy.hostName().isEmpty()) http->setProxy(proxy.hostName(), proxy.port(), proxy.user(), proxy.password()); compileProcess = NULL; dvipngProcess = NULL; editPage = new QWidget(); equationEditor = new QTextEdit; texFormatButtons = new TextFormatButtons(equationEditor, TextFormatButtons::Equation); texCompilerBox = new QComboBox; texCompilerBox->addItem(tr("MathTran (http://www.mathtran.org/)")); texCompilerBox->addItem(tr("locally installed")); if (d_app) texCompilerBox->setCurrentIndex(d_app->d_latex_compiler); connect(texCompilerBox, SIGNAL(activated(int)), this, SLOT(updateCompilerInterface(int))); QHBoxLayout *hl = new QHBoxLayout; hl->addWidget(new QLabel(tr("LaTeX Compiler"))); hl->addWidget(texCompilerBox); outputLabel = new QLabel; outputLabel->setFrameShape(QFrame::StyledPanel); QVBoxLayout *layout = new QVBoxLayout(editPage); layout->addWidget(equationEditor, 1); layout->addWidget(texFormatButtons); layout->addLayout(hl); layout->addWidget(new QLabel(tr("Preview:"))); layout->addWidget(outputLabel); tabWidget->addTab(editPage, tr("&Text" )); }
void NetworkSettingsPageWidget::setState(AppSettingsGUIPageState* s) { NetworkSettingsPageState* state = qobject_cast<NetworkSettingsPageState*>(s); const NetworkConfiguration& set = state->config; QNetworkProxy httpProxy = set.getProxy( QNetworkProxy::HttpProxy ); if( QNetworkProxy::DefaultProxy != httpProxy.type() ) { httpProxyAddrEdit->insert( httpProxy.hostName() ); httpProxyPortEdit->setValue( httpProxy.port() ); httpProxyCheck->setCheckState( Qt::Checked ); QString user = httpProxy.user(); if (!user.isEmpty()) { httpAuthBox->setChecked(true); httpAuthLoginEdit->setText(user); httpAuthPasswordEdit->setText(httpProxy.password()); } } if( !set.isProxyUsed(QNetworkProxy::HttpProxy) ){ httpProxyAddrEdit->setDisabled( true ); httpProxyPortEdit->setDisabled( true ); httpProxyCheck->setCheckState( Qt::Unchecked ); } proxyExceptionsEdit->setPlainText( set.getExceptionsList().join("\n") ); if( set.exceptionsEnabled() ) { proxyExceptionsCheck->setCheckState( Qt::Checked ); } else { proxyExceptionsEdit->setDisabled( true ); } sslBox->addItems(set.getSslProtocolNames()); int index = sslBox->findText(set.getSslProtocolName()); sslBox->setCurrentIndex(index); remoteRequestBox->setValue(set.remoteRequestTimeout()); defaultWebBrowser->setChecked(state->useDefaultWebBrowser); customWebBrowser->setChecked(!state->useDefaultWebBrowser); webBrowserButton->setEnabled(!state->useDefaultWebBrowser); webBrowserEdit->setEnabled(!state->useDefaultWebBrowser); webBrowserEdit->setText(state->webBrowserUrl); }
ownCloudFolder::ownCloudFolder(const QString &alias, const QString &mpath, const QString &secondPath, QObject *parent) : Folder(alias, mpath, secondPath, parent) , _thread(0) , _csync(0) , _csyncError(false) , _csyncUnavail(false) , _wipeDb(false) { ServerActionNotifier *notifier = new ServerActionNotifier(this); connect(notifier, SIGNAL(guiLog(QString,QString)), Logger::instance(), SIGNAL(guiLog(QString,QString))); connect(this, SIGNAL(syncFinished(SyncResult)), notifier, SLOT(slotSyncFinished(SyncResult))); qDebug() << "****** ownCloud folder using watcher *******"; // The folder interval is set in the folder parent class. QString url = replaceScheme(secondPath); QString localpath = path(); if( csync_create( &_csync_ctx, localpath.toUtf8().data(), url.toUtf8().data() ) < 0 ) { qDebug() << "Unable to create csync-context!"; _csync_ctx = 0; } else { csync_set_log_callback( _csync_ctx, csyncLogCatcher ); csync_set_log_verbosity(_csync_ctx, 11); MirallConfigFile cfgFile; csync_set_config_dir( _csync_ctx, cfgFile.configPath().toUtf8() ); csync_enable_conflictcopys(_csync_ctx); QString excludeList = cfgFile.excludeFile(); if( !excludeList.isEmpty() ) { qDebug() << "==== added CSync exclude List: " << excludeList.toUtf8(); csync_add_exclude_list( _csync_ctx, excludeList.toUtf8() ); } csync_set_auth_callback( _csync_ctx, getauth ); if( csync_init( _csync_ctx ) < 0 ) { qDebug() << "Could not initialize csync!"; _csync_ctx = 0; } if( _csync_ctx ) { /* Store proxy */ QList<QNetworkProxy> proxies = QNetworkProxyFactory::proxyForQuery(QUrl(cfgFile.ownCloudUrl())); // We set at least one in Application Q_ASSERT(proxies.count() > 0); QNetworkProxy proxy = proxies.first(); int proxyPort = proxy.port(); csync_set_module_property(_csync_ctx, "proxy_type", (char*) proxyTypeToCStr(proxy.type()) ); csync_set_module_property(_csync_ctx, "proxy_host", proxy.hostName().toUtf8().data() ); csync_set_module_property(_csync_ctx, "proxy_port", &proxyPort ); csync_set_module_property(_csync_ctx, "proxy_user", proxy.user().toUtf8().data() ); csync_set_module_property(_csync_ctx, "proxy_pwd" , proxy.password().toUtf8().data() ); csync_set_module_property(_csync_ctx, "csync_context", _csync_ctx); } } }
void MultiMC::updateProxySettings() { QString proxyTypeStr = settings()->get("ProxyType").toString(); // Get the proxy settings from the settings object. QString addr = settings()->get("ProxyAddr").toString(); int port = settings()->get("ProxyPort").value<qint16>(); QString user = settings()->get("ProxyUser").toString(); QString pass = settings()->get("ProxyPass").toString(); // Set the application proxy settings. if (proxyTypeStr == "SOCKS5") { QNetworkProxy::setApplicationProxy(QNetworkProxy(QNetworkProxy::Socks5Proxy, addr, port, user, pass)); } else if (proxyTypeStr == "HTTP") { QNetworkProxy::setApplicationProxy(QNetworkProxy(QNetworkProxy::HttpProxy, addr, port, user, pass)); } else if (proxyTypeStr == "None") { // If we have no proxy set, set no proxy and return. QNetworkProxy::setApplicationProxy(QNetworkProxy(QNetworkProxy::NoProxy)); } else { // If we have "Default" selected, set Qt to use the system proxy settings. QNetworkProxyFactory::setUseSystemConfiguration(true); } QLOG_INFO() << "Detecting proxy settings..."; QNetworkProxy proxy = QNetworkProxy::applicationProxy(); if (m_qnam.get()) m_qnam->setProxy(proxy); QString proxyDesc; if (proxy.type() == QNetworkProxy::NoProxy) { QLOG_INFO() << "Using no proxy is an option!"; return; } switch (proxy.type()) { case QNetworkProxy::DefaultProxy: proxyDesc = "Default proxy: "; break; case QNetworkProxy::Socks5Proxy: proxyDesc = "Socks5 proxy: "; break; case QNetworkProxy::HttpProxy: proxyDesc = "HTTP proxy: "; break; case QNetworkProxy::HttpCachingProxy: proxyDesc = "HTTP caching: "; break; case QNetworkProxy::FtpCachingProxy: proxyDesc = "FTP caching: "; break; default: proxyDesc = "DERP proxy: "; break; } proxyDesc += QString("%3@%1:%2 pass %4") .arg(proxy.hostName()) .arg(proxy.port()) .arg(proxy.user()) .arg(proxy.password()); QLOG_INFO() << proxyDesc; }