ADD_DEFINITIONS(-D_WIN32_WINNT=0x501)

	ADD_DEFINITIONS(-DWIN32_LEAN_AND_MEAN)

	ADD_DEFINITIONS(-DBOOST_USE_WINDOWS_H)

	ADD_DEFINITIONS(-DBOOST_THREAD_USE_LIB)

endif()

if(CMAKE_BUILD_TYPE MATCHES Debug)

	if (CMAKE_COMPILER_IS_GNUCXX)

		ADD_DEFINITIONS(-O0)

		ADD_DEFINITIONS(-ggdb)

	endif()

	ADD_DEFINITIONS(-DDEBUG)

#include "transport/ThreadPool.h"

#include "../libtwitcurl/twitcurl.h"

#include "../TwitterResponseParser.h"

#include "transport/Logging.h"

#include <string>

#include <boost/function.hpp>

#include <boost/bind.hpp>

#include <iostream>

using namespace Transport;

#include "../TwitterResponseParser.h"

#include "transport/ThreadPool.h"

#include "transport/Logging.h"

#include "transport/Config.h"

#include <string>

#include <boost/function.hpp>

#include <boost/bind.hpp>

#include <iostream>

#include <sstream>

using namespace Transport;

#include "unistd.h"

#include "signal.h"

#include "sys/wait.h"

#include "sys/signal.h"

#endif

#include <boost/algorithm/string.hpp>

#include <boost/thread.hpp>

#include <boost/thread/mutex.hpp>

#include "twitcurl.h"

#include "TwitterResponseParser.h"

 * See Documentation/Licenses/GPLv3.txt for more information.

 */

#pragma once

#include <boost/shared_ptr.hpp>

#include "Swiften/SwiftenCompat.h"

#include <Swiften/FileTransfer/OutgoingFileTransfer.h>

#include <Swiften/FileTransfer/ReadBytestream.h>

#include <Swiften/FileTransfer/FileTransferError.h>

			MyOutgoingSIFileTransfer(const std::string& id, const JID& from, const JID& to, const std::string& name, int size, const std::string& description, SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ReadBytestream> bytestream, IQRouter* iqRouter, SOCKS5BytestreamServer* socksServer, SOCKS5BytestreamRegistry* registry);

			virtual void start();

			virtual void stop();

			virtual void cancel();

		private:

			void handleStreamInitiationRequestResponse(StreamInitiation::ref, ErrorPayload::ref);

			void handleBytestreamsRequestResponse(Bytestreams::ref, ErrorPayload::ref);

			void finish(boost::optional<FileTransferError> error);

			void handleIBBSessionFinished(boost::optional<FileTransferError> error);

 * Licensed under the GNU General Public License v3.

 * See Documentation/Licenses/GPLv3.txt for more information.

 */

#include <Swiften/Network/DummyConnectionServer.h>

#include <boost/bind.hpp>

#include <boost/system/system_error.hpp>

#include <boost/asio/placeholders.hpp>

#include <Swiften/EventLoop/EventLoop.h>

#include "Swiften/Server/Server.h"

#include <string>

#include <boost/bind.hpp>

#include <boost/foreach.hpp>

#include "Swiften/Base/String.h"

#include "Swiften/Network/Connection.h"

#include "Swiften/Network/ConnectionServer.h"

#include "Swiften/Network/ConnectionServerFactory.h"

#include "Swiften/Elements/Element.h"

// 		session->finishSession();

// 	}

	serverFromClientSessions.clear();

	if (serverFromClientConnectionServer) {

		serverFromClientConnectionServer->stop();

			connection.disconnect();

		}

		serverFromClientConnectionServerSignalConnections.clear();

		serverFromClientConnectionServer.reset();

	}

 */

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/optional.hpp>

#include <vector>

#include "Swiften/Network/BoostIOServiceThread.h"

#include "Swiften/Network/ConnectionServer.h"

#include "Swiften/Server/UserRegistry.h"

