4 files changed, 34 insertions, 33 deletions
diff --git a/Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.cpp b/Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.cpp
index 2975193..09b664f 100644
--- a/Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.cpp
+++ b/Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.cpp
@@ -1,51 +1,50 @@
 /*
  * 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.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 #include <Swiften/FileTransfer/LocalJingleTransportCandidateGenerator.h>
 
 #include <memory>
 #include <vector>
 
 #include <boost/bind.hpp>
 
 #include <Swiften/Base/Log.h>
-#include <Swiften/Base/foreach.h>
 #include <Swiften/Elements/JingleS5BTransportPayload.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamProxiesManager.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamServerManager.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamServerPortForwardingUser.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamServerResourceUser.h>
 
 static const unsigned int LOCAL_PREFERENCE = 0;
 
 namespace Swift {
 
 LocalJingleTransportCandidateGenerator::LocalJingleTransportCandidateGenerator(
         SOCKS5BytestreamServerManager* s5bServerManager,
         SOCKS5BytestreamProxiesManager* s5bProxy,
         const JID& ownJID,
         IDGenerator* idGenerator,
         const FileTransferOptions& options) :
             s5bServerManager(s5bServerManager),
             s5bProxy(s5bProxy),
             ownJID(ownJID),
             idGenerator(idGenerator),
             triedServerInit_(false),
             triedForwarding_(false),
             triedProxyDiscovery_(false),
             options_(options) {
 }
 
 LocalJingleTransportCandidateGenerator::~LocalJingleTransportCandidateGenerator() {
     SWIFT_LOG_ASSERT(!s5bServerInitializeRequest, warning) << std::endl;
 }
 
@@ -113,79 +112,80 @@ void LocalJingleTransportCandidateGenerator::handlePortForwardingSetup(bool /* s
     if (s5bServerPortForwardingUser_) {
         s5bServerPortForwardingUser_->onSetup.disconnect(boost::bind(&LocalJingleTransportCandidateGenerator::handlePortForwardingSetup, this, _1));
     }
     triedForwarding_ = true;
     checkS5BCandidatesReady();
 }
 
 void LocalJingleTransportCandidateGenerator::handleDiscoveredProxiesChanged() {
     if (s5bProxy) {
         s5bProxy->onDiscoveredProxiesChanged.disconnect(boost::bind(&LocalJingleTransportCandidateGenerator::handleDiscoveredProxiesChanged, this));
     }
     triedProxyDiscovery_ = true;
     checkS5BCandidatesReady();
 }
 
 void LocalJingleTransportCandidateGenerator::checkS5BCandidatesReady() {
     if ((!options_.isDirectAllowed()  || (options_.isDirectAllowed()  && triedServerInit_)) &&
         (!options_.isProxiedAllowed() || (options_.isProxiedAllowed() && triedProxyDiscovery_)) &&
         (!options_.isAssistedAllowed()  || (options_.isAssistedAllowed()  && triedForwarding_))) {
         emitOnLocalTransportCandidatesGenerated();
     }
 }
 
 
 void LocalJingleTransportCandidateGenerator::emitOnLocalTransportCandidatesGenerated() {
     std::vector<JingleS5BTransportPayload::Candidate> candidates;
 
     if (options_.isDirectAllowed()) {
         // get direct candidates
         std::vector<HostAddressPort> directCandidates = s5bServerManager->getHostAddressPorts();
-        foreach(HostAddressPort addressPort, directCandidates) {
+        for(auto&& addressPort : directCandidates) {
             if (addressPort.getAddress().getRawAddress().is_v6() &&
                 addressPort.getAddress().getRawAddress().to_v6().is_link_local()) {
                 continue;
             }
             JingleS5BTransportPayload::Candidate candidate;
             candidate.type = JingleS5BTransportPayload::Candidate::DirectType;
             candidate.jid = ownJID;
             candidate.hostPort = addressPort;
             candidate.priority = 65536 * 126 + LOCAL_PREFERENCE;
             candidate.cid = idGenerator->generateID();
             candidates.push_back(candidate);
         }
     }
 
     if (options_.isAssistedAllowed()) {
         // get assissted candidates
         std::vector<HostAddressPort> assisstedCandidates = s5bServerManager->getAssistedHostAddressPorts();
-        foreach(HostAddressPort addressPort, assisstedCandidates) {
+        for (auto&& addressPort : assisstedCandidates) {
             JingleS5BTransportPayload::Candidate candidate;
             candidate.type = JingleS5BTransportPayload::Candidate::AssistedType;
             candidate.jid = ownJID;
             candidate.hostPort = addressPort;
             candidate.priority = 65536 * 120 + LOCAL_PREFERENCE;
             candidate.cid = idGenerator->generateID();
             candidates.push_back(candidate);
         }
     }
 
     if (options_.isProxiedAllowed() && s5bProxy->getOrDiscoverS5BProxies().is_initialized()) {
-        foreach(S5BProxyRequest::ref proxy, s5bProxy->getOrDiscoverS5BProxies().get()) {
+        for (auto&& proxy : s5bProxy->getOrDiscoverS5BProxies().get()) {
             if (proxy->getStreamHost()) { // FIXME: Added this test, because there were cases where this wasn't initialized. Investigate this. (Remko)
                 JingleS5BTransportPayload::Candidate candidate;
                 candidate.type = JingleS5BTransportPayload::Candidate::ProxyType;
                 candidate.jid = (*proxy->getStreamHost()).jid;
-                HostAddress address = (*proxy->getStreamHost()).host;
-                assert(address.isValid());
-                candidate.hostPort = HostAddressPort(address, (*proxy->getStreamHost()).port);
-                candidate.priority = 65536 * 10 + LOCAL_PREFERENCE;
-                candidate.cid = idGenerator->generateID();
-                candidates.push_back(candidate);
+                auto address = HostAddress::fromString((*proxy->getStreamHost()).host);
+                if (address) {
+                    candidate.hostPort = HostAddressPort(address.get(), (*proxy->getStreamHost()).port);
+                    candidate.priority = 65536 * 10 + LOCAL_PREFERENCE;
+                    candidate.cid = idGenerator->generateID();
+                    candidates.push_back(candidate);
+                }
             }
         }
     }
 
     onLocalTransportCandidatesGenerated(candidates);
 }
 
 }
diff --git a/Swiften/FileTransfer/SOCKS5BytestreamProxiesManager.cpp b/Swiften/FileTransfer/SOCKS5BytestreamProxiesManager.cpp
index 367676b..cd4cfaa 100644
--- a/Swiften/FileTransfer/SOCKS5BytestreamProxiesManager.cpp
+++ b/Swiften/FileTransfer/SOCKS5BytestreamProxiesManager.cpp
@@ -1,179 +1,181 @@
 /*
  * 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.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 
 #include <Swiften/FileTransfer/SOCKS5BytestreamProxiesManager.h>
 
 #include <memory>
 
 #include <boost/bind.hpp>
 
 #include <Swiften/Base/Log.h>
-#include <Swiften/Base/foreach.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>
 #include <Swiften/Network/ConnectionFactory.h>
 #include <Swiften/Network/DomainNameAddressQuery.h>
 #include <Swiften/Network/DomainNameResolveError.h>
 #include <Swiften/Network/DomainNameResolver.h>
 #include <Swiften/Network/TimerFactory.h>
 
 namespace Swift {
 
 SOCKS5BytestreamProxiesManager::SOCKS5BytestreamProxiesManager(ConnectionFactory *connFactory, TimerFactory *timeFactory, DomainNameResolver* resolver, IQRouter* iqRouter, const JID& serviceRoot) : connectionFactory_(connFactory), timerFactory_(timeFactory), resolver_(resolver), iqRouter_(iqRouter), serviceRoot_(serviceRoot) {
 
 }
 
 SOCKS5BytestreamProxiesManager::~SOCKS5BytestreamProxiesManager() {
     if (proxyFinder_) {
         proxyFinder_->stop();
     }
 
-    foreach (const ProxySessionsMap::value_type& sessionsForID, proxySessions_) {
-        foreach (const ProxyJIDClientSessionVector::value_type& session, sessionsForID.second) {
+    for (const auto& sessionsForID : proxySessions_) {
+        for (const auto& session : sessionsForID.second) {
             session.second->onSessionReady.disconnect(boost::bind(&SOCKS5BytestreamProxiesManager::handleProxySessionReady, this,sessionsForID.first, session.first, session.second, _1));
             session.second->onFinished.disconnect(boost::bind(&SOCKS5BytestreamProxiesManager::handleProxySessionFinished, this, sessionsForID.first, session.first, session.second, _1));
         }
     }
 }
 
 void SOCKS5BytestreamProxiesManager::addS5BProxy(S5BProxyRequest::ref proxy) {
     if (proxy) {
-        SWIFT_LOG_ASSERT(HostAddress(proxy->getStreamHost().get().host).isValid(), warning) << std::endl;
+        SWIFT_LOG_ASSERT(HostAddress::fromString(proxy->getStreamHost().get().host), warning) << std::endl;
         if (!localS5BProxies_) {
             localS5BProxies_ = std::vector<S5BProxyRequest::ref>();
         }
         localS5BProxies_->push_back(proxy);
     }
 }
 
 const boost::optional<std::vector<S5BProxyRequest::ref> >& SOCKS5BytestreamProxiesManager::getOrDiscoverS5BProxies() {
     if (!localS5BProxies_ && !proxyFinder_) {
         queryForProxies();
     }
     return localS5BProxies_;
 }
 
 void SOCKS5BytestreamProxiesManager::connectToProxies(const std::string& sessionID) {
     SWIFT_LOG(debug) << "session ID: " << sessionID << std::endl;
     ProxyJIDClientSessionVector clientSessions;
 
     if (localS5BProxies_) {
-        foreach(S5BProxyRequest::ref proxy, localS5BProxies_.get()) {
-            std::shared_ptr<Connection> conn = connectionFactory_->createConnection();
-
-            HostAddressPort addressPort = HostAddressPort(proxy->getStreamHost().get().host, proxy->getStreamHost().get().port);
-            SWIFT_LOG_ASSERT(addressPort.isValid(), warning) << std::endl;
-            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();
+        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;
+                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();
+            }
         }
     }
 
     proxySessions_[sessionID] = clientSessions;
 }
 
 std::shared_ptr<SOCKS5BytestreamClientSession> SOCKS5BytestreamProxiesManager::getProxySessionAndCloseOthers(const JID& proxyJID, const std::string& sessionID) {
     // checking parameters
     if (proxySessions_.find(sessionID) == proxySessions_.end()) {
         return std::shared_ptr<SOCKS5BytestreamClientSession>();
     }
 
     // get active session
     std::shared_ptr<SOCKS5BytestreamClientSession> activeSession;
     for (ProxyJIDClientSessionVector::iterator i = proxySessions_[sessionID].begin(); i != proxySessions_[sessionID].end(); i++) {
         i->second->onSessionReady.disconnect(boost::bind(&SOCKS5BytestreamProxiesManager::handleProxySessionReady, this,sessionID, proxyJID, i->second, _1));
         i->second->onFinished.disconnect(boost::bind(&SOCKS5BytestreamProxiesManager::handleProxySessionFinished, this, sessionID, proxyJID, i->second, _1));
         if (i->first == proxyJID && !activeSession) {
             activeSession = i->second;
         }
         else {
             i->second->stop();
         }
     }
     SWIFT_LOG_ASSERT(activeSession, warning) << "No active session with matching ID found." << std::endl;
 
     proxySessions_.erase(sessionID);
 
     return activeSession;
 }
 
 std::shared_ptr<SOCKS5BytestreamClientSession> SOCKS5BytestreamProxiesManager::createSOCKS5BytestreamClientSession(HostAddressPort addressPort, const std::string& destAddr) {
     SOCKS5BytestreamClientSession::ref connection = std::make_shared<SOCKS5BytestreamClientSession>(connectionFactory_->createConnection(), addressPort, destAddr, timerFactory_);
     return connection;
 }
 
 void SOCKS5BytestreamProxiesManager::handleProxiesFound(std::vector<S5BProxyRequest::ref> proxyHosts) {
     proxyFinder_->onProxiesFound.disconnect(boost::bind(&SOCKS5BytestreamProxiesManager::handleProxiesFound, this, _1));
-    foreach(S5BProxyRequest::ref proxy, proxyHosts) {
+    for (auto&& proxy : proxyHosts) {
         if (proxy) {
-            if (HostAddress(proxy->getStreamHost().get().host).isValid()) {
+            auto proxyHostAddress = HostAddress::fromString(proxy->getStreamHost().get().host);
+            if (proxyHostAddress) {
                 addS5BProxy(proxy);
                 onDiscoveredProxiesChanged();
             }
             else {
                 DomainNameAddressQuery::ref resolveRequest = resolver_->createAddressQuery(proxy->getStreamHost().get().host);
                 resolveRequest->onResult.connect(boost::bind(&SOCKS5BytestreamProxiesManager::handleNameLookupResult, this, _1, _2, proxy));
                 resolveRequest->run();
             }
         }
     }
     proxyFinder_->stop();
     proxyFinder_.reset();
     if (proxyHosts.empty()) {
         onDiscoveredProxiesChanged();
     }
 }
 
 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;
         }
         else {
             // generate proxy per returned address
-            foreach (const HostAddress& address, addresses) {
+            for (const auto& address : addresses) {
                 S5BProxyRequest::StreamHost streamHost = proxy->getStreamHost().get();
                 S5BProxyRequest::ref proxyForAddress = std::make_shared<S5BProxyRequest>(*proxy);
                 streamHost.host = address.toString();
                 proxyForAddress->setStreamHost(streamHost);
                 addS5BProxy(proxyForAddress);
             }
         }
         onDiscoveredProxiesChanged();
     }
 }
 
 void SOCKS5BytestreamProxiesManager::queryForProxies() {
     proxyFinder_ = std::make_shared<SOCKS5BytestreamProxyFinder>(serviceRoot_, iqRouter_);
 
     proxyFinder_->onProxiesFound.connect(boost::bind(&SOCKS5BytestreamProxiesManager::handleProxiesFound, this, _1));
     proxyFinder_->start();
 }
 
 void SOCKS5BytestreamProxiesManager::handleProxySessionReady(const std::string& sessionID, const JID& jid, std::shared_ptr<SOCKS5BytestreamClientSession> session, bool error) {
     session->onSessionReady.disconnect(boost::bind(&SOCKS5BytestreamProxiesManager::handleProxySessionReady, this, boost::cref(sessionID), boost::cref(jid), session, _1));
     if (!error) {
         // The SOCKS5 bytestream session to the proxy succeeded; stop and remove other sessions.
         if (proxySessions_.find(sessionID) != proxySessions_.end()) {
             for (ProxyJIDClientSessionVector::iterator i = proxySessions_[sessionID].begin(); i != proxySessions_[sessionID].end();) {
                 if ((i->first == jid) && (i->second != session)) {
                     i->second->stop();
                     i = proxySessions_[sessionID].erase(i);
                 }
                 else {
                     i++;
diff --git a/Swiften/FileTransfer/SOCKS5BytestreamServerManager.cpp b/Swiften/FileTransfer/SOCKS5BytestreamServerManager.cpp
index 33a5283..f749735 100644
--- a/Swiften/FileTransfer/SOCKS5BytestreamServerManager.cpp
+++ b/Swiften/FileTransfer/SOCKS5BytestreamServerManager.cpp
@@ -1,50 +1,49 @@
 /*
  * Copyright (c) 2012-2016 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
 
 /*
  * Copyright (c) 2011 Tobias Markmann
  * Licensed under the simplified BSD license.
  * See Documentation/Licenses/BSD-simplified.txt for more information.
  */
 
 #include <Swiften/FileTransfer/SOCKS5BytestreamServerManager.h>
 
 #include <memory>
 
 #include <boost/bind.hpp>
 
 #include <Swiften/Base/Log.h>
