+ numberOfConnectedClients++;

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

+ char* jid = getenv("SWIFT_BENCHTOOL_JID");

+ if (!jid) {

+ std::cerr << "Please set the SWIFT_BENCHTOOL_JID environment variable" << std::endl;

+ return -1;

+ }

+ char* pass = getenv("SWIFT_BENCHTOOL_PASS");

+ if (!pass) {

+ std::cerr << "Please set the SWIFT_BENCHTOOL_PASS environment variable" << std::endl;

+ return -1;

+ }

+ BlindCertificateTrustChecker trustChecker;

+ std::vector<CoreClient*> clients;

+ for (int i = 0; i < numberOfInstances; ++i) {

+ CoreClient* client = new Swift::CoreClient(JID(jid), createSafeByteArray(std::string(pass)), &networkFactories);

+ client->setCertificateTrustChecker(&trustChecker);

+ client->onConnected.connect(&handleConnected);

+ clients.push_back(client);

+ }

+ for (size_t i = 0; i < clients.size(); ++i) {

+ clients[i]->connect();

+ }

+ eventLoop.run();

+ for (size_t i = 0; i < clients.size(); ++i) {

+ delete clients[i];

+ }

+

+ return 0;

+ if (!error) {

+ errorConnection.disconnect();

+ client->disconnect();

+ eventLoop.stop();

+ exitCode = OK;

+ } else {

+ errorConnection.disconnect();

+ exitCode = DISCO_ERROR;

+ }

+ exitCode = NO_RESPONSE;

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

+ discoInfoRequest->onResponse.connect(&handleServerDiscoInfoResponse);

+ discoInfoRequest->send();

+ exitCode = CANNOT_AUTH;

+ eventLoop.stop();

+ if (argc < 4 || argc > 5) {

+ std::cerr << "Usage: " << argv[0] << " <jid> [<connect_host>] <password> <timeout_seconds>" << std::endl;

+ return -1;

+ }

+

+ int argi = 1;

+

+ std::string jid = argv[argi++];

+ std::string connectHost = "";

+ if (argc == 5) {

+ connectHost = argv[argi++];

+ }

+

+ client = new Swift::Client(JID(jid), std::string(argv[argi++]), &networkFactories);

+ char* timeoutChar = argv[argi++];

+ int timeout = atoi(timeoutChar);

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

+ ClientXMLTracer* tracer = new ClientXMLTracer(client);

+ client->onConnected.connect(&handleConnected);

+ errorConnection = client->onDisconnected.connect(&handleDisconnected);

+ std::cout << "Connecting to JID " << jid << " with timeout " << timeout << "ms on host: "; ;

+ if (!connectHost.empty()) {

+ std::cout << connectHost << std::endl;

+ ClientOptions options;

+ options.manualHostname = connectHost;

+ client->connect(options);

+ } else {

+ std::cout << " Default" << std::endl;

+ client->connect();

+ }

+

+ {

+ Timer::ref timer = networkFactories.getTimerFactory()->createTimer(timeout);

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

+ timer->start();

+

+ eventLoop.run();

+ }

+

+ delete tracer;

+ delete client;

+ return exitCode;

+ if (argc < 2) {

+ std::cerr << "Invalid parameters" << std::endl;

+ return -1;

+ }

+

+ SimpleEventLoop eventLoop;

+ PlatformDNSSDQuerierFactory factory(&eventLoop);

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

+ querier->start();

+

+ if (std::string(argv[1]) == "browse") {

+ boost::shared_ptr<DNSSDBrowseQuery> browseQuery = querier->createBrowseQuery();

+ browseQuery->startBrowsing();

+ eventLoop.run();

+ browseQuery->stopBrowsing();

+ }

+ else if (std::string(argv[1]) == "resolve-service") {

+ if (argc < 5) {

+ std::cerr << "Invalid parameters" << std::endl;

+ return -1;

+ }

+ boost::shared_ptr<DNSSDResolveServiceQuery> resolveQuery = querier->createResolveServiceQuery(DNSSDServiceID(argv[2], argv[3], argv[4]));

+ resolveQuery->start();

+ eventLoop.run();

+ std::cerr << "Done running" << std::endl;

+ resolveQuery->stop();

+ }

