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

}

header << "\r\n"

<< "Content-Type: text/xml; charset=utf-8\r\n"

<< "Content-Length: " << size << "\r\n\r\n";

<< " rid='" << rid << "'"

<< " ver='1.6'"

<< " wait='60'" /* FIXME: we probably want this configurable*/

<< " xml:lang='en'"

<< " xmlns:xmpp='urn:xmpp:bosh'"

<< " xmpp:version='1.0'"

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

}

header << "\r\n"

<< "Content-Type: text/xml; charset=utf-8\r\n"

<< "Content-Length: " << contentString.size() << "\r\n\r\n"

<< contentString;

waitingForStartResponse_ = false;

sid_ = parser.getBody()->attributes.getAttribute("sid");

std::string requestsString = parser.getBody()->attributes.getAttribute("requests");

if (!requestsString.empty()) {

try {

requests = boost::lexical_cast<size_t>(requestsString);

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

}

destroyConnection(connection);

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

handleSessionTerminated(BOSHError::ref());

}

else {

/* We might have just freed up a connection slot to send with */

tryToSendQueuedData();

#include <boost/asio/placeholders.hpp>

#include <boost/asio/write.hpp>

#include <boost/smart_ptr/make_shared.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/Algorithm.h>

void BoostConnection::connect(const HostAddressPort& addressPort) {

boost::asio::ip::tcp::endpoint endpoint(

socket_.async_connect(

endpoint,

boost::bind(&BoostConnection::handleConnectFinished, shared_from_this(), boost::asio::placeholders::error));

#include <boost/bind.hpp>

#include <boost/system/system_error.hpp>

#include <boost/asio/placeholders.hpp>

#include <Swiften/EventLoop/EventLoop.h>

}

void BoostConnectionServer::start() {

try {

assert(!acceptor_);

if (address_.isValid()) {

acceptor_ = new boost::asio::ip::tcp::acceptor(

*ioService_,

}

else {

acceptor_ = new boost::asio::ip::tcp::acceptor(

*ioService_,

}

acceptNextConnection();

}

catch (const boost::system::system_error& e) {

if (e.code() == boost::asio::error::address_in_use) {

}

else {

}

}

}

#include <Swiften/Network/BoostConnection.h>

#include <Swiften/Network/ConnectionServer.h>

#include <Swiften/EventLoop/EventOwner.h>

namespace Swift {

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

public:

typedef boost::shared_ptr<BoostConnectionServer> ref;

static ref create(int port, boost::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) {

return ref(new BoostConnectionServer(port, ioService, eventLoop));

}

return ref(new BoostConnectionServer(address, port, ioService, eventLoop));

}

virtual void start();

virtual void stop();

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Network/BoostNetworkFactories.h>

#include <Swiften/Network/BoostTimerFactory.h>

#include <Swiften/Network/BoostConnectionFactory.h>

#include <Swiften/Network/BoostConnectionServerFactory.h>

#include <Swiften/Network/PlatformNATTraversalWorker.h>

#include <Swiften/Parser/PlatformXMLParserFactory.h>

#include <Swiften/Network/NullNATTraverser.h>

#include <Swiften/TLS/PlatformTLSFactories.h>

#include <Swiften/Network/PlatformProxyProvider.h>

namespace Swift {

BoostNetworkFactories::BoostNetworkFactories(EventLoop* eventLoop) : eventLoop(eventLoop){

timerFactory = new BoostTimerFactory(ioServiceThread.getIOService(), eventLoop);

connectionFactory = new BoostConnectionFactory(ioServiceThread.getIOService(), eventLoop);

connectionServerFactory = new BoostConnectionServerFactory(ioServiceThread.getIOService(), eventLoop);

#ifdef SWIFT_EXPERIMENTAL_FT

natTraverser = new PlatformNATTraversalWorker(eventLoop);

#else

natTraverser = new NullNATTraverser(eventLoop);

#endif

xmlParserFactory = new PlatformXMLParserFactory();

tlsFactories = new PlatformTLSFactories();

proxyProvider = new PlatformProxyProvider();

}

BoostNetworkFactories::~BoostNetworkFactories() {

delete proxyProvider;

delete tlsFactories;

delete xmlParserFactory;

delete natTraverser;

delete connectionServerFactory;

delete connectionFactory;

delete timerFactory;

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Network/NetworkFactories.h>

#include <Swiften/Network/BoostIOServiceThread.h>

BoostNetworkFactories(EventLoop* eventLoop);

~BoostNetworkFactories();

return timerFactory;

}

return connectionFactory;

}

return &ioServiceThread;

}

return domainNameResolver;

}

return connectionServerFactory;

}

return natTraverser;

}

return xmlParserFactory;

}

return proxyProvider;

}

