purgeCachedCredentials();

}

if (quitRequested_) {

resetClient();

loginWindow_->quit();

}

else if (error) {

std::string message;

std::string certificateErrorMessage;

switch(error->getType()) {

case ClientError::UnknownError: message = QT_TRANSLATE_NOOP("", "Unknown Error"); break;

case ClientError::DomainNameResolveError: message = QT_TRANSLATE_NOOP("", "Unable to find server"); break;

case ClientError::ConnectionError: message = QT_TRANSLATE_NOOP("", "Error connecting to server"); break;

case ClientError::ConnectionReadError: message = QT_TRANSLATE_NOOP("", "Error while receiving server data"); break;

case ClientError::ConnectionWriteError: message = QT_TRANSLATE_NOOP("", "Error while sending data to the server"); break;

case ClientError::XMLError: message = QT_TRANSLATE_NOOP("", "Error parsing server data"); break;

case ClientError::AuthenticationFailedError: message = QT_TRANSLATE_NOOP("", "Login/password invalid"); break;

case ClientError::CompressionFailedError: message = QT_TRANSLATE_NOOP("", "Error while compressing stream"); break;

case ClientError::ServerVerificationFailedError: message = QT_TRANSLATE_NOOP("", "Server verification failed"); break;

case ClientError::NoSupportedAuthMechanismsError: message = QT_TRANSLATE_NOOP("", "Authentication mechanisms not supported"); break;

case ClientError::UnexpectedElementError: message = QT_TRANSLATE_NOOP("", "Unexpected response"); break;

case ClientError::ResourceBindError: message = QT_TRANSLATE_NOOP("", "Error binding resource"); break;

case ClientError::SessionStartError: message = QT_TRANSLATE_NOOP("", "Error starting session"); break;

case ClientError::StreamError: message = QT_TRANSLATE_NOOP("", "Stream error"); break;

case ClientError::TLSError: message = QT_TRANSLATE_NOOP("", "Encryption error"); break;

case ClientError::ClientCertificateLoadError: message = QT_TRANSLATE_NOOP("", "Error loading certificate (Invalid password?)"); break;

case ClientError::ClientCertificateError: message = QT_TRANSLATE_NOOP("", "Certificate not authorized"); break;

case ClientError::UnknownCertificateError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Unknown certificate"); break;

case ClientError::CertificateExpiredError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate has expired"); break;

case ClientError::CertificateNotYetValidError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate is not yet valid"); break;

case ClientError::CertificateSelfSignedError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate is self-signed"); break;

case ClientError::CertificateRejectedError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate has been rejected"); break;

case ClientError::CertificateUntrustedError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate is not trusted"); break;

case ClientError::InvalidCertificatePurposeError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate cannot be used for encrypting your connection"); break;

case ClientError::CertificatePathLengthExceededError: certificateErrorMessage = QT_TRANSLATE_NOOP("", "Certificate path length constraint exceeded"); break;

}

else {

message = QT_TRANSLATE_NOOP("", "Certificate error");

}

}

if (forceReconnectAfterCertificateTrust) {

performLoginFromCachedCredentials();

}

signOut();

loginWindow_->setMessage(message);

loginWindow_->setIsLoggingIn(false);

} else {

logout();

if (settings_->getSetting(SettingConstants::FORGET_PASSWORDS)) {

message = str(format(QT_TRANSLATE_NOOP("", "Disconnected from %1%: %2%. To reconnect, Sign Out and provide your password again.")) % jid_.getDomain() % message);

} else {

if (!offlineRequested_) {

NoSupportedAuthMechanismsError,

UnexpectedElementError,

ResourceBindError,

SessionStartError,

StreamError,

TLSError,

ClientCertificateLoadError,

ClientCertificateError,

// Certificate verification errors

UnknownCertificateError,

CertificateExpiredError,

CertificateNotYetValidError,

CertificateSelfSignedError,

CertificateRejectedError,

CertificateUntrustedError,

InvalidCertificatePurposeError,

CertificatePathLengthExceededError,

#include <boost/bind.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <Swiften/Base/IDGenerator.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Base/Algorithm.h>

#include <Swiften/Client/ClientSession.h>

#include <Swiften/TLS/CertificateVerificationError.h>

#include <Swiften/Network/ChainedConnector.h>

#include <Swiften/Network/NetworkFactories.h>

#include <Swiften/Network/ProxyProvider.h>

#include <Swiften/Network/DomainNameResolveError.h>

#include <Swiften/TLS/PKCS12Certificate.h>

#include <Swiften/Session/BasicSessionStream.h>

#include <Swiften/Session/BOSHSessionStream.h>

#include <Swiften/Queries/IQRouter.h>

#include <Swiften/Client/ClientSessionStanzaChannel.h>

break;

case ClientSession::Error::TLSClientCertificateError:

clientError = ClientError(ClientError::ClientCertificateError);

break;

case ClientSession::Error::StreamError:

clientError = ClientError(ClientError::StreamError);

break;

}

}

switch(actualError->type) {

clientError = ClientError(ClientError::XMLError);

break;

clientError = ClientError(ClientError::TLSError);

break;

clientError = ClientError(ClientError::ClientCertificateLoadError);

break;

clientError = ClientError(ClientError::ConnectionReadError);

break;

clientError = ClientError(ClientError::ConnectionWriteError);

break;

}

}

