/*

* Copyright (c) 2011 Thilo Cestonaro

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* Copyright (c) 2011-2017 Isode Limited.

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Error.h>

#include <Swiften/Base/String.h>

#include <Swiften/Base/URL.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/Connector.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/Session/SessionStream.h>

#include <Swiften/TLS/TLSError.h>

class BOSHConnectionTest;

namespace Swift {

class XMLParserFactory;

class TLSContextFactory;

class TLSLayer;

struct TLSOptions;

class HighLayer;

class SWIFTEN_API BOSHError : public SessionStream::SessionStreamError {

public:

enum Type {

BadRequest, HostGone, HostUnknown, ImproperAddressing,

InternalServerError, ItemNotFound, OtherRequest, PolicyViolation,

RemoteConnectionFailed, RemoteStreamError, SeeOtherURI, SystemShutdown, UndefinedCondition,

NoError};

BOSHError(Type type) : SessionStream::SessionStreamError(SessionStream::SessionStreamError::ConnectionReadError), type(type) {}

Type getType() const {return type;}

typedef std::shared_ptr<BOSHError> ref;

private:

Type type;

};

class SWIFTEN_API BOSHConnection : public std::enable_shared_from_this<BOSHConnection> {

public:

typedef std::shared_ptr<BOSHConnection> ref;

static ref create(const URL& boshURL, Connector::ref connector, XMLParserFactory* parserFactory, TLSContextFactory* tlsContextFactory, const TLSOptions& tlsOptions) {

return ref(new BOSHConnection(boshURL, connector, parserFactory, tlsContextFactory, tlsOptions));

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <vector>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeString.h>

#include <Swiften/Network/BOSHConnection.h>

#include <Swiften/TLS/CertificateWithKey.h>

#include <Swiften/TLS/TLSOptions.h>

namespace Swift {

class CachingDomainNameResolver;

class EventLoop;

class HTTPTrafficFilter;

class TLSContextFactory;

class CachingDomainNameResolver;

class EventLoop;

class SWIFTEN_API BOSHConnectionPool : public boost::signals2::trackable {

public:

BOSHConnectionPool(const URL& boshURL, DomainNameResolver* resolver, ConnectionFactory* connectionFactory, XMLParserFactory* parserFactory, TLSContextFactory* tlsFactory, TimerFactory* timerFactory, EventLoop* eventLoop, const std::string& to, unsigned long long initialRID, const URL& boshHTTPConnectProxyURL, const SafeString& boshHTTPConnectProxyAuthID, const SafeString& boshHTTPConnectProxyAuthPassword, const TLSOptions& tlsOptions, std::shared_ptr<HTTPTrafficFilter> trafficFilter = std::shared_ptr<HTTPTrafficFilter>());

~BOSHConnectionPool();

void open();

void write(const SafeByteArray& data);

void writeFooter();

void close();

void restartStream();

void setTLSCertificate(CertificateWithKey::ref certWithKey);

bool isTLSEncrypted() const;

Certificate::ref getPeerCertificate() const;

std::vector<Certificate::ref> getPeerCertificateChain() const;

std::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;

boost::signals2::signal<void ()> onTLSConnectionEstablished;

boost::signals2::signal<void (BOSHError::ref)> onSessionTerminated;

boost::signals2::signal<void ()> onSessionStarted;

boost::signals2::signal<void (const SafeByteArray&)> onXMPPDataRead;

boost::signals2::signal<void (const SafeByteArray&)> onBOSHDataRead;

boost::signals2::signal<void (const SafeByteArray&)> onBOSHDataWritten;

private:

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <mutex>

#include <boost/asio/io_service.hpp>

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

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeByteArray.h>

#include <Swiften/EventLoop/EventOwner.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/TLS/Certificate.h>

#include <Swiften/TLS/CertificateVerificationError.h>

#include <Swiften/TLS/CertificateWithKey.h>

namespace Swift {

class EventLoop;

class SWIFTEN_API BoostConnection : public Connection, public EventOwner, public std::enable_shared_from_this<BoostConnection> {

public:

typedef std::shared_ptr<BoostConnection> ref;

virtual ~BoostConnection();

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

return ref(new BoostConnection(ioService, eventLoop));

}

virtual void listen();

virtual void connect(const HostAddressPort& address);

virtual void disconnect();

virtual void write(const SafeByteArray& data);

boost::asio::ip::tcp::socket& getSocket() {

return socket_;

}

virtual HostAddressPort getLocalAddress() const;

virtual HostAddressPort getRemoteAddress() const;

bool setClientCertificate(CertificateWithKey::ref cert);

Certificate::ref getPeerCertificate() const;

std::vector<Certificate::ref> getPeerCertificateChain() const;

std::shared_ptr<CertificateVerificationError> getPeerCertificateVerificationError() const;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/asio/io_service.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Network/BoostConnection.h>

#include <Swiften/Network/ConnectionFactory.h>

namespace Swift {

class SWIFTEN_API BoostConnectionFactory : public ConnectionFactory {

public:

BoostConnectionFactory(std::shared_ptr<boost::asio::io_service>, EventLoop* eventLoop);

virtual std::shared_ptr<Connection> createConnection();

private:

std::shared_ptr<boost::asio::io_service> ioService;

EventLoop* eventLoop;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <boost/asio/io_service.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Network/BoostTimer.h>

#include <Swiften/Network/TimerFactory.h>

namespace Swift {

class EventLoop;

class SWIFTEN_API BoostTimerFactory : public TimerFactory {

public:

BoostTimerFactory(std::shared_ptr<boost::asio::io_service>, EventLoop* eventLoop);

virtual std::shared_ptr<Timer> createTimer(int milliseconds);

private:

std::shared_ptr<boost::asio::io_service> ioService;

EventLoop* eventLoop;

};

}

/*

* Copyright (c) 2010-2011 Thilo Cestonaro

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Network/ProxiedConnection.h>

namespace Swift {

class ConnectionFactory;

class DomainNameResolver;

class HTTPTrafficFilter;

class TimerFactory;

class SWIFTEN_API HTTPConnectProxiedConnection : public ProxiedConnection {

public:

typedef std::shared_ptr<HTTPConnectProxiedConnection> ref;

virtual ~HTTPConnectProxiedConnection();

static ref create(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword) {

return ref(new HTTPConnectProxiedConnection(resolver, connectionFactory, timerFactory, proxyHost, proxyPort, authID, authPassword));

}

void setHTTPTrafficFilter(std::shared_ptr<HTTPTrafficFilter> trafficFilter);

private:

HTTPConnectProxiedConnection(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword);

virtual void initializeProxy();

virtual void handleProxyInitializeData(std::shared_ptr<SafeByteArray> data);

void sendHTTPRequest(const std::string& statusLine, const std::vector<std::pair<std::string, std::string> >& headerFields);

void parseHTTPHeader(const std::string& data, std::string& statusLine, std::vector<std::pair<std::string, std::string> >& headerFields);

private:

SafeByteArray authID_;

SafeByteArray authPassword_;

std::shared_ptr<HTTPTrafficFilter> trafficFilter_;

std::string httpResponseBuffer_;

std::vector<std::pair<std::string, std::string> > nextHTTPRequestHeaders_;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

/*

* Copyright (c) 2010-2011 Thilo Cestonaro

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeString.h>

#include <Swiften/Network/ConnectionFactory.h>

#include <Swiften/Network/HostAddressPort.h>

namespace Swift {

class DomainNameResolver;

class HTTPTrafficFilter;

class SWIFTEN_API HTTPConnectProxiedConnectionFactory : public ConnectionFactory {

public:

HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort, std::shared_ptr<HTTPTrafficFilter> httpTrafficFilter = std::shared_ptr<HTTPTrafficFilter>());

HTTPConnectProxiedConnectionFactory(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort, const SafeString& authID, const SafeString& authPassword, std::shared_ptr<HTTPTrafficFilter> httpTrafficFilter = std::shared_ptr<HTTPTrafficFilter>());

virtual std::shared_ptr<Connection> createConnection();

private:

DomainNameResolver* resolver_;

ConnectionFactory* connectionFactory_;

TimerFactory* timerFactory_;

std::string proxyHost_;

int proxyPort_;

SafeString authID_;

SafeString authPassword_;

std::shared_ptr<HTTPTrafficFilter> httpTrafficFilter_;

};

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <Swiften/Base/API.h>

namespace Swift {

class ConnectionFactory;

class ConnectionServerFactory;

class EventLoop;

class IDNConverter;

class NetworkEnvironment;

/**

* An interface collecting network factories.

*/