#include "Swiften/Server/ServerSession.h"

#include "Swiften/Entity/Entity.h"

#include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"

#include "Swiften/Serializer/PayloadSerializers/FullPayloadSerializerCollection.h"

#include "Swiften/SwiftenCompat.h"

#include <Swiften/TLS/CertificateWithKey.h>

#include <Swiften/Parser/PlatformXMLParserFactory.h>

namespace Swift {

	class ConnectionServer;

	class SessionTracer;

	class EventLoop;

	class NetworkFactories;

			}

			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ConnectionServer> getConnectionServer() const {

				return serverFromClientConnectionServer;

			}

			void addTLSEncryption(TLSServerContextFactory* tlsContextFactory, CertificateWithKey::ref cert);

		private:

			void handleNewClientConnection(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Connection> c);

			void handleSessionStarted(SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession>);

			UserRegistry *userRegistry_;

			int port_;

			EventLoop* eventLoop;

			NetworkFactories* networkFactories_;

			bool stopping;

			SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ConnectionServer> serverFromClientConnectionServer;

			std::list<SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<ServerFromClientSession> > serverFromClientSessions;

			JID selfJID;

			StanzaChannel *stanzaChannel_;

			IQRouter *iqRouter_;

			TLSServerContextFactory *tlsFactory;

			CertificateWithKey::ref cert;

 */

#pragma once

#include <boost/shared_ptr.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <string>

#include <Swiften/Session/Session.h>

#include <Swiften/JID/JID.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Base/ByteArray.h>

					PayloadSerializerCollection* payloadSerializers,

					UserRegistry* userRegistry,

					XMLParserFactory* factory,

					Swift::JID remoteJID = Swift::JID());

			~ServerFromClientSession();

			void setAllowSASLEXTERNAL();

			const std::string &getUser() {

				return user_;

			}

			void addTLSEncryption(TLSServerContextFactory* tlsContextFactory, CertificateWithKey::ref cert);

 */

#pragma once

#include <string>

#include <Swiften/Base/SafeByteArray.h>

#include "Swiften/Server/ServerFromClientSession.h"

namespace Swift {

	class JID;

	class UserRegistry {

/*

 * Copyright (c) 2010 Remko Tronçon

 * Licensed under the GNU General Public License v3.

 * See Documentation/Licenses/GPLv3.txt for more information.

 */

#include "Swiften/Base/SafeByteArray.h"

#include "Swiften/StreamStack/StreamLayer.h"

#include "Swiften/TLS/Certificate.h"

#include <Swiften/TLS/CertificateWithKey.h>

#include "Swiften/TLS/CertificateVerificationError.h"

#include "Swiften/SwiftenCompat.h"

			TLSServerContext* getContext() const {

				return context;

			}

		public:

		private:

			TLSServerContext* context;

	};

}

/*

 * Define macros for Swiften compatible shared pointer and signal namespaces.

 *

 * Using these it is possible to declare shared pointers and signals like this:

 *

 * SWIFTEN_SIGNAL_NAMESPACE::signal signal;

 * SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<Type> ptr;

 *

 * These are guaranteed to be the same implementation as Swift uses internally,

 * thus can be used when passign/retrieveing data from/to swiften.

 *

 * This is due to Swift 4 moved from boost::shared_ptr to SWIFTEN_SHRPTR_NAMESPACE::shared_ptr

 * and from boost::signals to boost::signals2 .

 */

#if (SWIFTEN_VERSION >= 0x040000)

#define SWIFTEN_UNIQUE_PTR std::unique_ptr

#define SWIFTEN_SHRPTR_NAMESPACE std

#define SWIFTEN_SIGNAL_NAMESPACE boost::signals2

#define SWIFT_HOSTADDRESS(x) *(Swift::HostAddress::fromString(x))

#else

#define SWIFTEN_UNIQUE_PTR std::auto_ptr