+

+ querier->stop();

+ cout << "Joining " << roomJID.toString() << endl;

+ muc = client->getMUCManager()->createMUC(roomJID);

+ muc->joinAs("SwiftExample");

+ if (error) {

+ cout << "Error fetching list of rooms." << endl;

+ return;

+ }

+

+ int roomCount = 0;

+ cout << "List of rooms at " << mucJID.toString() << endl;

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

+ roomCount++;

+ cout << "\t" << roomCount << ". " << item.getJID().getNode() << " - " << item.getName() << std::endl;

+ if (roomCount == 1) {

+ roomJID = item.getJID();

+ }

+ }

+ cout << endl;

+ joinMUC();

+ cout << "Connected." << endl;

+ // search for MUC rooms

+ GetDiscoItemsRequest::ref discoItemsRequest = GetDiscoItemsRequest::create(mucJID, client->getIQRouter());

+ discoItemsRequest->onResponse.connect(&handleRoomsItemsResponse);

+ cout << "Request list of rooms." << endl;

+ discoItemsRequest->send();

+ cout << "Disconnected." << endl;

+ if (message->getFrom().toBare() == roomJID) {

+ cout << "[ " << roomJID << " ] " << message->getFrom().getResource() << ": " << message->getBody().get_value_or("") << endl;

+ }

+ int ret = 0;

+

+ if (argc != 4) {

+ cout << "Usage: ./" << argv[0] << " <jid> <password> <muc_domain>" << endl;

+ ret = -1;

+ }

+ else {

+ mucJID = JID(argv[3]);

+ client = boost::make_shared<Client>(JID(argv[1]), string(argv[2]), &networkFactories);

+ client->setAlwaysTrustCertificates();

+

+ // Enable the following line for detailed XML logging

+ // ClientXMLTracer* tracer = new ClientXMLTracer(client.get());

+

+ client->onConnected.connect(&handleConnected);

+ client->onDisconnected.connect(&handleDisconnected);

+ client->onMessageReceived.connect(&handleIncomingMessage);

+

+ cout << "Connecting..." << flush;

+ client->connect();

+ {

+ Timer::ref timer = networkFactories.getTimerFactory()->createTimer(30000);

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

+

+ Timer::ref disconnectTimer = networkFactories.getTimerFactory()->createTimer(25000);

+ disconnectTimer->onTick.connect(boost::bind(&Client::disconnect, client.get()));

+

+ timer->start();

+ disconnectTimer->start();

+

+ eventLoop.run();

+ }

+ }

+ return ret;

+ if (result) {

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

+ }

+ else {

+ std::cerr << "No result" << std::endl;

+ }

+ eventLoop.stop();

+ if (result) {

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

+ }

+ else {

+ std::cerr << "No result" << std::endl;

+ }

+ eventLoop.stop();

+ if (result && result.get()) {

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

+ }

+ else {

+ std::cerr << "Result: ERROR" << std::endl;

+ }

+ eventLoop.stop();

+ if (argc < 2) {

+ std::cerr << "Invalid parameters" << std::endl;

+ return -1;

+ }

+ PlatformNATTraversalWorker natTraverser(&eventLoop);

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

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

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

+ query->start();

+ eventLoop.run();

+ }

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

+ if (argc < 4) {

+ std::cerr << "Invalid parameters" << std::endl;

+ }

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

+ query->start();

+ eventLoop.run();

+ }

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

+ if (argc < 4) {

+ std::cerr << "Invalid parameters" << std::endl;

+ }

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

+ query->start();

+ eventLoop.run();

+ }

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

+ std::cout << PlatformNetworkEnvironment().getLocalAddress().toString() << std::endl;

+ }

+ public:

+ virtual void handleStreamStart(const ProtocolHeader&) {

+ std::cout << "-> Stream start" << std::endl;

+ }

+ virtual void handleElement(boost::shared_ptr<ToplevelElement> element) {

+ std::cout << "-> Element " << typeid(*element.get()).name() << std::endl;

+ }

+ virtual void handleStreamEnd() {

+ std::cout << "-> Stream end" << std::endl;

+ }

