example when path to backend binary is not found).

	* Update buddies in database only when it's needed and do not execute

	  useless database statements.

	* Send roster changes also when buddy's group change.

	* Fixed bug when transport contact we in all groups.

	* Answer to disco#info IQ with proper node (#206).

	* Set SQLite3 as default database backend.

	* Fixed disconnecting from server caused by sending VCard response

	  with bad "from" attribute.

	* Added Munin plugin (Thanks to Askovpen).

	* Added support for more admin_jid JIDs (Thanks to Askovpen).

	* Fixed allowed_servers option.

	Libpurple:

	* prpl-gg: Fetch the contact list properly (#252).

	Skype:

	* Log more errors.

	Backend API:

	* Added Python NetworkPlugin class, so it is now easier to write backends

	  in Python (Thanks to Sarang).

Version 2.0.0-beta2 (2012-03-28):

	General:

	* Fixed bug when Roster Item Exchange and subscribe stanzas were sent

	  repeatedly.

	* Backends related logs now contain the backend PID.

	* Fixed username_mask setting.

	* Added new fields into statistics (backends_crashed, messages related

	  stats).

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

 */

#pragma once

#include <vector>

#include "Swiften/Swiften.h"

#include "Swiften/Queries/GetResponder.h"

#include "Swiften/Elements/DiscoItems.h"

namespace Transport {

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

	public:

		~DiscoItemsResponder();

	private:

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

};

}

		/// \param buddyName Name of legacy network buddy. (eg. "user2@gmail.com")

		/// \param alias Alias of legacy network buddy. If empty, then it's not changed on XMPP side.

		/// \param groups Groups in which buddy currently is. If empty, then it's not changed on XMPP side.

		/// \param status Status of this buddy.

		/// \param statusMessage Status message of this buddy.

		/// \param iconHash MD5 hash of buddy icon. Empty if none buddy icon.

		/// \param blocked True if this buddy is blocked in privacy lists in legacy network.

		void handleBuddyChanged(const std::string &user, const std::string &buddyName, const std::string &alias,

			const std::vector<std::string> &groups, pbnetwork::StatusType status, const std::string &statusMessage = "", const std::string &iconHash = "",

			bool blocked = false

		);

		/// Call this function when participant 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 nickname Nickname of participant. If participant renamed, this is old name of participant. (eg. "HanzZ")

		/// \param room Room in which participant changed. (eg. #spectrum)

		/// \param flags Participant flags.

		/// \param status Current status of participant. Swift::StatusShow::None if participant left the room.

		/// \param statusMessage Current status message of participant.

		/// \param newname New name of participant if he changed the nickname. Otherwise empty.

		void handleParticipantChanged(const std::string &user, const std::string &nickname, const std::string &room, int flags,

			pbnetwork::StatusType = pbnetwork::STATUS_NONE, const std::string &statusMessage = "", const std::string &newname = "");

		/// Call this function when user disconnected the legacy network because of some legacy network error.

		bool moveToLongRunBackend(User *user);

		void handleMessageReceived(NetworkConversation *conv, boost::shared_ptr<Swift::Message> &message);

	private:

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

		void handleSessionFinished(Backend *c);

		void handleDataRead(Backend *c, boost::shared_ptr<Swift::SafeByteArray> data);

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

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

		void handleBuddyChangedPayload(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 handleChatStatePayload(const std::string &payload, Swift::ChatState::ChatStateType type);

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

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

		void handleStatsPayload(Backend *c, const std::string &payload);

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

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

		void handleFTDataPayload(Backend *b ,const std::string &payload);

		/// Associates the buddy with this roster,

		/// and if the buddy is not already in XMPP user's server-side roster, the proper requests

		/// are sent to XMPP user (subscribe presences, Roster Item Exchange stanza or

		/// the buddy is added to server-side roster using remote-roster protoXEP).

		/// \param buddy Buddy

		void setBuddy(Buddy *buddy);

		/// Deassociates the buddy with this roster.

		/// \param buddy Buddy.

		void unsetBuddy(Buddy *buddy);

		Buddy *getBuddy(const std::string &name);

		void setStorageBackend(StorageBackend *storageBackend);

		void storeBuddy(Buddy *buddy);

		Swift::RosterPayload::ref generateRosterPayload();

		/// Returns user associated with this roster.

		/// \return User

		User *getUser() { return m_user; }

		boost::signal<void (Buddy *buddy)> onBuddyUnset;

		boost::signal<void (Buddy *buddy)> onBuddyAdded;

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

		void handleBuddyChanged(Buddy *buddy);

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

		void sendBuddyRosterPush(Buddy *buddy);

		void sendBuddySubscribePresence(Buddy *buddy);

		void sendCurrentPresences(const Swift::JID &to);

		void sendCurrentPresence(const Swift::JID &from, const Swift::JID &to);

		void sendUnavailablePresences(const Swift::JID &to);

	private:

		void setBuddyCallback(Buddy *buddy);

		void sendRIE();

		void handleBuddyRosterPushResponse(Swift::ErrorPayload::ref error, Swift::SetRosterRequest::ref request, const std::string &key);

#include "transport/presenceoracle.h"

#include <Swiften/Network/BoostConnectionServer.h>

namespace Transport {

	// typedef enum { 	CLIENT_FEATURE_ROSTERX = 2,

	// 				CLIENT_FEATURE_XHTML_IM = 4,

	// 				CLIENT_FEATURE_FILETRANSFER = 8,

	// 				CLIENT_FEATURE_CHATSTATES = 16

	// 				} SpectrumImportantFeatures;

	// 

	class StorageBackend;

	class DiscoInfoResponder;

	class Factory;

	class UserRegistry;

	/// Represents one transport instance.

	/// It's used to connect the Jabber server and provides transaction layer

	/// between Jabber server and other classes.

	///

	/// In server mode it represents Jabber server to which users can connect and use

	/// it as transport.

	class Component {

		public:

			Swift::Server *m_server;

			Swift::Timer::ref m_reconnectTimer;

			Swift::EntityCapsManager *m_entityCapsManager;

			Swift::CapsManager *m_capsManager;

			Swift::CapsMemoryStorage *m_capsMemoryStorage;

			PresenceOracle *m_presenceOracle;

			Swift::StanzaChannel *m_stanzaChannel;

			Swift::IQRouter *m_iqRouter;

			Transport::UserRegistry *m_userRegistry;

			StorageBackend *m_storageBackend;

 			DiscoInfoResponder *m_discoInfoResponder;

			int m_reconnectCount;

			Config* m_config;

			std::string m_protocol;

			Swift::JID m_jid;

			Factory *m_factory;

			Swift::EventLoop *m_loop;

		friend class User;

		friend class UserRegistration;

		friend class NetworkPluginServer;

	};

}

	buddy.set_statusmessage(statusMessage);

	buddy.set_iconhash(iconHash);

	buddy.set_blocked(blocked);

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED);

	send(message);

}

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

	pbnetwork::Buddy buddy;

	buddy.set_username(user);

	buddy.set_buddyname(buddyName);

	std::string message;

	buddy.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING);

	send(message);

}

