libtransport.git Changeset - 66323700f5c7

Changeset - 66323700f5c7

Parent rev.

Child rev.

[Not reviewed]

0 3 0

Jan Kaluza - 10 years ago 2016-02-06 09:37:25
jkaluza@redhat.com

Libtransport: Fix IQs forwarding in Raw XML mode + test it

3 files changed with 56 insertions and 18 deletions:

libtransport/NetworkPluginServer.cpp

spectrum/src/frontends/xmpp/XMPPFrontend.cpp

tests/libtransport/networkpluginserver.cpp

0 comments (0 inline, 0 general)

libtransport/NetworkPluginServer.cpp

➞

Show inline comments

 		std::string message;
 		f.SerializeToString(&message);
 		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_PAUSE);
 		send(b->connection, message);
+	}
+}
 void NetworkPluginServer::handleFTDataNeeded(Backend *b, unsigned long ftid) {
 	pbnetwork::FileTransferData f;
 	f.set_ftid(ftid);
 	f.set_data("");
 	std::string message;
 	f.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_CONTINUE);
 	send(b->connection, message);
+}
 void NetworkPluginServer::connectWaitingUsers() {
 	// 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(true, false, true) == 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::handlePongReceived(Backend *c) {
 	// This could be first PONG from the backend
 	if (c->pongReceived == -1) {
 		// Backend is fully ready to handle requests
 		c->willDie = false;
 		if (m_firstPong) {
 			// first backend connected, start the server, we're ready.
 			m_component->start();
 			m_firstPong = false;
+		}
 		connectWaitingUsers();
+	}
 	c->pongReceived = true;
+}
 void NetworkPluginServer::handleQueryPayload(Backend *b, const std::string &data) {
 	pbnetwork::BackendConfig payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	if (!m_adminInterface) {
 		return;
+	}
 	boost::shared_ptr<Swift::Message> msg(new Swift::Message());
 	msg->setBody(payload.config());
 	m_adminInterface->handleQuery(msg);
 	pbnetwork::BackendConfig response;
 	response.set_config(msg->getBody());
 	std::string message;
 	response.SerializeToString(&message);
 	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_QUERY);
 	send(b->connection, message);
