namespace Swift {

memoryStorages = new MemoryStorages();

softwareVersionResponder = new SoftwareVersionResponder(getIQRouter());

* this is NULL,

* all data will be stored in memory (and be lost on shutdown)

*/

~Client();

namespace Swift {

stanzaChannel_ = new ClientSessionStanzaChannel();

stanzaChannel_->onMessageReceived.connect(boost::ref(onMessageReceived));

stanzaChannel_->onPresenceReceived.connect(boost::ref(onPresenceReceived));

stanzaChannel_->onAvailableChanged.connect(boost::bind(&CoreClient::handleStanzaChannelAvailableChanged, this, _1));

iqRouter_ = new IQRouter(stanzaChannel_);

tlsLayerFactory_ = new PlatformTLSLayerFactory();

}

class TimerFactory;

class ClientSession;

class BasicSessionStream;

/**

* The central class for communicating with an XMPP server.

public:

/**

* Constructs a client for the given JID with the given password.

*/

~CoreClient();

void setCertificate(const String& certificate);

PlatformDomainNameResolver resolver_;

JID jid_;

String password_;

ClientSessionStanzaChannel* stanzaChannel_;

IQRouter* iqRouter_;

Connector::ref connector_;

namespace Swift {

softwareVersionResponder = new SoftwareVersionResponder(getIQRouter());

softwareVersionResponder->start();

}

*/

class Component : public CoreComponent {

public:

~Component();

/**

namespace Swift {

stanzaChannel_ = new ComponentSessionStanzaChannel();

stanzaChannel_->onMessageReceived.connect(boost::ref(onMessageReceived));

stanzaChannel_->onPresenceReceived.connect(boost::ref(onPresenceReceived));

iqRouter_ = new IQRouter(stanzaChannel_);

iqRouter_->setFrom(jid);

tlsLayerFactory_ = new NullTLSLayerFactory();

}

*/

class CoreComponent {

public:

~CoreComponent();

void connect(const String& host, int port);

void handleDataWritten(const String&);

private:

PlatformDomainNameResolver resolver_;

JID jid_;

String secret_;

#include "Swiften/Network/HostAddressPort.h"

#include "Swiften/Network/StaticDomainNameResolver.h"

#include "Swiften/Network/DummyTimerFactory.h"

#include "Swiften/EventLoop/DummyEventLoop.h"

using namespace Swift;

void setUp() {

eventLoop = new DummyEventLoop();

timerFactory = new DummyTimerFactory();

}

struct MockConnection : public Connection {

public:

void listen() { assert(false); }

void connect(const HostAddressPort& address) {

hostAddressPort = address;

if (isResponsive) {

bool fail = std::find(failingPorts.begin(), failingPorts.end(), address) != failingPorts.end();

}

}

void write(const ByteArray&) { assert(false); }

HostAddressPort getLocalAddress() const { return HostAddressPort(); }

boost::optional<HostAddressPort> hostAddressPort;

std::vector<HostAddressPort> failingPorts;

bool isResponsive;

};

struct MockConnectionFactory : public ConnectionFactory {

}

boost::shared_ptr<Connection> createConnection() {

}

bool isResponsive;

std::vector<HostAddressPort> failingPorts;

};

#include <boost/bind.hpp>

#include <iostream>

namespace Swift {

EventLoop::EventLoop() : nextEventID_(0), handlingEvents_(false) {

}

EventLoop::~EventLoop() {

}

void EventLoop::handleEvent(const Event& event) {

sources = [

"EventLoop.cpp",

"EventOwner.cpp",

"SimpleEventLoop.cpp",

]

#include "Swiften/Client/Client.h"

#include "Swiften/Network/BoostTimer.h"

#include "Swiften/Client/ClientXMLTracer.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include "Swiften/Network/BoostIOServiceThread.h"

connectHost = argv[argi++];

}

char* timeoutChar = argv[argi++];

int timeout = atoi(timeoutChar);

timeout = (timeout ? timeout : 30) * 1000;

}

{

timer->onTick.connect(boost::bind(&SimpleEventLoop::stop, &eventLoop));

timer->start();

}

SimpleEventLoop eventLoop;

boost::shared_ptr<DNSSDQuerier> querier = factory.createQuerier();

querier->start();

#include "Swiften/Client/Client.h"

#include "Swiften/Network/BoostTimer.h"

#include "Swiften/Client/ClientXMLTracer.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include "Swiften/Network/MainBoostIOServiceThread.h"

class FileSender {

public:

FileSender(const JID& jid, const String& password, const JID& recipient, const boost::filesystem::path& file, int port) : jid(jid), password(password), recipient(recipient), file(file), transfer(NULL) {

socksBytestreamServer = new SOCKS5BytestreamServer(connectionServer);

client->onConnected.connect(boost::bind(&FileSender::handleConnected, this));

client->onError.connect(boost::bind(&FileSender::handleError, this, _1));

//tracer = new ClientXMLTracer(client);

#include "Swiften/Client/Client.h"

#include "Swiften/Network/BoostTimer.h"

#include "Swiften/Client/ClientXMLTracer.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include "Swiften/Network/BoostIOServiceThread.h"

connectHost = argv[argi++];

}

recipient = JID(argv[argi++]);

messageBody = std::string(argv[argi++]);

}

{

timer->onTick.connect(boost::bind(&SimpleEventLoop::stop, &eventLoop));

timer->start();

void setUp() {

receivedDataChunks = 0;

eventLoop = new DummyEventLoop();

connection->onDataSent.connect(boost::bind(&SOCKS5BytestreamServerSessionTest::handleDataWritten, this, _1));

stream1 = boost::shared_ptr<ByteArrayReadBytestream>(new ByteArrayReadBytestream(ByteArray("abcdefg")));

}

#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiQuery.h"

#include "Swiften/LinkLocal/DNSSD/DNSSDBrowseQuery.h"

namespace Swift {

class AvahiQuerier;

browser = avahi_service_browser_new(querier->getClient(), AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, "_presence._tcp", NULL, static_cast<AvahiLookupFlags>(0), &handleServiceDiscoveredStatic, this);

if (!browser) {

std::cout << "Error" << std::endl;

}

avahi_threaded_poll_unlock(querier->getThreadedPoll());

}

switch (event) {

case AVAHI_BROWSER_FAILURE:

std::cout << "Service browse error" << std::endl;

break;

case AVAHI_BROWSER_NEW: {

DNSSDServiceID service(name, domain, type, interfaceIndex);

std::cout << "Service discovered " << name << " " << domain << " " << type << " " << interfaceIndex << std::endl;

break;

}

case AVAHI_BROWSER_REMOVE: {

std::cout << "Service went away " << name << " " << domain << " " << type << " " << interfaceIndex << std::endl;

DNSSDServiceID service(name, domain, type, interfaceIndex);

break;

}

case AVAHI_BROWSER_ALL_FOR_NOW:

#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiQuery.h"

#include "Swiften/LinkLocal/DNSSD/DNSSDRegisterQuery.h"

#include "Swiften/Base/ByteArray.h"

namespace Swift {

class AvahiQuerier;

group = avahi_entry_group_new(querier->getClient(), handleEntryGroupChange, this);

if (!group) {

std::cout << "Error ceating entry group" << std::endl;

}

}

int result = avahi_entry_group_add_service_strlst(group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, static_cast<AvahiPublishFlags>(0), name.getUTF8Data(), "_presence._tcp", NULL, NULL, port, txtList);

if (result < 0) {

std::cout << "Error registering service: " << avahi_strerror(result) << std::endl;

}

result = avahi_entry_group_commit(group);

if (result < 0) {

switch (state) {

case AVAHI_ENTRY_GROUP_ESTABLISHED :

// Domain is a hack!

std::cout << "Entry group established" << std::endl;

break;

case AVAHI_ENTRY_GROUP_COLLISION : {

if (result != kDNSServiceErr_NoError) {

sdRef = NULL;

}*/

}

}

void handleServiceRegistered(DNSServiceErrorType errorCode, const char *name, const char *regtype, const char *domain) {

if (errorCode != kDNSServiceErr_NoError) {

}

else {

}

#include "Swiften/Base/String.h"

#include "Swiften/LinkLocal/DNSSD/Avahi/AvahiQuery.h"

#include "Swiften/LinkLocal/DNSSD/DNSSDResolveHostnameQuery.h"

#include "Swiften/Network/HostAddress.h"

#include <netinet/in.h>

}

void run() {

}

void finish() {

#include "Swiften/LinkLocal/DNSSD/DNSSDResolveServiceQuery.h"

#include "Swiften/LinkLocal/LinkLocalServiceInfo.h"

#include "Swiften/Base/ByteArray.h"

namespace Swift {

class AvahiQuerier;

resolver = avahi_service_resolver_new(querier->getClient(), service.getNetworkInterfaceID(), AVAHI_PROTO_UNSPEC, service.getName().getUTF8Data(), service.getType().getUTF8Data(), service.getDomain().getUTF8Data(), AVAHI_PROTO_UNSPEC, static_cast<AvahiLookupFlags>(0), handleServiceResolvedStatic, this);

if (!resolver) {

std::cout << "Error starting resolver" << std::endl;

}

avahi_threaded_poll_unlock(querier->getThreadedPoll());

}

switch(event) {

case AVAHI_RESOLVER_FAILURE:

std::cout << "Resolve error " << avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(resolver))) << std::endl;

break;

case AVAHI_RESOLVER_FOUND: {

std::cout << "Success" << std::endl;

// FIXME: Probably not accurate

String fullname = String(name) + "." + String(type) + "." + String(domain) + ".";

std::cout << "Result: " << fullname << "->" << String(a) << ":" << port << std::endl;

boost::bind(

boost::ref(onServiceResolved),

Result(fullname, String(a), port, txtRecord)),

#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuery.h"

#include "Swiften/LinkLocal/DNSSD/DNSSDBrowseQuery.h"

namespace Swift {

class BonjourQuerier;

class BonjourBrowseQuery : public DNSSDBrowseQuery, public BonjourQuery {

public:

DNSServiceErrorType result = DNSServiceBrowse(

&sdRef, 0, 0, "_presence._tcp", 0,

&BonjourBrowseQuery::handleServiceDiscoveredStatic, this);

void startBrowsing() {

if (!sdRef) {

}

else {

run();

void handleServiceDiscovered(DNSServiceFlags flags, uint32_t interfaceIndex, DNSServiceErrorType errorCode, const char *name, const char *type, const char *domain) {

if (errorCode != kDNSServiceErr_NoError) {

}

else {

//std::cout << "Discovered service: name:" << name << " domain:" << domain << " type: " << type << std::endl;

DNSSDServiceID service(name, domain, type, interfaceIndex);

if (flags & kDNSServiceFlagsAdd) {

}

else {

}

}

}

namespace Swift {

int fds[2];

int result = pipe(fds);

assert(result == 0);

}

boost::shared_ptr<DNSSDBrowseQuery> BonjourQuerier::createBrowseQuery() {

}

boost::shared_ptr<DNSSDRegisterQuery> BonjourQuerier::createRegisterQuery(const String& name, int port, const ByteArray& info) {

}

boost::shared_ptr<DNSSDResolveServiceQuery> BonjourQuerier::createResolveServiceQuery(const DNSSDServiceID& service) {

}

boost::shared_ptr<DNSSDResolveHostnameQuery> BonjourQuerier::createResolveHostnameQuery(const String& hostname, int interfaceIndex) {

}

void BonjourQuerier::addRunningQuery(boost::shared_ptr<BonjourQuery> query) {

public DNSSDQuerier,

public boost::enable_shared_from_this<BonjourQuerier> {

public:

~BonjourQuerier();

boost::shared_ptr<DNSSDBrowseQuery> createBrowseQuery();

void run();

private:

bool stopRequested;

boost::thread* thread;

boost::mutex runningQueriesMutex;

namespace Swift {

}

BonjourQuery::~BonjourQuery() {

namespace Swift {

class BonjourQuerier;

class BonjourQuery :

public EventOwner,

public boost::enable_shared_from_this<BonjourQuery> {

public:

virtual ~BonjourQuery();

void processResult();

void finish();

protected:

boost::shared_ptr<BonjourQuerier> querier;

mutable boost::mutex sdRefMutex;

DNSServiceRef sdRef;

#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuery.h"

#include "Swiften/LinkLocal/DNSSD/DNSSDRegisterQuery.h"

#include "Swiften/Base/ByteArray.h"

namespace Swift {

class BonjourQuerier;

class BonjourRegisterQuery : public DNSSDRegisterQuery, public BonjourQuery {

public:

DNSServiceErrorType result = DNSServiceRegister(

&sdRef, 0, 0, name.getUTF8Data(), "_presence._tcp", NULL, NULL, port,

txtRecord.getSize(), txtRecord.getData(),

run();

}

else {

}

}

void handleServiceRegistered(DNSServiceErrorType errorCode, const char *name, const char *regtype, const char *domain) {

if (errorCode != kDNSServiceErr_NoError) {

}

else {

}

}

};

#include "Swiften/Base/String.h"

#include "Swiften/LinkLocal/DNSSD/Bonjour/BonjourQuery.h"

#include "Swiften/LinkLocal/DNSSD/DNSSDResolveHostnameQuery.h"

#include "Swiften/Network/HostAddress.h"

#include <netinet/in.h>

class BonjourResolveHostnameQuery : public DNSSDResolveHostnameQuery, public BonjourQuery {

public:

DNSServiceErrorType result = DNSServiceGetAddrInfo(

&sdRef, 0, interfaceIndex, kDNSServiceProtocol_IPv4,

hostname.getUTF8Data(),

BonjourQuery::run();

}

else {

}

}

void handleHostnameResolved(DNSServiceErrorType errorCode, const struct sockaddr *rawAddress) {

if (errorCode) {

boost::bind(boost::ref(onHostnameResolved),

boost::optional<HostAddress>()),

shared_from_this());

assert(rawAddress->sa_family == AF_INET);

const sockaddr_in* sa = reinterpret_cast<const sockaddr_in*>(rawAddress);

uint32_t address = ntohl(sa->sin_addr.s_addr);

boost::ref(onHostnameResolved),

HostAddress(reinterpret_cast<unsigned char*>(&address), 4)),

shared_from_this());

#include "Swiften/LinkLocal/DNSSD/DNSSDResolveServiceQuery.h"

#include "Swiften/LinkLocal/LinkLocalServiceInfo.h"

#include "Swiften/Base/ByteArray.h"

namespace Swift {

class BonjourQuerier;

class BonjourResolveServiceQuery : public DNSSDResolveServiceQuery, public BonjourQuery {

public:

DNSServiceErrorType result = DNSServiceResolve(

&sdRef, 0, service.getNetworkInterfaceID(),

service.getName().getUTF8Data(), service.getType().getUTF8Data(),

run();

}

else {

}

}

void handleServiceResolved(DNSServiceErrorType errorCode, const char* fullName, const char* host, uint16_t port, uint16_t txtLen, const unsigned char *txtRecord) {

if (errorCode != kDNSServiceErr_NoError) {

}

else {

//std::cout << "Service resolved: name:" << fullName << " host:" << host << " port:" << port << std::endl;

boost::bind(

boost::ref(onServiceResolved),

Result(String(fullName), String(host), port,

#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDRegisterQuery.h"

#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveServiceQuery.h"

#include "Swiften/LinkLocal/DNSSD/Fake/FakeDNSSDResolveHostnameQuery.h"

namespace Swift {

}

FakeDNSSDQuerier::~FakeDNSSDQuerier() {

allQueriesEverRun.push_back(query);

if (boost::shared_ptr<FakeDNSSDBrowseQuery> browseQuery = boost::dynamic_pointer_cast<FakeDNSSDBrowseQuery>(query)) {

foreach(const DNSSDServiceID& service, services) {

}

}

else if (boost::shared_ptr<FakeDNSSDResolveServiceQuery> resolveQuery = boost::dynamic_pointer_cast<FakeDNSSDResolveServiceQuery>(query)) {

for(ServiceInfoMap::const_iterator i = serviceInfo.begin(); i != serviceInfo.end(); ++i) {

if (i->first == resolveQuery->service) {

}

}

}

else if (boost::shared_ptr<FakeDNSSDRegisterQuery> registerQuery = boost::dynamic_pointer_cast<FakeDNSSDRegisterQuery>(query)) {

DNSSDServiceID service(registerQuery->name, domain);

}

else if (boost::shared_ptr<FakeDNSSDResolveHostnameQuery> resolveHostnameQuery = boost::dynamic_pointer_cast<FakeDNSSDResolveHostnameQuery>(query)) {

std::map<String,boost::optional<HostAddress> >::const_iterator i = addresses.find(resolveHostnameQuery->hostname);

if (i != addresses.end()) {

boost::bind(

boost::ref(resolveHostnameQuery->onHostnameResolved), i->second),

shared_from_this());

void FakeDNSSDQuerier::addService(const DNSSDServiceID& id) {

services.insert(id);

foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {

}

}

services.erase(id);

serviceInfo.erase(id);

foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {

}

}

}

foreach(const boost::shared_ptr<FakeDNSSDResolveServiceQuery>& query, getQueries<FakeDNSSDResolveServiceQuery>()) {

if (query->service == id) {

}

}

}

void FakeDNSSDQuerier::setBrowseError() {

foreach(const boost::shared_ptr<FakeDNSSDBrowseQuery>& query, getQueries<FakeDNSSDBrowseQuery>()) {

}

}

void FakeDNSSDQuerier::setRegisterError() {

foreach(const boost::shared_ptr<FakeDNSSDRegisterQuery>& query, getQueries<FakeDNSSDRegisterQuery>()) {

}

}

addresses[hostname] = address;

foreach(const boost::shared_ptr<FakeDNSSDResolveHostnameQuery>& query, getQueries<FakeDNSSDResolveHostnameQuery>()) {

if (query->hostname == hostname) {

boost::ref(query->onHostnameResolved), address), shared_from_this());

}

}

class ByteArray;

class FakeDNSSDQuery;

class FakeDNSSDBrowseQuery;

class FakeDNSSDQuerier :

public DNSSDQuerier,

public EventOwner,

public boost::enable_shared_from_this<FakeDNSSDQuerier> {

public:

~FakeDNSSDQuerier();

void start() {}

private:

String domain;

std::list< boost::shared_ptr<FakeDNSSDQuery> > runningQueries;

std::list< boost::shared_ptr<FakeDNSSDQuery> > allQueriesEverRun;

std::set<DNSSDServiceID> services;

namespace Swift {

boost::shared_ptr<DNSSDQuerier> PlatformDNSSDQuerierFactory::createQuerier() {

#if defined(HAVE_BONJOUR)

#elif defined(HAVE_AVAHI)

#else

return boost::shared_ptr<DNSSDQuerier>();

#endif

namespace Swift {

class DNSSDQuerier;

class PlatformDNSSDQuerierFactory {

public:

};

}

void setUp() {

eventLoop = new DummyEventLoop();

querier = boost::shared_ptr<FakeDNSSDQuerier>(

connectFinished = false;

}

void setUp() {

eventLoop = new DummyEventLoop();

aliceServiceID = new DNSSDServiceID("alice", "wonderland.lit");

aliceServiceInfo = new DNSSDResolveServiceQuery::Result("_presence._tcp.wonderland.lit", "xmpp.wonderland.lit", 1234, LinkLocalServiceInfo().toTXTRecord());

testServiceID = new DNSSDServiceID("foo", "bar.local");

#include <boost/bind.hpp>

#include <boost/thread.hpp>

#include "Swiften/Base/String.h"

#include "Swiften/Base/ByteArray.h"

#include "Swiften/Network/HostAddressPort.h"

// -----------------------------------------------------------------------------

}

BoostConnection::~BoostConnection() {

void BoostConnection::handleConnectFinished(const boost::system::error_code& error) {

if (!error) {

doRead();

}

else if (error != boost::asio::error::operation_aborted) {

}

}

void BoostConnection::handleSocketRead(const boost::system::error_code& error, size_t bytesTransferred) {

if (!error) {

doRead();

}

else if (error == boost::asio::error::eof) {

}

else if (error != boost::asio::error::operation_aborted) {

}

}

void BoostConnection::handleDataWritten(const boost::system::error_code& error) {

if (!error) {

}

if (error == boost::asio::error::eof) {

}

else if (error && error != boost::asio::error::operation_aborted) {

}

}

}

namespace Swift {

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

public:

typedef boost::shared_ptr<BoostConnection> ref;

~BoostConnection();

}

virtual void listen();

HostAddressPort getLocalAddress() const;

private:

void handleConnectFinished(const boost::system::error_code& error);

void handleSocketRead(const boost::system::error_code& error, size_t bytesTransferred);

void doRead();

private:

boost::asio::ip::tcp::socket socket_;

std::vector<char> readBuffer_;

bool disconnecting_;

namespace Swift {

}

boost::shared_ptr<Connection> BoostConnectionFactory::createConnection() {

}

}

class BoostConnectionFactory : public ConnectionFactory {

public:

virtual boost::shared_ptr<Connection> createConnection();

private:

boost::asio::io_service* ioService;

};

}

#include <boost/bind.hpp>

#include <boost/system/system_error.hpp>

namespace Swift {

}

}

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

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

}

else {

}

}

}

delete acceptor_;

acceptor_ = NULL;

}

}

void BoostConnectionServer::acceptNextConnection() {

acceptor_->async_accept(newConnection->getSocket(),

boost::bind(&BoostConnectionServer::handleAccept, shared_from_this(), newConnection, boost::asio::placeholders::error));

}

void BoostConnectionServer::handleAccept(boost::shared_ptr<BoostConnection> newConnection, const boost::system::error_code& error) {

if (error) {

boost::bind(

&BoostConnectionServer::stop, shared_from_this(), UnknownError),

shared_from_this());

}

else {

boost::bind(boost::ref(onNewConnection), newConnection),

shared_from_this());

newConnection->listen();

UnknownError

};

}

void start();

boost::signal<void (boost::optional<Error>)> onStopped;

private:

void stop(boost::optional<Error> e);

void acceptNextConnection();

private:

int port_;

boost::asio::io_service* ioService_;

boost::asio::ip::tcp::acceptor* acceptor_;

};

}

#include <boost/date_time/posix_time/posix_time.hpp>

#include <boost/asio.hpp>

namespace Swift {

}

void BoostTimer::start() {

assert(error == boost::asio::error::operation_aborted);

}

else {

timer.expires_from_now(boost::posix_time::milliseconds(timeout));

timer.async_wait(boost::bind(&BoostTimer::handleTimerTick, shared_from_this(), boost::asio::placeholders::error));

}

#include "Swiften/Network/Timer.h"

namespace Swift {

class BoostTimer : public Timer, public EventOwner, public boost::enable_shared_from_this<BoostTimer> {

public:

typedef boost::shared_ptr<BoostTimer> ref;

}

virtual void start();

virtual void stop();

private:

void handleTimerTick(const boost::system::error_code& error);

private:

int timeout;

boost::asio::deadline_timer timer;

};

}

namespace Swift {

}

boost::shared_ptr<Timer> BoostTimerFactory::createTimer(int milliseconds) {

}

}

namespace Swift {

class BoostTimer;

class BoostTimerFactory : public TimerFactory {

public:

virtual boost::shared_ptr<Timer> createTimer(int milliseconds);

private:

boost::asio::io_service* ioService;

};

}

#include "Swiften/Network/DomainNameServiceQuery.h"

#include "Swiften/Network/DomainNameAddressQuery.h"

#include "Swiften/Base/ByteArray.h"

#include "Swiften/Base/foreach.h"

namespace Swift {

}

}

std::sort(records.begin(), records.end(), ResultPriorityComparator());

}

else if (status != ARES_EDESTRUCTION) {

}

}

};

std::vector<HostAddress> results;

results.push_back(HostAddress(inet_ntoa(addr)));

ares_free_hostent(hosts);

}

else {

}

}

