}

	return FALSE;

}

static gboolean create_dbus_proxy(gpointer data) {

	Skype *skype = (Skype *) data;

	return skype->createDBusProxy();

}

void Skype::login() {

	if (m_username.find("..") == 0 || m_username.find("/") != std::string::npos) {

		np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, "Invalid username");

		return;

	}

	boost::filesystem::remove_all(std::string("/tmp/skype/") + m_username);

	boost::filesystem::path	path(std::string("/tmp/skype/") + m_username);

	if (!boost::filesystem::exists(path)) {

		boost::filesystem::create_directories(path);

		boost::filesystem::path	path2(std::string("/tmp/skype/") + m_username + "/" + m_username );

		boost::filesystem::create_directories(path2);

	}

	std::string shared_xml = "<?xml version=\"1.0\"?>\n"

							"<config version=\"1.0\" serial=\"28\" timestamp=\"" + boost::lexical_cast<std::string>(time(NULL)) + ".0\">\n"

							"<UI>\n"

								"<Installed>2</Installed>\n"

								"<Language>en</Language>\n"

							"</UI>\n"

							"</config>\n";

	g_file_set_contents(std::string(std::string("/tmp/skype/") + m_username + "/shared.xml").c_str(), shared_xml.c_str(), -1, NULL);

	std::string config_xml = "<?xml version=\"1.0\"?>\n"

							"<config version=\"1.0\" serial=\"7\" timestamp=\"" + boost::lexical_cast<std::string>(time(NULL)) + ".0\">\n"

								"<Lib>\n"

									"<Account>\n"

									"<IdleTimeForAway>30000000</IdleTimeForAway>\n"

									"<IdleTimeForNA>300000000</IdleTimeForNA>\n"

									"<LastUsed>" + boost::lexical_cast<std::string>(time(NULL)) + "</LastUsed>\n"

									"</Account>\n"

								"</Lib>\n"

								"<UI>\n"

									"<API>\n"

									"<Authorizations>Spectrum</Authorizations>\n"

									"<BlockedPrograms></BlockedPrograms>\n"

									"</API>\n"

								"</UI>\n"

							"</config>\n";

	g_file_set_contents(std::string(std::string("/tmp/skype/") + m_username + "/" + m_username +"/config.xml").c_str(), config_xml.c_str(), -1, NULL);

	sleep(1);

	std::string db_path = std::string("/tmp/skype/") + m_username;

	char *db = (char *) malloc(db_path.size() + 1);

	strcpy(db, db_path.c_str());

	LOG4CXX_INFO(logger,  m_username << ": Spawning new Skype instance dbpath=" << db);

	gchar* argv[6] = {"skype", "--disable-cleanlooks", "--pipelogin", "--dbpath", db, 0};

	int fd;

	GError *error = NULL;

	bool spawned = g_spawn_async_with_pipes(NULL,

		argv,

		NULL /*envp*/,

		G_SPAWN_SEARCH_PATH,

		NULL /*child_setup*/,

		NULL /*user_data*/,

		&m_pid /*child_pid*/,

		&fd,

		NULL,

		&fd_output,

		&error);

	if (!spawned) {

		LOG4CXX_ERROR(logger, "Error spawning the Skype instance: " << error->message)

		np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, "Error spawning the Skype instance.");

		return;

	}

	std::string login_data = std::string(m_username + " " + m_password + "\n");

	LOG4CXX_INFO(logger,  m_username << ": Login data=" << m_username);

	write(fd, login_data.c_str(), login_data.size());

	close(fd);

	fcntl (fd_output, F_SETFL, O_NONBLOCK);

	free(db);

	//Initialise threading

	dbus_threads_init_default();

	if (m_connection == NULL)

	{

		LOG4CXX_INFO(logger, "Creating DBUS connection.");

		GError *error = NULL;

		m_connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);

		if (m_connection == NULL && error != NULL)

		{

			g_error_free(error);

			return;

		}

	}

	sleep(1);

	m_timer = g_timeout_add_seconds(1, create_dbus_proxy, this);

}

