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;
}
