+ * Copyright (c) 2011-2014 Kevin Smith

+ rid_(~0ULL),

+ else {

+ /* handleDisconnected takes care of the connector_ as well */

+ handleDisconnected(boost::optional<Connection::Error>());

+ }

+ header << "POST " << boshURL.getPath() << " HTTP/1.1\r\n"

+ << "Host: " << boshURL.getHost();

+ if (boshURL.getPort()) {

+ header << ":" << *boshURL.getPort();

+ }

+ header << "\r\n"

+ // << "Accept-Encoding: deflate\r\n"

+ connectionReady_ = !!connection;

+ // << " ack='0'" FIXME: support acks

+ header << "POST " << boshURL_.getPath() << " HTTP/1.1\r\n"

+ << "Host: " << boshURL_.getHost();

+ if (boshURL_.getPort()) {

+ header << ":" << *boshURL_.getPort();

+ }

+ header << "\r\n"

+ // << "Accept-Encoding: deflate\r\n"

+ size_t requests = 2;

+ onDisconnected(error ? true : false);

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

+ class SWIFTEN_API BOSHError : public SessionStream::SessionStreamError {

+ class SWIFTEN_API BOSHConnection : public boost::enable_shared_from_this<BOSHConnection> {

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

+ if (!boshHTTPConnectProxyURL.isEmpty()) {

+ connectionFactory = new HTTPConnectProxiedConnectionFactory(realResolver, connectionFactory, timerFactory, boshHTTPConnectProxyURL.getHost(), URL::getPortOrDefaultPort(boshHTTPConnectProxyURL), boshHTTPConnectProxyAuthID, boshHTTPConnectProxyAuthPassword);

+ resolver = new CachingDomainNameResolver(realResolver, eventLoop);

+ /* Don't do a normal close here. Instead kill things forcibly, as close() or writeFooter() will already have been called */

+ std::vector<BOSHConnection::ref> connectionCopies = connections;

+ foreach (BOSHConnection::ref connection, connectionCopies) {

+ if (connection) {

+ destroyConnection(connection);

+ connection->disconnect();

+ }

+ }

+ if (!sid.empty()) {

+ writeFooter();

+ }

+ else {

+ pendingTerminate = true;

+ }

+ sid = "";

+ close();

+void BOSHConnectionPool::handleConnectionDisconnected(bool/* error*/, BOSHConnection::ref connection) {

+ if (pendingTerminate && sid.empty() && connections.empty()) {

+ handleSessionTerminated(BOSHError::ref());

+ //else if (error) {

+ // handleSessionTerminated(boost::make_shared<BOSHError>(BOSHError::UndefinedCondition));

+ //}

+ Connector::ref connector = Connector::create(boshURL.getHost(), URL::getPortOrDefaultPort(boshURL), boost::optional<std::string>(), resolver, connectionFactory, timerFactory);

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

+ class CachingDomainNameResolver;

+ class SWIFTEN_API BOSHConnectionPool : public boost::bsignals::trackable {

+ CachingDomainNameResolver* resolver;

+#include <boost/numeric/conversion/cast.hpp>

+ boost::asio::ip::address::from_string(addressPort.getAddress().toString()), boost::numeric_cast<unsigned short>(addressPort.getPort()));

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

+ class SWIFTEN_API BoostConnection : public Connection, public EventOwner, public boost::enable_shared_from_this<BoostConnection> {

+#include <boost/numeric/conversion/cast.hpp>

+#include <boost/optional.hpp>

+ boost::optional<Error> error = tryStart();

+ if (error) {

+ eventLoop->postEvent(boost::bind(boost::ref(onStopped), *error), shared_from_this());

+ }

+}

+

+boost::optional<BoostConnectionServer::Error> BoostConnectionServer::tryStart() {

+ boost::asio::ip::tcp::endpoint(address_.getRawAddress(), boost::numeric_cast<unsigned short>(port_)));

+ boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), boost::numeric_cast<unsigned short>(port_)));

+ return Conflict;

+ return UnknownError;

+ return boost::optional<Error>();

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

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

+#include <boost/optional/optional_fwd.hpp>

+ class SWIFTEN_API BoostConnectionServer : public ConnectionServer, public EventOwner, public boost::enable_shared_from_this<BoostConnectionServer> {

+ virtual boost::optional<Error> tryStart(); // FIXME: This should become the new start

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

+

+ class SWIFTEN_API BoostIOServiceThread {

+ * Copyright (c) 2010-2013 Remko Tronçon

+

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

+#include <Swiften/IDN/PlatformIDNConverter.h>

+#include <Swiften/IDN/IDNConverter.h>

+#include <Swiften/Crypto/PlatformCryptoProvider.h>

+#include <Swiften/Crypto/CryptoProvider.h>

+

+#ifdef USE_UNBOUND

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

+#else

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

+#endif

+ networkEnvironment = new PlatformNetworkEnvironment();

+ idnConverter = PlatformIDNConverter::create();

+#ifdef USE_UNBOUND

+ // TODO: What to do about idnConverter.

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

+#else

+ domainNameResolver = new PlatformDomainNameResolver(idnConverter, eventLoop);

+#endif

+ cryptoProvider = PlatformCryptoProvider::create();

+ delete cryptoProvider;

+ delete domainNameResolver;

+ delete idnConverter;

+ delete networkEnvironment;

+ * Copyright (c) 2010-2013 Remko Tronçon

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

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

+ class SWIFTEN_API BoostNetworkFactories : public NetworkFactories {

+ virtual TimerFactory* getTimerFactory() const SWIFTEN_OVERRIDE {

+ virtual ConnectionFactory* getConnectionFactory() const SWIFTEN_OVERRIDE {

+ DomainNameResolver* getDomainNameResolver() const SWIFTEN_OVERRIDE {

+ ConnectionServerFactory* getConnectionServerFactory() const SWIFTEN_OVERRIDE {

+ NetworkEnvironment* getNetworkEnvironment() const SWIFTEN_OVERRIDE {

+ return networkEnvironment;

+ }

+

+ NATTraverser* getNATTraverser() const SWIFTEN_OVERRIDE {

+ virtual XMLParserFactory* getXMLParserFactory() const SWIFTEN_OVERRIDE {

+ virtual TLSContextFactory* getTLSContextFactory() const SWIFTEN_OVERRIDE;

+ virtual ProxyProvider* getProxyProvider() const SWIFTEN_OVERRIDE {

+ virtual EventLoop* getEventLoop() const SWIFTEN_OVERRIDE {

+ virtual IDNConverter* getIDNConverter() const SWIFTEN_OVERRIDE {

+ return idnConverter;

+ }

+

+ virtual CryptoProvider* getCryptoProvider() const SWIFTEN_OVERRIDE {

+ return cryptoProvider;

+ }

+

+ NetworkEnvironment* networkEnvironment;

+ IDNConverter* idnConverter;

+ CryptoProvider* cryptoProvider;

+/*

+ * Copyright (c) 2012 Kevin Smith

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

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

+

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

+

+namespace Swift {

+

+CachingDomainNameResolver::CachingDomainNameResolver(DomainNameResolver* realResolver, EventLoop*) : realResolver(realResolver) {

+}

+

+CachingDomainNameResolver::~CachingDomainNameResolver() {

+

+}

+

+DomainNameServiceQuery::ref CachingDomainNameResolver::createServiceQuery(const std::string& serviceLookupPrefix, const std::string& domain) {

+ //TODO: Cache

+ return realResolver->createServiceQuery(serviceLookupPrefix, domain);

+}

+

+DomainNameAddressQuery::ref CachingDomainNameResolver::createAddressQuery(const std::string& name) {

+ //TODO: Cache

+ return realResolver->createAddressQuery(name);

+}

+

+}

+/*

+ * FIXME: Does not do any caching yet.

+ */

+

+ class CachingDomainNameResolver : public DomainNameResolver {

+ CachingDomainNameResolver(DomainNameResolver* realResolver, EventLoop* eventLoop);

+ ~CachingDomainNameResolver();

+ virtual DomainNameServiceQuery::ref createServiceQuery(const std::string& serviceLookupPrefix, const std::string& domain);

+ int port,

+ const boost::optional<std::string>& serviceLookupPrefix,

+ port(port),

+ serviceLookupPrefix(serviceLookupPrefix),

+ currentConnector = Connector::create(hostname, port, serviceLookupPrefix, resolver, connectionFactory, timerFactory);

+#include <boost/optional.hpp>

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

+ class SWIFTEN_API ChainedConnector {

+ ChainedConnector(const std::string& hostname, int port, const boost::optional<std::string>& serviceLookupPrefix, DomainNameResolver*, const std::vector<ConnectionFactory*>&, TimerFactory*);

+ int port;

+ boost::optional<std::string> serviceLookupPrefix;

+}

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

+ class SWIFTEN_API Connection {

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

+

+ class SWIFTEN_API ConnectionFactory {

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

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

+#include <boost/optional/optional_fwd.hpp>

+ class SWIFTEN_API ConnectionServer {

+ enum Error {

+ Conflict,

+ UnknownError

+ };

+

+ virtual boost::optional<Error> tryStart() = 0; // FIXME: This should become the new start

+

+Connector::Connector(const std::string& hostname, int port, const boost::optional<std::string>& serviceLookupPrefix, DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory) : hostname(hostname), port(port), serviceLookupPrefix(serviceLookupPrefix), resolver(resolver), connectionFactory(connectionFactory), timerFactory(timerFactory), timeoutMilliseconds(0), queriedAllServices(true), foundSomeDNS(false) {

+ if (serviceLookupPrefix) {

+ serviceQuery = resolver->createServiceQuery(*serviceLookupPrefix, hostname);

+ serviceQuery->onResult.connect(boost::bind(&Connector::handleServiceQueryResult, shared_from_this(), _1));

+ else {

+ queryAddress(hostname);

+ }

+}

+ int connectPort = (port == -1 ? 5222 : port);

+ connectPort = serviceQueryResults.front().port;

+ tryConnect(HostAddressPort(address, connectPort));

+ if (timer) {

+ timer->start();

+ }

+ if (timer) {

+ timer->stop();

+ timer.reset();

+ }

+ handleConnectionConnectFinished(true);

+}

+#include <boost/optional.hpp>

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

+ class SWIFTEN_API Connector : public boost::bsignals::trackable, public boost::enable_shared_from_this<Connector> {

+ static Connector::ref create(const std::string& hostname, int port, const boost::optional<std::string>& serviceLookupPrefix, DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory) {

+ return ref(new Connector(hostname, port, serviceLookupPrefix, resolver, connectionFactory, timerFactory));

+ Connector(const std::string& hostname, int port, const boost::optional<std::string>& serviceLookupPrefix, DomainNameResolver*, ConnectionFactory*, TimerFactory*);

+ int port;

+ boost::optional<std::string> serviceLookupPrefix;

+}

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

+

+ class SWIFTEN_API DomainNameResolver {

+ virtual boost::shared_ptr<DomainNameServiceQuery> createServiceQuery(const std::string& serviceLookupPrefix, const std::string& domain) = 0;

+ * Copyright (c) 2010-2013 Remko Tronçon

+#include <boost/lambda/lambda.hpp>

+#include <boost/lambda/bind.hpp>

+#include <boost/typeof/typeof.hpp>

+namespace lambda = boost::lambda;

+ std::stable_sort(queries.begin(), queries.end(), comparator);

+ std::transform(i, next, std::back_inserter(weights),

+ /* easy hack to account for '0' weights getting at least some weight */

+ lambda::bind(&Result::weight, lambda::_1) + 1);

+ for (int j = 0; j < boost::numeric_cast<int>(weights.size() - 1); ++j) {

+ std::partial_sum(

+ weights.begin() + j,

+ weights.end(),

+ std::back_inserter(cumulativeWeights));

+ BOOST_AUTO(selectedIndex, std::lower_bound(cumulativeWeights.begin(), cumulativeWeights.end(), randomNumber) - cumulativeWeights.begin());

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

+ class SWIFTEN_API DomainNameServiceQuery {

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

+ class SWIFTEN_API DummyConnection : public Connection, public EventOwner, public boost::enable_shared_from_this<DummyConnection> {

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

+ class SWIFTEN_API DummyTimerFactory : public TimerFactory {

+ * Copyright (c) 2010-2014 Remko Tronçon

+ boost::bind(boost::ref(onConnectFinished), error ? true : false),

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

+ class SWIFTEN_API FakeConnection :

+HTTPConnectProxiedConnection::HTTPConnectProxiedConnection(

+ DomainNameResolver* resolver,

+ ConnectionFactory* connectionFactory,

+ TimerFactory* timerFactory,

+ const std::string& proxyHost,

+ int proxyPort,

+ const SafeString& authID,

+ const SafeString& authPassword) :

+ ProxiedConnection(resolver, connectionFactory, timerFactory, proxyHost, proxyPort),

+ authID_(authID),

+ authPassword_(authPassword) {

+void HTTPConnectProxiedConnection::initializeProxy() {

+ connect << "CONNECT " << getServer().getAddress().toString() << ":" << getServer().getPort() << " HTTP/1.1\r\n";

+ write(data);

+void HTTPConnectProxiedConnection::handleProxyInitializeData(boost::shared_ptr<SafeByteArray> data) {

+ try {

+ int status = boost::lexical_cast<int>(tmp[1]);

+ setProxyInitializeFinished(true);

+ else {

+ setProxyInitializeFinished(false);

+ catch (boost::bad_lexical_cast&) {

+ SWIFT_LOG(warning) << "Unexpected response: " << tmp[1] << std::endl;

+ setProxyInitializeFinished(false);

+ else {

+ setProxyInitializeFinished(false);

+ }

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

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

+ class DomainNameResolver;

+ class TimerFactory;

+ class SWIFTEN_API HTTPConnectProxiedConnection : public ProxiedConnection {

+ static ref create(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword) {

+ return ref(new HTTPConnectProxiedConnection(resolver, connectionFactory, timerFactory, proxyHost, proxyPort, authID, authPassword));

+ HTTPConnectProxiedConnection(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword);

+ virtual void initializeProxy();

+ virtual void handleProxyInitializeData(boost::shared_ptr<SafeByteArray> data);

+HTTPConnectProxiedConnectionFactory::HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort) : resolver_(resolver), connectionFactory_(connectionFactory), timerFactory_(timerFactory), proxyHost_(proxyHost), proxyPort_(proxyPort), authID_(""), authPassword_("") {

+HTTPConnectProxiedConnectionFactory::HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword) : resolver_(resolver), connectionFactory_(connectionFactory), timerFactory_(timerFactory), proxyHost_(proxyHost), proxyPort_(proxyPort), authID_(authID), authPassword_(authPassword) {

+ return HTTPConnectProxiedConnection::create(resolver_, connectionFactory_, timerFactory_, proxyHost_, proxyPort_, authID_, authPassword_);

+ HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort);

+ HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword);

+ * Copyright (c) 2010-2013 Remko Tronçon

+static boost::asio::ip::address localhost4 = boost::asio::ip::address(boost::asio::ip::address_v4::loopback());

+static boost::asio::ip::address localhost6 = boost::asio::ip::address(boost::asio::ip::address_v6::loopback());

+

+HostAddress::HostAddress(const unsigned char* address, size_t length) {

+ for (size_t i = 0; i < length; ++i) {

+ for (size_t i = 0; i < length; ++i) {

+bool HostAddress::isLocalhost() const {

+ return address_ == localhost4 || address_ == localhost6;

+}

+

+ * Copyright (c) 2010-2013 Remko Tronçon

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

+

+ class SWIFTEN_API HostAddress {

+ HostAddress(const unsigned char* address, size_t length);

+ bool isLocalhost() const;

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

+ class SWIFTEN_API HostAddressPort {

+/*

+ * Copyright (c) 2012 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

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

+

+using namespace Swift;

+

+namespace {

+ struct ToStringVisitor : public boost::static_visitor<std::string> {

+ std::string operator()(const HostAddress& address) const {

+ return address.toString();

+ }

+

+ std::string operator()(const std::string & str) const {

+ return str;

+ }

+ };

+}

+

+namespace Swift {

+

+std::string toString(const HostNameOrAddress& address) {

+ return boost::apply_visitor(ToStringVisitor(), address);

+}

+

+}

+/*

+ * Copyright (c) 2012 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+#pragma once

+

+#include <string>

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

+#include <boost/variant.hpp>

+

+namespace Swift {

+ typedef boost::variant<std::string, HostAddress> HostNameOrAddress;

+

+ std::string toString(const HostNameOrAddress& address);

+}

+/*

+ * Copyright (c) 2013 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <boost/numeric/conversion/cast.hpp>

+#pragma clang diagnostic ignored "-Wdisabled-macro-expansion"

+

+ CFRelease(zero);

+ buffer.resize(boost::numeric_cast<size_t>(length));

+ CFRelease(proxies);

+ CFRelease(proxies);

+#include <miniupnpc.h>

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

+struct MiniUPnPInterface::Private {

+ bool isValid;

+ std::string localAddress;

+ UPNPDev* deviceList;

+ UPNPUrls urls;

+ IGDdatas data;

+};

+

+MiniUPnPInterface::MiniUPnPInterface() : p(boost::make_shared<Private>()) {

+ p->isValid = false;

+ p->deviceList = upnpDiscover(1500 /* timeout in ms */, 0, 0, 0, 0 /* do IPv6? */, &error);

+ if (!p->deviceList) {

+ if (!UPNP_GetValidIGD(p->deviceList, &p->urls, &p->data, lanAddress, sizeof(lanAddress))) {

+ p->localAddress = std::string(lanAddress);

+ p->isValid = true;

+ if (p->isValid) {

+ FreeUPNPUrls(&p->urls);

+ freeUPNPDevlist(p->deviceList);

+ if (!p->isValid) {

+ int ret = UPNP_GetExternalIPAddress(p->urls.controlURL, p->data.first.servicetype, externalIPAddress);

+ if (!p->isValid) {

+ int ret = UPNP_AddPortMapping(

+ p->urls.controlURL,

+ p->data.first.servicetype,

+ publicPort.c_str(),

+ localPort.c_str(),

+ p->localAddress.c_str(),

+ 0,

+ mapping.getProtocol() == NATPortMapping::TCP ? "TCP" : "UDP",

+ 0,

+ leaseSeconds.c_str());

+ if (!p->isValid) {

+ int ret = UPNP_DeletePortMapping(p->urls.controlURL, p->data.first.servicetype, publicPort.c_str(), mapping.getProtocol() == NATPortMapping::TCP ? "TCP" : "UDP", 0);

+bool MiniUPnPInterface::isAvailable() {

+ return p->isValid;

+}

+

+#include <boost/noncopyable.hpp>

+#include <boost/shared_ptr.hpp>

+ class MiniUPnPInterface : public NATTraversalInterface, boost::noncopyable {

+ virtual bool isAvailable();

+ struct Private;

+ boost::shared_ptr<Private> p;

+/*

+* Copyright (c) 2014 Kevin Smith

+* Licensed under the GNU General Public License v3.

+* See Documentation/Licenses/GPLv3.txt for more information.

+*/

+

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

+#include <boost/numeric/conversion/cast.hpp>

+

+// This has to be included after the previous headers, because of WIN32 macro

+// being defined somewhere.

+#include <natpmp.h>

+

+struct NATPMPInterface::Private {

+ natpmp_t natpmp;

+};

+

+NATPMPInterface::NATPMPInterface() : p(boost::make_shared<Private>()) {

+ initnatpmp(&p->natpmp, 0, 0);

+ closenatpmp(&p->natpmp);

+ return getPublicIP() ? true : false;

+ if (sendpublicaddressrequest(&p->natpmp) < 0) {

+ FD_SET(p->natpmp.s, &fds);

+ getnatpmprequesttimeout(&p->natpmp, &timeout);

+ r = readnatpmpresponseorretry(&p->natpmp, &response);

+ if (sendnewportmappingrequest(

+ &p->natpmp,

+ mapping.getProtocol() == NATPortMapping::TCP ? NATPMP_PROTOCOL_TCP : NATPMP_PROTOCOL_UDP,

+ boost::numeric_cast<uint16_t>(mapping.getLocalPort()),

+ boost::numeric_cast<uint16_t>(mapping.getPublicPort()),

+ boost::numeric_cast<uint32_t>(mapping.getLeaseInSeconds())) < 0) {

+ FD_SET(p->natpmp.s, &fds);

+ getnatpmprequesttimeout(&p->natpmp, &timeout);

+ r = readnatpmpresponseorretry(&p->natpmp, &response);

+ NATPortMapping result(response.pnu.newportmapping.privateport, response.pnu.newportmapping.mappedpublicport, NATPortMapping::TCP, boost::numeric_cast<int>(response.pnu.newportmapping.lifetime));

+ if (sendnewportmappingrequest(&p->natpmp, mapping.getProtocol() == NATPortMapping::TCP ? NATPMP_PROTOCOL_TCP : NATPMP_PROTOCOL_UDP, 0, 0, boost::numeric_cast<uint32_t>(mapping.getLocalPort())) < 0) {

+ FD_SET(p->natpmp.s, &fds);

+ getnatpmprequesttimeout(&p->natpmp, &timeout);

+ r = readnatpmpresponseorretry(&p->natpmp, &response);

+#include <boost/shared_ptr.hpp>

+#include <boost/noncopyable.hpp>

+ class NATPMPInterface : public NATTraversalInterface, boost::noncopyable {

+ struct Private;

+ boost::shared_ptr<Private> p;

+ UDP

+ NATPortMapping(int localPort, int publicPort, Protocol protocol = TCP, int leaseInSeconds = 60 * 60 * 24) :

+ publicPort(publicPort), localPort(localPort), protocol(protocol), leaseInSeconds(leaseInSeconds) {

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

+ class SWIFTEN_API NATTraversalForwardPortRequest {

+ virtual void start() = 0;

+ virtual void stop() = 0;

+ virtual void start() = 0;

+ virtual void stop() = 0;

+ UDP

+ virtual void start() = 0;

+ virtual void stop() = 0;

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

+ class SWIFTEN_API NetworkEnvironment {

+ * Copyright (c) 2010-2013 Remko Tronçon

+ class IDNConverter;

+ class NetworkEnvironment;

+ class CryptoProvider;

+ virtual NetworkEnvironment* getNetworkEnvironment() const = 0;

+ virtual IDNConverter* getIDNConverter() const = 0;

+ virtual CryptoProvider* getCryptoProvider() const = 0;

+ virtual void start() {

+ virtual void stop() {

+ }

+

+ virtual void start() {

+ virtual void stop() {

+ }

+

+ virtual void start() {

+ virtual void stop() {

+ }

+

+PlatformDomainNameAddressQuery::PlatformDomainNameAddressQuery(const boost::optional<std::string>& host, EventLoop* eventLoop, PlatformDomainNameResolver* resolver) : PlatformDomainNameQuery(resolver), hostnameValid(false), eventLoop(eventLoop) {

+ if (!!host) {

+ hostname = *host;

+ hostnameValid = true;

+ }

+ if (!hostnameValid) {

+ emitError();

+ return;

+ }

+ PlatformDomainNameAddressQuery(const boost::optional<std::string>& host, EventLoop* eventLoop, PlatformDomainNameResolver*);

+ bool hostnameValid;

+ * Copyright (c) 2010-2013 Remko Tronçon

+#include <Swiften/IDN/IDNConverter.h>

+PlatformDomainNameResolver::PlatformDomainNameResolver(IDNConverter* idnConverter, EventLoop* eventLoop) : idnConverter(idnConverter), eventLoop(eventLoop), stopRequested(false) {

+boost::shared_ptr<DomainNameServiceQuery> PlatformDomainNameResolver::createServiceQuery(const std::string& serviceLookupPrefix, const std::string& domain) {

+ boost::optional<std::string> encodedDomain = idnConverter->getIDNAEncoded(domain);

+ std::string result;

+ if (encodedDomain) {

+ result = serviceLookupPrefix + *encodedDomain;

+ }

+ return boost::shared_ptr<DomainNameServiceQuery>(new PlatformDomainNameServiceQuery(result, eventLoop, this));

+ return boost::shared_ptr<DomainNameAddressQuery>(new PlatformDomainNameAddressQuery(idnConverter->getIDNAEncoded(name), eventLoop, this));

+ * Copyright (c) 2010-2013 Remko Tronçon

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

+ class IDNConverter;

+ class SWIFTEN_API PlatformDomainNameResolver : public DomainNameResolver {

+ PlatformDomainNameResolver(IDNConverter* idnConverter, EventLoop* eventLoop);

+ virtual DomainNameServiceQuery::ref createServiceQuery(const std::string& serviceLookupPrefix, const std::string& domain);

+ IDNConverter* idnConverter;

+#include <boost/numeric/conversion/cast.hpp>

+PlatformDomainNameServiceQuery::PlatformDomainNameServiceQuery(const boost::optional<std::string>& serviceName, EventLoop* eventLoop, PlatformDomainNameResolver* resolver) : PlatformDomainNameQuery(resolver), eventLoop(eventLoop), serviceValid(false) {

+ if (!!serviceName) {

+ service = *serviceName;

+ serviceValid = true;

+ }

+ if (!serviceValid) {

+ emitError();

+ return;

+ }

+

+ record.priority = boost::numeric_cast<int>(ns_get16(currentEntry));

+ record.weight = boost::numeric_cast<int>(ns_get16(currentEntry));

+ record.port = boost::numeric_cast<int>(ns_get16(currentEntry));

+ * Copyright (c) 2010-2013 Remko Tronçon

+ PlatformDomainNameServiceQuery(const boost::optional<std::string>& serviceName, EventLoop* eventLoop, PlatformDomainNameResolver* resolver);

+ bool serviceValid;

+#include <boost/numeric/conversion/cast.hpp>

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

+#ifdef HAVE_LIBNATPMP

+#endif

+#ifdef HAVE_LIBMINIUPNPC

+#endif

+ EventLoop* getEventLoop() const {

+ return worker->getEventLoop();

+ }

+

+ virtual void start() {

+ virtual void stop() {

+ // TODO

+ }

+

+ getEventLoop()->postEvent(boost::bind(boost::ref(onResult), getNATTraversalInterface()->getPublicIP()));

+ virtual void start() {

+ virtual void stop() {

+ // TODO

+ }

+

+ getEventLoop()->postEvent(boost::bind(boost::ref(onResult), getNATTraversalInterface()->addPortForward(boost::numeric_cast<int>(localIP), boost::numeric_cast<int>(publicIP))));

+ virtual void start() {

+ virtual void stop() {

+ // TODO

+ }

+

+ getEventLoop()->postEvent(boost::bind(boost::ref(onResult), getNATTraversalInterface()->removePortForward(mapping)));

+ // FIXME: This should be done from start(), and the current start() should be an internal method

+ thread = new boost::thread(boost::bind(&PlatformNATTraversalWorker::start, this));

+#ifdef HAVE_LIBNATPMP

+#endif

+#ifdef HAVE_LIBMINIUPNPC

+#endif

+#ifdef HAVE_LIBMINIUPNPC

+#endif

+#ifdef HAVE_LIBNATPMP

+#endif

+void PlatformNATTraversalWorker::start() {

+void PlatformNATTraversalWorker::stop() {

+ // TODO

+}

+

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

+ class SWIFTEN_API PlatformNATTraversalWorker : public NATTraverser {

+ void start();

+ void stop();

+

+ EventLoop* getEventLoop() const {

+ return eventLoop;

+ }

+#elif defined(SWIFTEN_PLATFORM_SOLARIS)

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

+namespace Swift {

+ typedef SolarisNetworkEnvironment PlatformNetworkEnvironment;

+}

+

+/*

+ * Copyright (c) 2012 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+

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

+

+#include <iostream>

+#include <boost/bind.hpp>

+

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

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

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

+

+using namespace Swift;

+

+ProxiedConnection::ProxiedConnection(

+ DomainNameResolver* resolver,

+ ConnectionFactory* connectionFactory,

+ TimerFactory* timerFactory,

+ const std::string& proxyHost,

+ int proxyPort) :

+ resolver_(resolver),

+ connectionFactory_(connectionFactory),

+ timerFactory_(timerFactory),

+ proxyHost_(proxyHost),

+ proxyPort_(proxyPort),

+ server_(HostAddressPort(HostAddress("0.0.0.0"), 0)) {

+ connected_ = false;

+}

+

+ProxiedConnection::~ProxiedConnection() {

+ cancelConnector();

+ if (connection_) {

+ connection_->onDataRead.disconnect(boost::bind(&ProxiedConnection::handleDataRead, shared_from_this(), _1));

+ connection_->onDisconnected.disconnect(boost::bind(&ProxiedConnection::handleDisconnected, shared_from_this(), _1));

+ }

+ if (connected_) {

+ std::cerr << "Warning: Connection was still established." << std::endl;

+ }

+}

+

+void ProxiedConnection::cancelConnector() {

+ if (connector_) {

+ connector_->onConnectFinished.disconnect(boost::bind(&ProxiedConnection::handleConnectFinished, shared_from_this(), _1));

+ connector_->stop();

+ connector_.reset();

+ }

+}

+

+void ProxiedConnection::connect(const HostAddressPort& server) {

+ server_ = server;

+

+ connector_ = Connector::create(proxyHost_, proxyPort_, boost::optional<std::string>(), resolver_, connectionFactory_, timerFactory_);

+ connector_->onConnectFinished.connect(boost::bind(&ProxiedConnection::handleConnectFinished, shared_from_this(), _1));

+ connector_->start();

+}

+

+void ProxiedConnection::listen() {

+ assert(false);

+ connection_->listen();

+}

+

+void ProxiedConnection::disconnect() {

+ connected_ = false;

+ connection_->disconnect();

+}

+

+void ProxiedConnection::handleDisconnected(const boost::optional<Error>& error) {

+ onDisconnected(error);

+}

+

+void ProxiedConnection::write(const SafeByteArray& data) {

+ connection_->write(data);

+}

+

+void ProxiedConnection::handleConnectFinished(Connection::ref connection) {

+ cancelConnector();

+ if (connection) {

+ connection_ = connection;

+ connection_->onDataRead.connect(boost::bind(&ProxiedConnection::handleDataRead, shared_from_this(), _1));

+ connection_->onDisconnected.connect(boost::bind(&ProxiedConnection::handleDisconnected, shared_from_this(), _1));

+

+ initializeProxy();

+ }

+ else {

+ onConnectFinished(true);

+ }

+}

+

+void ProxiedConnection::handleDataRead(boost::shared_ptr<SafeByteArray> data) {

+ if (!connected_) {

+ handleProxyInitializeData(data);

+ }

+ else {

+ onDataRead(data);

+ }

+}

+

+HostAddressPort ProxiedConnection::getLocalAddress() const {

+ return connection_->getLocalAddress();

+}

+

+void ProxiedConnection::setProxyInitializeFinished(bool success) {

+ connected_ = success;

+ if (!success) {

+ disconnect();

+ }

+ onConnectFinished(!success);

+}

+/*

+ * Copyright (c) 2012 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+

+#pragma once

+

+#include <boost/enable_shared_from_this.hpp>

+

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

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

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

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

+

+namespace boost {

+ class thread;

+ namespace system {

+ class error_code;

+ }

+}

+

+namespace Swift {

+ class ConnectionFactory;

+

+ class ProxiedConnection : public Connection, public boost::enable_shared_from_this<ProxiedConnection> {

+ public:

+ ProxiedConnection(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort);

+ ~ProxiedConnection();

+

+ virtual void listen();

+ virtual void connect(const HostAddressPort& address);

+ virtual void disconnect();

+ virtual void write(const SafeByteArray& data);

+

+ virtual HostAddressPort getLocalAddress() const;

+

+ private:

+ void handleConnectFinished(Connection::ref connection);

+ void handleDataRead(boost::shared_ptr<SafeByteArray> data);

+ void handleDisconnected(const boost::optional<Error>& error);

+ void cancelConnector();

+

+ protected:

+ void setProxyInitializeFinished(bool success);

+

+ virtual void initializeProxy() = 0;

+ virtual void handleProxyInitializeData(boost::shared_ptr<SafeByteArray> data) = 0;

+

+ const HostAddressPort& getServer() const {

+ return server_;

+ }

+

+ private:

+ bool connected_;

+ DomainNameResolver* resolver_;

+ ConnectionFactory* connectionFactory_;

+ TimerFactory* timerFactory_;

+ std::string proxyHost_;

+ int proxyPort_;

+ HostAddressPort server_;

+ Connector::ref connector_;

+ boost::shared_ptr<Connection> connection_;

+ };

+}

+

+

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

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

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

+ "ProxiedConnection.cpp",

+ "CachingDomainNameResolver.cpp",

+ "HostNameOrAddress.cpp",

+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":

+elif myenv["PLATFORM"] == "sunos" :

+ sourceList += [ "UnixProxyProvider.cpp" ]

+ sourceList += [ "SolarisNetworkEnvironment.cpp" ]

+ sourceList += [ "EnvironmentProxyProvider.cpp" ]

+if myenv["experimental_ft"] :

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

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

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

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

+/*

+ * Copyright (c) 2014 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+SOCKS5ProxiedConnection::SOCKS5ProxiedConnection(

+ DomainNameResolver* resolver,

+ ConnectionFactory* connectionFactory,

+ TimerFactory* timerFactory,

+ const std::string& proxyHost,

+ int proxyPort) :

+ ProxiedConnection(resolver, connectionFactory, timerFactory, proxyHost, proxyPort),

+ proxyState_(Initial) {

+void SOCKS5ProxiedConnection::initializeProxy() {

+ write(socksConnect);

+void SOCKS5ProxiedConnection::handleProxyInitializeData(boost::shared_ptr<SafeByteArray> data) {

+ boost::asio::ip::address rawAddress = getServer().getAddress().getRawAddress();

+

+ socksConnect.push_back(uc);

+ socksConnect.push_back(static_cast<unsigned char> ((getServer().getPort() >> 8) & 0xFF)); // highbyte of the port.

+ socksConnect.push_back(static_cast<unsigned char> (getServer().getPort() & 0xFF)); // lowbyte of the port.

+ write(socksConnect);

+ write(socksConnect);

+ setProxyInitializeFinished(true);

+ setProxyInitializeFinished(false);

+ setProxyInitializeFinished(true);

+ setProxyInitializeFinished(false);

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

+ class DomainNameResolver;

+ class TimerFactory;

+ class SOCKS5ProxiedConnection : public ProxiedConnection {

+ static ref create(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort) {

+ return ref(new SOCKS5ProxiedConnection(resolver, connectionFactory, timerFactory, proxyHost, proxyPort));

+ SOCKS5ProxiedConnection(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort);

+ virtual void initializeProxy();

+ virtual void handleProxyInitializeData(boost::shared_ptr<SafeByteArray> data);

+ Initial = 0,

+ ProxyAuthenticating,

+ ProxyConnecting

+SOCKS5ProxiedConnectionFactory::SOCKS5ProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort) : resolver_(resolver), connectionFactory_(connectionFactory), timerFactory_(timerFactory), proxyHost_(proxyHost), proxyPort_(proxyPort) {

+ return SOCKS5ProxiedConnection::create(resolver_, connectionFactory_, timerFactory_, proxyHost_, proxyPort_);

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

+ class DomainNameResolver;

+ class TimerFactory;

+

+ SOCKS5ProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort);

+ DomainNameResolver* resolver_;

+ TimerFactory* timerFactory_;

+ std::string proxyHost_;

+ int proxyPort_;

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+/*

+* Copyright (c) 2013-2014 Remko Tronçon and Kevin Smith

+* Licensed under the GNU General Public License v3.

+* See Documentation/Licenses/GPLv3.txt for more information.

+*/

+

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

+

+#include <string>

+#include <vector>

+#include <map>

+#include <boost/optional.hpp>

+

+#include <unistd.h>

+#include <stdlib.h>

+#include <errno.h>

+#include <string.h>

+#include <sys/sockio.h>

+#include <sys/socket.h>

+#include <sys/types.h>

+#include <net/if.h>

+

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

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

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

+

+/*

+ * Copyright (c) 2006 WIDE Project. All rights reserved.

+ *

+ * Redistribution and use in source and binary forms, with or without

+ * modification, are permitted provided that the following conditions

+ * are met:

+ * 1. Redistributions of source code must retain the above copyright

+ * notice, this list of conditions and the following disclaimer.

+ * 2. Redistributions in binary form must reproduce the above copyright

+ * notice, this list of conditions and the following disclaimer in the

+ * documentation and/or other materials provided with the distribution.

+ * 3. Neither the name of the project nor the names of its contributors

+ * may be used to endorse or promote products derived from this software

+ * without specific prior written permission.

+ *

+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND

+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

+ * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE

+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

+ * SUCH DAMAGE.

+ */

+

+#undef ifa_broadaddr

+#undef ifa_dstaddr

+struct ifaddrs {

+ struct ifaddrs *ifa_next; /* Pointer to next struct */

+ char *ifa_name; /* Interface name */

+ uint64_t ifa_flags; /* Interface flags */

+ struct sockaddr *ifa_addr; /* Interface address */

+ struct sockaddr *ifa_netmask; /* Interface netmask */

+ struct sockaddr *ifa_dstaddr; /* P2P interface destination */

+};

+#define ifa_broadaddr ifa_dstaddr

+

+static int

+get_lifreq(int fd, struct lifreq **ifr_ret)

+{

+ struct lifnum lifn;

+ struct lifconf lifc;

+ struct lifreq *lifrp;

+

+ lifn.lifn_family = AF_UNSPEC;

+ lifn.lifn_flags = 0;

+ if (ioctl(fd, SIOCGLIFNUM, &lifn) == -1)

+ lifn.lifn_count = 16;

+ else

+ lifn.lifn_count += 16;

+

+ for (;;) {

+ lifc.lifc_len = lifn.lifn_count * sizeof (*lifrp);

+ lifrp = (struct lifreq *) malloc(lifc.lifc_len);

+ if (lifrp == NULL)

+ return (-1);

+

+ lifc.lifc_family = AF_UNSPEC;

+ lifc.lifc_flags = 0;

+ lifc.lifc_buf = (char *)lifrp;

+ if (ioctl(fd, SIOCGLIFCONF, &lifc) == -1) {

+ free(lifrp);

+ if (errno == EINVAL) {

+ lifn.lifn_count <<= 1;

+ continue;

+ }

+ (void) close(fd);

+ return (-1);

+ }

+ if (lifc.lifc_len < (lifn.lifn_count - 1) * sizeof (*lifrp))

+ break;

+ free(lifrp);

+ lifn.lifn_count <<= 1;

+ }

+ (void) close(fd);

+

+ *ifr_ret = lifrp;

+

+ return (lifc.lifc_len / sizeof (*lifrp));

+}

+

+static size_t

+nbytes(const struct lifreq *lifrp, int nlif, size_t socklen)

+{

+ size_t len = 0;

+ size_t slen;

+

+ while (nlif > 0) {

+ slen = strlen(lifrp->lifr_name) + 1;

+ len += sizeof (struct ifaddrs) + ((slen + 3) & ~3);

+ len += 3 * socklen;

+ lifrp++;

+ nlif--;

+ }

+ return (len);

+}

+

+static struct sockaddr *

+addrcpy(struct sockaddr_storage *addr, char **bufp)

+{

+ char *buf = *bufp;

+ size_t len;

+

+ len = addr->ss_family == AF_INET ? sizeof (struct sockaddr_in) :

+ sizeof (struct sockaddr_in6);

+ (void) memcpy(buf, addr, len);

+ *bufp = buf + len;

+ return ((struct sockaddr *)buf);

+}

+

+static int

+populate(struct ifaddrs *ifa, int fd, struct lifreq *lifrp, int nlif, int af,

+ char **bufp)

+{

+ char *buf = *bufp;

+ size_t slen;

+

+ while (nlif > 0) {

+ ifa->ifa_next = (nlif > 1) ? ifa + 1 : NULL;

+ (void) strcpy(ifa->ifa_name = buf, lifrp->lifr_name);

+ slen = strlen(lifrp->lifr_name) + 1;

+ buf += (slen + 3) & ~3;

+ if (ioctl(fd, SIOCGLIFFLAGS, lifrp) == -1)

+ ifa->ifa_flags = 0;

+ else

+ ifa->ifa_flags = lifrp->lifr_flags;

+ if (ioctl(fd, SIOCGLIFADDR, lifrp) == -1)

+ ifa->ifa_addr = NULL;

+ else

+ ifa->ifa_addr = addrcpy(&lifrp->lifr_addr, &buf);

+ if (ioctl(fd, SIOCGLIFNETMASK, lifrp) == -1)

+ ifa->ifa_netmask = NULL;

+ else

+ ifa->ifa_netmask = addrcpy(&lifrp->lifr_addr, &buf);

+ if (ifa->ifa_flags & IFF_POINTOPOINT) {

+ if (ioctl(fd, SIOCGLIFDSTADDR, lifrp) == -1)

+ ifa->ifa_dstaddr = NULL;

+ else

+ ifa->ifa_dstaddr =

+ addrcpy(&lifrp->lifr_dstaddr, &buf);

+ } else if (ifa->ifa_flags & IFF_BROADCAST) {

+ if (ioctl(fd, SIOCGLIFBRDADDR, lifrp) == -1)

+ ifa->ifa_broadaddr = NULL;

+ else

+ ifa->ifa_broadaddr =

+ addrcpy(&lifrp->lifr_broadaddr, &buf);

+ } else {

+ ifa->ifa_dstaddr = NULL;

+ }

+

+ ifa++;

+ nlif--;

+ lifrp++;

+ }

+ *bufp = buf;

+ return (0);

+}

+

+static int

+getifaddrs(struct ifaddrs **ifap)

+{

+ int fd4, fd6;

+ int nif4, nif6 = 0;

+ struct lifreq *ifr4 = NULL;

+ struct lifreq *ifr6 = NULL;

+ struct ifaddrs *ifa = NULL;

+ char *buf;

+

+ if ((fd4 = socket(AF_INET, SOCK_DGRAM, 0)) == -1)

+ return (-1);

+ if ((fd6 = socket(AF_INET6, SOCK_DGRAM, 0)) == -1 &&

+ errno != EAFNOSUPPORT) {

+ (void) close(fd4);

+ return (-1);

+ }

+

+ if ((nif4 = get_lifreq(fd4, &ifr4)) == -1 ||

+ (fd6 != -1 && (nif6 = get_lifreq(fd6, &ifr6)) == -1))

+ goto failure;

+

+ if (nif4 == 0 && nif6 == 0) {

+ *ifap = NULL;

+ return (0);

+ }

+

+ ifa = (struct ifaddrs *) malloc(nbytes(ifr4, nif4, sizeof (struct sockaddr_in)) +

+ nbytes(ifr6, nif6, sizeof (struct sockaddr_in6)));

+ if (ifa == NULL)

+ goto failure;

+

+ buf = (char *)(ifa + nif4 + nif6);

+

+ if (populate(ifa, fd4, ifr4, nif4, AF_INET, &buf) == -1)

+ goto failure;

+ if (nif4 > 0 && nif6 > 0)

+ ifa[nif4 - 1].ifa_next = ifa + nif4;

+ if (populate(ifa + nif4, fd6, ifr6, nif6, AF_INET6, &buf) == -1)

+ goto failure;

+

+ return (0);

+

+failure:

+ free(ifa);

+ (void) close(fd4);

+ if (fd6 != -1)

+ (void) close(fd6);

+ free(ifr4);

+ free(ifr6);

+ return (-1);

+}

+

+static void

+freeifaddrs(struct ifaddrs *ifa)

+{

+ free(ifa);

+}

+

+/* End WIDE Project code */

+

+namespace Swift {

+

+std::vector<NetworkInterface> SolarisNetworkEnvironment::getNetworkInterfaces() const {

+ std::map<std::string, NetworkInterface> interfaces;

+

+ ifaddrs* addrs = 0;

+ int ret = getifaddrs(&addrs);

+ if (ret != 0) {

+ return std::vector<NetworkInterface>();

+ }

+

+ for (ifaddrs* a = addrs; a != 0; a = a->ifa_next) {

+ std::string name(a->ifa_name);

+ boost::optional<HostAddress> address;

+ if (a->ifa_addr->sa_family == PF_INET) {

+ sockaddr_in* sa = reinterpret_cast<sockaddr_in*>(a->ifa_addr);

+ address = HostAddress(reinterpret_cast<const unsigned char*>(&(sa->sin_addr)), 4);

+ }

+ else if (a->ifa_addr->sa_family == PF_INET6) {

+ sockaddr_in6* sa = reinterpret_cast<sockaddr_in6*>(a->ifa_addr);

+ address = HostAddress(reinterpret_cast<const unsigned char*>(&(sa->sin6_addr)), 16);

+ }

+ if (address) {

+ std::map<std::string, NetworkInterface>::iterator i = interfaces.insert(std::make_pair(name, NetworkInterface(name, a->ifa_flags & IFF_LOOPBACK))).first;

+ i->second.addAddress(*address);

+ }

+ }

+

+ freeifaddrs(addrs);

+

+ std::vector<NetworkInterface> result;

+ for (std::map<std::string,NetworkInterface>::const_iterator i = interfaces.begin(); i != interfaces.end(); ++i) {

+ result.push_back(i->second);

+ }

+ return result;

+}

+

+}

+/*

+ * Copyright (c) 2011 Tobias Markmann

+ * Licensed under the simplified BSD license.

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

+ */

+

+/*

+* Copyright (c) 2013-2014 Remko Tronçon and Kevin Smith

+* Licensed under the GNU General Public License v3.

+* See Documentation/Licenses/GPLv3.txt for more information.

+*/

+

+#pragma once

+

+#include <vector>

+

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

+

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

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

+

+namespace Swift {

+

+ class SolarisNetworkEnvironment : public NetworkEnvironment {

+ public:

+ std::vector<NetworkInterface> getNetworkInterfaces() const;

+ };

+

+}

+boost::shared_ptr<DomainNameServiceQuery> StaticDomainNameResolver::createServiceQuery(const std::string& serviceLookupPrefix, const std::string& domain) {

+ return boost::shared_ptr<DomainNameServiceQuery>(new ServiceQuery(serviceLookupPrefix + domain, this, eventLoop, owner));

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

+ class SWIFTEN_API StaticDomainNameResolver : public DomainNameResolver {

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

+ virtual void listen() {assert(false);}

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

+ class SWIFTEN_API Timer {

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

+ class SWIFTEN_API TimerFactory {

+/*

+ * 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/IDN/IDNConverter.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(IDNConverter* idnConverter, boost::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) : idnConverter(idnConverter), 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(error) << "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(error) << "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& serviceLookupPrefix, const std::string& domain) {

+ boost::optional<std::string> encodedDomain = idnConverter->getIDNAEncoded(domain);

+ std::string result;

+ if (encodedDomain) {

+ result = serviceLookupPrefix + *encodedDomain;

+ }

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

+}

+

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

+ return boost::make_shared<UnboundDomainNameAddressQuery>(this, ubContext, idnConverter->getIDNAEncoded(name).get_value_or(""));

+}

+

+}

+/*

+ * 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 IDNConverter;

+ class TimerFactory;

+

+ class UnboundDomainNameResolver;

+ class UnboundQuery;

+

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

+ public:

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

+ virtual ~UnboundDomainNameResolver();

+

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

+ 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:

+ IDNConverter* idnConverter;

+ boost::shared_ptr<EventOwner> eventOwner;

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

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

+ EventLoop* eventLoop;

+ ub_ctx* ubContext;

+ };

+

+}

+ path = "/http-bind";

+ unsigned long long rid = initialRID;

+ path = "/http-bind/";

+

+ testling->restartStream();

+ eventLoop->processEvents();

+ CPPUNIT_ASSERT_EQUAL(st(4), boshDataWritten.size());

+ CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());

+

+ response = "<body xmpp:version='1.0' xmlns:stream='http://etherx.jabber.org/streams' xmlns:xmpp='urn:xmpp:xbosh' inactivity='60' wait='60' polling='5' secure='true' hold='1' from='prosody.doomsong.co.uk' ver='1.6' sid='743da605-4c2e-4de1-afac-ac040dd4a940' requests='2' xmlns='http://jabber.org/protocol/httpbind'><stream:features><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'><required/></bind><session xmlns='urn:ietf:params:xml:ns:xmpp-session'><optional/></session><sm xmlns='urn:xmpp:sm:2'><optional/></sm></stream:features></body>";

+ readResponse(response, connectionFactory->connections[0]);

+ eventLoop->processEvents();

+ CPPUNIT_ASSERT_EQUAL(st(5), boshDataWritten.size()); /* Now we've authed (restarted) we should be keeping one query in flight so the server can reply to us at any time it wants. */

+ CPPUNIT_ASSERT_EQUAL(st(1), connectionFactory->connections.size());

+

+ send = "<body rid='2821988967416214' sid='cf663f6b94279d4f' xmlns='http://jabber.org/protocol/httpbind'><iq id='session-bind' type='set'><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'><resource>d5a9744036cd20a0</resource></bind></iq></body>";

+ testling->write(createSafeByteArray(send));

+ eventLoop->processEvents();

+ CPPUNIT_ASSERT_EQUAL(st(6), boshDataWritten.size());

+ CPPUNIT_ASSERT_EQUAL(st(2), connectionFactory->connections.size()); /* and as it keeps one in flight, it's needed to open a second to send these data */

+

+ unsigned long long initialRID;

+ connectionFactory->connections[0]->onDisconnected(boost::optional<Connection::Error>());

+ Connector::ref connector = Connector::create("wonderland.lit", 5280, boost::optional<std::string>(), resolver, connectionFactory, timerFactory);

+ BOSHConnection::ref c = BOSHConnection::create(URL("http", "wonderland.lit", 5280, "/http-bind"), connector, &parserFactory);

+ boost::shared_ptr<ChainedConnector> connector = boost::make_shared<ChainedConnector>("foo.com", -1, boost::optional<std::string>("_xmpp-client._tcp."), resolver, factories, timerFactory);

+ * Copyright (c) 2010-2014 Remko Tronçon

+ CPPUNIT_TEST(testConnect_NoServiceLookups);

+ CPPUNIT_TEST(testConnect_NoServiceLookups_DefaultPort);

+ //CPPUNIT_TEST(testConnect_TimeoutDuringResolve);

+ CPPUNIT_TEST(testConnect_TimeoutDuringConnectToOnlyCandidate);

+ CPPUNIT_TEST(testConnect_TimeoutDuringConnectToCandidateFallsBack);

+ void testConnect_NoServiceLookups() {

+ Connector::ref testling(createConnector(4321, boost::optional<std::string>()));

+ resolver->addXMPPClientService("foo.com", host1);

+ resolver->addXMPPClientService("foo.com", host2);

+ resolver->addAddress("foo.com", host3.getAddress());

+

+ testling->start();

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));

+ CPPUNIT_ASSERT(connections[0]);

+ CPPUNIT_ASSERT(host3.getAddress() == (*(connections[0]->hostAddressPort)).getAddress());

+ CPPUNIT_ASSERT(4321 == (*(connections[0]->hostAddressPort)).getPort());

+ CPPUNIT_ASSERT(!boost::dynamic_pointer_cast<DomainNameResolveError>(error));

+ }

+

+ void testConnect_NoServiceLookups_DefaultPort() {

+ Connector::ref testling(createConnector(-1, boost::optional<std::string>()));

+ resolver->addXMPPClientService("foo.com", host1);

+ resolver->addXMPPClientService("foo.com", host2);

+ resolver->addAddress("foo.com", host3.getAddress());

+

+ testling->start();

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));

+ CPPUNIT_ASSERT(connections[0]);

+ CPPUNIT_ASSERT(host3.getAddress() == (*(connections[0]->hostAddressPort)).getAddress());

+ CPPUNIT_ASSERT_EQUAL(5222, (*(connections[0]->hostAddressPort)).getPort());

+ CPPUNIT_ASSERT(!boost::dynamic_pointer_cast<DomainNameResolveError>(error));

+ }

+

+ /*void testConnect_TimeoutDuringResolve() {

+ }*/

+ void testConnect_TimeoutDuringConnectToOnlyCandidate() {

+ void testConnect_TimeoutDuringConnectToCandidateFallsBack() {

+ Connector::ref testling(createConnector());

+ testling->setTimeoutMilliseconds(10);

+

+ resolver->addXMPPClientService("foo.com", "host-foo.com", 1234);

+ HostAddress address1("1.1.1.1");

+ resolver->addAddress("host-foo.com", address1);

+ HostAddress address2("2.2.2.2");

+ resolver->addAddress("host-foo.com", address2);

+

+ connectionFactory->isResponsive = false;

+ testling->start();

+ eventLoop->processEvents();

+ connectionFactory->isResponsive = true;

+ timerFactory->setTime(10);

+ eventLoop->processEvents();

+

+ CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(connections.size()));

+ CPPUNIT_ASSERT(connections[0]);

+ CPPUNIT_ASSERT(HostAddressPort(address2, 1234) == *(connections[0]->hostAddressPort));

+ CPPUNIT_ASSERT(!boost::dynamic_pointer_cast<DomainNameResolveError>(error));

+ }

+

+

+ Connector::ref createConnector(int port = -1, boost::optional<std::string> serviceLookupPrefix = boost::optional<std::string>("_xmpp-client._tcp.")) {

+ Connector::ref connector = Connector::create("foo.com", port, serviceLookupPrefix, resolver, connectionFactory, timerFactory);

+ boost::shared_ptr<HTTPConnectProxiedConnection> c = HTTPConnectProxiedConnection::create(resolver, connectionFactory, timerFactory, proxyHost, proxyPort, "", "");

+

+#ifndef __ANDROID__

+#endif

+#ifndef __ANDROID__

+ if (address && !address->isLocalhost()) {

+#endif

+ if (hostAddress && !hostAddress->isLocalhost()) {

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

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

+ class SWIFTEN_API WindowsNetworkEnvironment : public NetworkEnvironment {

+

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

+ class SWIFTEN_API WindowsProxyProvider : public ProxyProvider {