+diff --git a/3rdParty/Boost/src/boost/detail/endian.hpp b/3rdParty/Boost/src/boost/detail/endian.hpp

+index 98c870c..ac77a2e 100644

+--- a/3rdParty/Boost/src/boost/detail/endian.hpp

++++ b/3rdParty/Boost/src/boost/detail/endian.hpp

+@@ -66,8 +66,8 @@

+ || defined(_M_ALPHA) || defined(__amd64) \

+ || defined(__amd64__) || defined(_M_AMD64) \

+ || defined(__x86_64) || defined(__x86_64__) \

+- || defined(_M_X64) || defined(__bfin__)

+-

++ || defined(_M_X64) || defined(__bfin__) \

++ || defined(ANDROID)

+ # define BOOST_LITTLE_ENDIAN

+ # define BOOST_BYTE_ORDER 1234

+ #else

+diff --git a/3rdParty/Boost/src/libs/filesystem/src/operations.cpp b/3rdParty/Boost/src/libs/filesystem/src/operations.cpp

+index 16a336f..d066e40 100644

+--- a/3rdParty/Boost/src/libs/filesystem/src/operations.cpp

++++ b/3rdParty/Boost/src/libs/filesystem/src/operations.cpp

+@@ -73,10 +73,14 @@ using std::wstring;

+ const fs::path dot_dot_path("..");

+ # include <sys/types.h>

+ # include <sys/stat.h>

+-# if !defined(__APPLE__) && !defined(__OpenBSD__)

++# if !defined(__APPLE__) && !defined(__OpenBSD__) && !defined(ANDROID)

+ # include <sys/statvfs.h>

+ # define BOOST_STATVFS statvfs

+ # define BOOST_STATVFS_F_FRSIZE vfs.f_frsize

++# elif defined (ANDROID)

++# include <sys/vfs.h>

++# define BOOST_STATVFS statfs

++# define BOOST_STATVFS_F_FRSIZE static_cast<boost::uintmax_t>(vfs.f_bsize)

+ # else

+ # ifdef __OpenBSD__

+ # include <sys/param.h>

+ -- \ No newline at end of file

+--- 3rdParty/Ldns/src/ldns/ldns/ldns.h 2013-04-12 14:30:16.000000000 +0200

++++ 3rdParty/Ldns/src/ldns/ldns/ldns.h 2013-04-12 14:30:48.000000000 +0200

+@@ -123,6 +123,12 @@

+ #include <ldns/sha1.h>

+ #include <ldns/sha2.h>

+

++#ifdef __ANDROID__

++#ifndef in_port_t

++#define in_port_t uint16_t

++#endif

++#endif

++

+ #ifdef __cplusplus

