void SslClient::establish(const QString& host, quint16 port)
{
threadLock_ = new QMutex();
threadEvent_ = new QWaitCondition();
QMutexLocker blocked(threadLock_);
host_ = host;
port_ = port;
start();
threadEvent_->wait(threadLock_);
if(ssl_.isNull() || running_ == false)
Q_ASSERT_X(ssl_.isNull() || running_ == false, "SslClient::establish", "Cannot start SslClient's thread");
connect(ssl_.data(), SIGNAL(stateChanged(QAbstractSocket::SocketState)),
this, SLOT(socketStateChanged(QAbstractSocket::SocketState)), Qt::DirectConnection);
connect(ssl_.data(), SIGNAL(encrypted()),
this, SLOT(socketEncrypted()), Qt::DirectConnection);
connect(ssl_.data(), SIGNAL(error(QAbstractSocket::SocketError)),
this, SLOT(socketError(QAbstractSocket::SocketError)), Qt::DirectConnection);
connect(ssl_.data(), SIGNAL(sslErrors(QList<QSslError>)),
this, SLOT(sslErrors(QList<QSslError>)), Qt::DirectConnection);
connect(ssl_.data(), SIGNAL(readyRead()),
this, SLOT(socketReadyRead()), Qt::DirectConnection);
ConfigureForLMAX();
}
void LanLinkProvider::sslErrors(const QList<QSslError>& errors)
{
QSslSocket* socket = qobject_cast<QSslSocket*>(sender());
if (!socket) return;
disconnect(socket, SIGNAL(encrypted()), this, SLOT(encrypted()));
disconnect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(sslErrors(QList<QSslError>)));
foreach(const QSslError &error, errors) {
qCDebug(KDECONNECT_CORE) << "SSL Error :" << error.errorString();
switch (error.error()) {
case QSslError::CertificateSignatureFailed:
case QSslError::CertificateNotYetValid:
case QSslError::CertificateExpired:
case QSslError::CertificateUntrusted:
case QSslError::SelfSignedCertificate: {
qCDebug(KDECONNECT_CORE) << "Unpairing device due to " << error.errorString();
// Due to simultaneous multiple connections, it may be possible that device instance does not exist anymore
Device *device = Daemon::instance()->getDevice(socket->peerVerifyName());
if (device != Q_NULLPTR) {
device->unpair();
}
break;
}
default:
continue;
// Lots of warnings without this
}
}
void LanLinkProvider::sslErrors(const QList<QSslError>& errors)
{
QSslSocket* socket = qobject_cast<QSslSocket*>(sender());
if (!socket) return;
disconnect(socket, &QSslSocket::encrypted, this, &LanLinkProvider::encrypted);
disconnect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(sslErrors(QList<QSslError>)));
Q_FOREACH (const QSslError &error, errors) {
switch (error.error()) {
case QSslError::CertificateSignatureFailed:
case QSslError::CertificateNotYetValid:
case QSslError::CertificateExpired:
case QSslError::CertificateUntrusted:
case QSslError::SelfSignedCertificate: {
qCDebug(KDECONNECT_CORE) << "Failing due to " << error.errorString();
// Due to simultaneous multiple connections, it may be possible that device instance does not exist anymore
Device *device = Daemon::instance()->getDevice(socket->peerVerifyName());
if (device != Q_NULLPTR) {
device->unpair();
}
break;
}
default:
continue;
}
}
delete receivedIdentityPackages.take(socket).np;
// Socket disconnects itself on ssl error and will be deleted by deleteLater slot, no need to delete manually
}
//We received a UDP package and answered by connecting to them by TCP. This gets called on a succesful connection.
void LanLinkProvider::connected()
{
qCDebug(KDECONNECT_CORE) << "Socket connected";
QSslSocket* socket = qobject_cast<QSslSocket*>(sender());
if (!socket) return;
disconnect(socket, &QAbstractSocket::connected, this, &LanLinkProvider::connected);
disconnect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(connectError()));
configureSocket(socket);
// If socket disconnects due to any reason after connection, link on ssl faliure
connect(socket, &QAbstractSocket::disconnected, socket, &QObject::deleteLater);
NetworkPackage* receivedPackage = receivedIdentityPackages[socket].np;
const QString& deviceId = receivedPackage->get<QString>(QStringLiteral("deviceId"));
//qCDebug(KDECONNECT_CORE) << "Connected" << socket->isWritable();
// If network is on ssl, do not believe when they are connected, believe when handshake is completed
NetworkPackage np2(QLatin1String(""));
NetworkPackage::createIdentityPackage(&np2);
socket->write(np2.serialize());
bool success = socket->waitForBytesWritten();
if (success) {
qCDebug(KDECONNECT_CORE) << "TCP connection done (i'm the existing device)";
// if ssl supported
if (receivedPackage->get<int>(QStringLiteral("protocolVersion")) >= MIN_VERSION_WITH_SSL_SUPPORT) {
bool isDeviceTrusted = KdeConnectConfig::instance()->trustedDevices().contains(deviceId);
configureSslSocket(socket, deviceId, isDeviceTrusted);
qCDebug(KDECONNECT_CORE) << "Starting server ssl (I'm the client TCP socket)";
connect(socket, &QSslSocket::encrypted, this, &LanLinkProvider::encrypted);
if (isDeviceTrusted) {
connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(sslErrors(QList<QSslError>)));
}
socket->startServerEncryption();
return; // Return statement prevents from deleting received package, needed in slot "encrypted"
} else {
qWarning() << receivedPackage->get<QString>(QStringLiteral("deviceName")) << "uses an old protocol version, this won't work";
//addLink(deviceId, socket, receivedPackage, LanDeviceLink::Remotely);
}
} else {
//I think this will never happen, but if it happens the deviceLink
//(or the socket that is now inside it) might not be valid. Delete them.
qCDebug(KDECONNECT_CORE) << "Fallback (2), try reverse connection (send udp packet)";
mUdpSocket.writeDatagram(np2.serialize(), receivedIdentityPackages[socket].sender, PORT);
}
delete receivedIdentityPackages.take(socket).np;
//We don't delete the socket because now it's owned by the LanDeviceLink
}
void QSslServer::incomingConnection(qintptr socket)
{
QSslSocket *pSslSocket = new QSslSocket();
if (Q_LIKELY(pSslSocket)) {
pSslSocket->setSslConfiguration(m_sslConfiguration);
if (Q_LIKELY(pSslSocket->setSocketDescriptor(socket)))
{
typedef void (QSslSocket::* sslErrorsSignal)(const QList<QSslError> &);
#if QT_VERSION >= QT_VERSION_CHECK(5, 0, 2)
connect(pSslSocket, &QSslSocket::peerVerifyError, this, &QSslServer::peerVerifyError);
connect(pSslSocket, &QSslSocket::encrypted, this, &QSslServer::newEncryptedConnection);
#else
connect(pSslSocket,SIGNAL(peerVerifyError(QSslError)), this, SIGNAL(peerVerifyError(QSslError)));
connect(pSslSocket, SIGNAL(sslErrors(QList<QSslError>)), this, SIGNAL(sslErrors(QList<QSslError>)));
connect(pSslSocket, SIGNAL(encrypted()), this, SIGNAL(newEncryptedConnection()));
#endif
addPendingConnection(pSslSocket);
pSslSocket->startServerEncryption();
}
else
{
delete pSslSocket;
}
}
}
void MapWidget::setGeo(const QGeoCoordinate &geo)
{
p->image = QImage(":/qml/Papyrus/files/map-loading.png").scaled(width(),height(),
Qt::IgnoreAspectRatio,
Qt::SmoothTransformation);
update();
if( !geo.latitude() && !geo.longitude() )
return;
if( p->reply )
return;
init_manager();
p->geo = geo;
QString path = "http://maps.google.com/maps/api/staticmap?center=" +
QString::number(geo.latitude()) + "," + QString::number(geo.longitude()) + "&zoom=15&size=" +
QString::number(width()) + "x" + QString::number(height()) + "&sensor=false";
QNetworkRequest request = QNetworkRequest(QUrl(path));
p->reply = p->manager->get(request);
connect(p->reply, SIGNAL(sslErrors(QList<QSslError>)), SLOT(sslErrors(QList<QSslError>)));
connect(p->reply, SIGNAL(downloadProgress(qint64,qint64)), SLOT(downloadProgress(qint64,qint64)) );
setToolTip( QString::number(p->geo.latitude()) + ", " + QString::number(p->geo.longitude()) );
}
JabberSslHandler::JabberSslHandler(QXmppClient *parent) :
QObject{parent}
{
parent->configuration().setIgnoreSslErrors(false);
connect(parent, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(sslErrors(QList<QSslError>)));
}
void ImageDownload::doImageDownload(const QUrl &url)
{
QNetworkRequest request(url);
QNetworkReply *reply = manager.get(request);
#ifndef QT_NO_SSL
connect(reply, SIGNAL(sslErrors(QList<QSslError>)), SLOT(sslErrors(QList<QSslError>)));
#endif
currentDownloads.append(reply);
}
void Server :: acceptConnection()
{
clientConnection = sslServer -> getClientConnection();
qDebug() << "New connection received from "<< clientConnection->peerAddress().toString();
connect(clientConnection, SIGNAL(encrypted()), SLOT(connectionAccepted()));
connect(clientConnection, SIGNAL(readyRead()), this, SLOT(readDataFromClient()));
connect(clientConnection, SIGNAL(disconnected()), clientConnection, SLOT(deleteLater()));
connect(clientConnection, SIGNAL(disconnected()), this, SLOT(notifyDisconnect()));
connect(clientConnection, SIGNAL(sslErrors(QList<QSslError>)),SLOT(sslErrors(QList<QSslError>)) );
}
//I'm the new device and this is the answer to my UDP identity package (data received)
void LanLinkProvider::dataReceived()
{
QSslSocket* socket = qobject_cast<QSslSocket*>(sender());
const QByteArray data = socket->readLine();
//qCDebug(KDECONNECT_CORE) << "LanLinkProvider received reply:" << data;
NetworkPackage* np = new NetworkPackage(QLatin1String(""));
bool success = NetworkPackage::unserialize(data, np);
if (!success) {
delete np;
return;
}
if (np->type() != PACKAGE_TYPE_IDENTITY) {
qCWarning(KDECONNECT_CORE) << "LanLinkProvider/newConnection: Expected identity, received " << np->type();
delete np;
return;
}
// Needed in "encrypted" if ssl is used, similar to "connected"
receivedIdentityPackages[socket].np = np;
const QString& deviceId = np->get<QString>(QStringLiteral("deviceId"));
//qCDebug(KDECONNECT_CORE) << "Handshaking done (i'm the new device)";
//This socket will now be owned by the LanDeviceLink or we don't want more data to be received, forget about it
disconnect(socket, &QIODevice::readyRead, this, &LanLinkProvider::dataReceived);
if (np->get<int>(QStringLiteral("protocolVersion")) >= MIN_VERSION_WITH_SSL_SUPPORT) {
bool isDeviceTrusted = KdeConnectConfig::instance()->trustedDevices().contains(deviceId);
configureSslSocket(socket, deviceId, isDeviceTrusted);
qCDebug(KDECONNECT_CORE) << "Starting client ssl (but I'm the server TCP socket)";
connect(socket, &QSslSocket::encrypted, this, &LanLinkProvider::encrypted);
if (isDeviceTrusted) {
connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(sslErrors(QList<QSslError>)));
}
socket->startClientEncryption();
} else {
qWarning() << np->get<QString>(QStringLiteral("deviceName")) << "uses an old protocol version, this won't work";
//addLink(deviceId, socket, np, LanDeviceLink::Locally);
delete receivedIdentityPackages.take(socket).np;
}
}
void ExternalAuthTask::start()
{
QVariantMap data = m_cache.value(m_data.id + m_data.cookie);
if (!data.isEmpty())
return done(data);
m_manager = new QNetworkAccessManager(this);
QNetworkRequest request(QUrl(Ch::server()->feed(FEED_NAME_SERVER)->data().value(SERVER_FEED_OAUTH_KEY).toString() + LS("/state/") + SimpleID::encode(m_data.id)));
request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::AlwaysNetwork);
request.setRawHeader("X-SChat-Cookie", SimpleID::encode(m_data.cookie));
m_reply = m_manager->get(request);
connect(m_reply, SIGNAL(finished()), SLOT(ready()));
connect(m_reply, SIGNAL(sslErrors(QList<QSslError>)), SLOT(sslErrors()));
}
void QNetworkAccessHttpBackend::setupConnection()
{
#ifndef QT_NO_NETWORKPROXY
connect(http, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));
#endif
connect(http, SIGNAL(authenticationRequired(QHttpNetworkRequest,QAuthenticator*)),
SLOT(httpAuthenticationRequired(QHttpNetworkRequest,QAuthenticator*)));
connect(http, SIGNAL(error(QNetworkReply::NetworkError,QString)),
SLOT(httpError(QNetworkReply::NetworkError,QString)));
#ifndef QT_NO_OPENSSL
connect(http, SIGNAL(sslErrors(QList<QSslError>)),
SLOT(sslErrors(QList<QSslError>)));
#endif
}
void SettingsEditorForm::connectToHost(QString addr, int port)
{
if(_socket != nullptr)
{
_socket->close();
_socket->deleteLater();
}
_socket = new QSslSocket(this);
connect( _socket, SIGNAL(error(QAbstractSocket::SocketError)), this,SLOT(onSocketError(QAbstractSocket::SocketError)));
connect( _socket, SIGNAL(peerVerifyError(QSslError)), this, SLOT(onPeerVerifyError(QSslError)) );
connect( _socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(onSslErrors(QList<QSslError>)));
connect( _socket, SIGNAL(connected()),this,SLOT(onConnected()));
connect( _socket, SIGNAL(readyRead()), this, SLOT(onReadyRead()));
_socket->setLocalCertificate( "./certs/manager.crt" );
_socket->setPrivateKey( "./certs/manager.key");
_socket->setProtocol(QSsl::SecureProtocols);
_socket->setCaCertificates(QSslCertificate::fromPath("./certs/trusted.pem"));
_socket->connectToHostEncrypted( addr, port, "SettingsServer");
if(!_socket->waitForEncrypted(1000))
{
LoggerDialog::get()->Error("SettingsEditorForm::connectToHost","Wait for encrypted failed!");
_socket->close();
ui->pushButton_connect->setText("Connect");
}
}
void Http::post(QString url, QString user, QString password, QString data)
{
QSslConfiguration config(QSslConfiguration::defaultConfiguration());
QNetworkRequest request;
request.setSslConfiguration(config);
request.setRawHeader("Authorization", "Basic " +
QByteArray(QString("%1:%2").arg(user).arg(password).toAscii().toBase64())
);
request.setRawHeader("Accept", "application/xml");
request.setRawHeader("Content-Type", "application/xml");
request.setUrl(QUrl(url));
connect(netManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(finished(QNetworkReply*)));
reply = netManager->post(request, data.toUtf8());
connect(reply, SIGNAL(downloadProgress(qint64,qint64)), this, SIGNAL(progress(qint64,qint64)));
connect(reply, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(sslError(QList<QSslError>)));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(networkError(QNetworkReply::NetworkError)));
}
/**
* Ignores ssl errors for a QNetworkReply if allowed
*/
void OwnCloudService::ignoreSslErrorsIfAllowed(QNetworkReply *reply) {
QSettings settings;
if (settings.value("networking/ignoreSSLErrors", true).toBool()) {
QObject::connect(reply, SIGNAL(sslErrors(QList<QSslError>)), reply,
SLOT(ignoreSslErrors()));
}
}
void OAuthenticator::RequestAccessToken(const QByteArray& code,
const QUrl& url) {
typedef QPair<QString, QString> Param;
QList<Param> parameters;
parameters << Param("code", code) << Param("client_id", client_id_)
<< Param("client_secret", client_secret_)
<< Param("grant_type", "authorization_code")
// Even though we don't use this URI anymore, it must match the
// original one.
<< Param("redirect_uri", url.toString());
QStringList params;
for (const Param& p : parameters) {
params.append(QString("%1=%2").arg(
p.first, QString(QUrl::toPercentEncoding(p.second))));
}
QString post_data = params.join("&");
qLog(Debug) << post_data;
QNetworkRequest request = QNetworkRequest(QUrl(token_endpoint_));
request.setHeader(QNetworkRequest::ContentTypeHeader,
"application/x-www-form-urlencoded");
QNetworkReply* reply = network_.post(request, post_data.toUtf8());
connect(reply, SIGNAL(sslErrors(QList<QSslError>)),
SLOT(SslErrors(QList<QSslError>)));
NewClosure(reply, SIGNAL(finished()), this,
SLOT(FetchAccessTokenFinished(QNetworkReply*)), reply);
}
int BdLogic::ConnectAndDownload(const QString &username, const QString &password)
{
QString loginPostData;
m_dlState = DLSTATE_LOGIN;
m_statusCode = BDLOGIC_STATUS_DOWNLOADING;
m_statusString = QString("Logging in");
m_actionListOrderedForQML.clear();
m_boxMapParsedJson.clear();
m_boxMapRawJson.clear();
m_replyGotError = false;
m_inactiveProjectListParsedJson.clear();
m_currentInactiveProjectDlIx = 0;
loginPostData = "username="******"&password=";
loginPostData += password;
QNetworkRequest request;
request.setUrl(QUrl(DOIT_LOGIN_URL));
m_reply = m_netManager->post(request, loginPostData.toUtf8());
connect(m_reply, SIGNAL(finished()), this, SLOT(replyFinished()));
connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(replyError(QNetworkReply::NetworkError)));
connect(m_reply, SIGNAL(sslErrors(QList<QSslError>)),
this, SLOT(replySSLError(QList<QSslError>)));
emit downloadStatusUpdated(m_statusCode, m_statusString);
return 0;
}
bool ArbitraryRequestHandler::request(int requestType, const QString &requestUri, const QVariantMap &queryItems, const QString &postData)
{
if (reply) {
qWarning() << Q_FUNC_INFO << "Warning: cannot start arbitrary request: another arbitrary request is in progress";
return false;
}
QList<QPair<QString, QString> > qil;
QStringList queryItemKeys = queryItems.keys();
foreach (const QString &qik, queryItemKeys)
qil.append(qMakePair<QString, QString>(qik, queryItems.value(qik).toString()));
QUrl url(requestUri);
url.setQueryItems(qil);
QNetworkReply *sniReply = 0;
switch (requestType) {
case SocialNetworkInterface::Get: sniReply = q->d->qnam->get(QNetworkRequest(url)); break;
case SocialNetworkInterface::Post: sniReply = q->d->qnam->post(QNetworkRequest(url), QByteArray::fromBase64(postData.toLatin1())); break;
default: sniReply = q->d->qnam->deleteResource(QNetworkRequest(url)); break;
}
if (sniReply) {
reply = sniReply;
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(errorHandler(QNetworkReply::NetworkError)));
connect(reply, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(sslErrorsHandler(QList<QSslError>)));
connect(reply, SIGNAL(finished()), this, SLOT(finishedHandler()));
return true;
}
qWarning() << Q_FUNC_INFO << "Warning: cannot start arbitrary request: null reply";
return false;
}
void WARequest::sendRequest(QString url)
{
qDebug()<< "SENDING";
QNetworkRequest request;
request.setUrl(QUrl(url+"?"+encodeUrl(params)));
request.setRawHeader("User-Agent", userAgent.toAscii());
//request.setRawHeader("Content-Type","application/x-www-form-urlencoded");
//request.setRawHeader("Accept","text/xml");
//QNetworkReply *reply = manager->post(request,encodeUrl(params));
QNetworkReply *reply = manager->get(request);
reply->ignoreSslErrors();
//connect(reply, SIGNAL(readyRead()), this, SLOT(readyRead()));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(networkError(QNetworkReply::NetworkError)));
connect(reply, SIGNAL(sslErrors(QList<QSslError>)),
this, SLOT(sslError(QList<QSslError>)));
// qDebug()<<encodeUrl(params);
// manager->get(request);
//manager->post(request,encodeUrl(params));
}
XmlRpcResponse *XmlRpcClient::execute(XmlRpcRequest *request, bool async) {
QNetworkAccessManager *network_manager = new QNetworkAccessManager();
QNetworkRequest network_request;
network_request.setUrl(QUrl(this->address));
network_request.setRawHeader("User-Agent", "XMLRPC browser");
network_request.setRawHeader("Content-Type", "application/x-www-form-urlencoded");
//connect(network_manager, SIGNAL(finished(QNetworkReply*)),
// this, SLOT(slotReplyFinished(QNetworkReply*)));
//qDebug() << "XMLRPC Request: " + request->toString().toLatin1();
QNetworkReply *reply = network_manager->post(network_request, request->toString().toLatin1());
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(slotError(QNetworkReply::NetworkError)));
//connect(reply, SIGNAL(sslErrors(QList<QSslError>)),
// this, SLOT(slotSslErrors(QList<QSslError>)));
if(async)
return NULL; // wait for complete signal
QEventLoop loop;
connect(reply, SIGNAL(readyRead()), &loop, SLOT(quit()));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), &loop, SLOT(quit()));
connect(reply, SIGNAL(sslErrors(QList<QSslError>)), &loop, SLOT(quit()));
loop.exec();
//qDebug() << "XMLRPC response: " + reply->readAll();
return XmlRpcResponse::fromString(reply->readAll());
}
void MainWindow::connectToHost()
{
client = new AnonymousClient(this);
connect(client, SIGNAL(sslErrors(QList<QSslError>)), SLOT(sslErrors(QList<QSslError>)));
connect(client, SIGNAL(messageAvailable(QString)), SLOT(displayMessage(QString)));
connect(client, SIGNAL(debugAvailable(QString)), debugConsole, SLOT(displayDebug(QString)));
connect(client, SIGNAL(setPhase0()), SLOT(phase0()));
connect(client, SIGNAL(setPhase1()), SLOT(phase1()));
connect(client, SIGNAL(disconnected()), SLOT(disconnectFromhost()));
connectButton->setEnabled(false);
disconnectButton->setEnabled(true);
displayMessage(tr("Connecting..."));
client->connectToHostEncrypted(settings->value("HostAddress", "localhost").toString(), settings->value("port", 9001).toInt());
}
int QNetworkAccessManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0:
proxyAuthenticationRequired((*reinterpret_cast< const QNetworkProxy(*)>(_a[1])),(*reinterpret_cast< QAuthenticator*(*)>(_a[2])));
break;
case 1:
authenticationRequired((*reinterpret_cast< QNetworkReply*(*)>(_a[1])),(*reinterpret_cast< QAuthenticator*(*)>(_a[2])));
break;
case 2:
finished((*reinterpret_cast< QNetworkReply*(*)>(_a[1])));
break;
case 3:
sslErrors((*reinterpret_cast< QNetworkReply*(*)>(_a[1])),(*reinterpret_cast< const QList<QSslError>(*)>(_a[2])));
break;
case 4:
d_func()->_q_replyFinished();
break;
case 5:
d_func()->_q_replySslErrors((*reinterpret_cast< QList<QSslError>(*)>(_a[1])));
break;
default:
;
}
_id -= 6;
}
return _id;
}
/*!
\qmlmethod bool FacebookPhoto::untagText(const QString &text)
Initiates a "delete tag" operation on the tag specified by
the given text.
If the network request was started successfully, the function
will return true and the status of the photo will change to
\c SocialNetwork::Busy. Otherwise, the function will return
false.
*/
bool FacebookPhotoInterface::untagText(const QString &text)
{
QVariantMap extraData;
extraData.insert("tag_text", text);
// try to find which tag will be removed if it succeeds
int tempPendingTagToRemoveIndex = -1;
for (int i = 0; i < f->tags.count(); ++i) {
QString tagText = f->tags.at(i)->text();
if (!tagText.isEmpty() && tagText == text) {
tempPendingTagToRemoveIndex = i;
break;
}
}
// possible that it's ok to not exist, since we might be out of sync with reality.
if (tempPendingTagToRemoveIndex == -1)
qWarning() << Q_FUNC_INFO << "Unknown tag specified for removal";
bool requestMade = request(IdentifiableContentItemInterface::Delete,
identifier(), QLatin1String("tags"),
QStringList(), QVariantMap(), extraData);
if (!requestMade)
return false;
f->action = FacebookInterfacePrivate::DeleteTagAction;
f->pendingTagToRemoveIndex = tempPendingTagToRemoveIndex;
connect(f->dd->reply(), SIGNAL(finished()), f, SLOT(finishedHandler()));
connect(f->dd->reply(), SIGNAL(error(QNetworkReply::NetworkError)), f->dd, SLOT(defaultErrorHandler(QNetworkReply::NetworkError)));
connect(f->dd->reply(), SIGNAL(sslErrors(QList<QSslError>)), f->dd, SLOT(defaultSslErrorsHandler(QList<QSslError>)));
return true;
}
void
NwReqTracker::disconnectReply()
{
bool rv = disconnect (reply, SIGNAL(finished()),
this , SLOT(onReplyFinished()));
Q_ASSERT(rv); Q_UNUSED(rv);
rv = disconnect (reply, SIGNAL(downloadProgress(qint64,qint64)),
this , SLOT(onReplyProgress(qint64,qint64)));
Q_ASSERT(rv);
rv = disconnect (reply, SIGNAL(uploadProgress(qint64,qint64)),
this , SLOT(onReplyProgress(qint64,qint64)));
Q_ASSERT(rv);
rv = disconnect (reply, SIGNAL(sslErrors(QList<QSslError>)),
this , SLOT(onReplySslErrors(QList<QSslError>)));
Q_ASSERT(rv);
rv = disconnect (reply, SIGNAL(error(QNetworkReply::NetworkError)),
this , SLOT(onReplyError(QNetworkReply::NetworkError)));
Q_ASSERT(rv);
rv = disconnect (reply, SIGNAL(downloadProgress(qint64,qint64)),
this , SLOT(onXferProgress(qint64,qint64)));
Q_ASSERT(rv);
rv = disconnect (reply, SIGNAL(uploadProgress(qint64,qint64)),
this , SLOT(onXferProgress(qint64,qint64)));
Q_ASSERT(rv);
}//NwReqTracker::disconnectReply
void BlFile::sync() {
BL_FUNC_DEBUG
// if (!exists() {
QFileInfo fileInfo(m_file);
QString filename(fileInfo.fileName());
QString user = g_confpr->value(CONF_LOGIN_USER);
QString dbname = g_confpr->value(CONF_DBNAME);
#ifdef Q_OS_WIN32
QString platform = "MS_WIN";
#else
QString platform = "LINUX";
#endif
QString url = "http://www.bulmages.com/bulmaincloud/"+platform+"/"+user+"/"+dbname+"/"+filename;
fprintf(stderr, "Iniciando descarga %s\n", url.toLatin1().constData());
manager = new QNetworkAccessManager(this);
QNetworkRequest request;
request.setUrl(QUrl(url));
request.setRawHeader("User-Agent", "BgBrowser 1.0");
QNetworkReply *reply = manager->get(request);
connect(reply, SIGNAL(readyRead()), this, SLOT(slotReadyRead()));
connect(reply, SIGNAL(downloadProgress(qint64,qint64)), this, SLOT(downloadProgress(qint64,qint64)));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(slotError(QNetworkReply::NetworkError)));
connect(reply, SIGNAL(sslErrors(QList<QSslError>)),
this, SLOT(slotSslErrors(QList<QSslError>)));
connect(manager, SIGNAL(finished(QNetworkReply*)),this, SLOT(replyFinished(QNetworkReply*)));
while (reply->isRunning()) {
QApplication::processEvents();
} // end while
// }// end if
url = "http://www.bulmages.com/bulmaincloud/ALL/"+user+"/"+dbname+"/"+filename;
fprintf(stderr, "Iniciando descarga %s\n", url.toLatin1().constData());
request.setUrl(QUrl(url));
reply = manager->get(request);
while (reply->isRunning()) {
QApplication::processEvents();
} // end while
if (reply->error() == QNetworkReply::NoError) {
return;
} // end if
url = "http://www.bulmages.com/bulmaincloud/ALL/ALL/"+filename;
fprintf(stderr, "Iniciando descarga %s\n", url.toLatin1().constData());
request.setUrl(QUrl(url));
reply = manager->get(request);
while (reply->isRunning()) {
QApplication::processEvents();
} // end while
}
/**
* Gets the calendar list from the ownCloud server
* for the settings dialog
*/
void OwnCloudService::settingsGetCalendarList(SettingsDialog *dialog) {
settingsDialog = dialog;
QUrl url(serverUrl + calendarPath);
QNetworkRequest r(url);
addAuthHeader(&r);
// build the request body
QString body = "<d:propfind xmlns:d=\"DAV:\" "
"xmlns:cs=\"http://sabredav.org/ns\" xmlns:c=\"urn:ietf:params:xml:ns:caldav\"> \
<d:prop> \
<d:resourcetype /> \
<d:displayname /> \
<cs:getctag /> \
<c:supported-calendar-component-set /> \
</d:prop> \
</d:propfind>";
QByteArray *dataToSend = new QByteArray(body.toLatin1());
r.setHeader(QNetworkRequest::ContentLengthHeader, dataToSend->size());
QBuffer *buffer = new QBuffer(dataToSend);
QNetworkReply *reply = networkManager->sendCustomRequest(r, "PROPFIND",
buffer);
QObject::connect(reply, SIGNAL(sslErrors(QList<QSslError>)), reply,
SLOT(ignoreSslErrors()));
}
void IslInterface::initClient()
{
QList<QSslError> expectedErrors;
expectedErrors.append(QSslError(QSslError::SelfSignedCertificate, peerCert));
socket->ignoreSslErrors(expectedErrors);
qDebug() << "[ISL] Connecting to #" << serverId << ":" << peerAddress << ":" << peerPort;
socket->connectToHostEncrypted(peerAddress, peerPort, peerHostName);
if (!socket->waitForConnected(5000)) {
qDebug() << "[ISL] Socket error:" << socket->errorString();
deleteLater();
return;
}
if (!socket->waitForEncrypted(5000)) {
QList<QSslError> sslErrors(socket->sslErrors());
if (sslErrors.isEmpty())
qDebug() << "[ISL] SSL handshake timeout, terminating connection";
else
qDebug() << "[ISL] SSL errors:" << sslErrors;
deleteLater();
return;
}
server->islLock.lockForWrite();
if (server->islConnectionExists(serverId)) {
qDebug() << "[ISL] Duplicate connection to #" << serverId << "terminating connection";
deleteLater();
return;
}
server->addIslInterface(serverId, this);
server->islLock.unlock();
}
/**
* @brief Restores a note on the server
*/
void OwnCloudService::restoreTrashedNoteOnServer(QString notesPath,
QString fileName,
int timestamp,
MainWindow *mainWindow) {
this->mainWindow = mainWindow;
QUrl url(serverUrl + restoreTrashedNotePath);
QString serverNotesPath = getServerNotesPath(notesPath);
url.setUserName(userName);
url.setPassword(password);
QUrlQuery q;
q.addQueryItem("format", format);
q.addQueryItem("file_name", serverNotesPath + fileName);
q.addQueryItem("timestamp", QString::number(timestamp));
url.setQuery(q);
qDebug() << url;
QNetworkRequest r(url);
addAuthHeader(&r);
QNetworkReply *reply = networkManager->get(r);
QObject::connect(reply, SIGNAL(sslErrors(QList<QSslError>)), reply,
SLOT(ignoreSslErrors()));
}
SimondConnector::SimondConnector(QObject *parent) :
QObject(parent), state(Unconnected),
socket(new QSslSocket(this)),
timeoutTimer(new QTimer(this)),
response(new QDataStream(socket)),
mic(new SoundInput(SOUND_CHANNELS, SOUND_SAMPLERATE, this)),
passThroughSound(false)
{
connect(this, SIGNAL(connectionState(ConnectionState)), this, SLOT(setCurrentState(ConnectionState)));
connect(socket, SIGNAL(readyRead()), this, SLOT(messageReceived()));
connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(socketError()));
connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(socketError()));
connect(socket, SIGNAL(connected()), this, SLOT(connectionEstablished()));
connect(socket, SIGNAL(encrypted()), this, SLOT(connectionEstablished()));
connect(socket, SIGNAL(disconnected()), this, SLOT(connectionLost()));
connect(mic, SIGNAL(error(QString)), this, SIGNAL(error(QString)));
connect(mic, SIGNAL(microphoneLevel(int,int,int)), this, SIGNAL(microphoneLevel(int,int,int)));
connect(mic, SIGNAL(listening()), this, SLOT(startRecording()));
connect(mic, SIGNAL(complete()), this, SLOT(commitRecording()));
connect(mic, SIGNAL(readyRead()), this, SLOT(soundDataAvailable()));
connect(timeoutTimer, SIGNAL(timeout()), this, SLOT(timeoutReached()));
timeoutTimer->setSingleShot(true);
timeoutTimer->setInterval(SOCKET_TIMEOUT);
}
void ServerThread::run()
{
QFile keyFile("./server.key");
s = new QSslSocket();
if(!s->setSocketDescriptor(socketDescriptor))
{
emit error(s->error());
}
if(!keyFile.open(QIODevice::ReadOnly))
{
qDebug() << "File was not opened";
}
QSslKey key(&keyFile, QSsl::Rsa, QSsl::Pem ,QSsl::PrivateKey);
s->setPrivateKey(key);
s->setLocalCertificate("./server.crt",QSsl::Pem);
s->addCaCertificates("./ca.crt", QSsl::Pem);
//s->addCaCertificates("./server.crt",QSsl::Pem);
connect(s, SIGNAL(readyRead()), this, SLOT(readyRead()), Qt::QueuedConnection);
connect(s, SIGNAL(disconnected()), this, SLOT(disconnected()), Qt::DirectConnection);
connect(s, SIGNAL(encrypted()), this, SLOT(ready()),Qt::QueuedConnection);
connect(s, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(errorm(QList<QSslError>)),Qt::DirectConnection);
s->startServerEncryption();
qDebug() << "started listening";
exec();
}