-#include <Swiften/Base/foreach.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamServer.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamServerPortForwardingUser.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamServerResourceUser.h>
 #include <Swiften/Network/ConnectionServer.h>
 #include <Swiften/Network/ConnectionServerFactory.h>
 #include <Swiften/Network/NATTraversalForwardPortRequest.h>
 #include <Swiften/Network/NATTraversalGetPublicIPRequest.h>
 #include <Swiften/Network/NATTraversalRemovePortForwardingRequest.h>
 #include <Swiften/Network/NATTraverser.h>
 #include <Swiften/Network/NetworkEnvironment.h>
 
 using namespace Swift;
 
 static const int LISTEN_PORTS_BEGIN = 10000;
 static const int LISTEN_PORTS_END = 11000;
 
 SOCKS5BytestreamServerManager::SOCKS5BytestreamServerManager(
         SOCKS5BytestreamRegistry* bytestreamRegistry,
         ConnectionServerFactory* connectionServerFactory,
         NetworkEnvironment* networkEnvironment,
         NATTraverser* natTraverser) :
             bytestreamRegistry(bytestreamRegistry),
             connectionServerFactory(connectionServerFactory),
             networkEnvironment(networkEnvironment),
             natTraverser(natTraverser),
             state(Start),
             server(nullptr),
             attemptedPortMapping_(false) {
 }
 
