512 lines
18 KiB
C++
512 lines
18 KiB
C++
/**
|
|
* XMPP - libpurple transport
|
|
*
|
|
* Copyright (C) 2013, Jan Kaluza <hanzz.k@gmail.com>
|
|
*
|
|
* 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 "session.h"
|
|
#include <QtCore>
|
|
#include <iostream>
|
|
#include <IrcCommand>
|
|
#include <IrcMessage>
|
|
#include "backports.h"
|
|
|
|
#include "ircnetworkplugin.h"
|
|
|
|
#define FROM_UTF8(WHAT) QString::fromUtf8((WHAT).c_str(), (WHAT).size())
|
|
#define TO_UTF8(WHAT) std::string((WHAT).toUtf8().data(), (WHAT).toUtf8().size())
|
|
|
|
#include "transport/Logging.h"
|
|
|
|
DEFINE_LOGGER(logger, "IRCConnection");
|
|
|
|
// static bool sentList;
|
|
|
|
MyIrcSession::MyIrcSession(const std::string &user, IRCNetworkPlugin *np, const std::string &suffix, QObject* parent) : IrcConnection(parent)
|
|
{
|
|
m_np = np;
|
|
m_user = user;
|
|
m_suffix = suffix;
|
|
m_connected = false;
|
|
rooms = 0;
|
|
|
|
connect(this, SIGNAL(disconnected()), SLOT(on_disconnected()));
|
|
connect(this, SIGNAL(socketError(QAbstractSocket::SocketError)), SLOT(on_socketError(QAbstractSocket::SocketError)));
|
|
connect(this, SIGNAL(connected()), SLOT(on_connected()));
|
|
connect(this, SIGNAL(messageReceived(IrcMessage*)), this, SLOT(onMessageReceived(IrcMessage*)));
|
|
|
|
m_awayTimer = new QTimer(this);
|
|
connect(m_awayTimer, SIGNAL(timeout()), this, SLOT(awayTimeout()));
|
|
m_awayTimer->start(5*1000);
|
|
}
|
|
|
|
MyIrcSession::~MyIrcSession() {
|
|
delete m_awayTimer;
|
|
}
|
|
|
|
void MyIrcSession::on_connected() {
|
|
m_connected = true;
|
|
if (m_suffix.empty()) {
|
|
m_np->handleConnected(m_user);
|
|
// if (!sentList) {
|
|
// sendCommand(IrcCommand::createList("", ""));
|
|
// sentList = true;
|
|
// }
|
|
}
|
|
|
|
// sendCommand(IrcCommand::createCapability("REQ", QStringList("away-notify")));
|
|
|
|
for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
|
|
sendCommand(IrcCommand::createJoin(FROM_UTF8(it->second->getChannel()), FROM_UTF8(it->second->getPassword())));
|
|
}
|
|
|
|
if (getIdentify().find(" ") != std::string::npos) {
|
|
std::string to = getIdentify().substr(0, getIdentify().find(" "));
|
|
std::string what = getIdentify().substr(getIdentify().find(" ") + 1);
|
|
LOG4CXX_INFO(logger, m_user << ": Sending IDENTIFY message to " << to);
|
|
sendCommand(IrcCommand::createMessage(FROM_UTF8(to), FROM_UTF8(what)));
|
|
}
|
|
}
|
|
|
|
void MyIrcSession::addPM(const std::string &name, const std::string &room) {
|
|
LOG4CXX_INFO(logger, m_user << ": Adding PM conversation " << name << " " << room);
|
|
m_pms[name] = room;
|
|
}
|
|
|
|
void MyIrcSession::on_socketError(QAbstractSocket::SocketError error) {
|
|
std::string reason;
|
|
switch(error) {
|
|
case QAbstractSocket::ConnectionRefusedError: reason = "The connection was refused by the peer (or timed out)."; break;
|
|
case QAbstractSocket::RemoteHostClosedError: reason = "The remote host closed the connection."; break;
|
|
case QAbstractSocket::HostNotFoundError: reason = "The host address was not found."; break;
|
|
case QAbstractSocket::SocketAccessError: reason = "The socket operation failed because the application lacked the required privileges."; break;
|
|
case QAbstractSocket::SocketResourceError: reason = "The local system ran out of resources."; break;
|
|
case QAbstractSocket::SocketTimeoutError: reason = "The socket operation timed out."; break;
|
|
case QAbstractSocket::DatagramTooLargeError: reason = "The datagram was larger than the operating system's limit."; break;
|
|
case QAbstractSocket::NetworkError: reason = "An error occurred with the network."; break;
|
|
case QAbstractSocket::SslHandshakeFailedError: reason = "The SSL/TLS handshake failed, so the connection was closed"; break;
|
|
case QAbstractSocket::UnknownSocketError: reason = "An unidentified error occurred."; break;
|
|
default: reason= "Unknown error."; break;
|
|
};
|
|
|
|
if (!m_suffix.empty()) {
|
|
for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
|
|
m_np->handleParticipantChanged(m_user, TO_UTF8(nickName()), it->second->getChannel() + m_suffix, pbnetwork::PARTICIPANT_FLAG_ROOM_NOT_FOUND, pbnetwork::STATUS_NONE, reason);
|
|
}
|
|
}
|
|
else {
|
|
m_np->handleDisconnected(m_user, 0, reason);
|
|
m_np->tryNextServer();
|
|
}
|
|
m_connected = false;
|
|
}
|
|
|
|
void MyIrcSession::on_disconnected() {
|
|
if (m_suffix.empty()) {
|
|
m_np->handleDisconnected(m_user, 0, "");
|
|
m_np->tryNextServer();
|
|
}
|
|
m_connected = false;
|
|
}
|
|
|
|
bool MyIrcSession::correctNickname(std::string &nickname) {
|
|
bool flags = 0;
|
|
if (!nickname.empty()) {
|
|
switch(nickname.at(0)) {
|
|
case '@': nickname = nickname.substr(1); flags = 1; break;
|
|
case '+': nickname = nickname.substr(1); break;
|
|
case '~': nickname = nickname.substr(1); break;
|
|
case '&': nickname = nickname.substr(1); break;
|
|
case '%': nickname = nickname.substr(1); break;
|
|
default: break;
|
|
}
|
|
}
|
|
return flags;
|
|
}
|
|
|
|
void MyIrcSession::on_joined(IrcMessage *message) {
|
|
IrcJoinMessage *m = (IrcJoinMessage *) message;
|
|
std::string nickname = TO_UTF8(m->nick());
|
|
bool op = correctNickname(nickname);
|
|
getIRCBuddy(TO_UTF8(m->channel().toLower()), nickname).setOp(op);
|
|
m_np->handleParticipantChanged(m_user, nickname, TO_UTF8(m->channel().toLower()) + m_suffix, op, pbnetwork::STATUS_ONLINE);
|
|
LOG4CXX_INFO(logger, m_user << ": " << nickname << " joined " << TO_UTF8(m->channel().toLower()) + m_suffix);
|
|
}
|
|
|
|
|
|
void MyIrcSession::on_parted(IrcMessage *message) {
|
|
IrcPartMessage *m = (IrcPartMessage *) message;
|
|
std::string nickname = TO_UTF8(m->nick());
|
|
bool op = correctNickname(nickname);
|
|
removeIRCBuddy(TO_UTF8(m->channel().toLower()), nickname);
|
|
LOG4CXX_INFO(logger, m_user << ": " << nickname << " parted " << TO_UTF8(m->channel().toLower()) + m_suffix);
|
|
m_np->handleParticipantChanged(m_user, nickname, TO_UTF8(m->channel().toLower()) + m_suffix, op, pbnetwork::STATUS_NONE, TO_UTF8(m->reason()));
|
|
}
|
|
|
|
void MyIrcSession::on_quit(IrcMessage *message) {
|
|
IrcQuitMessage *m = (IrcQuitMessage *) message;
|
|
std::string nickname = TO_UTF8(m->nick());
|
|
bool op = correctNickname(nickname);
|
|
|
|
for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
|
|
if (!hasIRCBuddy(it->second->getChannel(), nickname)) {
|
|
continue;
|
|
}
|
|
removeIRCBuddy(it->second->getChannel(), nickname);
|
|
LOG4CXX_INFO(logger, m_user << ": " << nickname << " quit " << it->second->getChannel() + m_suffix);
|
|
m_np->handleParticipantChanged(m_user, nickname, it->second->getChannel() + m_suffix, op, pbnetwork::STATUS_NONE, TO_UTF8(m->reason()));
|
|
}
|
|
}
|
|
|
|
void MyIrcSession::on_nickChanged(IrcMessage *message) {
|
|
IrcNickMessage *m = (IrcNickMessage *) message;
|
|
std::string nickname = TO_UTF8(m->nick());
|
|
correctNickname(nickname);
|
|
|
|
for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
|
|
if (!hasIRCBuddy(it->second->getChannel(), nickname)) {
|
|
continue;
|
|
}
|
|
IRCBuddy &buddy = getIRCBuddy(it->second->getChannel(), nickname);
|
|
LOG4CXX_INFO(logger, m_user << ": " << nickname << " changed nickname to " << TO_UTF8(m->nick()));
|
|
m_np->handleParticipantChanged(m_user, nickname, it->second->getChannel() + m_suffix,(int) buddy.isOp(), pbnetwork::STATUS_ONLINE, "", TO_UTF8(m->nick()));
|
|
}
|
|
}
|
|
|
|
void MyIrcSession::on_modeChanged(IrcMessage *message) {
|
|
IrcModeMessage *m = (IrcModeMessage *) message;
|
|
|
|
// mode changed: "#testik" "HanzZ" "+o" "hanzz_k"
|
|
std::string nickname = TO_UTF8(m->argument());
|
|
std::string mode = TO_UTF8(m->mode());
|
|
if (nickname.empty())
|
|
return;
|
|
|
|
correctNickname(nickname);
|
|
|
|
if (!hasIRCBuddy(TO_UTF8(m->target().toLower()), nickname)) {
|
|
return;
|
|
}
|
|
IRCBuddy &buddy = getIRCBuddy(TO_UTF8(m->target().toLower()), nickname);
|
|
if (mode == "+o") {
|
|
buddy.setOp(true);
|
|
}
|
|
else {
|
|
buddy.setOp(false);
|
|
}
|
|
|
|
m_np->handleParticipantChanged(m_user, nickname, TO_UTF8(m->target().toLower()) + m_suffix,(int) buddy.isOp(), pbnetwork::STATUS_ONLINE, "");
|
|
|
|
LOG4CXX_INFO(logger, m_user << ": " << nickname << " changed mode to " << mode << " in " << TO_UTF8(m->target().toLower()));
|
|
}
|
|
|
|
void MyIrcSession::on_topicChanged(IrcMessage *message) {
|
|
IrcTopicMessage *m = (IrcTopicMessage *) message;
|
|
|
|
std::string nickname = TO_UTF8(m->nick());
|
|
correctNickname(nickname);
|
|
|
|
LOG4CXX_INFO(logger, m_user << ": " << nickname << " topic changed to " << TO_UTF8(m->topic()));
|
|
m_np->handleSubject(m_user, TO_UTF8(m->channel().toLower()) + m_suffix, TO_UTF8(m->topic()), nickname);
|
|
}
|
|
|
|
void MyIrcSession::sendWhoisCommand(const std::string &channel, const std::string &to) {
|
|
m_whois[to] = channel;
|
|
sendCommand(IrcCommand::createWhois(FROM_UTF8(to)));
|
|
}
|
|
|
|
void MyIrcSession::on_whoisMessageReceived(IrcMessage *message) {
|
|
IrcWhoisMessage *m = (IrcWhoisMessage *) message;
|
|
std::string nickname = TO_UTF8(m->nick());
|
|
if (m_whois.find(nickname) == m_whois.end()) {
|
|
LOG4CXX_INFO(logger, "Whois response received with unexpected nickname " << nickname);
|
|
return;
|
|
}
|
|
|
|
std::string msg = "";
|
|
msg += nickname + " is connected to " + TO_UTF8(m->server()) + " (" + TO_UTF8(m->realName()) + ")\n";
|
|
msg += nickname + " is a user on channels: " + TO_UTF8(m->channels().join(", "));
|
|
|
|
sendMessageToFrontend(m_whois[nickname], "whois", msg);
|
|
m_whois.erase(nickname);
|
|
}
|
|
|
|
void MyIrcSession::sendMessageToFrontend(const std::string &channel, const std::string &nick, const std::string &msg) {
|
|
QString html = "";//msg;
|
|
// CommuniBackport::toPlainText(msg);
|
|
|
|
// TODO: Communi produces invalid html now...
|
|
// if (html == msg) {
|
|
// html = "";
|
|
// }
|
|
// else {
|
|
// html = IrcUtil::messageToHtml(html);
|
|
// }
|
|
|
|
std::string nickname = nick;
|
|
if (channel.find("#") == 0) {
|
|
correctNickname(nickname);
|
|
m_np->handleMessage(m_user, channel + m_suffix, msg, nickname, TO_UTF8(html));
|
|
}
|
|
else {
|
|
correctNickname(nickname);
|
|
if (m_pms.find(nickname) != m_pms.end()) {
|
|
std::string room = m_pms[nickname].substr(0, m_pms[nickname].find("/"));
|
|
room = room.substr(0, room.find("@"));
|
|
if (hasIRCBuddy(room, nickname)) {
|
|
m_np->handleMessage(m_user, room + m_suffix, msg, nickname, TO_UTF8(html), "", false, true);
|
|
return;
|
|
}
|
|
else {
|
|
nickname = nickname + m_suffix;
|
|
}
|
|
}
|
|
else {
|
|
for (AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
|
|
if (!hasIRCBuddy(it->second->getChannel(), nickname)) {
|
|
continue;
|
|
}
|
|
addPM(nickname, it->second->getChannel());
|
|
m_np->handleMessage(m_user, it->second->getChannel() + m_suffix, msg, nickname, TO_UTF8(html), "", false, true);
|
|
return;
|
|
}
|
|
|
|
nickname = nickname + m_suffix;
|
|
}
|
|
|
|
m_np->handleMessage(m_user, nickname, msg, "", TO_UTF8(html));
|
|
}
|
|
}
|
|
|
|
void MyIrcSession::on_messageReceived(IrcMessage *message) {
|
|
IrcPrivateMessage *m = (IrcPrivateMessage *) message;
|
|
if (m->isRequest()) {
|
|
QString request = m->content().split(" ", QString::SkipEmptyParts).value(0).toUpper();
|
|
if (request == "PING" || request == "TIME" || request == "VERSION") {
|
|
LOG4CXX_INFO(logger, m_user << ": " << TO_UTF8(request) << " received and has been answered");
|
|
return;
|
|
}
|
|
}
|
|
|
|
std::string msg = TO_UTF8(m->content());
|
|
if (m->isAction()) {
|
|
msg = "/me " + msg;
|
|
}
|
|
|
|
std::string target = TO_UTF8(m->target().toLower());
|
|
std::string nickname = TO_UTF8(m->nick());
|
|
sendMessageToFrontend(target, nickname, msg);
|
|
}
|
|
|
|
void MyIrcSession::on_numericMessageReceived(IrcMessage *message) {
|
|
QString channel;
|
|
QStringList members;
|
|
std::string nick;
|
|
|
|
IrcNumericMessage *m = (IrcNumericMessage *) message;
|
|
QStringList parameters = m->parameters();
|
|
switch (m->code()) {
|
|
case 301:
|
|
break;
|
|
case 315:
|
|
LOG4CXX_INFO(logger, "End of /who request " << TO_UTF8(parameters[1]));
|
|
break;
|
|
case 332:
|
|
m_topicData = TO_UTF8(parameters[2]);
|
|
break;
|
|
case 333:
|
|
nick = TO_UTF8(parameters[2]);
|
|
if (nick.find("!") != std::string::npos) {
|
|
nick = nick.substr(0, nick.find("!"));
|
|
}
|
|
if (nick.find("/") != std::string::npos) {
|
|
nick = nick.substr(0, nick.find("/"));
|
|
}
|
|
m_np->handleSubject(m_user, TO_UTF8(parameters[1].toLower()) + m_suffix, m_topicData, nick);
|
|
break;
|
|
case 352: {
|
|
channel = parameters[1].toLower();
|
|
nick = TO_UTF8(parameters[5]);
|
|
IRCBuddy &buddy = getIRCBuddy(TO_UTF8(channel), nick);
|
|
|
|
if (parameters[6].toUpper().startsWith("G")) {
|
|
if (!buddy.isAway()) {
|
|
buddy.setAway(true);
|
|
m_np->handleParticipantChanged(m_user, nick, TO_UTF8(channel) + m_suffix, buddy.isOp(), pbnetwork::STATUS_AWAY);
|
|
}
|
|
}
|
|
else if (buddy.isAway()) {
|
|
buddy.setAway(false);
|
|
m_np->handleParticipantChanged(m_user, nick, TO_UTF8(channel) + m_suffix, buddy.isOp(), pbnetwork::STATUS_ONLINE);
|
|
}
|
|
break;
|
|
}
|
|
case 353:
|
|
channel = parameters[2].toLower();
|
|
members = parameters[3].split(" ");
|
|
|
|
LOG4CXX_INFO(logger, m_user << ": Received members for " << TO_UTF8(channel) << m_suffix);
|
|
for (int i = 0; i < members.size(); i++) {
|
|
bool op = 0;
|
|
std::string nickname = TO_UTF8(members.at(i));
|
|
op = correctNickname(nickname);
|
|
IRCBuddy &buddy = getIRCBuddy(TO_UTF8(channel), nickname);
|
|
buddy.setOp(op);
|
|
m_np->handleParticipantChanged(m_user, nickname, TO_UTF8(channel) + m_suffix, buddy.isOp(), pbnetwork::STATUS_ONLINE);
|
|
}
|
|
|
|
break;
|
|
case 366:
|
|
// ask /who to get away states
|
|
channel = parameters[1].toLower();
|
|
LOG4CXX_INFO(logger, m_user << "Asking /who for channel " << TO_UTF8(channel));
|
|
sendCommand(IrcCommand::createWho(channel));
|
|
break;
|
|
case 401:
|
|
case 402:
|
|
nick = TO_UTF8(parameters[1]);
|
|
if (m_whois.find(nick) != m_whois.end()) {
|
|
sendMessageToFrontend(m_whois[nick], "whois", nick + ": No such client");
|
|
m_whois.erase(nick);
|
|
}
|
|
break;
|
|
case 432:
|
|
m_np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Erroneous Nickname");
|
|
break;
|
|
case 433:
|
|
for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
|
|
m_np->handleParticipantChanged(m_user, TO_UTF8(nickName()), it->second->getChannel() + m_suffix, pbnetwork::PARTICIPANT_FLAG_CONFLICT);
|
|
}
|
|
if (m_suffix.empty()) {
|
|
m_np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Nickname is already in use");
|
|
}
|
|
break;
|
|
case 436:
|
|
for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
|
|
m_np->handleParticipantChanged(m_user, TO_UTF8(nickName()), it->second->getChannel() + m_suffix, pbnetwork::PARTICIPANT_FLAG_CONFLICT);
|
|
}
|
|
m_np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Nickname collision KILL");
|
|
case 464:
|
|
for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
|
|
m_np->handleParticipantChanged(m_user, TO_UTF8(nickName()), it->second->getChannel() + m_suffix, pbnetwork::PARTICIPANT_FLAG_NOT_AUTHORIZED);
|
|
}
|
|
if (m_suffix.empty()) {
|
|
m_np->handleDisconnected(m_user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Password incorrect");
|
|
}
|
|
case 321:
|
|
m_rooms.clear();
|
|
m_names.clear();
|
|
break;
|
|
case 322:
|
|
m_rooms.push_back(TO_UTF8(parameters[1]));
|
|
m_names.push_back(TO_UTF8(parameters[1]));
|
|
break;
|
|
case 323:
|
|
m_np->handleRoomList("", m_rooms, m_names);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (m->code() >= 400 && m->code() < 500) {
|
|
LOG4CXX_INFO(logger, m_user << ": Error message received: " << message->toData().data());
|
|
}
|
|
}
|
|
|
|
void MyIrcSession::awayTimeout() {
|
|
for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {
|
|
if (it->second->shouldAskWho()) {
|
|
LOG4CXX_INFO(logger, "The time has come. Asking /who " << it->second->getChannel() << " again to get current away states.");
|
|
sendCommand(IrcCommand::createWho(FROM_UTF8(it->second->getChannel())));
|
|
}
|
|
}
|
|
}
|
|
|
|
void MyIrcSession::on_noticeMessageReceived(IrcMessage *message) {
|
|
IrcNoticeMessage *m = (IrcNoticeMessage *) message;
|
|
LOG4CXX_INFO(logger, m_user << ": NOTICE " << TO_UTF8(m->content()));
|
|
|
|
QString msg = m->content();
|
|
CommuniBackport::toPlainText(msg);
|
|
|
|
std::string target = TO_UTF8(m->target().toLower());
|
|
if (target.find("#") == 0) {
|
|
std::string nickname = TO_UTF8(m->nick());
|
|
correctNickname(nickname);
|
|
m_np->handleMessage(m_user, target + m_suffix, TO_UTF8(msg), nickname);
|
|
}
|
|
else {
|
|
std::string nickname = TO_UTF8(m->nick());
|
|
correctNickname(nickname);
|
|
if (nickname.find(".") != std::string::npos) {
|
|
return;
|
|
}
|
|
if (m_pms.find(nickname) != m_pms.end()) {
|
|
std::string room = m_pms[nickname].substr(0, m_pms[nickname].find("/"));
|
|
room = room.substr(0, room.find("@"));
|
|
if (hasIRCBuddy(room, nickname)) {
|
|
m_np->handleMessage(m_user, room + m_suffix, TO_UTF8(msg), nickname, "", "", false, true);
|
|
return;
|
|
}
|
|
else {
|
|
nickname = nickname + m_suffix;
|
|
}
|
|
}
|
|
else {
|
|
nickname = nickname + m_suffix;
|
|
}
|
|
|
|
LOG4CXX_INFO(logger, nickname);
|
|
m_np->handleMessage(m_user, nickname, TO_UTF8(msg), "");
|
|
}
|
|
}
|
|
|
|
void MyIrcSession::onMessageReceived(IrcMessage *message) {
|
|
switch (message->type()) {
|
|
case IrcMessage::Join:
|
|
on_joined(message);
|
|
break;
|
|
case IrcMessage::Part:
|
|
on_parted(message);
|
|
break;
|
|
case IrcMessage::Quit:
|
|
on_quit(message);
|
|
break;
|
|
case IrcMessage::Nick:
|
|
on_nickChanged(message);
|
|
break;
|
|
case IrcMessage::Mode:
|
|
on_modeChanged(message);
|
|
break;
|
|
case IrcMessage::Topic:
|
|
on_topicChanged(message);
|
|
break;
|
|
case IrcMessage::Private:
|
|
on_messageReceived(message);
|
|
break;
|
|
case IrcMessage::Numeric:
|
|
on_numericMessageReceived(message);
|
|
break;
|
|
case IrcMessage::Notice:
|
|
on_noticeMessageReceived(message);
|
|
break;
|
|
case IrcMessage::Whois:
|
|
on_whoisMessageReceived(message);
|
|
break;
|
|
default:break;
|
|
}
|
|
}
|