+}
 void NetworkPluginServer::handleBackendConfigPayload(const std::string &data) {
 	pbnetwork::BackendConfig payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	m_config->updateBackendConfig(payload.config());
+}
 void NetworkPluginServer::handleRoomListPayload(const std::string &data) {
 	pbnetwork::RoomList payload;
 	if (payload.ParseFromString(data) == false) {
 		// TODO: ERROR
 		return;
+	}
 	m_component->getFrontend()->clearRoomList();
 	for (int i = 0; i < payload.room_size() && i < payload.name_size(); i++) {
 		m_component->getFrontend()->addRoomToRoomList(Swift::JID::getEscapedNode(payload.room(i)) + "@" + m_component->getJID().toString(), payload.name(i));
+	}
+}
 #if HAVE_SWIFTEN_3
 void NetworkPluginServer::handleElement(boost::shared_ptr<Swift::ToplevelElement> element) {
 #else
 void NetworkPluginServer::handleElement(boost::shared_ptr<Swift::Element> element) {
 #endif
 	boost::shared_ptr<Swift::Stanza> stanza = boost::dynamic_pointer_cast<Swift::Stanza>(element);
 	if (!stanza) {
 		return;
+	}
 	User *user = m_userManager->getUser(stanza->getTo().toBare());
 	if (!user)
 		return;
 	Swift::JID originalJID = stanza->getFrom();
 	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(originalJID.toBare());
 	LocalBuddy *buddy = (LocalBuddy *) user->getRosterManager()->getBuddy(stanza->getFrom().toBare());
 	if (buddy) {
 		const Swift::JID &jid = buddy->getJID();
 		if (stanza->getFrom().getResource().empty()) {
 			stanza->setFrom(Swift::JID(jid.getNode(), jid.getDomain()));
+		}
 		else {
 			stanza->setFrom(Swift::JID(jid.getNode(), jid.getDomain(), stanza->getFrom().getResource()));
+		}
+	}
 	else {
 		std::string name = stanza->getFrom().toBare();
 		if (conv && conv->isMUC()) {
 			if (name.find_last_of("@") != std::string::npos) {
 				name.replace(name.find_last_of("@"), 1, "%");
+			}
+		}
 		else {
 			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, "%");
+				}
+			}
+		}
 		if (stanza->getFrom().getResource().empty()) {
 			stanza->setFrom(Swift::JID(name, m_component->getJID().toString()));
+		}
 		else {
 			stanza->setFrom(Swift::JID(name, m_component->getJID().toString(), stanza->getFrom().getResource()));
+		}
+	}
 	boost::shared_ptr<Swift::Message> message = boost::dynamic_pointer_cast<Swift::Message>(stanza);
 	if (message) {
 		if (conv) {
 			conv->handleRawMessage(message);
 			return;
+		}
 		m_component->getFrontend()->sendMessage(message);
 		return;
+	}
 	boost::shared_ptr<Swift::Presence> presence = boost::dynamic_pointer_cast<Swift::Presence>(stanza);
 	if (presence) {
 		if (buddy) {
 			if (!buddy->isAvailable() && presence->getType() != Swift::Presence::Unavailable) {
 				buddy->m_status.setType(Swift::StatusShow::Online);
+			}
 			buddy->handleRawPresence(presence);
+		}
 		else if (conv) {
 			conv->handleRawPresence(presence);
+		}
 		else {
 			m_component->getFrontend()->sendPresence(presence);
+		}
 		return;
+	}
 	// TODO: FIX TO MAKE RAW XML BACKENDS WORKING AGAIN.
 // 	boost::shared_ptr<Swift::IQ> iq = boost::dynamic_pointer_cast<Swift::IQ>(stanza);
 // 	if (iq) {
 // 		if (m_id2resource.find(stanza->getTo().toBare().toString() + stanza->getID()) != m_id2resource.end()) {
 // 			iq->setTo(Swift::JID(iq->getTo().getNode(), iq->getTo().getDomain(), m_id2resource[stanza->getTo().toBare().toString() + stanza->getID()]));
 // 			m_id2resource.erase(stanza->getTo().toBare().toString() + stanza->getID());
 // 		}
 // 		else {
 // 			Swift::Presence::ref highest = m_component->getPresenceOracle()->getHighestPriorityPresence(user->getJID());
 // 			if (highest) {
 // 			    iq->setTo(highest->getFrom());
 // 			} else {
 // 			    iq->setTo(user->getJID());
 // 			}
 // 		}
 // 		m_component->getFrontend()->sendIQ(iq);
 // 		return;
 // 	}
 	// TODO: Move m_id2resource in User and clean it up
 	boost::shared_ptr<Swift::IQ> iq = boost::dynamic_pointer_cast<Swift::IQ>(stanza);
 	if (iq) {
 		if (m_id2resource.find(stanza->getTo().toBare().toString() + stanza->getID()) != m_id2resource.end()) {
 			iq->setTo(Swift::JID(iq->getTo().getNode(), iq->getTo().getDomain(), m_id2resource[stanza->getTo().toBare().toString() + stanza->getID()]));
 			m_id2resource.erase(stanza->getTo().toBare().toString() + stanza->getID());
+		}
 		else {
 			Swift::Presence::ref highest = m_component->getPresenceOracle()->getHighestPriorityPresence(user->getJID());
 			if (highest) {
 			    iq->setTo(highest->getFrom());
 			} else {
 			    iq->setTo(user->getJID());
+			}
+		}
 		m_component->getFrontend()->sendIQ(iq);
 		return;
+	}
+}
 void NetworkPluginServer::handleRawXML(const std::string &xml) {
 	m_xmppParser->parse(xml);
+}
 void NetworkPluginServer::handleRawPresenceReceived(boost::shared_ptr<Swift::Presence> presence) {
 	if (!CONFIG_BOOL_DEFAULTED(m_config, "features.rawxml", false)) {
 		return;
+	}
 	User *user = m_userManager->getUser(presence->getFrom().toBare());
 	if (!user)
 		return;
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	Swift::JID legacyname = Swift::JID(Buddy::JIDToLegacyName(presence->getTo()));
 	if (!presence->getTo().getResource().empty()) {
 		presence->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain(), presence->getTo().getResource()));
+	}
 	else {
 		presence->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain()));
+	}
 	std::string xml = safeByteArrayToString(m_serializer->serializeElement(presence));
 	WRAP(xml, pbnetwork::WrapperMessage_Type_TYPE_RAW_XML);
 	send(c->connection, xml);
+}
 void NetworkPluginServer::handleRawIQReceived(boost::shared_ptr<Swift::IQ> iq) {
 	User *user = m_userManager->getUser(iq->getFrom().toBare());
 	if (!user)
 		return;
 	Backend *c = (Backend *) user->getData();
 	if (!c) {
 		return;
+	}
 	if (iq->getType() == Swift::IQ::Get) {
 		m_id2resource[iq->getFrom().toBare().toString() + iq->getID()] = iq->getFrom().getResource();
+	}
 	Swift::JID legacyname = Swift::JID(Buddy::JIDToLegacyName(iq->getTo()));
 	if (!iq->getTo().getResource().empty()) {
 		iq->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain(), iq->getTo().getResource()));
+	}
 	else {
 		iq->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain()));
+	}
 	std::string xml = safeByteArrayToString(m_serializer->serializeElement(iq));
 	WRAP(xml, pbnetwork::WrapperMessage_Type_TYPE_RAW_XML);
 	send(c->connection, xml);
