break;

}

session_->setUseAcks(options.useAcks);

stanzaChannel_->setSession(session_);

session_->onFinished.connect(boost::bind(&CoreClient::handleSessionFinished, this, _1));

session_->onNeedCredentials.connect(boost::bind(&CoreClient::handleNeedCredentials, this));

session_->start();

}

/**

* Only called for TCP sessions. BOSH is handled inside the BOSHSessionStream.

*/

void CoreClient::handleConnectorFinished(boost::shared_ptr<Connection> connection) {

resetConnector();

if (!connection) {

if (options.forgetPassword) {

purgePassword();

}

onDisconnected(disconnectRequested_ ? boost::optional<ClientError>() : boost::optional<ClientError>(ClientError::ConnectionError));

}

else {

assert(!connection_);

connection_ = connection;

assert(!sessionStream_);

sessionStream_ = boost::make_shared<BasicSessionStream>(ClientStreamType, connection_, getPayloadParserFactories(), getPayloadSerializers(), networkFactories->getTLSContextFactory(), networkFactories->getTimerFactory(), networkFactories->getXMLParserFactory());

}

sessionStream_->onDataRead.connect(boost::bind(&CoreClient::handleDataRead, this, _1));

sessionStream_->onDataWritten.connect(boost::bind(&CoreClient::handleDataWritten, this, _1));

bindSessionToStream();

}

}

void CoreClient::disconnect() {

disconnectRequested_ = true;

if (session_ && !session_->isFinished()) {

session_->finish();

}

else if (connector_) {

connector_->stop();

}

}

certificate_ = certificate;

}

void CoreClient::handleSessionFinished(boost::shared_ptr<Error> error) {

if (options.forgetPassword) {

purgePassword();

}

resetSession();

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <string>

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Entity/Entity.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Client/ClientError.h>

#include <Swiften/Client/ClientOptions.h>

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

class ChainedConnector;

class Message;

class Presence;

class Error;

class IQRouter;

class TLSContextFactory;

class ConnectionFactory;

class CoreClient : public Entity {

public:

/**

* Constructs a client for the given JID with the given password.

* The given eventLoop will be used to post events to.

*/

CoreClient(const JID& jid, const SafeByteArray& password, NetworkFactories* networkFactories);

~CoreClient();

/**

* Connects the client to the server.

*

* After the connection is established, the client will set

* initialize the stream and authenticate.

*/

void connect(const ClientOptions& = ClientOptions());

NetworkFactories* networkFactories;

ClientSessionStanzaChannel* stanzaChannel_;

IQRouter* iqRouter_;

ClientOptions options;

boost::shared_ptr<ChainedConnector> connector_;

std::vector<ConnectionFactory*> proxyConnectionFactories;

boost::shared_ptr<Connection> connection_;

boost::shared_ptr<SessionStream> sessionStream_;

boost::shared_ptr<ClientSession> session_;

bool disconnectRequested_;

CertificateTrustChecker* certificateTrustChecker;

};

}

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Session/SessionStream.h>

namespace Swift {

SessionStream::~SessionStream() {

}

};

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <Swiften/Base/boost_bsignals.h>

#include <boost/shared_ptr.hpp>

#include <boost/optional.hpp>

ConnectionReadError,

ConnectionWriteError

};

Error(Type type) : type(type) {}

Type type;

};

virtual ~SessionStream();

virtual void close() = 0;

virtual bool isOpen() = 0;

virtual void writeHeader(const ProtocolHeader& header) = 0;

virtual void writeFooter() = 0;

virtual void writeElement(boost::shared_ptr<Element>) = 0;

virtual void addZLibCompression() = 0;

virtual bool supportsTLSEncryption() = 0;

virtual void addTLSEncryption() = 0;

virtual bool isTLSEncrypted() = 0;

virtual void setWhitespacePingEnabled(bool enabled) = 0;

virtual void resetXMPPParser() = 0;

certificate = cert;

}

virtual bool hasTLSCertificate() {

return certificate && !certificate->isNull();

}

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

virtual boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const = 0;

boost::signal<void (const ProtocolHeader&)> onStreamStartReceived;

boost::signal<void (boost::shared_ptr<Element>)> onElementReceived;

boost::signal<void (boost::shared_ptr<Error>)> onClosed;

boost::signal<void ()> onTLSEncrypted;

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

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

protected:

return certificate;

}

private:

};

}

void TLSLayer::writeData(const SafeByteArray& data) {

context->handleDataFromApplication(data);

}

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

context->handleDataFromNetwork(data);

}

return context->setClientCertificate(certificate);

}

Certificate::ref TLSLayer::getPeerCertificate() const {

return context->getPeerCertificate();

}

