/// Generates whole Presennce stanza with current status/show for this buddy.

		/// Presence stanza does not containt "to" attribute, it has to be added manually.

		/// \param features features used in returned stanza

		/// \param only_new if True, this function returns Presence stanza only if it's different

		/// than the previously generated one.

		/// \return Presence stanza or NULL.

		Swift::Presence::ref generatePresenceStanza(int features, bool only_new = false);

		void setBlocked(bool block) {

			if (block)

				m_flags = (BuddyFlag) (m_flags | BUDDY_BLOCKED);

			else

				m_flags = (BuddyFlag) (m_flags & ~BUDDY_BLOCKED);

		}

		bool isBlocked() {

			return (m_flags & BUDDY_BLOCKED)  != 0;

		}

		/// Sets current subscription.

		/// \param subscription "to", "from", "both", "ask"

		void setSubscription(Subscription subscription);

		/// Returns current subscription

		/// \return subscription "to", "from", "both", "ask"

		Subscription getSubscription();

		/// Sets this buddy's flags.

		/// \param flags flags

		void setFlags(BuddyFlag flags);

		/// Returns this buddy's flags.

		/// \param flags flags

		BuddyFlag getFlags();

		/// Returns RosterManager associated with this buddy.

		/// \return RosterManager associated with this buddy.

		RosterManager *getRosterManager() { return m_rosterManager; }

		/// Returns legacy network username which does not contain unsafe characters,

		/// so it can be used in JIDs.

		std::string getSafeName();

		/// This method should be called whenever some information returned by virtual functions changes.

		/// This method sends presence to XMPP user.

		void handleBuddyChanged();

		/// Handles VCard from legacy network and forwards it to XMPP user.

		/// \param id ID used in IQ-result.

		/// \param vcard VCard which will be sent.

		void handleVCardReceived(const std::string &id, Swift::VCard::ref vcard);

		/// Returns legacy network username of this buddy. (for example UIN for ICQ, JID for Jabber, ...).

		/// \return legacy network username

		virtual std::string getName() = 0;

		/// Returns alias (nickname) of this buddy.

		/// \return alias (nickname)

		virtual std::string getAlias() = 0;

		/// Returns list of groups this buddy is in.

		/// \return groups

		virtual std::vector<std::string> getGroups() = 0;

		/// Returns current legacy network status and statuMessage of this buddy.

		/// \param status current status/show is stored here

		/// \param statusMessage current status message is stored here

		/// \return true if status was stored successfully

		virtual bool getStatus(Swift::StatusShow &status, std::string &statusMessage) = 0;

		/// Returns SHA-1 hash of buddy icon (avatar) or empty string if there is no avatar for this buddy.

		/// \return avatar hash or empty string.

		virtual std::string getIconHash() = 0;

		/// Returns legacy name of buddy from JID.

		/// \param jid Jabber ID.

		/// \return legacy name of buddy from JID.

		static std::string JIDToLegacyName(const Swift::JID &jid);

		static BuddyFlag buddFlagsFromJID(const Swift::JID &jid);

	protected:

		void generateJID();

	private:

		long m_id;

// 		Swift::Presence::ref m_lastPresence;

		BuddyFlag m_flags;

		RosterManager *m_rosterManager;

		Subscription m_subscription;

};

}

/**

 * XMPP - libpurple transport

 *

 * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (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 "transport/buddy.h"

#include "transport/rostermanager.h"

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/BlockPayload.h"

namespace Transport {

Buddy::Buddy(RosterManager *rosterManager, long id) : m_id(id), m_flags(BUDDY_NO_FLAG), m_rosterManager(rosterManager),

	m_subscription(Ask) {

// 	m_rosterManager->setBuddy(this);

}

Buddy::~Buddy() {

// 	m_rosterManager->unsetBuddy(this);

}

void Buddy::generateJID() {

	m_jid = Swift::JID();

	m_jid = Swift::JID(getSafeName(), m_rosterManager->getUser()->getComponent()->getJID().toString(), "bot");

}

void Buddy::setID(long id) {

	m_id = id;

}

long Buddy::getID() {

	return m_id;

}

void Buddy::setFlags(BuddyFlag flags) {

	m_flags = flags;

	}

}

BuddyFlag Buddy::getFlags() {

	return m_flags;

}

const Swift::JID &Buddy::getJID() {

	if (!m_jid.isValid() || m_jid.getNode().empty()) {

		generateJID();

	}

	return m_jid;

}

void Buddy::setSubscription(Subscription subscription) {

	m_subscription = subscription;

}

Buddy::Subscription Buddy::getSubscription() {

	return m_subscription;

}

Swift::Presence::ref Buddy::generatePresenceStanza(int features, bool only_new) {

	std::string alias = getAlias();

	std::string name = getSafeName();

	Swift::StatusShow s;

	std::string statusMessage;

	if (!getStatus(s, statusMessage))

		return Swift::Presence::ref();

	if (m_jid.getNode().empty()) {

		generateJID();

	}

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

 	presence->setFrom(m_jid);

	presence->setTo(m_rosterManager->getUser()->getJID().toBare());

	presence->setType(Swift::Presence::Available);

	if (!statusMessage.empty())

		presence->setStatus(statusMessage);

	if (s.getType() == Swift::StatusShow::None)

		presence->setType(Swift::Presence::Unavailable);

	presence->setShow(s.getType());

	if (presence->getType() != Swift::Presence::Unavailable) {

		// caps

		presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::CapsInfo(m_rosterManager->getUser()->getComponent()->getBuddyCapsInfo())));

// 		if (features & 0/*TRANSPORT_FEATURE_AVATARS*/) {

			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::VCardUpdate (getIconHash())));

