+#include "Swiften/Client/Client.h"

+

+#include <boost/bind.hpp>

+

+#include "Swiften/Network/MainBoostIOServiceThread.h"

+#include "Swiften/Network/BoostIOServiceThread.h"

+#include "Swiften/Client/ClientSession.h"

+#include "Swiften/StreamStack/PlatformTLSLayerFactory.h"

+#include "Swiften/Network/Connector.h"

+#include "Swiften/Network/BoostConnectionFactory.h"

+#include "Swiften/Network/BoostTimerFactory.h"

+#include "Swiften/TLS/PKCS12Certificate.h"

+#include "Swiften/Session/BasicSessionStream.h"

+

+namespace Swift {

+

+Client::Client(const JID& jid, const String& password) :

+ IQRouter(this), jid_(jid), password_(password) {

+ connectionFactory_ = new BoostConnectionFactory(&MainBoostIOServiceThread::getInstance().getIOService());

+ timerFactory_ = new BoostTimerFactory(&MainBoostIOServiceThread::getInstance().getIOService());

+ tlsLayerFactory_ = new PlatformTLSLayerFactory();

+}

+

+Client::~Client() {

+ if (session_ || connection_) {

+ std::cerr << "Warning: Client not disconnected properly" << std::endl;

+ }

+ delete tlsLayerFactory_;

+ delete timerFactory_;

+ delete connectionFactory_;

+}

+

+bool Client::isAvailable() {

+ return session_;

+}

+

+void Client::connect() {

+ assert(!connector_);

+ connector_ = boost::shared_ptr<Connector>(new Connector(jid_.getDomain(), &resolver_, connectionFactory_, timerFactory_));

+ connector_->onConnectFinished.connect(boost::bind(&Client::handleConnectorFinished, this, _1));

+ connector_->setTimeoutMilliseconds(60*1000);

+ connector_->start();

+}

+

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

+ // TODO: Add domain name resolver error

+ connector_.reset();

+ if (!connection) {

+ onError(ClientError::ConnectionError);

+ }

+ else {

+ assert(!connection_);

+ connection_ = connection;

+

+ assert(!sessionStream_);

+ sessionStream_ = boost::shared_ptr<BasicSessionStream>(new BasicSessionStream(connection_, &payloadParserFactories_, &payloadSerializers_, tlsLayerFactory_, timerFactory_));

+ if (!certificate_.isEmpty()) {

+ sessionStream_->setTLSCertificate(PKCS12Certificate(certificate_, password_));

+ }

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

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

+ sessionStream_->initialize();

+

+ session_ = ClientSession::create(jid_, sessionStream_);

+ session_->onInitialized.connect(boost::bind(boost::ref(onConnected)));

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

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

+ session_->onElementReceived.connect(boost::bind(&Client::handleElement, this, _1));

+ session_->start();

+ }

+}

+

+void Client::disconnect() {

+ if (session_) {

+ session_->finish();

+ }

+ else {

+ closeConnection();

+ }

+}

+

+void Client::closeConnection() {

+ if (sessionStream_) {

+ sessionStream_.reset();

+ }

+ if (connection_) {

+ connection_->disconnect();

+ connection_.reset();

+ }

+}

+

+void Client::send(boost::shared_ptr<Stanza> stanza) {

+ if (!isAvailable()) {

+ std::cerr << "Warning: Client: Trying to send a stanza while disconnected." << std::endl;

+ return;

+ }

+ session_->sendElement(stanza);

+}

+

+void Client::sendIQ(boost::shared_ptr<IQ> iq) {

+ send(iq);

+}

+

+void Client::sendMessage(boost::shared_ptr<Message> message) {

+ send(message);

+}

+

+void Client::sendPresence(boost::shared_ptr<Presence> presence) {

+ send(presence);

+}

+

+String Client::getNewIQID() {

+ return idGenerator_.generateID();

+}

+

+void Client::handleElement(boost::shared_ptr<Element> element) {

+ boost::shared_ptr<Message> message = boost::dynamic_pointer_cast<Message>(element);

+ if (message) {

+ onMessageReceived(message);

+ return;

+ }

+

+ boost::shared_ptr<Presence> presence = boost::dynamic_pointer_cast<Presence>(element);

+ if (presence) {

+ onPresenceReceived(presence);

+ return;

+ }

+

+ boost::shared_ptr<IQ> iq = boost::dynamic_pointer_cast<IQ>(element);

+ if (iq) {

+ onIQReceived(iq);

+ return;

+ }

+}

+

+void Client::setCertificate(const String& certificate) {

+ certificate_ = certificate;

+}

+

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

+ session_.reset();

+ closeConnection();

