/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Disco/DiscoServiceWalker.h>

#include <Swiften/Base/Log.h>

#include <Swiften/Base/foreach.h>

namespace Swift {

DiscoServiceWalker::DiscoServiceWalker(const JID& service, IQRouter* iqRouter, size_t maxSteps) : service_(service), iqRouter_(iqRouter), maxSteps_(maxSteps), active_(false) {

}

void DiscoServiceWalker::beginWalk() {

SWIFT_LOG(debug) << "Starting walk to " << service_ << std::endl;

assert(!active_);

void DiscoServiceWalker::handleDiscoInfoResponse(boost::shared_ptr<DiscoInfo> info, ErrorPayload::ref error, GetDiscoInfoRequest::ref request) {

/* If we got canceled, don't do anything */

if (!active_) {

return;

}

SWIFT_LOG(debug) << "Disco info response from " << request->getReceiver() << std::endl;

pendingDiscoInfoRequests_.erase(request);

if (error) {

handleDiscoError(request->getReceiver(), error);

return;

}

bool couldContainServices = false;

foreach (DiscoInfo::Identity identity, info->getIdentities()) {

if (identity.getCategory() == "server") {

}

void DiscoServiceWalker::handleDiscoItemsResponse(boost::shared_ptr<DiscoItems> items, ErrorPayload::ref error, GetDiscoItemsRequest::ref request) {

/* If we got canceled, don't do anything */

if (!active_) {

return;

}

SWIFT_LOG(debug) << "Received disco items from " << request->getReceiver() << std::endl;

pendingDiscoItemsRequests_.erase(request);

if (error) {

handleDiscoError(request->getReceiver(), error);

return;

}

foreach (DiscoItems::Item item, items->getItems()) {

if (item.getNode().empty()) {

/* Don't look at noded items. It's possible that this will exclude some services,

* but I've never seen one in the wild, and it's an easy fix for not looping.

connectionFactory,

timerFactory,

options);

remoteCandidateSelector->onCandidateSelectFinished.connect(

boost::bind(&DefaultFileTransferTransporter::handleRemoteCandidateSelectFinished, this, _1, _2));

}

DefaultFileTransferTransporter::~DefaultFileTransferTransporter() {

stopGeneratingLocalCandidates();

delete remoteCandidateSelector;

delete localCandidateGenerator;

}

void DefaultFileTransferTransporter::initialize() {

s5bSessionID = s5bRegistry->generateSessionID();

}

void DefaultFileTransferTransporter::initialize(const std::string& s5bSessionID) {

this->s5bSessionID = s5bSessionID;

destination(destination),

state(Initial),

chunkSize(131072) {

weFailedTimeout = timerFactory->createTimer(3000);

weFailedTimeout->onTick.connect(

boost::bind(&SOCKS5BytestreamClientSession::handleWeFailedTimeout, this));

}

SOCKS5BytestreamClientSession::~SOCKS5BytestreamClientSession() {

weFailedTimeout->stop();

}

void SOCKS5BytestreamClientSession::start() {

assert(state == Initial);

SWIFT_LOG(debug) << "Trying to connect via TCP to " << addressPort.toString() << "." << std::endl;

weFailedTimeout->start();

connectFinishedConnection = connection->onConnectFinished.connect(

boost::bind(&SOCKS5BytestreamClientSession::handleConnectFinished, this, _1));

return activeSession;

}

boost::shared_ptr<SOCKS5BytestreamClientSession> SOCKS5BytestreamProxiesManager::createSOCKS5BytestreamClientSession(HostAddressPort addressPort, const std::string& destAddr) {

SOCKS5BytestreamClientSession::ref connection = boost::make_shared<SOCKS5BytestreamClientSession>(connectionFactory_->createConnection(), addressPort, destAddr, timerFactory_);

return connection;

}

void SOCKS5BytestreamProxiesManager::handleProxiesFound(std::vector<S5BProxyRequest::ref> proxyHosts) {

foreach(S5BProxyRequest::ref proxy, proxyHosts) {

if (proxy) {

if (HostAddress(proxy->getStreamHost().get().host).isValid()) {

addS5BProxy(proxy);

onDiscoveredProxiesChanged();

}

else {

DomainNameAddressQuery::ref resolveRequest = resolver_->createAddressQuery(proxy->getStreamHost().get().host);

resolveRequest->onResult.connect(boost::bind(&SOCKS5BytestreamProxiesManager::handleNameLookupResult, this, _1, _2, proxy));

/*

* Copyright (c) 2014-2015 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#include <fstream>

#include <boost/algorithm/string.hpp>

#include <boost/filesystem.hpp>

#include <Swiften/Base/Log.h>

#include <Swiften/Client/Client.h>

#include <Swiften/Disco/EntityCapsProvider.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/FileTransfer/FileReadBytestream.h>

#include <Swiften/FileTransfer/FileTransferManager.h>

#include <Swiften/FileTransfer/FileWriteBytestream.h>

using namespace Swift;

static const std::string CLIENT_NAME = "Swiften FT Test";

static const std::string CLIENT_NODE = "http://swift.im";

static boost::shared_ptr<SimpleEventLoop> eventLoop;

static boost::shared_ptr<BoostNetworkFactories> networkFactories;

sender_ = boost::make_shared<Client>(JID(getenv("SWIFT_FILETRANSFERTEST_JID")), getenv("SWIFT_FILETRANSFERTEST_PASS"), networkFactories.get());

sender_->onDisconnected.connect(boost::bind(&FileTransferTest::handleSenderDisconnected, this, _1));

sender_->onConnected.connect(boost::bind(&FileTransferTest::handleSenderConnected, this));

sender_->getEntityCapsProvider()->onCapsChanged.connect(boost::bind(&FileTransferTest::handleSenderCapsChanged, this, _1));

receiver_ = boost::make_shared<Client>(JID(getenv("SWIFT_FILETRANSFERTEST2_JID")), getenv("SWIFT_FILETRANSFERTEST2_PASS"), networkFactories.get());

receiver_->onConnected.connect(boost::bind(&FileTransferTest::handleReceiverConnected, this));

receiver_->onDisconnected.connect(boost::bind(&FileTransferTest::handleReceiverDisconnected, this, _1));

ClientOptions options;

options.useTLS = ClientOptions::NeverUseTLS;

options.useStreamCompression = false;

options.useStreamResumption = false;

options.useAcks = false;

sender_->connect(options);

receiver_->connect(options);

std::ofstream outfile(sendFilePath_.native().c_str(), std::ios::out | std::ios::binary);

outfile.write(reinterpret_cast<char *>(&sendData_[0]), sendData_.size());

outfile.close();

}

~FileTransferTest() {

timeOut_->stop();

if(boost::filesystem::exists(sendFilePath_)) {

boost::filesystem::remove(sendFilePath_);

}

if(boost::filesystem::exists(receiveFilePath_)) {

boost::filesystem::remove(receiveFilePath_);

}

}

}

bool wasSuccessful() const {

return !senderError_ && !receiverError_;

}

private:

int senderCandidates_;

boost::shared_ptr<Client> sender_;

ByteArray sendData_;

OutgoingFileTransfer::ref outgoingFileTransfer_;

boost::filesystem::path sendFilePath_;

boost::optional<FileTransferError> senderError_;

bool senderIsDone_;

int receiverCandidates_;

boost::shared_ptr<Client> receiver_;

ByteArray receiveData_;

std::vector<IncomingFileTransfer::ref> incomingFileTransfers_;

boost::filesystem::path receiveFilePath_;

boost::optional<FileTransferError> receiverError_;

bool receiverIsDone_;

Timer::ref timeOut_;

};