1 files changed, 232 insertions, 0 deletions
diff --git a/Sluift/SluiftClient.cpp b/Sluift/SluiftClient.cpp
new file mode 100644
index 0000000..99892a9
--- /dev/null
+++ b/Sluift/SluiftClient.cpp
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) 2013-2018 Isode Limited.
+ * All rights reserved.
+ * See the COPYING file for more information.
+ */
+
+#include <Sluift/SluiftClient.h>
+
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <Swiften/Client/Client.h>
+#include <Swiften/Client/ClientBlockListManager.h>
+#include <Swiften/Client/ClientXMLTracer.h>
+#include <Swiften/Elements/Message.h>
+#include <Swiften/Elements/Presence.h>
+#include <Swiften/Elements/PubSubEvent.h>
+#include <Swiften/Queries/RawRequest.h>
+#include <Swiften/Roster/XMPPRoster.h>
+
+#include <Sluift/Helpers.h>
+#include <Sluift/Lua/Exception.h>
+#include <Sluift/SluiftGlobals.h>
+
+using namespace Swift;
+
+SluiftClient::SluiftClient(
+        const JID& jid,
+        const std::string& password,
+        NetworkFactories* networkFactories,
+        SimpleEventLoop* eventLoop) :
+            networkFactories(networkFactories),
+            eventLoop(eventLoop),
+            tracer(nullptr) {
+    client = new Client(jid, password, networkFactories);
+    client->setAlwaysTrustCertificates();
+    client->onDisconnected.connect(boost::bind(&SluiftClient::handleDisconnected, this, _1));
+    client->onMessageReceived.connect(boost::bind(&SluiftClient::handleIncomingMessage, this, _1));
+    client->onPresenceReceived.connect(boost::bind(&SluiftClient::handleIncomingPresence, this, _1));
+    client->getPubSubManager()->onEvent.connect(boost::bind(&SluiftClient::handleIncomingPubSubEvent, this, _1, _2));
+    client->getRoster()->onInitialRosterPopulated.connect(boost::bind(&SluiftClient::handleInitialRosterPopulated, this));
+    client->getRoster()->onJIDAdded.connect(boost::bind(&SluiftClient::handleIncomingRosterAdd, this, _1));
+    client->getRoster()->onJIDRemoved.connect(boost::bind(&SluiftClient::handleIncomingRosterRemove, this, _1));
+    client->getRoster()->onJIDUpdated.connect(boost::bind(&SluiftClient::handleIncomingRosterUpdate, this, _1));
+    client->getClientBlockListManager()->getBlockList()->onItemAdded.connect(boost::bind(&SluiftClient::handleIncomingBlockEvent, this, _1));
+    client->getClientBlockListManager()->getBlockList()->onItemRemoved.connect(boost::bind(&SluiftClient::handleIncomingUnblockEvent, this, _1));
+}
+
+SluiftClient::~SluiftClient() {
+    delete tracer;
+    delete client;
+}
+
+void SluiftClient::connect() {
+    if (client->isActive()) {
+        throw Lua::Exception("Client is already connecting or connected");
+    }
+    rosterReceived = false;
+    blockListReceived = false;
+    disconnectedError = boost::optional<ClientError>();
+    client->connect(options);
+}
+
+void SluiftClient::setTraceEnabled(bool b) {
+    if (b && !tracer) {
+        tracer = new ClientXMLTracer(client, options.boshURL.isEmpty()? false: true);
+    }
+    else if (!b && tracer) {
+        delete tracer;
+        tracer = nullptr;
+    }
+}
+
+void SluiftClient::waitConnected(int timeout) {
+    Watchdog watchdog(timeout, networkFactories->getTimerFactory());
+    while (!watchdog.getTimedOut() && client->isActive() && !client->isAvailable()) {
+        eventLoop->runUntilEvents();
+    }
+    if (watchdog.getTimedOut()) {
+        client->disconnect();
+        throw Lua::Exception("Timeout while connecting");
+    }
+    if (disconnectedError) {
+        throw Lua::Exception(getErrorString(*disconnectedError));
+    }
+}
+
+bool SluiftClient::isConnected() const {
+    return client->isAvailable();
+}
+
+void SluiftClient::disconnect() {
+    client->disconnect();
+    while (client->isActive()) {
+        eventLoop->runUntilEvents();
+    }
+}
+
+void SluiftClient::setSoftwareVersion(const std::string& name, const std::string& version, const std::string& os) {
+    client->setSoftwareVersion(name, version, os);
+}
+
+boost::optional<SluiftClient::Event> SluiftClient::getNextEvent(
+        int timeout, boost::function<bool (const Event&)> condition) {
+    Watchdog watchdog(timeout, networkFactories->getTimerFactory());
+    size_t currentIndex = 0;
+    while (true) {
+        // Look for pending events in the queue
+        while (currentIndex < pendingEvents.size()) {
+            Event event = pendingEvents[currentIndex];
+            if (!condition || condition(event)) {
+                pendingEvents.erase(
+                        pendingEvents.begin()
+                        + boost::numeric_cast<int>(currentIndex));
+                return event;
+            }
+            ++currentIndex;
+        }
+
+        // Wait for new events
+        while (!watchdog.getTimedOut() && currentIndex >= pendingEvents.size() && client->isActive()) {
+            eventLoop->runUntilEvents();
+        }
+
+        // Finish if we're disconnected or timed out
+        if (watchdog.getTimedOut() || !client->isActive()) {
+            return boost::optional<Event>();
+        }
+    }
+}
+
+std::vector<JID> SluiftClient::getBlockList(int timeout) {
+    Watchdog watchdog(timeout, networkFactories->getTimerFactory());
+    if (!blockListReceived) {
+        // If we haven't requested it yet, request it for the first time
+        client->getClientBlockListManager()->requestBlockList();
+
+        // Wait for new events
+        while (!watchdog.getTimedOut() && client->getClientBlockListManager()->getBlockList()->getState() != BlockList::Available) {
+            eventLoop->runUntilEvents();
+        }
+
+        // Throw an error if we're timed out
+        if (watchdog.getTimedOut()) {
+            throw Lua::Exception("Timeout while requesting blocklist");
+        }
+    }
+    blockListReceived = true;
+    return client->getClientBlockListManager()->getBlockList()->getItems();
+}
+
+std::vector<XMPPRosterItem> SluiftClient::getRoster(int timeout) {
+    Watchdog watchdog(timeout, networkFactories->getTimerFactory());
+    if (!rosterReceived) {
+        // If we haven't requested it yet, request it for the first time
+        client->requestRoster();
+
+        // Wait for new events
+        while (!watchdog.getTimedOut() && !rosterReceived) {
+            eventLoop->runUntilEvents();
+        }
+
+        // Throw an error if we're timed out
+        if (watchdog.getTimedOut()) {
+            throw Lua::Exception("Timeout while requesting roster");
+        }
+    }
+    return client->getRoster()->getItems();
+}
+
+void SluiftClient::handleIncomingMessage(std::shared_ptr<Message> stanza) {
+    if (stanza->getPayload<PubSubEvent>()) {
+        // Already handled by pubsub manager
+        return;
+    }
+    pendingEvents.push_back(Event(stanza));
+}
+
+void SluiftClient::handleIncomingPresence(std::shared_ptr<Presence> stanza) {
+    pendingEvents.push_back(Event(stanza));
+}
+
+void SluiftClient::handleIncomingPubSubEvent(const JID& from, std::shared_ptr<PubSubEventPayload> event) {
+    pendingEvents.push_back(Event(from, event));
+}
+
+void SluiftClient::handleIncomingBlockEvent(const JID& item) {
+    pendingEvents.push_back(Event(item, Event::BlockEventType));
+}
+
+void SluiftClient::handleIncomingUnblockEvent(const JID& item) {
+    pendingEvents.push_back(Event(item, Event::UnblockEventType));
+}
+
+void SluiftClient::handleInitialRosterPopulated() {
+    rosterReceived = true;
+}
+
+void SluiftClient::handleIncomingRosterAdd(const JID& item) {
+    pendingEvents.push_back(Event(item, Event::RosterAddType));
+}
+
+void SluiftClient::handleIncomingRosterRemove(const JID& item) {
+    pendingEvents.push_back(Event(item, Event::RosterRemoveType));
+}
+
+void SluiftClient::handleIncomingRosterUpdate(const JID& item) {
+    pendingEvents.push_back(Event(item, Event::RosterUpdateType));
+}
+
+void SluiftClient::handleRequestResponse(std::shared_ptr<Payload> response, std::shared_ptr<ErrorPayload> error) {
+    requestResponse = response;
+    requestError = error;
+    requestResponseReceived = true;
+}
+
+void SluiftClient::handleDisconnected(const boost::optional<ClientError>& error) {
+    disconnectedError = error;
+}
+
+Sluift::Response SluiftClient::doSendRequest(std::shared_ptr<Request> request, int timeout) {
+    requestResponse.reset();
+    requestError.reset();
+    requestResponseReceived = false;
+    request->send();
+
+    Watchdog watchdog(timeout, networkFactories->getTimerFactory());
+    while (!watchdog.getTimedOut() && !requestResponseReceived) {
+        eventLoop->runUntilEvents();
+    }
+    return Sluift::Response(requestResponse, watchdog.getTimedOut() ?
+            std::make_shared<ErrorPayload>(ErrorPayload::RemoteServerTimeout) : requestError);
+}