}

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

	c->write(Swift::createSafeByteArray(std::string(header, 4) + data));

}

void NetworkPluginServer::pingTimeout() {

	// TODO: move to separate timer, those 2 loops could be expensive

	// Some users are connected for weeks and they are blocking backend to be destroyed and its memory

	// to be freed. We are finding users who are inactive for more than "idle_reconnect_time" seconds and

	// reconnect them to long-running backend, where they can idle hapilly till the end of ages.

	time_t now = time(NULL);

	std::vector<User *> usersToMove;

	unsigned long diff = CONFIG_INT(m_config, "service.idle_reconnect_time");

	if (diff != 0) {

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

			// Users from long-running backends can't be moved

			if ((*it)->longRun) {

				continue;

	// check ping responses

	std::vector<Backend *> toRemove;

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

		// pong has been received OR backend just connected and did not have time to answer the ping

		// request.

		if ((*it)->pongReceived || (*it)->pongReceived == -1) {

			// Don't send another ping if pongReceived == -1, because we've already sent one

			// when registering backend.

			if ((*it)->pongReceived) {

				sendPing((*it));

			}

		}

		else {

			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). PING response not received.");

			toRemove.push_back(*it);

#ifndef WIN32

			// generate coredump for this backend to find out why it wasn't able to respond to PING

			std::string pid = (*it)->id;

			if (!pid.empty()) {

				try {

					kill(boost::lexical_cast<int>(pid), SIGABRT);

				}

void NetworkPluginServer::sendPing(Backend *c) {

	std::string message;

	pbnetwork::WrapperMessage wrap;

	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PING);

	wrap.SerializeToString(&message);

	if (c->connection) {

		LOG4CXX_INFO(logger, "PING to " << c << " (ID=" << c->id << ")");

		send(c->connection, message);

		c->pongReceived = false;

	}

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

}

void NetworkPluginServer::sendAPIVersion(Backend *c) {

	pbnetwork::APIVersion apiver;

	apiver.set_version(NETWORK_PLUGIN_API_VERSION);

	std::string message;

	apiver.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_API_VERSION);

		}

	}

}

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

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

	char *header = (char *) &size;

	sendData(std::string(header, 4) + data);

}

void NetworkPlugin::checkPing() {

	if (m_pingReceived == false) {

		handleExitRequest();

	}

	m_pingReceived = false;

}

void NetworkPlugin::sendPong() {

	m_pingReceived = true;

	std::string message;

	pbnetwork::WrapperMessage wrap;

	wrap.set_type(pbnetwork::WrapperMessage_Type_TYPE_PONG);

	wrap.SerializeToString(&message);