void handleLeaveRoomRequest(const std::string &user, const std::string &room);

		void handleRoomSubjectChangedRequest(const std::string &user, const std::string &room, const std::string &message);

		void tryNextServer();

	public slots:

		void readData();

		void sendData(const std::string &string);

	private:

		MyIrcSession *createSession(const std::string &user, const std::string &hostname, const std::string &nickname, const std::string &password, const std::string &suffix = "");

		std::string getSessionName(const std::string &user, const std::string &legacyName);

		std::string getTargetName(const std::string &legacyName);

	private:

		Config *config;

		QTcpSocket *m_socket;

		std::map<std::string, MyIrcSession *> m_sessions;

		std::vector<std::string> m_servers;

		int m_currentServer;

		std::string m_identify;

		bool m_firstPing;

      char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);

      char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

      for (i = 0; (i < 3); i++)

        ret += char_array_3[i];

      i = 0;

    }

  }

  if (i) {

    for (j = i; j <4; j++)

      char_array_4[j] = 0;

    for (j = 0; j <4; j++)

      char_array_4[j] = base64_chars.find(char_array_4[j]);

    char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);

    char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);

    char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

    for (j = 0; (j < i - 1); j++) ret += char_array_3[j];

  }

  return ret;

#include <string>

std::string base64_encode(unsigned char const* , unsigned int len);

}

std::string urlencode( const std::string &c )

{

    std::string escaped;

	int max = c.length();

	for(int i=0; i<max; i++)

	{

		if ( (48 <= c[i] && c[i] <= 57) ||//0-9

			(65 <= c[i] && c[i] <= 90) ||//ABC...XYZ

			(97 <= c[i] && c[i] <= 122) || //abc...xyz

			(c[i]=='~' || c[i]=='-' || c[i]=='_' || c[i]=='.')

			)

		{

			escaped.append( &c[i], 1);

		}

		else

		{

			escaped.append("%");

			escaped.append( char2hex(c[i]) );//converts char 255 to string "FF"

		}

	}

	return escaped;

#ifndef __URLENCODE_H__

#define __URLENCODE_H__

#include <iostream>

#include <string>

std::string char2hex( char dec );

std::string urlencode( const std::string &c );

class DiscoItemsResponder : public Swift::GetResponder<Swift::DiscoItems> {

	public:

		DiscoItemsResponder(Component *component);

		~DiscoItemsResponder();

		Swift::CapsInfo &getBuddyCapsInfo();

		void addAdHocCommand(const std::string &node, const std::string &name);

// 		void removeAdHocCommand(const std::string &node);

		void addRoom(const std::string &node, const std::string &name);

		void clearRooms();

	private:

		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoItems> payload);

	private:

		Component *m_component;

		boost::shared_ptr<Swift::DiscoItems> m_commands;

		boost::shared_ptr<Swift::DiscoItems> m_rooms;

		DiscoInfoResponder *m_discoInfoResponder;

};

 */

#pragma once

#include <vector>

#include "Swiften/Swiften.h"

#include "Swiften/Queries/Responder.h"

#include "Swiften/Elements/GatewayPayload.h"

namespace Transport {

class UserManager;

class GatewayResponder : public Swift::Responder<Swift::GatewayPayload> {

	public:

		GatewayResponder(Swift::IQRouter *router, UserManager *userManager);

		~GatewayResponder();

	private:

		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::GatewayPayload> payload);

		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::GatewayPayload> payload);

		UserManager *m_userManager;

};

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * 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 <vector>

#ifndef WIN32

#include "signal.h"

#endif

namespace Transport {

#ifndef WIN32

	void process_mem_usage(double& shared, double& resident_set, pid_t pid = 0);

#endif

#include "Swiften/Elements/RosterPayload.h"

namespace Transport {

class UserManager;

class Buddy;

class RosterResponder : public Swift::Responder<Swift::RosterPayload> {

	public:

		RosterResponder(Swift::IQRouter *router, UserManager *userManager);

		~RosterResponder();

		boost::signal<void (Buddy *, const Swift::RosterItemPayload &item)> onBuddyUpdated;