+}
 void NetworkPluginServer::handleDataRead(Backend *c, boost::shared_ptr<Swift::SafeByteArray> data) {
 	// Append data to buffer
 	c->data.insert(c->data.end(), data->begin(), data->end());
 	// Parse data while there are some
 	while (c->data.size() != 0) {
 		// expected_size of wrapper message
 		unsigned int expected_size;
 		// if data is >= 4, we have whole header and we can
 		// read expected_size.
 		if (c->data.size() >= 4) {
 			expected_size = *((unsigned int*) &c->data[0]);
 			expected_size = ntohl(expected_size);
 			// If we don't have whole wrapper message, wait for next
 			// handleDataRead call.
 			if (c->data.size() - 4 < expected_size)
 				return;
+		}
 		else {
 			return;
+		}
 		// Parse wrapper message and erase it from buffer.
 		pbnetwork::WrapperMessage wrapper;
 		if (wrapper.ParseFromArray(&c->data[4], expected_size) == false) {
 			std::cout << "PARSING ERROR " << expected_size << "\n";
 			c->data.erase(c->data.begin(), c->data.begin() + 4 + expected_size);
 			continue;
+		}
 		c->data.erase(c->data.begin(), c->data.begin() + 4 + expected_size);
 		// If backend is slow and it is sending us lot of message, there is possibility
 		// that we don't receive PONG response before timeout. However, if we received
 		// at least some data, it means backend is not dead and we can treat it as
 		// PONG received event.
 		if (c->pongReceived == false) {
 			c->pongReceived = true;
+		}
 		// Handle payload in wrapper message
 		switch(wrapper.type()) {
 			case pbnetwork::WrapperMessage_Type_TYPE_CONNECTED:
 				handleConnectedPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_DISCONNECTED:
 				handleDisconnectedPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED:
 				handleBuddyChangedPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE:
 				handleConvMessagePayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_SUBJECT_CHANGED:
 				handleConvMessagePayload(wrapper.payload(), true);
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_PONG:
 				handlePongReceived(c);
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_PARTICIPANT_CHANGED:
 				handleParticipantChangedPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_NICKNAME_CHANGED:
 				handleRoomChangedPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_VCARD:
 				handleVCardPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING:
 				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Composing);
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED:
 				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Paused);
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING:
 				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Active);
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_AUTH_REQUEST:
 				handleAuthorizationPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_ATTENTION:
 				handleAttentionPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_STATS:
 				handleStatsPayload(c, wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_FT_START:
 				handleFTStartPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_FT_FINISH:
 				handleFTFinishPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_FT_DATA:
 				handleFTDataPayload(c, wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_REMOVED:
 				handleBuddyRemovedPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_QUERY:
 				handleQueryPayload(c, wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_BACKEND_CONFIG:
 				handleBackendConfigPayload(wrapper.payload());
 				break;
 			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_LIST:
 				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

spectrum/src/frontends/xmpp/XMPPFrontend.cpp

➞

Show inline comments

 		m_server->addPayloadParserFactory(new GenericPayloadParserFactory<StorageParser>("private", "jabber:iq:private"));
 		m_server->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::AttentionParser>("attention", "urn:xmpp:attention:0"));
 		m_server->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::XHTMLIMParser>("html", "http://jabber.org/protocol/xhtml-im"));
 		m_server->addPayloadParserFactory(new GenericPayloadParserFactory<Transport::BlockParser>("block", "urn:xmpp:block:0"));
 		m_server->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::InvisibleParser>("invisible", "urn:xmpp:invisible:0"));
 		m_server->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::StatsParser>("query", "http://jabber.org/protocol/stats"));
 		m_server->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::GatewayPayloadParser>("query", "jabber:iq:gateway"));
 		m_server->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::MUCPayloadParser>("x", "http://jabber.org/protocol/muc"));
 		m_server->addPayloadSerializer(new Swift::AttentionSerializer());
 		m_server->addPayloadSerializer(new Swift::XHTMLIMSerializer());
 		m_server->addPayloadSerializer(new Transport::BlockSerializer());
 		m_server->addPayloadSerializer(new Swift::InvisibleSerializer());
 		m_server->addPayloadSerializer(new Swift::StatsSerializer());
 		m_server->addPayloadSerializer(new Swift::SpectrumErrorSerializer());
 		m_server->addPayloadSerializer(new Swift::GatewayPayloadSerializer());
 		m_server->onDataRead.connect(boost::bind(&XMPPFrontend::handleDataRead, this, _1));
 		m_server->onDataWritten.connect(boost::bind(&XMPPFrontend::handleDataWritten, this, _1));
+	}
 	else {
 		LOG4CXX_INFO(logger, "Creating component in gateway mode");
 #if HAVE_SWIFTEN_3
 		m_component = new Swift::Component(m_jid, CONFIG_STRING(m_config, "service.password"), factories);
 #else
 		m_component = new Swift::Component(loop, factories, m_jid, CONFIG_STRING(m_config, "service.password"));
 #endif
 		m_component->setSoftwareVersion("Spectrum", SPECTRUM_VERSION);
 		m_component->onConnected.connect(bind(&XMPPFrontend::handleConnected, this));
 		m_component->onError.connect(boost::bind(&XMPPFrontend::handleConnectionError, this, _1));
 		m_component->onDataRead.connect(boost::bind(&XMPPFrontend::handleDataRead, this, _1));
 		m_component->onDataWritten.connect(boost::bind(&XMPPFrontend::handleDataWritten, this, _1));
 		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<StorageParser>("private", "jabber:iq:private"));
 		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::AttentionParser>("attention", "urn:xmpp:attention:0"));
 		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::XHTMLIMParser>("html", "http://jabber.org/protocol/xhtml-im"));
 		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Transport::BlockParser>("block", "urn:xmpp:block:0"));
 		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::InvisibleParser>("invisible", "urn:xmpp:invisible:0"));
 		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::StatsParser>("query", "http://jabber.org/protocol/stats"));
 		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::GatewayPayloadParser>("query", "jabber:iq:gateway"));
 		m_component->addPayloadParserFactory(new GenericPayloadParserFactory<Swift::MUCPayloadParser>("x", "http://jabber.org/protocol/muc"));
 		m_component->addPayloadSerializer(new Swift::AttentionSerializer());
 		m_component->addPayloadSerializer(new Swift::XHTMLIMSerializer());
 		m_component->addPayloadSerializer(new Transport::BlockSerializer());
 		m_component->addPayloadSerializer(new Swift::InvisibleSerializer());
 		m_component->addPayloadSerializer(new Swift::StatsSerializer());
 		m_component->addPayloadSerializer(new Swift::SpectrumErrorSerializer());
 		m_component->addPayloadSerializer(new Swift::GatewayPayloadSerializer());
 		m_stanzaChannel = m_component->getStanzaChannel();
 		m_iqRouter = m_component->getIQRouter();