#define SWIFTEN_SHRPTR_NAMESPACE boost

#define SWIFT_HOSTADDRESS(x) Swift::HostAddress(x)

#endif

 * See Documentation/Licenses/GPLv3.txt for more information.

 */

#pragma once

#include <boost/shared_ptr.hpp>

#include "Swiften/Base/SafeByteArray.h"

#include "Swiften/TLS/Certificate.h"

#include <Swiften/TLS/CertificateWithKey.h>

#include "Swiften/TLS/CertificateVerificationError.h"

namespace Swift {

	class PKCS12Certificate;

	class TLSServerContext {

		public:

			virtual Certificate::ref getPeerCertificate() const = 0;

			virtual CertificateVerificationError::ref getPeerCertificateVerificationError() const = 0;

			virtual ByteArray getFinishMessage() const = 0;

		public:

	};

}

#include <boost/program_options.hpp>

#include <boost/foreach.hpp>

#include <boost/format.hpp>

#include <boost/algorithm/string.hpp>

#include <boost/assign.hpp>

#include <boost/bind.hpp>

namespace Transport {

template <class myType>

const myType &safeAs(const boost::program_options::variable_value &var, const myType &def) {

	try  {

		std::string getCommandLineArgs() const;

		/// Returns path to config file from which data were loaded.

		const std::string &getConfigFile() { return m_file; }

		/// This signal is emitted when config is loaded/reloaded.

		void updateBackendConfig(const std::string &backendConfig);

		static Config *createFromArgs(int argc, char **argv, std::string &error, std::string &host, int &port);

	private:

		int m_argc;

		char **m_argv;

#include "Swiften/Elements/Message.h"

#include "Swiften/Elements/IQ.h"

#include "Swiften/Elements/DiscoInfo.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/SwiftenCompat.h"

namespace Transport {

class Config;

class UserRegistry;

class Component;

class User;

		virtual std::string setOAuth2Code(const std::string &code, const std::string &state) { return "OAuth2 code is not needed for this frontend."; }

		virtual std::string getOAuth2URL(const std::vector<std::string> &args) { return ""; }

		virtual std::string getRegistrationFields() { return "Jabber ID\n3rd-party network username\n3rd-party network password"; }

		virtual bool isRawXMLEnabled() { return false; }

};

}

#include "transport/ThreadPool.h"

#include <iostream>

#include <sstream>

#include <string.h>

#include "rapidjson/document.h"

namespace Transport {

class HTTPRequest : public Thread {

	public:

		typedef enum { Get } Type;

		void finalize();

		const std::string &getURL() {

			return m_url;

		}

		static void globalInit() {

			curl_global_init(CURL_GLOBAL_ALL);

		}

		static void globalCleanup() {

 */

#pragma once

#include <string>

#include <map>

#include "Swiften/FileTransfer/ReadBytestream.h"

#include "Swiften/SwiftenCompat.h"

namespace Transport {

		virtual SWIFTEN_SHRPTR_NAMESPACE::shared_ptr<std::vector<unsigned char> > read(size_t size);

		void setFinished() { m_finished = true; }

		bool isFinished() const;

	private:

		bool m_finished;

		std::string m_data;

		bool neededData;

		unsigned long m_sent;

 */

#pragma once

#include <map>

#include <string>

#include <Swiften/Elements/Presence.h>

#include <Swiften/Client/StanzaChannel.h>

namespace Transport {

class Frontend;

class PresenceOracle {

		Swift::Presence::ref getHighestPriorityPresence(const Swift::JID& bareJID) const;

		std::vector<Swift::Presence::ref> getAllPresence(const Swift::JID& bareJID) const;

		void clearPresences(const Swift::JID& bareJID);

	public:

	private:

		void handleIncomingPresence(Swift::Presence::ref presence);

		void handleStanzaChannelAvailableChanged(bool);

	private:

#pragma once

#include <string>

#include <algorithm>

#include <map>

#include <boost/pool/pool_alloc.hpp>

#include <boost/pool/object_pool.hpp>

// #include "rosterstorage.h"

#include "Swiften/Elements/RosterPayload.h"

#include "Swiften/Queries/GenericRequest.h"

#include "Swiften/Roster/SetRosterRequest.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/Network/Timer.h"

namespace Transport {

class Buddy;

class User;

class Component;

		bool isRemoteRosterSupported() {

			return m_supportRemoteRoster;

		}

		/// Called when new Buddy is added to this roster.

		/// \param buddy newly added Buddy

		/// Called when Buddy has been removed from this roster.

		/// \param buddy removed Buddy

		void handleBuddyChanged(Buddy *buddy);

		void handleSubscription(Swift::Presence::ref presence);

		void sendBuddyRosterRemove(Buddy *buddy);

#pragma once 

#include <boost/thread.hpp>

#include <boost/thread/mutex.hpp>

#include <queue>

#include <iostream>

#include "Swiften/EventLoop/EventLoop.h"

namespace Transport {

/*

 * Thread serves as a base class for any code that has to be excuted as a thread

 * by the ThreadPool class. The run method defines the code that has to be run

	boost::mutex count_lock;

	boost::mutex pool_lock;

	boost::mutex criticalregion;

	Swift::EventLoop *loop;

	public:

	ThreadPool(Swift::EventLoop *loop, int maxthreads);

	~ThreadPool();

	void runAsThread(Thread *t);

	int getActiveThreadCount(); 

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#pragma once

#include <vector>

#include <boost/bind.hpp>

#include "Swiften/Network/BoostTimerFactory.h"

#include "Swiften/Network/BoostIOServiceThread.h"

#include "Swiften/Network/NetworkFactories.h"

#include "Swiften/Elements/DiscoInfo.h"

#include "Swiften/Elements/Presence.h"

			/// \return Transport Factory used to create basic Transport components.

			Factory *getFactory() { return m_factory; }

			/// This signal is emitted when server disconnects the transport because of some error.

			/// \param error disconnection error

			/// This signal is emitted when transport successfully connects the server.

			/// This signal is emitted when XML stanza is sent to server.

			Config *getConfig() { return m_config; }

			/// It's emitted only for presences addressed to transport itself

			/// (for example to="j2j.domain.tld") and for presences comming to

			/// MUC (for example to="#chat%irc.freenode.org@irc.domain.tld")

			/// \param presence Presence.

			void handlePresence(Swift::Presence::ref presence);

			void handleConnected();

			void handleConnectionError(const std::string &error);

			void handleDataRead(const std::string &data);

			void handleDataWritten(const std::string &data);

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#pragma once

#include <time.h>

#include "transport/StorageBackend.h"

#include <Swiften/FileTransfer/OutgoingFileTransfer.h>

#include "Swiften/Elements/SpectrumErrorPayload.h"

#include "Swiften/JID/JID.h"

#include "Swiften/Elements/Presence.h"

		void setStorageBackend(StorageBackend *storageBackend) {

			m_storageBackend = storageBackend;

		}

		void leaveRoom(const std::string &room);

	private:

		void onConnectingTimeout();

		Swift::JID m_jid;

		Component *m_component;

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#pragma once

#include <string>

#include <map>

#include "Swiften/Elements/Message.h"

#include "Swiften/Elements/Presence.h"

#include "Swiften/JID/JID.h"

#include "Swiften/Disco/EntityCapsProvider.h"

		void removeAllUsers(bool onUserBehalf = true);

// 		Swift::DiscoInfo::ref getCaps(const Swift::JID&) const;

		/// Called when new User class is created.

		/// \param user newly created User class

		/// Called when User class is going to be removed

		/// \param user removed User class

		/// Returns true if user is connected.

		/// \return True if user is connected.

		bool isUserConnected(const std::string &barejid) const {

			return m_users.find(barejid) != m_users.end();

		}

#pragma once