		boost::signal<void (Buddy *)> onBuddyRemoved;

		boost::signal<void (Buddy *, const Swift::RosterItemPayload &item)> onBuddyAdded;

	private:

		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);

		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::RosterPayload> payload);

		UserManager *m_userManager;

};

	ServiceStatusHandle = RegisterServiceCtrlHandlerA(ServiceName, ServiceControlHandler);

	if (ServiceStatusHandle) {

		ServiceStatus.dwCurrentState = SERVICE_START_PENDING;

		SetServiceStatus(ServiceStatusHandle, &ServiceStatus);

		ServiceStatus.dwControlsAccepted |= (SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);

		ServiceStatus.dwCurrentState = SERVICE_RUNNING;

		SetServiceStatus(ServiceStatusHandle, &ServiceStatus);

		mainloop();

		ServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;

		SetServiceStatus(ServiceStatusHandle, &ServiceStatus);

		ServiceStatus.dwControlsAccepted &= ~(SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN);

		ServiceStatus.dwCurrentState = SERVICE_STOPPED;

		SetServiceStatus(ServiceStatusHandle, &ServiceStatus);

	}	

}

void ServiceWrapper::RunService() {

	SERVICE_TABLE_ENTRYA serviceTable[] = {

		{ ServiceName, ServiceMain },

		{ NULL, NULL}

	};

	StartServiceCtrlDispatcherA(serviceTable);

#include "transport/config.h"

#include "transport/protocol.pb.h"

#include "Swiften/Swiften.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

std::string searchForBinary(const std::string &binary);

// Executes new backend

unsigned long exec_(std::string path, std::string config, std::string jid = "");

int getPort(const std::string &portfile);

int isRunning(const std::string &pidfile);

int start_instances(ManagerConfig *config, const std::string &_jid = "");

void stop_instances(ManagerConfig *config, const std::string &_jid = "");

int show_status(ManagerConfig *config);

void ask_local_server(ManagerConfig *config, Swift::BoostNetworkFactories &networkFactories, const std::string &jid, const std::string &message);

std::vector<std::string> show_list(ManagerConfig *config, bool show = true);

#include <vector>

#include "Swiften/Swiften.h"

#include "Swiften/Queries/SetResponder.h"

#include "transport/BlockPayload.h"

namespace Transport {

class UserManager;

class Buddy;

class BlockResponder : public Swift::SetResponder<Transport::BlockPayload> {

	public:

		BlockResponder(Swift::IQRouter *router, UserManager *userManager);

		~BlockResponder();

		boost::signal<void (Buddy *)> onBlockToggled;

	private:

		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Transport::BlockPayload> payload);

		UserManager *m_userManager;

};

		void setBuddyFeatures(std::list<std::string> &features);

		void addRoom(const std::string &jid, const std::string &name);

		void clearRooms();

		void addAdHocCommand(const std::string &node, const std::string &name);

		boost::signal<void (const Swift::CapsInfo &capsInfo)> onBuddyCapsInfoChanged;

		Swift::CapsInfo &getBuddyCapsInfo() {

				return m_capsInfo;

		}

	private:

		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoInfo> payload);

		Swift::DiscoInfo m_transportInfo;

		Swift::DiscoInfo m_buddyInfo;

		Config *m_config;

		Swift::CapsInfo m_capsInfo;

		std::map<std::string, std::string> m_rooms;

		std::map<std::string, std::string> m_commands;

};

#pragma once

#include <vector>

#include "Swiften/Swiften.h"

#include "Swiften/Queries/Responder.h"

#include "Swiften/Elements/RosterPayload.h"

namespace Transport {

class StorageBackend;

class UserManager;

class StorageResponder : public Swift::Responder<Swift::PrivateStorage> {

	public:

		StorageResponder(Swift::IQRouter *router, StorageBackend *storageBackend, UserManager *userManager);

		~StorageResponder();

	private:

		virtual bool handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::PrivateStorage> payload);

		virtual bool handleSetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::PrivateStorage> payload);

		StorageBackend *m_storageBackend;

		UserManager *m_userManager;

};