else if (boost::shared_ptr<CertificateVerificationError> verificationError = boost::dynamic_pointer_cast<CertificateVerificationError>(error)) {

switch(verificationError->getType()) {

case CertificateVerificationError::UnknownError:

clientError = ClientError(ClientError::UnknownCertificateError);

break;

virtual void setWhitespacePingEnabled(bool enabled) {

whitespacePingEnabled = enabled;

}

virtual void resetXMPPParser() {

resetCount++;

}

void breakConnection() {

}

void breakTLS() {

}

void sendStreamStart() {

ProtocolHeader header;

header.setTo("foo.com");

return onStreamStartReceived(header);

}

switch(actualError->type) {

case ComponentSession::Error::AuthenticationFailedError:

componentError = ComponentError(ComponentError::AuthenticationFailedError);

break;

case ComponentSession::Error::UnexpectedElementError:

componentError = ComponentError(ComponentError::UnexpectedElementError);

break;

}

}

switch(actualError->type) {

componentError = ComponentError(ComponentError::XMLError);

break;

assert(false);

componentError = ComponentError(ComponentError::UnknownError);

break;

assert(false);

componentError = ComponentError(ComponentError::UnknownError);

break;

componentError = ComponentError(ComponentError::ConnectionReadError);

break;

componentError = ComponentError(ComponentError::ConnectionWriteError);

break;

}

}

onError(componentError);

}

}

void CoreComponent::handleDataRead(const SafeByteArray& data) {

virtual void setWhitespacePingEnabled(bool enabled) {

whitespacePingEnabled = enabled;

}

virtual void resetXMPPParser() {

resetCount++;

}

void breakConnection() {

}

void sendStreamStart() {

ProtocolHeader header;

header.setFrom("service.foo.com");

return onStreamStartReceived(header);

}

void sendHandshakeResponse() {

}

}

class BOSHConnectionTest;

namespace Swift {

class XMLParserFactory;

class TLSContextFactory;

public:

enum Type {BadRequest, HostGone, HostUnknown, ImproperAddressing,

InternalServerError, ItemNotFound, OtherRequest, PolicyViolation,

RemoteConnectionFailed, RemoteStreamError, SeeOtherURI, SystemShutdown, UndefinedCondition,

NoError};

Type getType() {return type;}

typedef boost::shared_ptr<BOSHError> ref;

private:

Type type;

};

class BOSHConnection : public boost::enable_shared_from_this<BOSHConnection> {

onStreamStartReceived(header);

}

void BOSHSessionStream::handleElementReceived(boost::shared_ptr<Element> element) {

onElementReceived(element);

}

void BOSHSessionStream::handleXMPPError() {

available = false;

}

void BOSHSessionStream::handlePoolSessionStarted() {

fakeStreamHeaderReceipt();

}

void BOSHSessionStream::handlePoolSessionTerminated(BOSHError::ref error) {

eventLoop->postEvent(boost::bind(&BOSHSessionStream::fakeStreamFooterReceipt, this, error), shared_from_this());

}

bool BasicSessionStream::supportsTLSEncryption() {

return tlsContextFactory && tlsContextFactory->canCreate();

}

void BasicSessionStream::addTLSEncryption() {

assert(available);

tlsLayer = new TLSLayer(tlsContextFactory);

if (hasTLSCertificate() && !tlsLayer->setClientCertificate(getTLSCertificate())) {

}

else {

streamStack->addLayer(tlsLayer);

tlsLayer->onConnected.connect(boost::bind(&BasicSessionStream::handleTLSConnected, this));

tlsLayer->connect();

}

}

bool BasicSessionStream::isTLSEncrypted() {

return tlsLayer;

}

onStreamStartReceived(header);

}

void BasicSessionStream::handleElementReceived(boost::shared_ptr<Element> element) {

onElementReceived(element);

}

void BasicSessionStream::handleXMPPError() {

available = false;

}

void BasicSessionStream::handleTLSConnected() {

onTLSEncrypted();

}

available = false;

}

void BasicSessionStream::handleConnectionFinished(const boost::optional<Connection::Error>& error) {

available = false;

if (error == Connection::ReadError) {

}

else if (error) {

}

else {

}

}

void BasicSessionStream::handleDataRead(const SafeByteArray& data) {

onDataRead(data);

}

