libtransport.git Changeset - 8c529dbabbbc

Changeset - 8c529dbabbbc

Parent rev.

Child rev.

[Not reviewed]

0 4 0

HanzZ - 14 years ago 2011-10-25 20:29:58
hanzz.k@gmail.com

semi-working PMs in muc

4 files changed with 44 insertions and 18 deletions:

backends/libircclient-qt/ircnetworkplugin.cpp

include/transport/conversation.h

src/conversation.cpp

src/user.cpp

0 comments (0 inline, 0 general)

backends/libircclient-qt/ircnetworkplugin.cpp

➞

Show inline comments

 #include "ircnetworkplugin.h"
 IRCNetworkPlugin::IRCNetworkPlugin(Config *config, Swift::QtEventLoop *loop, const std::string &host, int port) {
 	this->config = config;
 	m_socket = new QTcpSocket();
 	m_socket->connectToHost(QString::fromStdString(host), port);
 	connect(m_socket, SIGNAL(readyRead()), this, SLOT(readData()));
+}
 void IRCNetworkPlugin::readData() {
 	size_t availableBytes = m_socket->bytesAvailable();
 	if (availableBytes == 0)
 		return;
 	std::cout << "READ\n";
 	std::string d = std::string(m_socket->readAll().data(), availableBytes);
 	handleDataRead(d);
+}
 void IRCNetworkPlugin::sendData(const std::string &string) {
 	m_socket->write(string.c_str(), string.size());
+}
 void IRCNetworkPlugin::handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) {
 	// Server is in server-mode, so user is JID of server when we want to connect
 	if (CONFIG_BOOL(config, "service.server_mode")) {
 		MyIrcSession *session = new MyIrcSession(user, this);
 		std::string h = user.substr(0, user.find("@"));
 		session->setNick(QString::fromStdString(h.substr(0, h.find("%"))));
 		session->connectToServer(QString::fromStdString(h.substr(h.find("%") + 1)), 6667);
 		std::cout << "CONNECTING IRC NETWORK " << h.substr(h.find("%") + 1) << "\n";
 		m_sessions[user] = session;
+	}
 	else {
 		handleConnected(user);
+	}
+}
 void IRCNetworkPlugin::handleLogoutRequest(const std::string &user, const std::string &legacyName) {
 	if (m_sessions[user] == NULL)
 		return;
 	m_sessions[user]->disconnectFromServer();
 	m_sessions[user]->deleteLater();
 	m_sessions.erase(user);
+}
 void IRCNetworkPlugin::handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &/*xhtml*/) {
 	std::string u = user;
 	std::cout << "AAAAA " << legacyName << "\n";
 	if (!CONFIG_BOOL(config, "service.server_mode")) {
 		u = user + legacyName.substr(legacyName.find("@") + 1);
 		if (u.find("/") != std::string::npos) {
 			u = u.substr(0, u.find("/"));
+		}
+	}
 	if (m_sessions[u] == NULL)
 	if (m_sessions[u] == NULL) {
 		std::cout << "No session for " << u << "\n";
 		return;
+	}
 	std::string r = legacyName;
 	if (!CONFIG_BOOL(config, "service.server_mode")) {
 		r = legacyName.substr(0, r.find("@"));
 		if (legacyName.find("/") == std::string::npos) {
 			r = legacyName.substr(0, r.find("@"));
+		}
 		else {
 			r = legacyName.substr(legacyName.find("/") + 1);
+		}
+	}
 	std::cout << "MESSAGE " << u << " " << r << "\n";
 	m_sessions[u]->message(QString::fromStdString(r), QString::fromStdString(message));
 	std::cout << "SENT\n";
+}
 void IRCNetworkPlugin::handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password) {
 	std::cout << "JOIN\n";
 	std::string r = room;
 	std::string u = user;
 	if (!CONFIG_BOOL(config, "service.server_mode")) {
 		u = user + room.substr(room.find("%") + 1);
 		r = room.substr(0, room.find("%"));
 		u = user + room.substr(room.find("@") + 1);
 		r = room.substr(0, room.find("@"));
+	}
 	if (m_sessions[u] == NULL) {
 		// in gateway mode we want to login this user to network according to legacyName
-		if (room.find("%") != std::string::npos) {
+		if (room.find("@") != std::string::npos) {
 			// suffix is %irc.freenode.net to let MyIrcSession return #room%irc.freenode.net
-			MyIrcSession *session = new MyIrcSession(user, this, room.substr(room.find("%")));
+			MyIrcSession *session = new MyIrcSession(user, this, room.substr(room.find("@")));
 			session->setNick(QString::fromStdString(nickname));
 			session->connectToServer(QString::fromStdString(room.substr(room.find("%") + 1)), 6667);
 			std::cout << "CONNECTING IRC NETWORK " << room.substr(room.find("%") + 1) << "\n";
 			std::cout << "SUFFIX " << room.substr(room.find("%")) << "\n";
 			session->connectToServer(QString::fromStdString(room.substr(room.find("@") + 1)), 6667);
 			std::cout << "CONNECTING IRC NETWORK " << room.substr(room.find("@") + 1) << "\n";
 			std::cout << "SUFFIX " << room.substr(room.find("@")) << "\n";
 			m_sessions[u] = session;
+		}
 		else {
 			return;
+		}
+	}
 	std::cout << "JOINING " << r << "\n";
 	m_sessions[u]->addAutoJoinChannel(QString::fromStdString(r));
 	m_sessions[u]->join(QString::fromStdString(r), QString::fromStdString(password));
 	m_sessions[u]->rooms += 1;
 	// update nickname, because we have nickname per session, no nickname per room.
 	handleRoomNicknameChanged(user, r, m_sessions[u]->nick().toStdString());
+}
 void IRCNetworkPlugin::handleLeaveRoomRequest(const std::string &user, const std::string &room) {
 	std::string r = room;
 	std::string u = user;
 	if (!CONFIG_BOOL(config, "service.server_mode")) {
 		r = room.substr(0, room.find("%"));
 		u = user + room.substr(room.find("%") + 1);
 		r = room.substr(0, room.find("@"));
 		u = user + room.substr(room.find("@") + 1);
+	}
 	if (m_sessions[u] == NULL)
 		return;
 	m_sessions[u]->part(QString::fromStdString(r));
 	m_sessions[u]->removeAutoJoinChannel(QString::fromStdString(r));
 	m_sessions[u]->rooms -= 1;
 	if (m_sessions[u]->rooms <= 0) {
 		m_sessions[u]->disconnectFromServer();
 		m_sessions[u]->deleteLater();
 		m_sessions.erase(u);
+	}
+}

include/transport/conversation.h

➞

Show inline comments

@@ @@ -52,68 +52,66 @@ class Conversation { @@
 		/// \return legacy network name of this conversation.
 		const std::string &getLegacyName() { return m_legacyName; }
 		/// Handles new message from Legacy network and forwards it to XMPP.
 		/// \param message Message received from legacy network.
 		/// \param nickname For MUC conversation this is nickname of room participant who sent this message.
 		void handleMessage(boost::shared_ptr<Swift::Message> &message, const std::string &nickname = "");
 		/// Handles participant change in MUC.
 		/// \param nickname Nickname of participant which changed.
 		/// \param flag ParticipantFlag.
 		/// \param status Current status of this participant.
 		/// \param statusMessage Current status message of this participant.
 		/// \param newname If participant was renamed, this variable contains his new name.
 		void handleParticipantChanged(const std::string &nickname, int flag, int status = Swift::StatusShow::None, const std::string &statusMessage = "", const std::string &newname = "");
 		/// Sets XMPP user nickname in MUC rooms.
 		/// \param nickname XMPP user nickname in MUC rooms.
 		void setNickname(const std::string &nickname) {
 			m_nickname = nickname;
+		}
 		/// Sends message to Legacy network.
 		/// \param message Message.
 		virtual void sendMessage(boost::shared_ptr<Swift::Message> &message) = 0;
 		/// Returns ConversationManager associated with this Conversation.
 		/// \return  ConversationManager associated with this Conversation.
 		ConversationManager *getConversationManager() {
 			return m_conversationManager;
+		}
 		/// Returns True if this conversation is MUC room.
 		/// \return  True if this conversation is MUC room.
 		bool isMUC() {
 			return m_muc;
+		}
 		/// Sets room name associated with this Conversation.
 		/// This is used to detect Private messages associated with particular room.
 		/// \param room room name associated with this Conversation.
 		void setRoom(const std::string &room) {
 			m_room = room;
+		}
 		void setRoom(const std::string &room);
 		/// Returns room name associated with this Conversation.
 		/// \return room name associated with this Conversation.
 		const std::string &getRoom() {
 			return m_room;
+		}
 	private:
 		ConversationManager *m_conversationManager;
 		std::string m_legacyName;
 		std::string m_nickname;
 		std::string m_room;
 		bool m_muc;
 };
+}