+	}
 	m_capsMemoryStorage = new CapsMemoryStorage();
 #if HAVE_SWIFTEN_3
 	m_capsManager = new CapsManager(m_capsMemoryStorage, m_stanzaChannel, m_iqRouter, factories->getCryptoProvider());
 #else
 	m_capsManager = new CapsManager(m_capsMemoryStorage, m_stanzaChannel, m_iqRouter);
 #endif
 	m_entityCapsManager = new EntityCapsManager(m_capsManager, m_stanzaChannel);
 	m_entityCapsManager->onCapsChanged.connect(boost::bind(&XMPPFrontend::handleCapsChanged, this, _1));
 	m_stanzaChannel->onPresenceReceived.connect(bind(&XMPPFrontend::handleGeneralPresence, this, _1));
 	m_stanzaChannel->onMessageReceived.connect(bind(&XMPPFrontend::handleMessage, this, _1));
 	m_discoItemsResponder = new DiscoItemsResponder(transport);
 	m_discoItemsResponder->start();
+}
 XMPPFrontend::~XMPPFrontend() {
 	delete m_entityCapsManager;
 	delete m_capsManager;
 	delete m_capsMemoryStorage;
 	if (m_component)
 		delete m_component;
 	if (m_server) {
 		m_server->stop();
 		delete m_server;
+	}
+}
 void XMPPFrontend::handleGeneralPresence(Swift::Presence::ref presence) {
 	onPresenceReceived(presence);
+}
 void XMPPFrontend::handleMessage(boost::shared_ptr<Swift::Message> message) {
 	onMessageReceived(message);
+}
 void XMPPFrontend::clearRoomList() {
 	m_discoItemsResponder->clearRooms();
+}
 void XMPPFrontend::addRoomToRoomList(const std::string &handle, const std::string &name) {
 	m_discoItemsResponder->addRoom(handle, name);
+}
 void XMPPFrontend::sendPresence(Swift::Presence::ref presence) {
 	if (!presence->getFrom().getNode().empty()) {
 		presence->addPayload(boost::shared_ptr<Swift::Payload>(new Swift::CapsInfo(m_discoItemsResponder->getBuddyCapsInfo())));
+	}
 	m_stanzaChannel->sendPresence(presence);
+}
 void XMPPFrontend::sendVCard(Swift::VCard::ref vcard, Swift::JID to) {
 	boost::shared_ptr<Swift::GenericRequest<Swift::VCard> > request(new Swift::GenericRequest<Swift::VCard>(Swift::IQ::Result, to, vcard, m_iqRouter));
 	request->send();
+}
 void XMPPFrontend::sendRosterRequest(Swift::RosterPayload::ref payload, Swift::JID to) {
 	Swift::SetRosterRequest::ref request = Swift::SetRosterRequest::create(payload, to, m_iqRouter);
 	request->send();
+}
 void XMPPFrontend::sendMessage(boost::shared_ptr<Swift::Message> message) {
 	m_stanzaChannel->sendMessage(message);
+}
 void XMPPFrontend::sendIQ(boost::shared_ptr<Swift::IQ> iq) {
 	m_iqRouter->sendIQ(iq);
+}
 boost::shared_ptr<Swift::DiscoInfo> XMPPFrontend::sendCapabilitiesRequest(Swift::JID to) {
 	Swift::DiscoInfo::ref caps = m_entityCapsManager->getCaps(to);
 	if (caps != Swift::DiscoInfo::ref()) {
 		onCapabilitiesReceived(to, caps);
 		return caps;
+	}
 #ifdef SUPPORT_LEGACY_CAPS
 	else {
 		GetDiscoInfoRequest::ref discoInfoRequest = GetDiscoInfoRequest::create(to, m_iqRouter);
 		discoInfoRequest->onResponse.connect(boost::bind(&XMPPFrontend::handleDiscoInfoResponse, this, _1, _2, to));
 		discoInfoRequest->send();
+	}
 #endif
 	return Swift::DiscoInfo::ref();
+}
 void XMPPFrontend::reconnectUser(const std::string &user) {
 	if (inServerMode()) {
 		return;
+	}
 	LOG4CXX_INFO(logger, "Sending probe presence to " << user);
 	Swift::Presence::ref response = Swift::Presence::create();
 	try {
 		response->setTo(user);
+	}
 	catch (...) { return; }
 	response->setFrom(m_component->getJID());
 	response->setType(Swift::Presence::Probe);
 	m_stanzaChannel->sendPresence(response);
+}
 RosterManager *XMPPFrontend::createRosterManager(User *user, Component *component) {
 	return new XMPPRosterManager(user, component);
+}
 User *XMPPFrontend::createUser(const Swift::JID &jid, UserInfo &userInfo, Component *component, UserManager *userManager) {
 	return new XMPPUser(jid, userInfo, component, userManager);
+}
 UserManager *XMPPFrontend::createUserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend) {
 	return new XMPPUserManager(component, userRegistry, storageBackend);
+}
 bool XMPPFrontend::handleIQ(boost::shared_ptr<Swift::IQ> iq) {
 	if (!m_rawXML) {
 		return false;
+	}
 	if (iq->getPayload<Swift::RosterPayload>() != NULL) { return false; }
 	if (iq->getPayload<Swift::InBandRegistrationPayload>() != NULL) { return false; }
 	if (iq->getPayload<Swift::StatsPayload>() != NULL) { return false; }
 	if (iq->getTo().getNode().empty()) {
 		return false;
+	}
 	m_transport->onRawIQReceived(iq);
 	return true;
+}
 void XMPPFrontend::handleBackendConfigChanged() {
 	if (!m_rawXML && CONFIG_BOOL_DEFAULTED(m_config, "features.rawxml", false)) {
 		LOG4CXX_INFO(logger, "Enabled Raw XML mode");
 		m_rawXML = true;
 		m_iqRouter->addHandler(this);
+	}
+}
 Swift::StanzaChannel *XMPPFrontend::getStanzaChannel() {
 	return m_stanzaChannel;
+}
 void XMPPFrontend::connectToServer() {
 	if (m_component && !m_component->isAvailable()) {
 		LOG4CXX_INFO(logger, "Connecting XMPP server " << CONFIG_STRING(m_config, "service.server") << " port " << CONFIG_INT(m_config, "service.port"));
 		if (CONFIG_INT(m_config, "service.port") == 5222) {
 			LOG4CXX_WARN(logger, "Port 5222 is usually used for client connections, not for component connections! Are you sure you are using right port?");
+		}
 		m_component->connect(CONFIG_STRING(m_config, "service.server"), CONFIG_INT(m_config, "service.port"));
+	}
 	else if (m_server) {
 		LOG4CXX_INFO(logger, "Starting XMPPFrontend in server mode on port " << CONFIG_INT(m_config, "service.port"));
 		m_server->start();
 		//Type casting to BoostConnectionServer since onStopped signal is not defined in ConnectionServer
 		//Ideally, onStopped must be defined in ConnectionServer
 		if (boost::dynamic_pointer_cast<Swift::BoostConnectionServer>(m_server->getConnectionServer())) {
 			boost::dynamic_pointer_cast<Swift::BoostConnectionServer>(m_server->getConnectionServer())->onStopped.connect(boost::bind(&XMPPFrontend::handleServerStopped, this, _1));
+		}
 		// We're connected right here, because we're in server mode...
 		handleConnected();
+	}
+}
 void XMPPFrontend::disconnectFromServer() {
 	if (m_component) {
 		// TODO: Call this once swiften will fix assert(!session_);
 // 		m_component->disconnect();
+	}
 	else if (m_server) {
 		LOG4CXX_INFO(logger, "Stopping component in server mode on port " << CONFIG_INT(m_config, "service.port"));
 		m_server->stop();
+	}
+}
 void XMPPFrontend::handleConnected() {
 	m_transport->handleConnected();
+}
 void XMPPFrontend::handleServerStopped(boost::optional<Swift::BoostConnectionServer::Error> e) {
 	if(e) {
 		if(*e == Swift::BoostConnectionServer::Conflict) {
 			LOG4CXX_INFO(logger, "Port "<< CONFIG_INT(m_config, "service.port") << " already in use! Stopping server..");
 			if (CONFIG_INT(m_config, "service.port") == 5347) {
 				LOG4CXX_INFO(logger, "Port 5347 is usually used for components. You are using server_mode=1. Are you sure you don't want to use server_mode=0 and run spectrum as component?");
+			}
+		}
 		if(*e == Swift::BoostConnectionServer::UnknownError)
 			LOG4CXX_INFO(logger, "Unknown error occured! Stopping server..");
 		exit(1);
+	}
+}
 void XMPPFrontend::handleConnectionError(const ComponentError &error) {
 	std::string str = "Unknown error";
 	switch (error.getType()) {
 		case ComponentError::UnknownError: str = "Unknown error"; break;
 		case ComponentError::ConnectionError: str = "Connection error"; break;
 		case ComponentError::ConnectionReadError: str = "Connection read error"; break;
 		case ComponentError::ConnectionWriteError: str = "Connection write error"; break;
 		case ComponentError::XMLError: str = "XML Error"; break;
 		case ComponentError::AuthenticationFailedError: str = "Authentication failed error"; break;
 		case ComponentError::UnexpectedElementError: str = "Unexpected element error"; break;
+	}
 	m_transport->handleConnectionError(str);
+}
 void XMPPFrontend::handleDataRead(const Swift::SafeByteArray &data) {
 	std::string d = safeByteArrayToString(data);
 	m_transport->handleDataRead(d);
+}
 void XMPPFrontend::handleDataWritten(const Swift::SafeByteArray &data) {
 	std::string d = safeByteArrayToString(data);
 	m_transport->handleDataWritten(d);
+}
 void XMPPFrontend::handleDiscoInfoResponse(boost::shared_ptr<Swift::DiscoInfo> info, Swift::ErrorPayload::ref error, const Swift::JID& jid) {
 #ifdef SUPPORT_LEGACY_CAPS
 	onCapabilitiesReceived(jid, info);
 #endif
+}
 void XMPPFrontend::handleCapsChanged(const Swift::JID& jid) {
 	onCapabilitiesReceived(jid, m_entityCapsManager->getCaps(jid));
+}
+}

