/*

* Copyright (c) 2013 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <string>

#include <Sluift/Completer.h>

#include <Swiften/Base/Override.h>

struct lua_State;

namespace Swift {

class Terminal;

class Console : public Completer {

public:

Console(lua_State* L, Terminal* terminal);

virtual ~Console();

void run();

static int call(lua_State* L, int numberOfArguments, bool keepResult);

private:

std::string getPrompt(bool firstLine) const;

std::string getErrorMessage() const;

bool readCommand();

int tryLoadCommand(const std::string& command);

virtual std::vector<std::string> getCompletions(const std::string&, int start, int end) SWIFTEN_OVERRIDE;

private:

lua_State* L;

Terminal* terminal;

int previousNumberOfReturnArguments;

};

/*

* Copyright (c) 2014 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <boost/shared_ptr.hpp>

namespace Swift {

class SWIFTEN_API ITunesInterface {

public:

struct Track {

std::string name;

std::string artist;

std::string album;

long trackNumber;

double duration;

long rating;

};

ITunesInterface();

virtual ~ITunesInterface();

boost::optional<Track> getCurrentTrack() const;

private:

bool haveApplication() const;

private:

struct Private;

boost::shared_ptr<Private> p;

};

}

/*

* Copyright (c) 2013 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <string>

namespace Swift {

class Completer;

class Terminal {

public:

Terminal();

virtual ~Terminal();

Completer* getCompleter() const {

return completer;

}

void setCompleter(Completer* completer) {

this->completer = completer;

}

virtual boost::optional<std::string> readLine(const std::string& prompt) = 0;

virtual void addToHistory(const std::string& command) = 0;

virtual void printError(const std::string& message) = 0;

private:

Completer* completer;

};

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <string>

#include <vector>

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

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/ToplevelElement.h>

#include <Swiften/JID/JID.h>

namespace Swift {

class Payload;

class SWIFTEN_API Stanza : public ToplevelElement {

public:

typedef boost::shared_ptr<Stanza> ref;

protected:

Stanza();

public:

virtual ~Stanza();

SWIFTEN_DEFAULT_COPY_CONSTRUCTOR(Stanza)

template<typename T>

boost::shared_ptr<T> getPayload() const {

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

boost::shared_ptr<T> result(boost::dynamic_pointer_cast<T>(payloads_[i]));

if (result) {

return result;

}

}

return boost::shared_ptr<T>();

}

/*

* Copyright (c) 2013-2015 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <vector>

#include <Swiften/Elements/JingleS5BTransportPayload.h>

#include <Swiften/Base/API.h>

#include <Swiften/Base/boost_bsignals.h>

namespace Swift {

class TransportSession;

class ErrorPayload;

class ReadBytestream;

class WriteBytestream;

/**

* @brief The FileTransferTransporter class is an abstract factory definition

* to generate SOCKS5 bytestream transports or IBB bytestreams for use in file

* transfers.

*/

class SWIFTEN_API FileTransferTransporter {

public:

virtual ~FileTransferTransporter();

virtual void startGeneratingLocalCandidates() = 0;

virtual void stopGeneratingLocalCandidates() = 0;

virtual void addRemoteCandidates(

const std::vector<JingleS5BTransportPayload::Candidate>&, const std::string&) = 0;

virtual void startTryingRemoteCandidates() = 0;

virtual void stopTryingRemoteCandidates() = 0;

virtual void startActivatingProxy(const JID& proxy) = 0;

virtual void stopActivatingProxy() = 0;

/*

* Copyright (c) 2010 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/FileTransfer/WriteBytestream.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Elements/IBB.h>

#include <Swiften/FileTransfer/FileTransferError.h>

namespace Swift {

class IQRouter;

class SWIFTEN_API IBBReceiveSession {

public:

IBBReceiveSession(

const std::string& id,

const JID& from,

const JID& to,

unsigned long long size,

boost::shared_ptr<WriteBytestream> bytestream,

IQRouter* router);

~IBBReceiveSession();

void start();

void stop();

const JID& getSender() const {

return from;

}

const JID& getReceiver() const {

/*

* Copyright (c) 2010-2013 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <string>

#include <iosfwd>

#include <Swiften/Base/API.h>

namespace Swift {

class IDNConverter;

/**

* This represents the JID used in XMPP

* (RFC6120 - http://tools.ietf.org/html/rfc6120 ).

* For a description of format, see the RFC or page 14 of

* XMPP: The Definitive Guide (Saint-Andre et al.)

*

* Particularly - a Bare JID is a JID without a resource part.

*

* A JID can be invalid (when isValid() returns false). No member methods are

* guaranteed to work correctly if they do.

*/

class SWIFTEN_API JID {

public:

enum CompareType {

WithResource, WithoutResource

};

/**

* Create a JID from its String representation.

*

* e.g.

* wonderland.lit

* wonderland.lit/rabbithole

* alice@wonderland.lit

* alice@wonderland.lit/TeaParty

*

/*

* Copyright (c) 2010 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/asio/io_service.hpp>

#include <boost/asio/ip/tcp.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Network/BoostConnection.h>

#include <Swiften/Network/ConnectionServer.h>

#include <Swiften/EventLoop/EventOwner.h>

namespace Swift {

class SWIFTEN_API BoostConnectionServer : public ConnectionServer, public EventOwner, public boost::enable_shared_from_this<BoostConnectionServer> {

public:

typedef boost::shared_ptr<BoostConnectionServer> ref;

static ref create(int port, boost::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) {

return ref(new BoostConnectionServer(port, ioService, eventLoop));

}

static ref create(const HostAddress &address, int port, boost::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop) {

return ref(new BoostConnectionServer(address, port, ioService, eventLoop));

}

virtual boost::optional<Error> tryStart(); // FIXME: This should become the new start

virtual void start();

virtual void stop();

virtual HostAddressPort getAddressPort() const;

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

private:

BoostConnectionServer(int port, boost::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop);

BoostConnectionServer(const HostAddress &address, int port, boost::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop);

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

void acceptNextConnection();

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

/*

* Copyright (c) 2010 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/shared_ptr.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/HostAddressPort.h>

namespace Swift {

class SWIFTEN_API ConnectionServer {

public:

enum Error {

Conflict,

UnknownError

};

virtual ~ConnectionServer();

virtual HostAddressPort getAddressPort() const = 0;

virtual boost::optional<Error> tryStart() = 0; // FIXME: This should become the new start

virtual void start() = 0;

virtual void stop() = 0;

boost::signal<void (boost::shared_ptr<Connection>)> onNewConnection;

};

}

/*

* Copyright (c) 2010 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <vector>

#include <string>

#include <map>

#include <Swiften/Base/API.h>

#include <Swiften/Parser/Attribute.h>

namespace Swift {

class SWIFTEN_API AttributeMap {

public:

class Entry {

public:

Entry(const Attribute& attribute, const std::string& value) : attribute(attribute), value(value) {

}

const Attribute& getAttribute() const {

return attribute;

}

const std::string& getValue() const {

return value;

}

private:

Attribute attribute;

std::string value;

};

AttributeMap();

std::string getAttribute(const std::string& attribute, const std::string& ns = "") const;

bool getBoolAttribute(const std::string& attribute, bool defaultValue = false) const;

boost::optional<std::string> getAttributeValue(const std::string&) const;