src/conversation.cpp

➞

Show inline comments

 /**
  * XMPP - libpurple transport
+ *
  * Copyright (C) 2009, Jan Kaluza <hanzz@soc.pidgin.im>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
+ *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
+ *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  */
 #include <iostream>
 #include "transport/conversation.h"
 #include "transport/conversationmanager.h"
 #include "transport/user.h"
 #include "transport/transport.h"
 #include "transport/buddy.h"
 #include "transport/rostermanager.h"
 #include "log4cxx/logger.h"
 using namespace log4cxx;
 namespace Transport {
 // static LoggerPtr logger = Logger::getLogger("Conversation");
 Conversation::Conversation(ConversationManager *conversationManager, const std::string &legacyName, bool isMUC) : m_conversationManager(conversationManager) {
 	m_legacyName = legacyName;
 	m_conversationManager->addConversation(this);
 	m_muc = isMUC;
+}
 Conversation::~Conversation() {
+}
 void Conversation::setRoom(const std::string &room) {
 	m_room = room;
 	m_legacyName = m_room + "/" + m_legacyName;
+}
 void Conversation::handleMessage(boost::shared_ptr<Swift::Message> &message, const std::string &nickname) {
 	if (m_muc) {
 		message->setType(Swift::Message::Groupchat);
+	}
 	else {
 		message->setType(Swift::Message::Chat);
+	}
 	if (message->getType() != Swift::Message::Groupchat) {
 		message->setTo(m_conversationManager->getUser()->getJID().toBare());
 		// normal message
 		if (nickname.empty()) {
 			Buddy *buddy = m_conversationManager->getUser()->getRosterManager()->getBuddy(m_legacyName);
 			if (buddy) {
 				message->setFrom(buddy->getJID());
+			}
 			else {
 				message->setFrom(Swift::JID(Swift::JID::getEscapedNode(m_legacyName), m_conversationManager->getComponent()->getJID().toBare()));
+			}
+		}
 		// PM message
 		else {
 			if (m_room.empty()) {
 				message->setFrom(Swift::JID(nickname, m_conversationManager->getComponent()->getJID().toBare(), "user"));
+			}
 			else {
 				message->setFrom(Swift::JID(m_room, m_conversationManager->getComponent()->getJID().toBare(), nickname));
+			}
+		}
 		m_conversationManager->getComponent()->getStanzaChannel()->sendMessage(message);
+	}
 	else {
 		std::string legacyName = m_legacyName;
 		if (legacyName.find_last_of("@") != std::string::npos) {
 			legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+		}
 		message->setTo(m_conversationManager->getUser()->getJID().toString());
-		message->setFrom(Swift::JID(m_legacyName, m_conversationManager->getComponent()->getJID().toBare(), nickname));
+		message->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), nickname));
 		m_conversationManager->getComponent()->getStanzaChannel()->sendMessage(message);
