8 files changed, 259 insertions, 259 deletions
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDBrowseQuery.h b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDBrowseQuery.h
index b2a6d61..15d8128 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDBrowseQuery.h
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDBrowseQuery.h
@@ -1,28 +1,28 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2010-2016 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
 #pragma once
 
-#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h>
 #include <Swiften/LinkLocal/DNSSD/DNSSDBrowseQuery.h>
+#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h>
 
 namespace Swift {
-	class FakeDNSSDQuerier;
+    class FakeDNSSDQuerier;
 
-	class FakeDNSSDBrowseQuery : public DNSSDBrowseQuery, public FakeDNSSDQuery {
-		public:	
-			FakeDNSSDBrowseQuery(boost::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier) {
-			}
+    class FakeDNSSDBrowseQuery : public DNSSDBrowseQuery, public FakeDNSSDQuery {
+        public:
+            FakeDNSSDBrowseQuery(std::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier) {
+            }
 
-			void startBrowsing() {
-				run();
-			}
+            void startBrowsing() {
+                run();
+            }
 
-			void stopBrowsing() {
-				finish();
-			}
-	};
+            void stopBrowsing() {
+                finish();
+            }
+    };
 }
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.cpp b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.cpp
index 1ddeffa..3381a26 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.cpp
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.cpp
@@ -1,21 +1,21 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2010-2018 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
 #include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h>
 
-#include <boost/bind.hpp>
 #include <iostream>
 
-#include <Swiften/Base/foreach.h>
+#include <boost/bind.hpp>
+
 #include <Swiften/Base/Algorithm.h>
+#include <Swiften/EventLoop/EventLoop.h>
 #include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDBrowseQuery.h>
 #include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDRegisterQuery.h>
-#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h>
 #include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveHostnameQuery.h>