else if (status != ARES_EDESTRUCTION) {

}

}

};

#include <boost/enable_shared_from_this.hpp>

#include "Swiften/Network/Connection.h"

#include "Swiften/EventLoop/EventOwner.h"

namespace Swift {

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

public:

void listen() {

assert(false);

}

}

void write(const ByteArray& data) {

onDataSent(data);

}

void receive(const ByteArray& data) {

}

HostAddressPort getLocalAddress() const {

boost::signal<void (const ByteArray&)> onDataSent;

HostAddressPort localAddress;

};

}

#include "Swiften/Network/Connection.h"

#include "Swiften/Network/HostAddressPort.h"

#include "Swiften/EventLoop/EventOwner.h"

namespace Swift {

class FakeConnection :

DisconnectedWithError

};

virtual void listen() {

assert(false);

error = boost::optional<Error>(e);

state = DisconnectedWithError;

if (connectedTo) {

boost::bind(boost::ref(onDisconnected), error),

shared_from_this());

}

else {

state = DisconnectedWithError;

}

boost::bind(boost::ref(onConnectFinished), error),

shared_from_this());

}

state = DisconnectedWithError;

}

connectedTo.reset();

boost::bind(boost::ref(onDisconnected), error),

shared_from_this());

}

delayConnect = true;

}