bool Skype::loadSkypeBuddies() {

//	std::string re = "CONNSTATUS OFFLINE";

//	while (re == "CONNSTATUS OFFLINE" || re.empty()) {

//		sleep(1);

	gchar buffer[1024];

	int bytes_read = read(fd_output, buffer, 1023);

	if (bytes_read > 0) {

		buffer[bytes_read] = 0;

		std::string b(buffer);

		LOG4CXX_WARN(logger, "Skype wrote this on stdout '" << b << "'");

		if (b.find("Incorrect Password") != std::string::npos) {

			LOG4CXX_INFO(logger, "Incorrect password, logging out")

			np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_FAILED, "Incorrect password");

			close(fd_output);

			logout();

			return FALSE;

		}

	}

	std::string re = send_command("NAME Spectrum");

	if (m_counter++ > 15) {

		LOG4CXX_ERROR(logger, "Logging out, because we tried to connect the Skype over DBUS 15 times without success");

		np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, "Skype is not ready. This issue have been logged and admins will check it and try to fix it soon.");

		close(fd_output);

		logout();

		return FALSE;

	}

	if (re.empty() || re == "CONNSTATUS OFFLINE" || re == "ERROR 68") {

		return TRUE;

	}

	close(fd_output);

	if (send_command("PROTOCOL 7") != "PROTOCOL 7") {

		LOG4CXX_ERROR(logger, "PROTOCOL 7 failed, logging out");

		np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE, "Skype is not ready. This issue have been logged and admins will check it and try to fix it soon.");

		logout();

		return FALSE;

	}

	np->handleConnected(m_user);

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

	std::string groups = send_command("SEARCH GROUPS CUSTOM");

	if (groups.find(' ') != std::string::npos) {

		groups = groups.substr(groups.find(' ') + 1);

		std::vector<std::string> grps;

		boost::split(grps, groups, boost::is_any_of(","));

		BOOST_FOREACH(std::string grp, grps) {

			std::vector<std::string> data;

			std::string name = send_command("GET GROUP " + grp + " DISPLAYNAME");

			if (name.find("ERROR") == 0) {

				continue;

			}

			boost::split(data, name, boost::is_any_of(" "));

			name = GET_RESPONSE_DATA(name, "DISPLAYNAME");

			std::string users = send_command("GET GROUP " + data[1] + " USERS");

			try {

				users = GET_RESPONSE_DATA(users, "USERS");

			}

			catch (std::out_of_range& oor) {

				continue;

			}

			boost::split(data, users, boost::is_any_of(","));

			BOOST_FOREACH(std::string u, data) {

				group_map[u] = grp;

			}

		}

	}

	std::string friends = send_command("GET AUTH_CONTACTS_PROFILES");

	char **full_friends_list = g_strsplit((strchr(friends.c_str(), ' ')+1), ";", 0);

	if (full_friends_list && full_friends_list[0])

	{

		//in the format of: username;full name;phone;office phone;mobile phone;

		//                  online status;friendly name;voicemail;mood

		// (comma-seperated lines, usernames can have comma's)

		for (int i=0; full_friends_list[i] && full_friends_list[i+1] && *full_friends_list[i] != '\0'; i+=8)

		{

			std::string buddy = full_friends_list[i];

		// 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);

			buddy->setName(buddyInfo.legacyName);

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

				buddy->setSubscription(Buddy::Both);

			}

			else {

				buddy->setSubscription(Buddy::Ask);

			}

			buddy->setGroups(buddyInfo.groups);

			buddy->setFlags((BuddyFlag) (buddyInfo.flags));

			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

	} else if ( pid < 0 ) {

	}

	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");

			}

		}

	}

}

#endif

static void handleBuddyPayload(LocalBuddy *buddy, const pbnetwork::Buddy &payload) {

	buddy->setName(payload.buddyname());

	// Set alias only if it's not empty. Backends are allowed to send empty alias if it has

	// not changed.

	if (!payload.alias().empty()) {

		LOG4CXX_INFO(logger, "Setting alias to " << payload.alias() << " " << buddy->getAlias());

		buddy->setAlias(payload.alias());

	}

	// Change groups if it's not empty. The same as above...

	std::vector<std::string> groups;

	for (int i = 0; i < payload.group_size(); i++) {

		groups.push_back(payload.group(i));

	}

	if (!groups.empty()) {

		buddy->setGroups(groups);

	}

	buddy->setStatus(Swift::StatusShow((Swift::StatusShow::Type) payload.status()), payload.statusmessage());

	buddy->setIconHash(payload.iconhash());

	buddy->setBlocked(payload.blocked());

}