@@ -61,91 +60,91 @@ SOCKS5BytestreamServerManager::~SOCKS5BytestreamServerManager() {
 }
 
 std::shared_ptr<SOCKS5BytestreamServerResourceUser> SOCKS5BytestreamServerManager::aquireResourceUser() {
     std::shared_ptr<SOCKS5BytestreamServerResourceUser> resourceUser;
     if (s5bServerResourceUser_.expired()) {
         resourceUser = std::make_shared<SOCKS5BytestreamServerResourceUser>(this);
         s5bServerResourceUser_ = resourceUser;
     }
     else {
         resourceUser = s5bServerResourceUser_.lock();
     }
     return resourceUser;
 }
 
 std::shared_ptr<SOCKS5BytestreamServerPortForwardingUser> SOCKS5BytestreamServerManager::aquirePortForwardingUser() {
     std::shared_ptr<SOCKS5BytestreamServerPortForwardingUser> portForwardingUser;
     if (s5bServerPortForwardingUser_.expired()) {
         portForwardingUser = std::make_shared<SOCKS5BytestreamServerPortForwardingUser>(this);
         s5bServerPortForwardingUser_ = portForwardingUser;
     }
     else {
         portForwardingUser = s5bServerPortForwardingUser_.lock();
     }
     return portForwardingUser;
 }
 
 std::vector<HostAddressPort> SOCKS5BytestreamServerManager::getHostAddressPorts() const {
     std::vector<HostAddressPort> result;
     if (connectionServer) {
         std::vector<NetworkInterface> networkInterfaces = networkEnvironment->getNetworkInterfaces();
-        foreach (const NetworkInterface& networkInterface, networkInterfaces) {
-            foreach (const HostAddress& address, networkInterface.getAddresses()) {
+        for (const auto& networkInterface : networkInterfaces) {
+            for (const auto& address : networkInterface.getAddresses()) {
                 result.push_back(HostAddressPort(address, connectionServerPort));
             }
         }
     }
     return result;
 }
 
 std::vector<HostAddressPort> SOCKS5BytestreamServerManager::getAssistedHostAddressPorts() const {
     std::vector<HostAddressPort> result;
     if (publicAddress && portMapping) {
         result.push_back(HostAddressPort(*publicAddress, portMapping->getPublicPort()));
     }
     return result;
 }
 
 bool SOCKS5BytestreamServerManager::isInitialized() const {
     return state == Initialized;
 }
 
 void SOCKS5BytestreamServerManager::initialize() {
     if (state == Start) {
         state = Initializing;
 
         // Find a port to listen on
         assert(!connectionServer);
         int port;
         for (port = LISTEN_PORTS_BEGIN; port < LISTEN_PORTS_END; ++port) {
             SWIFT_LOG(debug) << "Trying to start server on port " << port << std::endl;
-            connectionServer = connectionServerFactory->createConnectionServer(HostAddress("::"), 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;
                 onInitialized(false);
                 return;
             }
             connectionServer.reset();
         }
         if (!connectionServer) {
             SWIFT_LOG(debug) << "Unable to find an open port" << std::endl;
             onInitialized(false);
             return;
         }
         SWIFT_LOG(debug) << "Server started succesfully" << std::endl;
         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);
         server->start();
         checkInitializeFinished();
     }
 }
 
 bool SOCKS5BytestreamServerManager::isPortForwardingReady() const {
     return attemptedPortMapping_ && !getPublicIPRequest && !forwardPortRequest;
diff --git a/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamClientSessionTest.cpp b/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamClientSessionTest.cpp
index cb43d78..290dda5 100644
--- a/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamClientSessionTest.cpp
+++ b/Swiften/FileTransfer/UnitTest/SOCKS5BytestreamClientSessionTest.cpp
@@ -26,61 +26,61 @@
 #include <Swiften/Base/ByteArray.h>
 #include <Swiften/Base/Concat.h>
 #include <Swiften/Base/Log.h>
 #include <Swiften/Base/StartStopper.h>
 #include <Swiften/Crypto/CryptoProvider.h>
 #include <Swiften/Crypto/PlatformCryptoProvider.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/FileTransfer/ByteArrayReadBytestream.h>
 #include <Swiften/FileTransfer/ByteArrayWriteBytestream.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamClientSession.h>
 #include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>
 #include <Swiften/JID/JID.h>
 #include <Swiften/Network/DummyConnection.h>
 #include <Swiften/Network/DummyTimerFactory.h>
 #include <Swiften/StringCodecs/Hexify.h>
 
 using namespace Swift;
 
 static boost::mt19937 randomGen;
 
 class SOCKS5BytestreamClientSessionTest : public CppUnit::TestFixture {
     CPPUNIT_TEST_SUITE(SOCKS5BytestreamClientSessionTest);
     CPPUNIT_TEST(testForSessionReady);
     CPPUNIT_TEST(testErrorHandlingHello);
     CPPUNIT_TEST(testErrorHandlingRequest);
     CPPUNIT_TEST(testWriteBytestream);
     CPPUNIT_TEST(testReadBytestream);
     CPPUNIT_TEST_SUITE_END();
 
 public:
-    SOCKS5BytestreamClientSessionTest() : destinationAddressPort(HostAddressPort(HostAddress("127.0.0.1"), 8888)) {}
+    SOCKS5BytestreamClientSessionTest() : destinationAddressPort(HostAddressPort(HostAddress::fromString("127.0.0.1").get(), 8888)) {}
 
     void setUp() {
         crypto = std::shared_ptr<CryptoProvider>(PlatformCryptoProvider::create());
         destination = "092a44d859d19c9eed676b551ee80025903351c2";
         randomGen.seed(static_cast<unsigned int>(time(nullptr)));
         eventLoop = std::unique_ptr<DummyEventLoop>(new DummyEventLoop());
         timerFactory = std::unique_ptr<DummyTimerFactory>(new DummyTimerFactory());
         connection = std::make_shared<MockeryConnection>(failingPorts, true, eventLoop.get());
         //connection->onDataSent.connect(boost::bind(&SOCKS5BytestreamServerSessionTest::handleDataWritten, this, _1));
         //stream1 = std::make_shared<ByteArrayReadBytestream>(createByteArray("abcdefg")));
 //        connection->onDataRead.connect(boost::bind(&SOCKS5BytestreamClientSessionTest::handleDataRead, this, _1));
     }
 
     void tearDown() {
         //connection.reset();
     }
 
     void testForSessionReady() {
         TestHelper helper;
         connection->onDataSent.connect(boost::bind(&TestHelper::handleConnectionDataWritten, &helper, _1));
 
         SOCKS5BytestreamClientSession::ref clientSession = std::make_shared<SOCKS5BytestreamClientSession>(connection, destinationAddressPort, destination, timerFactory.get());
         clientSession->onSessionReady.connect(boost::bind(&TestHelper::handleSessionReady, &helper, _1));
 
         clientSession->start();
         eventLoop->processEvents();
         CPPUNIT_ASSERT(createByteArray("\x05\x01\x00", 3) == helper.unprocessedInput);
 
         helper.unprocessedInput.clear();
         serverRespondHelloOK();