boost::optional<HostAddressPort> connectedTo;

std::vector<ByteArray> dataWritten;

boost::optional<Error> error;

#include "Swiften/Base/String.h"

#include "Swiften/Network/HostAddress.h"

#include "Swiften/Network/HostAddressPort.h"

#include "Swiften/Network/DomainNameAddressQuery.h"

namespace {

struct AddressQuery : public DomainNameAddressQuery, public boost::enable_shared_from_this<AddressQuery>, public EventOwner {

~AddressQuery() {

if (safeToJoin) {

}

//std::cout << "PlatformDomainNameResolver::doRun(): Success" << std::endl;

boost::bind(boost::ref(onResult), results, boost::optional<DomainNameResolveError>()),

shared_from_this());

}

}

void emitError() {

}

boost::asio::io_service ioService;

String hostname;

boost::thread* thread;

bool safeToJoin;

};

namespace Swift {

}

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

}

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

}

}

namespace Swift {

class String;

class PlatformDomainNameResolver : public DomainNameResolver {

public:

virtual boost::shared_ptr<DomainNameServiceQuery> createServiceQuery(const String& name);

virtual boost::shared_ptr<DomainNameAddressQuery> createAddressQuery(const String& name);

};

}

#include <boost/bind.hpp>

#include "Swiften/Base/ByteArray.h"

