return games;

		}

			std::cout << "aaa\n";

			if (message.find("start") == 0) {

				std::string game = message.substr(6);

	return r;

}

	std::string session = getSessionName(user, legacyName);

	if (m_sessions[session] == NULL) {

		LOG4CXX_WARN(logger, user << ": Session name: " << session << ", No session for user");

		void handleLogoutRequest(const std::string &user, const std::string &legacyName);

		void handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password);

			}

		}

			PurpleAccount *account = m_sessions[user];

			if (account) {

				PurpleConversation *conv = purple_find_conversation_with_account_wrapped(PURPLE_CONV_TYPE_CHAT, legacyName.c_str(), account);

			}

		}

			YahooLocalAccount *account = m_users[user];

			if (account) {

				LOG4CXX_INFO(logger, "Sending message from " << user << " to " << legacyName << ": " << message << ".");

			}

		}

			Skype *skype = m_sessions[user];

			if (skype) {

				skype->send_command("MESSAGE " + legacyName + " " + message);

		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {

		}

			// Remove trailing +, because smstools doesn't use it in "From: " field for received messages.

			std::string n = legacyName;

			if (n.find("+") == 0) {

			}

		}

			LOG4CXX_INFO(logger, "Sending message from " << user << " to " << legacyName << ".");

			boost::shared_ptr<Swift::Client> client = m_users[user];

			if (client) {

void Plugin::handleLogoutRequest(const std::string &user, const std::string &legacyName) {

}

	LOG4CXX_INFO(logger, "Sending message from " << user << " to " << legacyName << ".");

	if (legacyName == "echo") {

		handleMessage(user, legacyName, message);

		void handleLogoutRequest(const std::string &user, const std::string &legacyName);

		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups);

}

// Messages to be sent to Twitter 

{

	LOG4CXX_INFO(logger, "Received " << user << " --> " << legacyName << " - " << message)

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

		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups);

		boost::signal<void ()> onConfigReloaded;

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

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

		/// \param xhtml XHTML message.

		void handleMessage(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &nickname = "", const std::string &xhtml = "", const std::string &timestamp = "", bool headline = false);

		/// Call this function when subject in room changed.

		/// \param user XMPP JID of user for which this event occurs. You can get it from NetworkPlugin::handleLoginRequest(). (eg. "user%gmail.com@xmpp.domain.tld")

		/// \param legacyName Name of room. (eg. "#spectrum")

		/// \param legacyName Legacy network name of buddy or room.

		/// \param message Plain text message.

		/// \param xhtml XHTML message.

		/// Called when XMPP user requests VCard of buddy.

		/// \param user XMPP JID of user for which this event occurs.

		void handleBuddyChangedPayload(const std::string &payload);

		void handleBuddyRemovedPayload(const std::string &payload);

		void handleConvMessagePayload(const std::string &payload, bool subject = false);

		void handleParticipantChangedPayload(const std::string &payload);

		void handleRoomChangedPayload(const std::string &payload);

		void handleVCardPayload(const std::string &payload);

		void pingTimeout();

		void sendPing(Backend *c);

		UserManager *m_userManager;

		VCardResponder *m_vcardResponder;

		std::list<Backend *>  m_clients;

		Swift::Timer::ref m_pingTimer;

		Swift::Timer::ref m_collectTimer;

		Component *m_component;

		std::list<User *> m_waitingUsers;

		bool m_isNextLongRun;

		AdminInterface *m_adminInterface;

		bool m_startingBackend;

		DiscoItemsResponder *m_discoItemsResponder;

};

}

	optional string xhtml = 5;

	optional string timestamp = 6;

	optional bool headline = 7;

}

message Room {

		TYPE_BACKEND_CONFIG			= 30;

		TYPE_QUERY					= 31;

		TYPE_ROOM_LIST				= 32;

	}

	required Type type = 1;

	optional bytes payload = 2;

		/// Returns full JID which supports particular feature or invalid JID.

		/// \param feature disco#info feature.

		/// \return full JID which supports particular feature or invalid JID.

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

	send(message);

}

