Remove std::endl from SWIFT_LOG calls

The std::endl is now added by ~Log, but only for output to stderr or a log file. Calls to the Android logging system or manually set callbacks will not include the newline in the logging output. JIRA: SWIFT-430 Test-Information: Unit tests pass on Debian 9 Checked that running Swift with logging to stderr still had a newline. Change-Id: I096fdba78a3b8f87db2097951c28c528592183e8
author: Edwin Mons <edwin.mons@isode.com> 2019-11-19 13:36:05 (GMT)
committer: Edwin Mons <edwin.mons@isode.com> 2019-11-19 13:58:45 (GMT)
commit: 261ba8d8595ed8cb90f9c4feb1d6ef642942bcba (patch)
tree: c7e60d473509db8c4dbff5aa83fbde963d8dd75e /Swiften/FileTransfer
parent: 697ae6ae84512a744958b24118197ec7bfdbc1f0 (diff)
download: swift-261ba8d8595ed8cb90f9c4feb1d6ef642942bcba.zip
swift-261ba8d8595ed8cb90f9c4feb1d6ef642942bcba.tar.bz2
14 files changed, 163 insertions, 163 deletions
diff --git a/Swiften/FileTransfer/DefaultFileTransferTransporter.cpp b/Swiften/FileTransfer/DefaultFileTransferTransporter.cpp
index c6987c0..ae3d7e0 100644
--- a/Swiften/FileTransfer/DefaultFileTransferTransporter.cpp
+++ b/Swiften/FileTransfer/DefaultFileTransferTransporter.cpp
@@ -1,8 +1,8 @@
 /*
- * Copyright (c) 2013-2016 Isode Limited.
+ * Copyright (c) 2013-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/FileTransfer/DefaultFileTransferTransporter.h>
 
@@ -130,13 +130,13 @@ void DefaultFileTransferTransporter::stopTryingRemoteCandidates() {
 void DefaultFileTransferTransporter::handleActivateProxySessionResult(const std::string& sessionID, ErrorPayload::ref error) {
     onProxyActivated(sessionID, error);
 }
 
 void DefaultFileTransferTransporter::startActivatingProxy(const JID& proxyServiceJID) {
     // activate proxy
-    SWIFT_LOG(debug) << "Start activating proxy " << proxyServiceJID.toString() << " with sid = " << s5bSessionID << "." << std::endl;
+    SWIFT_LOG(debug) << "Start activating proxy " << proxyServiceJID.toString() << " with sid = " << s5bSessionID << ".";
     S5BProxyRequest::ref proxyRequest = std::make_shared<S5BProxyRequest>();
     proxyRequest->setSID(s5bSessionID);
     proxyRequest->setActivate(role == Initiator ? responder : initiator);
 
     std::shared_ptr<GenericRequest<S5BProxyRequest> > request = std::make_shared<GenericRequest<S5BProxyRequest> >(IQ::Set, proxyServiceJID, proxyRequest, router);
     request->onResponse.connect(boost::bind(&DefaultFileTransferTransporter::handleActivateProxySessionResult, this, s5bSessionID, _2));
@@ -204,13 +204,13 @@ std::shared_ptr<TransportSession> DefaultFileTransferTransporter::createLocalCan
     if (candidate.type == JingleS5BTransportPayload::Candidate::ProxyType) {
         SOCKS5BytestreamClientSession::ref proxySession = s5bProxy->getProxySessionAndCloseOthers(candidate.jid, getLocalCandidateSOCKS5DstAddr());
         if (proxySession) {
             transportSession = std::make_shared<S5BTransportSession<SOCKS5BytestreamClientSession> >(proxySession, stream);
         }
         else {
-            SWIFT_LOG(error) << "Failed obtaining proxy session with candidate JID " << candidate.jid << " and dstAddr " << getLocalCandidateSOCKS5DstAddr() << "." << std::endl;
+            SWIFT_LOG(error) << "Failed obtaining proxy session with candidate JID " << candidate.jid << " and dstAddr " << getLocalCandidateSOCKS5DstAddr() << ".";
         }
     }
 
     if (!transportSession) {
         std::shared_ptr<SOCKS5BytestreamServerSession> serverSession = getServerSession();
         if (serverSession) {
@@ -231,13 +231,13 @@ std::shared_ptr<TransportSession> DefaultFileTransferTransporter::createLocalCan
     if (candidate.type == JingleS5BTransportPayload::Candidate::ProxyType) {
         SOCKS5BytestreamClientSession::ref proxySession = s5bProxy->getProxySessionAndCloseOthers(candidate.jid, getLocalCandidateSOCKS5DstAddr());
         if (proxySession) {
             transportSession = std::make_shared<S5BTransportSession<SOCKS5BytestreamClientSession> >(proxySession, stream);
         }
         else {
-            SWIFT_LOG(error) << "Failed obtaining proxy session with candidate JID " << candidate.jid << " and dstAddr " << getLocalCandidateSOCKS5DstAddr() << "." << std::endl;
+            SWIFT_LOG(error) << "Failed obtaining proxy session with candidate JID " << candidate.jid << " and dstAddr " << getLocalCandidateSOCKS5DstAddr() << ".";
         }
     }
 
     if (!transportSession) {
         std::shared_ptr<SOCKS5BytestreamServerSession> serverSession = getServerSession();
         if (serverSession) {
@@ -252,17 +252,17 @@ std::shared_ptr<TransportSession> DefaultFileTransferTransporter::createLocalCan
 }
 
 std::string DefaultFileTransferTransporter::getSOCKS5DstAddr() const {
     std::string result;
     if (role == Initiator) {
         result = getInitiatorCandidateSOCKS5DstAddr();
-        SWIFT_LOG(debug) << "Initiator S5B DST.ADDR = " << s5bSessionID << " + " << initiator.toString() << " + " << responder.toString() << " : " << result << std::endl;
+        SWIFT_LOG(debug) << "Initiator S5B DST.ADDR = " << s5bSessionID << " + " << initiator.toString() << " + " << responder.toString() << " : " << result;
     }
     else {
         result = getResponderCandidateSOCKS5DstAddr();
-        SWIFT_LOG(debug) << "Responder S5B DST.ADDR = " << s5bSessionID << " + " << responder.toString() << " + " << initiator.toString() << " : " << result << std::endl;
+        SWIFT_LOG(debug) << "Responder S5B DST.ADDR = " << s5bSessionID << " + " << responder.toString() << " + " << initiator.toString() << " : " << result;
     }
     return result;
 }
 
 std::string DefaultFileTransferTransporter::getInitiatorCandidateSOCKS5DstAddr() const {
     return Hexify::hexify(crypto->getSHA1Hash(createSafeByteArray(s5bSessionID + initiator.toString() + responder.toString())));
diff --git a/Swiften/FileTransfer/FailingTransportSession.cpp b/Swiften/FileTransfer/FailingTransportSession.cpp
index d1eb6a6..b9c79a0 100644
--- a/Swiften/FileTransfer/FailingTransportSession.cpp
+++ b/Swiften/FileTransfer/FailingTransportSession.cpp
@@ -1,8 +1,8 @@
 /*
- * Copyright (c) 2016 Isode Limited.
+ * Copyright (c) 2016-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/FileTransfer/FailingTransportSession.h>
 
@@ -11,13 +11,13 @@
 namespace Swift {
 
 FailingTransportSession::~FailingTransportSession() {
 }
 
 void FailingTransportSession::start() {
-    SWIFT_LOG(error) << "Trying to start failing transport." << std::endl;
+    SWIFT_LOG(error) << "Trying to start failing transport.";
     onFinished(FileTransferError(FileTransferError::PeerError));
 }
 
 void FailingTransportSession::stop() {
 }
 
diff --git a/Swiften/FileTransfer/FileTransferManagerImpl.cpp b/Swiften/FileTransfer/FileTransferManagerImpl.cpp
index 05dd3bb..98eb50e 100644
--- a/Swiften/FileTransfer/FileTransferManagerImpl.cpp
+++ b/Swiften/FileTransfer/FileTransferManagerImpl.cpp
@@ -2,13 +2,13 @@
  * Copyright (c) 2011 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
- * Copyright (c) 2013-2016 Isode Limited.
+ * Copyright (c) 2013-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/FileTransfer/FileTransferManagerImpl.h>
 
@@ -153,13 +153,13 @@ OutgoingFileTransfer::ref FileTransferManagerImpl::createOutgoingFileTransfer(
         }
         if (!capabilities->hasFeature(DiscoInfo::JingleTransportsIBBFeature)) {
             options = options.withInBandAllowed(false);
         }
     }
     else {
-        SWIFT_LOG(warning) << "No entity capabilities information for " << receipient.toString() << std::endl;
+        SWIFT_LOG(warning) << "No entity capabilities information for " << receipient.toString();
     }
 
     return outgoingFTManager->createOutgoingFileTransfer(iqRouter->getJID(), receipient, bytestream, fileInfo, options);
 }
 
 }
diff --git a/Swiften/FileTransfer/IncomingJingleFileTransfer.cpp b/Swiften/FileTransfer/IncomingJingleFileTransfer.cpp
index d5de5e4..7c46c60 100644
--- a/Swiften/FileTransfer/IncomingJingleFileTransfer.cpp
+++ b/Swiften/FileTransfer/IncomingJingleFileTransfer.cpp
@@ -1,8 +1,8 @@
 /*
- * Copyright (c) 2011-2016 Isode Limited.
+ * Copyright (c) 2011-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/FileTransfer/IncomingJingleFileTransfer.h>
 
@@ -64,14 +64,14 @@ IncomingJingleFileTransfer::~IncomingJingleFileTransfer() {
     hashCalculator = nullptr;
 }
 
 void IncomingJingleFileTransfer::accept(
         std::shared_ptr<WriteBytestream> stream,
         const FileTransferOptions& options) {
-    SWIFT_LOG(debug) << std::endl;
-    if (state != Initial) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }
+    SWIFT_LOG(debug);
+    if (state != Initial) { SWIFT_LOG(warning) << "Incorrect state"; return; }
 
     assert(!this->stream);
     this->stream = stream;
     this->options = options;
 
     assert(!hashCalculator);
@@ -82,21 +82,21 @@ void IncomingJingleFileTransfer::accept(
     writeStreamDataReceivedConnection = stream->onWrite.connect(
             boost::bind(&IncomingJingleFileTransfer::handleWriteStreamDataReceived, this, _1));
 
     JingleS5BTransportPayload::ref s5bTransport = initialContent->getTransport<JingleS5BTransportPayload>();
     JingleIBBTransportPayload::ref ibbTransport = initialContent->getTransport<JingleIBBTransportPayload>();
     if (s5bTransport) {
-        SWIFT_LOG(debug) << "Got S5B transport as initial payload." << std::endl;
+        SWIFT_LOG(debug) << "Got S5B transport as initial payload.";
         setTransporter(transporterFactory->createResponderTransporter(
                 getInitiator(), getResponder(), s5bTransport->getSessionID(), options));
         transporter->addRemoteCandidates(s5bTransport->getCandidates(), s5bTransport->getDstAddr());
         setState(GeneratingInitialLocalCandidates);
         transporter->startGeneratingLocalCandidates();
     }
     else if (ibbTransport && options.isInBandAllowed()) {
-        SWIFT_LOG(debug) << "Got IBB transport as initial payload." << std::endl;
+        SWIFT_LOG(debug) << "Got IBB transport as initial payload.";
         setTransporter(transporterFactory->createResponderTransporter(
                 getInitiator(), getResponder(), ibbTransport->getSessionID(), options));
 
         startTransferring(transporter->createIBBReceiveSession(
             ibbTransport->getSessionID(),
             description->getFileInfo().getSize(),
@@ -109,22 +109,22 @@ void IncomingJingleFileTransfer::accept(
         session->sendTerminate(JinglePayload::Reason::UnsupportedTransports);
         setFinishedState(FileTransfer::State::Failed, FileTransferError(FileTransferError::PeerError));
     }
 }
 
 void IncomingJingleFileTransfer::cancel() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
     terminate(state == Initial ? JinglePayload::Reason::Decline : JinglePayload::Reason::Cancel);
 }
 
 void IncomingJingleFileTransfer::handleLocalTransportCandidatesGenerated(
         const std::string& s5bSessionID,
         const std::vector<JingleS5BTransportPayload::Candidate>& candidates,
         const std::string& dstAddr) {
-    SWIFT_LOG(debug) << std::endl;
-    if (state != GeneratingInitialLocalCandidates) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }
+    SWIFT_LOG(debug);
+    if (state != GeneratingInitialLocalCandidates) { SWIFT_LOG(warning) << "Incorrect state"; return; }
 
     fillCandidateMap(localCandidates, candidates);
 
     JingleS5BTransportPayload::ref transport = std::make_shared<JingleS5BTransportPayload>();
     transport->setSessionID(s5bSessionID);
     transport->setMode(JingleS5BTransportPayload::TCPMode);
@@ -137,39 +137,39 @@ void IncomingJingleFileTransfer::handleLocalTransportCandidatesGenerated(
     setState(TryingCandidates);
     transporter->startTryingRemoteCandidates();
 }
 
 
 void IncomingJingleFileTransfer::handleSessionInfoReceived(JinglePayload::ref jinglePayload) {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     JingleFileTransferHash::ref transferHash = jinglePayload->getPayload<JingleFileTransferHash>();
     if (transferHash) {
-        SWIFT_LOG(debug) << "Received hash information." << std::endl;
+        SWIFT_LOG(debug) << "Received hash information.";
         waitOnHashTimer->stop();
         if (transferHash->getFileInfo().getHashes().find("sha-1") != transferHash->getFileInfo().getHashes().end()) {
             hashes["sha-1"] = transferHash->getFileInfo().getHash("sha-1").get();
         }
         if (transferHash->getFileInfo().getHashes().find("md5") != transferHash->getFileInfo().getHashes().end()) {
             hashes["md5"] = transferHash->getFileInfo().getHash("md5").get();
         }
         if (state == WaitingForHash) {
             checkHashAndTerminate();
         }
     }
     else {
-        SWIFT_LOG(debug) << "Ignoring unknown session info" << std::endl;
+        SWIFT_LOG(debug) << "Ignoring unknown session info";
     }
 }
 
 void IncomingJingleFileTransfer::handleSessionTerminateReceived(boost::optional<JinglePayload::Reason> reason) {
-    SWIFT_LOG(debug) << std::endl;
-    if (state == Finished) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }
+    SWIFT_LOG(debug);
+    if (state == Finished) { SWIFT_LOG(warning) << "Incorrect state"; return; }
 
     if (state == Finished) {
-        SWIFT_LOG(debug) << "Already terminated" << std::endl;
+        SWIFT_LOG(debug) << "Already terminated";
         return;
     }
 
     stopAll();
     if (reason && reason->type == JinglePayload::Reason::Cancel) {
         setFinishedState(FileTransfer::State::Canceled, FileTransferError(FileTransferError::PeerError));
@@ -184,36 +184,36 @@ void IncomingJingleFileTransfer::handleSessionTerminateReceived(boost::optional<
 
 void IncomingJingleFileTransfer::checkHashAndTerminate() {
     if (verifyData()) {
         terminate(JinglePayload::Reason::Success);
     }
     else {
-        SWIFT_LOG(warning) << "Hash verification failed" << std::endl;
+        SWIFT_LOG(warning) << "Hash verification failed";
         terminate(JinglePayload::Reason::MediaError);
     }
 }
 
 void IncomingJingleFileTransfer::checkIfAllDataReceived() {
     if (receivedBytes == getFileSizeInBytes()) {
-        SWIFT_LOG(debug) << "All data received." << std::endl;
+        SWIFT_LOG(debug) << "All data received.";
         bool hashInfoAvailable = false;
         for (const auto& hashElement : hashes) {
             hashInfoAvailable |= !hashElement.second.empty();
         }
 
         if (!hashInfoAvailable) {
-            SWIFT_LOG(debug) << "No hash information yet. Waiting a while on hash info." << std::endl;
+            SWIFT_LOG(debug) << "No hash information yet. Waiting a while on hash info.";
             setState(WaitingForHash);
             waitOnHashTimer->start();
         }
         else {
             checkHashAndTerminate();
         }
     }
     else if (receivedBytes > getFileSizeInBytes()) {
-        SWIFT_LOG(debug) << "We got more than we could handle!" << std::endl;
+        SWIFT_LOG(debug) << "We got more than we could handle!";
         terminate(JinglePayload::Reason::MediaError);
     }
 }
 
 void IncomingJingleFileTransfer::handleWriteStreamDataReceived(
         const std::vector<unsigned char>& data) {
@@ -222,59 +222,59 @@ void IncomingJingleFileTransfer::handleWriteStreamDataReceived(
     onProcessedBytes(data.size());
     checkIfAllDataReceived();
 }
 
 void IncomingJingleFileTransfer::handleTransportReplaceReceived(
         const JingleContentID& content, JingleTransportPayload::ref transport) {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
     if (state != WaitingForFallbackOrTerminate) {
-        SWIFT_LOG(warning) << "Incorrect state" << std::endl;
+        SWIFT_LOG(warning) << "Incorrect state";
         return;
     }
 
     JingleIBBTransportPayload::ref ibbTransport;
     if (options.isInBandAllowed() && (ibbTransport = std::dynamic_pointer_cast<JingleIBBTransportPayload>(transport))) {
-        SWIFT_LOG(debug) << "transport replaced with IBB" << std::endl;
+        SWIFT_LOG(debug) << "transport replaced with IBB";
 
         startTransferring(transporter->createIBBReceiveSession(
             ibbTransport->getSessionID(),
             description->getFileInfo().getSize(),
             stream));
         session->sendTransportAccept(content, ibbTransport);
     }
     else {
-        SWIFT_LOG(debug) << "Unknown replace transport" << std::endl;
+        SWIFT_LOG(debug) << "Unknown replace transport";
         session->sendTransportReject(content, transport);
     }
 }
 
 JingleContentID IncomingJingleFileTransfer::getContentID() const {
     return JingleContentID(initialContent->getName(), initialContent->getCreator());
 }
 
 bool IncomingJingleFileTransfer::verifyData() {
     if (hashes.empty()) {
-        SWIFT_LOG(debug) << "no verification possible, skipping" << std::endl;
+        SWIFT_LOG(debug) << "no verification possible, skipping";
         return true;
     }
     if (hashes.find("sha-1") != hashes.end()) {
-        SWIFT_LOG(debug) << "Verify SHA-1 hash: " << (hashes["sha-1"] == hashCalculator->getSHA1Hash()) << std::endl;
+        SWIFT_LOG(debug) << "Verify SHA-1 hash: " << (hashes["sha-1"] == hashCalculator->getSHA1Hash());
         return hashes["sha-1"] == hashCalculator->getSHA1Hash();
     }
     else if (hashes.find("md5") != hashes.end()) {
-        SWIFT_LOG(debug) << "Verify MD5 hash: " << (hashes["md5"] == hashCalculator->getMD5Hash()) << std::endl;
+        SWIFT_LOG(debug) << "Verify MD5 hash: " << (hashes["md5"] == hashCalculator->getMD5Hash());
         return hashes["md5"] == hashCalculator->getMD5Hash();
     }
     else {
-        SWIFT_LOG(debug) << "Unknown hash, skipping" << std::endl;
+        SWIFT_LOG(debug) << "Unknown hash, skipping";
         return true;
     }
 }
 
 void IncomingJingleFileTransfer::handleWaitOnHashTimerTicked() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
     waitOnHashTimer->stop();
     terminate(JinglePayload::Reason::Success);
 }
 
 const JID& IncomingJingleFileTransfer::getSender() const {
     return getInitiator();
@@ -282,20 +282,20 @@ const JID& IncomingJingleFileTransfer::getSender() const {
 
 const JID& IncomingJingleFileTransfer::getRecipient() const {
     return getResponder();
 }
 
 void IncomingJingleFileTransfer::setState(State state) {
-    SWIFT_LOG(debug) << state << std::endl;
+    SWIFT_LOG(debug) << state;
     this->state = state;
     onStateChanged(FileTransfer::State(getExternalState(state)));
 }
 
 void IncomingJingleFileTransfer::setFinishedState(
         FileTransfer::State::Type type, const boost::optional<FileTransferError>& error) {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
     this->state = Finished;
     onStateChanged(type);
     onFinished(error);
 }
 
 void IncomingJingleFileTransfer::handleTransferFinished(boost::optional<FileTransferError> error) {
@@ -337,13 +337,13 @@ void IncomingJingleFileTransfer::stopAll() {
         case Transferring:
             assert(transportSession);
             transferFinishedConnection.disconnect();
             transportSession->stop();
             transportSession.reset();
             break;
-        case Finished: SWIFT_LOG(warning) << "Already finished" << std::endl; break;
+        case Finished: SWIFT_LOG(warning) << "Already finished"; break;
     }
     if (state != Initial) {
         removeTransporter();
     }
 }
 
@@ -353,36 +353,36 @@ bool IncomingJingleFileTransfer::hasPriorityOnCandidateTie() const {
 
 void IncomingJingleFileTransfer::fallback() {
     setState(WaitingForFallbackOrTerminate);
 }
 
 void IncomingJingleFileTransfer::startTransferViaRemoteCandidate() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     if (ourCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {
         setState(WaitingForPeerProxyActivate);
     }
     else {
         startTransferring(createRemoteCandidateSession());
     }
 }
 
 void IncomingJingleFileTransfer::startTransferViaLocalCandidate() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     if (theirCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {
         setState(WaitingForLocalProxyActivate);
         transporter->startActivatingProxy(theirCandidateChoice->jid);
     }
     else {
         startTransferring(createLocalCandidateSession());
     }
 }
 
 void IncomingJingleFileTransfer::startTransferring(std::shared_ptr<TransportSession> transportSession) {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     this->transportSession = transportSession;
     transferFinishedConnection = transportSession->onFinished.connect(
             boost::bind(&IncomingJingleFileTransfer::handleTransferFinished, this, _1));
     setState(Transferring);
     transportSession->start();
@@ -406,13 +406,13 @@ std::shared_ptr<TransportSession> IncomingJingleFileTransfer::createLocalCandida
 
 std::shared_ptr<TransportSession> IncomingJingleFileTransfer::createRemoteCandidateSession() {
     return transporter->createRemoteCandidateSession(stream, ourCandidateChoice.get());
 }
 
 void IncomingJingleFileTransfer::terminate(JinglePayload::Reason::Type reason) {
-    SWIFT_LOG(debug) << reason << std::endl;
+    SWIFT_LOG(debug) << reason;
 
     if (state != Finished) {
         session->sendTerminate(reason);
     }
     stopAll();
     setFinishedState(getExternalFinishedState(reason), getFileTransferError(reason));
diff --git a/Swiften/FileTransfer/JingleFileTransfer.cpp b/Swiften/FileTransfer/JingleFileTransfer.cpp
index cc1cd1c..3d05db9 100644
--- a/Swiften/FileTransfer/JingleFileTransfer.cpp
+++ b/Swiften/FileTransfer/JingleFileTransfer.cpp
@@ -1,8 +1,8 @@
 /*
- * Copyright (c) 2013-2018 Isode Limited.
+ * Copyright (c) 2013-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/FileTransfer/JingleFileTransfer.h>
 
@@ -75,13 +75,13 @@ boost::optional<FileTransferError> JingleFileTransfer::getFileTransferError(Jing
         return boost::optional<FileTransferError>(FileTransferError::UnknownError);
     }
 }
 
 void JingleFileTransfer::handleRemoteTransportCandidateSelectFinished(
         const std::string& s5bSessionID, const boost::optional<JingleS5BTransportPayload::Candidate>& candidate) {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     ourCandidateChoice = candidate;
     ourCandidateSelectFinished = true;
 
     JingleS5BTransportPayload::ref s5bPayload = std::make_shared<JingleS5BTransportPayload>();
     s5bPayload->setSessionID(s5bSessionID);
@@ -95,61 +95,61 @@ void JingleFileTransfer::handleRemoteTransportCandidateSelectFinished(
 
     decideOnCandidates();
 }
 
 // decide on candidates according to http://xmpp.org/extensions/xep-0260.html#complete
 void JingleFileTransfer::decideOnCandidates() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
     if (!ourCandidateSelectFinished || !theirCandidateSelectFinished) {
-        SWIFT_LOG(debug) << "Can't make a decision yet!" << std::endl;
+        SWIFT_LOG(debug) << "Can't make a decision yet!";
         return;
     }
     if (!ourCandidateChoice && !theirCandidateChoice) {
-        SWIFT_LOG(debug) << "No candidates succeeded." << std::endl;
+        SWIFT_LOG(debug) << "No candidates succeeded.";
         fallback();
     }
     else if (ourCandidateChoice && !theirCandidateChoice) {
-        SWIFT_LOG(debug) << "Start transfer using remote candidate: " << ourCandidateChoice.get().cid << "." << std::endl;
+        SWIFT_LOG(debug) << "Start transfer using remote candidate: " << ourCandidateChoice.get().cid << ".";
         startTransferViaRemoteCandidate();
     }
     else if (theirCandidateChoice && !ourCandidateChoice) {
-        SWIFT_LOG(debug) << "Start transfer using local candidate: " << theirCandidateChoice.get().cid << "." << std::endl;
+        SWIFT_LOG(debug) << "Start transfer using local candidate: " << theirCandidateChoice.get().cid << ".";
         startTransferViaLocalCandidate();
     }
     else {
         SWIFT_LOG(debug) << "Choosing between candidates "
             << ourCandidateChoice->cid << "(" << ourCandidateChoice->priority << ")" << " and "
-            << theirCandidateChoice->cid << "(" << theirCandidateChoice->priority << ")" << std::endl;
+            << theirCandidateChoice->cid << "(" << theirCandidateChoice->priority << ")";
         if (ourCandidateChoice->priority > theirCandidateChoice->priority) {
-            SWIFT_LOG(debug) << "Start transfer using remote candidate: " << ourCandidateChoice.get().cid << "." << std::endl;
+            SWIFT_LOG(debug) << "Start transfer using remote candidate: " << ourCandidateChoice.get().cid << ".";
             startTransferViaRemoteCandidate();
         }
         else if (ourCandidateChoice->priority < theirCandidateChoice->priority) {
-            SWIFT_LOG(debug) << "Start transfer using local candidate:" << theirCandidateChoice.get().cid << "." << std::endl;
+            SWIFT_LOG(debug) << "Start transfer using local candidate:" << theirCandidateChoice.get().cid << ".";
             startTransferViaLocalCandidate();
         }
         else {
             if (hasPriorityOnCandidateTie()) {
-                SWIFT_LOG(debug) << "Start transfer using remote candidate: " << ourCandidateChoice.get().cid << std::endl;
+                SWIFT_LOG(debug) << "Start transfer using remote candidate: " << ourCandidateChoice.get().cid;
                 startTransferViaRemoteCandidate();
             }
             else {
-                SWIFT_LOG(debug) << "Start transfer using local candidate: " << theirCandidateChoice.get().cid << std::endl;
+                SWIFT_LOG(debug) << "Start transfer using local candidate: " << theirCandidateChoice.get().cid;
                 startTransferViaLocalCandidate();
             }
         }
     }
 }
 
 void JingleFileTransfer::handleProxyActivateFinished(
         const std::string& s5bSessionID, ErrorPayload::ref error) {
-    SWIFT_LOG(debug) << std::endl;
-    if (!isWaitingForLocalProxyActivate()) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }
+    SWIFT_LOG(debug);
+    if (!isWaitingForLocalProxyActivate()) { SWIFT_LOG(warning) << "Incorrect state"; return; }
 
     if (error) {
-        SWIFT_LOG(debug) << "Error activating proxy" << std::endl;
+        SWIFT_LOG(debug) << "Error activating proxy";
         JingleS5BTransportPayload::ref proxyError = std::make_shared<JingleS5BTransportPayload>();
         proxyError->setSessionID(s5bSessionID);
         proxyError->setProxyError(true);
         session->sendTransportInfo(getContentID(), proxyError);
         fallback();
     }
@@ -161,53 +161,53 @@ void JingleFileTransfer::handleProxyActivateFinished(
         startTransferring(createLocalCandidateSession());
     }
 }
 
 void JingleFileTransfer::handleTransportInfoReceived(
         const JingleContentID& /* contentID */, JingleTransportPayload::ref transport) {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     if (JingleS5BTransportPayload::ref s5bPayload = std::dynamic_pointer_cast<JingleS5BTransportPayload>(transport)) {
         if (s5bPayload->hasCandidateError() || !s5bPayload->getCandidateUsed().empty()) {
-            SWIFT_LOG(debug) << "Received candidate decision from peer" << std::endl;
-            if (!isTryingCandidates()) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }
+            SWIFT_LOG(debug) << "Received candidate decision from peer";
+            if (!isTryingCandidates()) { SWIFT_LOG(warning) << "Incorrect state"; return; }
 
             theirCandidateSelectFinished = true;
             if (!s5bPayload->hasCandidateError()) {
                 auto theirCandidate = localCandidates.find(s5bPayload->getCandidateUsed());
                 if (theirCandidate == localCandidates.end()) {
-                    SWIFT_LOG(warning) << "Got invalid candidate" << std::endl;
+                    SWIFT_LOG(warning) << "Got invalid candidate";
                     terminate(JinglePayload::Reason::GeneralError);
                     return;
                 }
                 theirCandidateChoice = theirCandidate->second;
             }
             decideOnCandidates();
         }
         else if (!s5bPayload->getActivated().empty()) {
-            SWIFT_LOG(debug) << "Received peer activate from peer" << std::endl;
-            if (!isWaitingForPeerProxyActivate()) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }
+            SWIFT_LOG(debug) << "Received peer activate from peer";
+            if (!isWaitingForPeerProxyActivate()) { SWIFT_LOG(warning) << "Incorrect state"; return; }
 
             if (ourCandidateChoice->cid == s5bPayload->getActivated()) {
                 startTransferring(createRemoteCandidateSession());
             }
             else {
-                SWIFT_LOG(warning) << "ourCandidateChoice doesn't match activated proxy candidate!" << std::endl;
+                SWIFT_LOG(warning) << "ourCandidateChoice doesn't match activated proxy candidate!";
                 terminate(JinglePayload::Reason::GeneralError);
             }
         }
         else if (s5bPayload->hasProxyError()) {
-            SWIFT_LOG(debug) << "Received proxy error. Trying to fall back to IBB." << std::endl;
+            SWIFT_LOG(debug) << "Received proxy error. Trying to fall back to IBB.";
             fallback();
         }
         else {
-            SWIFT_LOG(debug) << "Ignoring unknown info" << std::endl;
+            SWIFT_LOG(debug) << "Ignoring unknown info";
         }
     }
     else {
-        SWIFT_LOG(debug) << "Ignoring unknown info" << std::endl;
+        SWIFT_LOG(debug) << "Ignoring unknown info";
     }
 }
 
 void JingleFileTransfer::setTransporter(FileTransferTransporter* transporter) {
     SWIFT_LOG_ASSERT(!this->transporter, error);
     this->transporter = transporter;
diff --git a/Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.cpp b/Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.cpp
index 834a401..7cb4cbb 100644
--- a/Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.cpp
+++ b/Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.cpp
@@ -2,13 +2,13 @@
  * Copyright (c) 2011 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
- * Copyright (c) 2013-2016 Isode Limited.
+ * Copyright (c) 2013-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.h>
 
@@ -42,13 +42,13 @@ LocalJingleTransportCandidateGenerator::LocalJingleTransportCandidateGenerator(
             triedForwarding_(false),
             triedProxyDiscovery_(false),
             options_(options) {
 }
 
 LocalJingleTransportCandidateGenerator::~LocalJingleTransportCandidateGenerator() {
-    SWIFT_LOG_ASSERT(!s5bServerInitializeRequest, warning) << std::endl;
+    SWIFT_LOG_ASSERT(!s5bServerInitializeRequest, warning);
 }
 
 void LocalJingleTransportCandidateGenerator::start() {
     assert(!s5bServerInitializeRequest);
     if (options_.isDirectAllowed() || options_.isAssistedAllowed()) {
         s5bServerResourceUser_ = s5bServerManager->aquireResourceUser();
@@ -95,13 +95,13 @@ void LocalJingleTransportCandidateGenerator::handleS5BServerInitialized(bool suc
             if (s5bServerPortForwardingUser_->isForwardingSetup()) {
                 handlePortForwardingSetup(true);
             }
         }
     }
     else {
-        SWIFT_LOG(warning) << "Unable to start SOCKS5 server" << std::endl;
+        SWIFT_LOG(warning) << "Unable to start SOCKS5 server";
         if (s5bServerResourceUser_) {
             s5bServerResourceUser_->onSuccessfulInitialized.disconnect(boost::bind(&LocalJingleTransportCandidateGenerator::handleS5BServerInitialized, this, _1));
         }
         s5bServerResourceUser_.reset();
         handlePortForwardingSetup(false);
     }
diff --git a/Swiften/FileTransfer/OutgoingJingleFileTransfer.cpp b/Swiften/FileTransfer/OutgoingJingleFileTransfer.cpp
index 367fc97..57a18a8 100644
--- a/Swiften/FileTransfer/OutgoingJingleFileTransfer.cpp
+++ b/Swiften/FileTransfer/OutgoingJingleFileTransfer.cpp
@@ -2,13 +2,13 @@
  * Copyright (c) 2011 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
- * Copyright (c) 2013-2016 Isode Limited.
+ * Copyright (c) 2013-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 // TODO:
 // - We should handle incoming terminates after we have terminated, so the other
@@ -84,15 +84,15 @@ OutgoingJingleFileTransfer::~OutgoingJingleFileTransfer() {
     delete hashCalculator;
     hashCalculator = nullptr;
     removeTransporter();
 }
 
 void OutgoingJingleFileTransfer::start() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
     if (state != Initial) {
-        SWIFT_LOG(warning) << "Incorrect state" << std::endl;
+        SWIFT_LOG(warning) << "Incorrect state";
         return;
     }
 
     if (!options.isInBandAllowed() && !options.isDirectAllowed() && !options.isAssistedAllowed() && !options.isProxiedAllowed()) {
         // Started outgoing file transfer while not supporting transport methods.
         setFinishedState(FileTransfer::State::Failed, FileTransferError(FileTransferError::UnknownError));
@@ -106,45 +106,45 @@ void OutgoingJingleFileTransfer::start() {
 
 void OutgoingJingleFileTransfer::cancel() {
     terminate(JinglePayload::Reason::Cancel);
 }
 
 void OutgoingJingleFileTransfer::terminate(JinglePayload::Reason::Type reason) {
-    SWIFT_LOG(debug) << reason << std::endl;
+    SWIFT_LOG(debug) << reason;
 
     if (state != Initial && state != GeneratingInitialLocalCandidates && state != Finished) {
         session->sendTerminate(reason);
     }
     stopAll();
     setFinishedState(getExternalFinishedState(reason), getFileTransferError(reason));
 }
 
 void OutgoingJingleFileTransfer::handleSessionAcceptReceived(
         const JingleContentID&,
         JingleDescription::ref,
         JingleTransportPayload::ref transportPayload) {
-    SWIFT_LOG(debug) << std::endl;
-    if (state != WaitingForAccept) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }
+    SWIFT_LOG(debug);
+    if (state != WaitingForAccept) { SWIFT_LOG(warning) << "Incorrect state"; return; }
 
     if (JingleS5BTransportPayload::ref s5bPayload = std::dynamic_pointer_cast<JingleS5BTransportPayload>(transportPayload)) {
         transporter->addRemoteCandidates(s5bPayload->getCandidates(), s5bPayload->getDstAddr());
         setInternalState(TryingCandidates);
         transporter->startTryingRemoteCandidates();
     }
     else if (JingleIBBTransportPayload::ref ibbPayload = std::dynamic_pointer_cast<JingleIBBTransportPayload>(transportPayload)) {
         startTransferring(transporter->createIBBSendSession(ibbPayload->getSessionID(), ibbPayload->getBlockSize().get_value_or(DEFAULT_BLOCK_SIZE), stream));
     }
     else {
-        SWIFT_LOG(debug) << "Unknown transport payload. Falling back." << std::endl;
+        SWIFT_LOG(debug) << "Unknown transport payload. Falling back.";
         fallback();
     }
 }
 
 void OutgoingJingleFileTransfer::handleSessionTerminateReceived(boost::optional<JinglePayload::Reason> reason) {
-    SWIFT_LOG(debug) << std::endl;
-    if (state == Finished) { SWIFT_LOG(warning) << "Incorrect state: " << state << std::endl; return; }
+    SWIFT_LOG(debug);
+    if (state == Finished) { SWIFT_LOG(warning) << "Incorrect state: " << state; return; }
 
     stopAll();
     if (state == WaitForTermination) {
         waitForRemoteTermination->stop();
     }
     if (reason && reason->type == JinglePayload::Reason::Cancel) {
@@ -159,92 +159,92 @@ void OutgoingJingleFileTransfer::handleSessionTerminateReceived(boost::optional<
     else {
         setFinishedState(FileTransfer::State::Failed, FileTransferError(FileTransferError::PeerError));
     }
 }
 
 void OutgoingJingleFileTransfer::handleTransportAcceptReceived(const JingleContentID&, JingleTransportPayload::ref transport) {
-    SWIFT_LOG(debug) << std::endl;
-    if (state != FallbackRequested) { SWIFT_LOG(warning) << "Incorrect state" << std::endl; return; }
+    SWIFT_LOG(debug);
+    if (state != FallbackRequested) { SWIFT_LOG(warning) << "Incorrect state"; return; }
 
     if (JingleIBBTransportPayload::ref ibbPayload = std::dynamic_pointer_cast<JingleIBBTransportPayload>(transport)) {
         startTransferring(transporter->createIBBSendSession(ibbPayload->getSessionID(), ibbPayload->getBlockSize().get_value_or(DEFAULT_BLOCK_SIZE), stream));
     }
     else {
-        SWIFT_LOG(debug) << "Unknown transport replacement" << std::endl;
+        SWIFT_LOG(debug) << "Unknown transport replacement";
         terminate(JinglePayload::Reason::FailedTransport);
     }
 }
 
 void OutgoingJingleFileTransfer::handleTransportRejectReceived(const JingleContentID &, std::shared_ptr<JingleTransportPayload>) {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     terminate(JinglePayload::Reason::UnsupportedTransports);
 }
 
 void OutgoingJingleFileTransfer::sendSessionInfoHash() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     JingleFileTransferHash::ref hashElement = std::make_shared<JingleFileTransferHash>();
     hashElement->getFileInfo().addHash(HashElement("sha-1", hashCalculator->getSHA1Hash()));
     hashElement->getFileInfo().addHash(HashElement("md5", hashCalculator->getMD5Hash()));
     session->sendInfo(hashElement);
 }
 
 void OutgoingJingleFileTransfer::handleLocalTransportCandidatesGenerated(
         const std::string& s5bSessionID, const std::vector<JingleS5BTransportPayload::Candidate>& candidates, const std::string& dstAddr) {
-    SWIFT_LOG(debug) << std::endl;
-    if (state != GeneratingInitialLocalCandidates) { SWIFT_LOG(warning) << "Incorrect state: " << state << std::endl; return; }
+    SWIFT_LOG(debug);
+    if (state != GeneratingInitialLocalCandidates) { SWIFT_LOG(warning) << "Incorrect state: " << state; return; }
 
     fillCandidateMap(localCandidates, candidates);
 
     JingleFileTransferDescription::ref description = std::make_shared<JingleFileTransferDescription>();
     fileInfo.addHash(HashElement("sha-1", ByteArray()));
     fileInfo.addHash(HashElement("md5", ByteArray()));
     description->setFileInfo(fileInfo);
 
     JingleTransportPayload::ref transport;
     if (candidates.empty()) {
-        SWIFT_LOG(debug) << "no S5B candidates generated. Send IBB transport candidate." << std::endl;
+        SWIFT_LOG(debug) << "no S5B candidates generated. Send IBB transport candidate.";
         JingleIBBTransportPayload::ref ibbTransport = std::make_shared<JingleIBBTransportPayload>();
         ibbTransport->setBlockSize(DEFAULT_BLOCK_SIZE);
         ibbTransport->setSessionID(idGenerator->generateID());
         transport = ibbTransport;
     }
     else {
         JingleS5BTransportPayload::ref s5bTransport = std::make_shared<JingleS5BTransportPayload>();
         s5bTransport->setSessionID(s5bSessionID);
         s5bTransport->setMode(JingleS5BTransportPayload::TCPMode);
         s5bTransport->setDstAddr(dstAddr);
         for (auto&& candidate : candidates) {
             s5bTransport->addCandidate(candidate);
-            SWIFT_LOG(debug) << "\t" << "S5B candidate: " << candidate.hostPort.toString() << std::endl;
+            SWIFT_LOG(debug) << "\t" << "S5B candidate: " << candidate.hostPort.toString();
         }
         transport = s5bTransport;
     }
     setInternalState(WaitingForAccept);
     session->sendInitiate(contentID, description, transport);
 }
 
 void OutgoingJingleFileTransfer::fallback() {
     if (options.isInBandAllowed()) {
-        SWIFT_LOG(debug) << "Trying to fallback to IBB transport." << std::endl;
+        SWIFT_LOG(debug) << "Trying to fallback to IBB transport.";
         JingleIBBTransportPayload::ref ibbTransport = std::make_shared<JingleIBBTransportPayload>();
         ibbTransport->setBlockSize(DEFAULT_BLOCK_SIZE);
         ibbTransport->setSessionID(idGenerator->generateID());
         setInternalState(FallbackRequested);
         session->sendTransportReplace(contentID, ibbTransport);
     }
     else {
-        SWIFT_LOG(debug) << "Fallback to IBB transport not allowed." << std::endl;
+        SWIFT_LOG(debug) << "Fallback to IBB transport not allowed.";
         terminate(JinglePayload::Reason::ConnectivityError);
     }
 }
 
 void OutgoingJingleFileTransfer::handleTransferFinished(boost::optional<FileTransferError> error) {
-    SWIFT_LOG(debug) << std::endl;
-    if (state != Transferring) { SWIFT_LOG(warning) << "Incorrect state: " << state << std::endl; return; }
+    SWIFT_LOG(debug);
+    if (state != Transferring) { SWIFT_LOG(warning) << "Incorrect state: " << state; return; }
 
     if (error) {
         terminate(JinglePayload::Reason::ConnectivityError);
     }
     else {
         sendSessionInfoHash();
@@ -253,33 +253,33 @@ void OutgoingJingleFileTransfer::handleTransferFinished(boost::optional<FileTran
         setInternalState(WaitForTermination);
         waitForRemoteTermination->start();
     }
 }
 
 void OutgoingJingleFileTransfer::startTransferring(std::shared_ptr<TransportSession> transportSession) {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     this->transportSession = transportSession;
     processedBytesConnection = transportSession->onBytesSent.connect(
             boost::bind(boost::ref(onProcessedBytes), _1));
     transferFinishedConnection = transportSession->onFinished.connect(
             boost::bind(&OutgoingJingleFileTransfer::handleTransferFinished, this, _1));
     setInternalState(Transferring);
     transportSession->start();
 }
 
 
 void OutgoingJingleFileTransfer::setInternalState(State state) {
-    SWIFT_LOG(debug) <<  state << std::endl;
+    SWIFT_LOG(debug) <<  state;
     this->state = state;
     setState(FileTransfer::State(getExternalState(state)));
 }
 
 void OutgoingJingleFileTransfer::setFinishedState(
         FileTransfer::State::Type type, const boost::optional<FileTransferError>& error) {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
     this->state = Finished;
     onStateChanged(type);
     onFinished(error);
 }
 
 FileTransfer::State::Type OutgoingJingleFileTransfer::getExternalState(State state) {
@@ -298,15 +298,15 @@ FileTransfer::State::Type OutgoingJingleFileTransfer::getExternalState(State sta
     }
     assert(false);
     return FileTransfer::State::Initial;
 }
 
 void OutgoingJingleFileTransfer::stopAll() {
-    SWIFT_LOG(debug) << state << std::endl;
+    SWIFT_LOG(debug) << state;
     switch (state) {
-        case Initial: SWIFT_LOG(warning) << "Not yet started" << std::endl; break;
+        case Initial: SWIFT_LOG(warning) << "Not yet started"; break;
         case GeneratingInitialLocalCandidates: transporter->stopGeneratingLocalCandidates(); break;
         case WaitingForAccept: break;
         case TryingCandidates: transporter->stopTryingRemoteCandidates(); break;
         case FallbackRequested: break;
         case WaitingForPeerProxyActivate: break;
         case WaitingForLocalProxyActivate: transporter->stopActivatingProxy(); break;
@@ -317,33 +317,33 @@ void OutgoingJingleFileTransfer::stopAll() {
             transferFinishedConnection.disconnect();
             transportSession->stop();
             transportSession.reset();
             break;
         case WaitForTermination:
             break;
-        case Finished: SWIFT_LOG(warning) << "Already finished" << std::endl; break;
+        case Finished: SWIFT_LOG(warning) << "Already finished"; break;
     }
     if (state != Initial) {
         removeTransporter();
     }
 }
 
 void OutgoingJingleFileTransfer::startTransferViaRemoteCandidate() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     if (ourCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {
         setInternalState(WaitingForPeerProxyActivate);
     }
     else {
         transportSession = createRemoteCandidateSession();
         startTransferringIfCandidateAcknowledged();
     }
 }
 
 void OutgoingJingleFileTransfer::startTransferViaLocalCandidate() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
 
     if (theirCandidateChoice->type == JingleS5BTransportPayload::Candidate::ProxyType) {
         setInternalState(WaitingForLocalProxyActivate);
         transporter->startActivatingProxy(theirCandidateChoice->jid);
     }
     else {
@@ -397,11 +397,11 @@ std::shared_ptr<TransportSession> OutgoingJingleFileTransfer::createLocalCandida
 std::shared_ptr<TransportSession> OutgoingJingleFileTransfer::createRemoteCandidateSession() {
     return transporter->createRemoteCandidateSession(stream, ourCandidateChoice.get());
 }
 
 void OutgoingJingleFileTransfer::handleWaitForRemoteTerminationTimeout() {
     assert(state == WaitForTermination);
-    SWIFT_LOG(warning) << "Other party did not terminate session. Terminate it now." << std::endl;
+    SWIFT_LOG(warning) << "Other party did not terminate session. Terminate it now.";
     waitForRemoteTermination->stop();
     terminate(JinglePayload::Reason::MediaError);
 }
 
diff --git a/Swiften/FileTransfer/RemoteJingleTransportCandidateSelector.cpp b/Swiften/FileTransfer/RemoteJingleTransportCandidateSelector.cpp
index 56013ca..4023be3 100644
--- a/Swiften/FileTransfer/RemoteJingleTransportCandidateSelector.cpp
+++ b/Swiften/FileTransfer/RemoteJingleTransportCandidateSelector.cpp
@@ -2,13 +2,13 @@
  * Copyright (c) 2011 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
- * Copyright (c) 2013-2016 Isode Limited.
+ * Copyright (c) 2013-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/FileTransfer/RemoteJingleTransportCandidateSelector.h>
 
@@ -53,32 +53,32 @@ void RemoteJingleTransportCandidateSelector::stopSelectingCandidate() {
         s5bSession->stop();
     }
 }
 
 void RemoteJingleTransportCandidateSelector::tryNextCandidate() {
     if (candidates.empty()) {
-        SWIFT_LOG(debug) << "No more candidates" << std::endl;
+        SWIFT_LOG(debug) << "No more candidates";
         onCandidateSelectFinished(
                 boost::optional<JingleS5BTransportPayload::Candidate>(), std::shared_ptr<SOCKS5BytestreamClientSession>());
     }
     else {
         lastCandidate = candidates.top();
         candidates.pop();
-        SWIFT_LOG(debug) << "Trying candidate " << lastCandidate.cid << std::endl;
+        SWIFT_LOG(debug) << "Trying candidate " << lastCandidate.cid;
         if ((lastCandidate.type == JingleS5BTransportPayload::Candidate::DirectType && options.isDirectAllowed()) ||
             (lastCandidate.type == JingleS5BTransportPayload::Candidate::AssistedType && options.isAssistedAllowed()) ||
             (lastCandidate.type == JingleS5BTransportPayload::Candidate::ProxyType && options.isProxiedAllowed())) {
             std::shared_ptr<Connection> connection = connectionFactory->createConnection();
             s5bSession = std::make_shared<SOCKS5BytestreamClientSession>(
                     connection, lastCandidate.hostPort, socks5DstAddr, timerFactory);
             sessionReadyConnection = s5bSession->onSessionReady.connect(
                     boost::bind(&RemoteJingleTransportCandidateSelector::handleSessionReady, this, _1));
             s5bSession->start();
         }
         else {
-            SWIFT_LOG(debug) << "Can't handle this type of candidate" << std::endl;
+            SWIFT_LOG(debug) << "Can't handle this type of candidate";
             tryNextCandidate();
         }
     }
 }
 
 void RemoteJingleTransportCandidateSelector::handleSessionReady(bool error) {
diff --git a/Swiften/FileTransfer/SOCKS5BytestreamClientSession.cpp b/Swiften/FileTransfer/SOCKS5BytestreamClientSession.cpp
index 5ddd32b..a3f0dab 100644
--- a/Swiften/FileTransfer/SOCKS5BytestreamClientSession.cpp
+++ b/Swiften/FileTransfer/SOCKS5BytestreamClientSession.cpp
@@ -2,13 +2,13 @@
  * Copyright (c) 2011 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
- * Copyright (c) 2013-2016 Isode Limited.
+ * Copyright (c) 2013-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>
 
@@ -46,34 +46,34 @@ SOCKS5BytestreamClientSession::~SOCKS5BytestreamClientSession() {
             boost::bind(&SOCKS5BytestreamClientSession::handleWeFailedTimeout, this));
     weFailedTimeout->stop();
 }
 
 void SOCKS5BytestreamClientSession::start() {
     assert(state == Initial);
-    SWIFT_LOG(debug) << "Trying to connect via TCP to " << addressPort.toString() << "." << std::endl;
+    SWIFT_LOG(debug) << "Trying to connect via TCP to " << addressPort.toString() << ".";
     weFailedTimeout->start();
     connectFinishedConnection = connection->onConnectFinished.connect(
             boost::bind(&SOCKS5BytestreamClientSession::handleConnectFinished, this, _1));
     connection->connect(addressPort);
 }
 
 void SOCKS5BytestreamClientSession::stop() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
     if (state < Ready) {
         weFailedTimeout->stop();
     }
     if (state == Finished) {
         return;
     }
     closeConnection();
     readBytestream.reset();
     state = Finished;
 }
 
 void SOCKS5BytestreamClientSession::process() {
-    SWIFT_LOG(debug) << "unprocessedData.size(): " << unprocessedData.size() << std::endl;
+    SWIFT_LOG(debug) << "unprocessedData.size(): " << unprocessedData.size();
     ByteArray bndAddress;
     switch(state) {
         case Initial:
             hello();
             break;
         case Hello:
@@ -121,25 +121,25 @@ void SOCKS5BytestreamClientSession::process() {
                 // we expect a 0 as port
                 // disconnect and fail
                 finish(true);
             }
             unprocessedData.clear();
             state = Ready;
-            SWIFT_LOG(debug) << "session ready" << std::endl;
+            SWIFT_LOG(debug) << "session ready";
             // issue ready signal so the bytestream can be used for reading or writing
             weFailedTimeout->stop();
             onSessionReady(false);
             break;
         case Ready:
-            SWIFT_LOG(debug) << "Received further data in Ready state." << std::endl;
+            SWIFT_LOG(debug) << "Received further data in Ready state.";
             break;
         case Reading:
         case Writing:
         case Finished:
-            SWIFT_LOG(debug) << "Unexpected receive of data. Current state: " << state << std::endl;
-            SWIFT_LOG(debug) << "Data: " << Hexify::hexify(unprocessedData) << std::endl;
+            SWIFT_LOG(debug) << "Unexpected receive of data. Current state: " << state;
+            SWIFT_LOG(debug) << "Data: " << Hexify::hexify(unprocessedData);
             unprocessedData.clear();
             //assert(false);
     }
 }
 
 void SOCKS5BytestreamClientSession::hello() {
@@ -147,13 +147,13 @@ void SOCKS5BytestreamClientSession::hello() {
     const SafeByteArray hello = createSafeByteArray("\x05\x01\x00", 3);
     connection->write(hello);
     state = Hello;
 }
 
 void SOCKS5BytestreamClientSession::authenticate() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
     SafeByteArray header = createSafeByteArray("\x05\x01\x00\x03", 4);
     SafeByteArray message = header;
     append(message, createSafeByteArray(boost::numeric_cast<char>(destination.size())));
     authenticateAddress = createByteArray(destination);
     append(message, authenticateAddress);
     append(message, createSafeByteArray("\x00\x00", 2)); // 2 byte for port
@@ -165,25 +165,25 @@ void SOCKS5BytestreamClientSession::startReceiving(std::shared_ptr<WriteBytestre
     if (state == Ready) {
         state = Reading;
         writeBytestream = writeStream;
         writeBytestream->write(unprocessedData);
         unprocessedData.clear();
     } else {
-        SWIFT_LOG(debug) << "Session isn't ready for transfer yet!" << std::endl;
+        SWIFT_LOG(debug) << "Session isn't ready for transfer yet!";
     }
 }
 
 void SOCKS5BytestreamClientSession::startSending(std::shared_ptr<ReadBytestream> readStream) {
     if (state == Ready) {
         state = Writing;
         readBytestream = readStream;
         dataWrittenConnection = connection->onDataWritten.connect(
                 boost::bind(&SOCKS5BytestreamClientSession::sendData, this));
         sendData();
     } else {
-        SWIFT_LOG(debug) << "Session isn't ready for transfer yet!" << std::endl;
+        SWIFT_LOG(debug) << "Session isn't ready for transfer yet!";
     }
 }
 
 HostAddressPort SOCKS5BytestreamClientSession::getAddressPort() const {
     return addressPort;
 }
@@ -202,13 +202,13 @@ void SOCKS5BytestreamClientSession::sendData() {
     else {
         finish(false);
     }
 }
 
 void SOCKS5BytestreamClientSession::finish(bool error) {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
     if (state < Ready) {
         weFailedTimeout->stop();
     }
     closeConnection();
     readBytestream.reset();
     if (state == Initial || state == Hello || state == Authenticating) {
@@ -224,47 +224,47 @@ void SOCKS5BytestreamClientSession::finish(bool error) {
     }
 }
 
 void SOCKS5BytestreamClientSession::handleConnectFinished(bool error) {
     connectFinishedConnection.disconnect();
     if (error) {
-        SWIFT_LOG(debug) << "Failed to connect via TCP to " << addressPort.toString() << "." << std::endl;
+        SWIFT_LOG(debug) << "Failed to connect via TCP to " << addressPort.toString() << ".";
         finish(true);
     } else {
-        SWIFT_LOG(debug) << "Successfully connected via TCP" << addressPort.toString() << "." << std::endl;
+        SWIFT_LOG(debug) << "Successfully connected via TCP" << addressPort.toString() << ".";
         disconnectedConnection = connection->onDisconnected.connect(
                 boost::bind(&SOCKS5BytestreamClientSession::handleDisconnected, this, _1));
         dataReadConnection = connection->onDataRead.connect(
                 boost::bind(&SOCKS5BytestreamClientSession::handleDataRead, this, _1));
         weFailedTimeout->stop();
         weFailedTimeout->start();
         process();
     }
 }
 
 void SOCKS5BytestreamClientSession::handleDataRead(std::shared_ptr<SafeByteArray> data) {
-    SWIFT_LOG(debug) << "state: " << state << " data.size() = " << data->size() << std::endl;
+    SWIFT_LOG(debug) << "state: " << state << " data.size() = " << data->size();
     if (state != Reading) {
         append(unprocessedData, *data);
         process();
     }
     else {
         writeBytestream->write(createByteArray(vecptr(*data), data->size()));
         //onBytesReceived(data->size());
     }
 }
 
 void SOCKS5BytestreamClientSession::handleDisconnected(const boost::optional<Connection::Error>& error) {
-    SWIFT_LOG(debug) << (error ? (error == Connection::ReadError ? "Read Error" : "Write Error") : "No Error") << std::endl;
+    SWIFT_LOG(debug) << (error ? (error == Connection::ReadError ? "Read Error" : "Write Error") : "No Error");
     if (error) {
         finish(true);
     }
 }
 
 void SOCKS5BytestreamClientSession::handleWeFailedTimeout() {
-    SWIFT_LOG(debug) << "Failed due to timeout!" << std::endl;
+    SWIFT_LOG(debug) << "Failed due to timeout!";
     finish(true);
 }
 
 void SOCKS5BytestreamClientSession::closeConnection() {
     connectFinishedConnection.disconnect();
     dataWrittenConnection.disconnect();
diff --git a/Swiften/FileTransfer/SOCKS5BytestreamProxiesManager.cpp b/Swiften/FileTransfer/SOCKS5BytestreamProxiesManager.cpp
index cd4cfaa..72c4d41 100644
--- a/Swiften/FileTransfer/SOCKS5BytestreamProxiesManager.cpp
+++ b/Swiften/FileTransfer/SOCKS5BytestreamProxiesManager.cpp
@@ -2,13 +2,13 @@
  * Copyright (c) 2011 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
- * Copyright (c) 2015-2016 Isode Limited.
+ * Copyright (c) 2015-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 
 #include <Swiften/FileTransfer/SOCKS5BytestreamProxiesManager.h>
@@ -43,13 +43,13 @@ SOCKS5BytestreamProxiesManager::~SOCKS5BytestreamProxiesManager() {
         }
     }
 }
 
 void SOCKS5BytestreamProxiesManager::addS5BProxy(S5BProxyRequest::ref proxy) {
     if (proxy) {
-        SWIFT_LOG_ASSERT(HostAddress::fromString(proxy->getStreamHost().get().host), warning) << std::endl;
+        SWIFT_LOG_ASSERT(HostAddress::fromString(proxy->getStreamHost().get().host), warning);
         if (!localS5BProxies_) {
             localS5BProxies_ = std::vector<S5BProxyRequest::ref>();
         }
         localS5BProxies_->push_back(proxy);
     }
 }
@@ -59,22 +59,22 @@ const boost::optional<std::vector<S5BProxyRequest::ref> >& SOCKS5BytestreamProxi
         queryForProxies();
     }
     return localS5BProxies_;
 }
 
 void SOCKS5BytestreamProxiesManager::connectToProxies(const std::string& sessionID) {
-    SWIFT_LOG(debug) << "session ID: " << sessionID << std::endl;
+    SWIFT_LOG(debug) << "session ID: " << sessionID;
     ProxyJIDClientSessionVector clientSessions;
 
     if (localS5BProxies_) {
         for (auto&& proxy : localS5BProxies_.get()) {
             auto proxyHostAddress = HostAddress::fromString(proxy->getStreamHost().get().host);
             if (proxyHostAddress) {
                 std::shared_ptr<Connection> conn = connectionFactory_->createConnection();
                 HostAddressPort addressPort = HostAddressPort(proxyHostAddress.get(), proxy->getStreamHost().get().port);
-                SWIFT_LOG_ASSERT(addressPort.isValid(), warning) << std::endl;
+                SWIFT_LOG_ASSERT(addressPort.isValid(), warning);
                 std::shared_ptr<SOCKS5BytestreamClientSession> session = std::make_shared<SOCKS5BytestreamClientSession>(conn, addressPort, sessionID, timerFactory_);
                 JID proxyJid = proxy->getStreamHost().get().jid;
                 clientSessions.push_back(std::pair<JID, std::shared_ptr<SOCKS5BytestreamClientSession> >(proxyJid, session));
                 session->onSessionReady.connect(boost::bind(&SOCKS5BytestreamProxiesManager::handleProxySessionReady, this,sessionID, proxyJid, session, _1));
                 session->onFinished.connect(boost::bind(&SOCKS5BytestreamProxiesManager::handleProxySessionFinished, this, sessionID, proxyJid, session, _1));
                 session->start();
@@ -100,13 +100,13 @@ std::shared_ptr<SOCKS5BytestreamClientSession> SOCKS5BytestreamProxiesManager::g
             activeSession = i->second;
         }
         else {
             i->second->stop();
         }
     }
-    SWIFT_LOG_ASSERT(activeSession, warning) << "No active session with matching ID found." << std::endl;
+    SWIFT_LOG_ASSERT(activeSession, warning) << "No active session with matching ID found.";
 
     proxySessions_.erase(sessionID);
 
     return activeSession;
 }
 
@@ -141,13 +141,13 @@ void SOCKS5BytestreamProxiesManager::handleProxiesFound(std::vector<S5BProxyRequ
 void SOCKS5BytestreamProxiesManager::handleNameLookupResult(const std::vector<HostAddress>& addresses, boost::optional<DomainNameResolveError> error, S5BProxyRequest::ref proxy) {
     if (error) {
         onDiscoveredProxiesChanged();
     }
     else {
         if (addresses.empty()) {
-            SWIFT_LOG(warning) << "S5B proxy hostname does not resolve." << std::endl;
+            SWIFT_LOG(warning) << "S5B proxy hostname does not resolve.";
         }
         else {
             // generate proxy per returned address
             for (const auto& address : addresses) {
                 S5BProxyRequest::StreamHost streamHost = proxy->getStreamHost().get();
                 S5BProxyRequest::ref proxyForAddress = std::make_shared<S5BProxyRequest>(*proxy);
diff --git a/Swiften/FileTransfer/SOCKS5BytestreamProxyFinder.cpp b/Swiften/FileTransfer/SOCKS5BytestreamProxyFinder.cpp
index 90c42dd..1efc54a 100644
--- a/Swiften/FileTransfer/SOCKS5BytestreamProxyFinder.cpp
+++ b/Swiften/FileTransfer/SOCKS5BytestreamProxyFinder.cpp
@@ -2,13 +2,13 @@
  * Copyright (c) 2011 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
- * Copyright (c) 2015-2016 Isode Limited.
+ * Copyright (c) 2015-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/FileTransfer/SOCKS5BytestreamProxyFinder.h>
 
@@ -68,16 +68,16 @@ void SOCKS5BytestreamProxyFinder::handleWalkEnded() {
 }
 
 void SOCKS5BytestreamProxyFinder::handleProxyResponse(std::shared_ptr<GenericRequest<S5BProxyRequest> > requester, std::shared_ptr<S5BProxyRequest> request, ErrorPayload::ref error) {
     requester->onResponse.disconnect(boost::bind(&SOCKS5BytestreamProxyFinder::handleProxyResponse, this, requester, _1, _2));
     pendingRequests.erase(requester);
     if (error) {
-        SWIFT_LOG(debug) << "ERROR" << std::endl;
+        SWIFT_LOG(debug) << "ERROR";
     } else {
         if (request) {
-            SWIFT_LOG(debug) << "add request" << std::endl;
+            SWIFT_LOG(debug) << "add request";
             proxyHosts.push_back(request);
         }
     }
     if (pendingRequests.empty() && !serviceWalker->isActive()) {
         onProxiesFound(proxyHosts);
     }
diff --git a/Swiften/FileTransfer/SOCKS5BytestreamServerManager.cpp b/Swiften/FileTransfer/SOCKS5BytestreamServerManager.cpp
index a6b75da..7fc1388 100644
--- a/Swiften/FileTransfer/SOCKS5BytestreamServerManager.cpp
+++ b/Swiften/FileTransfer/SOCKS5BytestreamServerManager.cpp
@@ -1,8 +1,8 @@
 /*
- * Copyright (c) 2012-2018 Isode Limited.
+ * Copyright (c) 2012-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 /*
  * Copyright (c) 2011 Tobias Markmann
@@ -45,18 +45,18 @@ SOCKS5BytestreamServerManager::SOCKS5BytestreamServerManager(
             state(Start),
             server(nullptr),
             attemptedPortMapping_(false) {
 }
 
 SOCKS5BytestreamServerManager::~SOCKS5BytestreamServerManager() {
-    SWIFT_LOG_ASSERT(!connectionServer, warning) << std::endl;
-    SWIFT_LOG_ASSERT(!getPublicIPRequest, warning) << std::endl;
-    SWIFT_LOG_ASSERT(!forwardPortRequest, warning) << std::endl;
-    SWIFT_LOG_ASSERT(state == Start, warning) << std::endl;
+    SWIFT_LOG_ASSERT(!connectionServer, warning);
+    SWIFT_LOG_ASSERT(!getPublicIPRequest, warning);
+    SWIFT_LOG_ASSERT(!forwardPortRequest, warning);
+    SWIFT_LOG_ASSERT(state == Start, warning);
     if (portMapping && !unforwardPortRequest) {
-        SWIFT_LOG(warning) << "Port forwarding still alive. Trying to remove it now." << std::endl;
+        SWIFT_LOG(warning) << "Port forwarding still alive. Trying to remove it now.";
         unforwardPortRequest = natTraverser->createRemovePortForwardingRequest(portMapping.get().getLocalPort(), portMapping.get().getPublicPort());
         unforwardPortRequest->start();
     }
 }
 
 std::shared_ptr<SOCKS5BytestreamServerResourceUser> SOCKS5BytestreamServerManager::aquireResourceUser() {
@@ -113,31 +113,31 @@ void SOCKS5BytestreamServerManager::initialize() {
         state = Initializing;
 
         // Find a port to listen on
         assert(!connectionServer);
         unsigned short port;
         for (port = LISTEN_PORTS_BEGIN; port < LISTEN_PORTS_END; ++port) {
-            SWIFT_LOG(debug) << "Trying to start server on port " << port << std::endl;
+            SWIFT_LOG(debug) << "Trying to start server on port " << port;
             connectionServer = connectionServerFactory->createConnectionServer(HostAddress::fromString("::").get(), port);
             boost::optional<ConnectionServer::Error> error = connectionServer->tryStart();
             if (!error) {
                 break;
             }
             else if (*error != ConnectionServer::Conflict) {
-                SWIFT_LOG(debug) << "Error starting server" << std::endl;
+                SWIFT_LOG(debug) << "Error starting server";
                 onInitialized(false);
                 return;
             }
             connectionServer.reset();
         }
         if (!connectionServer) {
-            SWIFT_LOG(debug) << "Unable to find an open port" << std::endl;
+            SWIFT_LOG(debug) << "Unable to find an open port";
             onInitialized(false);
             return;
         }
-        SWIFT_LOG(debug) << "Server started succesfully" << std::endl;
+        SWIFT_LOG(debug) << "Server started succesfully";
         connectionServerPort = port;
 
         // Start bytestream server. Should actually happen before the connectionserver is started
         // but that doesn't really matter here.
         assert(!server);
         server = new SOCKS5BytestreamServer(connectionServer, bytestreamRegistry);
@@ -208,30 +208,30 @@ void SOCKS5BytestreamServerManager::stop() {
 
     state = Start;
 }
 
 void SOCKS5BytestreamServerManager::handleGetPublicIPResult(boost::optional<HostAddress> address) {
     if (address) {
-        SWIFT_LOG(debug) << "Public IP discovered as " << address.get().toString() << "." << std::endl;
+        SWIFT_LOG(debug) << "Public IP discovered as " << address.get().toString() << ".";
     }
     else {
-        SWIFT_LOG(debug) << "No public IP discoverable." << std::endl;
+        SWIFT_LOG(debug) << "No public IP discoverable.";
     }
 
     publicAddress = address;
 
     getPublicIPRequest->stop();
     getPublicIPRequest.reset();
 }
 
 void SOCKS5BytestreamServerManager::handleForwardPortResult(boost::optional<NATPortMapping> mapping) {
     if (mapping) {
-        SWIFT_LOG(debug) << "Mapping port was successful." << std::endl;
+        SWIFT_LOG(debug) << "Mapping port was successful.";
     }
     else {
-        SWIFT_LOG(debug) << "Mapping port has failed." << std::endl;
+        SWIFT_LOG(debug) << "Mapping port has failed.";
     }
 
     portMapping = mapping;
     onPortForwardingSetup(mapping.is_initialized());
 
     forwardPortRequest->stop();
@@ -240,13 +240,13 @@ void SOCKS5BytestreamServerManager::handleForwardPortResult(boost::optional<NATP
 
 void SOCKS5BytestreamServerManager::handleUnforwardPortResult(boost::optional<bool> result) {
     if (result.is_initialized() && result.get()) {
         portMapping.reset();
     }
     else {
-        SWIFT_LOG(warning) << "Failed to remove port forwarding." << std::endl;
+        SWIFT_LOG(warning) << "Failed to remove port forwarding.";
     }
     attemptedPortMapping_ = false;
     unforwardPortRequest.reset();
 }
 
 void SOCKS5BytestreamServerManager::checkInitializeFinished() {
diff --git a/Swiften/FileTransfer/SOCKS5BytestreamServerSession.cpp b/Swiften/FileTransfer/SOCKS5BytestreamServerSession.cpp
index 0fd40bf..a4ab751 100644
--- a/Swiften/FileTransfer/SOCKS5BytestreamServerSession.cpp
+++ b/Swiften/FileTransfer/SOCKS5BytestreamServerSession.cpp
@@ -1,8 +1,8 @@
 /*
- * Copyright (c) 2010-2018 Isode Limited.
+ * Copyright (c) 2010-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/FileTransfer/SOCKS5BytestreamServerSession.h>
 
@@ -30,42 +30,42 @@ SOCKS5BytestreamServerSession::SOCKS5BytestreamServerSession(
             waitingForData(false) {
     disconnectedConnection = connection->onDisconnected.connect(boost::bind(&SOCKS5BytestreamServerSession::handleDisconnected, this, _1));
 }
 
 SOCKS5BytestreamServerSession::~SOCKS5BytestreamServerSession() {
     if (state != Finished && state != Initial) {
-        SWIFT_LOG(warning) << "SOCKS5BytestreamServerSession unfinished" << std::endl;
+        SWIFT_LOG(warning) << "SOCKS5BytestreamServerSession unfinished";
         finish();
     }
 }
 
 void SOCKS5BytestreamServerSession::start() {
-    SWIFT_LOG(debug) << std::endl;
+    SWIFT_LOG(debug);
     dataReadConnection = connection->onDataRead.connect(
             boost::bind(&SOCKS5BytestreamServerSession::handleDataRead, this, _1));
     state = WaitingForAuthentication;
 }
 
 void SOCKS5BytestreamServerSession::stop() {
     finish();
 }
 
 void SOCKS5BytestreamServerSession::startSending(std::shared_ptr<ReadBytestream> stream) {
-    if (state != ReadyForTransfer) { SWIFT_LOG(debug) << "Not ready for transfer!" << std::endl; return; }
+    if (state != ReadyForTransfer) { SWIFT_LOG(debug) << "Not ready for transfer!"; return; }
 
     readBytestream = stream;
     state = WritingData;
     dataAvailableConnection = readBytestream->onDataAvailable.connect(
             boost::bind(&SOCKS5BytestreamServerSession::handleDataAvailable, this));
     dataWrittenConnection = connection->onDataWritten.connect(
             boost::bind(&SOCKS5BytestreamServerSession::sendData, this));
     sendData();
 }
 
 void SOCKS5BytestreamServerSession::startReceiving(std::shared_ptr<WriteBytestream> stream) {
-    if (state != ReadyForTransfer) { SWIFT_LOG(debug) << "Not ready for transfer!" << std::endl; return; }
+    if (state != ReadyForTransfer) { SWIFT_LOG(debug) << "Not ready for transfer!"; return; }
 
     writeBytestream = stream;
     state = ReadingData;
     writeBytestream->write(unprocessedData);
     // onBytesReceived(unprocessedData.size());
     unprocessedData.clear();
@@ -90,13 +90,13 @@ void SOCKS5BytestreamServerSession::handleDataAvailable() {
     if (waitingForData) {
         sendData();
     }
 }
 
 void SOCKS5BytestreamServerSession::handleDisconnected(const boost::optional<Connection::Error>& error) {
-    SWIFT_LOG(debug) << (error ? (error == Connection::ReadError ? "Read Error" : "Write Error") : "No Error") << std::endl;
+    SWIFT_LOG(debug) << (error ? (error == Connection::ReadError ? "Read Error" : "Write Error") : "No Error");
     finish(error ? boost::optional<FileTransferError>(FileTransferError::PeerError) : boost::optional<FileTransferError>());
 }
 
 void SOCKS5BytestreamServerSession::process() {
     if (state == WaitingForAuthentication) {
         if (unprocessedData.size() >= 2) {
@@ -106,13 +106,13 @@ void SOCKS5BytestreamServerSession::process() {
                 // Skip authentication mechanism
                 ++i;
             }
             if (i == 2 + authCount) {
                 // Authentication message is complete
                 if (i != unprocessedData.size()) {
-                    SWIFT_LOG(debug) << "Junk after authentication mechanism" << std::endl;
+                    SWIFT_LOG(debug) << "Junk after authentication mechanism";
                 }
                 unprocessedData.clear();
                 connection->write(createSafeByteArray("\x05\x00", 2));
                 state = WaitingForRequest;
             }
         }
@@ -127,36 +127,36 @@ void SOCKS5BytestreamServerSession::process() {
                 ++i;
             }
             // Skip the port: 2 byte large, one already skipped. Add one for comparison with size
             i += 2;
             if (i <= unprocessedData.size()) {
                 if (i != unprocessedData.size()) {
-                    SWIFT_LOG(debug) << "Junk after authentication mechanism" << std::endl;
+                    SWIFT_LOG(debug) << "Junk after authentication mechanism";
                 }
                 unprocessedData.clear();
                 streamID = byteArrayToString(requestID);
                 bool hasBytestream = bytestreams->hasBytestream(streamID);
                 SafeByteArray result = createSafeByteArray("\x05", 1);
                 result.push_back(hasBytestream ? 0x0 : 0x4);
                 append(result, createByteArray("\x00\x03", 2));
                 try {
                     result.push_back(boost::numeric_cast<unsigned char>(requestID.size()));
                 }
                 catch (const boost::numeric::bad_numeric_cast& e) {
-                    SWIFT_LOG(warning) << "SOCKS5 request ID is too long (" << requestID.size() << "): " << e.what() << std::endl;
+                    SWIFT_LOG(warning) << "SOCKS5 request ID is too long (" << requestID.size() << "): " << e.what();
                     finish();
                     return;
                 }
                 append(result, concat(requestID, createByteArray("\x00\x00", 2)));
                 if (!hasBytestream) {
-                    SWIFT_LOG(debug) << "Readstream or Wrtiestream with ID " << streamID << " not found!" << std::endl;
+                    SWIFT_LOG(debug) << "Readstream or Wrtiestream with ID " << streamID << " not found!";
                     connection->write(result);
                     finish(boost::optional<FileTransferError>(FileTransferError::PeerError));
                 }
                 else {
-                    SWIFT_LOG(debug) << "Found stream. Sent OK." << std::endl;
+                    SWIFT_LOG(debug) << "Found stream. Sent OK.";
                     connection->write(result);
                     state = ReadyForTransfer;
                 }
             }
         }
     }
@@ -182,13 +182,13 @@ void SOCKS5BytestreamServerSession::sendData() {
     else {
         finish();
     }
 }
 
 void SOCKS5BytestreamServerSession::finish(const boost::optional<FileTransferError>& error) {
-    SWIFT_LOG(debug) << "state: " << state << std::endl;
+    SWIFT_LOG(debug) << "state: " << state;
     if (state == Finished) {
         return;
     }
 
     disconnectedConnection.disconnect();
     dataReadConnection.disconnect();
diff --git a/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamClientSessionTest.cpp b/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamClientSessionTest.cpp
index 80667b6..fad02da 100644
--- a/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamClientSessionTest.cpp
+++ b/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamClientSessionTest.cpp
@@ -2,13 +2,13 @@
  * Copyright (c) 2011 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 /*
- * Copyright (c) 2015-2016 Isode Limited.
+ * Copyright (c) 2015-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <memory>
 
@@ -235,13 +235,13 @@ private:
         append(*correctData, createSafeByteArray(destination));
         append(*correctData, createSafeByteArray("\x00", 1));
 
         std::shared_ptr<SafeByteArray> dataToSend;
         //ByteArray failingData = Hexify::unhexify("8417947d1d305c72c11520ea7d2c6e787396705e72c312c6ccc3f66613d7cae1b91b7ab48e8b59a17d559c15fb51");
         //append(dataToSend, failingData);
-        //SWIFT_LOG(debug) << "hexed: " << Hexify::hexify(failingData) << std::endl;
+        //SWIFT_LOG(debug) << "hexed: " << Hexify::hexify(failingData);
         do {
             ByteArray rndArray = generateRandomByteArray(correctData->size());
             dataToSend = createSafeByteArrayRef(vecptr(rndArray), rndArray.size());
         } while (*dataToSend == *correctData);
         connection->onDataRead(dataToSend);
     }
@@ -252,13 +252,13 @@ private:
         ByteArray unprocessedInput;
         bool sessionReadyCalled;
         bool sessionReadyError;
 
         void handleConnectionDataWritten(const SafeByteArray& data) {
             append(unprocessedInput, data);
-            //SWIFT_LOG(debug) << "unprocessedInput (" << unprocessedInput.size() <<  "): " << Hexify::hexify(unprocessedInput) << std::endl;
+            //SWIFT_LOG(debug) << "unprocessedInput (" << unprocessedInput.size() <<  "): " << Hexify::hexify(unprocessedInput);
         }
 
         void handleSessionReady(bool error) {
             sessionReadyCalled = true;
             sessionReadyError = error;
         }
author	Edwin Mons <edwin.mons@isode.com>	2019-11-19 13:36:05 (GMT)
committer	Edwin Mons <edwin.mons@isode.com>	2019-11-19 13:58:45 (GMT)
commit	261ba8d8595ed8cb90f9c4feb1d6ef642942bcba (patch)
tree	c7e60d473509db8c4dbff5aa83fbde963d8dd75e /Swiften/FileTransfer
parent	697ae6ae84512a744958b24118197ec7bfdbc1f0 (diff)
download	swift-261ba8d8595ed8cb90f9c4feb1d6ef642942bcba.zip swift-261ba8d8595ed8cb90f9c4feb1d6ef642942bcba.tar.bz2