+	}
+}
 void Conversation::handleParticipantChanged(const std::string &nick, int flag, int status, const std::string &statusMessage, const std::string &newname) {
 	std::string nickname = nick;
 	Swift::Presence::ref presence = Swift::Presence::create();
  	presence->setFrom(Swift::JID(m_legacyName, m_conversationManager->getComponent()->getJID().toBare(), nickname));
 	std::string legacyName = m_legacyName;
 	if (m_muc) {
 		if (legacyName.find_last_of("@") != std::string::npos) {
 			legacyName.replace(legacyName.find_last_of("@"), 1, "%"); // OK
+		}
+	}
 	presence->setFrom(Swift::JID(legacyName, m_conversationManager->getComponent()->getJID().toBare(), nickname));
 	presence->setTo(m_conversationManager->getUser()->getJID().toString());
 	presence->setType(Swift::Presence::Available);
 	if (!statusMessage.empty())
 		presence->setStatus(statusMessage);
 	Swift::StatusShow s((Swift::StatusShow::Type) status);
 	if (s.getType() == Swift::StatusShow::None) {
 		presence->setType(Swift::Presence::Unavailable);
+	}
 	presence->setShow(s.getType());
 	Swift::MUCUserPayload *p = new Swift::MUCUserPayload ();
 	if (m_nickname == nickname) {
 		Swift::MUCUserPayload::StatusCode c;
 		c.code = 110;
 		p->addStatusCode(c);
+	}
 	Swift::MUCItem item;
 	item.affiliation = Swift::MUCOccupant::Member;
 	item.role = Swift::MUCOccupant::Participant;
 	if (flag & Moderator) {
 		item.affiliation = Swift::MUCOccupant::Admin;
 		item.role = Swift::MUCOccupant::Moderator;
+	}
 	if (!newname.empty()) {
 		item.nick = newname;
 		Swift::MUCUserPayload::StatusCode c;
 		c.code = 303;
 		p->addStatusCode(c);
 		presence->setType(Swift::Presence::Unavailable);
+	}
 	p->addItem(item);
 	presence->addPayload(boost::shared_ptr<Swift::Payload>(p));
 	m_conversationManager->getComponent()->getStanzaChannel()->sendPresence(presence);
 	if (!newname.empty()) {
 		handleParticipantChanged(newname, flag, status, statusMessage);
+	}
+}