tests/libtransport/networkpluginserver.cpp

➞

Show inline comments

 #include <cppunit/TestFixture.h>
 #include <cppunit/extensions/HelperMacros.h>
 #include <Swiften/Swiften.h>
 #include <Swiften/EventLoop/DummyEventLoop.h>
 #include <Swiften/Server/Server.h>
 #include <Swiften/Network/DummyNetworkFactories.h>
 #include <Swiften/Network/DummyConnectionServer.h>
 #include "Swiften/Server/ServerStanzaChannel.h"
 #include "Swiften/Server/ServerFromClientSession.h"
 #include "Swiften/Parser/PayloadParsers/FullPayloadParserFactoryCollection.h"
 #include "basictest.h"
 #include <cppunit/TestListener.h>
 #include <cppunit/Test.h>
 #include <time.h>    // for clock()
 #include <stdint.h>
 #include "transport/protocol.pb.h"
 using namespace Transport;
 class Clock {
 	public:
 		double m_beginTime;
 		double m_elapsedTime;
 		void start() {
 			m_beginTime = clock();
+		}
 		void end() {
 			m_elapsedTime = double(clock() - m_beginTime) / CLOCKS_PER_SEC;
+		}
 		double elapsedTime() const {
 			return m_elapsedTime;
+		}
 };
 class NetworkPluginServerTest : public CPPUNIT_NS :: TestFixture, public BasicTest {
 	CPPUNIT_TEST_SUITE(NetworkPluginServerTest);
 	CPPUNIT_TEST(handleBuddyChangedPayload);
 	CPPUNIT_TEST(handleBuddyChangedPayloadNoEscaping);
 	CPPUNIT_TEST(handleBuddyChangedPayloadUserContactInRoster);
 	CPPUNIT_TEST(handleMessageHeadline);
 	CPPUNIT_TEST(handleConvMessageAckPayload);
 	CPPUNIT_TEST(handleRawXML);
 	CPPUNIT_TEST(handleRawXMLSplit);
 	CPPUNIT_TEST(handleRawXMLIQ);
 	CPPUNIT_TEST(benchmarkHandleBuddyChangedPayload);
 	CPPUNIT_TEST(benchmarkSendUnavailablePresence);
 	CPPUNIT_TEST_SUITE_END();
 	public:
 		NetworkPluginServer *serv;
 		NetworkPluginServer::Backend backend;
 		Swift::SafeByteArray protobufData;
 		void setUp (void) {
 			setMeUp();
 			serv = new NetworkPluginServer(component, cfg, userManager, NULL);
 			connectUser();
 			User *user = userManager->getUser("user@localhost");
 			user->setData(&backend);
 			boost::shared_ptr<Swift::Connection> client1 = factories->getConnectionFactory()->createConnection();
 			dynamic_cast<Swift::DummyConnection *>(client1.get())->onDataSent.connect(boost::bind(&NetworkPluginServerTest::handleDataSent, this, _1));
 			backend.connection = client1;
 			received.clear();
+		}
 		void tearDown (void) {
 			received.clear();
 			disconnectUser();
 			delete serv;
 			tearMeDown();
+		}
 		void handleDataSent(const Swift::SafeByteArray &data) {
 			protobufData = data;
+		}
 		void handleConvMessageAckPayload() {
 			handleMessageHeadline();
 			received.clear();
 			User *user = userManager->getUser("user@localhost");
 			pbnetwork::ConversationMessage m;
 			m.set_username("user@localhost");
 			m.set_buddyname("user");
 			m.set_message("");
 			m.set_nickname("");
 			m.set_id("testingid");
 			m.set_xhtml("");
 			m.set_timestamp("");
 			m.set_headline(true);
 			std::string message;
 			m.SerializeToString(&message);
 			serv->handleConvMessageAckPayload(message);
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0]))->getPayload<Swift::DeliveryReceipt>());
 			CPPUNIT_ASSERT_EQUAL(std::string("testingid"), dynamic_cast<Swift::Message *>(getStanza(received[0]))->getPayload<Swift::DeliveryReceipt>()->getReceivedID());
