4 files changed, 16 insertions, 7 deletions
diff --git a/Swiften/Client/Client.cpp b/Swiften/Client/Client.cpp
index 2bd039a..874e23b 100644
--- a/Swiften/Client/Client.cpp
+++ b/Swiften/Client/Client.cpp
@@ -96,96 +96,99 @@ 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) {
 	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::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);
 	}
 	session_.reset();
 }
 
 void Client::handleNeedCredentials() {
 	session_->sendCredentials(password_);
 }
 
diff --git a/Swiften/Client/ClientError.h b/Swiften/Client/ClientError.h
index d4f280c..55c57fc 100644
--- a/Swiften/Client/ClientError.h
+++ b/Swiften/Client/ClientError.h
@@ -1,30 +1,31 @@
 #pragma once
 
 namespace Swift {
 	class ClientError {
 		public:
 			enum Type {
 				UnknownError,
 				DomainNameResolveError,
 				ConnectionError,
 				ConnectionReadError,
 				ConnectionWriteError,
 				XMLError,
 				AuthenticationFailedError,
+				ServerVerificationFailedError,
 				NoSupportedAuthMechanismsError,
 				UnexpectedElementError,
 				ResourceBindError,
 				SessionStartError,
 				TLSError,
 				ClientCertificateLoadError,
 				ClientCertificateError
 			};
 
 			ClientError(Type type = UnknownError) : type_(type) {}
 
 			Type getType() const { return type_; }
 
 		private:
 			Type type_;
 	};
 }
diff --git a/Swiften/Client/ClientSession.cpp b/Swiften/Client/ClientSession.cpp
index fb80754..960af70 100644
--- a/Swiften/Client/ClientSession.cpp
+++ b/Swiften/Client/ClientSession.cpp
@@ -85,104 +85,108 @@ void ClientSession::handleElement(boost::shared_ptr<Element> element) {
 				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 (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 (dynamic_cast<AuthSuccess*>(element.get())) {
-		// TODO: Check success data with authenticator
+	else if (AuthSuccess* authSuccess = dynamic_cast<AuthSuccess*>(element.get())) {
 		checkState(Authenticating);
-		state = WaitingForStreamStart;
-		delete authenticator;
-		authenticator = NULL;
-		stream->resetXMPPParser();
-		sendStreamHeader();
+		if (!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 {
diff --git a/Swiften/Client/ClientSession.h b/Swiften/Client/ClientSession.h
index f3bc119..5e5acbc 100644
--- a/Swiften/Client/ClientSession.h
+++ b/Swiften/Client/ClientSession.h
@@ -1,84 +1,85 @@
 #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,
+					ServerVerificationFailedError,
 					NoSupportedAuthMechanismsError,
 					UnexpectedElementError,
 					ResourceBindError,
 					SessionStartError,
 					TLSClientCertificateError,
 					TLSError,
 				} type;
 				Error(Type type) : type(type) {}
 			};
 
 			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>);