#include "Swiften/Base/foreach.h"

using namespace Swift;

namespace Swift {

}

PlatformDomainNameServiceQuery::~PlatformDomainNameServiceQuery() {

safeToJoin = true;

std::sort(records.begin(), records.end(), ResultPriorityComparator());

//std::cout << "Sending out " << records.size() << " SRV results " << std::endl;

}

void PlatformDomainNameServiceQuery::emitError() {

safeToJoin = true;

}

}

#include "Swiften/Base/String.h"

namespace Swift {

class PlatformDomainNameServiceQuery : public DomainNameServiceQuery, public boost::enable_shared_from_this<PlatformDomainNameServiceQuery>, public EventOwner {

public:

~PlatformDomainNameServiceQuery();

virtual void run();

void emitError();

private:

boost::thread* thread;

String service;

bool safeToJoin;

namespace {

struct ServiceQuery : public DomainNameServiceQuery, public boost::enable_shared_from_this<ServiceQuery> {

virtual void run() {

if (!resolver->getIsResponsive()) {

results.push_back(i->second);

}

}

}

void emitOnResult(std::vector<DomainNameServiceQuery::Result> results) {

onResult(results);

}

String service;

StaticDomainNameResolver* resolver;

};

struct AddressQuery : public DomainNameAddressQuery, public boost::enable_shared_from_this<AddressQuery> {

virtual void run() {

if (!resolver->getIsResponsive()) {

}

StaticDomainNameResolver::AddressesMap::const_iterator i = resolver->getAddresses().find(host);

if (i != resolver->getAddresses().end()) {

boost::bind(&AddressQuery::emitOnResult, shared_from_this(), i->second, boost::optional<DomainNameResolveError>()));

}

else {

}

}

onResult(results, error);

}

String host;

StaticDomainNameResolver* resolver;

};