+		}
 		void benchmarkHandleBuddyChangedPayload() {
 			Clock clk;
 			std::vector<std::string> lst;
 			for (int i = 0; i < 2000; i++) {
 				pbnetwork::Buddy buddy;
 				buddy.set_username("user@localhost");
 				buddy.set_buddyname("buddy" + boost::lexical_cast<std::string>(i)  + "@test");
 				buddy.set_status((pbnetwork::StatusType) 5);
 				std::string message;
 				buddy.SerializeToString(&message);
 				lst.push_back(message);
+			}
 			std::vector<std::string> lst2;
 			for (int i = 0; i < 2000; i++) {
 				pbnetwork::Buddy buddy;
 				buddy.set_username("user@localhost");
 				buddy.set_buddyname("buddy" + boost::lexical_cast<std::string>(i)  + "@test");
 				buddy.set_status((pbnetwork::StatusType) 2);
 				std::string message;
 				buddy.SerializeToString(&message);
 				lst2.push_back(message);
+			}
 			clk.start();
 			for (int i = 0; i < 2000; i++) {
 				serv->handleBuddyChangedPayload(lst[i]);
 				received.clear();
+			}
 			for (int i = 0; i < 2000; i++) {
 				serv->handleBuddyChangedPayload(lst2[i]);
 				received.clear();
+			}
 			clk.end();
 			std::cerr << " " << clk.elapsedTime() << " s";
+		}
 		void benchmarkSendUnavailablePresence() {
 			Clock clk;
 			std::vector<std::string> lst;
 			for (int i = 0; i < 1000; i++) {
 				pbnetwork::Buddy buddy;
 				buddy.set_username("user@localhost");
 				buddy.set_buddyname("buddy" + boost::lexical_cast<std::string>(i)  + "@test");
 				buddy.set_status((pbnetwork::StatusType) 5);
 				std::string message;
 				buddy.SerializeToString(&message);
 				lst.push_back(message);
+			}
 			std::vector<std::string> lst2;
 			for (int i = 0; i < 1000; i++) {
 				pbnetwork::Buddy buddy;
 				buddy.set_username("user@localhost");
 				buddy.set_buddyname("buddy" + boost::lexical_cast<std::string>(1000+i)  + "@test");
 				buddy.set_status((pbnetwork::StatusType) 2);
 				std::string message;
 				buddy.SerializeToString(&message);
 				lst2.push_back(message);
+			}
 			for (int i = 0; i < 1000; i++) {
 				serv->handleBuddyChangedPayload(lst[i]);
 				received.clear();
+			}
 			for (int i = 0; i < 1000; i++) {
 				serv->handleBuddyChangedPayload(lst2[i]);
 				received.clear();
+			}
 			User *user = userManager->getUser("user@localhost");
 			clk.start();
 			user->getRosterManager()->sendUnavailablePresences("user@localhost");
 			clk.end();
 			std::cerr << " " << clk.elapsedTime() << " s";
+		}
 		void handleBuddyChangedPayload() {
 			User *user = userManager->getUser("user@localhost");
 			pbnetwork::Buddy buddy;
 			buddy.set_username("user@localhost");
 			buddy.set_buddyname("buddy1@test");
 			buddy.set_status(pbnetwork::STATUS_NONE);
 			std::string message;
 			buddy.SerializeToString(&message);
 			serv->handleBuddyChangedPayload(message);
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			Swift::RosterPayload::ref payload1 = getStanza(received[0])->getPayload<Swift::RosterPayload>();
 			CPPUNIT_ASSERT_EQUAL(1, (int) payload1->getItems().size());
 			Swift::RosterItemPayload item = payload1->getItems()[0];
 			CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40test@localhost"), item.getJID().toString());
+		}
 		void handleBuddyChangedPayloadNoEscaping() {
 			std::istringstream ifs("service.server_mode = 1\nservice.jid_escaping=0\nservice.jid=localhost\nservice.more_resources=1\n");
 			cfg->load(ifs);
 			User *user = userManager->getUser("user@localhost");
 			pbnetwork::Buddy buddy;
 			buddy.set_username("user@localhost");
 			buddy.set_buddyname("buddy1@test");
 			buddy.set_status(pbnetwork::STATUS_NONE);
 			std::string message;
 			buddy.SerializeToString(&message);
 			serv->handleBuddyChangedPayload(message);
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			Swift::RosterPayload::ref payload1 = getStanza(received[0])->getPayload<Swift::RosterPayload>();
 			CPPUNIT_ASSERT_EQUAL(1, (int) payload1->getItems().size());
 			Swift::RosterItemPayload item = payload1->getItems()[0];
 			CPPUNIT_ASSERT_EQUAL(std::string("buddy1%test@localhost"), item.getJID().toString());
 			std::istringstream ifs2("service.server_mode = 1\nservice.jid_escaping=1\nservice.jid=localhost\nservice.more_resources=1\n");
 			cfg->load(ifs2);
+		}
 		void handleBuddyChangedPayloadUserContactInRoster() {
 			User *user = userManager->getUser("user@localhost");
 			pbnetwork::Buddy buddy;
 			buddy.set_username("user@localhost");
 			buddy.set_buddyname("user");
 			std::string message;
 			buddy.SerializeToString(&message);
 			serv->handleBuddyChangedPayload(message);
 			CPPUNIT_ASSERT_EQUAL(0, (int) received.size());
+		}
 		void handleRawXML() {
 			cfg->updateBackendConfig("[features]\nrawxml=1\n");
 			User *user = userManager->getUser("user@localhost");
 			std::vector<std::string> grp;
 			grp.push_back("group1");
 			LocalBuddy *buddy = new LocalBuddy(user->getRosterManager(), -1, "buddy1@domain.tld", "Buddy 1", grp, BUDDY_JID_ESCAPING);
 			user->getRosterManager()->setBuddy(buddy);
 			received.clear();
 			std::string xml = "<presence from='buddy1@domain.tld/res' to='user@localhost'/>";
 			serv->handleRawXML(xml);
 			std::string xml2 = "<presence from='buddy1@domain.tld/res2' to='user@localhost'/>";
 			serv->handleRawXML(xml2);
 			CPPUNIT_ASSERT_EQUAL(2, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40domain.tld@localhost/res"), dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getFrom().toString());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40domain.tld@localhost/res2"), dynamic_cast<Swift::Presence *>(getStanza(received[1]))->getFrom().toString());
 			received.clear();
 			user->getRosterManager()->sendUnavailablePresences("user@localhost");
 			CPPUNIT_ASSERT_EQUAL(3, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40domain.tld@localhost/res"), dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getFrom().toString());
 			CPPUNIT_ASSERT_EQUAL(Swift::Presence::Unavailable, dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getType());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[1])));
 			CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40domain.tld@localhost/res2"), dynamic_cast<Swift::Presence *>(getStanza(received[1]))->getFrom().toString());
 			CPPUNIT_ASSERT_EQUAL(Swift::Presence::Unavailable, dynamic_cast<Swift::Presence *>(getStanza(received[1]))->getType());