void NetworkPlugin::handleAttention(const std::string &user, const std::string &buddyName, const std::string &msg) {

	pbnetwork::ConversationMessage m;

	m.set_username(user);

		return;

	}

}

void NetworkPlugin::handleRoomSubjectChangedPayload(const std::string &data) {

}

void AdHocManager::handleUserCreated(User *user) {

	for (std::map<std::string, AdHocCommandFactory *>::const_iterator it = m_factories.begin(); it != m_factories.end(); it++) {

		for (std::map<std::string, std::string>::const_iterator it2 = it->second->getUserSettings().begin(); it2 != it->second->getUserSettings().end(); it2++) {

			std::string value = CONFIG_STRING_DEFAULTED(m_component->getConfig(), it->second->getNode() + "." + it2->first, it2->second);

				int type = (int) TYPE_BOOLEAN;

				m_storageBackend->getUserSetting(user->getUserInfo().id, it2->first, type, value);

			user->addUserSetting(it2->first, value);

		}

	}

		("service.enable_privacy_lists", value<bool>()->default_value(true), "")

		("service.enable_xhtml", value<bool>()->default_value(true), "")

		("service.max_room_list_size", value<int>()->default_value(100), "")

		("service.jid_escaping", value<bool>()->default_value(true), "")

		("service.vip_only", value<bool>()->default_value(false), "")

		("service.vip_message", value<std::string>()->default_value(""), "")

		("registration.needPassword", value<bool>()->default_value(true), "")

		("registration.needRegistration", value<bool>()->default_value(false), "")

		("registration.extraField", value<std::vector<std::string> >()->multitoken(), "")

	;

	std::stringstream ifs(backendConfig);

	store(parsed, m_backendConfig);

	notify(m_backendConfig);

}

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

DiscoInfoResponder::DiscoInfoResponder(Swift::IQRouter *router, Config *config) : Swift::GetResponder<DiscoInfo>(router) {

	m_config = config;

	m_transportInfo.addIdentity(DiscoInfo::Identity(CONFIG_STRING(m_config, "identity.name"),

													CONFIG_STRING(m_config, "identity.category"),

													CONFIG_STRING(m_config, "identity.type")));

	std::list<std::string> features;

	features.push_back("jabber:iq:register");

	features.push_back("jabber:iq:gateway");

	features.push_back("http://jabber.org/protocol/commands");

	setTransportFeatures(features);

	features.push_back("http://jabber.org/protocol/disco#items");

	features.push_back("http://jabber.org/protocol/disco#info");

	features.push_back("http://jabber.org/protocol/chatstates");

	features.push_back("http://jabber.org/protocol/xhtml-im");

	}

}

void DiscoInfoResponder::setTransportFeatures(std::list<std::string> &features) {

}

void DiscoInfoResponder::setBuddyFeatures(std::list<std::string> &f) {

	for (std::list<std::string>::iterator it = f.begin(); it != f.end(); it++) {

		}

	}

	CapsInfoGenerator caps("spectrum");

	onBuddyCapsInfoChanged(m_capsInfo);

}

	}

	// disco#info for buddy

	else {

		res->setNode(info->getNode());

		sendResponse(from, to, id, res);

	}

	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;

		Config *m_config;

		Swift::CapsInfo m_capsInfo;

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

	m_isNextLongRun = false;

	m_adminInterface = NULL;

	m_startingBackend = false;

	m_discoItemsResponder = discoItemsResponder;

	m_component->m_factory = new NetworkFactory(this);

	m_userManager->onUserCreated.connect(boost::bind(&NetworkPluginServer::handleUserCreated, this, _1));

	m_pingTimer->onTick.connect(boost::bind(&NetworkPluginServer::pingTimeout, this));

	m_pingTimer->start();

	if (CONFIG_INT(m_config, "service.memory_collector_time") != 0) {

		m_collectTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(CONFIG_INT(m_config, "service.memory_collector_time"));

		m_collectTimer->onTick.connect(boost::bind(&NetworkPluginServer::collectBackend, this));

	}

}

void NetworkPluginServer::handleNewClientConnection(boost::shared_ptr<Swift::Connection> c) {

	// Create new Backend instance

	Backend *client = new Backend;

	m_userManager->messageToXMPPSent();

}