namespace Swift {

}

void StaticDomainNameResolver::addAddress(const String& domain, const HostAddress& address) {

}

boost::shared_ptr<DomainNameServiceQuery> StaticDomainNameResolver::createServiceQuery(const String& name) {

}

boost::shared_ptr<DomainNameAddressQuery> StaticDomainNameResolver::createAddressQuery(const String& name) {

}

}

#include "Swiften/Network/DomainNameResolver.h"

#include "Swiften/Network/DomainNameServiceQuery.h"

#include "Swiften/Network/DomainNameAddressQuery.h"

namespace Swift {

class String;

typedef std::vector< std::pair<String, DomainNameServiceQuery::Result> > ServicesCollection;

public:

void addAddress(const String& domain, const HostAddress& address);

void addService(const String& service, const DomainNameServiceQuery::Result& result);

virtual boost::shared_ptr<DomainNameAddressQuery> createAddressQuery(const String& name);

private:

bool isResponsive;

AddressesMap addresses;

ServicesCollection services;

#include "Swiften/Network/HostAddressPort.h"

#include "Swiften/Network/StaticDomainNameResolver.h"

#include "Swiften/Network/DummyTimerFactory.h"

#include "Swiften/EventLoop/DummyEventLoop.h"

using namespace Swift;

void setUp() {

eventLoop = new DummyEventLoop();

timerFactory = new DummyTimerFactory();

}

struct MockConnection : public Connection {

public:

void listen() { assert(false); }

void connect(const HostAddressPort& address) {

hostAddressPort = address;

if (isResponsive) {

bool fail = std::find(failingPorts.begin(), failingPorts.end(), address) != failingPorts.end();

}

}

void disconnect() { assert(false); }

void write(const ByteArray&) { assert(false); }

boost::optional<HostAddressPort> hostAddressPort;

std::vector<HostAddressPort> failingPorts;

bool isResponsive;

};

struct MockConnectionFactory : public ConnectionFactory {

}

boost::shared_ptr<Connection> createConnection() {

}

bool isResponsive;

std::vector<HostAddressPort> failingPorts;

};