#include "transport/logger.h"

#include "transport/sqlite3backend.h"

#include "transport/mysqlbackend.h"

#include "transport/pqxxbackend.h"

#include "transport/userregistration.h"

#include "transport/networkpluginserver.h"

#include "transport/admininterface.h"

#include "transport/statsresponder.h"

#include "transport/usersreconnecter.h"

#include "transport/util.h"

#include "transport/gatewayresponder.h"

#include "transport/logging.h"

#include "Swiften/EventLoop/SimpleEventLoop.h"

#include <boost/filesystem.hpp>

#include <boost/algorithm/string.hpp>

#ifndef WIN32

#include "sys/signal.h"

#include <pwd.h>

#include <grp.h>

#include <sys/resource.h>

#include "libgen.h"

#else

#include <windows.h>

#endif

	FileTransferManager ftManager(&transport, &userManager);

	NetworkPluginServer plugin(&transport, &config, &userManager, &ftManager);

	AdminInterface adminInterface(&transport, &userManager, &plugin, storageBackend);

	StatsResponder statsResponder(&transport, &userManager, &plugin, storageBackend);

	statsResponder.start();

	GatewayResponder gatewayResponder(transport.getIQRouter(), &userManager);

	gatewayResponder.start();

	eventLoop_ = &eventLoop;

	eventLoop.run();

	if (userRegistration) {

		userRegistration->stop();

		delete userRegistration;

	}

	if (usersReconnecter) {

		delete usersReconnecter;

	}

 * (at your option) any later version.

 *

 * 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

 */

