handleRoomListPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE_ACK:

				handleConvMessageAckPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_RAW_XML:

				handleRawXML(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

	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;

			}

			// Find users which are inactive for more than 'diff'

			BOOST_FOREACH(User *u, (*it)->users) {

				if (now - u->getLastActivity() > diff) {

					usersToMove.push_back(u);

				}

			}

		}

		// Move inactive users to long-running backend.

		BOOST_FOREACH(User *u, usersToMove) {

			LOG4CXX_INFO(logger, "Moving user " << u->getJID().toString() << " to long-running backend");

			if (!moveToLongRunBackend(u))

				break;

		}

	}

	// We have to remove startingBackend flag otherwise 1 broken backend start could

	// block the backend.

	m_startingBackend = false;

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

				}

				catch (...) { }

			}

#endif

		}

		if ((*it)->users.size() == 0) {

			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). There are no users.");

			toRemove.push_back(*it);

		}

	}

	BOOST_FOREACH(Backend *b, toRemove) {

		return;

	}

#if !HAVE_SWIFTEN_3

	if (state.state == Swift::FileTransfer::State::Transferring) {

		handleFTAccepted(user, buddyName, fileName, size, id);

	}

	else if (state.state == Swift::FileTransfer::State::Canceled) {

		handleFTRejected(user, buddyName, fileName, size);

	}

#endif

}

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

	if (c->connection) {

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

		send(c->connection, message);

	}

}

void NetworkPluginServer::handlePIDTerminated(unsigned long pid) {

	std::vector<unsigned long>::iterator log_id_it;

	log_id_it = std::find(m_pids.begin(), m_pids.end(), pid);

	if (log_id_it != m_pids.end()) {

		*log_id_it = 0;

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_FT_CONTINUE:

				handleFTContinuePayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_EXIT:

				handleExitRequest();

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_RAW_XML:

				handleRawXML(wrapper.payload());

				break;

			default:

				return;

		}

	}

}

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

	send(message);

	sendMemoryUsage();

}

void NetworkPlugin::sendMemoryUsage() {

	pbnetwork::Stats stats;

	stats.set_init_res(m_init_res);

	double res = 0;

	double shared = 0;

#ifndef WIN32

	process_mem_usage(shared, res);