3 files changed, 7 insertions, 6 deletions
diff --git a/Swiften/Avatars/VCardUpdateAvatarManager.cpp b/Swiften/Avatars/VCardUpdateAvatarManager.cpp
index adbefd5..3a32889 100644
--- a/Swiften/Avatars/VCardUpdateAvatarManager.cpp
+++ b/Swiften/Avatars/VCardUpdateAvatarManager.cpp
@@ -1,84 +1,84 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
+ * Copyright (c) 2010-2014 Remko Tronçon
  * Licensed under the GNU General Public License v3.
  * See Documentation/Licenses/GPLv3.txt for more information.
  */
 
 #include <Swiften/Avatars/VCardUpdateAvatarManager.h>
 
 #include <boost/bind.hpp>
 
 #include <Swiften/Client/StanzaChannel.h>
 #include <Swiften/Elements/VCardUpdate.h>
 #include <Swiften/VCards/GetVCardRequest.h>
 #include <Swiften/Crypto/CryptoProvider.h>
 #include <Swiften/StringCodecs/Hexify.h>
 #include <Swiften/Avatars/AvatarStorage.h>
 #include <Swiften/MUC/MUCRegistry.h>
 #include <Swiften/VCards/VCardManager.h>
 #include <Swiften/Base/Log.h>
 
 namespace Swift {
 
 VCardUpdateAvatarManager::VCardUpdateAvatarManager(VCardManager* vcardManager, StanzaChannel* stanzaChannel, AvatarStorage* avatarStorage, CryptoProvider* crypto, MUCRegistry* mucRegistry) : vcardManager_(vcardManager), avatarStorage_(avatarStorage), crypto_(crypto), mucRegistry_(mucRegistry) {
 	stanzaChannel->onPresenceReceived.connect(boost::bind(&VCardUpdateAvatarManager::handlePresenceReceived, this, _1));
 	stanzaChannel->onAvailableChanged.connect(boost::bind(&VCardUpdateAvatarManager::handleStanzaChannelAvailableChanged, this, _1));
 	vcardManager_->onVCardChanged.connect(boost::bind(&VCardUpdateAvatarManager::handleVCardChanged, this, _1, _2));
 }
 
 void VCardUpdateAvatarManager::handlePresenceReceived(boost::shared_ptr<Presence> presence) {
 	boost::shared_ptr<VCardUpdate> update = presence->getPayload<VCardUpdate>();
 	if (!update || presence->getPayload<ErrorPayload>()) {
 		return;
 	}
 	JID from = getAvatarJID(presence->getFrom());
 	if (getAvatarHash(from) == update->getPhotoHash()) {
 		return;
 	}
 	SWIFT_LOG(debug) << "Updated hash: " << from << " -> " << update->getPhotoHash() << std::endl;
 	if (avatarStorage_->hasAvatar(update->getPhotoHash())) {
 		setAvatarHash(from, update->getPhotoHash());
 	}
 	else {
 		vcardManager_->requestVCard(from);
 	}
 }
 
 void VCardUpdateAvatarManager::handleVCardChanged(const JID& from, VCard::ref vCard) {
 	if (!vCard) {
-		std::cerr << "Warning: " << from << ": null vcard payload" << std::endl;
+		SWIFT_LOG(debug) << "Missing element: " << from << ": null vcard payload" << std::endl;
 		return;
 	}
 
 	if (vCard->getPhoto().empty()) {
 		setAvatarHash(from, "");
 	}
 	else {
 		std::string hash = Hexify::hexify(crypto_->getSHA1Hash(vCard->getPhoto()));
 		if (!avatarStorage_->hasAvatar(hash)) {
 			avatarStorage_->addAvatar(hash, vCard->getPhoto());
 		}
 		setAvatarHash(from, hash);
 	}
 }
 
 void VCardUpdateAvatarManager::setAvatarHash(const JID& from, const std::string& hash) {
 	SWIFT_LOG(debug) << "Updating hash: " << from << " -> " << hash << std::endl;
 	avatarHashes_[from] = hash;
 	onAvatarChanged(from);
 }
 
 /*
 void VCardUpdateAvatarManager::setAvatar(const JID& jid, const ByteArray& avatar) {
 	std::string hash = Hexify::hexify(SHA1::getHash(avatar));
 	avatarStorage_->addAvatar(hash, avatar);
 	setAvatarHash(getAvatarJID(jid), hash);
 }
 */
 
 std::string VCardUpdateAvatarManager::getAvatarHash(const JID& jid) const {
 	std::map<JID, std::string>::const_iterator i = avatarHashes_.find(getAvatarJID(jid));
 	if (i != avatarHashes_.end()) {
 		return i->second;
 	}
 	else {
diff --git a/Swiften/Client/CoreClient.cpp b/Swiften/Client/CoreClient.cpp
index d927c0b..da755b1 100644
--- a/Swiften/Client/CoreClient.cpp
+++ b/Swiften/Client/CoreClient.cpp
@@ -418,45 +418,45 @@ const JID& CoreClient::getJID() const {
 	}
 }
 
 void CoreClient::purgePassword() {
 	safeClear(password_);
 }
 
 void CoreClient::resetConnector() {
 	connector_->onConnectFinished.disconnect(boost::bind(&CoreClient::handleConnectorFinished, this, _1, _2));
 	connector_.reset();
 	foreach(ConnectionFactory* f, proxyConnectionFactories) {
 		delete f;
 	}
 	proxyConnectionFactories.clear();
 }
 
 void CoreClient::resetSession() {
 	session_->onFinished.disconnect(boost::bind(&CoreClient::handleSessionFinished, this, _1));
 	session_->onNeedCredentials.disconnect(boost::bind(&CoreClient::handleNeedCredentials, this));
 
 	sessionStream_->onDataRead.disconnect(boost::bind(&CoreClient::handleDataRead, this, _1));
 	sessionStream_->onDataWritten.disconnect(boost::bind(&CoreClient::handleDataWritten, this, _1));
 
 	if (connection_) {
 		connection_->disconnect();
 	}
 	else if (boost::dynamic_pointer_cast<BOSHSessionStream>(sessionStream_)) {
 		sessionStream_->close();
 	}
 	sessionStream_.reset();
 	connection_.reset();
 }
 
 void CoreClient::forceReset() {
 	if (connector_) {
-		std::cerr << "Warning: Client not disconnected properly: Connector still active" << std::endl;
+		SWIFT_LOG(warning) << "Client not disconnected properly: Connector still active" << std::endl;
 		resetConnector();
 	}
 	if (sessionStream_ || connection_) {
-		std::cerr << "Warning: Client not disconnected properly: Session still active" << std::endl;
+		SWIFT_LOG(warning) << "Client not disconnected properly: Session still active" << std::endl;
 		resetSession();
 	}
 }
 
 }
diff --git a/Swiften/Serializer/PayloadSerializers/JinglePayloadSerializer.cpp b/Swiften/Serializer/PayloadSerializers/JinglePayloadSerializer.cpp
index a04687b..2e8ae4a 100644
--- a/Swiften/Serializer/PayloadSerializers/JinglePayloadSerializer.cpp
+++ b/Swiften/Serializer/PayloadSerializers/JinglePayloadSerializer.cpp
@@ -1,48 +1,49 @@
 /*
  * Copyright (c) 2011 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 #include <Swiften/Serializer/PayloadSerializers/JinglePayloadSerializer.h>
 
 #include <boost/shared_ptr.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 #include <boost/smart_ptr/intrusive_ptr.hpp>
 
 #include <Swiften/Base/foreach.h>
+#include <Swiften/Base/Log.h>
 #include <Swiften/Serializer/XML/XMLNode.h>
 #include <Swiften/Serializer/XML/XMLElement.h>
 #include <Swiften/Serializer/XML/XMLRawTextNode.h>
 #include <Swiften/Serializer/PayloadSerializers/JingleContentPayloadSerializer.h>
 #include <Swiften/Serializer/PayloadSerializers/JingleFileTransferHashSerializer.h>
 #include <Swiften/Serializer/PayloadSerializers/JingleFileTransferReceivedSerializer.h>
 
 #include <Swiften/Serializer/PayloadSerializerCollection.h>
 
 #include <Swiften/Elements/JinglePayload.h>
 #include <Swiften/Elements/JingleContentPayload.h>
 #include <Swiften/Elements/JingleIBBTransportPayload.h>
 #include <Swiften/Elements/JingleFileTransferDescription.h>
 #include <Swiften/Elements/JingleFileTransferHash.h>
 #include <Swiften/Elements/JingleFileTransferReceived.h>
 
 namespace Swift {
 
 JinglePayloadSerializer::JinglePayloadSerializer(PayloadSerializerCollection* serializers) : serializers(serializers) {
 }
 
 std::string JinglePayloadSerializer::serializePayload(boost::shared_ptr<JinglePayload> payload) const {
 	XMLElement jinglePayload("jingle", "urn:xmpp:jingle:1");
 	jinglePayload.setAttribute("action", actionToString(payload->getAction()));
 	jinglePayload.setAttribute("initiator", payload->getInitiator());
 	jinglePayload.setAttribute("sid", payload->getSessionID());
 
 	std::vector<boost::shared_ptr<Payload> > payloads = payload->getPayloads();
 	if (!payloads.empty()) {
 		foreach(boost::shared_ptr<Payload> subPayload, payloads) {
 			PayloadSerializer* serializer = serializers->getPayloadSerializer(subPayload);
 			if (serializer) {
 				jinglePayload.addNode(boost::make_shared<XMLRawTextNode>(serializer->serialize(subPayload)));
 			}
 		}
@@ -61,81 +62,81 @@ std::string JinglePayloadSerializer::serializePayload(boost::shared_ptr<JinglePa
 }
 
 std::string JinglePayloadSerializer::actionToString(JinglePayload::Action action) const {
 	switch(action) {
 		case JinglePayload::ContentAccept:
 			return "content-accept";
 		case JinglePayload::ContentAdd:
 			return "content-add";
 		case JinglePayload::ContentModify:
 			return "content-modify";
 		case JinglePayload::ContentReject:
 			return "content-reject";
 		case JinglePayload::ContentRemove:
 			return "content-remove";
 		case JinglePayload::DescriptionInfo:
 			return "description-info";
 		case JinglePayload::SecurityInfo:
 			return "security-info";
 		case JinglePayload::SessionAccept:
 			return "session-accept";
 		case JinglePayload::SessionInfo:
 			return "session-info";
 		case JinglePayload::SessionInitiate:
 			return "session-initiate";
 		case JinglePayload::SessionTerminate:
 			return "session-terminate";
 		case JinglePayload::TransportAccept:
 			return "transport-accept";
 		case JinglePayload::TransportInfo:
 			return "transport-info";
 		case JinglePayload::TransportReject:
 			return "transport-reject";
 		case JinglePayload::TransportReplace:
 			return "transport-replace";
 		case JinglePayload::UnknownAction:
-			std::cerr << "Serializing unknown action value." << std::endl;
+			SWIFT_LOG(warning) << "Serializing unknown action value." << std::endl;
 			return "";
 	}
 	assert(false);
 	return "";
 }
 
 std::string JinglePayloadSerializer::reasonTypeToString(JinglePayload::Reason::Type type) const {
 	switch(type) {
 		case JinglePayload::Reason::UnknownType:
-			std::cerr << "Unknown jingle reason type!" << std::endl;
+			SWIFT_LOG(warning) << "Unknown jingle reason type!" << std::endl;
 			return "";
 		case JinglePayload::Reason::AlternativeSession:
 			return "alternative-session";
 		case JinglePayload::Reason::Busy:
 			return "busy";
 		case JinglePayload::Reason::Cancel:
 			return "cancel";
 		case JinglePayload::Reason::ConnectivityError:
 			return "connectivity-error";
 		case JinglePayload::Reason::Decline:
 			return "decline";
 		case JinglePayload::Reason::Expired:
 			return "expired";
 		case JinglePayload::Reason::FailedApplication:
 			return "failed-application";
 		case JinglePayload::Reason::FailedTransport:
 			return "failed-transport";
 		case JinglePayload::Reason::GeneralError:
 			return "general-error";
 		case JinglePayload::Reason::Gone:
 			return "gone";
 		case JinglePayload::Reason::IncompatibleParameters:
 			return "incompatible-parameters";
 		case JinglePayload::Reason::MediaError:
 			return "media-error";
 		case JinglePayload::Reason::SecurityError:
 			return "security-error";
 		case JinglePayload::Reason::Success:
 			return "success";
 		case JinglePayload::Reason::Timeout:
 			return "timeout";
 		case JinglePayload::Reason::UnsupportedApplications:
 			return "unsupported-applications";
 		case JinglePayload::Reason::UnsupportedTransports:
 			return "unsupported-transports";