#include <iostream>

#include <boost/bind.hpp>

#include "Swiften/Queries/IQRouter.h"

#include "Swiften/Swiften.h"

using namespace Swift;

using namespace boost;

namespace Transport {

}

DiscoItemsResponder::~DiscoItemsResponder() {

}

bool DiscoItemsResponder::handleGetRequest(const Swift::JID& from, const Swift::JID& to, const std::string& id, boost::shared_ptr<Swift::DiscoItems> info) {

		sendResponse(from, id, boost::shared_ptr<DiscoItems>(new DiscoItems()));

	}

	else {

		sendResponse(from, id, boost::shared_ptr<DiscoItems>(new DiscoItems()));

	}

	return true;

}

}

	m_blockResponder = new BlockResponder(component->getIQRouter(), userManager);

	m_blockResponder->onBlockToggled.connect(boost::bind(&NetworkPluginServer::handleBlockToggled, this, _1));

	m_blockResponder->start();

	m_server = component->getNetworkFactories()->getConnectionServerFactory()->createConnectionServer(Swift::HostAddress(CONFIG_STRING(m_config, "service.backend_host")), boost::lexical_cast<int>(CONFIG_STRING(m_config, "service.backend_port")));

	m_server->onNewConnection.connect(boost::bind(&NetworkPluginServer::handleNewClientConnection, this, _1));

	m_server->start();

	LOG4CXX_INFO(logger, "Listening on host " << CONFIG_STRING(m_config, "service.backend_host") << " port " << CONFIG_STRING(m_config, "service.backend_port"));

	unsigned long pid = exec_(CONFIG_STRING(m_config, "service.backend"), CONFIG_STRING(m_config, "service.backend_host").c_str(), CONFIG_STRING(m_config, "service.backend_port").c_str(), m_config->getConfigFile().c_str());

	LOG4CXX_INFO(logger, "Backend should now connect to Spectrum2 instance. Spectrum2 won't accept any connection before backend connects");

#ifndef _WIN32

	// wait if the backend process will still be alive after 1 second

	sleep(1);

	pid_t result;

	int status;

	result = waitpid(-1, &status, WNOHANG);

	if (result != 0) {

		if (WIFEXITED(status)) {

			if (WEXITSTATUS(status) != 0) {

				LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status) << ", possible error: " << strerror(WEXITSTATUS(status)));

	if (buddy) {

		handleBuddyPayload(buddy, payload);

		buddy->handleBuddyChanged();

	}

	else {

		buddy = new LocalBuddy(user->getRosterManager(), -1);

		buddy->setFlags(BUDDY_JID_ESCAPING);

		handleBuddyPayload(buddy, payload);

		user->getRosterManager()->setBuddy(buddy);

	}

}

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

	pbnetwork::Participant payload;

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

		// TODO: ERROR

		return;

	}

	User *user = m_userManager->getUser(payload.username());

	if (!user)

		return;

	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(payload.room());

			case pbnetwork::WrapperMessage_Type_TYPE_STATS:

				handleStatsPayload(c, wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_FT_START:

				handleFTStartPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_FT_FINISH:

				handleFTFinishPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_FT_DATA:

				handleFTDataPayload(c, wrapper.payload());

				break;

			default:

				return;

		}

	}

}