#include "Swiften/Client/Client.h"

#include "Swiften/Network/BoostTimer.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include "Swiften/Roster/GetRosterRequest.h"

#include "Swiften/Client/ClientXMLTracer.h"

return -1;

}

ClientXMLTracer* tracer = new ClientXMLTracer(client);

client->onConnected.connect(&handleConnected);

client->connect();

{

timer->onTick.connect(boost::bind(&SimpleEventLoop::stop, &eventLoop));

timer->start();

}

void testConstructor_TwoServersOnSamePort() {

}

void testStart_Conflict() {

testling->start();

testling2->onStopped.connect(

boost::bind(&BoostConnectionServerTest::handleStopped, this, _1));

}

void testStop() {

testling->start();

testling->stop();

testling2->start();

testling2->stop();

void testDestructor() {

{

testling->connect(HostAddressPort(HostAddress(address, 4), 5222));

}

}

void testDestructor_PendingEvents() {

{

testling->connect(HostAddressPort(HostAddress(address, 4), 5222));

while (!eventLoop_->hasEvents()) {

Swift::sleep(10);

}

void testWrite() {

testling->onConnectFinished.connect(boost::bind(&BoostConnectionTest::doWrite, this, testling.get()));

testling->onDataRead.connect(boost::bind(&BoostConnectionTest::handleDataRead, this, _1));

testling->onDisconnected.connect(boost::bind(&BoostConnectionTest::handleDisconnected, this));

void setUp() {

eventLoop = new DummyEventLoop();

resultsAvailable = false;

}

#include "Swiften/Client/Client.h"

#include "Swiften/Network/BoostTimer.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include "Swiften/Roster/GetRosterRequest.h"

#include "Swiften/Client/ClientXMLTracer.h"

#include "Swiften/Queries/Request.h"

#include "Swiften/Queries/IQRouter.h"

namespace Swift {

#include "Swiften/Elements/RosterItemPayload.h"

#include "Swiften/Queries/IQRouter.h"

#include "Swiften/Roster/GetRosterRequest.h"

#include "Swiften/Roster/Roster.h"

#include "Swiften/Roster/SetPresence.h"

#include "Swiften/Roster/OfflineRosterFilter.h"