void NetworkPluginServer::handleAttentionPayload(const std::string &data) {

	pbnetwork::ConversationMessage payload;

	if (payload.ParseFromString(data) == false) {

	send(b->connection, message);

}

	// some users are in queue waiting for this backend

	while(!m_waitingUsers.empty()) {

		// There's no new backend, so stop associating users and wait for new backend,

		// which has been already spawned in getFreeClient() call.

			break;

		User *u = m_waitingUsers.front();

	}

}

	c->pongReceived = true;

}

			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_LIST:

				handleRoomListPayload(wrapper.payload());

				break;

			default:

				return;

		}

		m.set_buddyname(conv->getLegacyName());

		m.set_message(msg->getBody());

		m.set_xhtml(xhtml);

		std::string message;

		m.SerializeToString(&message);

// 	LOG4CXX_INFO(logger, "PING to " << c);

}

	NetworkPluginServer::Backend *c = NULL;

	// Check all backends and find free one

	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {

		if ((*it)->willDie == false && (*it)->acceptUsers == acceptUsers && (*it)->users.size() < CONFIG_INT(m_config, "service.users_per_backend") && (*it)->connection && (*it)->longRun == longRun) {

	response->setTo(m_user->getJID());

	response->setFrom(buddy->getJID());

	response->setType(Swift::Presence::Subscribe);

	m_component->getStanzaChannel()->sendPresence(response);

}

			sendBuddyRosterPush(buddy);

		}

		else {

			m_RIETimer->start();

		}

	}

	if (m_rosterStorage)

	m_RIETimer->stop();

	// Check the feature, because proper resource could logout during RIETimer.

	// fallback to normal subscribe

		for (std::map<std::string, Buddy *, std::less<std::string>, boost::pool_allocator< std::pair<std::string, Buddy *> > >::iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

			Buddy *buddy = (*it).second;

			if (!buddy) {

		return;

	}

	Swift::RosterItemExchangePayload::ref payload = Swift::RosterItemExchangePayload::ref(new Swift::RosterItemExchangePayload());

	for (std::map<std::string, Buddy *, std::less<std::string>, boost::pool_allocator< std::pair<std::string, Buddy *> > >::iterator it = m_buddies.begin(); it != m_buddies.end(); it++) {

		Buddy *buddy = (*it).second;

		payload->addItem(item);

	}

		request->send();

	}

void RosterManager::handleSubscription(Swift::Presence::ref presence) {

	std::string legacyName = Buddy::JIDToLegacyName(presence->getTo());

	CPPUNIT_TEST(roomList);

	CPPUNIT_TEST(roomInfo);

	CPPUNIT_TEST(clearRooms);

	CPPUNIT_TEST_SUITE_END();

	public:

		CPPUNIT_ASSERT(getStanza(received[0])->getPayload<Swift::DiscoItems>()->getItems().empty());

	}

};

CPPUNIT_TEST_SUITE_REGISTRATION (DiscoItemsResponderTest);

	CPPUNIT_TEST(setBuddy);

	CPPUNIT_TEST(sendCurrentPresences);

	CPPUNIT_TEST(sendCurrentPresence);

	CPPUNIT_TEST(removeBuddy);

	CPPUNIT_TEST(subscribeExistingBuddy);

	CPPUNIT_TEST(subscribeNewBuddy);

		m_buddy = buddy->getName();

	}

	void setBuddy() {

		add2Buddies();

		CPPUNIT_ASSERT_EQUAL(2, (int) received.size());

	return m_jid;

}

	std::vector<Swift::Presence::ref> presences = m_presenceOracle->getAllPresence(m_jid);

	foreach(Swift::Presence::ref presence, presences) {

		if (discoInfo->hasFeature(feature)) {

			LOG4CXX_INFO(logger, m_jid.toString() << ": Found JID with " << feature << " feature: " << presence->getFrom().toString());

		}

	}

		LOG4CXX_INFO(logger, m_jid.toString() << ": No JID with " << feature << " feature " << m_legacyCaps.size());

	return jid;

}