return eventLoop;

}

private:

BoostIOServiceThread ioServiceThread;

TimerFactory* timerFactory;

DomainNameResolver* domainNameResolver;

ConnectionServerFactory* connectionServerFactory;

NATTraverser* natTraverser;

XMLParserFactory* xmlParserFactory;

PlatformTLSFactories* tlsFactories;

ProxyProvider* proxyProvider;

EventLoop* eventLoop;

};

}

boost::shared_ptr<Connector> currentConnector;

boost::shared_ptr<Error> lastError;

};

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/HostAddressPort.h>

namespace Swift {

class SWIFTEN_API ConnectionServer {

public:

virtual ~ConnectionServer();

virtual HostAddressPort getAddressPort() const = 0;

virtual void start() = 0;

virtual void stop() = 0;

handleConnectionConnectFinished(true);

}

boost::shared_ptr<Connection> currentConnection;

bool foundSomeDNS;

};

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Base/RandomGenerator.h>

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

using namespace Swift;

namespace {

struct ResultPriorityComparator {

return a.priority < b.priority;

}

};

}

namespace Swift {

void DomainNameServiceQuery::sortResults(std::vector<DomainNameServiceQuery::Result>& queries, RandomGenerator& generator) {

ResultPriorityComparator comparator;

std::vector<DomainNameServiceQuery::Result>::iterator i = queries.begin();

while (i != queries.end()) {

std::vector<DomainNameServiceQuery::Result>::iterator next = std::upper_bound(i, queries.end(), *i, comparator);

if (std::distance(i, next) > 1) {

std::vector<int> weights;

std::vector<int> cumulativeWeights;

int randomNumber = generator.generateRandomInteger(cumulativeWeights.back());

std::swap(i[j], i[j + selectedIndex]);

std::swap(weights.begin()[j], weights.begin()[j + selectedIndex]);

}

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Base/foreach.h>

#include <string>

namespace Swift {

HostAddress::HostAddress() {

}

}

assert(length == 4 || length == 16);

if (length == 4) {

boost::asio::ip::address_v4::bytes_type data;

data[i] = address[i];

}

address_ = boost::asio::ip::address(boost::asio::ip::address_v4(data));

}

else {

boost::asio::ip::address_v6::bytes_type data;

data[i] = address[i];

}

address_ = boost::asio::ip::address(boost::asio::ip::address_v6(data));

return address_;

}

}

/*

* Licensed under the GNU General Public License v3.

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

*/

public:

HostAddress();

HostAddress(const std::string&);

HostAddress(const boost::asio::ip::address& address);

std::string toString() const;

}

bool isValid() const;

private:

boost::asio::ip::address address_;

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

*/

#include <Swiften/Base/Platform.h>

#include <Swiften/Network/MacOSXProxyProvider.h>

#include <stdio.h>

#include <stdlib.h>

#include <iostream>

#include <utility>

#ifndef SWIFTEN_PLATFORM_IPHONE

#include <SystemConfiguration/SystemConfiguration.h>

#endif

using namespace Swift;

#ifndef SWIFTEN_PLATFORM_IPHONE

const int i = 0;

CFNumberRef zero = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &i);

CFComparisonResult result = CFNumberCompare(numberValue, zero, NULL);

if(result != kCFCompareEqualTo) {

int port = 0;

// length must be +1 for the ending zero; and the Docu of CFStringGetCString tells it like

// if the string is toby the length must be at least 5.

CFIndex length = CFStringGetLength(stringValue) + 1;

if(CFStringGetCString(stringValue, &buffer[0], length, kCFStringEncodingMacRoman)) {

for(std::vector<char>::iterator iter = buffer.begin(); iter != buffer.end(); ++iter) {

host += *iter;

CFDictionaryRef proxies = SCDynamicStoreCopyProxies(NULL);

if(proxies != NULL) {

result = getFromDictionary(proxies, kSCPropNetProxiesHTTPEnable, kSCPropNetProxiesHTTPProxy, kSCPropNetProxiesHTTPPort);

}

#endif

return result;

CFDictionaryRef proxies = SCDynamicStoreCopyProxies(NULL);

if(proxies != NULL) {

result = getFromDictionary(proxies, kSCPropNetProxiesSOCKSEnable, kSCPropNetProxiesSOCKSProxy, kSCPropNetProxiesSOCKSPort);

}

#endif

return result;

std::string localPort = boost::lexical_cast<std::string>(mapping.getLocalPort());

std::string leaseSeconds = boost::lexical_cast<std::string>(mapping.getLeaseInSeconds());

if (ret == UPNPCOMMAND_SUCCESS) {

return mapping;

}

#include <Swiften/Network/NATPMPInterface.h>

#include <boost/smart_ptr/make_shared.hpp>

#include <Swiften/Base/Log.h>

boost::optional<NATPortMapping> NATPMPInterface::addPortForward(int localPort, int publicPort) {

NATPortMapping mapping(localPort, publicPort, NATPortMapping::TCP);

}

int r = 0;

} while(r == NATPMP_TRYAGAIN);

if (r == 0) {

return result;

}

else {

}

bool NATPMPInterface::removePortForward(const NATPortMapping& mapping) {

SWIFT_LOG(debug) << "Failed to send NAT-PMP remove forwarding request!" << std::endl;

return false;

}

public:

enum Protocol {

TCP,

};

}

public:

virtual ~NATTraversalForwardPortRequest();

boost::signal<void (boost::optional<NATPortMapping>)> onResult;

};