+ if (error) {

+ ClientError clientError;

+ if (boost::shared_ptr<ClientSession::Error> actualError = boost::dynamic_pointer_cast<ClientSession::Error>(error)) {

+ switch(actualError->type) {

+ case ClientSession::Error::AuthenticationFailedError:

+ clientError = ClientError(ClientError::AuthenticationFailedError);

+ break;

+ case ClientSession::Error::CompressionFailedError:

+ clientError = ClientError(ClientError::CompressionFailedError);

+ break;

+ case ClientSession::Error::ServerVerificationFailedError:

+ clientError = ClientError(ClientError::ServerVerificationFailedError);

+ break;

+ case ClientSession::Error::NoSupportedAuthMechanismsError:

+ clientError = ClientError(ClientError::NoSupportedAuthMechanismsError);

+ break;

+ case ClientSession::Error::UnexpectedElementError:

+ clientError = ClientError(ClientError::UnexpectedElementError);

+ break;

+ case ClientSession::Error::ResourceBindError:

+ clientError = ClientError(ClientError::ResourceBindError);

+ break;

+ case ClientSession::Error::SessionStartError:

+ clientError = ClientError(ClientError::SessionStartError);

+ break;

+ case ClientSession::Error::TLSError:

+ clientError = ClientError(ClientError::TLSError);

+ break;

+ case ClientSession::Error::TLSClientCertificateError:

+ clientError = ClientError(ClientError::ClientCertificateError);

+ break;

+ }

+ }

+ else if (boost::shared_ptr<SessionStream::Error> actualError = boost::dynamic_pointer_cast<SessionStream::Error>(error)) {

+ switch(actualError->type) {

+ case SessionStream::Error::ParseError:

+ clientError = ClientError(ClientError::XMLError);

+ break;

+ case SessionStream::Error::TLSError:

+ clientError = ClientError(ClientError::TLSError);

+ break;

+ case SessionStream::Error::InvalidTLSCertificateError:

+ clientError = ClientError(ClientError::ClientCertificateLoadError);

+ break;

+ case SessionStream::Error::ConnectionReadError:

+ clientError = ClientError(ClientError::ConnectionReadError);

+ break;

+ case SessionStream::Error::ConnectionWriteError:

+ clientError = ClientError(ClientError::ConnectionWriteError);

+ break;

+ }

+ }

+ onError(clientError);

+ }

+}

+

+void Client::handleNeedCredentials() {

+ assert(session_);

+ session_->sendCredentials(password_);

+}

+

+void Client::handleDataRead(const String& data) {

+ onDataRead(data);

+}

+

+void Client::handleDataWritten(const String& data) {

+ onDataWritten(data);

+}

+

+}

+#pragma once

+

+#include <boost/signals.hpp>

+#include <boost/shared_ptr.hpp>

+

+#include "Swiften/Network/PlatformDomainNameResolver.h"

+#include "Swiften/Base/Error.h"

+#include "Swiften/Client/ClientSession.h"

+#include "Swiften/Client/ClientError.h"

+#include "Swiften/Elements/Presence.h"

+#include "Swiften/Elements/Message.h"

+#include "Swiften/JID/JID.h"

+#include "Swiften/Base/String.h"

+#include "Swiften/Base/IDGenerator.h"

+#include "Swiften/Client/StanzaChannel.h"

+#include "Swiften/Queries/IQRouter.h"

+#include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"

+#include "Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h"

+

+namespace Swift {

+ class TLSLayerFactory;

+ class ConnectionFactory;

+ class TimerFactory;

+ class ClientSession;

+ class BasicSessionStream;

+ class Connector;

+

+ class Client : public StanzaChannel, public IQRouter, public boost::bsignals::trackable {

+ public:

+ Client(const JID& jid, const String& password);

+ ~Client();

+

+ void setCertificate(const String& certificate);

+

+ void connect();

+ void disconnect();

+

+ bool isAvailable();

+

+ virtual void sendIQ(boost::shared_ptr<IQ>);

+ virtual void sendMessage(boost::shared_ptr<Message>);

+ virtual void sendPresence(boost::shared_ptr<Presence>);

+

+ public:

+ boost::signal<void (const ClientError&)> onError;

+ boost::signal<void ()> onConnected;

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

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

+

+ private:

+ void handleConnectorFinished(boost::shared_ptr<Connection>);

+ void send(boost::shared_ptr<Stanza>);

+ virtual String getNewIQID();

+ void handleElement(boost::shared_ptr<Element>);

+ void handleSessionFinished(boost::shared_ptr<Error>);

+ void handleNeedCredentials();

+ void handleDataRead(const String&);

+ void handleDataWritten(const String&);

+

+ void closeConnection();

+

+ private:

+ PlatformDomainNameResolver resolver_;

+ JID jid_;

+ String password_;

+ IDGenerator idGenerator_;

+ boost::shared_ptr<Connector> connector_;

+ ConnectionFactory* connectionFactory_;

+ TimerFactory* timerFactory_;

+ TLSLayerFactory* tlsLayerFactory_;

+ FullPayloadParserFactoryCollection payloadParserFactories_;

+ FullPayloadSerializerCollection payloadSerializers_;

+ boost::shared_ptr<Connection> connection_;

+ boost::shared_ptr<BasicSessionStream> sessionStream_;

+ boost::shared_ptr<ClientSession> session_;

+ String certificate_;

+ };

+}

+#pragma once

+

+namespace Swift {

+ class ClientError {

+ public:

+ enum Type {

+ UnknownError,

+ DomainNameResolveError,

+ ConnectionError,

+ ConnectionReadError,

+ ConnectionWriteError,

+ XMLError,

+ AuthenticationFailedError,

+ CompressionFailedError,

+ ServerVerificationFailedError,

+ NoSupportedAuthMechanismsError,

+ UnexpectedElementError,

+ ResourceBindError,

+ SessionStartError,

+ TLSError,

+ ClientCertificateLoadError,

+ ClientCertificateError

+ };

+

+ ClientError(Type type = UnknownError) : type_(type) {}

+

+ Type getType() const { return type_; }

+

+ private:

+ Type type_;

+ };

+}

+#include "Swiften/Client/ClientSession.h"

+

+#include <boost/bind.hpp>

+

+#include "Swiften/Elements/ProtocolHeader.h"

+#include "Swiften/Elements/StreamFeatures.h"

+#include "Swiften/Elements/StartTLSRequest.h"

+#include "Swiften/Elements/StartTLSFailure.h"

+#include "Swiften/Elements/TLSProceed.h"

+#include "Swiften/Elements/AuthRequest.h"

+#include "Swiften/Elements/AuthSuccess.h"

+#include "Swiften/Elements/AuthFailure.h"

+#include "Swiften/Elements/AuthChallenge.h"

+#include "Swiften/Elements/AuthResponse.h"

+#include "Swiften/Elements/Compressed.h"