class SWIFTEN_API NetworkFactories {

public:

virtual ~NetworkFactories();

virtual TimerFactory* getTimerFactory() const = 0;

virtual ConnectionFactory* getConnectionFactory() const = 0;

virtual DomainNameResolver* getDomainNameResolver() const = 0;

virtual ConnectionServerFactory* getConnectionServerFactory() const = 0;

virtual NATTraverser* getNATTraverser() const = 0;

virtual NetworkEnvironment* getNetworkEnvironment() const = 0;

virtual XMLParserFactory* getXMLParserFactory() const = 0;

virtual TLSContextFactory* getTLSContextFactory() const = 0;

virtual ProxyProvider* getProxyProvider() const = 0;

virtual EventLoop* getEventLoop() const = 0;

virtual IDNConverter* getIDNConverter() const = 0;

virtual CryptoProvider* getCryptoProvider() const = 0;

};

}

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <condition_variable>

#include <deque>

#include <mutex>

#include <thread>

#include <boost/logic/tribool.hpp>

#include <boost/optional.hpp>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Atomic.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/Network/NATTraverser.h>

#include <Swiften/Network/NullNATTraversalInterface.h>

namespace Swift {

class EventLoop;

class NATTraversalGetPublicIPRequest;

class NATTraversalForwardPortRequest;

class NATTraversalRemovePortForwardingRequest;

class PlatformNATTraversalRequest;

class NATPMPInterface;

class MiniUPnPInterface;

class NATTraversalInterface;

class SWIFTEN_API PlatformNATTraversalWorker : public NATTraverser {

friend class PlatformNATTraversalRequest;

public:

PlatformNATTraversalWorker(EventLoop* eventLoop);

virtual ~PlatformNATTraversalWorker();

std::shared_ptr<NATTraversalGetPublicIPRequest> createGetPublicIPRequest();

std::shared_ptr<NATTraversalForwardPortRequest> createForwardPortRequest(int localPort, int publicPort);

std::shared_ptr<NATTraversalRemovePortForwardingRequest> createRemovePortForwardingRequest(int localPort, int publicPort);

private:

NATTraversalInterface* getNATTraversalInterface() const;

void addRequestToQueue(std::shared_ptr<PlatformNATTraversalRequest>);

void start();

void stop();

EventLoop* getEventLoop() const {

return eventLoop;

}

private:

EventLoop* eventLoop;

Atomic<bool> stopRequested;

std::thread* thread;

std::deque<std::shared_ptr<PlatformNATTraversalRequest> > queue;

std::mutex queueMutex;

std::condition_variable queueNonEmpty;

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/SafeString.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/Connector.h>

#include <Swiften/Network/HostAddressPort.h>

namespace Swift {

class ConnectionFactory;

class SWIFTEN_API ProxiedConnection : public Connection, public std::enable_shared_from_this<ProxiedConnection> {

public:

ProxiedConnection(DomainNameResolver* resolver, ConnectionFactory* connectionFactory, TimerFactory* timerFactory, const std::string& proxyHost, int proxyPort);

virtual ~ProxiedConnection();

virtual void listen();

virtual void connect(const HostAddressPort& address);

virtual void disconnect();

virtual void write(const SafeByteArray& data);

virtual HostAddressPort getLocalAddress() const;

virtual HostAddressPort getRemoteAddress() const;

private:

void handleConnectFinished(Connection::ref connection);

void handleDataRead(std::shared_ptr<SafeByteArray> data);

void handleDisconnected(const boost::optional<Error>& error);

void cancelConnector();

protected:

void setProxyInitializeFinished(bool success);

virtual void initializeProxy() = 0;

virtual void handleProxyInitializeData(std::shared_ptr<SafeByteArray> data) = 0;

const HostAddressPort& getServer() const {

return server_;

/*

* Copyright (c) 2013 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <boost/asio.hpp>

#include <Swiften/EventLoop/EventOwner.h>

#include <Swiften/Network/DomainNameResolver.h>

#include <Swiften/Network/Timer.h>

struct ub_ctx;

struct ub_result;

namespace Swift {

class EventLoop;

class IDNConverter;

class UnboundDomainNameResolver;

class UnboundQuery;

class UnboundDomainNameResolver : public DomainNameResolver, public EventOwner, public std::enable_shared_from_this<UnboundDomainNameResolver> {

public:

UnboundDomainNameResolver(IDNConverter* idnConverter, std::shared_ptr<boost::asio::io_service> ioService, EventLoop* eventLoop);

virtual ~UnboundDomainNameResolver();

virtual std::shared_ptr<DomainNameServiceQuery> createServiceQuery(const std::string& serviceLookupPrefix, const std::string& domain);

virtual std::shared_ptr<DomainNameAddressQuery> createAddressQuery(const std::string& name);

static void unbound_callback_wrapper(void* data, int err, ub_result* result);

private:

void unbound_callback(std::shared_ptr<UnboundQuery> query, int err, ub_result* result);

void handleUBSocketReadable(boost::system::error_code);

void processData();

private:

IDNConverter* idnConverter;

std::shared_ptr<EventOwner> eventOwner;

std::shared_ptr<boost::asio::io_service> ioService;

boost::asio::posix::stream_descriptor ubDescriptior;

EventLoop* eventLoop;

ub_ctx* ubContext;

};

}