public:

virtual ~NATTraversalGetPublicIPRequest();

boost::signal<void (boost::optional<HostAddress>)> onResult;

};

struct PortMapping {

enum Protocol {

TCP,

};

unsigned int publicPort;

public:

virtual ~NATTraversalRemovePortForwardingRequest();

boost::signal<void (boost::optional<bool> /* failure */)> onResult;

};

/*

* Licensed under the GNU General Public License v3.

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

*/

class CertificateFactory;

class ProxyProvider;

class EventLoop;

/**

* An interface collecting network factories.

virtual DomainNameResolver* getDomainNameResolver() const = 0;

virtual ConnectionServerFactory* getConnectionServerFactory() const = 0;

virtual NATTraverser* getNATTraverser() const = 0;

virtual XMLParserFactory* getXMLParserFactory() const = 0;

virtual TLSContextFactory* getTLSContextFactory() const = 0;

virtual ProxyProvider* getProxyProvider() const = 0;

virtual EventLoop* getEventLoop() const = 0;

};

}

NullNATTraversalGetPublicIPRequest(EventLoop* eventLoop) : eventLoop(eventLoop) {

}

eventLoop->postEvent(boost::bind(boost::ref(onResult), boost::optional<HostAddress>()));

}

private:

EventLoop* eventLoop;

};

NullNATTraversalForwardPortRequest(EventLoop* eventLoop) : eventLoop(eventLoop) {

}

eventLoop->postEvent(boost::bind(boost::ref(onResult), boost::optional<NATPortMapping>()));

}

private:

EventLoop* eventLoop;

};

NullNATTraversalRemovePortForwardingRequest(EventLoop* eventLoop) : eventLoop(eventLoop) {

}

eventLoop->postEvent(boost::bind(boost::ref(onResult), boost::optional<bool>(true)));

}

private:

EventLoop* eventLoop;

};

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <algorithm>

#include <string>

#include <Swiften/Network/HostAddress.h>

#include <Swiften/EventLoop/EventLoop.h>

#include <Swiften/Network/HostAddressPort.h>

namespace Swift {

thread = new boost::thread(boost::bind(&PlatformDomainNameResolver::run, this));

}

}

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

}

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

}

void PlatformDomainNameResolver::run() {

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Network/DomainNameAddressQuery.h>

namespace Swift {

class EventLoop;

class SWIFTEN_API PlatformDomainNameResolver : public DomainNameResolver {

public:

~PlatformDomainNameResolver();

virtual DomainNameServiceQuery::ref createServiceQuery(const std::string& name);

private:

friend class PlatformDomainNameServiceQuery;

friend class PlatformDomainNameAddressQuery;

EventLoop* eventLoop;

bool stopRequested;

boost::thread* thread;

#include <Swiften/Base/Platform.h>

#include <stdlib.h>

#ifdef SWIFTEN_PLATFORM_WINDOWS

#undef UNICODE

#include <windows.h>

emitError();

return;

}

currentEntry += 2;

// Weight

emitError();

return;

}

currentEntry += 2;

// Port

emitError();

return;

}

currentEntry += 2;

// Hostname

/*

* 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/enable_shared_from_this.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Network/NATTraversalGetPublicIPRequest.h>

#include <Swiften/Network/NATTraversalForwardPortRequest.h>

#include <Swiften/Network/NATTraversalRemovePortForwardingRequest.h>

#include <Swiften/Network/NATPMPInterface.h>

#include <Swiften/Network/MiniUPnPInterface.h>

namespace Swift {

PlatformNATTraversalGetPublicIPRequest(PlatformNATTraversalWorker* worker) : PlatformNATTraversalRequest(worker) {

}

doRun();

}

virtual void runBlocking() {

onResult(getNATTraversalInterface()->getPublicIP());

}

PlatformNATTraversalForwardPortRequest(PlatformNATTraversalWorker* worker, unsigned int localIP, unsigned int publicIP) : PlatformNATTraversalRequest(worker), localIP(localIP), publicIP(publicIP) {

}

doRun();

}

virtual void runBlocking() {

}

private:

PlatformNATTraversalRemovePortForwardingRequest(PlatformNATTraversalWorker* worker, const NATPortMapping& mapping) : PlatformNATTraversalRequest(worker), mapping(mapping) {

}

doRun();

}

virtual void runBlocking() {

onResult(getNATTraversalInterface()->removePortForward(mapping));

}

PlatformNATTraversalWorker::PlatformNATTraversalWorker(EventLoop* eventLoop) : eventLoop(eventLoop), stopRequested(false), natPMPSupported(boost::logic::indeterminate), natPMPInterface(NULL), miniUPnPSupported(boost::logic::indeterminate), miniUPnPInterface(NULL) {

nullNATTraversalInterface = new NullNATTraversalInterface();

}

PlatformNATTraversalWorker::~PlatformNATTraversalWorker() {

addRequestToQueue(boost::shared_ptr<PlatformNATTraversalRequest>());

thread->join();

delete thread;

delete natPMPInterface;

delete miniUPnPInterface;

delete nullNATTraversalInterface;

}

NATTraversalInterface* PlatformNATTraversalWorker::getNATTraversalInterface() const {

if (boost::logic::indeterminate(miniUPnPSupported)) {

miniUPnPInterface = new MiniUPnPInterface();

miniUPnPSupported = miniUPnPInterface->isAvailable();

if (miniUPnPSupported) {

return miniUPnPInterface;

}

if (boost::logic::indeterminate(natPMPSupported)) {

natPMPInterface = new NATPMPInterface();

natPMPSupported = natPMPInterface->isAvailable();

if (natPMPSupported) {

return natPMPInterface;

}

return nullNATTraversalInterface;

}

return boost::make_shared<PlatformNATTraversalRemovePortForwardingRequest>(this, mapping);

}

while (!stopRequested) {

PlatformNATTraversalRequest::ref request;

{

}

}

void PlatformNATTraversalWorker::addRequestToQueue(PlatformNATTraversalRequest::ref request) {

{

boost::lock_guard<boost::mutex> lock(queueMutex);

private:

NATTraversalInterface* getNATTraversalInterface() const;

void addRequestToQueue(boost::shared_ptr<PlatformNATTraversalRequest>);

private:

EventLoop* eventLoop;

#pragma once

#include <map>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/Base/String.h>

myenv = swiften_env.Clone()

sourceList = [

"ProxiedConnection.cpp",

"HTTPConnectProxiedConnection.cpp",

"DomainNameResolver.cpp",

"DomainNameAddressQuery.cpp",

"DomainNameServiceQuery.cpp",

"StaticDomainNameResolver.cpp",

"HostAddress.cpp",

"HostAddressPort.cpp",

"NATTraversalRemovePortForwardingRequest.cpp",

"NATTraversalInterface.cpp",

]

myenv.Append(FRAMEWORKS = ["CoreServices", "SystemConfiguration"])

sourceList += [ "MacOSXProxyProvider.cpp" ]

sourceList += [ "UnixNetworkEnvironment.cpp" ]

objects = myenv.SwiftenObject(sourceList)

# LibNATPMP classes

# LibMINIUPnP classes

objects += myenv.SwiftenObject([

"PlatformNATTraversalWorker.cpp",

])

else {

uc = rawAddress.to_v6().to_bytes()[s]; // the address.

}

}

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

private:

enum {

ProxyAuthenticating = 0,

} proxyState_;

};

}

TLSConnection(Connection::ref connection, TLSContextFactory* tlsFactory);

virtual ~TLSConnection();

virtual void connect(const HostAddressPort& address);

virtual void disconnect();

virtual void write(const SafeByteArray& data);

void testConnectionCount_ThreeWritesTwoReads() {

boost::shared_ptr<MockConnection> c0;

boost::shared_ptr<MockConnection> c1;

PoolRef testling = createTestling();

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

std::string port;

std::string sid;

std::string initial;

int sessionStarted;

int sessionTerminated;

#include <sys/socket.h>

#include <arpa/inet.h>

#include <net/if.h>

#include <ifaddrs.h>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Network/HostAddress.h>

std::vector<NetworkInterface> UnixNetworkEnvironment::getNetworkInterfaces() const {

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

ifaddrs* addrs = 0;

int ret = getifaddrs(&addrs);

if (ret != 0) {

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

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

}

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);

sockaddr_in6* sa = reinterpret_cast<sockaddr_in6*>(address->Address.lpSockaddr);

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

}

std::map<std::string, NetworkInterface>::iterator i = interfaces.insert(std::make_pair(name, NetworkInterface(name, false))).first;

i->second.addAddress(*hostAddress);

}