// NetworkPlugin uses this method to send the data to networkplugin server

		void sendData(const std::string &string) {

			m_conn->write(Swift::createSafeByteArray(string));

		}

		// This method has to call handleDataRead with all received data from network plugin server

		void _handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data) {

			if (m_firstPing) {

				m_firstPing = false;

				NetworkPlugin::PluginConfig cfg;

				cfg.setRawXML(true);

				sendConfig(cfg);

			}

			std::string d(data->begin(), data->end());

			handleDataRead(d);

		}

		void handleStreamStart(const Swift::ProtocolHeader&) {}

		void handleElement(boost::shared_ptr<Swift::Element> element) {

			boost::shared_ptr<Swift::Stanza> stanza = boost::dynamic_pointer_cast<Swift::Stanza>(element);

			if (!stanza) {

				return;

			}

			std::string user = stanza->getFrom().toBare();

			boost::shared_ptr<Swift::Client> client = m_users[user];

			if (!client)

				return;

			stanza->setFrom(client->getJID());

			boost::shared_ptr<Swift::Message> message = boost::dynamic_pointer_cast<Swift::Message>(stanza);

			if (message) {

				client->sendMessage(message);

				return;

			}

			boost::shared_ptr<Swift::Presence> presence = boost::dynamic_pointer_cast<Swift::Presence>(stanza);

			if (presence) {

				client->sendPresence(presence);

				return;

			}

			boost::shared_ptr<Swift::IQ> iq = boost::dynamic_pointer_cast<Swift::IQ>(stanza);

			if (iq) {

				if (m_handlers[user]->m_id2resource.find(stanza->getID()) != m_handlers[user]->m_id2resource.end()) {

					m_handlers[user]->m_id2resource.erase(stanza->getID());

				}

				client->getIQRouter()->sendIQ(iq);

				return;

			}

		}

		void handleStreamEnd() {}

		void handleRawXML(const std::string &xml) {

			m_xmppParser->parse(xml);

		}

		void handleSwiftDisconnected(const std::string &user, const boost::optional<Swift::ClientError> &error) {

			std::string message = "";

			bool reconnect = false;

			if (error) {

				switch(error->getType()) {

					case Swift::ClientError::UnknownError: message = ("Unknown Error"); reconnect = true; break;

					case Swift::ClientError::DomainNameResolveError: message = ("Unable to find server"); break;

					case Swift::ClientError::ConnectionError: message = ("Error connecting to server"); break;

					case Swift::ClientError::ConnectionReadError: message = ("Error while receiving server data"); reconnect = true; break;

					case Swift::ClientError::ConnectionWriteError: message = ("Error while sending data to the server"); reconnect = true; break;

					case Swift::ClientError::XMLError: message = ("Error parsing server data"); reconnect = true; break;

					case Swift::ClientError::AuthenticationFailedError: message = ("Login/password invalid"); break;

					case Swift::ClientError::CompressionFailedError: message = ("Error while compressing stream"); break;

					case Swift::ClientError::ServerVerificationFailedError: message = ("Server verification failed"); break;

					case Swift::ClientError::NoSupportedAuthMechanismsError: message = ("Authentication mechanisms not supported"); break;

					case Swift::ClientError::UnexpectedElementError: message = ("Unexpected response"); break;

					case Swift::ClientError::ResourceBindError: message = ("Error binding resource"); break;

					case Swift::ClientError::SessionStartError: message = ("Error starting session"); break;

					case Swift::ClientError::StreamError: message = ("Stream error"); break;

					case Swift::ClientError::TLSError: message = ("Encryption error"); break;

					case Swift::ClientError::ClientCertificateLoadError: message = ("Error loading certificate (Invalid password?)"); break;

					case Swift::ClientError::ClientCertificateError: message = ("Certificate not authorized"); break;

					case Swift::ClientError::UnknownCertificateError: message = ("Unknown certificate"); break;

					case Swift::ClientError::CertificateExpiredError: message = ("Certificate has expired"); break;

					case Swift::ClientError::CertificateNotYetValidError: message = ("Certificate is not yet valid"); break;

					case Swift::ClientError::CertificateSelfSignedError: message = ("Certificate is self-signed"); break;

					case Swift::ClientError::CertificateRejectedError: message = ("Certificate has been rejected"); break;

					case Swift::ClientError::CertificateUntrustedError: message = ("Certificate is not trusted"); break;

					case Swift::ClientError::InvalidCertificatePurposeError: message = ("Certificate cannot be used for encrypting your connection"); break;

					case Swift::ClientError::CertificatePathLengthExceededError: message = ("Certificate path length constraint exceeded"); break;

					case Swift::ClientError::InvalidCertificateSignatureError: message = ("Invalid certificate signature"); break;

					case Swift::ClientError::InvalidCAError: message = ("Invalid Certificate Authority"); break;

					case Swift::ClientError::InvalidServerIdentityError: message = ("Certificate does not match the host identity"); break;

				}