+#include "Swiften/Elements/CompressFailure.h"

+#include "Swiften/Elements/CompressRequest.h"

+#include "Swiften/Elements/StartSession.h"

+#include "Swiften/Elements/IQ.h"

+#include "Swiften/Elements/ResourceBind.h"

+#include "Swiften/SASL/PLAINClientAuthenticator.h"

+#include "Swiften/SASL/SCRAMSHA1ClientAuthenticator.h"

+#include "Swiften/Session/SessionStream.h"

+

+namespace Swift {

+

+ClientSession::ClientSession(

+ const JID& jid,

+ boost::shared_ptr<SessionStream> stream) :

+ localJID(jid),

+ state(Initial),

+ stream(stream),

+ needSessionStart(false),

+ authenticator(NULL) {

+}

+

+ClientSession::~ClientSession() {

+}

+

+void ClientSession::start() {

+ stream->onStreamStartReceived.connect(boost::bind(&ClientSession::handleStreamStart, shared_from_this(), _1));

+ stream->onElementReceived.connect(boost::bind(&ClientSession::handleElement, shared_from_this(), _1));

+ stream->onError.connect(boost::bind(&ClientSession::handleStreamError, shared_from_this(), _1));

+ stream->onTLSEncrypted.connect(boost::bind(&ClientSession::handleTLSEncrypted, shared_from_this()));

+

+ assert(state == Initial);

+ state = WaitingForStreamStart;

+ sendStreamHeader();

+}

+

+void ClientSession::sendStreamHeader() {

+ ProtocolHeader header;

+ header.setTo(getRemoteJID());

+ stream->writeHeader(header);

+}

+

+void ClientSession::sendElement(boost::shared_ptr<Element> element) {

+ stream->writeElement(element);

+}

+

+void ClientSession::handleStreamStart(const ProtocolHeader&) {

+ checkState(WaitingForStreamStart);

+ state = Negotiating;

+}

+

+void ClientSession::handleElement(boost::shared_ptr<Element> element) {

+ if (getState() == Initialized) {

+ onElementReceived(element);

+ }

+ else if (StreamFeatures* streamFeatures = dynamic_cast<StreamFeatures*>(element.get())) {

+ if (!checkState(Negotiating)) {

+ return;

+ }

+

+ if (streamFeatures->hasStartTLS() && stream->supportsTLSEncryption()) {

+ state = WaitingForEncrypt;

+ stream->writeElement(boost::shared_ptr<StartTLSRequest>(new StartTLSRequest()));

+ }

+ else if (streamFeatures->hasCompressionMethod("zlib")) {

+ state = Compressing;

+ stream->writeElement(boost::shared_ptr<CompressRequest>(new CompressRequest("zlib")));

+ }

+ else if (streamFeatures->hasAuthenticationMechanisms()) {

+ if (stream->hasTLSCertificate()) {

+ if (streamFeatures->hasAuthenticationMechanism("EXTERNAL")) {

+ state = Authenticating;

+ stream->writeElement(boost::shared_ptr<Element>(new AuthRequest("EXTERNAL", "")));

+ }

+ else {

+ finishSession(Error::TLSClientCertificateError);

+ }

+ }

+ else if (streamFeatures->hasAuthenticationMechanism("SCRAM-SHA-1")) {

+ // FIXME: Use a real nonce

+ authenticator = new SCRAMSHA1ClientAuthenticator("ClientNonce");

+ state = WaitingForCredentials;

+ onNeedCredentials();

+ }

+ else if (streamFeatures->hasAuthenticationMechanism("PLAIN")) {

+ authenticator = new PLAINClientAuthenticator();

+ state = WaitingForCredentials;

+ onNeedCredentials();

+ }

+ else {

+ finishSession(Error::NoSupportedAuthMechanismsError);

+ }

+ }

+ else {

+ // Start the session

+ stream->setWhitespacePingEnabled(true);

+

+ if (streamFeatures->hasSession()) {

+ needSessionStart = true;

+ }

+

+ if (streamFeatures->hasResourceBind()) {

+ state = BindingResource;

+ boost::shared_ptr<ResourceBind> resourceBind(new ResourceBind());

+ if (!localJID.getResource().isEmpty()) {

+ resourceBind->setResource(localJID.getResource());

+ }

+ stream->writeElement(IQ::createRequest(IQ::Set, JID(), "session-bind", resourceBind));

+ }

+ else if (needSessionStart) {

+ sendSessionStart();

+ }

+ else {

+ state = Initialized;

+ onInitialized();

+ }

+ }

+ }

+ else if (boost::dynamic_pointer_cast<Compressed>(element)) {

+ checkState(Compressing);

+ state = WaitingForStreamStart;

+ stream->addZLibCompression();

+ stream->resetXMPPParser();

+ sendStreamHeader();

+ }

+ else if (boost::dynamic_pointer_cast<CompressFailure>(element)) {

+ finishSession(Error::CompressionFailedError);

+ }

+ else if (AuthChallenge* challenge = dynamic_cast<AuthChallenge*>(element.get())) {

+ checkState(Authenticating);

+ assert(authenticator);

+ if (authenticator->setChallenge(challenge->getValue())) {

+ stream->writeElement(boost::shared_ptr<AuthResponse>(new AuthResponse(authenticator->getResponse())));

+ }

+ else {

+ finishSession(Error::AuthenticationFailedError);

+ }

+ }

+ else if (AuthSuccess* authSuccess = dynamic_cast<AuthSuccess*>(element.get())) {

+ checkState(Authenticating);

+ if (authenticator && !authenticator->setChallenge(authSuccess->getValue())) {

+ finishSession(Error::ServerVerificationFailedError);

+ }

+ else {

+ state = WaitingForStreamStart;

+ delete authenticator;

+ authenticator = NULL;

+ stream->resetXMPPParser();

+ sendStreamHeader();

+ }

+ }

+ else if (dynamic_cast<AuthFailure*>(element.get())) {

+ delete authenticator;

+ authenticator = NULL;

+ finishSession(Error::AuthenticationFailedError);

+ }

+ else if (dynamic_cast<TLSProceed*>(element.get())) {

+ checkState(WaitingForEncrypt);

+ state = Encrypting;

+ stream->addTLSEncryption();

+ }

+ else if (dynamic_cast<StartTLSFailure*>(element.get())) {

+ finishSession(Error::TLSError);

+ }

+ else if (IQ* iq = dynamic_cast<IQ*>(element.get())) {

+ if (state == BindingResource) {

+ boost::shared_ptr<ResourceBind> resourceBind(iq->getPayload<ResourceBind>());

+ if (iq->getType() == IQ::Error && iq->getID() == "session-bind") {

+ finishSession(Error::ResourceBindError);

+ }

+ else if (!resourceBind) {

+ finishSession(Error::UnexpectedElementError);

+ }

+ else if (iq->getType() == IQ::Result) {

+ localJID = resourceBind->getJID();

+ if (!localJID.isValid()) {

+ finishSession(Error::ResourceBindError);

+ }

+ if (needSessionStart) {

+ sendSessionStart();

+ }

+ else {

+ state = Initialized;

+ }

+ }

+ else {

+ finishSession(Error::UnexpectedElementError);

+ }

+ }

+ else if (state == StartingSession) {

+ if (iq->getType() == IQ::Result) {

+ state = Initialized;

+ onInitialized();

+ }

+ else if (iq->getType() == IQ::Error) {

+ finishSession(Error::SessionStartError);

+ }

+ else {

+ finishSession(Error::UnexpectedElementError);

+ }

+ }

+ else {

+ finishSession(Error::UnexpectedElementError);

+ }

+ }

+ else {

+ // FIXME Not correct?

+ state = Initialized;

+ onInitialized();

+ }

+}

+

+void ClientSession::sendSessionStart() {

+ state = StartingSession;

+ stream->writeElement(IQ::createRequest(IQ::Set, JID(), "session-start", boost::shared_ptr<StartSession>(new StartSession())));

+}

+

+bool ClientSession::checkState(State state) {

+ if (state != state) {

+ finishSession(Error::UnexpectedElementError);

+ return false;

+ }

+ return true;

+}

+

+void ClientSession::sendCredentials(const String& password) {

+ assert(WaitingForCredentials);

+ state = Authenticating;

+ authenticator->setCredentials(localJID.getNode(), password);

+ stream->writeElement(boost::shared_ptr<AuthRequest>(new AuthRequest(authenticator->getName(), authenticator->getResponse())));

+}

+

+void ClientSession::handleTLSEncrypted() {

+ checkState(WaitingForEncrypt);

+ state = WaitingForStreamStart;

+ stream->resetXMPPParser();

+ sendStreamHeader();

+}

+

+void ClientSession::handleStreamError(boost::shared_ptr<Swift::Error> error) {

+ finishSession(error);

+}

+

+void ClientSession::finish() {

+ if (stream->isAvailable()) {

+ stream->writeFooter();

+ }

+ finishSession(boost::shared_ptr<Error>());

+}

+

+void ClientSession::finishSession(Error::Type error) {

+ finishSession(boost::shared_ptr<Swift::ClientSession::Error>(new Swift::ClientSession::Error(error)));

+}

+

+void ClientSession::finishSession(boost::shared_ptr<Swift::Error> error) {

+ state = Finished;

+ stream->setWhitespacePingEnabled(false);

+ onFinished(error);

+}

+

+

+}