src/user.cpp

➞

Show inline comments

@@ @@ -149,107 +149,109 @@ void User::sendCurrentPresence() { @@
 		Swift::Presence::ref response = Swift::Presence::create();
 		response->setTo(m_jid.toBare());
 		response->setFrom(m_component->getJID());
 		response->setType(Swift::Presence::Unavailable);
 		response->setStatus("Connecting");
 		m_component->getStanzaChannel()->sendPresence(response);
+	}
+}
 void User::setConnected(bool connected) {
 	m_connected = connected;
 	setIgnoreDisconnect(false);
 	updateLastActivity();
 	sendCurrentPresence();
+}
 void User::handlePresence(Swift::Presence::ref presence) {
 	if (!m_connected) {
 		// we are not connected to legacy network, so we should do it when disco#info arrive :)
 		if (m_readyForConnect == false) {
 			// Forward status message to legacy network, but only if it's sent from active resource
 // 					if (m_activeResource == presence->getFrom().getResource().getUTF8String()) {
 // 						forwardStatus(presenceShow, stanzaStatus);
 // 					}
 			boost::shared_ptr<Swift::CapsInfo> capsInfo = presence->getPayload<Swift::CapsInfo>();
 			if (capsInfo && capsInfo->getHash() == "sha-1") {
 				if (m_entityCapsManager->getCaps(presence->getFrom()) != Swift::DiscoInfo::ref()) {
 					LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 					m_readyForConnect = true;
 					onReadyToConnect();
+				}
+			}
 			else if (m_component->inServerMode()) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 				m_readyForConnect = true;
 				onReadyToConnect();
+			}
 			else {
 				m_reconnectTimer->start();
+			}
+		}
+	}
 	bool isMUC = presence->getPayload<Swift::MUCPayload>() != NULL || *presence->getTo().getNode().c_str() == '#';
 	if (isMUC) {
 		if (presence->getType() == Swift::Presence::Unavailable) {
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Going to left room " << presence->getTo().getNode());
 			onRoomLeft(presence->getTo().getNode());
 			std::string room = Buddy::JIDToLegacyName(presence->getTo());
 			onRoomLeft(room);
+		}
 		else {
 			// force connection to legacy network to let backend to handle auto-join on connect.
 			if (!m_readyForConnect) {
 				LOG4CXX_INFO(logger, m_jid.toString() << ": Ready to be connected to legacy network");
 				m_readyForConnect = true;
 				onReadyToConnect();
+			}
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Going to join room " << presence->getTo().getNode() << " as " << presence->getTo().getResource());
 			onRoomJoined(presence->getTo().getNode(), presence->getTo().getResource(), "");
 			std::string room = Buddy::JIDToLegacyName(presence->getTo());
 			onRoomJoined(room, presence->getTo().getResource(), "");
+		}
 		return;
+	}
 	sendCurrentPresence();
 	// Change legacy network presence
 	if (m_readyForConnect) {
 		Swift::Presence::ref highest = m_presenceOracle->getHighestPriorityPresence(m_jid.toBare());
 		if (highest) {
 			Swift::Presence::ref response = Swift::Presence::create(highest);
 			response->setTo(m_jid);
 			response->setFrom(m_component->getJID());
 			LOG4CXX_INFO(logger, m_jid.toString() << ": Changing legacy network presence to " << response->getType());
 			onPresenceChanged(highest);
+		}
 		else {
 			Swift::Presence::ref response = Swift::Presence::create();
 			response->setTo(m_jid.toBare());
 			response->setFrom(m_component->getJID());
 			response->setType(Swift::Presence::Unavailable);
 			onPresenceChanged(response);
+		}
+	}
+}
 void User::handleSubscription(Swift::Presence::ref presence) {
 	m_rosterManager->handleSubscription(presence);
+}
 void User::handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info) {
 	LOG4CXX_INFO(logger, jid.toString() << ": got disco#info");
 #ifdef SUPPORT_LEGACY_CAPS
 	Swift::DiscoInfo::ref discoInfo = m_entityCapsManager->getCaps(jid);
 	// This is old legacy cap which is not stored in entityCapsManager,
 	// we have to store it in our user class.
 	if (!discoInfo) {
 		LOG4CXX_INFO(logger, jid.toString() << ": LEGACY");
 		m_legacyCaps[jid] = info;
+	}
 #endif
 	onConnectingTimeout();
+}
 void User::onConnectingTimeout() {
 	if (m_connected || m_readyForConnect)

0 comments (0 inline, 0 general)