/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <string>

#include <vector>

#include <boost/date_time/posix_time/ptime.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 std::shared_ptr<Stanza> ref;

protected:

Stanza();

public:

virtual ~Stanza();

SWIFTEN_DEFAULT_COPY_CONSTRUCTOR(Stanza)

template<typename T>

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

for (const auto& payload : payloads_) {

std::shared_ptr<T> result(std::dynamic_pointer_cast<T>(payload));

if (result) {

return result;

}

}

return std::shared_ptr<T>();

}

/*

* Copyright (c) 2013-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <vector>

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/JingleS5BTransportPayload.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-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Elements/IBB.h>

#include <Swiften/FileTransfer/FileTransferError.h>

#include <Swiften/FileTransfer/WriteBytestream.h>

#include <Swiften/JID/JID.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,

std::shared_ptr<WriteBytestream> bytestream,

IQRouter* router);

~IBBReceiveSession();

void start();

void stop();

const JID& getSender() const {

return from;

}

const JID& getReceiver() const {

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <iosfwd>

#include <string>

#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

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <boost/asio/io_service.hpp>

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

#include <boost/signals2.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/EventLoop/EventOwner.h>

#include <Swiften/Network/BoostConnection.h>

#include <Swiften/Network/ConnectionServer.h>

namespace Swift {

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

public:

typedef std::shared_ptr<BoostConnectionServer> ref;

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

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

}

static ref create(const HostAddress &address, int port, std::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::signals2::signal<void (boost::optional<Error>)> onStopped;

private:

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

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <boost/signals2.hpp>

#include <Swiften/Base/API.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::signals2::signal<void (std::shared_ptr<Connection>)> onNewConnection;

};

}

/*

* Copyright (c) 2010-2016 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <map>

#include <string>

#include <vector>

#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;