+		}
 		void handleMessageHeadline() {
 			User *user = userManager->getUser("user@localhost");
 			pbnetwork::ConversationMessage m;
 			m.set_username("user@localhost");
 			m.set_buddyname("user");
 			m.set_message("msg");
 			m.set_nickname("");
 			m.set_xhtml("");
 			m.set_timestamp("");
 			m.set_headline(true);
 			std::string message;
 			m.SerializeToString(&message);
 			serv->handleConvMessagePayload(message, false);
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::Message::Chat, dynamic_cast<Swift::Message *>(getStanza(received[0]))->getType());
 			received.clear();
 			user->addUserSetting("send_headlines", "1");
 			serv->handleConvMessagePayload(message, false);
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Message *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::Message::Headline, dynamic_cast<Swift::Message *>(getStanza(received[0]))->getType());
+		}
 		void handleRawXMLSplit() {
 			cfg->updateBackendConfig("[features]\nrawxml=1\n");
 			User *user = userManager->getUser("user@localhost");
 			std::vector<std::string> grp;
 			grp.push_back("group1");
 			LocalBuddy *buddy = new LocalBuddy(user->getRosterManager(), -1, "buddy1@domain.tld", "Buddy 1", grp, BUDDY_JID_ESCAPING);
 			user->getRosterManager()->setBuddy(buddy);
 			received.clear();
 			std::string xml = "<presence from='buddy1@domain.tld/res' ";
 			serv->handleRawXML(xml);
 			std::string xml2 = " to='user@localhost'/>";
 			serv->handleRawXML(xml2);
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::Presence *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(std::string("buddy1\\40domain.tld@localhost/res"), dynamic_cast<Swift::Presence *>(getStanza(received[0]))->getFrom().toString());
+		}
 		void handleRawXMLIQ() {
 			cfg->updateBackendConfig("[features]\nrawxml=1\n");
 			User *user = userManager->getUser("user@localhost");
 			std::vector<std::string> grp;
 			grp.push_back("group1");
 			LocalBuddy *buddy = new LocalBuddy(user->getRosterManager(), -1, "buddy1@domain.tld", "Buddy 1", grp, BUDDY_JID_ESCAPING);
 			user->getRosterManager()->setBuddy(buddy);
 			received.clear();
 			std::string xml = "<iq from='buddy1@domain.tld/res' to='user@localhost' type='get' id='1'/>";
 			serv->handleRawXML(xml);
 			CPPUNIT_ASSERT_EQUAL(1, (int) received.size());
 			CPPUNIT_ASSERT(dynamic_cast<Swift::IQ *>(getStanza(received[0])));
 			CPPUNIT_ASSERT_EQUAL(Swift::IQ::Get, dynamic_cast<Swift::IQ *>(getStanza(received[0]))->getType());
 			injectIQ(Swift::IQ::createResult(getStanza(received[0])->getFrom(), getStanza(received[0])->getTo(), getStanza(received[0])->getID()));
 			loop->processEvents();
 			pbnetwork::WrapperMessage wrapper;
 			wrapper.ParseFromArray(&protobufData[4], protobufData.size());
 			CPPUNIT_ASSERT_EQUAL(pbnetwork::WrapperMessage_Type_TYPE_RAW_XML, wrapper.type());
+		}
 };
 CPPUNIT_TEST_SUITE_REGISTRATION (NetworkPluginServerTest);

0 comments (0 inline, 0 general)