boost::shared_ptr<CertificateVerificationError> TLSLayer::getPeerCertificateVerificationError() const {

return context->getPeerCertificateVerificationError();

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/StreamStack/StreamLayer.h>

#include <Swiften/TLS/Certificate.h>

#include <Swiften/TLS/CertificateVerificationError.h>

namespace Swift {

class TLSContext;

class TLSContextFactory;

class TLSLayer : public StreamLayer {

public:

TLSLayer(TLSContextFactory*);

~TLSLayer();

void connect();

Certificate::ref getPeerCertificate() const;

boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;

void writeData(const SafeByteArray& data);

void handleDataRead(const SafeByteArray& data);

TLSContext* getContext() const {

return context;

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/TLS/CertificateWithKey.h>

#define SECURITY_WIN32

#include <WinCrypt.h>

namespace Swift {

class CAPICertificate : public Swift::CertificateWithKey {

public:

private:

bool valid_;

std::string uri_;

/* Parsed components of the uri_ */

};

}

*/

#pragma once

#include <Swiften/Base/SafeByteArray.h>

namespace Swift {

class CertificateWithKey {

public:

CertificateWithKey() {}

virtual ~CertificateWithKey() {}

virtual bool isNull() const = 0;

};

}

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

}

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

state_ = Error;

onError();

}

}

bool OpenSSLContext::setClientCertificate(CertificateWithKey * certificate) {

return false;

}

// Create a PKCS12 structure

BIO* bio = BIO_new(BIO_s_mem());

boost::shared_ptr<PKCS12> pkcs12(d2i_PKCS12_bio(bio, NULL), PKCS12_free);

BIO_free(bio);

if (!pkcs12) {

return false;

}

// Parse PKCS12

X509 *certPtr = 0;

EVP_PKEY* privateKeyPtr = 0;

STACK_OF(X509)* caCertsPtr = 0;

if (result != 1) {

return false;

}

boost::shared_ptr<X509> cert(certPtr, X509_free);

boost::shared_ptr<EVP_PKEY> privateKey(privateKeyPtr, EVP_PKEY_free);

boost::shared_ptr<STACK_OF(X509)> caCerts(caCertsPtr, freeX509Stack);

// Use the key & certificates

if (SSL_CTX_use_certificate(context_, cert.get()) != 1) {

namespace Swift {

class CertificateWithKey;

class OpenSSLContext : public TLSContext, boost::noncopyable {

public:

OpenSSLContext();

~OpenSSLContext();

void connect();

void handleDataFromNetwork(const SafeByteArray&);

void handleDataFromApplication(const SafeByteArray&);

Certificate::ref getPeerCertificate() const;

boost::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;

virtual ByteArray getFinishMessage() const;

myenv.MergeFlags(myenv["OPENSSL_FLAGS"])

objects += myenv.SwiftenObject([

"OpenSSL/OpenSSLContext.cpp",

"OpenSSL/OpenSSLCertificate.cpp",

"OpenSSL/OpenSSLContextFactory.cpp",

])

myenv.Append(CPPDEFINES = "HAVE_OPENSSL")

elif myenv.get("HAVE_SCHANNEL", 0) :

objects += myenv.StaticObject([

"Schannel/SchannelContext.cpp",

"Schannel/SchannelCertificate.cpp",

"Schannel/SchannelContextFactory.cpp",

])

myenv.Append(CPPDEFINES = "HAVE_SCHANNEL")

objects += myenv.SwiftenObject(["PlatformTLSFactories.cpp"])

/*

* Copyright (c) 2011 Soren Dreijer

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

namespace Swift {

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

SchannelContext::SchannelContext()

: m_state(Start)

, m_secContext(0)

, m_verificationError(CertificateVerificationError::UnknownError)

, m_my_cert_store(NULL)

, m_cert_store_name("MY")

{

m_ctxtFlags = ISC_REQ_ALLOCATE_MEMORY |

ISC_REQ_CONFIDENTIALITY |

ISC_REQ_EXTENDED_ERROR |

ISC_REQ_INTEGRITY |

ISC_REQ_REPLAY_DETECT |

ISC_REQ_SEQUENCE_DETECT |

ISC_REQ_USE_SUPPLIED_CREDS |

ISC_REQ_STREAM;

sendDataOnNetwork(&sendBuffer[0], outBuffers[0].cbBuffer + outBuffers[1].cbBuffer + outBuffers[2].cbBuffer);

bytesSent += bytesToSend;

} while (bytesSent < data.size());

}

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

{

return false;

}

}

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

Certificate::ref SchannelContext::getPeerCertificate() const

{

SchannelCertificate::ref pCertificate;

ScopedCertContext pServerCert;

public:

SchannelContext();

~SchannelContext();

//

// TLSContext

//

virtual void connect();

virtual void handleDataFromNetwork(const SafeByteArray& data);

virtual void handleDataFromApplication(const SafeByteArray& data);

virtual Certificate::ref getPeerCertificate() const;

virtual CertificateVerificationError::ref getPeerCertificateVerificationError() const;

virtual ByteArray getFinishMessage() const;

*/

#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/CertificateVerificationError.h>

namespace Swift {

class TLSContext {

public:

virtual ~TLSContext();

virtual void connect() = 0;

virtual void handleDataFromNetwork(const SafeByteArray&) = 0;

virtual void handleDataFromApplication(const SafeByteArray&) = 0;

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

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

virtual ByteArray getFinishMessage() const = 0;