+ extern "C" {

+ #endif

+Import("env")

+

+if env.get("LDNS_BUNDLED", False) :

+

+ if env["PLATFORM"] == "win32" :

+ cppflags = ["/I" + Dir("#/3rdParty/Ldns/src/ldns").abspath]

+ else :

+ cppflags = [("-isystem", Dir("#/3rdParty/Ldns/src/ldns").abspath)]

+

+

+################################################################################

+# Flags

+################################################################################

+

+ if env["SCONS_STAGE"] == "flags" :

+ env["LDNS_FLAGS"] = {

+ "CPPPATH": [Dir("src/ldns")],

+ "CPPFLAGS": cppflags,

+ "LIBPATH": [env.Dir(".")],

+ "LIBS": ["Swiften_Ldns"],

+ }

+ if env["target"] == "android" :

+ env["LDNS_FLAGS"]["CPPPATH"].append(Dir("src/android"))

+

+################################################################################

+# Build

+################################################################################

+

+ if env["SCONS_STAGE"] == "build" :

+ myenv = env.Clone()

+ myenv.Append(CPPDEFINES = [("LDNS_STATICLIB")])

+ myenv.Append(CPPPATH = ["src/ldns", "."])

+ if env["target"] == "android" :

+ myenv.Append(CPPPATH = ["src/android"])

+ myenv.UseFlags(env["OPENSSL_FLAGS"])

+

+ env["LDNS_OBJECTS"] = myenv.SwiftenObject([

+ "src/ldns/compat/b32_ntop.c",

+ "src/ldns/compat/b32_pton.c",

+ "src/ldns/compat/b64_ntop.c",

+ "src/ldns/compat/b64_pton.c",

+ "src/ldns/buffer.c",

+ "src/ldns/dname.c",

+ "src/ldns/dnssec_sign.c",

+ "src/ldns/dnssec_verify.c",

+ "src/ldns/dnssec_zone.c",

+ "src/ldns/dnssec.c",

+ "src/ldns/error.c",

+ "src/ldns/higher.c",

+ "src/ldns/host2str.c",

+ "src/ldns/host2wire.c",

+ "src/ldns/keys.c",

+ "src/ldns/linktest.c",

+ "src/ldns/net.c",

+ "src/ldns/packet.c",

+ "src/ldns/parse.c",

+ "src/ldns/rbtree.c",

+ "src/ldns/rdata.c",

+ "src/ldns/resolver.c",

+ "src/ldns/rr_functions.c",

+ "src/ldns/rr.c",

+ "src/ldns/sha1.c",

+ "src/ldns/sha2.c",

+ "src/ldns/str2host.c",

+ "src/ldns/tsig.c",

+ "src/ldns/update.c",

+ "src/ldns/util.c",

+ "src/ldns/wire2host.c",

+ "src/ldns/zone.c",

+ ])

+#!/usr/bin/env bash

+curl -o src/ldns-1.6.16.tar.gz http://www.nlnetlabs.nl/downloads/ldns/ldns-1.6.16.tar.gz

+cd src

+tar -xf ldns-1.6.16.tar.gz

+mv ldns-1.6.16 ldns \ No newline at end of file

+diff --git a/3rdParty/LibMiniUPnPc/src/miniupnpc/miniwget.c b/3rdParty/LibMiniUPnPc/src/miniupnpc/miniwget.c

+index 87f6155..0c31416 100644

+--- a/3rdParty/LibMiniUPnPc/src/miniupnpc/miniwget.c

++++ b/3rdParty/LibMiniUPnPc/src/miniupnpc/miniwget.c

+@@ -44,6 +44,10 @@

+ #define MIN(x,y) (((x)<(y))?(x):(y))

+ #endif

+

++#ifdef __ANDROID__

++#define MIN(x,y) (((x)<(y))?(x):(y))

++#endif

++

+ #include "miniupnpcstrings.h"

+ #include "miniwget.h"

+ #include "connecthostport.h"

+-- \ No newline at end of file

+diff --git a/3rdParty/LibNATPMP/src/libnatpmp/getgateway.h b/3rdParty/LibNATPMP/src/libnatpmp/getgateway.h

+index 9432528..51dadb7 100644

+--- a/3rdParty/LibNATPMP/src/libnatpmp/getgateway.h

++++ b/3rdParty/LibNATPMP/src/libnatpmp/getgateway.h

+@@ -27,6 +27,11 @@ typedef unsigned short uint16_t;

+ #endif

+ #include "declspec.h"

+

++#ifdef ANDROID

++#include <arpa/inet.h>

++#define in_addr_t uint32_t

++#endif

++

+ /* getdefaultgateway() :

+ * return value :

+ * 0 : success

+diff --git a/3rdParty/LibNATPMP/src/libnatpmp/natpmp.h b/3rdParty/LibNATPMP/src/libnatpmp/natpmp.h

+index 1175b58..c870371 100644

+--- a/3rdParty/LibNATPMP/src/libnatpmp/natpmp.h

++++ b/3rdParty/LibNATPMP/src/libnatpmp/natpmp.h

+@@ -39,6 +39,12 @@ typedef unsigned short uint16_t;

+ #include <netinet/in.h>

+ #endif

+

++#ifdef ANDROID

++#include <arpa/inet.h>

++#define in_addr_t uint32_t

++#endif

++

++

+ typedef struct {

+ int s; /* socket */

+ in_addr_t gateway; /* default gateway (IPv4) */

+-- \ No newline at end of file

+--- a/3rdParty/Unbound/src/unbound/libunbound/libunbound.c

++++ b/3rdParty/Unbound/src/unbound/libunbound/libunbound.c

+@@ -812,6 +812,10 @@ ub_ctx_resolvconf(struct ub_ctx* ctx, char* fname)

+ char* parse, *addr;

+ int r;

+

++#ifdef __ANDROID__

++ ub_ctx_set_fwd(ctx, "8.8.8.8");

++ ub_ctx_set_fwd(ctx, "8.8.4.4");

++#endif

+ if(fname == NULL) {

+ #if !defined(UB_ON_WINDOWS) || !defined(HAVE_WINDOWS_H)

+ fname = "/etc/resolv.conf"; \ No newline at end of file

+Import("env")

+

+if env.get("UNBOUND_BUNDLED", False) :

+

+ if env["PLATFORM"] == "win32" :

+ cppflags = ["/I" + Dir("#/3rdParty/Unbound/src/unbound").abspath]

+ else :

+ cppflags = [("-isystem", Dir("#/3rdParty/Unbound/src/unbound").abspath)]

+

+

+################################################################################

+# Flags

+################################################################################

+

+ if env["SCONS_STAGE"] == "flags" :

+ env["UNBOUND_FLAGS"] = {

+ "CPPPATH": [Dir("src/unbound/libunbound")],

+ "CPPFLAGS": cppflags,

+ "LIBPATH": [env.Dir(".")],

+ "LIBS": ["Swiften_Unbound"],

+ }

+ if env["target"] == "android" :

+ env["UNBOUND_FLAGS"]["CPPPATH"].append(Dir("src/android/compat"))

+

+################################################################################

+# Build

+################################################################################

+

+ if env["SCONS_STAGE"] == "build" :

+ myenv = env.Clone()

+ myenv.Append(CPPDEFINES = [("UNBOUND_STATICLIB")])

+ myenv.Append(CPPPATH = ["../Ldns/src/ldns", "src/unbound", "."])

+ if env["target"] == "android" :

+ myenv.Append(CPPPATH = ["src/android/compat", "src/android/config"])

+ myenv.Append(CPPPATH = ["../Ldns/src/android"])

+ myenv.UseFlags(env["OPENSSL_FLAGS"])

+

+ unbound_objects = [

+ "src/unbound/daemon/acl_list.c",

+ "src/unbound/daemon/cachedump.c",

+ "src/unbound/daemon/daemon.c",

+ "src/unbound/daemon/remote.c",

+ "src/unbound/daemon/stats.c",

+ "src/unbound/daemon/unbound.c",

+ # duplicate symbols: "src/src/daemon/worker.c",

+ "src/unbound/iterator/iter_delegpt.c",

+ "src/unbound/iterator/iter_donotq.c",

+ "src/unbound/iterator/iter_fwd.c",

+ "src/unbound/iterator/iter_hints.c",

+ "src/unbound/iterator/iter_priv.c",

+ "src/unbound/iterator/iter_resptype.c",

+ "src/unbound/iterator/iter_scrub.c",

+ "src/unbound/iterator/iter_utils.c",

+ "src/unbound/iterator/iterator.c",

+ "src/unbound/libunbound/context.c",

+ "src/unbound/libunbound/libunbound.c",

+ "src/unbound/libunbound/libworker.c",

+ "src/unbound/services/cache/dns.c",

+ "src/unbound/services/cache/infra.c",

+ "src/unbound/services/cache/rrset.c",

+ "src/unbound/services/listen_dnsport.c",

+ "src/unbound/services/localzone.c",

+ "src/unbound/services/mesh.c",

+ "src/unbound/services/modstack.c",

+ "src/unbound/services/outbound_list.c",

+ "src/unbound/services/outside_network.c",

+ "src/unbound/util/alloc.c",

+ "src/unbound/util/config_file.c",

+ "src/unbound/util/configlexer.c",

+ "src/unbound/util/configparser.c",

+ "src/unbound/util/data/dname.c",

+ "src/unbound/util/data/msgencode.c",

+ "src/unbound/util/data/msgparse.c",

+ "src/unbound/util/data/msgreply.c",

+ "src/unbound/util/data/packed_rrset.c",

+ "src/unbound/util/fptr_wlist.c",

+ "src/unbound/util/locks.c",

+ "src/unbound/util/log.c",

+ "src/unbound/util/mini_event.c",

+ "src/unbound/util/module.c",

+ "src/unbound/util/net_help.c",

+ "src/unbound/util/netevent.c",

+ "src/unbound/util/random.c",

+ "src/unbound/util/rbtree.c",

+ "src/unbound/util/regional.c",

+ "src/unbound/util/rtt.c",

+ "src/unbound/util/storage/dnstree.c",

+ "src/unbound/util/storage/lookup3.c",

+ "src/unbound/util/storage/lruhash.c",

+ "src/unbound/util/storage/slabhash.c",

+ "src/unbound/util/timehist.c",

+ "src/unbound/util/tube.c",

+ #src/unbound/util/winsock_event.c

+ "src/unbound/validator/autotrust.c",

+ "src/unbound/validator/val_anchor.c",

+ "src/unbound/validator/val_kcache.c",

+ "src/unbound/validator/val_kentry.c",

+ "src/unbound/validator/val_neg.c",

+ "src/unbound/validator/val_nsec.c",

+ "src/unbound/validator/val_nsec3.c",

+ "src/unbound/validator/val_secalgo.c",

+ "src/unbound/validator/val_sigcrypt.c",

+ "src/unbound/validator/val_utils.c",

+ "src/unbound/validator/validator.c",

+ ]

+ if env["target"] == "android" :

+ unbound_objects.append("src/android/compat/glob.c")

+ env["UNBOUND_OBJECTS"] = myenv.SwiftenObject(unbound_objects)

+#!/usr/bin/env bash

+curl -o src/unbound-1.4.20.tar.gz http://www.unbound.net/downloads/unbound-1.4.20.tar.gz

+cd src

+tar -xf unbound-1.4.20.tar.gz

+mv unbound-1.4.20 unbound \ No newline at end of file

+vars.Add(EnumVariable("target", "Choose a target platform for compilation", "native", ["native", "iphone-simulator", "iphone-device", "xcode", "android"]))

+vars.Add('android_toolchain', "Path to Android toolchain")

+vars.Add('android_sdk_bin', "Path to Android SDK's tools directory")

+vars.Add(BoolVariable("unbound", "Build bundled ldns and unbound. Use them for DNS lookup.", "no"))

+if env["PLATFORM"] == "darwin" and not env["target"] in ["iphone-device", "iphone-simulator", "xcode", "android"] :

+################################################################################

+# Android

+################################################################################

+if target in ["android"] :

+ env["ENV"]["PATH"] = env["android_toolchain"] + "/bin:" + env["ENV"]["PATH"]

+ env["CC"] = "arm-linux-androideabi-gcc"

+ env["CXX"] = "arm-linux-androideabi-g++"

+ env["RANLIB"] = "arm-linux-androideabi-ranlib"

+ env.Append(CPPDEFINES = ["ANDROID"])

+ env.Append(CPPDEFINES = ["_REENTRANT", "_GLIBCXX__PTHREADS"])

+

+# Unbound

+if env["unbound"] :

+ env["LDNS_BUNDLED"] = 1

+ env["UNBOUND_BUNDLED"] = 1

+else :

+ env["LDNS_FLAGS"] = {}

+ env["UNBOUND_FLAGS"] = {}

+

+if env.get("openssl_force_bundled", False) or env["target"] in ("iphone-device", "iphone-simulator", "xcode", "android") :

+if env["PLATFORM"] == "darwin" and env["target"] == "native" :

+ if env["target"] == "android" :

+ test_env["ENV"]["PATH"] = env["android_sdk_bin"] + ";" + test_env["ENV"]["PATH"]

+ else :

+ if test_env["PLATFORM"] == "darwin" :

+ test_env["ENV"]["DYLD_FALLBACK_LIBRARY_PATH"] = ":".join(map(lambda x : str(x), test_env.get("LIBPATH", [])))

+ elif test_env["PLATFORM"] == "win32" :

+ test_env["ENV"]["PATH"] = ";".join(map(lambda x : str(x), test_env.get("LIBRUNPATH", []))) + ";" + test_env["ENV"]["PATH"]

+

+ if env["target"] == "android":

+ exec_name = os.path.basename(cmd)

+ test_env.Command("**dummy**", target, SCons.Action.Action(

+ ["adb shell mount -o rw,remount /system",

+ "adb push " + cmd + " /system/usr/bin/" + exec_name,

+ "adb shell SWIFT_CLIENTTEST_JID=\"" + os.getenv("SWIFT_CLIENTTEST_JID") + "\" SWIFT_CLIENTTEST_PASS=\"" + os.getenv("SWIFT_CLIENTTEST_PASS") + "\" " + env.get("TEST_RUNNER", "") + "/system/usr/bin/" + exec_name], cmdstr = "$TESTCOMSTR"))

+ else :

+ test_env.Command("**dummy**", target,

+if swiften_env["PLATFORM"] == "darwin" and swiften_env["target"] == "native":

+

+#ifdef USE_UNBOUND

+#include <Swiften/Network/UnboundDomainNameResolver.h>

+#else

+#include <Swiften/Network/PlatformDomainNameResolver.h>

+#endif

+

+#ifdef USE_UNBOUND

+ // TODO: What to do about idnConverter.

+ domainNameResolver = new UnboundDomainNameResolver(ioServiceThread.getIOService(), eventLoop);

+#else

+#endif

+if myenv.get("unbound", False) :

+ myenv.MergeFlags(myenv.get("UNBOUND_FLAGS", {}))

+ myenv.MergeFlags(myenv.get("LDNS_FLAGS", {}))

+

+

+if myenv.get("unbound", False) :

+ myenv.Append(CPPDEFINES = "USE_UNBOUND")

+ sourceList.append("UnboundDomainNameResolver.cpp")

+else :

+ sourceList.append("PlatformDomainNameResolver.cpp")

+ sourceList.append("PlatformDomainNameServiceQuery.cpp")

+ sourceList.append("PlatformDomainNameAddressQuery.cpp")

+

+if myenv["PLATFORM"] == "darwin" and myenv["target"] != "android":

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "UnboundDomainNameResolver.h"

+

+#include <vector>

+

+#include <boost/bind.hpp>

+#include <boost/smart_ptr/make_shared.hpp>

+#include <boost/enable_shared_from_this.hpp>

+

+#include <Swiften/Base/Log.h>

+#include <Swiften/EventLoop/EventLoop.h>

+#include <Swiften/Network/DomainNameAddressQuery.h>

+#include <Swiften/Network/DomainNameResolveError.h>

+#include <Swiften/Network/DomainNameServiceQuery.h>

+#include <Swiften/Network/HostAddress.h>

+#include <Swiften/Network/TimerFactory.h>

+

+#include <arpa/inet.h>

+#include <unbound.h>

+#include <ldns/ldns.h>

+#include <unistd.h>

+

+namespace Swift {

+

+class UnboundQuery {

+ public:

+ UnboundQuery(UnboundDomainNameResolver* resolver, ub_ctx* context) : resolver(resolver), ubContext(context) {}

+ virtual ~UnboundQuery() {}

+ virtual void handleResult(int err, ub_result* result) = 0;

+ protected:

+ UnboundDomainNameResolver* resolver;

+ ub_ctx* ubContext;

+};

+

+struct UnboundWrapperHelper {

+ UnboundWrapperHelper(UnboundDomainNameResolver* resolver, boost::shared_ptr<UnboundQuery> query) : resolver(resolver), query(query) {}

+ UnboundDomainNameResolver* resolver;

+ boost::shared_ptr<UnboundQuery> query;

+};

+

+class UnboundDomainNameServiceQuery : public DomainNameServiceQuery, public UnboundQuery, public boost::enable_shared_from_this<UnboundDomainNameServiceQuery> {

+ public:

+ UnboundDomainNameServiceQuery(UnboundDomainNameResolver* resolver, ub_ctx* context, std::string name) : UnboundQuery(resolver, context), name(name) {

+ }

+

+ virtual ~UnboundDomainNameServiceQuery() { }

+

+ virtual void run() {

+ int retval;

+ UnboundWrapperHelper* helper = new UnboundWrapperHelper(resolver, shared_from_this());

+

+ retval = ub_resolve_async(ubContext, const_cast<char*>(name.c_str()), LDNS_RR_TYPE_SRV,

+ 1 /* CLASS IN (internet) */,

+ helper, UnboundDomainNameResolver::unbound_callback_wrapper, NULL);

+ if(retval != 0) {

+ SWIFT_LOG(debug) << "resolve error: " << ub_strerror(retval) << std::endl;

+ delete helper;

+ }

+ }

+

+ void handleResult(int err, struct ub_result* result) {

+ std::vector<DomainNameServiceQuery::Result> serviceRecords;

+

+ if(err != 0) {

+ SWIFT_LOG(debug) << "resolve error: " << ub_strerror(err) << std::endl;

+ } else {

+ if(result->havedata) {

+ ldns_pkt* replyPacket = 0;

+ ldns_buffer* buffer = ldns_buffer_new(1024);

+ if (buffer && ldns_wire2pkt(&replyPacket, static_cast<const uint8_t*>(result->answer_packet), result->answer_len) == LDNS_STATUS_OK) {

+ ldns_rr_list* rrList = ldns_pkt_answer(replyPacket);

+ for (size_t n = 0; n < ldns_rr_list_rr_count(rrList); n++) {

+ ldns_rr* rr = ldns_rr_list_rr(rrList, n);

+ if ((ldns_rr_get_type(rr) != LDNS_RR_TYPE_SRV) ||

+ (ldns_rr_get_class(rr) != LDNS_RR_CLASS_IN) ||

+ (ldns_rr_rd_count(rr) != 4)) {

+ continue;

+ }

+

+ DomainNameServiceQuery::Result serviceRecord;

+ serviceRecord.priority = ldns_rdf2native_int16(ldns_rr_rdf(rr, 0));

+ serviceRecord.weight = ldns_rdf2native_int16(ldns_rr_rdf(rr, 1));

+ serviceRecord.port = ldns_rdf2native_int16(ldns_rr_rdf(rr, 2));

+

+ ldns_buffer_rewind(buffer);

+ if ((ldns_rdf2buffer_str_dname(buffer, ldns_rr_rdf(rr, 3)) != LDNS_STATUS_OK) ||

+ (ldns_buffer_position(buffer) < 2) ||

+ !ldns_buffer_reserve(buffer, 1)) {

+ // either name invalid, empty or buffer to small

+ continue;

+ }

+ char terminator = 0;

+ ldns_buffer_write(buffer, &terminator, sizeof(terminator));

+

+ serviceRecord.hostname = std::string(reinterpret_cast<char*>(ldns_buffer_at(buffer, 0)));

+ serviceRecords.push_back(serviceRecord);

+ SWIFT_LOG(debug) << "hostname " << serviceRecord.hostname << " added" << std::endl;

+ }

+ }

+ if (replyPacket) ldns_pkt_free(replyPacket);

+ if (buffer) ldns_buffer_free(buffer);

+ }

+ }

+

+ ub_resolve_free(result);

+ onResult(serviceRecords);

+ }

+

+ private:

+ std::string name;

+};

+

+class UnboundDomainNameAddressQuery : public DomainNameAddressQuery, public UnboundQuery, public boost::enable_shared_from_this<UnboundDomainNameAddressQuery> {

+ public:

+ UnboundDomainNameAddressQuery(UnboundDomainNameResolver* resolver, ub_ctx* context, std::string name) : UnboundQuery(resolver, context), name(name) {

+ }

+

+ virtual ~UnboundDomainNameAddressQuery() { }

+

+ virtual void run() {

+ int retval;

+ UnboundWrapperHelper* helper = new UnboundWrapperHelper(resolver, shared_from_this());

+

+ //FIXME: support AAAA queries in some way

+ retval = ub_resolve_async(ubContext, const_cast<char*>(name.c_str()), LDNS_RR_TYPE_A,

+ 1 /* CLASS IN (internet) */,

+ helper, UnboundDomainNameResolver::unbound_callback_wrapper, NULL);

+ if(retval != 0) {

+ SWIFT_LOG(debug) << "resolve error: " << ub_strerror(retval) << std::endl;

+ delete helper;

+ }

+ }

+

+ void handleResult(int err, struct ub_result* result) {

+ std::vector<HostAddress> addresses;

+ boost::optional<DomainNameResolveError> error;

+ SWIFT_LOG(debug) << "Result for: " << name << std::endl;

+

+ if(err != 0) {

+ SWIFT_LOG(debug) << "resolve error: " << ub_strerror(err) << std::endl;

+ error = DomainNameResolveError();

+ } else {

+ if(result->havedata) {

+ for(int i=0; result->data[i]; i++) {

+ char address[100];

+ const char* addressStr = 0;

+ if ((addressStr = inet_ntop(AF_INET, result->data[i], address, 100))) {

+ SWIFT_LOG(debug) << "IPv4 address: " << addressStr << std::endl;

+ addresses.push_back(HostAddress(std::string(addressStr)));

+ } else if ((addressStr = inet_ntop(AF_INET6, result->data[i], address, 100))) {

+ SWIFT_LOG(debug) << "IPv6 address: " << addressStr << std::endl;

+ addresses.push_back(HostAddress(std::string(addressStr)));

+ } else {

+ SWIFT_LOG(debug) << "inet_ntop() failed" << std::endl;

+ error = DomainNameResolveError();

+ }

+ }

+ } else {

+ error = DomainNameResolveError();

+ }

+ }

+

+ ub_resolve_free(result);

+ onResult(addresses, error);

+ }

+

+ private:

+ std::string name;

+};

+

+UnboundDomainNameResolver::UnboundDomainNameResolver(boost::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) : ioService(ioService), ubDescriptior(*ioService), eventLoop(eventLoop) {

+ ubContext = ub_ctx_create();

+ if(!ubContext) {

+ SWIFT_LOG(debug) << "could not create unbound context" << std::endl;

+ }

+ eventOwner = boost::make_shared<EventOwner>();

+

+ ub_ctx_async(ubContext, true);

+

+ int ret;

+

+ /* read /etc/resolv.conf for DNS proxy settings (from DHCP) */

+ if( (ret=ub_ctx_resolvconf(ubContext, const_cast<char*>("/etc/resolv.conf"))) != 0) {

+ SWIFT_LOG(debug) << "error reading resolv.conf: " << ub_strerror(ret) << ". errno says: " << strerror(errno) << std::endl;

+ }

+ /* read /etc/hosts for locally supplied host addresses */

+ if( (ret=ub_ctx_hosts(ubContext, const_cast<char*>("/etc/hosts"))) != 0) {

+ SWIFT_LOG(debug) << "error reading hosts: " << ub_strerror(ret) << ". errno says: " << strerror(errno) << std::endl;

+ }

+

+ ubDescriptior.assign(ub_fd(ubContext));

+

+ ubDescriptior.async_read_some(boost::asio::null_buffers(), boost::bind(&UnboundDomainNameResolver::handleUBSocketReadable, this, boost::asio::placeholders::error));

+}

+

+UnboundDomainNameResolver::~UnboundDomainNameResolver() {

+ eventLoop->removeEventsFromOwner(eventOwner);

+ if (ubContext) {

+ ub_ctx_delete(ubContext);

+ }

+}

+

+void UnboundDomainNameResolver::unbound_callback(boost::shared_ptr<UnboundQuery> query, int err, ub_result* result) {

+ query->handleResult(err, result);

+}

+

+void UnboundDomainNameResolver::unbound_callback_wrapper(void* data, int err, ub_result* result) {

+ UnboundWrapperHelper* helper = static_cast<UnboundWrapperHelper*>(data);

+ UnboundDomainNameResolver* resolver = helper->resolver;

+ resolver->unbound_callback(helper->query, err, result);

+ delete helper;

+}

+

+void UnboundDomainNameResolver::handleUBSocketReadable(boost::system::error_code) {

+ eventLoop->postEvent(boost::bind(&UnboundDomainNameResolver::processData, this), eventOwner);

+ ubDescriptior.async_read_some(boost::asio::null_buffers(), boost::bind(&UnboundDomainNameResolver::handleUBSocketReadable, this, boost::asio::placeholders::error));

+}

+

+void UnboundDomainNameResolver::processData() {

+ if (ub_poll(ubContext)) {

+ int ret = ub_process(ubContext);

+ if(ret != 0) {

+ SWIFT_LOG(debug) << "resolve error: " << ub_strerror(ret) << std::endl;

+ }

+ }

+}

+

+boost::shared_ptr<DomainNameServiceQuery> UnboundDomainNameResolver::createServiceQuery(const std::string& name) {

+ return boost::make_shared<UnboundDomainNameServiceQuery>(this, ubContext, name);

+}

+

+boost::shared_ptr<DomainNameAddressQuery> UnboundDomainNameResolver::createAddressQuery(const std::string& name) {

+ return boost::make_shared<UnboundDomainNameAddressQuery>(this, ubContext, name);

+}

+

+}

+/*

+ * Copyright (c) 2013 Tobias Markmann

+ * Licensed under the simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+#include <Swiften/Network/DomainNameResolver.h>

+#include <Swiften/Network/Timer.h>

+#include <Swiften/EventLoop/EventOwner.h>

+

+#include <boost/shared_ptr.hpp>

+#include <boost/enable_shared_from_this.hpp>

+#include <boost/asio.hpp>

+

+struct ub_ctx;

+struct ub_result;

+

+namespace Swift {

+ class EventLoop;

+ class TimerFactory;

+

+ class UnboundDomainNameResolver;

+ class UnboundQuery;

+

+ class UnboundDomainNameResolver : public DomainNameResolver, public EventOwner, public boost::enable_shared_from_this<UnboundDomainNameResolver> {

+ public:

+ UnboundDomainNameResolver(boost::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop);

+ virtual ~UnboundDomainNameResolver();

+

+ virtual boost::shared_ptr<DomainNameServiceQuery> createServiceQuery(const std::string& name);

+ virtual boost::shared_ptr<DomainNameAddressQuery> createAddressQuery(const std::string& name);

+

+ static void unbound_callback_wrapper(void* data, int err, ub_result* result);

+

+ private:

+ void unbound_callback(boost::shared_ptr<UnboundQuery> query, int err, ub_result* result);

+

+ void handleUBSocketReadable(boost::system::error_code);

+ void processData();

+

+ private:

+ boost::shared_ptr<EventOwner> eventOwner;

+ boost::shared_ptr<boost::asio::io_service> ioService;

+ boost::asio::posix::stream_descriptor ubDescriptior;

+ EventLoop* eventLoop;

+ ub_ctx* ubContext;

+ };

+

+}

+

+#ifndef __ANDROID__

+#endif

+#ifndef __ANDROID__

+#endif

+#ifdef USE_UNBOUND

+#include <Swiften/Network/UnboundDomainNameResolver.h>

+#else

+#endif

+#include <Swiften/Network/BoostTimerFactory.h>

+#include <Swiften/Network/NetworkFactories.h>

+#include <Swiften/Network/BoostIOServiceThread.h>

+#ifndef USE_UNBOUND

+#endif

+#ifndef USE_UNBOUND

+#endif

+ ioServiceThread = new BoostIOServiceThread();

+#ifdef USE_UNBOUND

+ resolver = new UnboundDomainNameResolver(ioServiceThread->getIOService(), eventLoop);

+#else

+#endif

+ delete ioServiceThread;

+ BoostIOServiceThread* ioServiceThread;

+ boost::shared_ptr<TimerFactory> timerFactory;

+ DomainNameResolver* resolver;

+ if env.get("unbound", False) :

+ myenv.Append(CPPDEFINES = ["USE_UNBOUND"])

+

+swiften_dep_modules = ["BOOST", "GCONF", "ICU", "LIBIDN", "ZLIB", "LDNS", "UNBOUND", "OPENSSL", "LIBXML", "EXPAT", "AVAHI", "LIBMINIUPNPC", "LIBNATPMP", "SQLITE"]

+ if file.endswith("_Private.h") or file.startswith("Schannel") or file.startswith("CAPI") or file.startswith("MacOSX") or file.startswith("Windows") or file.endswith("_Windows.h") or file.startswith("SQLite") or file == "ICUConverter.h" or file == "UnboundDomainNameResolver.h" :