1 files changed, 2 insertions, 3 deletions
diff --git a/Swiften/Client/ClientSession.cpp b/Swiften/Client/ClientSession.cpp
index 441189e..500299a 100644
--- a/Swiften/Client/ClientSession.cpp
+++ b/Swiften/Client/ClientSession.cpp
@@ -12,71 +12,70 @@
 #include <boost/uuid/uuid_generators.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 
 #include <Swiften/Base/Platform.h>
 #include <Swiften/Base/Log.h>
 #include <Swiften/Elements/ProtocolHeader.h>
 #include <Swiften/Elements/StreamFeatures.h>
 #include <Swiften/Elements/StreamError.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/EnableStreamManagement.h>
 #include <Swiften/Elements/StreamManagementEnabled.h>
 #include <Swiften/Elements/StreamManagementFailed.h>
 #include <Swiften/Elements/StartSession.h>
 #include <Swiften/Elements/StanzaAck.h>
 #include <Swiften/Elements/StanzaAckRequest.h>
 #include <Swiften/Elements/IQ.h>
 #include <Swiften/Elements/ResourceBind.h>
 #include <Swiften/SASL/PLAINClientAuthenticator.h>
 #include <Swiften/SASL/EXTERNALClientAuthenticator.h>
 #include <Swiften/SASL/SCRAMSHA1ClientAuthenticator.h>
 #include <Swiften/SASL/DIGESTMD5ClientAuthenticator.h>
 #include <Swiften/Crypto/CryptoProvider.h>
 #include <Swiften/Session/SessionStream.h>
 #include <Swiften/TLS/CertificateTrustChecker.h>
 #include <Swiften/TLS/ServerIdentityVerifier.h>
-#include <Swiften/Base/Log.h>
 
 #ifdef SWIFTEN_PLATFORM_WIN32
 #include <Swiften/Base/WindowsRegistry.h>
 #endif
 
 #define CHECK_STATE_OR_RETURN(a) \
 	if (!checkState(a)) { return; }
 
 namespace Swift {
 
 ClientSession::ClientSession(
 		const JID& jid, 
 		boost::shared_ptr<SessionStream> stream,
 		IDNConverter* idnConverter,
 		CryptoProvider* crypto) :
 			localJID(jid),	
 			state(Initial), 
 			stream(stream),
 			idnConverter(idnConverter),
 			crypto(crypto),
 			allowPLAINOverNonTLS(false),
 			useStreamCompression(true),
 			useTLS(UseTLSWhenAvailable),
 			useAcks(true),
 			needSessionStart(false),
 			needResourceBind(false),
 			needAcking(false),
 			rosterVersioningSupported(false),
 			authenticator(NULL),
 			certificateTrustChecker(NULL) {
 #ifdef SWIFTEN_PLATFORM_WIN32
 if (WindowsRegistry::isFIPSEnabled()) {
 	SWIFT_LOG(info) << "Windows is running in FIPS-140 mode. Some authentication methods will be unavailable." << std::endl;
 }
 #endif
@@ -139,75 +138,75 @@ void ClientSession::handleElement(boost::shared_ptr<ToplevelElement> element) {
 					needResourceBind = false;
 					continueSessionInitialization();
 				}
 				else {
 					finishSession(Error::UnexpectedElementError);
 				}
 			}
 			else if (state == StartingSession) {
 				if (iq->getType() == IQ::Result) {
 					needSessionStart = false;
 					continueSessionInitialization();
 				}
 				else if (iq->getType() == IQ::Error) {
 					finishSession(Error::SessionStartError);
 				}
 				else {
 					finishSession(Error::UnexpectedElementError);
 				}
 			}
 			else {
 				finishSession(Error::UnexpectedElementError);
 			}
 		}
 	}
 	else if (boost::dynamic_pointer_cast<StanzaAckRequest>(element)) {
 		if (stanzaAckResponder_) {
 			stanzaAckResponder_->handleAckRequestReceived();
 		}
 	}
 	else if (boost::shared_ptr<StanzaAck> ack = boost::dynamic_pointer_cast<StanzaAck>(element)) {
 		if (stanzaAckRequester_) {
 			if (ack->isValid()) {
 				stanzaAckRequester_->handleAckReceived(ack->getHandledStanzasCount());
 			}
 			else {
-				std::cerr << "Warning: Got invalid ack from server" << std::endl;
+				SWIFT_LOG(warning) << "Got invalid ack from server";
 			}
 		}
 		else {
-			std::cerr << "Warning: Ignoring ack" << std::endl;
+			SWIFT_LOG(warning) << "Ignoring ack";
 		}
 	}
 	else if (StreamError::ref streamError = boost::dynamic_pointer_cast<StreamError>(element)) {
 		finishSession(Error::StreamError);
 	}
 	else if (getState() == Initialized) {
 		boost::shared_ptr<Stanza> stanza = boost::dynamic_pointer_cast<Stanza>(element);
 		if (stanza) {
 			if (stanzaAckResponder_) {
 				stanzaAckResponder_->handleStanzaReceived();
 			}
 			onStanzaReceived(stanza);
 		}
 	}
 	else if (StreamFeatures* streamFeatures = dynamic_cast<StreamFeatures*>(element.get())) {
 		CHECK_STATE_OR_RETURN(Negotiating);
 
 		if (streamFeatures->hasStartTLS() && stream->supportsTLSEncryption() && useTLS != NeverUseTLS) {
 			state = WaitingForEncrypt;
 			stream->writeElement(boost::make_shared<StartTLSRequest>());
 		}
 		else if (useTLS == RequireTLS && !stream->isTLSEncrypted()) {
 			finishSession(Error::NoSupportedAuthMechanismsError);
 		}
 		else if (useStreamCompression && stream->supportsZLibCompression() && streamFeatures->hasCompressionMethod("zlib")) {
 			state = Compressing;
 			stream->writeElement(boost::make_shared<CompressRequest>("zlib"));
 		}
 		else if (streamFeatures->hasAuthenticationMechanisms()) {
 			if (stream->hasTLSCertificate()) {
 				if (streamFeatures->hasAuthenticationMechanism("EXTERNAL")) {
 					authenticator = new EXTERNALClientAuthenticator();
 					state = Authenticating;
 					stream->writeElement(boost::make_shared<AuthRequest>("EXTERNAL", createSafeByteArray("")));
 				}