if (! CreateProcess(

		utf8ToUtf16(finalExePath).c_str(),

		&rawCommandLineArgs[0],

		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

	// Add host and port.

	finalExePath += std::string(" --host ") + host + " --port " + port + " --service.backend_id=" + log_id + " " + cmdlineArgs;

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

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

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

	strcpy(p, finalExePath.c_str());

	int argc;

	char **argv;

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

	// fork and exec

	pid_t pid = fork();

	if ( pid == 0 ) {

		setsid();

		// close all files

		int maxfd=sysconf(_SC_OPEN_MAX);

		for(int fd=3; fd<maxfd; fd++) {

			close(fd);

		}

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

			_server->handlePIDTerminated((unsigned long)result);

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

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

	// not changed.

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

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

		std::string group = payload.group(i);

		utf8::replace_invalid(payload.group(i).begin(), payload.group(i).end(), group.begin(), '_');

		groups.push_back(group);

	}

	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, DiscoItemsResponder *discoItemsResponder) {

	_server = this;

	m_ftManager = ftManager;

	m_userManager = userManager;

	m_config = config;

	m_component = component;

	m_isNextLongRun = false;

	m_adminInterface = NULL;

	m_startingBackend = false;

	m_lastLogin = 0;

	m_discoItemsResponder = discoItemsResponder;

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

	m_loginTimer = component->getNetworkFactories()->getTimerFactory()->createTimer(CONFIG_INT(config, "service.login_delay") * 1000);

	m_loginTimer->onTick.connect(boost::bind(&NetworkPluginServer::loginDelayFinished, this));

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

}

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::start() {

	m_server->start();

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

	while (true) {

		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(), "1", m_config->getCommandLineArgs().c_str());

		LOG4CXX_INFO(logger, "Tried to spawn first backend with pid " << pid);

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

					if (status == 254) {

						LOG4CXX_ERROR(logger, "Backend can not be started, because it needs database to store data, but the database backend is not configured.");

					}

					else {

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

					}

					LOG4CXX_ERROR(logger, "Check backend log for more details");

					continue;

				}

			}

			else {

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

				continue;

			}

		}

		m_pids.push_back(pid);

		signal(SIGCHLD, SigCatcher);

#endif

		// quit the while loop

		break;

	}

}

void NetworkPluginServer::loginDelayFinished() {

	m_loginTimer->stop();

	connectWaitingUsers();

}

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;

	// Until we receive first PONG from backend, backend is in willDie state.

	client->willDie = true;

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

	client->acceptUsers = !m_isNextLongRun;

	client->longRun = m_isNextLongRun;

	m_startingBackend = false;

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

	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;

}

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;

	pbnetwork::WrapperMessage wrap;

	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_EXIT);

	wrap.SerializeToString(&message);

	send(c->connection, message);

	c->connection->onDisconnected.disconnect_all_slots();

	c->connection->onDataRead.disconnect_all_slots();

	c->connection->disconnect();

	c->connection.reset();

	m_clients.remove(c);

	delete c;

}

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

	pbnetwork::Connected payload;

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

		// TODO: ERROR

		return;

	}

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

	if (!user) {

		LOG4CXX_ERROR(logger, "Connected payload received for unknown user " << payload.user());

		return;

	}

	user->setConnected(true);

	m_component->m_userRegistry->onPasswordValid(payload.user());

}

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

	pbnetwork::Disconnected payload;

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

		// TODO: ERROR

		return;

	}

	m_component->m_userRegistry->onPasswordInvalid(payload.user(), payload.message());

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

	if (!user) {

		return;

	}

	user->handleDisconnected(payload.message(), (Swift::SpectrumErrorPayload::Error) payload.error());

}

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

	pbnetwork::VCard payload;

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

		std::cout << "PARSING ERROR\n";

		// TODO: ERROR

		return;

	}

	std::string field = payload.fullname();

	boost::shared_ptr<Swift::VCard> vcard(new Swift::VCard());

	utf8::replace_invalid(payload.fullname().begin(), payload.fullname().end(), field.begin(), '_');

	vcard->setFullName(field);

	field = payload.nickname();

	utf8::replace_invalid(payload.nickname().begin(), payload.nickname().end(), field.begin(), '_');

	vcard->setNickname(field);

	vcard->setPhoto(Swift::createByteArray(payload.photo()));

	m_vcardResponder->sendVCard(payload.id(), vcard);

}

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

	pbnetwork::Buddy payload;

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

		// TODO: ERROR

		return;

	}

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

	if (!user)

		return;

	// Create subscribe presence and forward it to XMPP side

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

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

	std::string name = payload.buddyname();

	if (CONFIG_BOOL_DEFAULTED(m_config, "service.jid_escaping", true)) {

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

	}

	else {

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

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

		}

	}

	response->setFrom(Swift::JID(name, m_component->getJID().toString()));

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

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

}

void NetworkPluginServer::handleChatStatePayload(const std::string &data, Swift::ChatState::ChatStateType type) {

	pbnetwork::Buddy payload;

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

		// TODO: ERROR

		return;

	}

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

	if (!user)

		return;

	// We're not creating new Conversation just because of chatstates.

	// Some networks/clients spams with chatstates a lot and it leads to bigger memory usage.

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

	if (!conv) {

		return;