void BasicSessionStream::handleDataWritten(const SafeByteArray& data) {

onDataWritten(data);

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Session/SessionStream.h>

#include <Swiften/Elements/StreamType.h>

namespace Swift {

class TLSContextFactory;

class TLSLayer;

class TimerFactory;

class WhitespacePingLayer;

class PayloadParserFactoryCollection;

class PayloadSerializerCollection;

class StreamStack;

virtual void setWhitespacePingEnabled(bool);

virtual void resetXMPPParser();

private:

void handleConnectionFinished(const boost::optional<Connection::Error>& error);

void handleXMPPError();

void handleTLSConnected();

void handleStreamStartReceived(const ProtocolHeader&);

void handleElementReceived(boost::shared_ptr<Element>);

void handleDataRead(const SafeByteArray& data);

void handleDataWritten(const SafeByteArray& data);

private:

bool available;

boost::shared_ptr<Connection> connection;

PayloadParserFactoryCollection* payloadParserFactories;

#include <Swiften/Base/Error.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/TLS/CertificateWithKey.h>

#include <Swiften/TLS/Certificate.h>

#include <Swiften/TLS/CertificateVerificationError.h>

namespace Swift {

class SessionStream {

public:

public:

enum Type {

ParseError,

TLSError,

InvalidTLSCertificateError,

ConnectionReadError,

ConnectionWriteError

};

Type type;

};

SessionStream(): certificate() {}

virtual ~SessionStream();

virtual void close() = 0;

*/

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/StreamStack/StreamLayer.h>

#include <Swiften/TLS/Certificate.h>

#include <Swiften/TLS/CertificateWithKey.h>

#include <Swiften/TLS/CertificateVerificationError.h>

namespace Swift {

class TLSContext;

class TLSContextFactory;

class TLSLayer : public StreamLayer {

public:

TLSLayer(TLSContextFactory*);

~TLSLayer();

void writeData(const SafeByteArray& data);

void handleDataRead(const SafeByteArray& data);

TLSContext* getContext() const {

return context;

}

public:

boost::signal<void ()> onConnected;

private:

TLSContext* context;

};

}

//std::cout << "Compression: " << SSL_COMP_get_name(comp) << std::endl;

onConnected();

break;

}

case SSL_ERROR_WANT_READ:

sendPendingDataToNetwork();

break;

default:

state_ = Error;

}

}

void OpenSSLContext::sendPendingDataToNetwork() {

int size = BIO_pending(writeBIO_);

if (size > 0) {

SafeByteArray data;

data.resize(size);

BIO_read(writeBIO_, vecptr(data), size);

}

}

void OpenSSLContext::handleDataFromApplication(const SafeByteArray& data) {

if (SSL_write(handle_, vecptr(data), data.size()) >= 0) {

sendPendingDataToNetwork();

}

else {

state_ = Error;

}

}

void OpenSSLContext::sendPendingDataToApplication() {

SafeByteArray data;

data.resize(SSL_READ_BUFFERSIZE);

int ret = SSL_read(handle_, vecptr(data), data.size());

while (ret > 0) {

data.resize(ret);

onDataForApplication(data);

data.resize(SSL_READ_BUFFERSIZE);

ret = SSL_read(handle_, vecptr(data), data.size());

}

if (ret < 0 && SSL_get_error(handle_, ret) != SSL_ERROR_WANT_READ) {

state_ = Error;

}

}

bool OpenSSLContext::setClientCertificate(CertificateWithKey::ref certificate) {

boost::shared_ptr<PKCS12Certificate> pkcs12Certificate = boost::dynamic_pointer_cast<PKCS12Certificate>(certificate);

if (!pkcs12Certificate || pkcs12Certificate->isNull()) {

return false;

}

}

}

//------------------------------------------------------------------------

void SchannelContext::indicateError()

{

m_state = Error;

m_receivedData.clear();

}

//------------------------------------------------------------------------

void SchannelContext::decryptAndProcessData(const SafeByteArray& data)

{

SecBuffer inBuffers[4] = {0};

appendNewData(data);

#pragma once

#include <Swiften/Base/boost_bsignals.h>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/TLS/Certificate.h>

#include <Swiften/TLS/CertificateWithKey.h>

#include <Swiften/TLS/CertificateVerificationError.h>

namespace Swift {

class TLSContext {

public:

virtual ~TLSContext();

virtual void connect() = 0;

virtual Certificate::ref getPeerCertificate() const = 0;

virtual CertificateVerificationError::ref getPeerCertificateVerificationError() const = 0;

virtual ByteArray getFinishMessage() const = 0;

public:

boost::signal<void (const SafeByteArray&)> onDataForNetwork;

boost::signal<void (const SafeByteArray&)> onDataForApplication;

boost::signal<void ()> onConnected;

};

}