// 		}

		if (isBlocked()) {

			presence->addPayload(boost::shared_ptr<Swift::Payload>(new Transport::BlockPayload ()));

		}

	}

// 	if (only_new) {

// 		if (m_lastPresence)

// 			m_lastPresence->setTo(Swift::JID(""));

// 		if (m_lastPresence == presence) {

// 			return Swift::Presence::ref();

// 		}

// 		m_lastPresence = presence;

// 	}

	return presence;

}

std::string Buddy::getSafeName() {

	if (m_jid.isValid()) {

		return m_jid.getNode();

	}

	std::string name = getName();

// 	Transport::instance()->protocol()->prepareUsername(name, purple_buddy_get_account(m_buddy));

	if (getFlags() & BUDDY_JID_ESCAPING) {

		name = Swift::JID::getEscapedNode(name);

	}

	else {

		if (name.find_last_of("@") != std::string::npos) {

			name.replace(name.find_last_of("@"), 1, "%"); // OK

		}

	}

// 	if (name.empty()) {

// 		Log("SpectrumBuddy::getSafeName", "Name is EMPTY! Previous was " << getName() << ".");

// 	}

	return name;

}

void Buddy::handleBuddyChanged() {

	Swift::Presence::ref presence = generatePresenceStanza(255);

	if (presence) {

		m_rosterManager->getUser()->getComponent()->getStanzaChannel()->sendPresence(presence);

/**

 * XMPP - libpurple transport

 *

 * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (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 "transport/localbuddy.h"

#include "transport/user.h"

namespace Transport {

LocalBuddy::LocalBuddy(RosterManager *rosterManager, long id) : Buddy(rosterManager, id) {

	m_status = Swift::StatusShow::None;

	m_firstSet = true;

}

LocalBuddy::~LocalBuddy() {

}

bool LocalBuddy::setName(const std::string &name) {

	if (name == m_name) {

		return true;

	}

	std::string oldName = name;

	m_name = name;

	try {

		generateJID();

	} catch (...) {

		m_name = oldName;

		return false;

	}

}

void LocalBuddy::setAlias(const std::string &alias) {

//	if (m_firstSet) {

//		m_firstSet = false;

//		m_alias = alias;

//		return;

//	}

	bool changed = m_alias != alias;

	m_alias = alias;

	if (changed) {

		if (getRosterManager()->getUser()->getComponent()->inServerMode() || getRosterManager()->isRemoteRosterSupported()) {

			getRosterManager()->sendBuddyRosterPush(this);

		}

		getRosterManager()->storeBuddy(this);

	}

}

void LocalBuddy::setGroups(const std::vector<std::string> &groups) {

	bool changed = m_groups.size() != groups.size();

	if (!changed) {

		for (int i = 0; i != m_groups.size(); i++) {

			if (m_groups[i] != groups[i]) {

				changed = true;

				break;

			}

		}

	}

	m_groups = groups;

	if (changed) {

		if (getRosterManager()->getUser()->getComponent()->inServerMode() || getRosterManager()->isRemoteRosterSupported()) {

			getRosterManager()->sendBuddyRosterPush(this);

		}

		getRosterManager()->storeBuddy(this);

	}

}

}

 * libtransport -- C++ library for easy XMPP Transports development

 *

 * Copyright (C) 2011, Jan Kaluza <hanzz.k@gmail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (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 "transport/networkpluginserver.h"

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/storagebackend.h"

#include "transport/rostermanager.h"

#include "transport/usermanager.h"

#include "transport/conversationmanager.h"

#include "transport/localbuddy.h"

#include "transport/config.h"

#include "transport/conversation.h"

#include "transport/vcardresponder.h"

#include "transport/rosterresponder.h"

#include "transport/memoryreadbytestream.h"

#include "transport/logging.h"

#include "transport/admininterface.h"

#include "blockresponder.h"

#include "Swiften/Swiften.h"

#include "Swiften/Server/ServerStanzaChannel.h"

#include "Swiften/Elements/StreamError.h"

#include "Swiften/Network/BoostConnectionServer.h"

#include "Swiften/Elements/AttentionPayload.h"

#include "Swiften/Elements/XHTMLIMPayload.h"

#include "Swiften/Elements/InvisiblePayload.h"

#include "Swiften/Elements/SpectrumErrorPayload.h"

#include "transport/protocol.pb.h"

#include "utf8.h"

#include <Swiften/FileTransfer/ReadBytestream.h>

#include <Swiften/Elements/StreamInitiationFileInfo.h>

#ifdef _WIN32

#include "windows.h"

#include <stdint.h>

#else

#include "sys/wait.h"

#include "sys/signal.h"

#include "popt.h"

#endif

namespace Transport {

static unsigned long backend_id;

static unsigned long bytestream_id;

DEFINE_LOGGER(logger, "NetworkPluginServer");

class NetworkConversation : public Conversation {

	public:

		NetworkConversation(ConversationManager *conversationManager, const std::string &legacyName, bool muc = false) : Conversation(conversationManager, legacyName, muc) {

		}

		// Called when there's new message to legacy network from XMPP network

		void sendMessage(boost::shared_ptr<Swift::Message> &message) {

			onMessageToSend(this, message);

		}

		boost::signal<void (NetworkConversation *, boost::shared_ptr<Swift::Message> &)> onMessageToSend;

};

class NetworkFactory : public Factory {

	public:

		NetworkFactory(NetworkPluginServer *nps) {

			m_nps = nps;

		}

		// Creates new conversation (NetworkConversation in this case)

		Conversation *createConversation(ConversationManager *conversationManager, const std::string &legacyName) {

			NetworkConversation *nc = new NetworkConversation(conversationManager, legacyName);

			nc->onMessageToSend.connect(boost::bind(&NetworkPluginServer::handleMessageReceived, m_nps, _1, _2));

			return nc;

		}

		// Creates new LocalBuddy

		Buddy *createBuddy(RosterManager *rosterManager, const BuddyInfo &buddyInfo) {

			LocalBuddy *buddy = new LocalBuddy(rosterManager, buddyInfo.id);

			buddy->setAlias(buddyInfo.alias);

			if (!buddy->setName(buddyInfo.legacyName)) {

				delete buddy;

				return NULL;

			}

			if (buddyInfo.subscription == "both") {

				buddy->setSubscription(Buddy::Both);

			}

			else {

				buddy->setSubscription(Buddy::Ask);

			}

			buddy->setGroups(buddyInfo.groups);

			if (buddyInfo.settings.find("icon_hash") != buddyInfo.settings.end())

				buddy->setIconHash(buddyInfo.settings.find("icon_hash")->second.s);

			return buddy;

		}

	private:

		NetworkPluginServer *m_nps;

};

// Wraps google protobuf payload into WrapperMessage and serialize it to string

#define WRAP(MESSAGE, TYPE) 	pbnetwork::WrapperMessage wrap; \

	wrap.set_type(TYPE); \

	wrap.set_payload(MESSAGE); \

	wrap.SerializeToString(&MESSAGE);

// Executes new backend

static unsigned long exec_(std::string path, const char *host, const char *port, const char *config) {

	std::string original_path = path;

	// BACKEND_ID is replaced with unique ID. The ID is increasing for every backend.

	boost::replace_all(path, "BACKEND_ID", boost::lexical_cast<std::string>(backend_id++));

	// Add host and port.

	path += std::string(" --host ") + host + " --port " + port + " " + config;

	LOG4CXX_INFO(logger, "Starting new backend " << path);

#ifdef _WIN32

	STARTUPINFO         si;

	PROCESS_INFORMATION pi;

	ZeroMemory (&si, sizeof(si));

	si.cb=sizeof (si);

	if (! CreateProcess(

	NULL,

	(LPSTR)path.c_str(),         // command line

	0,                    // process attributes

	0,                    // thread attributes

	0,                    // inherit handles

	0,                    // creation flags

	0,                    // environment

	0,                    // cwd

	&si,

	&pi

	)

	)  {

		LOG4CXX_ERROR(logger, "Could not start process");

	}

	return 0;

#else

	// Create array of char * from string using -lpopt library

	char *p = (char *) malloc(path.size() + 1);

	strcpy(p, path.c_str());

	int argc;

	char **argv;

	poptParseArgvString(p, &argc, (const char ***) &argv);

	// fork and exec

	pid_t pid = fork();

	if ( pid == 0 ) {

		setsid();

		// child process

		errno = 0;

		int ret = execv(argv[0], argv);

		if (ret == -1) {

			exit(errno);

		}

		exit(0);

	} else if ( pid < 0 ) {

		LOG4CXX_ERROR(logger, "Fork failed");

	}

	free(p);

	return (unsigned long) pid;

#endif

}

#ifndef _WIN32

static void SigCatcher(int n) {

	pid_t result;

	int status;

	// Read exit code from all children to not have zombies arround

	// WARNING: Do not put LOG4CXX_ here, because it can lead to deadlock

	while ((result = waitpid(-1, &status, WNOHANG)) > 0) {

		if (result != 0) {

			if (WIFEXITED(status)) {

				if (WEXITSTATUS(status) != 0) {

// 					LOG4CXX_ERROR(logger, "Backend can not be started, exit_code=" << WEXITSTATUS(status));

				}

			}

			else {

// 				LOG4CXX_ERROR(logger, "Backend can not be started");

			}

		}

	}

}

					currentPresence = buddy->generatePresenceStanza(255);

					if (currentPresence) {

						currentPresence->setTo(presence->getFrom());

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

					}

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

						buddy->setSubscription(Buddy::Both);

						handleBuddyChanged(buddy);

					}

					break;

				// remove buddy

				case Swift::Presence::Unsubscribe:

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

					onBuddyRemoved(buddy);

					break;

				// just send response

				case Swift::Presence::Unsubscribed:

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

					// We set both here, because this Unsubscribed can be response to

					// subscribe presence and we don't want that unsubscribe presence

					// to be send later again

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

						buddy->setSubscription(Buddy::Both);

						handleBuddyChanged(buddy);

					}

					break;

				case Swift::Presence::Subscribed:

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

						buddy->setSubscription(Buddy::Both);

						handleBuddyChanged(buddy);

					}

					return;

				default:

					return;

			}

		}

		else {

			BuddyInfo buddyInfo;

			switch (presence->getType()) {

				// buddy is not in roster, so add him

				case Swift::Presence::Subscribe:

					buddyInfo.id = -1;

					buddyInfo.alias = "";

					buddyInfo.legacyName = Buddy::JIDToLegacyName(presence->getTo());

					buddyInfo.subscription = "both";

					buddyInfo.flags = Buddy::buddFlagsFromJID(presence->getTo());

					buddy = m_component->getFactory()->createBuddy(this, buddyInfo);

					setBuddy(buddy);

					onBuddyAdded(buddy);

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

					break;

				// buddy is already there, so nothing to do, just answer

				case Swift::Presence::Unsubscribe:

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

// 					onBuddyRemoved(buddy);

					break;

				// just send response

				case Swift::Presence::Unsubscribed:

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

					break;

				// just send response

				default:

					return;

			}

		}

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

		// We have to act as buddy and send its subscribe/unsubscribe just to be sure...

		switch (response->getType()) {

			case Swift::Presence::Unsubscribed:

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

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

				break;

			case Swift::Presence::Subscribed:

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

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

				break;

			default:

				break;

		}

	}

}

void RosterManager::setStorageBackend(StorageBackend *storageBackend) {

	if (m_rosterStorage || !storageBackend) {

		return;

	}

	RosterStorage *storage = new RosterStorage(m_user, storageBackend);

	std::list<BuddyInfo> roster;

	storageBackend->getBuddies(m_user->getUserInfo().id, roster);

	for (std::list<BuddyInfo>::const_iterator it = roster.begin(); it != roster.end(); it++) {

		Buddy *buddy = m_component->getFactory()->createBuddy(this, *it);

	}

	m_rosterStorage = storage;

}

Swift::RosterPayload::ref RosterManager::generateRosterPayload() {

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

	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) {

			continue;

		}

		Swift::RosterItemPayload item;

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

		item.setName(buddy->getAlias());

		item.setGroups(buddy->getGroups());

		item.setSubscription(Swift::RosterItemPayload::Both);

		payload->addItem(item);

	}

	return payload;

}

void RosterManager::sendCurrentPresences(const Swift::JID &to) {

	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) {

			continue;

		}

		Swift::Presence::ref presence = buddy->generatePresenceStanza(255);

		if (presence) {

			presence->setTo(to);

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

		}

	}

}

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

	Buddy *buddy = getBuddy(Buddy::JIDToLegacyName(from));

	if (buddy) {

		Swift::Presence::ref presence = buddy->generatePresenceStanza(255);

		if (presence) {

			presence->setTo(to);

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

		}

	}

	else {

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

		response->setTo(to);

		response->setFrom(from);

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

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

	}

}

void RosterManager::sendUnavailablePresences(const Swift::JID &to) {

	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) {

			continue;

		}

		Swift::Presence::ref presence = buddy->generatePresenceStanza(255);

		if (presence) {

			presence->setTo(to);

			presence->setType(Swift::Presence::Unavailable);

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

		}

	}

	// in gateway mode, we have to send unavailable presence for transport

	// contact

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

	response->setTo(to);

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

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

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

}

}