-#include <Swiften/EventLoop/EventLoop.h>
+#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h>
 
 namespace Swift {
 
@@ -23,117 +23,117 @@ FakeDNSSDQuerier::FakeDNSSDQuerier(const std::string& domain, EventLoop* eventLo
 }
 
 FakeDNSSDQuerier::~FakeDNSSDQuerier() {
-	if (!runningQueries.empty()) {
-		std::cerr << "FakeDNSSDQuerier: Running queries not empty at destruction time" << std::endl;
-	}
+    if (!runningQueries.empty()) {
+        std::cerr << "FakeDNSSDQuerier: Running queries not empty at destruction time" << std::endl;
+    }
 }
 
-boost::shared_ptr<DNSSDBrowseQuery> FakeDNSSDQuerier::createBrowseQuery() {
-	return boost::shared_ptr<DNSSDBrowseQuery>(new FakeDNSSDBrowseQuery(shared_from_this()));
+std::shared_ptr<DNSSDBrowseQuery> FakeDNSSDQuerier::createBrowseQuery() {
+    return std::make_shared<FakeDNSSDBrowseQuery>(shared_from_this());
 }
 
-boost::shared_ptr<DNSSDRegisterQuery> FakeDNSSDQuerier::createRegisterQuery(const std::string& name, int port, const ByteArray& info) {
-	return boost::shared_ptr<DNSSDRegisterQuery>(new FakeDNSSDRegisterQuery(name, port, info, shared_from_this()));
+std::shared_ptr<DNSSDRegisterQuery> FakeDNSSDQuerier::createRegisterQuery(const std::string& name, unsigned short port, const ByteArray& info) {
+    return std::make_shared<FakeDNSSDRegisterQuery>(name, port, info, shared_from_this());
 }
 
-boost::shared_ptr<DNSSDResolveServiceQuery> FakeDNSSDQuerier::createResolveServiceQuery(const DNSSDServiceID& service) {
-	return boost::shared_ptr<DNSSDResolveServiceQuery>(new FakeDNSSDResolveServiceQuery(service, shared_from_this()));
+std::shared_ptr<DNSSDResolveServiceQuery> FakeDNSSDQuerier::createResolveServiceQuery(const DNSSDServiceID& service) {
+    return std::make_shared<FakeDNSSDResolveServiceQuery>(service, shared_from_this());
 }
 
-boost::shared_ptr<DNSSDResolveHostnameQuery> FakeDNSSDQuerier::createResolveHostnameQuery(const std::string& hostname, int interfaceIndex) {
-	return boost::shared_ptr<DNSSDResolveHostnameQuery>(new FakeDNSSDResolveHostnameQuery(hostname, interfaceIndex, shared_from_this()));
+std::shared_ptr<DNSSDResolveHostnameQuery> FakeDNSSDQuerier::createResolveHostnameQuery(const std::string& hostname, int interfaceIndex) {
+    return std::make_shared<FakeDNSSDResolveHostnameQuery>(hostname, interfaceIndex, shared_from_this());
 }
 
-void FakeDNSSDQuerier::addRunningQuery(boost::shared_ptr<FakeDNSSDQuery> query) {
-	runningQueries.push_back(query);
-	allQueriesEverRun.push_back(query);
-	if (boost::shared_ptr<FakeDNSSDBrowseQuery> browseQuery = boost::dynamic_pointer_cast<FakeDNSSDBrowseQuery>(query)) {
-		foreach(const DNSSDServiceID& service, services) {
-			eventLoop->postEvent(boost::bind(boost::ref(browseQuery->onServiceAdded), service), shared_from_this());
-		}
-	}
-	else if (boost::shared_ptr<FakeDNSSDResolveServiceQuery> resolveQuery = boost::dynamic_pointer_cast<FakeDNSSDResolveServiceQuery>(query)) {
-		for(ServiceInfoMap::const_iterator i = serviceInfo.begin(); i != serviceInfo.end(); ++i) {
-			if (i->first == resolveQuery->service) {
-				eventLoop->postEvent(boost::bind(boost::ref(resolveQuery->onServiceResolved), i->second), shared_from_this());
-			}
-		}
-	}
-	else if (boost::shared_ptr<FakeDNSSDRegisterQuery> registerQuery = boost::dynamic_pointer_cast<FakeDNSSDRegisterQuery>(query)) {
-		DNSSDServiceID service(registerQuery->name, domain);
-		eventLoop->postEvent(boost::bind(boost::ref(registerQuery->onRegisterFinished), service), shared_from_this());
-	}
-	else if (boost::shared_ptr<FakeDNSSDResolveHostnameQuery> resolveHostnameQuery = boost::dynamic_pointer_cast<FakeDNSSDResolveHostnameQuery>(query)) {
-		std::map<std::string,boost::optional<HostAddress> >::const_iterator i = addresses.find(resolveHostnameQuery->hostname);
-		if (i != addresses.end()) {
-			eventLoop->postEvent(
-					boost::bind(
-						boost::ref(resolveHostnameQuery->onHostnameResolved), i->second), 
-					shared_from_this());
-		}
-	}
+void FakeDNSSDQuerier::addRunningQuery(std::shared_ptr<FakeDNSSDQuery> query) {
+    runningQueries.push_back(query);
+    allQueriesEverRun.push_back(query);
+    if (std::shared_ptr<FakeDNSSDBrowseQuery> browseQuery = std::dynamic_pointer_cast<FakeDNSSDBrowseQuery>(query)) {
+        for (const auto& service : services) {
+            eventLoop->postEvent(boost::bind(boost::ref(browseQuery->onServiceAdded), service), shared_from_this());
+        }
+    }
+    else if (std::shared_ptr<FakeDNSSDResolveServiceQuery> resolveQuery = std::dynamic_pointer_cast<FakeDNSSDResolveServiceQuery>(query)) {
+        for (const auto& i : serviceInfo) {
+            if (i.first == resolveQuery->service) {
+                eventLoop->postEvent(boost::bind(boost::ref(resolveQuery->onServiceResolved), i.second), shared_from_this());
+            }
+        }
+    }
+    else if (std::shared_ptr<FakeDNSSDRegisterQuery> registerQuery = std::dynamic_pointer_cast<FakeDNSSDRegisterQuery>(query)) {
+        DNSSDServiceID service(registerQuery->name, domain);
+        eventLoop->postEvent(boost::bind(boost::ref(registerQuery->onRegisterFinished), service), shared_from_this());
+    }
+    else if (std::shared_ptr<FakeDNSSDResolveHostnameQuery> resolveHostnameQuery = std::dynamic_pointer_cast<FakeDNSSDResolveHostnameQuery>(query)) {
+        std::map<std::string,boost::optional<HostAddress> >::const_iterator i = addresses.find(resolveHostnameQuery->hostname);
+        if (i != addresses.end()) {
+            eventLoop->postEvent(
+                    boost::bind(
+                        boost::ref(resolveHostnameQuery->onHostnameResolved), i->second),
+                    shared_from_this());
+        }
+    }
 }
 
-void FakeDNSSDQuerier::removeRunningQuery(boost::shared_ptr<FakeDNSSDQuery> query) {
-	erase(runningQueries, query);
+void FakeDNSSDQuerier::removeRunningQuery(std::shared_ptr<FakeDNSSDQuery> query) {
+    erase(runningQueries, query);
 }
 
 void FakeDNSSDQuerier::addService(const DNSSDServiceID& id) {
-	services.insert(id);
-	foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {
-		eventLoop->postEvent(boost::bind(boost::ref(query->onServiceAdded), id), shared_from_this());
-	}
+    services.insert(id);
+    for (const auto& query : getQueries<FakeDNSSDBrowseQuery>()) {
+        eventLoop->postEvent(boost::bind(boost::ref(query->onServiceAdded), id), shared_from_this());
+    }
 }
 
 void FakeDNSSDQuerier::removeService(const DNSSDServiceID& id) {
-	services.erase(id);
-	serviceInfo.erase(id);
-	foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {
-		eventLoop->postEvent(boost::bind(boost::ref(query->onServiceRemoved), id), shared_from_this());
-	}
+    services.erase(id);
+    serviceInfo.erase(id);
+    for (const auto& query : getQueries<FakeDNSSDBrowseQuery>()) {
+        eventLoop->postEvent(boost::bind(boost::ref(query->onServiceRemoved), id), shared_from_this());
+    }
 }
 
 void FakeDNSSDQuerier::setServiceInfo(const DNSSDServiceID& id, const DNSSDResolveServiceQuery::Result& info) {
-	std::pair<ServiceInfoMap::iterator, bool> r = serviceInfo.insert(std::make_pair(id, info));
-	if (!r.second) {
-		r.first->second = info;
-	}
-	foreach(const boost::shared_ptr<FakeDNSSDResolveServiceQuery>& query, getQueries<FakeDNSSDResolveServiceQuery>()) {
-		if (query->service == id) {
-			eventLoop->postEvent(boost::bind(boost::ref(query->onServiceResolved), info), shared_from_this());
-		}
-	}
-}
-
-bool FakeDNSSDQuerier::isServiceRegistered(const std::string& name, int port, const ByteArray& info) {
-	foreach(const boost::shared_ptr<FakeDNSSDRegisterQuery>& query, getQueries<FakeDNSSDRegisterQuery>()) {
-		if (query->name == name && query->port == port && query->info == info) {
-			return true;
-		}
-	}
-	return false;
+    std::pair<ServiceInfoMap::iterator, bool> r = serviceInfo.insert(std::make_pair(id, info));
+    if (!r.second) {
+        r.first->second = info;
+    }
+    for (const auto& query : getQueries<FakeDNSSDResolveServiceQuery>()) {
+        if (query->service == id) {
+            eventLoop->postEvent(boost::bind(boost::ref(query->onServiceResolved), info), shared_from_this());
+        }
+    }
+}
+
+bool FakeDNSSDQuerier::isServiceRegistered(const std::string& name, unsigned short port, const ByteArray& info) {
+    for (const auto& query : getQueries<FakeDNSSDRegisterQuery>()) {
+        if (query->name == name && query->port == port && query->info == info) {
+            return true;
+        }
+    }
+    return false;
 }
 
 void FakeDNSSDQuerier::setBrowseError() {
-	foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {
-		eventLoop->postEvent(boost::ref(query->onError), shared_from_this());
-	}
+    for (const auto& query : getQueries<FakeDNSSDBrowseQuery>()) {
+        eventLoop->postEvent(boost::ref(query->onError), shared_from_this());
+    }
 }
 
 void FakeDNSSDQuerier::setRegisterError() {
-	foreach(const boost::shared_ptr<FakeDNSSDRegisterQuery>& query, getQueries<FakeDNSSDRegisterQuery>()) {
-		eventLoop->postEvent(boost::bind(boost::ref(query->onRegisterFinished), boost::optional<DNSSDServiceID>()), shared_from_this());
-	}
+    for (const auto& query : getQueries<FakeDNSSDRegisterQuery>()) {
+        eventLoop->postEvent(boost::bind(boost::ref(query->onRegisterFinished), boost::optional<DNSSDServiceID>()), shared_from_this());
+    }
 }
 
 void FakeDNSSDQuerier::setAddress(const std::string& hostname, boost::optional<HostAddress> address) {
-	addresses[hostname] = address;
-	foreach(const boost::shared_ptr<FakeDNSSDResolveHostnameQuery>& query, getQueries<FakeDNSSDResolveHostnameQuery>()) {
-		if (query->hostname == hostname) {
-			eventLoop->postEvent(boost::bind(
-					boost::ref(query->onHostnameResolved), address), shared_from_this());
-		}
-	}
+    addresses[hostname] = address;
+    for (const auto& query : getQueries<FakeDNSSDResolveHostnameQuery>()) {
+        if (query->hostname == hostname) {
+            eventLoop->postEvent(boost::bind(
+                    boost::ref(query->onHostnameResolved), address), shared_from_this());
+        }
+    }
 }
 
 }
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h
index 9fc4608..07cb75c 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h
@@ -1,17 +1,16 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2010-2018 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
 #pragma once
 
-#include <boost/shared_ptr.hpp>
-#include <boost/enable_shared_from_this.hpp>
 #include <list>
+#include <memory>
 #include <set>
-
 #include <string>
+
 #include <Swiften/Base/API.h>
 #include <Swiften/Base/ByteArray.h>
 #include <Swiften/EventLoop/EventOwner.h>
@@ -20,78 +19,77 @@
 #include <Swiften/Network/HostAddress.h>
 
 namespace Swift {
-	class FakeDNSSDQuery;
-	class FakeDNSSDBrowseQuery;
-	class EventLoop;
+    class FakeDNSSDQuery;
+    class EventLoop;
 
-	class SWIFTEN_API FakeDNSSDQuerier : 
-			public DNSSDQuerier, 
-			public EventOwner,
-			public boost::enable_shared_from_this<FakeDNSSDQuerier> {
-		public:
-			FakeDNSSDQuerier(const std::string& domain, EventLoop* eventLoop);
-			~FakeDNSSDQuerier();
+    class SWIFTEN_API FakeDNSSDQuerier :
+            public DNSSDQuerier,
+            public EventOwner,
+            public std::enable_shared_from_this<FakeDNSSDQuerier> {
+        public:
+            FakeDNSSDQuerier(const std::string& domain, EventLoop* eventLoop);
+            ~FakeDNSSDQuerier();
 
-			void start() {}
-			void stop() {}
+            void start() {}
+            void stop() {}
 
-			void clearAllQueriesEverRun() {
-				allQueriesEverRun.clear();
-			}
+            void clearAllQueriesEverRun() {
+                allQueriesEverRun.clear();
+            }
 
-			boost::shared_ptr<DNSSDBrowseQuery> createBrowseQuery();
-			boost::shared_ptr<DNSSDRegisterQuery> createRegisterQuery(
-					const std::string& name, int port, const ByteArray& info);
-			boost::shared_ptr<DNSSDResolveServiceQuery> createResolveServiceQuery(
-					const DNSSDServiceID&);
-			boost::shared_ptr<DNSSDResolveHostnameQuery> createResolveHostnameQuery(
-					const std::string& hostname, int interfaceIndex);
+            std::shared_ptr<DNSSDBrowseQuery> createBrowseQuery();
+            std::shared_ptr<DNSSDRegisterQuery> createRegisterQuery(
+                    const std::string& name, unsigned short port, const ByteArray& info);
+            std::shared_ptr<DNSSDResolveServiceQuery> createResolveServiceQuery(
+                    const DNSSDServiceID&);
+            std::shared_ptr<DNSSDResolveHostnameQuery> createResolveHostnameQuery(
+                    const std::string& hostname, int interfaceIndex);
 
-			void addRunningQuery(boost::shared_ptr<FakeDNSSDQuery>);
-			void removeRunningQuery(boost::shared_ptr<FakeDNSSDQuery>);
+            void addRunningQuery(std::shared_ptr<FakeDNSSDQuery>);
+            void removeRunningQuery(std::shared_ptr<FakeDNSSDQuery>);
 
-			void addService(const DNSSDServiceID& id);
-			void removeService(const DNSSDServiceID& id);
-			void setServiceInfo(const DNSSDServiceID& id, const DNSSDResolveServiceQuery::Result& info);
-			bool isServiceRegistered(const std::string& name, int port, const ByteArray& info);
-			void setAddress(const std::string& hostname, boost::optional<HostAddress> address);
+            void addService(const DNSSDServiceID& id);
+            void removeService(const DNSSDServiceID& id);
+            void setServiceInfo(const DNSSDServiceID& id, const DNSSDResolveServiceQuery::Result& info);
+            bool isServiceRegistered(const std::string& name, unsigned short port, const ByteArray& info);
+            void setAddress(const std::string& hostname, boost::optional<HostAddress> address);
 
-			void setBrowseError();
-			void setRegisterError();
+            void setBrowseError();
+            void setRegisterError();
 
-		public:
-			template<typename T>
-			std::vector< boost::shared_ptr<T> > getAllQueriesEverRun() const {
-				std::vector< boost::shared_ptr<T> > result;
-				for (QueryList::const_iterator i = allQueriesEverRun.begin(); i != allQueriesEverRun.end(); ++i) {
-					if (boost::shared_ptr<T> resultQuery = boost::dynamic_pointer_cast<T>(*i)) {
-						result.push_back(resultQuery);
-					}
-				}
-				return result;
-			}
+        public:
+            template<typename T>
+            std::vector< std::shared_ptr<T> > getAllQueriesEverRun() const {
+                std::vector< std::shared_ptr<T> > result;
+                for (const auto& i : allQueriesEverRun) {
+                    if (std::shared_ptr<T> resultQuery = std::dynamic_pointer_cast<T>(i)) {
+                        result.push_back(resultQuery);
+                    }
+                }
+                return result;
+            }
 
-		private:
-			template<typename T>
-			std::vector< boost::shared_ptr<T> > getQueries() const {
-				std::vector< boost::shared_ptr<T> > result;
-				for (QueryList::const_iterator i = runningQueries.begin(); i != runningQueries.end(); ++i) {
-					if (boost::shared_ptr<T> resultQuery = boost::dynamic_pointer_cast<T>(*i)) {
-						result.push_back(resultQuery);
-					}
-				}
-				return result;
-			}
+        private:
+            template<typename T>
+            std::vector< std::shared_ptr<T> > getQueries() const {
+                std::vector< std::shared_ptr<T> > result;
+                for (const auto& runningQuerie : runningQueries) {
+                    if (std::shared_ptr<T> resultQuery = std::dynamic_pointer_cast<T>(runningQuerie)) {
+                        result.push_back(resultQuery);
+                    }
+                }
+                return result;
+            }
 
-		private:
-			std::string domain;
-			EventLoop* eventLoop;
-			typedef std::list< boost::shared_ptr<FakeDNSSDQuery> > QueryList;
-			QueryList runningQueries;
-			QueryList allQueriesEverRun;
-			std::set<DNSSDServiceID> services;
-			typedef std::map<DNSSDServiceID,DNSSDResolveServiceQuery::Result> ServiceInfoMap;
-			ServiceInfoMap serviceInfo;
-			std::map<std::string, boost::optional<HostAddress> > addresses;
-	};
+        private:
+            std::string domain;
+            EventLoop* eventLoop;
+            typedef std::list< std::shared_ptr<FakeDNSSDQuery> > QueryList;
+            QueryList runningQueries;
+            QueryList allQueriesEverRun;
+            std::set<DNSSDServiceID> services;
+            typedef std::map<DNSSDServiceID,DNSSDResolveServiceQuery::Result> ServiceInfoMap;
+            ServiceInfoMap serviceInfo;
+            std::map<std::string, boost::optional<HostAddress> > addresses;
+    };
 }
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.cpp b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.cpp
index 99f55fa..0e05968 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.cpp
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.cpp
@@ -1,26 +1,27 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2010-2016 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
 #include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h>
+
 #include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuerier.h>
 
 namespace Swift {
 
-FakeDNSSDQuery::FakeDNSSDQuery(boost::shared_ptr<FakeDNSSDQuerier> querier) : querier(querier) {
+FakeDNSSDQuery::FakeDNSSDQuery(std::shared_ptr<FakeDNSSDQuerier> querier) : querier(querier) {
 }
 
 FakeDNSSDQuery::~FakeDNSSDQuery() {
 }
 
 void FakeDNSSDQuery::run() {
-	querier->addRunningQuery(shared_from_this());
+    querier->addRunningQuery(shared_from_this());
 }
 
 void FakeDNSSDQuery::finish() {
-	querier->removeRunningQuery(shared_from_this());
+    querier->removeRunningQuery(shared_from_this());
 }
 
 }
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h
index b6d5c98..5d869d4 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h
@@ -1,31 +1,30 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2010-2016 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
 #pragma once
 
-#include <boost/shared_ptr.hpp>
-#include <boost/enable_shared_from_this.hpp>
+#include <memory>
 
 #include <Swiften/EventLoop/EventOwner.h>
 
 namespace Swift {
-	class FakeDNSSDQuerier;
+    class FakeDNSSDQuerier;
 
-	class FakeDNSSDQuery : 
-			public EventOwner,
-			public boost::enable_shared_from_this<FakeDNSSDQuery> {
-		public:
-			FakeDNSSDQuery(boost::shared_ptr<FakeDNSSDQuerier>);
-			virtual ~FakeDNSSDQuery();
-			
-		protected:
-			void run();
-			void finish();
-		
-		protected:
-			boost::shared_ptr<FakeDNSSDQuerier> querier;
-	};
+    class FakeDNSSDQuery :
+            public EventOwner,
+            public std::enable_shared_from_this<FakeDNSSDQuery> {
+        public:
+            FakeDNSSDQuery(std::shared_ptr<FakeDNSSDQuerier>);
+            virtual ~FakeDNSSDQuery();
+
+        protected:
+            void run();
+            void finish();
+
+        protected:
+            std::shared_ptr<FakeDNSSDQuerier> querier;
+    };
 }
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDRegisterQuery.h b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDRegisterQuery.h
index c568f5b..ee6bb92 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDRegisterQuery.h
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDRegisterQuery.h
@@ -1,38 +1,39 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2010-2018 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
 #pragma once
 
-#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h>
-#include <Swiften/LinkLocal/DNSSD/DNSSDRegisterQuery.h>
-#include <Swiften/Base/ByteArray.h>
 #include <string>
 
+#include <Swiften/Base/ByteArray.h>
+#include <Swiften/LinkLocal/DNSSD/DNSSDRegisterQuery.h>
+#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h>
+
 namespace Swift {
-	class FakeDNSSDQuerier;
+    class FakeDNSSDQuerier;
 
-	class FakeDNSSDRegisterQuery : public DNSSDRegisterQuery, public FakeDNSSDQuery {
-		public:	
-			FakeDNSSDRegisterQuery(const std::string& name, int port, const ByteArray& info, boost::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), name(name), port(port), info(info) {
-			}
+    class FakeDNSSDRegisterQuery : public DNSSDRegisterQuery, public FakeDNSSDQuery {
+        public:
+            FakeDNSSDRegisterQuery(const std::string& name, unsigned short port, const ByteArray& info, std::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), name(name), port(port), info(info) {
+            }
 
-			void registerService() {
-				run();
-			}
+            void registerService() {
+                run();
+            }
 
-			void updateServiceInfo(const ByteArray& i) {
-				info = i;
-			}
+            void updateServiceInfo(const ByteArray& i) {
+                info = i;
+            }
 
-			void unregisterService() {
-				finish();
-			}
+            void unregisterService() {
+                finish();
+            }
 
-			std::string name;
-			int port;
-			ByteArray info;
-	};
+            std::string name;
+            unsigned short port;
+            ByteArray info;
+    };
 }
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveHostnameQuery.h b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveHostnameQuery.h
index aa427cc..60dc144 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveHostnameQuery.h
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveHostnameQuery.h
@@ -1,33 +1,34 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2010-2016 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
 #pragma once
 
 #include <string>
-#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h>
+
 #include <Swiften/LinkLocal/DNSSD/DNSSDResolveHostnameQuery.h>
+#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h>
 #include <Swiften/Network/HostAddress.h>
 
 namespace Swift {
-	class FakeDNSSDQuerier;
+    class FakeDNSSDQuerier;
 
-	class FakeDNSSDResolveHostnameQuery : public DNSSDResolveHostnameQuery, public FakeDNSSDQuery {
-		public:	
-			FakeDNSSDResolveHostnameQuery(const std::string& hostname, int interfaceIndex, boost::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), hostname(hostname), interfaceIndex(interfaceIndex) {
-			}
+    class FakeDNSSDResolveHostnameQuery : public DNSSDResolveHostnameQuery, public FakeDNSSDQuery {
+        public:
+            FakeDNSSDResolveHostnameQuery(const std::string& hostname, int interfaceIndex, std::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), hostname(hostname), interfaceIndex(interfaceIndex) {
+            }
 
-			void run() {
-				FakeDNSSDQuery::run();
-			}
+            void run() {
+                FakeDNSSDQuery::run();
+            }
 
-			void finish() {
-				FakeDNSSDQuery::finish();
-			}
+            void finish() {
+                FakeDNSSDQuery::finish();
+            }
 
-			std::string hostname;
-			int interfaceIndex;
-	};
+            std::string hostname;
+            int interfaceIndex;
+    };
 }
diff --git a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h
index 5c69843..8a02e7b 100644
--- a/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h
+++ b/Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h
@@ -1,31 +1,31 @@
 /*
- * Copyright (c) 2010 Remko Tronçon
- * Licensed under the GNU General Public License v3.
- * See Documentation/Licenses/GPLv3.txt for more information.
+ * Copyright (c) 2010-2016 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
  */
 
 #pragma once
 
-#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h>
 #include <Swiften/LinkLocal/DNSSD/DNSSDResolveServiceQuery.h>
+#include <Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDQuery.h>
 #include <Swiften/LinkLocal/LinkLocalServiceInfo.h>
 
 namespace Swift {
-	class FakeDNSSDQuerier;
+    class FakeDNSSDQuerier;
 
-	class FakeDNSSDResolveServiceQuery : public DNSSDResolveServiceQuery, public FakeDNSSDQuery {
-		public:	
-			FakeDNSSDResolveServiceQuery(const DNSSDServiceID& service, boost::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), service(service) {
-			}
+    class FakeDNSSDResolveServiceQuery : public DNSSDResolveServiceQuery, public FakeDNSSDQuery {
+        public:
+            FakeDNSSDResolveServiceQuery(const DNSSDServiceID& service, std::shared_ptr<FakeDNSSDQuerier> querier) : FakeDNSSDQuery(querier), service(service) {
+            }
 
-			void start() {
-				run();
-			}
+            void start() {
+                run();
+            }
 
-			void stop() {
-				finish();
-			}
+            void stop() {
+                finish();
+            }
 
-			DNSSDServiceID service;
-	};
+            DNSSDServiceID service;
+    };
 }