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;

				nick = nick.substr(0, nick.find("/"));

			}

			np->handleSubject(user, TO_UTF8(m->parameters().value(1)) + suffix, m_topicData, nick);

			break;

		case 352:

			if (m->parameters().value(6).toUpper().startsWith("G")) {

				channel = m->parameters().value(1);

				nick = TO_UTF8(m->parameters().value(5));

				np->handleParticipantChanged(user, nick, TO_UTF8(channel) + suffix, m_modes[TO_UTF8(channel) + nick], pbnetwork::STATUS_AWAY);

			}

			break;

		case 353:

			channel = m->parameters().value(2);

			members = m->parameters().value(3).split(" ");

			LOG4CXX_INFO(logger, user << ": Received members for " << TO_UTF8(channel) << suffix);

			for (int i = 0; i < members.size(); i++) {

				bool flags = 0;

				std::string nickname = TO_UTF8(members.at(i));

				flags = correctNickname(nickname);

				m_modes[TO_UTF8(channel) + nickname] = flags;

				np->handleParticipantChanged(user, nickname, TO_UTF8(channel) + suffix,(int) flags, pbnetwork::STATUS_ONLINE);

			}

			// ask /who to get away states

			sendCommand(IrcCommand::createWho(channel));

			break;

		case 432:

			np->handleDisconnected(user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Erroneous Nickname");

			break;

		case 321:

			m_rooms.clear();

			m_names.clear();

			break;

		case 322:

			m_rooms.push_back(TO_UTF8(m->parameters().value(1)));

			m_names.push_back(TO_UTF8(m->parameters().value(1)));

			break;

		case 323:

			np->handleRoomList("", m_rooms, m_names);

			break;

		default:

			break;

	}

	//qDebug() << "numeric message received:" << receiver() << origin << code << params;

}

void MyIrcSession::onMessageReceived(IrcMessage *message) {

      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;

};

%global groupname spectrum

%global username spectrum

Summary: XMPP transport

Name: spectrum2

Version: 2.0

Group: Applications/Internet

License: GPLv3

Source0: spectrum2.tar.gz

URL: http://swift.im/

%else

%endif

Requires:      libtransport%{?_isa} = %{version}-%{release}

%description

%prep

%setup -q -n spectrum2

%build

%cmake . -DCMAKE_BUILD_TYPE=Debug

make VERBOSE=1 %{?_smp_mflags}

%install

rm -rf %{buildroot}

make install DESTDIR=%{buildroot}

install -d %{buildroot}%{_localstatedir}/{lib,run,log}/spectrum2

install -p -D -m 755 packaging/fedora/spectrum2.init \

    %{buildroot}%{_initddir}/spectrum2

ln -s /usr/bin/spectrum2_libpurple_backend %{buildroot}/usr/bin/spectrum_libpurple_backend

%pre

getent group %{groupname} >/dev/null || groupadd -r %{groupname}

getent passwd %{username} >/dev/null || \

    useradd -r -g %{groupname} -d %{_localstatedir}/lib/spectrum \

        -s /sbin/nologin \

        -c "spectrum XMPP transport" %{username}

exit 0

# Requires:   libpurple

# 

# %description libircclient-qt-backend

# Spectrum2 libircclient-qt backend

# 

# %files libircclient-qt-backend

# %defattr(-, root, root,-)

# /usr/bin/spectrum_libircclient-qt_backend

%package -n libtransport

Summary:    Libtransport

Group:      Development/Libraries

Requires:   boost

%description -n libtransport

Libtransport library

%files -n libtransport

%defattr(-, root, root,-)

%{_libdir}/libtransport*.so*

/usr/include/transport

%changelog

- Work in progress

* Mon Jul 25 2011 Jan Kaluza <jkaluza@redhat.com> - 1.0-4

- rebuild for new boost

* Wed May 25 2011 Jan Kaluza <jkaluza@redhat.com> - 1.0-3

- fix #706719 - fixed another crash during login

* Tue Apr 26 2011 Jan Kaluza <jkaluza@redhat.com> - 1.0-2

- fix #697832 - fixed crash during login

* Tue Apr 19 2011 Jan Kaluza <jkaluza@redhat.com> - 1.0-1

- update to new upstream version 1.0

* Wed Apr 06 2011 Jan Kaluza <jkaluza@redhat.com> - 1.0-0.11.beta9

- rebuild for new boost

* Tue Mar 15 2011 Jan Kaluza <jkaluza@redhat.com> - 1.0-0.10.beta9

- update to new upstream version 1.0-beta9

* Wed Feb 09 2011 Fedora Release Engineering <rel-eng@lists.fedoraproject.org> - 1.0-0.9.beta8

- Rebuilt for https://fedoraproject.org/wiki/Fedora_15_Mass_Rebuild

* Sun Feb 06 2011 Thomas Spura <tomspur@fedoraproject.org> - 1.0-0.8.beta8

	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;

};