+#pragma once

+

+#include <boost/signal.hpp>

+#include <boost/shared_ptr.hpp>

+#include <boost/enable_shared_from_this.hpp>

+

+#include "Swiften/Base/Error.h"

+#include "Swiften/Session/SessionStream.h"

+#include "Swiften/Session/BasicSessionStream.h"

+#include "Swiften/Base/String.h"

+#include "Swiften/JID/JID.h"

+#include "Swiften/Elements/Element.h"

+

+namespace Swift {

+ class ClientAuthenticator;

+

+ class ClientSession : public boost::enable_shared_from_this<ClientSession> {

+ public:

+ enum State {

+ Initial,

+ WaitingForStreamStart,

+ Negotiating,

+ Compressing,

+ WaitingForEncrypt,

+ Encrypting,

+ WaitingForCredentials,

+ Authenticating,

+ BindingResource,

+ StartingSession,

+ Initialized,

+ Finished

+ };

+

+ struct Error : public Swift::Error {

+ enum Type {

+ AuthenticationFailedError,

+ CompressionFailedError,

+ ServerVerificationFailedError,

+ NoSupportedAuthMechanismsError,

+ UnexpectedElementError,

+ ResourceBindError,

+ SessionStartError,

+ TLSClientCertificateError,

+ TLSError,

+ } type;

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

+ };

+

+ ~ClientSession();

+ static boost::shared_ptr<ClientSession> create(const JID& jid, boost::shared_ptr<SessionStream> stream) {

+ return boost::shared_ptr<ClientSession>(new ClientSession(jid, stream));

+ }

+

+ State getState() const {

+ return state;

+ }

+

+ void start();

+ void finish();

+

+ void sendCredentials(const String& password);

+ void sendElement(boost::shared_ptr<Element> element);

+

+ public:

+ boost::signal<void ()> onNeedCredentials;

+ boost::signal<void ()> onInitialized;

+ boost::signal<void (boost::shared_ptr<Swift::Error>)> onFinished;

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

+

+ private:

+ ClientSession(

+ const JID& jid,

+ boost::shared_ptr<SessionStream>);

+

+ void finishSession(Error::Type error);

+ void finishSession(boost::shared_ptr<Swift::Error> error);

+

+ JID getRemoteJID() const {

+ return JID("", localJID.getDomain());

+ }

+

+ void sendStreamHeader();

+ void sendSessionStart();

+

+ void handleElement(boost::shared_ptr<Element>);

+ void handleStreamStart(const ProtocolHeader&);

+ void handleStreamError(boost::shared_ptr<Swift::Error>);

+

+ void handleTLSEncrypted();

+

+ bool checkState(State);

+

+ private:

+ JID localJID;

+ State state;

+ boost::shared_ptr<SessionStream> stream;

+ bool needSessionStart;

+ ClientAuthenticator* authenticator;

+ };

+}