void NetworkPluginServer::send(boost::shared_ptr<Swift::Connection> &c, const std::string &data) {

	// generate header - size of wrapper message

	uint32_t size = htonl(data.size());

	char *header = (char *) &size;

	// send header together with wrapper message

	boost::singleton_pool<boost::pool_allocator_tag, sizeof(unsigned int)>::release_memory();

	if (m_rosterStorage)

		delete m_rosterStorage;

}

void RosterManager::setBuddy(Buddy *buddy) {

// 	m_setBuddyTimer->onTick.connect(boost::bind(&RosterManager::setBuddyCallback, this, buddy));

// 	m_setBuddyTimer->start();

	setBuddyCallback(buddy);

}

void RosterManager::sendBuddyRosterPush(Buddy *buddy) {

	// user can't receive anything in server mode if he's not logged in.

	// He will ask for roster later (handled in rosterreponsder.cpp)

	if (m_component->inServerMode() && !m_user->isConnected())

		return;

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

	Swift::RosterItemPayload item;

	item.setJID(buddy->getJID().toBare());

	if (buddy->getAlias().empty()) {

		item.setName(buddy->getJID().toBare().toString());

	}

		Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, m_user->getJID().toBare(), m_component->getIQRouter());

		request->onResponse.connect(boost::bind(&RosterManager::handleBuddyRosterPushResponse, this, _1, request, buddy->getName()));

		request->send();

		m_requests.push_back(request);

	}

	if (buddy->getSubscription() != Buddy::Both) {

		buddy->setSubscription(Buddy::Both);

		handleBuddyChanged(buddy);

	}

}

void RosterManager::sendBuddySubscribePresence(Buddy *buddy) {

	Swift::Presence::ref response = Swift::Presence::create();

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

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

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

// 	TODO: NICKNAME

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

}

void RosterManager::handleBuddyChanged(Buddy *buddy) {

}

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

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

 */

#include "transport/transport.h"

#include <boost/bind.hpp>

#include <boost/algorithm/string/predicate.hpp>

#include "transport/storagebackend.h"

#include "transport/factory.h"

#include "transport/userregistry.h"

#include "transport/logging.h"

#include "discoinforesponder.h"

#include "storageparser.h"

#include "Swiften/TLS/OpenSSL/OpenSSLServerContext.h"

#include "Swiften/TLS/PKCS12Certificate.h"

#include "Swiften/TLS/OpenSSL/OpenSSLServerContextFactory.h"

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

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

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

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

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

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

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

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

	m_capsMemoryStorage = new CapsMemoryStorage();

	m_capsManager = new CapsManager(m_capsMemoryStorage, m_stanzaChannel, m_iqRouter);

	m_entityCapsManager = new EntityCapsManager(m_capsManager, m_stanzaChannel);

 	m_entityCapsManager->onCapsChanged.connect(boost::bind(&Component::handleCapsChanged, this, _1));

	m_presenceOracle = new Transport::PresenceOracle(m_stanzaChannel);

	m_presenceOracle->onPresenceChange.connect(bind(&Component::handlePresence, this, _1));

	m_discoInfoResponder = new DiscoInfoResponder(m_iqRouter, m_config);

	m_discoInfoResponder->start();

// 

// 	m_registerHandler = new SpectrumRegisterHandler(m_component);

// 	m_registerHandler->start();

}

Component::~Component() {

	delete m_presenceOracle;

	delete m_entityCapsManager;

	delete m_capsManager;

	delete m_capsMemoryStorage;

	delete m_discoInfoResponder;

	if (m_component)

		delete m_component;

	if (m_server) {

		m_server->stop();

		delete m_server;

	}

}

Swift::StanzaChannel *Component::getStanzaChannel() {

	return m_stanzaChannel;

}