+ if (argc != 2) {

+ std::cerr << "Usage: " << argv[0] << " file" << std::endl;

+ return 0;

+ }

+ FullPayloadParserFactoryCollection factories;

+ MyXMPPParserClient parserClient;

+ PlatformXMLParserFactory xmlParserFactory;

+ XMPPParser parser(&parserClient, &factories, &xmlParserFactory);

+ ParserTester<XMLParserClient> tester(&parser);

+ std::string line;

+ std::ifstream myfile (argv[1]);

+ if (myfile.is_open()) {

+ while (!myfile.eof()) {

+ getline (myfile,line);

+ std::cout << "Parsing: " << line << std::endl;

+ if (!tester.parse(line)) {

+ std::cerr << "PARSE ERROR" << std::endl;

+ return -1;

+ }

+ }

+ myfile.close();

+ }

+ else {

+ std::cerr << "Unable to open file " << argv[1] << std::endl;

+ }

+ return 0;

+ public:

+ FileReceiver(const JID& jid, const std::string& password) : jid(jid), password(password) {

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

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

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

+ tracer = new ClientXMLTracer(client);

+ }

+

+ ~FileReceiver() {

+ delete tracer;

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

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

+ delete client;

+ }

+

+ void start() {

+ client->connect();

+ }

+

+ void stop() {

+ foreach(const IncomingFileTransfer::ref transfer, incomingFileTransfers) {

+ //transfer->stop();

+ }

+ client->disconnect();

+ }

+

+ private:

+ void handleConnected() {

+ Log::setLogLevel(Log::debug);

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

+

+ DiscoInfo discoInfo;

+ discoInfo.addIdentity(DiscoInfo::Identity(CLIENT_NAME, "client", "pc"));

+ discoInfo.addFeature(DiscoInfo::JingleFeature);

+ discoInfo.addFeature(DiscoInfo::JingleFTFeature);

+ discoInfo.addFeature(DiscoInfo::Bytestream);

+ discoInfo.addFeature(DiscoInfo::JingleTransportsIBBFeature);

+ discoInfo.addFeature(DiscoInfo::JingleTransportsS5BFeature);

+ client->getDiscoManager()->setCapsNode(CLIENT_NODE);

+ client->getDiscoManager()->setDiscoInfo(discoInfo);

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

+ }

+

+ void handleIncomingFileTransfer(IncomingFileTransfer::ref transfer) {

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

+ incomingFileTransfers.push_back(transfer);

+ boost::shared_ptr<FileWriteBytestream> out = boost::make_shared<FileWriteBytestream>("out");

+ transfer->onFinished.connect(boost::bind(&FileReceiver::handleFileTransferFinished, this, _1, out));

+ transfer->accept(out);

+ }

+

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

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

+ exit(-1);

+ }

+

+ void handleFileTransferFinished(

+ const boost::optional<FileTransferError>& error,

+ boost::shared_ptr<FileWriteBytestream> out) {

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

+ out->close();

+ if (error) {

+ exit(-1);

+ }

+ else {

+ exit(0);

+ }

+ }

+

+ void exit(int code) {

+ exitCode = code;

+ stop();

+ eventLoop.stop();

+ }

+

+ private:

+ JID jid;

+ std::string password;

+ Client* client;

+ ClientXMLTracer* tracer;

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

+ if (argc != 3) {

+ std::cerr << "Usage: " << argv[0] << " <jid> <password>" << std::endl;

+ return -1;

+ }

+ JID jid(argv[1]);

+ FileReceiver fileReceiver(jid, std::string(argv[2]));

+ fileReceiver.start();

+ eventLoop.run();

+ return exitCode;

+ public:

+ FileSender(const JID& jid, const std::string& password, const JID& recipient, const boost::filesystem::path& file) : jid(jid), password(password), recipient(recipient), file(file), tracer(NULL) {

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

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

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

+ //tracer = new ClientXMLTracer(client);

+ client->getEntityCapsProvider()->onCapsChanged.connect(boost::bind(&FileSender::handleCapsChanged, this, _1));

+ }

+