+#pragma once

+

+#include "Swiften/Client/Client.h"

+

+namespace Swift {

+ class ClientXMLTracer {

+ public:

+ ClientXMLTracer(Client* client) {

+ client->onDataRead.connect(boost::bind(&ClientXMLTracer::printData, '<', _1));

+ client->onDataWritten.connect(boost::bind(&ClientXMLTracer::printData, '>', _1));

+ }

+

+ private:

+ static void printData(char direction, const String& data) {

+ printLine(direction);

+ std::cerr << data << std::endl;

+ }

+

+ static void printLine(char c) {

+ for (unsigned int i = 0; i < 80; ++i) {

+ std::cerr << c;

+ }

+ std::cerr << std::endl;

+ }

+ };

+}

+#pragma once

+

+#include <vector>

+

+#include "Swiften/Client/StanzaChannel.h"

+

+namespace Swift {

+ class DummyStanzaChannel : public StanzaChannel {

+ public:

+ DummyStanzaChannel() {}

+

+ virtual void sendStanza(boost::shared_ptr<Stanza> stanza) {

+ sentStanzas.push_back(stanza);

+ }

+

+ virtual void sendIQ(boost::shared_ptr<IQ> iq) {

+ sentStanzas.push_back(iq);

+ }

+

+ virtual void sendMessage(boost::shared_ptr<Message> message) {

+ sentStanzas.push_back(message);

+ }

+

+ virtual void sendPresence(boost::shared_ptr<Presence> presence) {

+ sentStanzas.push_back(presence);

+ }

+

+ virtual String getNewIQID() {

+ return "test-id";

+ }

+

+ virtual bool isAvailable() {

+ return true;

+ }

+

+ std::vector<boost::shared_ptr<Stanza> > sentStanzas;

+ };

+}

+#pragma once

+

+#include <boost/signal.hpp>

+#include <boost/shared_ptr.hpp>

+

+#include "Swiften/Queries/IQChannel.h"

+#include "Swiften/Elements/Message.h"

+#include "Swiften/Elements/Presence.h"

+

+namespace Swift {

+ class StanzaChannel : public IQChannel {

+ public:

+ virtual void sendMessage(boost::shared_ptr<Message>) = 0;

+ virtual void sendPresence(boost::shared_ptr<Presence>) = 0;

+ virtual bool isAvailable() = 0;

+

+ boost::signal<void (boost::shared_ptr<Message>)> onMessageReceived;

+ boost::signal<void (boost::shared_ptr<Presence>) > onPresenceReceived;

+ };

+}

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+#include <deque>

+#include <boost/bind.hpp>

+#include <boost/optional.hpp>

+

+#include "Swiften/Session/SessionStream.h"

+#include "Swiften/Client/ClientSession.h"

+#include "Swiften/Elements/StartTLSRequest.h"

+#include "Swiften/Elements/StreamFeatures.h"

+#include "Swiften/Elements/TLSProceed.h"

+#include "Swiften/Elements/StartTLSFailure.h"

+#include "Swiften/Elements/AuthRequest.h"

+#include "Swiften/Elements/AuthSuccess.h"

+#include "Swiften/Elements/AuthFailure.h"

+

+using namespace Swift;

+

+class ClientSessionTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(ClientSessionTest);

+ CPPUNIT_TEST(testStart_Error);

+ CPPUNIT_TEST(testStartTLS);

+ CPPUNIT_TEST(testStartTLS_ServerError);

+ CPPUNIT_TEST(testStartTLS_ConnectError);

+ CPPUNIT_TEST(testAuthenticate);

+ CPPUNIT_TEST(testAuthenticate_Unauthorized);

+ CPPUNIT_TEST(testAuthenticate_NoValidAuthMechanisms);

+ /*

+ CPPUNIT_TEST(testResourceBind);

+ CPPUNIT_TEST(testResourceBind_ChangeResource);

+ CPPUNIT_TEST(testResourceBind_EmptyResource);

+ CPPUNIT_TEST(testResourceBind_Error);

+ CPPUNIT_TEST(testSessionStart);

+ CPPUNIT_TEST(testSessionStart_Error);

+ CPPUNIT_TEST(testSessionStart_AfterResourceBind);

+ CPPUNIT_TEST(testWhitespacePing);

+ CPPUNIT_TEST(testReceiveElementAfterSessionStarted);

+ CPPUNIT_TEST(testSendElement);

+ */

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void setUp() {

+ server = boost::shared_ptr<MockSessionStream>(new MockSessionStream());

+ sessionFinishedReceived = false;

+ needCredentials = false;

+ }

+

+ void testStart_Error() {

+ boost::shared_ptr<ClientSession> session(createSession());

+ session->start();

+ server->breakConnection();

+

+ CPPUNIT_ASSERT_EQUAL(ClientSession::Finished, session->getState());

+ CPPUNIT_ASSERT(sessionFinishedReceived);

+ CPPUNIT_ASSERT(sessionFinishedError);

+ }

