using namespace Swift;

numberOfConnectedClients++;

std::cout << "Connected " << numberOfConnectedClients << std::endl;

}

enum ExitCodes {OK = 0, CANNOT_CONNECT, CANNOT_AUTH, NO_RESPONSE, DISCO_ERROR};

if (!error) {

errorConnection.disconnect();

client->disconnect();

}

}

exitCode = NO_RESPONSE;

GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(JID(), client->getIQRouter());

discoInfoRequest->onResponse.connect(&handleServerDiscoInfoResponse);

discoInfoRequest->send();

}

exitCode = CANNOT_AUTH;

eventLoop.stop();

}

Import("env")

myenv = env.Clone()

tester = myenv.Program("ConnectivityTest", ["ConnectivityTest.cpp"])

Import("env")

myenv = env.Clone()

linkLocalTool = myenv.Program("LinkLocalTool", [

"main.cpp"

using namespace Swift;

if (result) {

std::cerr << "Result: " << result->toString() << std::endl;;

}

eventLoop.stop();

}

if (result) {

std::cerr << "Result: " << result->getPublicPort() << " -> " << result->getLocalPort() << std::endl;;

}

eventLoop.stop();

}

if (result) {

std::cerr << "Result: OK" << std::endl;

}

if (std::string(argv[1]) == "get-public-ip") {

boost::shared_ptr<NATTraversalGetPublicIPRequest> query = natTraverser.createGetPublicIPRequest();

query->onResult.connect(boost::bind(&handleGetPublicIPRequestResponse, _1));

eventLoop.run();

}

else if (std::string(argv[1]) == "add-port-forward") {

}

boost::shared_ptr<NATTraversalForwardPortRequest> query = natTraverser.createForwardPortRequest(boost::lexical_cast<int>(argv[2]), boost::lexical_cast<int>(argv[3]));

query->onResult.connect(boost::bind(&handleGetForwardPortRequestResponse, _1));

eventLoop.run();

}

else if (std::string(argv[1]) == "remove-port-forward") {

}

boost::shared_ptr<NATTraversalRemovePortForwardingRequest> query = natTraverser.createRemovePortForwardingRequest(boost::lexical_cast<int>(argv[2]), boost::lexical_cast<int>(argv[3]));

query->onResult.connect(boost::bind(&handleRemovePortForwardingRequestResponse, _1));

eventLoop.run();

}

else if (std::string(argv[1]) == "get-local-ip") {

Import("env")

myenv = env.Clone()

myenv.Program("ParserTester", ["ParserTester.cpp"])

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <iostream>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Client/Client.h>

#include <Swiften/Elements/DiscoInfo.h>

#include <Swiften/FileTransfer/IncomingFileTransferManager.h>

#include <Swiften/FileTransfer/FileWriteBytestream.h>

#include <Swiften/Jingle/JingleSessionManager.h>

#include <Swiften/FileTransfer/SOCKS5BytestreamRegistry.h>

#include <Swiften/FileTransfer/FileTransferManager.h>

using namespace Swift;

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

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

class FileReceiver {

public:

client = new Swift::Client(jid, password, &networkFactories);

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

client->onDisconnected.connect(boost::bind(&FileReceiver::handleDisconnected, this, _1));

private:

void handleConnected() {

client->getFileTransferManager()->onIncomingFileTransfer.connect(boost::bind(&FileReceiver::handleIncomingFileTransfer, this, _1));

DiscoInfo discoInfo;

void handleIncomingFileTransfer(IncomingFileTransfer::ref transfer) {

SWIFT_LOG(debug) << "foo" << std::endl;

incomingFileTransfers.push_back(transfer);

}

void handleDisconnected(const boost::optional<ClientError>&) {

exit(-1);

}

std::cout << "File transfer finished" << std::endl;

if (error) {

exit(-1);

}

else {

exit(0);

}

void exit(int code) {

exitCode = code;

std::string password;

Client* client;

ClientXMLTracer* tracer;

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

};

Import("env")

myenv = env.Clone()

myenv.Program("SendFile", ["SendFile.cpp"])

myenv.Program("ReceiveFile", ["ReceiveFile.cpp"])

/*

* Licensed under the GNU General Public License v3.

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

*/

#include <Swiften/Client/Client.h>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Network/BoostTimer.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Network/BoostNetworkFactories.h>

#include <Swiften/FileTransfer/OutgoingFileTransfer.h>

#include <Swiften/Jingle/JingleSessionManager.h>

#include <Swiften/Disco/EntityCapsManager.h>

#include <Swiften/Base/ByteArray.h>

#include <Swiften/StringCodecs/Hexify.h>

#include <Swiften/FileTransfer/FileTransferManager.h>

using namespace Swift;

class FileSender {

public:

void handleConnected() {

client->sendPresence(Presence::create());

//ByteArray fileData;

// gather file information

/*StreamInitiationFileInfo fileInfo;

JID sender(argv[1]);

JID recipient(argv[3]);

FileSender fileSender(sender, std::string(argv[2]), recipient, boost::filesystem::path(argv[4]));

fileSender.start();

{

Import("env")

myenv = env.Clone()

tester = myenv.Program("SendMessage", ["SendMessage.cpp"])

using namespace Swift;

boost::shared_ptr<Message> message(new Message());

message->setBody(messageBody);

message->setTo(recipient);

eventLoop.stop();

}

std::cerr << "Error!" << std::endl;

exitCode = 1;

eventLoop.stop();