自学教程：C++ sslErrors函数代码示例

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=";    loginPostData += username;    loginPostData += "&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;}

voidNwReqTracker::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();}

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