+

+ void testStartTLS() {

+ boost::shared_ptr<ClientSession> session(createSession());

+ session->start();

+ server->receiveStreamStart();

+ server->sendStreamStart();

+ server->sendStreamFeaturesWithStartTLS();

+ server->receiveStartTLS();

+ CPPUNIT_ASSERT(!server->tlsEncrypted);

+ server->sendTLSProceed();

+ CPPUNIT_ASSERT(server->tlsEncrypted);

+ server->onTLSEncrypted();

+ server->receiveStreamStart();

+ server->sendStreamStart();

+ }

+

+ void testStartTLS_ServerError() {

+ boost::shared_ptr<ClientSession> session(createSession());

+ session->start();

+ server->receiveStreamStart();

+ server->sendStreamStart();

+ server->sendStreamFeaturesWithStartTLS();

+ server->receiveStartTLS();

+ server->sendTLSFailure();

+

+ CPPUNIT_ASSERT(!server->tlsEncrypted);

+ CPPUNIT_ASSERT_EQUAL(ClientSession::Finished, session->getState());

+ CPPUNIT_ASSERT(sessionFinishedReceived);

+ CPPUNIT_ASSERT(sessionFinishedError);

+ }

+

+ void testStartTLS_ConnectError() {

+ boost::shared_ptr<ClientSession> session(createSession());

+ session->start();

+ server->receiveStreamStart();

+ server->sendStreamStart();

+ server->sendStreamFeaturesWithStartTLS();

+ server->receiveStartTLS();

+ server->sendTLSProceed();

+ server->breakTLS();

+

+ CPPUNIT_ASSERT_EQUAL(ClientSession::Finished, session->getState());

+ CPPUNIT_ASSERT(sessionFinishedReceived);

+ CPPUNIT_ASSERT(sessionFinishedError);

+ }

+

+ void testAuthenticate() {

+ boost::shared_ptr<ClientSession> session(createSession());

+ session->start();

+ server->receiveStreamStart();

+ server->sendStreamStart();

+ server->sendStreamFeaturesWithPLAINAuthentication();

+ CPPUNIT_ASSERT(needCredentials);

+ CPPUNIT_ASSERT_EQUAL(ClientSession::WaitingForCredentials, session->getState());

+ session->sendCredentials("mypass");

+ server->receiveAuthRequest("PLAIN");

+ server->sendAuthSuccess();

+ server->receiveStreamStart();

+ }

+

+ void testAuthenticate_Unauthorized() {

+ boost::shared_ptr<ClientSession> session(createSession());

+ session->start();

+ server->receiveStreamStart();

+ server->sendStreamStart();

+ server->sendStreamFeaturesWithPLAINAuthentication();

+ CPPUNIT_ASSERT(needCredentials);

+ CPPUNIT_ASSERT_EQUAL(ClientSession::WaitingForCredentials, session->getState());

+ session->sendCredentials("mypass");

+ server->receiveAuthRequest("PLAIN");

+ server->sendAuthFailure();

+

+ CPPUNIT_ASSERT_EQUAL(ClientSession::Finished, session->getState());

+ CPPUNIT_ASSERT(sessionFinishedReceived);

+ CPPUNIT_ASSERT(sessionFinishedError);

+ }

+

+ void testAuthenticate_NoValidAuthMechanisms() {

+ boost::shared_ptr<ClientSession> session(createSession());

+ session->start();

+ server->receiveStreamStart();

+ server->sendStreamStart();

+ server->sendStreamFeaturesWithUnknownAuthentication();

+

+ CPPUNIT_ASSERT_EQUAL(ClientSession::Finished, session->getState());

+ CPPUNIT_ASSERT(sessionFinishedReceived);

+ CPPUNIT_ASSERT(sessionFinishedError);

+ }

+

+ private:

+ boost::shared_ptr<ClientSession> createSession() {

+ boost::shared_ptr<ClientSession> session = ClientSession::create(JID("me@foo.com"), server);

+ session->onFinished.connect(boost::bind(&ClientSessionTest::handleSessionFinished, this, _1));

+ session->onNeedCredentials.connect(boost::bind(&ClientSessionTest::handleSessionNeedCredentials, this));

+ return session;

+ }

+

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

+ sessionFinishedReceived = true;

+ sessionFinishedError = error;

+ }

+

+ void handleSessionNeedCredentials() {

+ needCredentials = true;

+ }

+