NetworkPluginServer::NetworkPluginServer(Component *component, Config *config, UserManager *userManager, FileTransferManager *ftManager) {

	m_ftManager = ftManager;

	m_userManager = userManager;

	m_config = config;

	m_component = component;

	m_isNextLongRun = false;

	m_component->m_factory = new NetworkFactory(this);

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

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

	m_pingTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(20000);

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

		m_collectTimer->start();

	}

	m_vcardResponder = new VCardResponder(component->getIQRouter(), component->getNetworkFactories(), userManager);

	m_vcardResponder->onVCardRequired.connect(boost::bind(&NetworkPluginServer::handleVCardRequired, this, _1, _2, _3));

	m_vcardResponder->onVCardUpdated.connect(boost::bind(&NetworkPluginServer::handleVCardUpdated, this, _1, _2));

	m_vcardResponder->start();

	m_rosterResponder = new RosterResponder(component->getIQRouter(), userManager);

	m_rosterResponder->onBuddyAdded.connect(boost::bind(&NetworkPluginServer::handleBuddyAdded, this, _1, _2));

	m_rosterResponder->onBuddyRemoved.connect(boost::bind(&NetworkPluginServer::handleBuddyRemoved, this, _1));

	m_rosterResponder->onBuddyUpdated.connect(boost::bind(&NetworkPluginServer::handleBuddyUpdated, this, _1, _2));

	m_rosterResponder->start();

	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"));

#ifndef _WIN32

	signal(SIGCHLD, SigCatcher);

#endif

}

NetworkPluginServer::~NetworkPluginServer() {

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

		LOG4CXX_INFO(logger, "Stopping backend " << *it);

		std::string message;

		pbnetwork::WrapperMessage wrap;

		wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_EXIT);

		wrap.SerializeToString(&message);

		Backend *c = (Backend *) *it;

		send(c->connection, message);

	}

	m_pingTimer->stop();

	m_server->stop();

	m_server.reset();

	delete m_component->m_factory;

	delete m_vcardResponder;

	delete m_rosterResponder;

	delete m_blockResponder;

}

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

	// Create new Backend instance

	Backend *client = new Backend;

	client->pongReceived = -1;

	client->connection = c;

	client->res = 0;

	client->init_res = 0;

	client->shared = 0;

	client->willDie = 0;

	// Backend does not accept new clients automatically if it's long-running

	client->acceptUsers = !m_isNextLongRun;

	client->longRun = m_isNextLongRun;

	LOG4CXX_INFO(logger, "New" + (client->longRun ? std::string(" long-running") : "") +  " backend " << client << " connected. Current backend count=" << (m_clients.size() + 1));

	if (m_clients.size() == 0) {

		// first backend connected, start the server, we're ready.

		m_component->start();

	}

	m_clients.push_front(client);

	c->onDisconnected.connect(boost::bind(&NetworkPluginServer::handleSessionFinished, this, client));

	c->onDataRead.connect(boost::bind(&NetworkPluginServer::handleDataRead, this, client, _1));

	sendPing(client);

	// sendPing sets pongReceived to 0, but we want to have it -1 to ignore this backend

	// in first ::pingTimeout call, because it can be called right after this function

	// and backend wouldn't have any time to response to ping.

	client->pongReceived = -1;

	// 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.

		if (getFreeClient() == NULL)

			break;

		User *u = m_waitingUsers.front();

		m_waitingUsers.pop_front();

		LOG4CXX_INFO(logger, "Associating " << u->getJID().toString() << " with this backend");

		// associate backend with user

		handleUserCreated(u);

		// connect user if it's ready

		if (u->isReadyToConnect()) {

			handleUserReadyToConnect(u);

		}

	}

}

void NetworkPluginServer::handleSessionFinished(Backend *c) {

	LOG4CXX_INFO(logger, "Backend " << c << " (ID=" << c->id << ") disconnected. Current backend count=" << (m_clients.size() - 1));

	// This backend will do, so we can't reconnect users to it in User::handleDisconnected call

	c->willDie = true;

	// If there are users associated with this backend, it must have crashed, so print error output

	// and disconnect users

	if (!c->users.empty()) {

		m_crashedBackends.push_back(c->id);

	}

	for (std::list<User *>::const_iterator it = c->users.begin(); it != c->users.end(); it++) {

		LOG4CXX_ERROR(logger, "Backend " << c << " (ID=" << c->id << ") disconnected (probably crashed) with active user " << (*it)->getJID().toString());

		(*it)->setData(NULL);

		(*it)->handleDisconnected("Internal Server Error, please reconnect.");

	}

	std::string message;