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 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);
}
}
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 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());
}
}
void FileDownloader::setProxy(QNetworkProxy proxy) {
http->abort();
http->setProxy(proxy);
qDebug("FileDownloader::setProxy: host: '%s' port: %d type: %d",
proxy.hostName().toUtf8().constData(), proxy.port(), proxy.type());
}
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 Proxy::Init()
{
if (CONF->UsingProxy())
{
QNetworkProxy ps = CONF->GetProxy();
SetProxy(CONF->ProxyType(), ps.hostName(), ps.port(), ps.user(), ps.password());
}
}
QString Phantom::proxy()
{
QNetworkProxy proxy = QNetworkProxy::applicationProxy();
if (proxy.hostName().isEmpty()) {
return NULL;
}
return proxy.hostName() + ":" + QString::number(proxy.port());
}
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 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 PackageManagerProxyFactory::setProxyCredentials(const QNetworkProxy &proxy,
const QString &user,
const QString &password)
{
auto p = std::find_if(m_proxyCredentials.begin(), m_proxyCredentials.end(),
FindProxyCredential(proxy.hostName(), proxy.port()));
if (p == m_proxyCredentials.end()) {
ProxyCredential proxyCredential;
proxyCredential.host = proxy.hostName();
proxyCredential.port = proxy.port();
proxyCredential.user = user;
proxyCredential.password = password;
m_proxyCredentials.append(proxyCredential);
} else {
p->user = user;
p->password = password;
}
}
void FindSubtitlesWindow::setProxy(QNetworkProxy proxy) {
downloader->abort();
downloader->setProxy(proxy);
#ifdef DOWNLOAD_SUBS
file_downloader->setProxy(proxy);
#endif
qDebug("FindSubtitlesWindow::setProxy: host: '%s' port: %d type: %d",
proxy.hostName().toUtf8().constData(), proxy.port(), proxy.type());
}
void HTTPTransportTest::testSetProperty()
{
HTTPTransport transport;
transport.setProperty("foo", "bar");
QString proxyHost("http://foo.bar.net");
transport.setProperty(HTTPNUMBEROFRESENDATTEMPTSPROP, "10");
transport.setProperty(HTTPPROXYHOSTPROP, proxyHost);
transport.setProperty(HTTPPROXYPORTPROP, "5555");
QNetworkProxy proxy = transport.getProxyConfig();
QCOMPARE(proxy.hostName(), proxyHost);
QCOMPARE(proxy.port(), (quint16)5555);
}
void HTTPTransportTest::testSetProxy()
{
HTTPTransport transport;
QNetworkProxy proxy;
QString proxyHost("http://foo.bar.net");
quint16 port = 5555;
proxy.setHostName(proxyHost);
proxy.setPort(port);
transport.setProxyConfig(proxy);
proxy = transport.getProxyConfig();
QCOMPARE(proxy.hostName(), proxyHost);
QCOMPARE(proxy.port(), port);
}
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());
}
}
QList<QNetworkProxy> PackageManagerProxyFactory::queryProxy(const QNetworkProxyQuery &query)
{
const Settings &settings = m_core->settings();
QList<QNetworkProxy> list;
if (settings.proxyType() == Settings::SystemProxy) {
QList<QNetworkProxy> systemProxies = systemProxyForQuery(query);
auto proxyIter = systemProxies.begin();
for (; proxyIter != systemProxies.end(); ++proxyIter) {
QNetworkProxy &proxy = *proxyIter;
auto p = std::find_if(m_proxyCredentials.constBegin(), m_proxyCredentials.constEnd(),
FindProxyCredential(proxy.hostName(), proxy.port()));
if (p != m_proxyCredentials.constEnd()) {
proxy.setUser(p->user);
proxy.setPassword(p->password);
}
}
return systemProxies;
}
if ((settings.proxyType() == Settings::NoProxy))
return list << QNetworkProxy(QNetworkProxy::NoProxy);
if (query.queryType() == QNetworkProxyQuery::UrlRequest) {
QNetworkProxy proxy;
if (query.url().scheme() == QLatin1String("ftp")) {
proxy = settings.ftpProxy();
} else if (query.url().scheme() == QLatin1String("http")
|| query.url().scheme() == QLatin1String("https")) {
proxy = settings.httpProxy();
}
auto p = std::find_if(m_proxyCredentials.constBegin(), m_proxyCredentials.constEnd(),
FindProxyCredential(proxy.hostName(), proxy.port()));
if (p != m_proxyCredentials.constEnd()) {
proxy.setUser(p->user);
proxy.setPassword(p->password);
}
return list << proxy;
}
return list << QNetworkProxy(QNetworkProxy::DefaultProxy);
}
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" ));
}
QNetworkProxy Core::guessProxy(const QUrl &url)
{
QList<QNetworkProxy> proxies = QNetworkProxyFactory::systemProxyForQuery(QNetworkProxyQuery(url));
if (proxies.size())
{
QNetworkProxy localProxy = proxies.at(0);
localProxy.setUser(httpProxy.user());
localProxy.setPassword(httpProxy.password());
qDebug() << name().toAscii().constData() << "::guessProxy()\n"
<< "\tusing proxy "
<< localProxy.user().toAscii().constData() << "@"
<< localProxy.hostName().toAscii().constData() << ":"
<< QString::number(localProxy.port()).toAscii().constData() << "\n"
<< "\tfor " << url.toString().toAscii().constData();
return localProxy;
}
else
return QNetworkProxy(QNetworkProxy::NoProxy);
}
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);
}
static QByteArray proxyAuthenticationKey(const QNetworkProxy &proxy, const QString &realm)
{
QUrl key;
switch (proxy.type()) {
case QNetworkProxy::Socks5Proxy:
key.setScheme(QLatin1String("proxy-socks5"));
break;
case QNetworkProxy::HttpProxy:
case QNetworkProxy::HttpCachingProxy:
key.setScheme(QLatin1String("proxy-http"));
break;
case QNetworkProxy::FtpCachingProxy:
key.setScheme(QLatin1String("proxy-ftp"));
break;
case QNetworkProxy::DefaultProxy:
case QNetworkProxy::NoProxy:
// shouldn't happen
return QByteArray();
// no default:
// let there be errors if a new proxy type is added in the future
}
if (key.scheme().isEmpty())
// proxy type not handled
return QByteArray();
key.setUserName(proxy.user());
key.setHost(proxy.hostName());
key.setPort(proxy.port());
key.setFragment(realm);
return "auth:" + key.toEncoded();
}
void QtNetworkAccessManager::onProxyAuthenticationRequired(const QNetworkProxy& proxy, QAuthenticator* authenticator)
{
// FIXME: Check if there is a better way to get a reference to the page.
WebPage* webPage = m_webProcess->focusedWebPage();
if (!webPage)
return;
String hostname = proxy.hostName();
uint16_t port = static_cast<uint16_t>(proxy.port());
String prefilledUsername = authenticator->user();
String username;
String password;
if (webPage->sendSync(
Messages::WebPageProxy::ProxyAuthenticationRequiredRequest(hostname, port, prefilledUsername),
Messages::WebPageProxy::ProxyAuthenticationRequiredRequest::Reply(username, password))) {
if (!username.isEmpty())
authenticator->setUser(username);
if (!password.isEmpty())
authenticator->setPassword(password);
}
}
void DefaultConnection::setProxy(const QNetworkProxy &AProxy)
{
if (AProxy != FSocket.proxy())
{
LogDetail(QString("[DefaultConnection] Connection proxy changed, type='%1', host='%2', port='%3'").arg(AProxy.type()).arg(AProxy.hostName()).arg(AProxy.port()));
FSocket.setProxy(AProxy);
emit proxyChanged(AProxy);
}
}
QString printQNetworkProxy(const QNetworkProxy &proxy)
{
return QString("%1://%2:%3").arg(proxy.type()).arg(proxy.hostName()).arg(proxy.port());
}
void PaymentServer::initNetManager()
{
if (!optionsModel)
return;
delete netManager;
// netManager is used to fetch paymentrequests given in bitcoin: URIs
netManager = new QNetworkAccessManager(this);
QNetworkProxy proxy;
// Query active SOCKS5 proxy
if (optionsModel->getProxySettings(proxy)) {
netManager->setProxy(proxy);
qDebug() << "PaymentServer::initNetManager: Using SOCKS5 proxy" << proxy.hostName() << ":" << proxy.port();
}
else
qDebug() << "PaymentServer::initNetManager: No active proxy server found.";
connect(netManager, SIGNAL(finished(QNetworkReply*)),
this, SLOT(netRequestFinished(QNetworkReply*)));
connect(netManager, SIGNAL(sslErrors(QNetworkReply*, const QList<QSslError> &)),
this, SLOT(reportSslErrors(QNetworkReply*, const QList<QSslError> &)));
}
void Settings::setHTTPNetworkProxy(QNetworkProxy httpNetworkProxy) {
mChangedHTTPNetworkProxy = mHTTPNetworkProxy.hostName() != httpNetworkProxy.hostName() || mHTTPNetworkProxy.port() != httpNetworkProxy.port();
mHTTPNetworkProxy = httpNetworkProxy;
}
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;
}
void CodeDownloader::setProxy(QNetworkProxy proxy) {
manager->setProxy(proxy);
qDebug("CodeDownloader::setProxy: host: '%s' port: %d type: %d",
proxy.hostName().toUtf8().constData(), proxy.port(), proxy.type());
}
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);
}
}
}