+ class MockSessionStream : public SessionStream {

+ public:

+ struct Event {

+ Event(boost::shared_ptr<Element> element) : element(element), footer(false) {}

+ Event(const ProtocolHeader& header) : header(header), footer(false) {}

+ Event() : footer(true) {}

+

+ boost::shared_ptr<Element> element;

+ boost::optional<ProtocolHeader> header;

+ bool footer;

+ };

+

+ MockSessionStream() : available(true), canTLSEncrypt(true), tlsEncrypted(false), compressed(false), whitespacePingEnabled(false), resetCount(0) {

+ }

+

+ virtual bool isAvailable() {

+ return available;

+ }

+

+ virtual void writeHeader(const ProtocolHeader& header) {

+ receivedEvents.push_back(Event(header));

+ }

+

+ virtual void writeFooter() {

+ receivedEvents.push_back(Event());

+ }

+

+ virtual void writeElement(boost::shared_ptr<Element> element) {

+ receivedEvents.push_back(Event(element));

+ }

+

+ virtual bool supportsTLSEncryption() {

+ return canTLSEncrypt;

+ }

+

+ virtual void addTLSEncryption() {

+ tlsEncrypted = true;

+ }

+

+ virtual void addZLibCompression() {

+ compressed = true;

+ }

+

+ virtual void setWhitespacePingEnabled(bool enabled) {

+ whitespacePingEnabled = enabled;

+ }

+

+ virtual void resetXMPPParser() {

+ resetCount++;

+ }

+

+ void breakConnection() {

+ onError(boost::shared_ptr<SessionStream::Error>(new SessionStream::Error(SessionStream::Error::ConnectionReadError)));

+ }

+

+ void breakTLS() {

+ onError(boost::shared_ptr<SessionStream::Error>(new SessionStream::Error(SessionStream::Error::TLSError)));

+ }

+

+

+ void sendStreamStart() {

+ ProtocolHeader header;

+ header.setTo("foo.com");

+ return onStreamStartReceived(header);

+ }

+

+ void sendStreamFeaturesWithStartTLS() {

+ boost::shared_ptr<StreamFeatures> streamFeatures(new StreamFeatures());

+ streamFeatures->setHasStartTLS();

+ onElementReceived(streamFeatures);

+ }

+

+ void sendTLSProceed() {

+ onElementReceived(boost::shared_ptr<TLSProceed>(new TLSProceed()));

+ }

+

+ void sendTLSFailure() {

+ onElementReceived(boost::shared_ptr<StartTLSFailure>(new StartTLSFailure()));

+ }

+

+ void sendStreamFeaturesWithPLAINAuthentication() {

+ boost::shared_ptr<StreamFeatures> streamFeatures(new StreamFeatures());

+ streamFeatures->addAuthenticationMechanism("PLAIN");

+ onElementReceived(streamFeatures);

+ }

+

+ void sendStreamFeaturesWithUnknownAuthentication() {

+ boost::shared_ptr<StreamFeatures> streamFeatures(new StreamFeatures());

+ streamFeatures->addAuthenticationMechanism("UNKNOWN");

+ onElementReceived(streamFeatures);

+ }

+

+ void sendAuthSuccess() {

+ onElementReceived(boost::shared_ptr<AuthSuccess>(new AuthSuccess()));

+ }

+

+ void sendAuthFailure() {

+ onElementReceived(boost::shared_ptr<AuthFailure>(new AuthFailure()));

+ }

+

+ void receiveStreamStart() {

+ Event event = popEvent();

+ CPPUNIT_ASSERT(event.header);

+ }

+

+ void receiveStartTLS() {

+ Event event = popEvent();

+ CPPUNIT_ASSERT(event.element);

+ CPPUNIT_ASSERT(boost::dynamic_pointer_cast<StartTLSRequest>(event.element));

+ }

+

+ void receiveAuthRequest(const String& mech) {

+ Event event = popEvent();

+ CPPUNIT_ASSERT(event.element);

+ boost::shared_ptr<AuthRequest> request(boost::dynamic_pointer_cast<AuthRequest>(event.element));

+ CPPUNIT_ASSERT(request);

+ CPPUNIT_ASSERT_EQUAL(mech, request->getMechanism());

+ }

+

+ Event popEvent() {

+ CPPUNIT_ASSERT(receivedEvents.size() > 0);

+ Event event = receivedEvents.front();

+ receivedEvents.pop_front();

+ return event;

+ }

+

+ bool available;

+ bool canTLSEncrypt;

+ bool tlsEncrypted;

+ bool compressed;

+ bool whitespacePingEnabled;

+ int resetCount;

+ std::deque<Event> receivedEvents;

+ };

+

+ boost::shared_ptr<MockSessionStream> server;

+ bool sessionFinishedReceived;

+ bool needCredentials;

+ boost::shared_ptr<Error> sessionFinishedError;

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(ClientSessionTest);

+

+#if 0

+ void testAuthenticate() {

+ boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

+ session->onNeedCredentials.connect(boost::bind(&ClientSessionTest::setNeedCredentials, this));

+ getMockServer()->expectStreamStart();

+ getMockServer()->sendStreamStart();

+ getMockServer()->sendStreamFeaturesWithAuthentication();

+ session->startSession();

+ processEvents();

+ CPPUNIT_ASSERT_EQUAL(ClientSession::WaitingForCredentials, session->getState());

+ CPPUNIT_ASSERT(needCredentials_);

+

+ getMockServer()->expectAuth("me", "mypass");

+ getMockServer()->sendAuthSuccess();

+ getMockServer()->expectStreamStart();

+ getMockServer()->sendStreamStart();

+ session->sendCredentials("mypass");

+ CPPUNIT_ASSERT_EQUAL(ClientSession::Authenticating, session->getState());

+ processEvents();

+ CPPUNIT_ASSERT_EQUAL(ClientSession::Negotiating, session->getState());

+ }

+

+ void testAuthenticate_Unauthorized() {

+ boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

+ getMockServer()->expectStreamStart();

+ getMockServer()->sendStreamStart();

+ getMockServer()->sendStreamFeaturesWithAuthentication();

+ session->startSession();

+ processEvents();

+

+ getMockServer()->expectAuth("me", "mypass");

+ getMockServer()->sendAuthFailure();

+ session->sendCredentials("mypass");

+ processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(ClientSession::Error, session->getState());

+ CPPUNIT_ASSERT_EQUAL(ClientSession::AuthenticationFailedError, *session->getError());

+ }

+

+ void testAuthenticate_NoValidAuthMechanisms() {

+ boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

+ getMockServer()->expectStreamStart();

+ getMockServer()->sendStreamStart();

+ getMockServer()->sendStreamFeaturesWithUnsupportedAuthentication();

+ session->startSession();

+ processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(ClientSession::Error, session->getState());

+ CPPUNIT_ASSERT_EQUAL(ClientSession::NoSupportedAuthMechanismsError, *session->getError());

+ }

+