+ ~FileSender() {

+ delete tracer;

+ client->onDisconnected.disconnect(boost::bind(&FileSender::handleDisconnected, this, _1));

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

+ delete client;

+ }

+

+ void start() {

+ client->connect();

+ }

+

+ private:

+ void handleConnected() {

+ std::cout << "Connected. Awaiting presence from receipient." << std::endl;

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

+ }

+

+ void handleCapsChanged(JID jid) {

+ if (jid.toBare() == recipient) {

+ // create ReadBytestream from file

+ boost::shared_ptr<FileReadBytestream> fileStream = boost::make_shared<FileReadBytestream>(file);

+

+ outgoingFileTransfer = client->getFileTransferManager()->createOutgoingFileTransfer(recipient, file, "Some File!", fileStream);

+

+ if (outgoingFileTransfer) {

+ outgoingFileTransfer->onFinished.connect(boost::bind(&FileSender::handleFileTransferFinished, this, _1));

+ std::cout << "Starting file-transfer to " << recipient.toString() << "." << std::endl;

+ outgoingFileTransfer->start();

+ // TODO: getting notified about FT status and end

+ } else {

+ std::cout << recipient << " doesn't support any kind of file transfer!" << std::endl;

+ client->disconnect();

+ }

+ }

+ }

+

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

+ if (err) {

+ std::cout << "Disconnected due to error ( " << err.get().getType() << " )." << std::endl;

+ exit(-1);

+ }

+ else {

+ std::cout << "Successfully disconnected." << std::endl;

+ }

+ }

+

+ void handleFileTransferFinished(const boost::optional<FileTransferError>& error) {

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

+ outgoingFileTransfer.reset();

+ if (error) {

+ client->disconnect();

+ exit(-1);

+ }

+ else {

+ client->disconnect();

+ exit(0);

+ }

+ }

+

+ void exit(int code) {

+ exitCode = code;

+ eventLoop.stop();

+ }

+

+ private:

+ BoostConnectionServer::ref connectionServer;

+ OutgoingFileTransfer::ref outgoingFileTransfer;

+ JID jid;

+ std::string password;

+ JID recipient;

+ boost::filesystem::path file;

+ Client* client;

+ ClientXMLTracer* tracer;

+ if (argc != 5) {

+ std::cerr << "Usage: " << argv[0] << " <jid> <password> <recipient> <file>" << std::endl;

+ return -1;

+ }

+

+ //Log::setLogLevel(Log::debug);

+

+ JID sender(argv[1]);

+ JID recipient(argv[3]);

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

+ fileSender.start();

+ {

+ Timer::ref timer = networkFactories.getTimerFactory()->createTimer(30000);

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

+ timer->start();

+

+ eventLoop.run();

+ }

+

+ return exitCode;

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

+ message->setBody(messageBody);

+ message->setTo(recipient);

+ client->sendMessage(message);

+ exitCode = 0;

+ errorConnection.disconnect();

+ client->disconnect();

+ eventLoop.stop();

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

+ exitCode = 1;

+ eventLoop.stop();

+ if (argc < 5 || argc > 6) {

+ std::cerr << "Usage: " << argv[0] << " <jid> [<connect_host>]<password> <recipient> <message>" << std::endl;

+ return -1;

+ }

+

+ int argi = 1;

+

+ std::string jid = argv[argi++];

+ std::string connectHost = "";

+ if (argc == 6) {

+ connectHost = argv[argi++];

+ }

+

+ client = new Swift::Client(JID(jid), std::string(argv[argi++]), &networkFactories);

+ client->setAlwaysTrustCertificates();

+

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

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

+

+ ClientXMLTracer* tracer = new ClientXMLTracer(client);

+ client->onConnected.connect(&handleConnected);

+ errorConnection = client->onDisconnected.connect(&handleDisconnected);

+ if (!connectHost.empty()) {

+ ClientOptions options;

+ options.manualHostname = connectHost;

+ client->connect(options);

+ } else {

+ client->connect();

+ }

+

+ {

+ Timer::ref timer = networkFactories.getTimerFactory()->createTimer(30000);

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

+ timer->start();

+

+ eventLoop.run();

+ }

+

+ delete tracer;

+ delete client;

+ return exitCode;