+ void testResourceBind() {

+ boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

+ getMockServer()->expectStreamStart();

+ getMockServer()->sendStreamStart();

+ getMockServer()->sendStreamFeaturesWithResourceBind();

+ getMockServer()->expectResourceBind("Bar", "session-bind");

+ // FIXME: Check CPPUNIT_ASSERT_EQUAL(ClientSession::BindingResource, session->getState());

+ getMockServer()->sendResourceBindResponse("me@foo.com/Bar", "session-bind");

+ session->startSession();

+

+ processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(ClientSession::SessionStarted, session->getState());

+ CPPUNIT_ASSERT_EQUAL(JID("me@foo.com/Bar"), session->getLocalJID());

+ }

+

+ void testResourceBind_ChangeResource() {

+ boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

+ getMockServer()->expectStreamStart();

+ getMockServer()->sendStreamStart();

+ getMockServer()->sendStreamFeaturesWithResourceBind();

+ getMockServer()->expectResourceBind("Bar", "session-bind");

+ getMockServer()->sendResourceBindResponse("me@foo.com/Bar123", "session-bind");

+ session->startSession();

+ processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(ClientSession::SessionStarted, session->getState());

+ CPPUNIT_ASSERT_EQUAL(JID("me@foo.com/Bar123"), session->getLocalJID());

+ }

+

+ void testResourceBind_EmptyResource() {

+ boost::shared_ptr<MockSession> session(createSession("me@foo.com"));

+ getMockServer()->expectStreamStart();

+ getMockServer()->sendStreamStart();

+ getMockServer()->sendStreamFeaturesWithResourceBind();

+ getMockServer()->expectResourceBind("", "session-bind");

+ getMockServer()->sendResourceBindResponse("me@foo.com/NewResource", "session-bind");

+ session->startSession();

+ processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(ClientSession::SessionStarted, session->getState());

+ CPPUNIT_ASSERT_EQUAL(JID("me@foo.com/NewResource"), session->getLocalJID());

+ }

+

+ void testResourceBind_Error() {

+ boost::shared_ptr<MockSession> session(createSession("me@foo.com"));

+ getMockServer()->expectStreamStart();

+ getMockServer()->sendStreamStart();

+ getMockServer()->sendStreamFeaturesWithResourceBind();

+ getMockServer()->expectResourceBind("", "session-bind");

+ getMockServer()->sendError("session-bind");

+ session->startSession();

+ processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(ClientSession::Error, session->getState());

+ CPPUNIT_ASSERT_EQUAL(ClientSession::ResourceBindError, *session->getError());

+ }

+

+ void testSessionStart() {

+ boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

+ session->onSessionStarted.connect(boost::bind(&ClientSessionTest::setSessionStarted, this));

+ getMockServer()->expectStreamStart();

+ getMockServer()->sendStreamStart();

+ getMockServer()->sendStreamFeaturesWithSession();

+ getMockServer()->expectSessionStart("session-start");

+ // FIXME: Check CPPUNIT_ASSERT_EQUAL(ClientSession::StartingSession, session->getState());

+ getMockServer()->sendSessionStartResponse("session-start");

+ session->startSession();

+ processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(ClientSession::SessionStarted, session->getState());

+ CPPUNIT_ASSERT(sessionStarted_);

+ }

+

+ void testSessionStart_Error() {

+ boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

+ getMockServer()->expectStreamStart();

+ getMockServer()->sendStreamStart();

+ getMockServer()->sendStreamFeaturesWithSession();

+ getMockServer()->expectSessionStart("session-start");

+ getMockServer()->sendError("session-start");

+ session->startSession();

+ processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(ClientSession::Error, session->getState());

+ CPPUNIT_ASSERT_EQUAL(ClientSession::SessionStartError, *session->getError());

+ }

+

+ void testSessionStart_AfterResourceBind() {

+ boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

+ session->onSessionStarted.connect(boost::bind(&ClientSessionTest::setSessionStarted, this));

+ getMockServer()->expectStreamStart();

+ getMockServer()->sendStreamStart();

+ getMockServer()->sendStreamFeaturesWithResourceBindAndSession();

+ getMockServer()->expectResourceBind("Bar", "session-bind");

+ getMockServer()->sendResourceBindResponse("me@foo.com/Bar", "session-bind");

+ getMockServer()->expectSessionStart("session-start");

+ getMockServer()->sendSessionStartResponse("session-start");

+ session->startSession();

+ processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(ClientSession::SessionStarted, session->getState());

+ CPPUNIT_ASSERT(sessionStarted_);

+ }

+

+ void testWhitespacePing() {

+ boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

+ getMockServer()->expectStreamStart();

+ getMockServer()->sendStreamStart();

+ getMockServer()->sendStreamFeatures();

+ session->startSession();

+ processEvents();

+ CPPUNIT_ASSERT(session->getWhitespacePingLayer());

+ }

+

+ void testReceiveElementAfterSessionStarted() {

+ boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

+ getMockServer()->expectStreamStart();

+ getMockServer()->sendStreamStart();

+ getMockServer()->sendStreamFeatures();

+ session->startSession();

+ processEvents();

+

+ getMockServer()->expectMessage();

+ session->sendElement(boost::shared_ptr<Message>(new Message()));

+ }

+

+ void testSendElement() {

+ boost::shared_ptr<MockSession> session(createSession("me@foo.com/Bar"));

+ session->onElementReceived.connect(boost::bind(&ClientSessionTest::addReceivedElement, this, _1));

+ getMockServer()->expectStreamStart();

+ getMockServer()->sendStreamStart();

+ getMockServer()->sendStreamFeatures();

+ getMockServer()->sendMessage();

+ session->startSession();

+ processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(receivedElements_.size()));

+ CPPUNIT_ASSERT(boost::dynamic_pointer_cast<Message>(receivedElements_[0]));

+ }

+#endif