summaryrefslogtreecommitdiffstats
path: root/libcommuni/src/core
diff options
context:
space:
mode:
Diffstat (limited to 'libcommuni/src/core')
-rw-r--r--libcommuni/src/core/core.pri65
-rw-r--r--libcommuni/src/core/core.pro8
-rw-r--r--libcommuni/src/core/irc.cpp172
-rw-r--r--libcommuni/src/core/irccommand.cpp851
-rw-r--r--libcommuni/src/core/ircconnection.cpp1508
-rw-r--r--libcommuni/src/core/irccore.cpp90
-rw-r--r--libcommuni/src/core/ircfilter.cpp248
-rw-r--r--libcommuni/src/core/ircmessage.cpp1604
-rw-r--r--libcommuni/src/core/ircmessage_p.cpp284
-rw-r--r--libcommuni/src/core/ircmessagebuilder.cpp121
-rw-r--r--libcommuni/src/core/ircmessagedecoder.cpp73
-rw-r--r--libcommuni/src/core/ircmessagedecoder_icu.cpp68
-rw-r--r--libcommuni/src/core/ircmessagedecoder_uchardet.cpp56
-rw-r--r--libcommuni/src/core/ircnetwork.cpp687
-rw-r--r--libcommuni/src/core/ircprotocol.cpp480
15 files changed, 6315 insertions, 0 deletions
diff --git a/libcommuni/src/core/core.pri b/libcommuni/src/core/core.pri
new file mode 100644
index 0000000..3d4a0b1
--- /dev/null
+++ b/libcommuni/src/core/core.pri
@@ -0,0 +1,65 @@
+######################################################################
+# Communi
+######################################################################
+
+DEFINES += BUILD_IRC_CORE
+QT += network
+
+INCDIR = $$PWD/../../include/IrcCore
+
+DEPENDPATH += $$PWD $$INCDIR
+INCLUDEPATH += $$PWD $$INCDIR
+
+CONV_HEADERS = $$INCDIR/Irc
+CONV_HEADERS += $$INCDIR/IrcCommand
+CONV_HEADERS += $$INCDIR/IrcCommandFilter
+CONV_HEADERS += $$INCDIR/IrcConnection
+CONV_HEADERS += $$INCDIR/IrcCore
+CONV_HEADERS += $$INCDIR/IrcGlobal
+CONV_HEADERS += $$INCDIR/IrcMessage
+CONV_HEADERS += $$INCDIR/IrcMessageFilter
+CONV_HEADERS += $$INCDIR/IrcNetwork
+CONV_HEADERS += $$INCDIR/IrcProtocol
+
+PUB_HEADERS = $$INCDIR/irc.h
+PUB_HEADERS += $$INCDIR/irccommand.h
+PUB_HEADERS += $$INCDIR/ircconnection.h
+PUB_HEADERS += $$INCDIR/irccore.h
+PUB_HEADERS += $$INCDIR/ircfilter.h
+PUB_HEADERS += $$INCDIR/ircglobal.h
+PUB_HEADERS += $$INCDIR/ircmessage.h
+PUB_HEADERS += $$INCDIR/ircnetwork.h
+PUB_HEADERS += $$INCDIR/ircprotocol.h
+
+PRIV_HEADERS = $$INCDIR/ircconnection_p.h
+PRIV_HEADERS += $$INCDIR/ircmessage_p.h
+PRIV_HEADERS += $$INCDIR/ircmessagebuilder_p.h
+PRIV_HEADERS += $$INCDIR/ircmessagedecoder_p.h
+PRIV_HEADERS += $$INCDIR/ircnetwork_p.h
+
+HEADERS += $$PUB_HEADERS
+HEADERS += $$PRIV_HEADERS
+
+SOURCES += $$PWD/irc.cpp
+SOURCES += $$PWD/irccommand.cpp
+SOURCES += $$PWD/ircconnection.cpp
+SOURCES += $$PWD/irccore.cpp
+SOURCES += $$PWD/ircfilter.cpp
+SOURCES += $$PWD/ircmessage.cpp
+SOURCES += $$PWD/ircmessage_p.cpp
+SOURCES += $$PWD/ircmessagebuilder.cpp
+SOURCES += $$PWD/ircmessagedecoder.cpp
+SOURCES += $$PWD/ircnetwork.cpp
+SOURCES += $$PWD/ircprotocol.cpp
+
+include(../3rdparty/mozilla/mozilla.pri)
+
+CONFIG(icu, icu|no_icu) {
+ DEFINES += HAVE_ICU
+ SOURCES += $$PWD/ircmessagedecoder_icu.cpp
+ include(../3rdparty/icu/icu.pri)
+} else {
+ DEFINES += HAVE_UCHARDET
+ SOURCES += $$PWD/ircmessagedecoder_uchardet.cpp
+ include(../3rdparty/uchardet-0.0.1/uchardet.pri)
+}
diff --git a/libcommuni/src/core/core.pro b/libcommuni/src/core/core.pro
new file mode 100644
index 0000000..a9a0c5a
--- /dev/null
+++ b/libcommuni/src/core/core.pro
@@ -0,0 +1,8 @@
+######################################################################
+# Communi
+######################################################################
+
+IRC_MODULE = IrcCore
+include(core.pri)
+include(../module_build.pri)
+include(../module_install.pri)
diff --git a/libcommuni/src/core/irc.cpp b/libcommuni/src/core/irc.cpp
new file mode 100644
index 0000000..5a51645
--- /dev/null
+++ b/libcommuni/src/core/irc.cpp
@@ -0,0 +1,172 @@
+/*
+ Copyright (C) 2008-2014 The Communi Project
+
+ You may use this file under the terms of BSD license as follows:
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "irc.h"
+#include "irccore.h"
+#include "irccommand.h"
+#include "ircconnection.h"
+#include "ircmessage_p.h"
+#include <QMetaEnum>
+#include <QDebug>
+
+IRC_BEGIN_NAMESPACE
+
+/*!
+ \file irc.h
+ \brief \#include &lt;Irc&gt;
+ */
+
+/*!
+ \namespace Irc
+ \ingroup core
+ \brief Miscellaneous identifiers used throughout the library.
+ */
+
+/*!
+ Returns the version number of Communi at run-time as a string (for example, "1.2.3").
+ This may be a different version than the version the application was compiled against.
+
+ \sa IRC_VERSION, IRC_VERSION_STR
+ */
+QString Irc::version()
+{
+ return QLatin1String(IRC_VERSION_STR);
+}
+
+/*!
+ Returns the numeric \a code as a string or a null string if the code is unknown.
+
+ \sa Irc::Code, IrcNumericMessage::code()
+ */
+QString Irc::codeToString(int code)
+{
+ const int index = Irc::staticMetaObject.indexOfEnumerator("Code");
+ QMetaEnum enumerator = Irc::staticMetaObject.enumerator(index);
+ return QLatin1String(enumerator.valueToKey(code));
+}
+
+/*!
+ Returns the nick part of the specified \a prefix.
+
+ Nick part of a prefix as specified in RFC 1459:
+ <pre>
+ <b>&lt;nick&gt;</b> [ '!' &lt;ident&gt; ] [ '@' &lt;host&gt; ]
+ </pre>
+
+ \sa IrcMessage::prefix, IrcMessage::nick
+ */
+QString Irc::nickFromPrefix(const QString& prefix)
+{
+ QString nick;
+ IrcMessagePrivate::parsePrefix(prefix, &nick, 0, 0);
+ return nick;
+}
+
+/*!
+ Returns the ident part of the specified \a prefix.
+
+ Ident part of a prefix as specified in RFC 1459:
+ <pre>
+ &lt;nick&gt; [ '!' <b>&lt;ident&gt;</b> ] [ '@' &lt;host&gt; ]
+ </pre>
+
+ \sa IrcMessage::prefix, IrcMessage::ident
+ */
+QString Irc::identFromPrefix(const QString& prefix)
+{
+ QString ident;
+ IrcMessagePrivate::parsePrefix(prefix, 0, &ident, 0);
+ return ident;
+}
+
+/*!
+ Returns the host part of the specified \a prefix.
+
+ Host part of a prefix as specified in RFC 1459:
+ <pre>
+ &lt;nick&gt; [ '!' &lt;ident&gt; ] [ '@' <b>&lt;host&gt;</b> ]
+ </pre>
+
+ \sa IrcMessage::prefix, IrcMessage::host
+ */
+QString Irc::hostFromPrefix(const QString& prefix)
+{
+ QString host;
+ IrcMessagePrivate::parsePrefix(prefix, 0, 0, &host);
+ return host;
+}
+
+/*!
+ \deprecated Use IrcCore::registerMetaTypes() instead.
+ */
+void Irc::registerMetaTypes()
+{
+ IrcCore::registerMetaTypes();
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug debug, Irc::Code code)
+{
+ const int index = Irc::staticMetaObject.indexOfEnumerator("Code");
+ QMetaEnum enumerator = Irc::staticMetaObject.enumerator(index);
+ const char* key = enumerator.valueToKey(code);
+ debug << (key ? key : "Unknown");
+ return debug;
+}
+
+QDebug operator<<(QDebug debug, Irc::DataRole role)
+{
+ const int index = Irc::staticMetaObject.indexOfEnumerator("DataRole");
+ QMetaEnum enumerator = Irc::staticMetaObject.enumerator(index);
+ const char* key = enumerator.valueToKey(role);
+ debug << (key ? key : "Unknown");
+ return debug;
+}
+
+QDebug operator<<(QDebug debug, Irc::Color color)
+{
+ const int index = Irc::staticMetaObject.indexOfEnumerator("Color");
+ QMetaEnum enumerator = Irc::staticMetaObject.enumerator(index);
+ const char* key = enumerator.valueToKey(color);
+ debug << (key ? key : "Unknown");
+ return debug;
+}
+
+QDebug operator<<(QDebug debug, Irc::SortMethod method)
+{
+ const int index = Irc::staticMetaObject.indexOfEnumerator("SortMethod");
+ QMetaEnum enumerator = Irc::staticMetaObject.enumerator(index);
+ const char* key = enumerator.valueToKey(method);
+ debug << (key ? key : "Unknown");
+ return debug;
+}
+#endif // QT_NO_DEBUG_STREAM
+
+#include "moc_irc.cpp"
+
+IRC_END_NAMESPACE
diff --git a/libcommuni/src/core/irccommand.cpp b/libcommuni/src/core/irccommand.cpp
new file mode 100644
index 0000000..d7e9b30
--- /dev/null
+++ b/libcommuni/src/core/irccommand.cpp
@@ -0,0 +1,851 @@
+/*
+ Copyright (C) 2008-2014 The Communi Project
+
+ You may use this file under the terms of BSD license as follows:
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "irccommand.h"
+#include "ircmessage.h"
+#include <QTextCodec>
+#include <QMetaEnum>
+#include <QDebug>
+
+IRC_BEGIN_NAMESPACE
+
+/*!
+ \file irccommand.h
+ \brief \#include &lt;IrcCommand&gt;
+ */
+
+/*!
+ \class IrcCommand irccommand.h <IrcCommand>
+ \ingroup core
+ \brief Provides the most common commands.
+
+ The IrcCommand class supports the most common IRC commands out of the box,
+ and can be extended for custom commands as well. See IrcCommand::Type for
+ the list of built-in command types. IRC commands, as in IrcCommand instances,
+ are sent to the IRC server via IrcConnection::sendCommand().
+
+ \section creating-commands Creating commands
+
+ It is recommended to create IrcCommand instances via static
+ IrcCommand::createXxx() methods.
+
+ \warning IrcCommand instances must be allocated on the heap, since
+ IrcConnection::sendCommand() takes ownership of the command and deletes
+ it once it has been sent.
+
+ \section custom-commands Custom commands
+
+ A "custom command" here refers to command types not listed in IrcCommand::Type,
+ the list of built-in command types. There are two ways to send custom commands:
+ \li by passing the string representation of a command directly to
+ IrcConnection::sendRaw() or IrcConnection::sendData(), or
+ \li by subclassing IrcCommand and reimplementing
+ IrcCommand::toString(), which eventually creates the string representation
+ of the command.
+
+ Example implementation of a custom command:
+ \code
+ class IrcServerCommand : public IrcCommand
+ {
+ Q_OBJECT
+ public:
+ explicit IrcServerCommand(QObject* parent = 0) : IrcCommand(parent)
+ {
+ }
+
+ // provided for convenience, to ensure correct parameter order
+ static IrcCommand* create(const QString& serverName, int hopCount, const QString& info)
+ {
+ IrcCommand* command = new IrcServerCommand;
+ command->setParameters(QStringList() << serverName << QString::number(hopCount) << info);
+ return command;
+ }
+
+ // reimplemented from IrcCommand::toString()
+ virtual toString() const
+ {
+ // SERVER <servername> <hopcount> <info>
+ return QString("SERVER %1 %2 %3").arg(params.value(0), params.value(1), params.value(2));
+ }
+ };
+ \endcode
+
+ \sa IrcConnection::sendCommand(), IrcConnection::sendRaw(), IrcCommand::Type
+ */
+
+/*!
+ \enum IrcCommand::Type
+ This enum describes the built-in command types.
+ */
+
+/*!
+ \var IrcCommand::Admin
+ \brief An admin command (ADMIN) is used to query server admin info.
+ */
+
+/*!
+ \var IrcCommand::Away
+ \brief An away command (AWAY) is used to set the away status.
+ */
+
+/*!
+ \var IrcCommand::Capability
+ \brief A capability command (CAP) is used to manage connection capabilities.
+ */
+
+/*!
+ \var IrcCommand::CtcpAction
+ \brief A CTCP action command is used to send an action message to channels and users.
+ */
+
+/*!
+ \var IrcCommand::CtcpReply
+ \brief A CTCP reply command is used to send a reply to a request.
+ */
+
+/*!
+ \var IrcCommand::CtcpRequest
+ \brief A CTCP request command is used to send a request.
+ */
+
+/*!
+ \var IrcCommand::Custom
+ \brief A custom command
+ */
+
+/*!
+ \var IrcCommand::Info
+ \brief An info command (INFO) is used to query server info.
+ */
+
+/*!
+ \var IrcCommand::Invite
+ \brief An invite command (INVITE) is used to invite users to a channel.
+ */
+
+/*!
+ \var IrcCommand::Join
+ \brief A join command (JOIN) is used to start listening a specific channel.
+ */
+
+/*!
+ \var IrcCommand::Kick
+ \brief A kick command (KICK) is used to forcibly remove a user from a channel.
+ */
+
+/*!
+ \var IrcCommand::Knock
+ \brief A knock command (KNOCK) is used to request channel invitation.
+ */
+
+/*!
+ \var IrcCommand::List
+ \brief A list command (LIST) is used to list channels and their topics.
+ */
+
+/*!
+ \var IrcCommand::Message
+ \brief A message command (PRIVMSG) is used to send private messages to channels and users.
+ */
+
+/*!
+ \var IrcCommand::Mode
+ \brief A mode command (MODE) is used to change the mode of users and channels.
+ */
+
+/*!
+ \var IrcCommand::Motd
+ \brief A message of the day command (MOTD) is used to query the message of the day.
+ */
+
+/*!
+ \var IrcCommand::Names
+ \brief A names command (NAMES) is used to list all nicknames on a channel.
+ */
+
+/*!
+ \var IrcCommand::Nick
+ \brief A nick command (NICK) is used to give user a nickname or change the previous one.
+ */
+
+/*!
+ \var IrcCommand::Notice
+ \brief A notice command (NOTICE) is used to send notice messages to channels and users.
+ */
+
+/*!
+ \var IrcCommand::Part
+ \brief A part command (PART) causes the client to be removed from the channel.
+ */
+
+/*!
+ \var IrcCommand::Quit
+ \brief A quit command (QUIT) is used to end a client connection.
+ */
+
+/*!
+ \var IrcCommand::Quote
+ \brief A quote command is used to send a raw message to the server.
+ */
+
+/*!
+ \var IrcCommand::Stats
+ \brief A stats command (STATS) is used to query server statistics.
+ */
+
+/*!
+ \var IrcCommand::Time
+ \brief A time command (TIME) is used to query local server time.
+ */
+
+/*!
+ \var IrcCommand::Topic
+ \brief A topic command (TOPIC) is used to change or view the topic of a channel.
+ */
+
+/*!
+ \var IrcCommand::Trace
+ \brief A trace command (TRACE) is used to trace the connection path to a target.
+ */
+
+/*!
+ \var IrcCommand::Users
+ \brief A users command (USERS) is used to query server users.
+ */
+
+/*!
+ \var IrcCommand::Version
+ \brief A version command (VERSION) is used to query user or server version.
+ */
+
+/*!
+ \var IrcCommand::Who
+ \brief A who command (WHO) is used to generate a query which returns a list of matching users.
+ */
+
+/*!
+ \var IrcCommand::Whois
+ \brief A whois command (WHOIS) is used to query information about a particular user.
+ */
+
+/*!
+ \var IrcCommand::Whowas
+ \brief A whowas command (WHOWAS) is used to query information about a user that no longer exists.
+ */
+
+#ifndef IRC_DOXYGEN
+class IrcCommandPrivate
+{
+public:
+ IrcCommandPrivate() : encoding("UTF-8") { }
+
+ QString params(int index) const;
+
+ IrcCommand::Type type;
+ QStringList parameters;
+ QByteArray encoding;
+
+ static IrcCommand* createCommand(IrcCommand::Type type, const QStringList& parameters);
+};
+
+QString IrcCommandPrivate::params(int index) const
+{
+ return QStringList(parameters.mid(index)).join(QLatin1String(" "));
+}
+
+IrcCommand* IrcCommandPrivate::createCommand(IrcCommand::Type type, const QStringList& parameters)
+{
+ IrcCommand* command = new IrcCommand;
+ command->setType(type);
+ command->setParameters(parameters);
+ return command;
+}
+#endif // IRC_DOXYGEN
+
+/*!
+ Constructs a new IrcCommand with \a parent.
+ */
+IrcCommand::IrcCommand(QObject* parent) : QObject(parent), d_ptr(new IrcCommandPrivate)
+{
+ Q_D(IrcCommand);
+ d->type = Custom;
+}
+
+/*!
+ Destructs the IRC command.
+ */
+IrcCommand::~IrcCommand()
+{
+}
+
+/*!
+ This property holds the command type.
+
+ \par Access functions:
+ \li IrcCommand::Type <b>type</b>() const
+ \li void <b>setType</b>(IrcCommand::Type type)
+ */
+IrcCommand::Type IrcCommand::type() const
+{
+ Q_D(const IrcCommand);
+ return d->type;
+}
+
+void IrcCommand::setType(Type type)
+{
+ Q_D(IrcCommand);
+ d->type = type;
+}
+
+/*!
+ This property holds the command parameters.
+
+ \par Access functions:
+ \li QStringList <b>parameters</b>() const
+ \li void <b>setParameters</b>(const QStringList& parameters)
+ */
+QStringList IrcCommand::parameters() const
+{
+ Q_D(const IrcCommand);
+ return d->parameters;
+}
+
+void IrcCommand::setParameters(const QStringList& parameters)
+{
+ Q_D(IrcCommand);
+ d->parameters = parameters;
+}
+
+/*!
+ This property holds the encoding that is used when
+ sending the command via IrcConnection::sendCommand().
+
+ See QTextCodec::availableCodes() for the list of
+ supported encodings. The default value is \c "UTF-8".
+
+ \par Access functions:
+ \li QByteArray <b>encoding</b>() const
+ \li void <b>setEncoding</b>(const QByteArray& encoding)
+
+ \sa QTextCodec::availableCodecs()
+ */
+QByteArray IrcCommand::encoding() const
+{
+ Q_D(const IrcCommand);
+ return d->encoding;
+}
+
+void IrcCommand::setEncoding(const QByteArray& encoding)
+{
+ Q_D(IrcCommand);
+ extern bool irc_is_supported_encoding(const QByteArray& encoding); // ircmessagedecoder.cpp
+ if (!irc_is_supported_encoding(encoding)) {
+ qWarning() << "IrcCommand::setEncoding(): unsupported encoding" << encoding;
+ return;
+ }
+ d->encoding = encoding;
+}
+
+/*!
+ Returns the command as a string.
+
+ Reimplement for custom commands.
+ \sa IrcCommand::Custom
+ */
+QString IrcCommand::toString() const
+{
+ Q_D(const IrcCommand);
+ const QString p0 = d->parameters.value(0);
+ const QString p1 = d->parameters.value(1);
+ const QString p2 = d->parameters.value(2);
+
+ switch (d->type) {
+ case Admin: return QString("ADMIN %1").arg(p0); // server
+ case Away: return QString("AWAY :%1").arg(d->params(0)); // reason
+ case Capability: return QString("CAP %1 :%2").arg(p0, d->params(1)); // subcmd, caps
+ case CtcpAction: return QString("PRIVMSG %1 :\1ACTION %2\1").arg(p0, d->params(1)); // target, msg
+ case CtcpRequest: return QString("PRIVMSG %1 :\1%2\1").arg(p0, d->params(1)); // target, msg
+ case CtcpReply: return QString("NOTICE %1 :\1%2\1").arg(p0, d->params(1)); // target, msg
+ case Info: return QString("INFO %1").arg(p0); // server
+ case Invite: return QString("INVITE %1 %2").arg(p0, p1); // user, chan
+ case Join: return p1.isNull() ? QString("JOIN %1").arg(p0) : QString("JOIN %1 %2").arg(p0, p1); // chan, key
+ case Kick: return p2.isNull() ? QString("KICK %1 %2").arg(p0, p1) : QString("KICK %1 %2 :%3").arg(p0, p1, d->params(2)); // chan, user, reason
+ case Knock: return QString("KNOCK %1 %2").arg(p0, p1); // chan, msg
+ case List: return p1.isNull() ? QString("LIST %1").arg(p0) : QString("LIST %1 %2").arg(p0, p1); // chan, server
+ case Message: return QString("PRIVMSG %1 :%2").arg(p0, d->params(1)); // target, msg
+ case Mode: return QString("MODE ") + d->parameters.join(" "); // target, mode, arg
+ case Motd: return QString("MOTD %1").arg(p0); // server
+ case Names: return QString("NAMES %1").arg(p0); // chan
+ case Nick: return QString("NICK %1").arg(p0); // nick
+ case Notice: return QString("NOTICE %1 :%2").arg(p0, d->params(1)); // target, msg
+ case Part: return p1.isNull() ? QString("PART %1").arg(p0) : QString("PART %1 :%2").arg(p0, d->params(1)); // chan, reason
+ case Ping: return QString("PING %1").arg(p0); // argument
+ case Pong: return QString("PONG %1").arg(p0); // argument
+ case Quit: return QString("QUIT :%1").arg(d->params(0)); // reason
+ case Quote: return d->parameters.join(" ");
+ case Stats: return QString("STATS %1 %2").arg(p0, p1); // query, server
+ case Time: return QString("TIME %1").arg(p0); // server
+ case Topic: return p1.isNull() ? QString("TOPIC %1").arg(p0) : QString("TOPIC %1 :%2").arg(p0, d->params(1)); // chan, topic
+ case Trace: return QString("TRACE %1").arg(p0); // target
+ case Users: return QString("USERS %1").arg(p0); // server
+ case Version: return p0.isNull() ? QString("VERSION") : QString("PRIVMSG %1 :\1VERSION\1").arg(p0); // user
+ case Who: return QString("WHO %1").arg(p0); // user
+ case Whois: return QString("WHOIS %1 %1").arg(p0); // user
+ case Whowas: return QString("WHOWAS %1 %1").arg(p0); // user
+
+ case Custom: qWarning("Reimplement IrcCommand::toString() for IrcCommand::Custom");
+ default: return QString();
+ }
+}
+
+/*!
+ Creates a new message from this command for \a prefix and \a connection.
+
+ Notice that IRC servers do not echo sent message commands back to the client.
+ This function is particularly useful for converting sent message commands as
+ messages for presentation purposes.
+
+ \code
+ if (command->type() == IrcCommand::Message) {
+ IrcMessage* message = command->toMessage(connection->nickName(), connection);
+ receiveMessage(message);
+ message->deleteLater();
+ }
+ \endcode
+ */
+IrcMessage* IrcCommand::toMessage(const QString& prefix, IrcConnection* connection) const
+{
+ return IrcMessage::fromData(":" + prefix.toUtf8() + " " + toString().toUtf8(), connection);
+}
+
+/*!
+ Creates a new ADMIN command with type IrcCommand::Admin and optional parameter \a server.
+
+ This command shows admin info for the specified \a server,
+ or the current server if not specified.
+ */
+IrcCommand* IrcCommand::createAdmin(const QString& server)
+{
+ return IrcCommandPrivate::createCommand(Admin, QStringList() << server);
+}
+
+/*!
+ Creates a new AWAY command with type IrcCommand::Away and optional parameter \a reason.
+
+ Provides the server with \a reason to automatically send in reply to a private
+ message directed at the user. If \a reason is omitted, the away status is removed.
+ */
+IrcCommand* IrcCommand::createAway(const QString& reason)
+{
+ return IrcCommandPrivate::createCommand(Away, QStringList() << reason);
+}
+
+/*!
+ Creates a new capability command with type IrcCommand::Capability and parameters \a subCommand and a \a capability.
+
+ Available subcommands are: LS, LIST, REQ, ACK, NAK, CLEAR and END.
+ */
+IrcCommand* IrcCommand::createCapability(const QString& subCommand, const QString& capability)
+{
+ return createCapability(subCommand, QStringList() << capability);
+}
+
+/*!
+ Creates a new capability command with type IrcCommand::Capability and parameters \a subCommand and optional \a capabilities.
+
+ Available subcommands are: LS, LIST, REQ, ACK, NAK, CLEAR and END.
+ */
+IrcCommand* IrcCommand::createCapability(const QString& subCommand, const QStringList& capabilities)
+{
+ return IrcCommandPrivate::createCommand(Capability, QStringList() << subCommand << capabilities.join(QLatin1String(" ")));
+}
+
+/*!
+ Creates a new CTCP action command with type IrcCommand::CtcpAction and parameters \a target and \a action.
+ */
+IrcCommand* IrcCommand::createCtcpAction(const QString& target, const QString& action)
+{
+ return IrcCommandPrivate::createCommand(CtcpAction, QStringList() << target << action);
+}
+
+/*!
+ Creates a new CTCP reply command with type IrcCommand::CtcpReply and parameters \a target and \a reply.
+ */
+IrcCommand* IrcCommand::createCtcpReply(const QString& target, const QString& reply)
+{
+ return IrcCommandPrivate::createCommand(CtcpReply, QStringList() << target << reply);
+}
+
+/*!
+ Creates a new CTCP request command with type IrcCommand::CtcpRequest and parameters \a target and \a request.
+ */
+IrcCommand* IrcCommand::createCtcpRequest(const QString& target, const QString& request)
+{
+ return IrcCommandPrivate::createCommand(CtcpRequest, QStringList() << target << request);
+}
+
+/*!
+ Creates a new INFO command with type IrcCommand::Info and optional parameter \a server.
+
+ This command shows info for the specified \a server,
+ or the current server if not specified.
+ */
+IrcCommand* IrcCommand::createInfo(const QString& server)
+{
+ return IrcCommandPrivate::createCommand(Info, QStringList() << server);
+}
+
+/*!
+ Creates a new INVITE command with type IrcCommand::Invite and parameters \a user and \a channel.
+
+ This command invites \a user to the \a channel. The channel does not have to exist, but
+ if it does, only members of the channel are allowed to invite other clients. if the
+ channel mode +i (invite-only) is set, only channel operators may invite other clients.
+ */
+IrcCommand* IrcCommand::createInvite(const QString& user, const QString& channel)
+{
+ return IrcCommandPrivate::createCommand(Invite, QStringList() << user << channel);
+}
+
+/*!
+ Creates a new JOIN command with type IrcCommand::Join and parameters \a channel and optional \a key.
+
+ This command joins the \a channel using \a key if specified.
+ If the channel does not exist, it will be created.
+ */
+IrcCommand* IrcCommand::createJoin(const QString& channel, const QString& key)
+{
+ return IrcCommandPrivate::createCommand(Join, QStringList() << channel << key);
+}
+
+/*!
+ This overload is provided for convenience.
+ */
+IrcCommand* IrcCommand::createJoin(const QStringList& channels, const QStringList& keys)
+{
+ return IrcCommandPrivate::createCommand(Join, QStringList() << channels.join(",") << keys.join(","));
+}
+
+/*!
+ Creates a new KICK command with type IrcCommand::Kick and parameters \a channel, \a user and optional \a reason.
+
+ This command forcibly removes \a user from \a channel,
+ and may only be issued by channel operators.
+ */
+IrcCommand* IrcCommand::createKick(const QString& channel, const QString& user, const QString& reason)
+{
+ return IrcCommandPrivate::createCommand(Kick, QStringList() << channel << user << reason);
+}
+
+/*!
+ Creates a new KNOCK command with type IrcCommand::Knock and parameters \a channel and optional \a message.
+
+ This command sends an invitation request to a \a channel with an optional \a message.
+
+ \note The command is not formally defined by an RFC, but is supported by most major IRC daemons.
+ Support is indicated in a RPL_ISUPPORT reply (numeric 005) with the KNOCK keyword.
+ */
+IrcCommand* IrcCommand::createKnock(const QString& channel, const QString& message)
+{
+ return IrcCommandPrivate::createCommand(Knock, QStringList() << channel << message);
+}
+
+/*!
+ Creates a new LIST command with type IrcCommand::List and optional parameters \a channels and \a server.
+
+ This command lists all channels on the server. If \a channels are given, it will list the channel topics.
+ If \a server is given, the command will be forwarded to \a server for evaluation.
+ */
+IrcCommand* IrcCommand::createList(const QStringList& channels, const QString& server)
+{
+ return IrcCommandPrivate::createCommand(List, QStringList() << channels.join(",") << server);
+}
+
+/*!
+ Creates a new PRIVMSG command with type IrcCommand::Message and parameters \a target and \a message.
+
+ This command sends \a message to \a target, which is usually a user or channel.
+ */
+IrcCommand* IrcCommand::createMessage(const QString& target, const QString& message)
+{
+ return IrcCommandPrivate::createCommand(Message, QStringList() << target << message);
+}
+
+/*!
+ Creates a new MODE command with type IrcCommand::Mode and parameters \a target and optional \a mode and \a arg.
+
+ This command is used to set both user and channel modes.
+ */
+IrcCommand* IrcCommand::createMode(const QString& target, const QString& mode, const QString& arg)
+{
+ return IrcCommandPrivate::createCommand(Mode, QStringList() << target << mode << arg);
+}
+
+/*!
+ Creates a new MOTD command with type IrcCommand::Motd and optional parameter \a server.
+
+ This command shows the message of the day on the specified \a server,
+ or the current server if not specified.
+ */
+IrcCommand* IrcCommand::createMotd(const QString& server)
+{
+ return IrcCommandPrivate::createCommand(Motd, QStringList() << server);
+}
+
+/*!
+ Creates a new NAMES command with type IrcCommand::Names and parameter \a channel.
+
+ This command lists all users on the \a channel, optionally limiting to the given \a server.
+
+ If \a channel is omitted, all users are shown, grouped by channel name with
+ all users who are not on a channel being shown as part of channel "*".
+ If \a server is specified, the command is sent to \a server for evaluation.
+*/
+IrcCommand* IrcCommand::createNames(const QString& channel, const QString& server)
+{
+ return IrcCommandPrivate::createCommand(Names, QStringList() << channel << server);
+}
+
+/*!
+ This overload is provided for convenience.
+ */
+IrcCommand* IrcCommand::createNames(const QStringList& channels, const QString& server)
+{
+ return IrcCommandPrivate::createCommand(Names, QStringList() << channels.join(",") << server);
+}
+
+/*!
+ Creates a new NICK command with type IrcCommand::Nick and parameter \a nick.
+
+ This command allows a client to change their IRC nickname.
+ */
+IrcCommand* IrcCommand::createNick(const QString& nick)
+{
+ return IrcCommandPrivate::createCommand(Nick, QStringList() << nick);
+}
+
+/*!
+ Creates a new NOTICE command with type IrcCommand::Notice and parameters \a target and \a message.
+
+ This command sends \a notice to \a target, which is usually a user or channel.
+
+ \note The command works similarly to PRIVMSG, except automatic replies must never be sent in reply to NOTICE messages.
+ */
+IrcCommand* IrcCommand::createNotice(const QString& target, const QString& message)
+{
+ return IrcCommandPrivate::createCommand(Notice, QStringList() << target << message);
+}
+
+/*!
+ Creates a new PART command with type IrcCommand::Part and parameters \a channel and optional \a reason.
+
+ This command causes the client to leave the specified channel.
+ */
+IrcCommand* IrcCommand::createPart(const QString& channel, const QString& reason)
+{
+ return IrcCommandPrivate::createCommand(Part, QStringList() << channel << reason);
+}
+
+/*!
+ This overload is provided for convenience.
+ */
+IrcCommand* IrcCommand::createPart(const QStringList& channels, const QString& reason)
+{
+ return IrcCommandPrivate::createCommand(Part, QStringList() << channels.join(",") << reason);
+}
+
+/*!
+ Creates a new PING command with type IrcCommand::Ping and \a argument.
+ */
+IrcCommand* IrcCommand::createPing(const QString& argument)
+{
+ return IrcCommandPrivate::createCommand(Ping, QStringList() << argument);
+}
+
+/*!
+ Creates a new PONG command with type IrcCommand::Pong and \a argument.
+ */
+IrcCommand* IrcCommand::createPong(const QString& argument)
+{
+ return IrcCommandPrivate::createCommand(Pong, QStringList() << argument);
+}
+
+/*!
+ Creates a new QUIT command with type IrcCommand::Quit and optional parameter \a reason.
+ */
+IrcCommand* IrcCommand::createQuit(const QString& reason)
+{
+ return IrcCommandPrivate::createCommand(Quit, QStringList() << reason);
+}
+
+/*!
+ Creates a new QUOTE command with type IrcCommand::Quote and \a raw.
+ */
+IrcCommand* IrcCommand::createQuote(const QString& raw)
+{
+ return IrcCommandPrivate::createCommand(Quote, QStringList() << raw);
+}
+
+/*!
+ Creates a new QUOTE command with type IrcCommand::Quote and \a parameters.
+ */
+IrcCommand* IrcCommand::createQuote(const QStringList& parameters)
+{
+ return IrcCommandPrivate::createCommand(Quote, parameters);
+}
+
+/*!
+ Creates a new STATS command with type IrcCommand::Stats and parameters \a query and optional \a server.
+
+ This command queries statistics about the specified \a server,
+ or the current server if not specified.
+ */
+IrcCommand* IrcCommand::createStats(const QString& query, const QString& server)
+{
+ return IrcCommandPrivate::createCommand(Stats, QStringList() << query << server);
+}
+
+/*!
+ Creates a new TIME command with type IrcCommand::Time and optional parameter \a server.
+
+ This command queries local time of the specified \a server,
+ or the current server if not specified.
+ */
+IrcCommand* IrcCommand::createTime(const QString& server)
+{
+ return IrcCommandPrivate::createCommand(Time, QStringList() << server);
+}
+
+/*!
+ Creates a new TOPIC command with type IrcCommand::Topic and parameters \a channel and optional \a topic.
+
+ This command allows the client to query or set the channel topic on \a channel.
+ If \a topic is given, it sets the channel topic to \a topic.
+ If channel mode +t is set, only a channel operator may set the topic.
+ */
+IrcCommand* IrcCommand::createTopic(const QString& channel, const QString& topic)
+{
+ return IrcCommandPrivate::createCommand(Topic, QStringList() << channel << topic);
+}
+
+/*!
+ Creates a new TRACE command with type IrcCommand::Trace and optional parameter \a target.
+
+ This command traces the connection path across the IRC network
+ to the current server or to a specific \a target (server or client)
+ in a similar method to traceroute.
+ */
+IrcCommand* IrcCommand::createTrace(const QString& target)
+{
+ return IrcCommandPrivate::createCommand(Trace, QStringList() << target);
+}
+
+/*!
+ Creates a new USERS command with type IrcCommand::Users and optional parameter \a server.
+
+ This command queries the users of the specified \a server,
+ or the current server if not specified.
+ */
+IrcCommand* IrcCommand::createUsers(const QString& server)
+{
+ return IrcCommandPrivate::createCommand(Users, QStringList() << server);
+}
+
+/*!
+ Creates a new command with type IrcCommand::Version and optional parameter \a user.
+
+ This command queries the version of the specified \a user's client (CTCP REQUEST VERSION),
+ or the current server (VERSION) if not specified.
+ */
+IrcCommand* IrcCommand::createVersion(const QString& user)
+{
+ return IrcCommandPrivate::createCommand(Version, QStringList() << user);
+}
+
+/*!
+ Creates a new WHO command with type IrcCommand::Who and parameters \a mask and optional \a operators.
+
+ This command returns a list of users who match \a mask,
+ optionally matching only IRC \a operators.
+ */
+IrcCommand* IrcCommand::createWho(const QString& mask, bool operators)
+{
+ return IrcCommandPrivate::createCommand(Who, QStringList() << mask << (operators ? "o" : ""));
+}
+
+/*!
+ Creates a new WHOIS command with type IrcCommand::Whois and parameter \a user.
+
+ This command returns information about \a user.
+ */
+IrcCommand* IrcCommand::createWhois(const QString& user)
+{
+ return IrcCommandPrivate::createCommand(Whois, QStringList() << user);
+}
+
+/*!
+ Creates a new WHOWAS command with type IrcCommand::Whowas and parameters \a user and optional \a count.
+
+ This command returns information about a \a user that is no longer online
+ (due to client disconnection, or nickname changes). If given, the server
+ will return information from the last \a count times the nickname has been used.
+ */
+IrcCommand* IrcCommand::createWhowas(const QString& user, int count)
+{
+ return IrcCommandPrivate::createCommand(Whowas, QStringList() << user << QString::number(count));
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug debug, IrcCommand::Type type)
+{
+ const int index = IrcCommand::staticMetaObject.indexOfEnumerator("Type");
+ QMetaEnum enumerator = IrcCommand::staticMetaObject.enumerator(index);
+ const char* key = enumerator.valueToKey(type);
+ debug << (key ? key : "Unknown");
+ return debug;
+}
+
+QDebug operator<<(QDebug debug, const IrcCommand* command)
+{
+ if (!command)
+ return debug << "IrcCommand(0x0) ";
+ debug.nospace() << command->metaObject()->className() << '(' << (void*) command;
+ if (!command->objectName().isEmpty())
+ debug.nospace() << ", name=" << qPrintable(command->objectName());
+ debug.nospace() << ", type=" << command->type();
+ QString str = command->toString();
+ if (!str.isEmpty())
+ debug.nospace() << ", " << str.left(20);
+ debug.nospace() << ')';
+ return debug.space();
+}
+#endif // QT_NO_DEBUG_STREAM
+
+#include "moc_irccommand.cpp"
+
+IRC_END_NAMESPACE
diff --git a/libcommuni/src/core/ircconnection.cpp b/libcommuni/src/core/ircconnection.cpp
new file mode 100644
index 0000000..837aa16
--- /dev/null
+++ b/libcommuni/src/core/ircconnection.cpp
@@ -0,0 +1,1508 @@
+/*
+ Copyright (C) 2008-2014 The Communi Project
+
+ You may use this file under the terms of BSD license as follows:
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "ircconnection.h"
+#include "ircconnection_p.h"
+#include "ircnetwork_p.h"
+#include "ircprotocol.h"
+#include "ircnetwork.h"
+#include "irccommand.h"
+#include "ircmessage.h"
+#include "ircfilter.h"
+#include "irc.h"
+#include <QLocale>
+#include <QDateTime>
+#include <QTcpSocket>
+#include <QTextCodec>
+#include <QStringList>
+#include <QMetaObject>
+#include <QMetaMethod>
+#include <QMetaEnum>
+#ifndef QT_NO_OPENSSL
+#include <QSslSocket>
+#include <QSslError>
+#endif // QT_NO_OPENSSL
+#include <QDataStream>
+#include <QVariantMap>
+
+IRC_BEGIN_NAMESPACE
+
+/*!
+ \file ircconnection.h
+ \brief \#include &lt;IrcConnection&gt;
+ */
+
+/*!
+ \class IrcConnection ircconnection.h IrcConnection
+ \ingroup core
+ \brief Provides means to establish a connection to an IRC server.
+
+ \section connection-management Connection management
+
+ Before \ref open() "opening" a connection, it must be first initialized
+ with \ref host, \ref userName, \ref nickName and \ref realName.
+
+ The connection status may be queried at any time via status(). Also
+ \ref active "isActive()" and \ref connected "isConnected()" are provided
+ for convenience. In addition to the \ref status "statusChanged()" signal,
+ the most important statuses are informed via the following convenience
+ signals:
+ \li connecting() -
+ The connection is being established.
+ \li \ref connected "connected()" -
+ The IRC connection has been established, and the server is ready to receive commands.
+ \li disconnected() -
+ The connection has been lost.
+
+ \section receiving-messages Receiving messages
+
+ Whenever a message is received from the server, the messageReceived()
+ signal is emitted. Also message type specific signals are provided
+ for convenience. See messageReceived() and IrcMessage and its
+ subclasses for more details.
+
+ \section sending-commands Sending commands
+
+ Sending commands to a server is most conveniently done by creating
+ them via the various static \ref IrcCommand "IrcCommand::createXxx()"
+ methods and passing them to sendCommand(). Also sendData() is provided
+ for more low-level access. See IrcCommand for more details.
+
+ \section example Example
+
+ \code
+ IrcConnection* connection = new IrcConnection(this);
+ connect(connection, SIGNAL(messageReceived(IrcMessage*)), this, SLOT(onMessageReceived(IrcMessage*)));
+ connection->setHost("irc.server.com");
+ connection->setUserName("me");
+ connection->setNickName("myself");
+ connection->setRealName("And I");
+ connection->sendCommand(IrcCommand::createJoin("#mine"));
+ connection->open();
+ \endcode
+
+ \sa IrcNetwork, IrcMessage, IrcCommand
+ */
+
+/*!
+ \enum IrcConnection::Status
+ This enum describes the connection status.
+ */
+
+/*!
+ \var IrcConnection::Inactive
+ \brief The connection is inactive.
+ */
+
+/*!
+ \var IrcConnection::Waiting
+ \brief The connection is waiting for a reconnect.
+ */
+
+/*!
+ \var IrcConnection::Connecting
+ \brief The connection is being established.
+ */
+
+/*!
+ \var IrcConnection::Connected
+ \brief The connection has been established.
+ */
+
+/*!
+ \var IrcConnection::Closing
+ \brief The connection is being closed.
+ */
+
+/*!
+ \var IrcConnection::Closed
+ \brief The connection has been closed.
+ */
+
+/*!
+ \var IrcConnection::Error
+ \brief The connection has encountered an error.
+ */
+
+/*!
+ \fn void IrcConnection::connecting()
+
+ This signal is emitted when the connection is being established.
+
+ The underlying \ref socket has connected, but the IRC handshake is
+ not yet finished and the server is not yet ready to receive commands.
+ */
+
+/*!
+ \fn void IrcConnection::nickNameRequired(const QString& reserved, QString* alternate)
+
+ This signal is emitted when the requested nick name is \a reserved
+ and an \a alternate nick name should be provided.
+
+ An alternate nick name may be set via the provided argument, by changing
+ the \ref nickName property, or by sending a nick command directly.
+
+ \sa IrcCommand::createNick(), Irc::ERR_NICKNAMEINUSE, Irc::ERR_NICKCOLLISION
+ */
+
+/*!
+ \fn void IrcConnection::channelKeyRequired(const QString& channel, QString* key)
+
+ This signal is emitted when joining a \a channel requires a \a key.
+ The key may be set via the provided argument, or by sending a new
+ join command directly.
+
+ \sa IrcCommand::createJoin(), Irc::ERR_BADCHANNELKEY
+ */
+
+/*!
+ \fn void IrcConnection::disconnected()
+
+ This signal is emitted when the connection has been lost.
+ */
+
+/*!
+ \fn void IrcConnection::socketError(QAbstractSocket::SocketError error)
+
+ This signal is emitted when a \ref socket \a error occurs.
+
+ \sa QAbstractSocket::error()
+ */
+
+/*!
+ \fn void IrcConnection::socketStateChanged(QAbstractSocket::SocketState state)
+
+ This signal is emitted when the \a state of the underlying \ref socket changes.
+
+ \sa QAbstractSocket::stateChanged()
+ */
+
+/*!
+ \since 3.2
+ \fn void IrcConnection::secureError()
+
+ This signal is emitted when SSL socket error occurs.
+
+ Either QSslSocket::sslErrors() was emitted, or the remote host closed
+ the connection without QSslSocket::sslErrors() being emitted meaning
+ that the server is not SSL-enabled.
+ */
+
+/*!
+ \fn void IrcConnection::messageReceived(IrcMessage* message)
+
+ This signal is emitted when a \a message is received.
+
+ In addition, message type specific signals are provided for convenience:
+ \li void <b>capabilityMessageReceived</b>(\ref IrcCapabilityMessage* message)
+ \li void <b>errorMessageReceived</b>(\ref IrcErrorMessage* message)
+ \li void <b>inviteMessageReceived</b>(\ref IrcInviteMessage* message)
+ \li void <b>joinMessageReceived</b>(\ref IrcJoinMessage* message)
+ \li void <b>kickMessageReceived</b>(\ref IrcKickMessage* message)
+ \li void <b>modeMessageReceived</b>(\ref IrcModeMessage* message)
+ \li void <b>namesMessageReceived</b>(\ref IrcNamesMessage* message)
+ \li void <b>nickMessageReceived</b>(\ref IrcNickMessage* message)
+ \li void <b>noticeMessageReceived</b>(\ref IrcNoticeMessage* message)
+ \li void <b>numericMessageReceived</b>(\ref IrcNumericMessage* message)
+ \li void <b>motdMessageReceived</b>(\ref IrcMotdMessage* message)
+ \li void <b>partMessageReceived</b>(\ref IrcPartMessage* message)
+ \li void <b>pingMessageReceived</b>(\ref IrcPingMessage* message)
+ \li void <b>pongMessageReceived</b>(\ref IrcPongMessage* message)
+ \li void <b>privateMessageReceived</b>(\ref IrcPrivateMessage* message)
+ \li void <b>quitMessageReceived</b>(\ref IrcQuitMessage* message)
+ \li void <b>topicMessageReceived</b>(\ref IrcTopicMessage* message)
+ */
+
+#ifndef IRC_DOXYGEN
+template<typename T>
+static void irc_debug(IrcConnection* connection, const char* msg, const T& arg)
+{
+ static bool dbg = qgetenv("IRC_DEBUG").toInt();
+ if (dbg) {
+ const QString desc = QString::fromLatin1("IrcConnection(%1)").arg(connection->displayName());
+ qDebug() << qPrintable(desc) << msg << arg;
+ }
+}
+
+IrcConnectionPrivate::IrcConnectionPrivate() :
+ q_ptr(0),
+ encoding("ISO-8859-15"),
+ network(0),
+ protocol(0),
+ socket(0),
+ host(),
+ port(6667),
+ userName(),
+ nickName(),
+ realName(),
+ enabled(true),
+ status(IrcConnection::Inactive),
+ sslErrors(false),
+ closed(false)
+{
+}
+
+void IrcConnectionPrivate::init(IrcConnection* connection)
+{
+ q_ptr = connection;
+ network = IrcNetworkPrivate::create(connection);
+ connection->setSocket(new QTcpSocket(connection));
+ connection->setProtocol(new IrcProtocol(connection));
+ QObject::connect(&reconnecter, SIGNAL(timeout()), connection, SLOT(_irc_reconnect()));
+}
+
+void IrcConnectionPrivate::_irc_connected()
+{
+ Q_Q(IrcConnection);
+ closed = false;
+ sslErrors = false;
+ emit q->connecting();
+ if (q->isSecure())
+ QMetaObject::invokeMethod(socket, "startClientEncryption");
+ protocol->open();
+}
+
+void IrcConnectionPrivate::_irc_disconnected()
+{
+ Q_Q(IrcConnection);
+ protocol->close();
+ emit q->disconnected();
+ if (enabled && !sslErrors && (status != IrcConnection::Closed || !closed) && !reconnecter.isActive() && reconnecter.interval() > 0) {
+ reconnecter.start();
+ setStatus(IrcConnection::Waiting);
+ }
+}
+
+void IrcConnectionPrivate::_irc_error(QAbstractSocket::SocketError error)
+{
+ Q_Q(IrcConnection);
+ if (!closed && !sslErrors && error == QAbstractSocket::RemoteHostClosedError && q->isSecure()) {
+ irc_debug(q, "SSL error:", "no SSL available");
+ setStatus(IrcConnection::Error);
+ sslErrors = true;
+ emit q->secureError();
+ } else if (!closed || (error != QAbstractSocket::RemoteHostClosedError && error != QAbstractSocket::UnknownSocketError)) {
+ irc_debug(q, "socket error:", error);
+ emit q->socketError(error);
+ setStatus(IrcConnection::Error);
+ }
+}
+
+void IrcConnectionPrivate::_irc_sslErrors()
+{
+ Q_Q(IrcConnection);
+ QStringList errors;
+#ifndef QT_NO_OPENSSL
+ QSslSocket* ssl = qobject_cast<QSslSocket*>(socket);
+ if (ssl) {
+ foreach (const QSslError& error, ssl->sslErrors())
+ errors += error.errorString();
+ }
+#endif
+ irc_debug(q, "SSL handshake errors:", errors);
+ sslErrors = true;
+ emit q->secureError();
+}
+
+void IrcConnectionPrivate::_irc_state(QAbstractSocket::SocketState state)
+{
+ Q_Q(IrcConnection);
+ switch (state) {
+ case QAbstractSocket::UnconnectedState:
+ if (closed)
+ setStatus(IrcConnection::Closed);
+ break;
+ case QAbstractSocket::ClosingState:
+ if (status != IrcConnection::Error)
+ setStatus(IrcConnection::Closing);
+ break;
+ case QAbstractSocket::HostLookupState:
+ case QAbstractSocket::ConnectingState:
+ case QAbstractSocket::ConnectedState:
+ default:
+ setStatus(IrcConnection::Connecting);
+ break;
+ }
+ emit q->socketStateChanged(state);
+}
+
+void IrcConnectionPrivate::_irc_reconnect()
+{
+ Q_Q(IrcConnection);
+ if (!q->isActive()) {
+ reconnecter.stop();
+ q->open();
+ }
+}
+
+void IrcConnectionPrivate::_irc_readData()
+{
+ protocol->read();
+}
+
+void IrcConnectionPrivate::_irc_filterDestroyed(QObject* filter)
+{
+ messageFilters.removeAll(filter);
+ commandFilters.removeAll(filter);
+}
+
+void IrcConnectionPrivate::setNick(const QString& nick)
+{
+ Q_Q(IrcConnection);
+ if (nickName != nick) {
+ nickName = nick;
+ emit q->nickNameChanged(nick);
+ }
+}
+
+void IrcConnectionPrivate::setStatus(IrcConnection::Status value)
+{
+ Q_Q(IrcConnection);
+ if (status != value) {
+ const bool wasConnected = q->isConnected();
+ status = value;
+ emit q->statusChanged(value);
+
+ if (!wasConnected && q->isConnected()) {
+ emit q->connected();
+ foreach (IrcCommand* cmd, pendingCommands)
+ q->sendCommand(cmd);
+ pendingCommands.clear();
+ }
+ irc_debug(q, "status:", status);
+ }
+}
+
+void IrcConnectionPrivate::setInfo(const QHash<QString, QString>& info)
+{
+ Q_Q(IrcConnection);
+ const QString oldName = q->displayName();
+ IrcNetworkPrivate* priv = IrcNetworkPrivate::get(network);
+ priv->setInfo(info);
+ const QString newName = q->displayName();
+ if (oldName != newName)
+ emit q->displayNameChanged(newName);
+}
+
+void IrcConnectionPrivate::receiveMessage(IrcMessage* msg)
+{
+ Q_Q(IrcConnection);
+ bool filtered = false;
+ for (int i = messageFilters.count() - 1; !filtered && i >= 0; --i) {
+ IrcMessageFilter* filter = qobject_cast<IrcMessageFilter*>(messageFilters.at(i));
+ if (filter)
+ filtered |= filter->messageFilter(msg);
+ }
+
+ if (!filtered) {
+ emit q->messageReceived(msg);
+
+ switch (msg->type()) {
+ case IrcMessage::Nick:
+ emit q->nickMessageReceived(static_cast<IrcNickMessage*>(msg));
+ break;
+ case IrcMessage::Quit:
+ emit q->quitMessageReceived(static_cast<IrcQuitMessage*>(msg));
+ break;
+ case IrcMessage::Join:
+ emit q->joinMessageReceived(static_cast<IrcJoinMessage*>(msg));
+ break;
+ case IrcMessage::Part:
+ emit q->partMessageReceived(static_cast<IrcPartMessage*>(msg));
+ break;
+ case IrcMessage::Topic:
+ emit q->topicMessageReceived(static_cast<IrcTopicMessage*>(msg));
+ break;
+ case IrcMessage::WhoReply:
+ emit q->whoReplyMessageReceived(static_cast<IrcWhoReplyMessage*>(msg));
+ break;
+ case IrcMessage::Invite:
+ emit q->inviteMessageReceived(static_cast<IrcInviteMessage*>(msg));
+ break;
+ case IrcMessage::Kick:
+ emit q->kickMessageReceived(static_cast<IrcKickMessage*>(msg));
+ break;
+ case IrcMessage::Mode:
+ emit q->modeMessageReceived(static_cast<IrcModeMessage*>(msg));
+ break;
+ case IrcMessage::Private:
+ emit q->privateMessageReceived(static_cast<IrcPrivateMessage*>(msg));
+ break;
+ case IrcMessage::Notice:
+ emit q->noticeMessageReceived(static_cast<IrcNoticeMessage*>(msg));
+ break;
+ case IrcMessage::Ping:
+ emit q->pingMessageReceived(static_cast<IrcPingMessage*>(msg));
+ break;
+ case IrcMessage::Pong:
+ emit q->pongMessageReceived(static_cast<IrcPongMessage*>(msg));
+ break;
+ case IrcMessage::Error:
+ emit q->errorMessageReceived(static_cast<IrcErrorMessage*>(msg));
+ break;
+ case IrcMessage::Numeric:
+ emit q->numericMessageReceived(static_cast<IrcNumericMessage*>(msg));
+ break;
+ case IrcMessage::Capability:
+ emit q->capabilityMessageReceived(static_cast<IrcCapabilityMessage*>(msg));
+ break;
+ case IrcMessage::Motd:
+ emit q->motdMessageReceived(static_cast<IrcMotdMessage*>(msg));
+ break;
+ case IrcMessage::Names:
+ emit q->namesMessageReceived(static_cast<IrcNamesMessage*>(msg));
+ break;
+ case IrcMessage::Unknown:
+ default:
+ break;
+ }
+ }
+ msg->deleteLater();
+}
+
+IrcCommand* IrcConnectionPrivate::createCtcpReply(IrcPrivateMessage* request)
+{
+ Q_Q(IrcConnection);
+ IrcCommand* reply = 0;
+ const QMetaObject* metaObject = q->metaObject();
+ int idx = metaObject->indexOfMethod("createCtcpReply(QVariant)");
+ if (idx != -1) {
+ // QML: QVariant createCtcpReply(QVariant)
+ QVariant ret;
+ QMetaMethod method = metaObject->method(idx);
+ method.invoke(q, Q_RETURN_ARG(QVariant, ret), Q_ARG(QVariant, QVariant::fromValue(request)));
+ reply = ret.value<IrcCommand*>();
+ } else {
+ // C++: IrcCommand* createCtcpReply(IrcPrivateMessage*)
+ idx = metaObject->indexOfMethod("createCtcpReply(IrcPrivateMessage*)");
+ QMetaMethod method = metaObject->method(idx);
+ method.invoke(q, Q_RETURN_ARG(IrcCommand*, reply), Q_ARG(IrcPrivateMessage*, request));
+ }
+ return reply;
+}
+#endif // IRC_DOXYGEN
+
+/*!
+ Constructs a new IRC connection with \a parent.
+ */
+IrcConnection::IrcConnection(QObject* parent) : QObject(parent), d_ptr(new IrcConnectionPrivate)
+{
+ Q_D(IrcConnection);
+ d->init(this);
+}
+
+/*!
+ Constructs a new IRC connection with \a host and \a parent.
+ */
+IrcConnection::IrcConnection(const QString& host, QObject* parent) : QObject(parent), d_ptr(new IrcConnectionPrivate)
+{
+ Q_D(IrcConnection);
+ d->init(this);
+ setHost(host);
+}
+
+/*!
+ Destructs the IRC connection.
+ */
+IrcConnection::~IrcConnection()
+{
+ close();
+ emit destroyed(this);
+}
+
+/*!
+ This property holds the FALLBACK encoding for received messages.
+
+ The fallback encoding is used when the message is detected not
+ to be valid \c UTF-8 and the consequent auto-detection of message
+ encoding fails. See QTextCodec::availableCodecs() for the list of
+ supported encodings.
+
+ The default value is \c ISO-8859-15.
+
+ \par Access functions:
+ \li QByteArray <b>encoding</b>() const
+ \li void <b>setEncoding</b>(const QByteArray& encoding)
+
+ \sa QTextCodec::availableCodecs(), QTextCodec::codecForLocale()
+ */
+QByteArray IrcConnection::encoding() const
+{
+ Q_D(const IrcConnection);
+ return d->encoding;
+}
+
+void IrcConnection::setEncoding(const QByteArray& encoding)
+{
+ Q_D(IrcConnection);
+ extern bool irc_is_supported_encoding(const QByteArray& encoding); // ircmessagedecoder.cpp
+ if (!irc_is_supported_encoding(encoding)) {
+ qWarning() << "IrcConnection::setEncoding(): unsupported encoding" << encoding;
+ return;
+ }
+ d->encoding = encoding;
+}
+
+/*!
+ This property holds the server host.
+
+ \par Access functions:
+ \li QString <b>host</b>() const
+ \li void <b>setHost</b>(const QString& host)
+
+ \par Notifier signal:
+ \li void <b>hostChanged</b>(const QString& host)
+ */
+QString IrcConnection::host() const
+{
+ Q_D(const IrcConnection);
+ return d->host;
+}
+
+void IrcConnection::setHost(const QString& host)
+{
+ Q_D(IrcConnection);
+ if (d->host != host) {
+ if (isActive())
+ qWarning("IrcConnection::setHost() has no effect until re-connect");
+ const QString oldName = displayName();
+ d->host = host;
+ emit hostChanged(host);
+ const QString newName = displayName();
+ if (oldName != newName)
+ emit displayNameChanged(newName);
+ }
+}
+
+/*!
+ This property holds the server port.
+
+ The default value is \c 6667.
+
+ \par Access functions:
+ \li int <b>port</b>() const
+ \li void <b>setPort</b>(int port)
+
+ \par Notifier signal:
+ \li void <b>portChanged</b>(int port)
+ */
+int IrcConnection::port() const
+{
+ Q_D(const IrcConnection);
+ return d->port;
+}
+
+void IrcConnection::setPort(int port)
+{
+ Q_D(IrcConnection);
+ if (d->port != port) {
+ if (isActive())
+ qWarning("IrcConnection::setPort() has no effect until re-connect");
+ d->port = port;
+ emit portChanged(port);
+ }
+}
+
+/*!
+ This property holds the user name.
+
+ \note Changing the user name has no effect until the connection is re-established.
+
+ \par Access functions:
+ \li QString <b>userName</b>() const
+ \li void <b>setUserName</b>(const QString& name)
+
+ \par Notifier signal:
+ \li void <b>userNameChanged</b>(const QString& name)
+ */
+QString IrcConnection::userName() const
+{
+ Q_D(const IrcConnection);
+ return d->userName;
+}
+
+void IrcConnection::setUserName(const QString& name)
+{
+ Q_D(IrcConnection);
+ QString user = name.split(" ", QString::SkipEmptyParts).value(0).trimmed();
+ if (d->userName != user) {
+ if (isActive())
+ qWarning("IrcConnection::setUserName() has no effect until re-connect");
+ d->userName = user;
+ emit userNameChanged(user);
+ }
+}
+
+/*!
+ This property holds the nick name.
+
+ \par Access functions:
+ \li QString <b>nickName</b>() const
+ \li void <b>setNickName</b>(const QString& name)
+
+ \par Notifier signal:
+ \li void <b>nickNameChanged</b>(const QString& name)
+ */
+QString IrcConnection::nickName() const
+{
+ Q_D(const IrcConnection);
+ return d->nickName;
+}
+
+void IrcConnection::setNickName(const QString& name)
+{
+ Q_D(IrcConnection);
+ QString nick = name.split(" ", QString::SkipEmptyParts).value(0).trimmed();
+ if (d->nickName != nick) {
+ if (isActive())
+ sendCommand(IrcCommand::createNick(nick));
+ else
+ d->setNick(nick);
+ }
+}
+
+/*!
+ This property holds the real name.
+
+ \note Changing the real name has no effect until the connection is re-established.
+
+ \par Access functions:
+ \li QString <b>realName</b>() const
+ \li void <b>setRealName</b>(const QString& name)
+
+ \par Notifier signal:
+ \li void <b>realNameChanged</b>(const QString& name)
+ */
+QString IrcConnection::realName() const
+{
+ Q_D(const IrcConnection);
+ return d->realName;
+}
+
+void IrcConnection::setRealName(const QString& name)
+{
+ Q_D(IrcConnection);
+ if (d->realName != name) {
+ if (isActive())
+ qWarning("IrcConnection::setRealName() has no effect until re-connect");
+ d->realName = name;
+ emit realNameChanged(name);
+ }
+}
+
+/*!
+ This property holds the password.
+
+ \par Access functions:
+ \li QString <b>password</b>() const
+ \li void <b>setPassword</b>(const QString& password)
+
+ \par Notifier signal:
+ \li void <b>passwordChanged</b>(const QString& password)
+ */
+QString IrcConnection::password() const
+{
+ Q_D(const IrcConnection);
+ return d->password;
+}
+
+void IrcConnection::setPassword(const QString& password)
+{
+ Q_D(IrcConnection);
+ if (d->password != password) {
+ if (isActive())
+ qWarning("IrcConnection::setPassword() has no effect until re-connect");
+ d->password = password;
+ emit passwordChanged(password);
+ }
+}
+
+/*!
+ This property holds the display name.
+
+ Unless explicitly set, display name resolves to IrcNetwork::name
+ or IrcConnection::host while the former is not known.
+
+ \par Access functions:
+ \li QString <b>displayName</b>() const
+ \li void <b>setDisplayName</b>(const QString& name)
+
+ \par Notifier signal:
+ \li void <b>displayNameChanged</b>(const QString& name)
+ */
+QString IrcConnection::displayName() const
+{
+ Q_D(const IrcConnection);
+ QString name = d->displayName;
+ if (name.isEmpty())
+ name = d->network->name();
+ if (name.isEmpty())
+ name = d->host;
+ return name;
+}
+
+void IrcConnection::setDisplayName(const QString& name)
+{
+ Q_D(IrcConnection);
+ if (d->displayName != name) {
+ d->displayName = name;
+ emit displayNameChanged(name);
+ }
+}
+
+/*!
+ \since 3.1
+
+ This property holds arbitrary user data.
+
+ \par Access functions:
+ \li QVariantMap <b>userData</b>() const
+ \li void <b>setUserData</b>(const QVariantMap& data)
+
+ \par Notifier signal:
+ \li void <b>userDataChanged</b>(const QVariantMap& data)
+ */
+QVariantMap IrcConnection::userData() const
+{
+ Q_D(const IrcConnection);
+ return d->userData;
+}
+
+void IrcConnection::setUserData(const QVariantMap& data)
+{
+ Q_D(IrcConnection);
+ if (d->userData != data) {
+ d->userData = data;
+ emit userDataChanged(data);
+ }
+}
+
+/*!
+ \property Status IrcConnection::status
+ This property holds the connection status.
+
+ \par Access function:
+ \li Status <b>status</b>() const
+
+ \par Notifier signal:
+ \li void <b>statusChanged</b>(Status status)
+ */
+IrcConnection::Status IrcConnection::status() const
+{
+ Q_D(const IrcConnection);
+ return d->status;
+}
+
+/*!
+ \property bool IrcConnection::active
+ This property holds whether the connection is active.
+
+ The connection is considered active when its either connecting, connected or closing.
+
+ \par Access function:
+ \li bool <b>isActive</b>() const
+ */
+bool IrcConnection::isActive() const
+{
+ Q_D(const IrcConnection);
+ return d->status == Connecting || d->status == Connected || d->status == Closing;
+}
+
+/*!
+ \property bool IrcConnection::connected
+ This property holds whether the connection has been established.
+
+ The connection has been established when the welcome message
+ has been received and the server is ready to receive commands.
+
+ \sa Irc::RPL_WELCOME
+
+ \par Access function:
+ \li bool <b>isConnected</b>() const
+
+ \par Notifier signal:
+ \li void <b>connected</b>()
+ */
+bool IrcConnection::isConnected() const
+{
+ Q_D(const IrcConnection);
+ return d->status == Connected;
+}
+
+/*!
+ \property bool IrcConnection::enabled
+ This property holds whether the connection is enabled.
+
+ The default value is \c true.
+
+ When set to \c false, a disabled connection does nothing when open() is called.
+
+ \par Access functions:
+ \li bool <b>isEnabled</b>() const
+ \li void <b>setEnabled</b>(bool enabled) [slot]
+ \li void <b>setDisabled</b>(bool disabled) [slot]
+
+ \par Notifier signal:
+ \li void <b>enabledChanged</b>(bool enabled)
+ */
+bool IrcConnection::isEnabled() const
+{
+ Q_D(const IrcConnection);
+ return d->enabled;
+}
+
+void IrcConnection::setEnabled(bool enabled)
+{
+ Q_D(IrcConnection);
+ if (d->enabled != enabled) {
+ d->enabled = enabled;
+ emit enabledChanged(enabled);
+ }
+}
+
+void IrcConnection::setDisabled(bool disabled)
+{
+ setEnabled(!disabled);
+}
+
+/*!
+ \property int IrcConnection::reconnectDelay
+ This property holds the reconnect delay in seconds.
+
+ A positive (greater than zero) value enables automatic reconnect.
+ When the connection is lost due to a socket error, IrcConnection
+ will automatically attempt to reconnect after the specified delay.
+
+ The default value is \c 0 (automatic reconnect disabled).
+
+ \par Access functions:
+ \li int <b>reconnectDelay</b>() const
+ \li void <b>setReconnectDelay</b>(int seconds)
+
+ \par Notifier signal:
+ \li void <b>reconnectDelayChanged</b>(int seconds)
+ */
+int IrcConnection::reconnectDelay() const
+{
+ Q_D(const IrcConnection);
+ return d->reconnecter.interval() / 1000;
+}
+
+void IrcConnection::setReconnectDelay(int seconds)
+{
+ Q_D(IrcConnection);
+ const int interval = qMax(0, seconds) * 1000;
+ if (d->reconnecter.interval() != interval) {
+ d->reconnecter.setInterval(interval);
+ emit reconnectDelayChanged(interval);
+ }
+}
+
+/*!
+ This property holds the socket. The default value is an instance of QTcpSocket.
+
+ The previously set socket is deleted if its parent is \c this.
+
+ \note IrcConnection supports QSslSocket in the way that it automatically
+ calls QSslSocket::startClientEncryption() while connecting.
+
+ \par Access functions:
+ \li \ref QAbstractSocket* <b>socket</b>() const
+ \li void <b>setSocket</b>(\ref QAbstractSocket* socket)
+
+ \sa IrcConnection::secure
+ */
+QAbstractSocket* IrcConnection::socket() const
+{
+ Q_D(const IrcConnection);
+ return d->socket;
+}
+
+void IrcConnection::setSocket(QAbstractSocket* socket)
+{
+ Q_D(IrcConnection);
+ if (d->socket != socket) {
+ if (d->socket) {
+ d->socket->disconnect(this);
+ if (d->socket->parent() == this)
+ d->socket->deleteLater();
+ }
+
+ d->socket = socket;
+ if (socket) {
+ connect(socket, SIGNAL(connected()), this, SLOT(_irc_connected()));
+ connect(socket, SIGNAL(disconnected()), this, SLOT(_irc_disconnected()));
+ connect(socket, SIGNAL(readyRead()), this, SLOT(_irc_readData()));
+ connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(_irc_error(QAbstractSocket::SocketError)));
+ connect(socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(_irc_state(QAbstractSocket::SocketState)));
+ if (isSecure())
+ connect(socket, SIGNAL(sslErrors(QList<QSslError>)), this, SLOT(_irc_sslErrors()));
+ }
+ }
+}
+
+/*!
+ \property bool IrcConnection::secure
+ This property holds whether the socket is an SSL socket.
+
+ This property is provided for convenience. Calling
+ \code
+ connection->setSecure(true);
+ \endcode
+
+ is equivalent to:
+
+ \code
+ QSslSocket* socket = new QSslSocket(socket);
+ socket->setPeerVerifyMode(QSslSocket::QueryPeer);
+ connection->setSocket(socket);
+ \endcode
+
+ \note IrcConnection does not handle SSL errors, see
+ QSslSocket::sslErrors() for more details on the subject.
+
+ \par Access functions:
+ \li bool <b>isSecure</b>() const
+ \li void <b>setSecure</b>(bool secure)
+
+ \par Notifier signal:
+ \li void <b>secureChanged</b>(bool secure)
+
+ \sa secureSupported, IrcConnection::socket
+ */
+bool IrcConnection::isSecure() const
+{
+#ifdef QT_NO_OPENSSL
+ return false;
+#else
+ return qobject_cast<QSslSocket*>(socket());
+#endif // QT_NO_OPENSSL
+}
+
+void IrcConnection::setSecure(bool secure)
+{
+#ifdef QT_NO_OPENSSL
+ if (secure) {
+ qWarning("IrcConnection::setSecure(): the Qt build does not support SSL");
+ return;
+ }
+#else
+ if (secure && !QSslSocket::supportsSsl()) {
+ qWarning("IrcConnection::setSecure(): the platform does not support SSL - try installing OpenSSL");
+ return;
+ }
+
+ QSslSocket* sslSocket = qobject_cast<QSslSocket*>(socket());
+ if (secure && !sslSocket) {
+ sslSocket = new QSslSocket(this);
+ sslSocket->setPeerVerifyMode(QSslSocket::QueryPeer);
+ setSocket(sslSocket);
+ emit secureChanged(true);
+ } else if (!secure && sslSocket) {
+ setSocket(new QTcpSocket(this));
+ emit secureChanged(false);
+ }
+#endif // !QT_NO_OPENSSL
+}
+
+/*!
+ \since 3.2
+ \property bool IrcConnection::secureSupported
+ This property holds whether SSL is supported.
+
+ The value may be \c false for the following reasons:
+ \li Qt was built without SSL support (\c QT_NO_SSL is defined), or
+ \li The platform does not support SSL (QSslSocket::supportsSsl() returns \c false).
+
+ \par Access function:
+ \li static bool <b>isSecureSupported</b>()
+
+ \sa secure, QSslSocket::supportsSsl()
+ */
+
+bool IrcConnection::isSecureSupported()
+{
+#ifdef QT_NO_OPENSSL
+ return false;
+#else
+ return QSslSocket::supportsSsl();
+#endif
+}
+
+/*!
+ This property holds the used SASL (Simple Authentication and Security Layer) mechanism.
+
+ \par Access functions:
+ \li QString <b>saslMechanism</b>() const
+ \li void <b>setSaslMechanism</b>(const QString& mechanism)
+
+ \par Notifier signal:
+ \li void <b>saslMechanismChanged</b>(const QString& mechanism)
+
+ \sa supportedSaslMechanisms
+ */
+QString IrcConnection::saslMechanism() const
+{
+ Q_D(const IrcConnection);
+ return d->saslMechanism;
+}
+
+void IrcConnection::setSaslMechanism(const QString& mechanism)
+{
+ Q_D(IrcConnection);
+ if (!mechanism.isEmpty() && !supportedSaslMechanisms().contains(mechanism.toUpper())) {
+ qWarning("IrcConnection::setSaslMechanism(): unsupported mechanism: '%s'", qPrintable(mechanism));
+ return;
+ }
+ if (d->saslMechanism != mechanism) {
+ if (isActive())
+ qWarning("IrcConnection::setSaslMechanism() has no effect until re-connect");
+ d->saslMechanism = mechanism.toUpper();
+ emit saslMechanismChanged(mechanism);
+ }
+}
+
+/*!
+ This property holds the list of supported SASL (Simple Authentication and Security Layer) mechanisms.
+
+ \par Access function:
+ \li static QStringList <b>supportedSaslMechanisms</b>()
+
+ \sa saslMechanism
+ */
+QStringList IrcConnection::supportedSaslMechanisms()
+{
+ return QStringList() << QLatin1String("PLAIN");
+}
+
+/*!
+ This property holds the network information.
+
+ \par Access function:
+ \li IrcNetwork* <b>network</b>() const
+ */
+IrcNetwork* IrcConnection::network() const
+{
+ Q_D(const IrcConnection);
+ return d->network;
+}
+
+/*!
+ Opens a connection to the server.
+
+ The function does nothing when the connection is already \ref active
+ or explicitly \ref enabled "disabled".
+
+ \note The function merely outputs a warnings and returns immediately if
+ either \ref host, \ref userName, \ref nickName or \ref realName is empty.
+ */
+void IrcConnection::open()
+{
+ Q_D(IrcConnection);
+ if (d->host.isEmpty()) {
+ qWarning("IrcConnection::open(): host is empty!");
+ return;
+ }
+ if (d->userName.isEmpty()) {
+ qWarning("IrcConnection::open(): userName is empty!");
+ return;
+ }
+ if (d->nickName.isEmpty()) {
+ qWarning("IrcConnection::open(): nickName is empty!");
+ return;
+ }
+ if (d->realName.isEmpty()) {
+ qWarning("IrcConnection::open(): realName is empty!");
+ return;
+ }
+ if (d->enabled && d->socket && !isActive())
+ d->socket->connectToHost(d->host, d->port);
+}
+
+/*!
+ Immediately closes the connection to the server.
+
+ Calling close() makes the connection close immediately and thus might lead to
+ "remote host closed the connection". In order to quit gracefully, call quit()
+ first. This function attempts to flush the underlying socket, but this does
+ not guarantee that the server ever receives the QUIT command if the connection
+ is closed immediately after sending the command. In order to ensure a graceful
+ quit, let the server handle closing the connection.
+
+ C++ example:
+ \code
+ connection->quit(reason);
+ QTimer::singleShot(timeout, connection, SLOT(deleteLater()));
+ \endcode
+
+ QML example:
+ \code
+ connection.quit(reason);
+ connection.destroy(timeout);
+ \endcode
+
+ \sa quit()
+ */
+void IrcConnection::close()
+{
+ Q_D(IrcConnection);
+ if (d->socket) {
+ d->closed = true;
+ d->socket->flush();
+ d->socket->abort();
+ d->socket->disconnectFromHost();
+ if (d->socket->state() == QAbstractSocket::UnconnectedState)
+ d->setStatus(Closed);
+ d->reconnecter.stop();
+ }
+}
+
+/*!
+ Sends a quit command with an optionally specified \a reason.
+
+ This method is provided for convenience. It is equal to:
+ \code
+ IrcCommand* command = IrcCommand::createQuit(reason);
+ connection->sendCommand(command);
+ \endcode
+
+ \sa IrcCommand::createQuit()
+ */
+void IrcConnection::quit(const QString& reason)
+{
+ sendCommand(IrcCommand::createQuit(reason));
+}
+
+/*!
+ Sends a \a command to the server.
+
+ If the connection is not active, the \a command is queued and sent
+ later when the connection has been established.
+
+ \note If the command has a valid parent, it is an indication that
+ the caller of this method is be responsible for freeing the command.
+ If the command does not have a valid parent (like the commands
+ created via various IrcCommand::createXxx() methods) the connection
+ will take ownership of the command and delete it once it has been
+ sent. Thus, the command must have been allocated on the heap and
+ it is not safe to access the command after it has been sent.
+
+ \sa sendData()
+ */
+bool IrcConnection::sendCommand(IrcCommand* command)
+{
+ Q_D(IrcConnection);
+ bool res = false;
+ if (command) {
+ bool filtered = false;
+ for (int i = d->commandFilters.count() - 1; !filtered && i >= 0; --i) {
+ QObject* filter = d->commandFilters.at(i);
+ IrcCommandFilter* commandFilter = qobject_cast<IrcCommandFilter*>(filter);
+ if (commandFilter && !d->activeCommandFilters.contains(filter)) {
+ d->activeCommandFilters.push(filter);
+ filtered |= commandFilter->commandFilter(command);
+ d->activeCommandFilters.pop();
+ }
+ }
+ if (filtered)
+ return false;
+
+ if (isActive()) {
+ QTextCodec* codec = QTextCodec::codecForName(command->encoding());
+ Q_ASSERT(codec);
+ res = sendData(codec->fromUnicode(command->toString()));
+ if (!command->parent())
+ command->deleteLater();
+ } else {
+ Q_D(IrcConnection);
+ d->pendingCommands += command;
+ }
+ }
+ return res;
+}
+
+/*!
+ Sends raw \a data to the server.
+
+ \sa sendCommand()
+ */
+bool IrcConnection::sendData(const QByteArray& data)
+{
+ Q_D(IrcConnection);
+ if (d->socket) {
+ static bool dbg = qgetenv("IRC_DEBUG").toInt();
+ if (dbg) qDebug() << "->" << data;
+ if (!d->closed && data.length() >= 4) {
+ const QByteArray cmd = data.left(5).toUpper();
+ if (cmd.startsWith("QUIT") && (data.length() == 4 || QChar(data.at(4)).isSpace()))
+ d->closed = true;
+ }
+ return d->protocol->write(data);
+ }
+ return false;
+}
+
+/*!
+ Sends raw \a message to the server using UTF-8 encoding.
+
+ \sa sendData(), sendCommand()
+ */
+bool IrcConnection::sendRaw(const QString& message)
+{
+ return sendData(message.toUtf8());
+}
+
+/*!
+ Installs a message \a filter on the connection. The \a filter must implement the IrcMessageFilter interface.
+
+ A message filter receives all messages that are sent to the connection. The filter
+ receives messages via the \ref IrcMessageFilter::messageFilter() "messageFilter()"
+ function. The function must return \c true if the message should be filtered,
+ (i.e. stopped); otherwise it must return \c false.
+
+ If multiple message filters are installed on the same connection, the filter
+ that was installed last is activated first.
+
+ \sa removeMessageFilter()
+ */
+void IrcConnection::installMessageFilter(QObject* filter)
+{
+ Q_D(IrcConnection);
+ IrcMessageFilter* msgFilter = qobject_cast<IrcMessageFilter*>(filter);
+ if (msgFilter) {
+ d->messageFilters += filter;
+ connect(filter, SIGNAL(destroyed(QObject*)), this, SLOT(_irc_filterDestroyed(QObject*)), Qt::UniqueConnection);
+ }
+}
+
+/*!
+ Removes a message \a filter from the connection.
+
+ The request is ignored if such message filter has not been installed.
+ All message filters for a connection are automatically removed
+ when the connection is destroyed.
+
+ \sa installMessageFilter()
+ */
+void IrcConnection::removeMessageFilter(QObject* filter)
+{
+ Q_D(IrcConnection);
+ IrcMessageFilter* msgFilter = qobject_cast<IrcMessageFilter*>(filter);
+ if (msgFilter) {
+ d->messageFilters.removeAll(filter);
+ disconnect(filter, SIGNAL(destroyed(QObject*)), this, SLOT(_irc_filterDestroyed(QObject*)));
+ }
+}
+
+/*!
+ Installs a command \a filter on the connection. The \a filter must implement the IrcCommandFilter interface.
+
+ A command filter receives all commands that are sent from the connection. The filter
+ receives commands via the \ref IrcCommandFilter::commandFilter() "commandFilter()"
+ function. The function must return \c true if the command should be filtered,
+ (i.e. stopped); otherwise it must return \c false.
+
+ If multiple command filters are installed on the same connection, the filter
+ that was installed last is activated first.
+
+ \sa removeCommandFilter()
+ */
+void IrcConnection::installCommandFilter(QObject* filter)
+{
+ Q_D(IrcConnection);
+ IrcCommandFilter* cmdFilter = qobject_cast<IrcCommandFilter*>(filter);
+ if (cmdFilter) {
+ d->commandFilters += filter;
+ connect(filter, SIGNAL(destroyed(QObject*)), this, SLOT(_irc_filterDestroyed(QObject*)), Qt::UniqueConnection);
+ }
+}
+
+/*!
+ Removes a command \a filter from the connection.
+
+ The request is ignored if such command filter has not been installed.
+ All command filters for a connection are automatically removed when
+ the connection is destroyed.
+
+ \sa installCommandFilter()
+ */
+void IrcConnection::removeCommandFilter(QObject* filter)
+{
+ Q_D(IrcConnection);
+ IrcCommandFilter* cmdFilter = qobject_cast<IrcCommandFilter*>(filter);
+ if (cmdFilter) {
+ d->commandFilters.removeAll(filter);
+ disconnect(filter, SIGNAL(destroyed(QObject*)), this, SLOT(_irc_filterDestroyed(QObject*)));
+ }
+}
+
+/*!
+ \since 3.1
+
+ Saves the state of the connection. The \a version number is stored as part of the state data.
+
+ To restore the saved state, pass the return value and \a version number to restoreState().
+ */
+QByteArray IrcConnection::saveState(int version) const
+{
+ QVariantMap args;
+ args.insert("version", version);
+ args.insert("host", host());
+ args.insert("port", port());
+ args.insert("userName", userName());
+ args.insert("nickName", nickName());
+ args.insert("realName", realName());
+ args.insert("password", password());
+ args.insert("displayName", displayName());
+ args.insert("userData", userData());
+ args.insert("encoding", encoding());
+ args.insert("enabled", isEnabled());
+ args.insert("reconnectDelay", reconnectDelay());
+ args.insert("secure", isSecure());
+ args.insert("saslMechanism", saslMechanism());
+
+ QByteArray state;
+ QDataStream out(&state, QIODevice::WriteOnly);
+ out << args;
+ return state;
+}
+
+/*!
+ \since 3.1
+
+ Restores the \a state of the connection. The \a version number is compared with that stored in \a state.
+ If they do not match, the connection state is left unchanged, and this function returns \c false; otherwise,
+ the state is restored, and \c true is returned.
+
+ \sa saveState()
+ */
+bool IrcConnection::restoreState(const QByteArray& state, int version)
+{
+ if (isActive())
+ return false;
+
+ QVariantMap args;
+ QDataStream in(state);
+ in >> args;
+ if (in.status() != QDataStream::Ok || args.value("version", -1).toInt() != version)
+ return false;
+
+ setHost(args.value("host", host()).toString());
+ setPort(args.value("port", port()).toInt());
+ setUserName(args.value("userName", userName()).toString());
+ setNickName(args.value("nickName", nickName()).toString());
+ setRealName(args.value("realName", realName()).toString());
+ setPassword(args.value("password", password()).toString());
+ setDisplayName(args.value("displayName").toString());
+ setUserData(args.value("userData", userData()).toMap());
+ setEncoding(args.value("encoding", encoding()).toByteArray());
+ setEnabled(args.value("enabled", isEnabled()).toBool());
+ setReconnectDelay(args.value("reconnectDelay", reconnectDelay()).toInt());
+ setSecure(args.value("secure", isSecure()).toBool());
+ setSaslMechanism(args.value("saslMechanism", saslMechanism()).toString());
+ return true;
+}
+
+/*!
+ Creates a reply command for the CTCP \a request.
+
+ The default implementation handles the following CTCP requests: CLIENTINFO, PING, SOURCE, TIME and VERSION.
+
+ Reimplement this function in order to alter or omit the default replies.
+ */
+IrcCommand* IrcConnection::createCtcpReply(IrcPrivateMessage* request) const
+{
+ QString reply;
+ QString type = request->content().split(" ", QString::SkipEmptyParts).value(0).toUpper();
+ if (type == "PING")
+ reply = request->content();
+ else if (type == "TIME")
+ reply = QLatin1String("TIME ") + QLocale().toString(QDateTime::currentDateTime(), QLocale::ShortFormat);
+ else if (type == "VERSION")
+ reply = QLatin1String("VERSION Using libcommuni ") + Irc::version() + QLatin1String(" - http://communi.github.com");
+ else if (type == "SOURCE")
+ reply = QLatin1String("SOURCE http://communi.github.com");
+ else if (type == "CLIENTINFO")
+ reply = QLatin1String("CLIENTINFO PING SOURCE TIME VERSION");
+ if (!reply.isEmpty())
+ return IrcCommand::createCtcpReply(request->nick(), reply);
+ return 0;
+}
+
+/*!
+ \since 3.2
+
+ This property holds the protocol.
+
+ The previously set protocol is deleted if its parent is \c this.
+
+ \par Access functions:
+ \li \ref IrcProtocol* <b>protocol</b>() const
+ \li void <b>setProtocol</b>(\ref IrcProtocol* protocol)
+ */
+IrcProtocol* IrcConnection::protocol() const
+{
+ Q_D(const IrcConnection);
+ return d->protocol;
+}
+
+void IrcConnection::setProtocol(IrcProtocol* proto)
+{
+ Q_D(IrcConnection);
+ if (d->protocol != proto) {
+ if (d->protocol && d->protocol->parent() == this)
+ delete d->protocol;
+ d->protocol = proto;
+ }
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug debug, IrcConnection::Status status)
+{
+ const int index = IrcConnection::staticMetaObject.indexOfEnumerator("Status");
+ QMetaEnum enumerator = IrcConnection::staticMetaObject.enumerator(index);
+ const char* key = enumerator.valueToKey(status);
+ debug << (key ? key : "Unknown");
+ return debug;
+}
+
+QDebug operator<<(QDebug debug, const IrcConnection* connection)
+{
+ if (!connection)
+ return debug << "IrcConnection(0x0) ";
+ debug.nospace() << connection->metaObject()->className() << '(' << (void*) connection;
+ if (!connection->displayName().isEmpty())
+ debug.nospace() << ", " << qPrintable(connection->displayName());
+ debug.nospace() << ')';
+ return debug.space();
+}
+#endif // QT_NO_DEBUG_STREAM
+
+#include "moc_ircconnection.cpp"
+
+IRC_END_NAMESPACE
diff --git a/libcommuni/src/core/irccore.cpp b/libcommuni/src/core/irccore.cpp
new file mode 100644
index 0000000..f6453c8
--- /dev/null
+++ b/libcommuni/src/core/irccore.cpp
@@ -0,0 +1,90 @@
+/*
+ Copyright (C) 2008-2014 The Communi Project
+
+ You may use this file under the terms of BSD license as follows:
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "irccore.h"
+
+IRC_BEGIN_NAMESPACE
+
+/*!
+ \file irccore.h
+ \brief \#include &lt;IrcCore&gt;
+ */
+
+/*!
+ \namespace IrcCore
+ \ingroup core
+ \brief Module meta-type registration.
+ */
+
+namespace IrcCore {
+
+ /*!
+ Registers IrcCore types to the %Qt meta-system.
+
+ \sa IrcModel::registerMetaTypes(), IrcUtil::registerMetaTypes(), qRegisterMetaType()
+ */
+ void registerMetaTypes()
+ {
+ qRegisterMetaType<Irc::Color>("Irc::Color");
+ qRegisterMetaType<Irc::DataRole>("Irc::DataRole");
+ qRegisterMetaType<Irc::SortMethod>("Irc::SortMethod");
+ qRegisterMetaType<Irc::Code>("Irc::Code");
+
+ qRegisterMetaType<IrcConnection*>("IrcConnection*");
+ qRegisterMetaType<IrcConnection::Status>("IrcConnection::Status");
+
+ qRegisterMetaType<IrcNetwork*>("IrcNetwork*");
+
+ qRegisterMetaType<IrcCommand*>("IrcCommand*");
+ qRegisterMetaType<IrcCommand::Type>("IrcCommand::Type");
+
+ qRegisterMetaType<IrcMessage*>("IrcMessage*");
+ qRegisterMetaType<IrcMessage::Type>("IrcMessage::Type");
+
+ qRegisterMetaType<IrcCapabilityMessage*>("IrcCapabilityMessage*");
+ qRegisterMetaType<IrcErrorMessage*>("IrcErrorMessage*");
+ qRegisterMetaType<IrcInviteMessage*>("IrcInviteMessage*");
+ qRegisterMetaType<IrcJoinMessage*>("IrcJoinMessage*");
+ qRegisterMetaType<IrcKickMessage*>("IrcKickMessage*");
+ qRegisterMetaType<IrcModeMessage*>("IrcModeMessage*");
+ qRegisterMetaType<IrcNamesMessage*>("IrcNamesMessage*");
+ qRegisterMetaType<IrcNickMessage*>("IrcNickMessage*");
+ qRegisterMetaType<IrcNoticeMessage*>("IrcNoticeMessage*");
+ qRegisterMetaType<IrcNumericMessage*>("IrcNumericMessage*");
+ qRegisterMetaType<IrcMotdMessage*>("IrcMotdMessage*");
+ qRegisterMetaType<IrcPartMessage*>("IrcPartMessage*");
+ qRegisterMetaType<IrcPingMessage*>("IrcPingMessage*");
+ qRegisterMetaType<IrcPongMessage*>("IrcPongMessage*");
+ qRegisterMetaType<IrcPrivateMessage*>("IrcPrivateMessage*");
+ qRegisterMetaType<IrcQuitMessage*>("IrcQuitMessage*");
+ qRegisterMetaType<IrcTopicMessage*>("IrcTopicMessage*");
+ qRegisterMetaType<IrcWhoReplyMessage*>("IrcWhoReplyMessage*");
+ }
+}
+
+IRC_END_NAMESPACE
diff --git a/libcommuni/src/core/ircfilter.cpp b/libcommuni/src/core/ircfilter.cpp
new file mode 100644
index 0000000..054badb
--- /dev/null
+++ b/libcommuni/src/core/ircfilter.cpp
@@ -0,0 +1,248 @@
+/*
+ Copyright (C) 2008-2014 The Communi Project
+
+ You may use this file under the terms of BSD license as follows:
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "ircfilter.h"
+
+IRC_BEGIN_NAMESPACE
+
+/*!
+ \file ircfilter.h
+ \brief \#include &lt;\ref ircfilter.h "IrcFilter"&gt;
+ */
+
+/*!
+ \file ircmessagefilter.h
+ \brief \#include &lt;IrcMessageFilter&gt;
+ */
+
+/*!
+ \file irccommandfilter.h
+ \brief \#include &lt;IrcCommandFilter&gt;
+ */
+
+/*!
+ \class IrcMessageFilter ircfilter.h <IrcMessageFilter>
+ \ingroup core
+ \brief Provides an interface for filtering messages
+
+ IrcMessageFilter may be used to intercept messages before
+ IrcConnection::messageReceived() is emitted and the messages get delivered
+ further. In order to use IrcMessageFilter, it must be installed via
+ IrcConnection::installMessageFilter().
+
+ Message filtering is mostly useful for handling specific replies before
+ the rest of the application receives it. This way there is no need to
+ for example ignore and hide such replies later in the application code.
+
+ The following example sends a PING command after each PRIVMSG command.
+ A consequent PONG reply from the server verifies that the PRIVMSG has
+ been also processed.
+
+ \code
+ class CommandVerifier : public QObject,
+ public IrcCommandFilter,
+ public IrcMessageFilter
+ {
+ Q_OBJECT
+ Q_INTERFACES(IrcCommandFilter IrcMessageFilter)
+
+ public:
+ CommandVerifier(IrcConnection* parent) :
+ QObject(parent), identifier(0), connection(parent)
+ {
+ connection->installMessageFilter(this);
+ connection->installCommandFilter(this);
+ }
+
+ virtual bool commandFilter(IrcCommand* cmd)
+ {
+ if (cmd->type() == IrcCommand::Message) {
+ cmd->setParent(this); // take ownership
+ connection->sendCommand(cmd);
+ commands.insert(++identifier, cmd);
+ connection->sendData("PING communi/" + QByteArray::number(identifier));
+ return true;
+ }
+ return false;
+ }
+
+ virtual bool messageFilter(IrcMessage* msg)
+ {
+ if (msg->type() == IrcMessage::Pong) {
+ QString arg = static_cast<IrcPongMessage*>(msg)->argument();
+ if (arg.startsWith("communi/")) {
+ bool ok = false;
+ quint64 id = arg.mid(8).toULongLong(&ok);
+ if (ok) {
+ IrcCommand* command = commands.take(id);
+ if (command) {
+ emit verified(command);
+ command->deleteLater();
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ signals:
+ void verified(IrcCommand* cmd);
+
+ private:
+ quint64 identifier;
+ IrcConnection* connection;
+ QMap<quint64, IrcCommand*> commands;
+ };
+ \endcode
+
+ \sa IrcConnection::installMessageFilter(), IrcCommandFilter
+ */
+
+/*!
+ \fn IrcMessageFilter::~IrcMessageFilter()
+ Destructs the message filter.
+
+ The message filter is automatically removed from any connection(s)
+ it is installed on.
+
+ \sa IrcConnection::removeMessageFilter()
+ */
+
+/*!
+ \fn virtual bool IrcMessageFilter::messageFilter(IrcMessage* message) = 0
+
+ Reimplement this function to filter messages from installed connections.
+
+ Return \c true to filter the message out, i.e. stop it being handled further;
+ otherwise return \c false.
+
+ \sa IrcConnection::installMessageFilter()
+ */
+
+/*!
+ \class IrcCommandFilter ircfilter.h <IrcCommandFilter>
+ \ingroup core
+ \brief Provides an interface for filtering commands
+
+ IrcCommandFilter may be used to intercept commands before they
+ get sent further. In order to use IrcCommandFilter, it must be
+ installed via IrcConnection::installCommandFilter().
+
+ Command filtering can be useful doing extra tasks for specific
+ type of commands. The following example sends a PING command
+ after each PRIVMSG command. A consequent PONG reply from the
+ server verifies that the PRIVMSG has been also processed.
+
+ \code
+ class CommandVerifier : public QObject,
+ public IrcCommandFilter,
+ public IrcMessageFilter
+ {
+ Q_OBJECT
+ Q_INTERFACES(IrcCommandFilter IrcMessageFilter)
+
+ public:
+ CommandVerifier(IrcConnection* parent) :
+ QObject(parent), identifier(0), connection(parent)
+ {
+ connection->installMessageFilter(this);
+ connection->installCommandFilter(this);
+ }
+
+ virtual bool commandFilter(IrcCommand* cmd)
+ {
+ if (cmd->type() == IrcCommand::Message) {
+ cmd->setParent(this); // take ownership
+ connection->sendCommand(cmd);
+ commands.insert(++identifier, cmd);
+ connection->sendData("PING communi/" + QByteArray::number(identifier));
+ return true;
+ }
+ return false;
+ }
+
+ virtual bool messageFilter(IrcMessage* msg)
+ {
+ if (msg->type() == IrcMessage::Pong) {
+ QString arg = static_cast<IrcPongMessage*>(msg)->argument();
+ if (arg.startsWith("communi/")) {
+ bool ok = false;
+ quint64 id = arg.mid(8).toULongLong(&ok);
+ if (ok) {
+ IrcCommand* command = commands.take(id);
+ if (command) {
+ emit verified(command);
+ command->deleteLater();
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+ }
+
+ signals:
+ void verified(IrcCommand* cmd);
+
+ private:
+ quint64 identifier;
+ IrcConnection* connection;
+ QMap<quint64, IrcCommand*> commands;
+ };
+ \endcode
+
+ \note Notice that it is safe to call IrcConnection::sendCommand()
+ from IrcCommandFilter::commandFilter(). Such commands won't get
+ delivered back to the \b same filter to avoid recursion.
+
+ \sa IrcConnection::installCommandFilter(), IrcMessageFilter
+ */
+
+/*!
+ \fn IrcCommandFilter::~IrcCommandFilter()
+ Destructs the command filter.
+
+ The command filter is automatically removed from any connection(s)
+ it is installed on.
+
+ \sa IrcConnection::removeCommandFilter()
+ */
+
+/*!
+ \fn virtual bool IrcCommandFilter::commandFilter(IrcCommand* command) = 0
+
+ Reimplement this function to filter commands to installed connections.
+
+ Return \c true to filter the command out, i.e. stop it being handled further;
+ otherwise return \c false.
+
+ \sa IrcConnection::installCommandFilter()
+ */
+
+IRC_END_NAMESPACE
diff --git a/libcommuni/src/core/ircmessage.cpp b/libcommuni/src/core/ircmessage.cpp
new file mode 100644
index 0000000..eaca6ab
--- /dev/null
+++ b/libcommuni/src/core/ircmessage.cpp
@@ -0,0 +1,1604 @@
+/*
+ Copyright (C) 2008-2014 The Communi Project
+
+ You may use this file under the terms of BSD license as follows:
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "ircmessage.h"
+#include "ircmessage_p.h"
+#include "ircconnection.h"
+#include "ircconnection_p.h"
+#include "ircnetwork.h"
+#include "irccommand.h"
+#include "irc.h"
+#include <QMetaEnum>
+#include <QVariant>
+#include <QDebug>
+
+IRC_BEGIN_NAMESPACE
+
+/*!
+ \file ircmessage.h
+ \brief \#include &lt;IrcMessage&gt;
+ */
+
+/*!
+ \class IrcMessage ircmessage.h <IrcMessage>
+ \ingroup core
+ \ingroup message
+ \brief The base class of all messages.
+
+ IRC messages are received from an IRC server. IrcConnection translates received
+ messages into IrcMessage instances and emits the IrcConnection::messageReceived()
+ signal upon message received.
+
+ Subclasses of IrcMessage contain specialized accessors for parameters that
+ are specific to the particular type of message. See IrcMessage::Type for
+ the list of supported message types.
+
+ \sa IrcConnection::messageReceived(), IrcMessage::Type
+ */
+
+/*!
+ \enum IrcMessage::Type
+ This enum describes the supported message types.
+ */
+
+/*!
+ \var IrcMessage::Unknown
+ \brief An unknown message (IrcMessage).
+ */
+
+/*!
+ \var IrcMessage::Capability
+ \brief A capability message (IrcCapabilityMessage).
+ */
+
+/*!
+ \var IrcMessage::Error
+ \brief An error message (IrcErrorMessage).
+ */
+
+/*!
+ \var IrcMessage::Invite
+ \brief An invite message (IrcInviteMessage).
+ */
+
+/*!
+ \var IrcMessage::Join
+ \brief A join message (IrcJoinMessage).
+ */
+
+/*!
+ \var IrcMessage::Kick
+ \brief A kick message (IrcKickMessage).
+ */
+
+/*!
+ \var IrcMessage::Mode
+ \brief A mode message (IrcModeMessage).
+ */
+
+/*!
+ \var IrcMessage::Motd
+ \brief A message of the day (IrcMotdMessage).
+ */
+
+/*!
+ \var IrcMessage::Names
+ \brief A names message (IrcNamesMessage).
+ */
+
+/*!
+ \var IrcMessage::Nick
+ \brief A nick message (IrcNickMessage).
+ */
+
+/*!
+ \var IrcMessage::Notice
+ \brief A notice message (IrcNoticeMessage).
+ */
+
+/*!
+ \var IrcMessage::Numeric
+ \brief A numeric message (IrcNumericMessage).
+ */
+
+/*!
+ \var IrcMessage::Part
+ \brief A part message (IrcPartMessage).
+ */
+
+/*!
+ \var IrcMessage::Ping
+ \brief A ping message (IrcPingMessage).
+ */
+
+/*!
+ \var IrcMessage::Pong
+ \brief A pong message (IrcPongMessage).
+ */
+
+/*!
+ \var IrcMessage::Private
+ \brief A private message (IrcPrivateMessage).
+ */
+
+/*!
+ \var IrcMessage::Quit
+ \brief A quit message (IrcQuitMessage).
+ */
+
+/*!
+ \var IrcMessage::Topic
+ \brief A topic message (IrcTopicMessage).
+ */
+
+/*!
+ \enum IrcMessage::Flag
+ This enum describes the supported message flags.
+ */
+
+/*!
+ \var IrcMessage::None
+ \brief The message has no flags.
+ */
+
+/*!
+ \var IrcMessage::Own
+ \brief The message is user's own message.
+ */
+
+/*!
+ \var IrcMessage::Identified
+ \brief The message is identified.
+ */
+
+/*!
+ \var IrcMessage::Unidentified
+ \brief The message is unidentified.
+ */
+
+/*!
+ \since 3.2
+ \var IrcMessage::Playback
+ \brief The message is playback.
+ */
+
+static const QMetaObject* irc_command_meta_object(const QString& command)
+{
+ static QHash<QString, const QMetaObject*> metaObjects;
+ if (metaObjects.isEmpty()) {
+ metaObjects.insert("CAP", &IrcCapabilityMessage::staticMetaObject);
+ metaObjects.insert("ERROR", &IrcErrorMessage::staticMetaObject);
+ metaObjects.insert("INVITE", &IrcInviteMessage::staticMetaObject);
+ metaObjects.insert("JOIN", &IrcJoinMessage::staticMetaObject);
+ metaObjects.insert("KICK", &IrcKickMessage::staticMetaObject);
+ metaObjects.insert("MODE", &IrcModeMessage::staticMetaObject);
+ metaObjects.insert("NICK", &IrcNickMessage::staticMetaObject);
+ metaObjects.insert("NOTICE", &IrcNoticeMessage::staticMetaObject);
+ metaObjects.insert("PART", &IrcPartMessage::staticMetaObject);
+ metaObjects.insert("PING", &IrcPingMessage::staticMetaObject);
+ metaObjects.insert("PONG", &IrcPongMessage::staticMetaObject);
+ metaObjects.insert("PRIVMSG", &IrcPrivateMessage::staticMetaObject);
+ metaObjects.insert("QUIT", &IrcQuitMessage::staticMetaObject);
+ metaObjects.insert("TOPIC", &IrcTopicMessage::staticMetaObject);
+ }
+
+ const QMetaObject* metaObject = metaObjects.value(command.toUpper());
+ if (!metaObject) {
+ bool ok = false;
+ command.toInt(&ok);
+ if (ok)
+ metaObject = &IrcNumericMessage::staticMetaObject;
+ }
+ if (!metaObject)
+ metaObject = &IrcMessage::staticMetaObject;
+ return metaObject;
+}
+
+/*!
+ Constructs a new IrcMessage with \a connection.
+ */
+IrcMessage::IrcMessage(IrcConnection* connection) : QObject(connection), d_ptr(new IrcMessagePrivate)
+{
+ Q_D(IrcMessage);
+ d->connection = connection;
+}
+
+/*!
+ Destructs the message.
+ */
+IrcMessage::~IrcMessage()
+{
+}
+
+/*!
+ This property holds the message connection.
+
+ \par Access function:
+ \li \ref IrcConnection* <b>connection</b>() const
+ */
+IrcConnection* IrcMessage::connection() const
+{
+ Q_D(const IrcMessage);
+ return d->connection;
+}
+
+/*!
+ This property holds the message network.
+
+ \par Access function:
+ \li \ref IrcNetwork* <b>network</b>() const
+ */
+IrcNetwork* IrcMessage::network() const
+{
+ Q_D(const IrcMessage);
+ return d->connection ? d->connection->network() : 0;
+}
+
+/*!
+ This property holds the message type.
+
+ \par Access function:
+ \li \ref IrcMessage::Type <b>type</b>() const
+ */
+IrcMessage::Type IrcMessage::type() const
+{
+ Q_D(const IrcMessage);
+ return d->type;
+}
+
+/*!
+ \since 3.2
+ \property bool IrcMessage::own
+
+ This property holds whether the message is user's own.
+
+ This property is provided for convenience. It is equivalent
+ of testing for the IrcMessage::Own flag.
+
+ \par Access function:
+ \li bool <b>isOwn</b>() const
+ */
+bool IrcMessage::isOwn() const
+{
+ return flags() & Own;
+}
+
+/*!
+ This property holds the message flags.
+
+ \par Access function:
+ \li \ref IrcMessage::Flag "IrcMessage::Flags" <b>flags</b>() const
+ \li void <b>setFlags</b>(\ref IrcMessage::Flag "IrcMessage::Flags" flags) (\b Since 3.2)
+ */
+IrcMessage::Flags IrcMessage::flags() const
+{
+ Q_D(const IrcMessage);
+ if (d->flags == -1) {
+ d->flags = IrcMessage::None;
+ if (d->connection) {
+ if (!d->prefix().isEmpty() && d->nick() == d->connection->nickName())
+ d->flags |= IrcMessage::Own;
+
+ if ((d->type == IrcMessage::Private || d->type == IrcMessage::Notice) &&
+ network()->activeCapabilities().contains("identify-msg")) {
+ QString msg = property("content").toString();
+ if (msg.startsWith("+"))
+ d->flags |= IrcMessage::Identified;
+ else if (msg.startsWith("-"))
+ d->flags |= IrcMessage::Unidentified;
+ }
+ }
+ }
+ return IrcMessage::Flags(d->flags);
+}
+
+void IrcMessage::setFlags(IrcMessage::Flags flags)
+{
+ Q_D(IrcMessage);
+ d->flags = flags;
+}
+
+/*!
+ This property holds the message command.
+
+ \par Access functions:
+ \li QString <b>command</b>() const
+ \li void <b>setCommand</b>(const QString& command)
+ */
+QString IrcMessage::command() const
+{
+ Q_D(const IrcMessage);
+ return d->command();
+}
+
+void IrcMessage::setCommand(const QString& command)
+{
+ Q_D(IrcMessage);
+ d->setCommand(command);
+}
+
+/*!
+ This property holds the message sender prefix.
+
+ The prefix consists of \ref nick, \ref ident and \ref host as specified in RFC 1459:
+ <pre>
+ &lt;prefix&gt; ::= &lt;\ref nick&gt; [ '!' &lt;\ref ident&gt; ] [ '@' &lt;\ref host&gt; ]
+ </pre>
+
+ \par Access functions:
+ \li QString <b>prefix</b>() const
+ \li void <b>setPrefix</b>(const QString& prefix)
+ */
+QString IrcMessage::prefix() const
+{
+ Q_D(const IrcMessage);
+ return d->prefix();
+}
+
+void IrcMessage::setPrefix(const QString& prefix)
+{
+ Q_D(IrcMessage);
+ d->setPrefix(prefix);
+}
+
+/*!
+ This property holds the message sender nick.
+
+ Nick is part of the sender \ref prefix as specified in RFC 1459:
+ <pre>
+ <b>&lt;nick&gt;</b> [ '!' &lt;\ref ident&gt; ] [ '@' &lt;\ref host&gt; ]
+ </pre>
+
+ \par Access function:
+ \li QString <b>nick</b>() const
+ */
+QString IrcMessage::nick() const
+{
+ Q_D(const IrcMessage);
+ return d->nick();
+}
+
+/*!
+ This property holds the message sender ident.
+
+ Ident is part of the sender \ref prefix as specified in RFC 1459:
+ <pre>
+ &lt;\ref nick&gt; [ '!' <b>&lt;ident&gt;</b> ] [ '@' &lt;\ref host&gt; ]
+ </pre>
+
+ \par Access function:
+ \li QString <b>ident</b>() const
+ */
+QString IrcMessage::ident() const
+{
+ Q_D(const IrcMessage);
+ return d->ident();
+}
+
+/*!
+ This property holds the message sender host.
+
+ Host is part of the sender \ref prefix as specified in RFC 1459:
+ <pre>
+ &lt;\ref nick&gt; [ '!' &lt;\ref ident&gt; ] [ '@' <b>&lt;host&gt;</b> ]
+ </pre>
+
+ \par Access function:
+ \li QString <b>host</b>() const
+ */
+QString IrcMessage::host() const
+{
+ Q_D(const IrcMessage);
+ return d->host();
+}
+
+/*!
+ This property holds the message parameters.
+
+ \par Access functions:
+ \li QStringList <b>parameters</b>() const
+ \li void <b>setParameters</b>(const QStringList& parameters)
+ */
+QStringList IrcMessage::parameters() const
+{
+ Q_D(const IrcMessage);
+ return d->params();
+}
+
+void IrcMessage::setParameters(const QStringList& parameters)
+{
+ Q_D(IrcMessage);
+ d->setParams(parameters);
+}
+
+/*!
+ This property holds the message time stamp.
+
+ \par Access functions:
+ \li QDateTime <b>timeStamp</b>() const
+ \li void <b>setTimeStamp</b>(const QDateTime& timeStamp)
+ */
+QDateTime IrcMessage::timeStamp() const
+{
+ Q_D(const IrcMessage);
+ return d->timeStamp;
+}
+
+void IrcMessage::setTimeStamp(const QDateTime& timeStamp)
+{
+ Q_D(IrcMessage);
+ d->timeStamp = timeStamp;
+}
+
+/*!
+ This property holds the FALLBACK encoding for the message.
+
+ The fallback encoding is used when the message is detected not
+ to be valid UTF-8 and the consequent auto-detection of message
+ encoding fails. See QTextCodec::availableCodes() for the list of
+ supported encodings.
+
+ The default value is ISO-8859-15.
+
+ \par Access functions:
+ \li QByteArray <b>encoding</b>() const
+ \li void <b>setEncoding</b>(const QByteArray& encoding)
+
+ \sa QTextCodec::availableCodecs(), QTextCodec::codecForLocale()
+ */
+QByteArray IrcMessage::encoding() const
+{
+ Q_D(const IrcMessage);
+ return d->encoding;
+}
+
+void IrcMessage::setEncoding(const QByteArray& encoding)
+{
+ Q_D(IrcMessage);
+ extern bool irc_is_supported_encoding(const QByteArray& encoding); // ircmessagedecoder.cpp
+ if (!irc_is_supported_encoding(encoding)) {
+ qWarning() << "IrcMessage::setEncoding(): unsupported encoding" << encoding;
+ return;
+ }
+ d->encoding = encoding;
+ d->invalidate();
+}
+
+/*!
+ \since 3.1
+
+ This property holds the message tags.
+
+ \par Access functions:
+ \li QVariantMap <b>tags</b>() const
+ \li void <b>setTags</b>(const QVariantMap& tags)
+
+ \sa <a href="http://ircv3.org/specification/message-tags-3.2">IRCv3.2 Message Tags</a>
+ */
+QVariantMap IrcMessage::tags() const
+{
+ Q_D(const IrcMessage);
+ return d->tags();
+}
+
+void IrcMessage::setTags(const QVariantMap& tags)
+{
+ Q_D(IrcMessage);
+ d->setTags(tags);
+}
+
+/*!
+ Creates a new message from \a data and \a connection.
+ */
+IrcMessage* IrcMessage::fromData(const QByteArray& data, IrcConnection* connection)
+{
+ IrcMessage* message = 0;
+ IrcMessageData md = IrcMessageData::fromData(data);
+ const QMetaObject* metaObject = irc_command_meta_object(md.command);
+ if (metaObject) {
+ message = qobject_cast<IrcMessage*>(metaObject->newInstance(Q_ARG(IrcConnection*, connection)));
+ Q_ASSERT(message);
+ message->d_ptr->data = md;
+ }
+ return message;
+}
+
+/*!
+ Creates a new message from \a prefix, \a command and \a parameters with \a connection.
+ */
+IrcMessage* IrcMessage::fromParameters(const QString& prefix, const QString& command, const QStringList& parameters, IrcConnection* connection)
+{
+ IrcMessage* message = 0;
+ const QMetaObject* metaObject = irc_command_meta_object(command);
+ if (metaObject) {
+ message = qobject_cast<IrcMessage*>(metaObject->newInstance(Q_ARG(IrcConnection*, connection)));
+ Q_ASSERT(message);
+ message->setPrefix(prefix);
+ message->setCommand(command);
+ message->setParameters(parameters);
+ }
+ return message;
+}
+
+/*!
+ \property bool IrcMessage::valid
+ This property is \c true if the message is valid; otherwise \c false.
+
+ A message is considered valid if the prefix is not empty
+ and the parameters match the message.
+
+ \par Access function:
+ \li bool <b>isValid</b>() const
+ */
+bool IrcMessage::isValid() const
+{
+ Q_D(const IrcMessage);
+ return d->connection && !prefix().isNull();
+}
+
+/*!
+ Returns the message as received from an IRC server.
+ */
+QByteArray IrcMessage::toData() const
+{
+ Q_D(const IrcMessage);
+ return d->content();
+}
+
+/*!
+ \class IrcCapabilityMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a capability message.
+ */
+
+/*!
+ Constructs a new IrcCapabilityMessage with \a connection.
+ */
+IrcCapabilityMessage::IrcCapabilityMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Capability;
+}
+
+/*!
+ This property holds the subcommand.
+
+ The following capability subcommands are defined:
+ LS, LIST, REQ, ACK, NAK, CLEAR, END
+
+ \par Access function:
+ \li QString <b>subCommand</b>() const
+ */
+QString IrcCapabilityMessage::subCommand() const
+{
+ Q_D(const IrcMessage);
+ return d->param(1);
+}
+
+/*!
+ This property holds the capabilities.
+
+ A list of capabilities may exist for the following
+ subcommands: LS, LIST, REQ, ACK and NAK.
+
+ \par Access function:
+ \li QStringList <b>capabilities</b>() const
+ */
+QStringList IrcCapabilityMessage::capabilities() const
+{
+ Q_D(const IrcMessage);
+ QStringList caps;
+ QStringList params = d->params();
+ if (params.count() > 2)
+ caps = params.last().split(QLatin1Char(' '), QString::SkipEmptyParts);
+ return caps;
+}
+
+bool IrcCapabilityMessage::isValid() const
+{
+ return IrcMessage::isValid();
+}
+
+/*!
+ \class IrcErrorMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents an error message.
+ */
+
+/*!
+ Constructs a new IrcErrorMessage with \a connection.
+ */
+IrcErrorMessage::IrcErrorMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Error;
+}
+
+/*!
+ This property holds the error.
+
+ \par Access function:
+ \li QString <b>error</b>() const
+ */
+QString IrcErrorMessage::error() const
+{
+ Q_D(const IrcMessage);
+ return d->param(0);
+}
+
+bool IrcErrorMessage::isValid() const
+{
+ return IrcMessage::isValid() && !error().isEmpty();
+}
+
+/*!
+ \class IrcInviteMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents an invite message.
+ */
+
+/*!
+ Constructs a new IrcInviteMessage with \a connection.
+ */
+IrcInviteMessage::IrcInviteMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Invite;
+}
+
+/*!
+ This property holds the user in question.
+
+ \par Access function:
+ \li QString <b>user</b>() const
+ */
+QString IrcInviteMessage::user() const
+{
+ Q_D(const IrcMessage);
+ return d->param(0);
+}
+
+/*!
+ This property holds the channel in question.
+
+ \par Access function:
+ \li QString <b>channel</b>() const
+ */
+QString IrcInviteMessage::channel() const
+{
+ Q_D(const IrcMessage);
+ return d->param(1);
+}
+
+bool IrcInviteMessage::isValid() const
+{
+ return IrcMessage::isValid() && !user().isEmpty() && !channel().isEmpty();
+}
+
+/*!
+ \class IrcJoinMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a join message.
+ */
+
+/*!
+ Constructs a new IrcJoinMessage with \a connection.
+ */
+IrcJoinMessage::IrcJoinMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Join;
+}
+
+/*!
+ This property holds the channel in question.
+
+ \par Access function:
+ \li QString <b>channel</b>() const
+ */
+QString IrcJoinMessage::channel() const
+{
+ Q_D(const IrcMessage);
+ return d->param(0);
+}
+
+bool IrcJoinMessage::isValid() const
+{
+ return IrcMessage::isValid() && !channel().isEmpty();
+}
+
+/*!
+ \class IrcKickMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a kick message.
+ */
+
+/*!
+ Constructs a new IrcKickMessage with \a connection.
+ */
+IrcKickMessage::IrcKickMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Kick;
+}
+
+/*!
+ This property holds the channel in question.
+
+ \par Access function:
+ \li QString <b>channel</b>() const
+ */
+QString IrcKickMessage::channel() const
+{
+ Q_D(const IrcMessage);
+ return d->param(0);
+}
+
+/*!
+ This property holds the user in question.
+
+ \par Access function:
+ \li QString <b>user</b>() const
+ */
+QString IrcKickMessage::user() const
+{
+ Q_D(const IrcMessage);
+ return d->param(1);
+}
+
+/*!
+ This property holds the optional kick reason.
+
+ \par Access function:
+ \li QString <b>reason</b>() const
+ */
+QString IrcKickMessage::reason() const
+{
+ Q_D(const IrcMessage);
+ return d->param(2);
+}
+
+bool IrcKickMessage::isValid() const
+{
+ return IrcMessage::isValid() && !channel().isEmpty() && !user().isEmpty();
+}
+
+/*!
+ \class IrcModeMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a mode message.
+ */
+
+/*!
+ \enum IrcModeMessage::Kind
+ This enum describes the kind of modes.
+ */
+
+/*!
+ \var IrcModeMessage::Channel
+ \brief Channel mode
+ */
+
+/*!
+ \var IrcModeMessage::User
+ \brief User mode
+ */
+
+/*!
+ Constructs a new IrcModeMessage with \a connection.
+ */
+IrcModeMessage::IrcModeMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Mode;
+}
+
+/*!
+ This property holds the target channel or user in question.
+
+ \par Access function:
+ \li QString <b>target</b>() const
+ */
+QString IrcModeMessage::target() const
+{
+ Q_D(const IrcMessage);
+ return d->param(0);
+}
+
+/*!
+ This property holds the channel or user mode.
+
+ \par Access function:
+ \li QString <b>mode</b>() const
+ */
+QString IrcModeMessage::mode() const
+{
+ Q_D(const IrcMessage);
+ return d->param(1);
+}
+
+/*!
+ This property holds the first mode argument.
+
+ \par Access function:
+ \li QString <b>argument</b>() const
+ */
+QString IrcModeMessage::argument() const
+{
+ Q_D(const IrcMessage);
+ return d->param(2);
+}
+
+/*!
+ \since 3.1
+
+ This property holds the all mode arguments.
+
+ \par Access function:
+ \li QStringList <b>arguments</b>() const
+ */
+QStringList IrcModeMessage::arguments() const
+{
+ Q_D(const IrcMessage);
+ return d->params().mid(2);
+}
+
+/*!
+ This property holds whether the message is a reply.
+
+ Mode messages are sent when a mode changes (\c false)
+ and when joining a channel (\c true).
+
+ \par Access function:
+ \li bool <b>isReply</b>() const
+
+ \sa Irc::RPL_CHANNELMODEIS
+ */
+bool IrcModeMessage::isReply() const
+{
+ Q_D(const IrcMessage);
+ int rpl = d->command().toInt();
+ return rpl == Irc::RPL_CHANNELMODEIS;
+}
+
+/*!
+ This property holds the kind of the mode.
+
+ \par Access function:
+ \li Kind <b>kind</b>() const
+ */
+IrcModeMessage::Kind IrcModeMessage::kind() const
+{
+ Q_D(const IrcMessage);
+ const IrcNetwork* network = d->connection->network();
+ const QStringList channelModes = network->channelModes(IrcNetwork::AllTypes);
+ const QString m = mode().remove(QLatin1Char('+')).remove(QLatin1Char('-'));
+ for (int i = 0; i < m.length(); ++i) {
+ if (!channelModes.contains(m.at(i)))
+ return User;
+ }
+ return Channel;
+}
+
+bool IrcModeMessage::isValid() const
+{
+ return IrcMessage::isValid() && !target().isEmpty() && !mode().isEmpty();
+}
+
+/*!
+ \class IrcMotdMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a message of the day.
+ */
+
+/*!
+ Constructs a new IrcMotdMessage with \a connection.
+ */
+IrcMotdMessage::IrcMotdMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Motd;
+ setCommand(QLatin1String("MOTD"));
+}
+
+/*!
+ This property holds the message of the day lines.
+
+ \par Access function:
+ \li QStringList <b>lines</b>() const
+ */
+QStringList IrcMotdMessage::lines() const
+{
+ Q_D(const IrcMessage);
+ return d->params().mid(1);
+}
+
+bool IrcMotdMessage::isValid() const
+{
+ Q_D(const IrcMessage);
+ return IrcMessage::isValid() && !d->params().isEmpty();
+}
+
+/*!
+ \class IrcNamesMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a names list message.
+ */
+
+/*!
+ Constructs a new IrcNamesMessage with \a connection.
+ */
+IrcNamesMessage::IrcNamesMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Names;
+ setCommand(QLatin1String("NAMES"));
+}
+
+/*!
+ This property holds the channel.
+
+ \par Access function:
+ \li QString <b>channel</b>() const
+ */
+QString IrcNamesMessage::channel() const
+{
+ Q_D(const IrcMessage);
+ return d->param(0);
+}
+
+/*!
+ This property holds the list of names.
+
+ \par Access function:
+ \li QStringList <b>names</b>() const
+ */
+QStringList IrcNamesMessage::names() const
+{
+ Q_D(const IrcMessage);
+ return d->params().mid(1);
+}
+
+bool IrcNamesMessage::isValid() const
+{
+ Q_D(const IrcMessage);
+ return IrcMessage::isValid() && !d->params().isEmpty();
+}
+
+/*!
+ \class IrcNickMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a nick message.
+ */
+
+/*!
+ Constructs a new IrcNickMessage with \a connection.
+ */
+IrcNickMessage::IrcNickMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Nick;
+}
+
+/*!
+ This property holds the old nick.
+
+ This property is provided for symmetry with \ref newNick
+ and is equal to \ref nick.
+
+ \par Access function:
+ \li QString <b>oldNick</b>() const
+ */
+QString IrcNickMessage::oldNick() const
+{
+ Q_D(const IrcMessage);
+ return d->nick();
+}
+
+/*!
+ This property holds the new nick.
+
+ \par Access function:
+ \li QString <b>newNick</b>() const
+ */
+QString IrcNickMessage::newNick() const
+{
+ Q_D(const IrcMessage);
+ return d->param(0);
+}
+
+bool IrcNickMessage::isValid() const
+{
+ return IrcMessage::isValid() && !newNick().isEmpty();
+}
+
+/*!
+ \class IrcNoticeMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a notice message.
+ */
+
+/*!
+ Constructs a new IrcNoticeMessage with \a connection.
+ */
+IrcNoticeMessage::IrcNoticeMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Notice;
+}
+
+/*!
+ This property holds the target channel or user in question.
+
+ \par Access function:
+ \li QString <b>target</b>() const
+ */
+QString IrcNoticeMessage::target() const
+{
+ Q_D(const IrcMessage);
+ return d->param(0);
+}
+
+/*!
+ This property holds the message content.
+
+ \par Access function:
+ \li QString <b>content</b>() const
+ */
+QString IrcNoticeMessage::content() const
+{
+ Q_D(const IrcMessage);
+ QString msg = d->param(1);
+ if (flags() & (Identified | Unidentified))
+ msg.remove(0, 1);
+ if (isReply()) {
+ msg.remove(0, 1);
+ msg.chop(1);
+ }
+ return msg;
+}
+
+/*!
+ \property bool IrcNoticeMessage::private
+ This property is \c true if the notice is private,
+ or \c false if it is a channel notice.
+
+ \par Access function:
+ \li bool <b>isPrivate</b>() const
+ */
+bool IrcNoticeMessage::isPrivate() const
+{
+ Q_D(const IrcMessage);
+ if (d->connection)
+ return !target().compare(d->connection->nickName(), Qt::CaseInsensitive);
+ return false;
+}
+
+/*!
+ \property bool IrcNoticeMessage::reply
+ This property is \c true if the message is a reply; otherwise \c false.
+
+ \par Access function:
+ \li bool <b>isReply</b>() const
+ */
+bool IrcNoticeMessage::isReply() const
+{
+ Q_D(const IrcMessage);
+ QString msg = d->param(1);
+ return msg.startsWith('\1') && msg.endsWith('\1');
+}
+
+bool IrcNoticeMessage::isValid() const
+{
+ return IrcMessage::isValid() && !target().isEmpty() && !content().isEmpty();
+}
+
+/*!
+ \class IrcNumericMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a numeric message.
+ */
+
+/*!
+ Constructs a new IrcNumericMessage with \a connection.
+ */
+IrcNumericMessage::IrcNumericMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Numeric;
+}
+
+/*!
+ This property holds the numeric code.
+
+ \par Access function:
+ \li int <b>code</b>() const
+ */
+int IrcNumericMessage::code() const
+{
+ Q_D(const IrcMessage);
+ bool ok = false;
+ int number = d->command().toInt(&ok);
+ return ok ? number : -1;
+}
+
+bool IrcNumericMessage::isValid() const
+{
+ return IrcMessage::isValid() && code() != -1;
+}
+
+/*!
+ \class IrcPartMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a part message.
+ */
+
+/*!
+ Constructs a new IrcPartMessage with \a connection.
+ */
+IrcPartMessage::IrcPartMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Part;
+}
+
+/*!
+ This property holds the channel in question.
+
+ \par Access function:
+ \li QString <b>channel</b>() const
+ */
+QString IrcPartMessage::channel() const
+{
+ Q_D(const IrcMessage);
+ return d->param(0);
+}
+
+/*!
+ This property holds the optional part reason.
+
+ \par Access function:
+ \li QString <b>reason</b>() const
+ */
+QString IrcPartMessage::reason() const
+{
+ Q_D(const IrcMessage);
+ return d->param(1);
+}
+
+bool IrcPartMessage::isValid() const
+{
+ return IrcMessage::isValid() && !channel().isEmpty();
+}
+
+/*!
+ \class IrcPingMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a ping message.
+ */
+
+/*!
+ Constructs a new IrcPingMessage with \a connection.
+ */
+IrcPingMessage::IrcPingMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Ping;
+}
+
+/*!
+ This property holds the optional message argument.
+
+ \par Access function:
+ \li QString <b>argument</b>() const
+ */
+QString IrcPingMessage::argument() const
+{
+ Q_D(const IrcMessage);
+ return d->param(0);
+}
+
+bool IrcPingMessage::isValid() const
+{
+ return IrcMessage::isValid();
+}
+
+/*!
+ \class IrcPongMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a pong message.
+ */
+
+/*!
+ Constructs a new IrcPongMessage with \a connection.
+ */
+IrcPongMessage::IrcPongMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Pong;
+}
+
+/*!
+ This property holds the optional message argument.
+
+ \par Access function:
+ \li QString <b>argument</b>() const
+ */
+QString IrcPongMessage::argument() const
+{
+ Q_D(const IrcMessage);
+ return d->param(1);
+}
+
+bool IrcPongMessage::isValid() const
+{
+ return IrcMessage::isValid();
+}
+
+/*!
+ \class IrcPrivateMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a private message.
+ */
+
+/*!
+ Constructs a new IrcPrivateMessage with \a connection.
+ */
+IrcPrivateMessage::IrcPrivateMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Private;
+}
+
+/*!
+ This property holds the target channel or user in question.
+
+ \par Access function:
+ \li QString <b>target</b>() const
+ */
+QString IrcPrivateMessage::target() const
+{
+ Q_D(const IrcMessage);
+ return d->param(0);
+}
+
+/*!
+ This property holds the message content.
+
+ \par Access function:
+ \li QString <b>content</b>() const
+ */
+QString IrcPrivateMessage::content() const
+{
+ Q_D(const IrcMessage);
+ QString msg = d->param(1);
+ if (flags() & (Identified | Unidentified))
+ msg.remove(0, 1);
+ const bool act = isAction();
+ const bool req = isRequest();
+ if (act) msg.remove(0, 8);
+ if (req) msg.remove(0, 1);
+ if (act || req) msg.chop(1);
+ return msg;
+}
+
+/*!
+ \property bool IrcPrivateMessage::private
+ This property is \c true if the message is private,
+ or \c false if it is a channel message.
+
+ \par Access function:
+ \li bool <b>isPrivate</b>() const
+ */
+bool IrcPrivateMessage::isPrivate() const
+{
+ Q_D(const IrcMessage);
+ if (d->connection)
+ return !target().compare(d->connection->nickName(), Qt::CaseInsensitive);
+ return false;
+}
+
+/*!
+ \property bool IrcPrivateMessage::action
+ This property is \c true if the message is an action; otherwise \c false.
+
+ \par Access function:
+ \li bool <b>isAction</b>() const
+ */
+bool IrcPrivateMessage::isAction() const
+{
+ Q_D(const IrcMessage);
+ QString msg = d->param(1);
+ if (flags() & (Identified | Unidentified))
+ msg.remove(0, 1);
+ return msg.startsWith("\1ACTION ") && msg.endsWith('\1');
+}
+
+/*!
+ \property bool IrcPrivateMessage::request
+ This property is \c true if the message is a request; otherwise \c false.
+
+ \par Access function:
+ \li bool <b>isRequest</b>() const
+ */
+bool IrcPrivateMessage::isRequest() const
+{
+ Q_D(const IrcMessage);
+ QString msg = d->param(1);
+ if (flags() & (Identified | Unidentified))
+ msg.remove(0, 1);
+ return msg.startsWith('\1') && msg.endsWith('\1') && !isAction();
+}
+
+bool IrcPrivateMessage::isValid() const
+{
+ return IrcMessage::isValid() && !target().isEmpty() && !content().isEmpty();
+}
+
+/*!
+ \class IrcQuitMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a quit message.
+ */
+
+/*!
+ Constructs a new IrcQuitMessage with \a connection.
+ */
+IrcQuitMessage::IrcQuitMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Quit;
+}
+
+/*!
+ This property holds the optional quit reason.
+
+ \par Access function:
+ \li QString <b>reason</b>() const
+ */
+QString IrcQuitMessage::reason() const
+{
+ Q_D(const IrcMessage);
+ return d->param(0);
+}
+
+bool IrcQuitMessage::isValid() const
+{
+ return IrcMessage::isValid();
+}
+
+/*!
+ \class IrcTopicMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a topic message.
+ */
+
+/*!
+ Constructs a new IrcTopicMessage with \a connection.
+ */
+IrcTopicMessage::IrcTopicMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = Topic;
+}
+
+/*!
+ This property holds the channel in question.
+
+ \par Access function:
+ \li QString <b>channel</b>() const
+ */
+QString IrcTopicMessage::channel() const
+{
+ Q_D(const IrcMessage);
+ return d->param(0);
+}
+
+/*!
+ This property holds the new channel topic.
+
+ \par Access function:
+ \li QString <b>topic</b>() const
+ */
+QString IrcTopicMessage::topic() const
+{
+ Q_D(const IrcMessage);
+ return d->param(1);
+}
+
+/*!
+ This property holds whether the message is a reply.
+
+ Topic messages are sent in three situations:
+ \li as a notification of a topic change (\c false),
+ \li as a reply when joining a channel (\c true), or
+ \li as a reply when explicitly querying the channel topic (\c true).
+
+ \par Access function:
+ \li bool <b>isReply</b>() const
+
+ \sa Irc::RPL_TOPIC, Irc::RPL_NOTOPIC, IrcTopicCommand
+ */
+bool IrcTopicMessage::isReply() const
+{
+ Q_D(const IrcMessage);
+ int rpl = d->command().toInt();
+ return rpl == Irc::RPL_TOPIC || rpl == Irc::RPL_NOTOPIC;
+}
+
+bool IrcTopicMessage::isValid() const
+{
+ return IrcMessage::isValid() && !channel().isEmpty();
+}
+
+/*!
+ \since 3.1
+ \class IrcWhoReplyMessage ircmessage.h <IrcMessage>
+ \ingroup message
+ \brief Represents a reply message to a WHO command.
+ */
+
+/*!
+ Constructs a new IrcWhoReplyMessage with \a connection.
+ */
+IrcWhoReplyMessage::IrcWhoReplyMessage(IrcConnection* connection) : IrcMessage(connection)
+{
+ Q_D(IrcMessage);
+ d->type = WhoReply;
+}
+
+/*!
+ This property holds the mask.
+
+ \par Access function:
+ \li QString <b>mask</b>() const
+ */
+QString IrcWhoReplyMessage::mask() const
+{
+ Q_D(const IrcMessage);
+ return d->param(0);
+}
+
+/*!
+ This property holds the server of the user.
+
+ \par Access function:
+ \li QString <b>server</b>() const
+ */
+QString IrcWhoReplyMessage::server() const
+{
+ Q_D(const IrcMessage);
+ return d->param(1);
+}
+
+/*!
+ \property bool IrcWhoReplyMessage::away
+ This property holds whether the user is away.
+
+ \par Access function:
+ \li QString <b>isAway</b>() const
+ */
+bool IrcWhoReplyMessage::isAway() const
+{
+ Q_D(const IrcMessage);
+ return d->param(2).contains("G");
+}
+
+/*!
+ \property bool IrcWhoReplyMessage::servOp
+ This property holds whether the user is a server operator.
+
+ \par Access function:
+ \li QString <b>isServOp</b>() const
+ */
+bool IrcWhoReplyMessage::isServOp() const
+{
+ Q_D(const IrcMessage);
+ return d->param(2).contains("*");
+}
+
+/*!
+ This property holds the real name of the user.
+
+ \par Access function:
+ \li QString <b>realName</b>() const
+ */
+QString IrcWhoReplyMessage::realName() const
+{
+ Q_D(const IrcMessage);
+ return d->param(3);
+}
+
+bool IrcWhoReplyMessage::isValid() const
+{
+ return IrcMessage::isValid() && !mask().isEmpty() && !nick().isEmpty();
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug debug, IrcMessage::Type type)
+{
+ const int index = IrcMessage::staticMetaObject.indexOfEnumerator("Type");
+ QMetaEnum enumerator = IrcMessage::staticMetaObject.enumerator(index);
+ const char* key = enumerator.valueToKey(type);
+ debug << (key ? key : "Unknown");
+ return debug;
+}
+
+QDebug operator<<(QDebug debug, IrcMessage::Flag flag)
+{
+ const int index = IrcMessage::staticMetaObject.indexOfEnumerator("Flag");
+ QMetaEnum enumerator = IrcMessage::staticMetaObject.enumerator(index);
+ const char* key = enumerator.valueToKey(flag);
+ debug << (key ? key : "None");
+ return debug;
+}
+
+QDebug operator<<(QDebug debug, IrcMessage::Flags flags)
+{
+ QStringList lst;
+ if (flags == IrcMessage::None)
+ lst << "None";
+ if (flags & IrcMessage::Own)
+ lst << "Own";
+ if (flags & IrcMessage::Identified)
+ lst << "Identified";
+ if (flags & IrcMessage::Unidentified)
+ lst << "Unidentified";
+ debug.nospace() << '(' << qPrintable(lst.join("|")) << ')';
+ return debug;
+}
+
+QDebug operator<<(QDebug debug, IrcModeMessage::Kind kind)
+{
+ const int index = IrcModeMessage::staticMetaObject.indexOfEnumerator("Kind");
+ QMetaEnum enumerator = IrcModeMessage::staticMetaObject.enumerator(index);
+ const char* key = enumerator.valueToKey(kind);
+ debug << (key ? key : "Unknown");
+ return debug;
+}
+
+QDebug operator<<(QDebug debug, const IrcMessage* message)
+{
+ if (!message)
+ return debug << "IrcMessage(0x0) ";
+ debug.nospace() << message->metaObject()->className() << '(' << (void*) message;
+ if (!message->objectName().isEmpty())
+ debug.nospace() << ", name=" << qPrintable(message->objectName());
+ debug.nospace() << ", flags=" << message->flags();
+ if (!message->prefix().isEmpty())
+ debug.nospace() << ", prefix=" << qPrintable(message->prefix());
+ if (!message->command().isEmpty())
+ debug.nospace() << ", command=" << qPrintable(message->command());
+ debug.nospace() << ')';
+ return debug.space();
+}
+#endif // QT_NO_DEBUG_STREAM
+
+#include "moc_ircmessage.cpp"
+
+IRC_END_NAMESPACE
diff --git a/libcommuni/src/core/ircmessage_p.cpp b/libcommuni/src/core/ircmessage_p.cpp
new file mode 100644
index 0000000..e5fdd24
--- /dev/null
+++ b/libcommuni/src/core/ircmessage_p.cpp
@@ -0,0 +1,284 @@
+/*
+ Copyright (C) 2008-2014 The Communi Project
+
+ You may use this file under the terms of BSD license as follows:
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "ircmessage_p.h"
+#include "ircmessagedecoder_p.h"
+
+IRC_BEGIN_NAMESPACE
+
+#ifndef IRC_DOXYGEN
+IrcMessagePrivate::IrcMessagePrivate() :
+ connection(0), type(IrcMessage::Unknown), timeStamp(QDateTime::currentDateTime()), encoding("ISO-8859-15"), flags(-1)
+{
+}
+
+QString IrcMessagePrivate::prefix() const
+{
+ if (!m_prefix.isExplicit() && m_prefix.isNull() && !data.prefix.isNull()) {
+ if (data.prefix.startsWith(':')) {
+ if (data.prefix.length() > 1)
+ m_prefix = decode(data.prefix.mid(1), encoding);
+ } else {
+ // empty (not null)
+ m_prefix = QString("");
+ }
+ }
+ return m_prefix.value();
+}
+
+void IrcMessagePrivate::setPrefix(const QString& prefix)
+{
+ m_prefix.setValue(prefix);
+ m_nick.clear();
+ m_ident.clear();
+ m_host.clear();
+}
+
+QString IrcMessagePrivate::nick() const
+{
+ if (m_nick.isNull())
+ parsePrefix(prefix(), &m_nick, &m_ident, &m_host);
+ return m_nick;
+}
+
+QString IrcMessagePrivate::ident() const
+{
+ if (m_ident.isNull())
+ parsePrefix(prefix(), &m_nick, &m_ident, &m_host);
+ return m_ident;
+}
+
+QString IrcMessagePrivate::host() const
+{
+ if (m_host.isNull())
+ parsePrefix(prefix(), &m_nick, &m_ident, &m_host);
+ return m_host;
+}
+
+QString IrcMessagePrivate::command() const
+{
+ if (!m_command.isExplicit() && m_command.isNull() && !data.command.isNull())
+ m_command = decode(data.command, encoding);
+ return m_command.value();
+}
+
+void IrcMessagePrivate::setCommand(const QString& command)
+{
+ m_command.setValue(command);
+}
+
+QStringList IrcMessagePrivate::params() const
+{
+ if (!m_params.isExplicit() && m_params.isNull() && !data.params.isEmpty()) {
+ QStringList params;
+ foreach (const QByteArray& param, data.params)
+ params += decode(param, encoding);
+ m_params = params;
+ }
+ return m_params.value();
+}
+
+QString IrcMessagePrivate::param(int index) const
+{
+ return params().value(index);
+}
+
+void IrcMessagePrivate::setParams(const QStringList& params)
+{
+ m_params.setValue(params);
+}
+
+QVariantMap IrcMessagePrivate::tags() const
+{
+ if (!m_tags.isExplicit() && m_tags.isNull() && !data.tags.isEmpty()) {
+ QVariantMap tags;
+ QMap<QByteArray, QByteArray>::const_iterator it;
+ for (it = data.tags.constBegin(); it != data.tags.constEnd(); ++it)
+ tags.insert(decode(it.key(), encoding), decode(it.value(), encoding));
+ m_tags = tags;
+ }
+ return m_tags.value();
+}
+
+void IrcMessagePrivate::setTags(const QVariantMap& tags)
+{
+ m_tags.setValue(tags);
+}
+
+QByteArray IrcMessagePrivate::content() const
+{
+ if (m_prefix.isExplicit() || m_command.isExplicit() || m_params.isExplicit() || m_tags.isExplicit()) {
+ QByteArray data;
+
+ // format <tags>
+ QStringList tt;
+ const QVariantMap t = tags();
+ for (QVariantMap::const_iterator it = t.begin(); it != t.end(); ++it)
+ tt += it.key() + QLatin1Char('=') + it.value().toString();
+ if (!tt.isEmpty())
+ data += '@' + tt.join(QLatin1String(";")).toUtf8() + ' ';
+
+ // format <prefix>
+ const QString p = prefix();
+ if (!p.isEmpty())
+ data += ':' + p.toUtf8() + ' ';
+
+ // format <command>
+ data += command().toUtf8();
+
+ // format <params>
+ foreach (const QString& param, params()) {
+ data += ' ';
+ if (param.contains(QLatin1Char(' ')))
+ data += ':';
+ data += param.toUtf8();
+ }
+ return data;
+ }
+
+ return data.content;
+}
+
+void IrcMessagePrivate::invalidate()
+{
+ m_nick.clear();
+ m_ident.clear();
+ m_host.clear();
+
+ m_prefix.clear();
+ m_command.clear();
+ m_params.clear();
+ m_tags.clear();
+}
+
+IrcMessageData IrcMessageData::fromData(const QByteArray& data)
+{
+ IrcMessageData message;
+ message.content = data;
+
+ // From RFC 1459:
+ // <message> ::= [':' <prefix> <SPACE> ] <command> <params> <crlf>
+ // <prefix> ::= <servername> | <nick> [ '!' <user> ] [ '@' <host> ]
+ // <command> ::= <letter> { <letter> } | <number> <number> <number>
+ // <SPACE> ::= ' ' { ' ' }
+ // <params> ::= <SPACE> [ ':' <trailing> | <middle> <params> ]
+ // <middle> ::= <Any *non-empty* sequence of octets not including SPACE
+ // or NUL or CR or LF, the first of which may not be ':'>
+ // <trailing> ::= <Any, possibly *empty*, sequence of octets not including
+ // NUL or CR or LF>
+
+ // IRCv3.2 Message Tags
+ // <message> ::= ['@' <tags> <SPACE>] [':' <prefix> <SPACE> ] <command> <params> <crlf>
+ // <tags> ::= <tag> [';' <tag>]*
+ // <tag> ::= <key> ['=' <value>]
+ // <key> ::= [ <vendor> '/' ] <sequence of letters, digits, hyphens (`-`)>
+ // <value> ::= <sequence of any characters except NUL, BELL, CR, LF, semicolon (`;`) and SPACE>
+ // <vendor> ::= <host>
+
+ QByteArray process = data;
+
+ // parse <tags>
+ if (process.startsWith('@')) {
+ process.remove(0, 1);
+ QByteArray tags = process.left(process.indexOf(' '));
+ foreach (const QByteArray& tag, tags.split(';')) {
+ const int idx = tag.indexOf('=');
+ if (idx != -1)
+ message.tags.insert(tag.left(idx), tag.mid(idx + 1));
+ else
+ message.tags.insert(tag, QByteArray());
+ }
+ process.remove(0, tags.length() + 1);
+ }
+
+ // parse <prefix>
+ if (process.startsWith(':')) {
+ message.prefix = process.left(process.indexOf(' '));
+ process.remove(0, message.prefix.length() + 1);
+ } else {
+ // empty (not null)
+ message.prefix = QByteArray("");
+ }
+
+ // parse <command>
+ message.command = process.mid(0, process.indexOf(' '));
+ process.remove(0, message.command.length() + 1);
+
+ // parse <params>
+ while (!process.isEmpty()) {
+ if (process.startsWith(':')) {
+ process.remove(0, 1);
+ message.params += process;
+ process.clear();
+ } else {
+ QByteArray param = process.mid(0, process.indexOf(' '));
+ process.remove(0, param.length() + 1);
+ message.params += param;
+ }
+ }
+
+ return message;
+}
+
+QString IrcMessagePrivate::decode(const QByteArray& data, const QByteArray& encoding)
+{
+ // TODO: not thread safe
+ static IrcMessageDecoder decoder;
+ return decoder.decode(data, encoding);
+}
+
+bool IrcMessagePrivate::parsePrefix(const QString& prefix, QString* nick, QString* ident, QString* host)
+{
+ const QString trimmed = prefix.trimmed();
+ if (trimmed.contains(QLatin1Char(' ')))
+ return false;
+
+ const int len = trimmed.length();
+ const int ex = trimmed.indexOf(QLatin1Char('!'));
+ const int at = trimmed.indexOf(QLatin1Char('@'));
+
+ if (ex == -1 && at == -1) {
+ if (nick) *nick = trimmed;
+ } else if (ex > 0 && at > 0 && ex + 1 < at && at < len - 1) {
+ if (nick) *nick = trimmed.mid(0, ex);
+ if (ident) *ident = trimmed.mid(ex + 1, at - ex - 1);
+ if (host) *host = trimmed.mid(at + 1);
+ } else if (ex > 0 && ex < len - 1 && at == -1) {
+ if (nick) *nick = trimmed.mid(0, ex);
+ if (ident) *ident = trimmed.mid(ex + 1);
+ } else if (at > 0 && at < len - 1 && ex == -1) {
+ if (nick) *nick = trimmed.mid(0, at);
+ if (host) *host = trimmed.mid(at + 1);
+ } else {
+ return false;
+ }
+ return true;
+}
+#endif // IRC_DOXYGEN
+
+IRC_END_NAMESPACE
diff --git a/libcommuni/src/core/ircmessagebuilder.cpp b/libcommuni/src/core/ircmessagebuilder.cpp
new file mode 100644
index 0000000..298ac79
--- /dev/null
+++ b/libcommuni/src/core/ircmessagebuilder.cpp
@@ -0,0 +1,121 @@
+/*
+ Copyright (C) 2008-2014 The Communi Project
+
+ You may use this file under the terms of BSD license as follows:
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "ircmessagebuilder_p.h"
+#include "ircmessage.h"
+#include "irc.h"
+
+IRC_BEGIN_NAMESPACE
+
+#ifndef IRC_DOXYGEN
+IrcMessageBuilder::IrcMessageBuilder(IrcConnection* connection)
+{
+ d.connection = connection;
+ d.message = 0;
+}
+
+void IrcMessageBuilder::processMessage(IrcNumericMessage* message)
+{
+ switch (message->code()) {
+ case Irc::RPL_MOTDSTART:
+ d.message = new IrcMotdMessage(d.connection);
+ d.message->setPrefix(message->prefix());
+ d.message->setParameters(QStringList(message->parameters().value(0)));
+ break;
+ case Irc::RPL_MOTD:
+ d.message->setParameters(d.message->parameters() << message->parameters().value(1));
+ break;
+ case Irc::RPL_ENDOFMOTD:
+ d.message->setTimeStamp(message->timeStamp());
+ emit messageReceived(d.message);
+ d.message = 0;
+ break;
+
+ case Irc::RPL_NAMREPLY: {
+ if (!d.message)
+ d.message = new IrcNamesMessage(d.connection);
+ d.message->setPrefix(message->prefix());
+ int count = message->parameters().count();
+ QString channel = message->parameters().value(count - 2);
+ QStringList names = d.message->parameters().mid(1);
+ names += message->parameters().value(count - 1).split(QLatin1Char(' '), QString::SkipEmptyParts);
+ d.message->setParameters(QStringList() << channel << names);
+ break;
+ }
+ case Irc::RPL_ENDOFNAMES:
+ d.message->setTimeStamp(message->timeStamp());
+ emit messageReceived(d.message);
+ d.message = 0;
+ break;
+
+ case Irc::RPL_TOPIC:
+ case Irc::RPL_NOTOPIC:
+ d.message = new IrcTopicMessage(d.connection);
+ d.message->setPrefix(message->prefix());
+ d.message->setTimeStamp(message->timeStamp());
+ d.message->setCommand(QString::number(message->code()));
+ d.message->setParameters(QStringList() << message->parameters().value(1) << message->parameters().value(2));
+ emit messageReceived(d.message);
+ d.message = 0;
+ break;
+
+ case Irc::RPL_WHOREPLY: {
+ d.message = new IrcWhoReplyMessage(d.connection);
+ d.message->setPrefix(message->parameters().value(5) // nick
+ + QLatin1Char('!') + message->parameters().value(2) // ident
+ + QLatin1Char('@') + message->parameters().value(3)); // host
+ d.message->setTimeStamp(message->timeStamp());
+ d.message->setCommand(QString::number(message->code()));
+ d.message->setParameters(QStringList() << message->parameters().value(1) // mask
+ << message->parameters().value(4) // server
+ << message->parameters().value(6)); // status
+ QString last = message->parameters().value(7);
+ int index = last.indexOf(QLatin1Char(' ')); // ignore hopcount
+ if (index != -1)
+ d.message->setParameters(d.message->parameters() << last.mid(index + 1)); // real name
+ emit messageReceived(d.message);
+ d.message = 0;
+ break;
+ }
+
+ case Irc::RPL_CHANNELMODEIS:
+ d.message = new IrcModeMessage(d.connection);
+ d.message->setPrefix(message->prefix());
+ d.message->setTimeStamp(message->timeStamp());
+ d.message->setCommand(QString::number(message->code()));
+ d.message->setParameters(message->parameters().mid(1));
+ emit messageReceived(d.message);
+ d.message = 0;
+ break;
+ }
+}
+#endif // IRC_DOXYGEN
+
+#include "moc_ircmessagebuilder_p.cpp"
+
+IRC_END_NAMESPACE
diff --git a/libcommuni/src/core/ircmessagedecoder.cpp b/libcommuni/src/core/ircmessagedecoder.cpp
new file mode 100644
index 0000000..1e2eb25
--- /dev/null
+++ b/libcommuni/src/core/ircmessagedecoder.cpp
@@ -0,0 +1,73 @@
+/*
+ Copyright (C) 2008-2014 The Communi Project
+
+ You may use this file under the terms of BSD license as follows:
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "ircmessagedecoder_p.h"
+#include <IrcGlobal>
+#include <QSet>
+
+#ifndef IRC_DOXYGEN
+extern "C" {
+ int IsUTF8Text(const char* utf8, int len);
+}
+
+IRC_BEGIN_NAMESPACE
+
+IRC_CORE_EXPORT bool irc_is_supported_encoding(const QByteArray& encoding)
+{
+ static QSet<QByteArray> codecs = QTextCodec::availableCodecs().toSet();
+ return codecs.contains(encoding);
+}
+
+IrcMessageDecoder::IrcMessageDecoder()
+{
+ initialize();
+}
+
+IrcMessageDecoder::~IrcMessageDecoder()
+{
+ uninitialize();
+}
+
+QString IrcMessageDecoder::decode(const QByteArray& data, const QByteArray& encoding) const
+{
+ QTextCodec* codec = 0;
+ if (IsUTF8Text(data, data.length())) {
+ codec = QTextCodec::codecForName("UTF-8");
+ } else {
+ QByteArray name = codecForData(data);
+ codec = QTextCodec::codecForName(name);
+ }
+
+ if (!codec)
+ codec = QTextCodec::codecForName(encoding);
+ Q_ASSERT(codec);
+ return codec->toUnicode(data);
+}
+#endif // IRC_DOXYGEN
+
+IRC_END_NAMESPACE
diff --git a/libcommuni/src/core/ircmessagedecoder_icu.cpp b/libcommuni/src/core/ircmessagedecoder_icu.cpp
new file mode 100644
index 0000000..2c303fc
--- /dev/null
+++ b/libcommuni/src/core/ircmessagedecoder_icu.cpp
@@ -0,0 +1,68 @@
+/*
+ Copyright (C) 2008-2014 The Communi Project
+
+ You may use this file under the terms of BSD license as follows:
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "ircmessagedecoder_p.h"
+#include <unicode/ucsdet.h>
+
+IRC_BEGIN_NAMESPACE
+
+#ifndef IRC_DOXYGEN
+#define UCSD(x) reinterpret_cast<UCharsetDetector*>(x)
+
+void IrcMessageDecoder::initialize()
+{
+ UErrorCode status = U_ZERO_ERROR;
+ d.detector = ucsdet_open(&status);
+ if (U_FAILURE(status))
+ qWarning("IrcMessageDecoder: ICU initialization failed: %s", u_errorName(status));
+}
+
+void IrcMessageDecoder::uninitialize()
+{
+ ucsdet_close(UCSD(d.detector));
+}
+
+QByteArray IrcMessageDecoder::codecForData(const QByteArray &data) const
+{
+ QByteArray encoding;
+ UErrorCode status = U_ZERO_ERROR;
+ if (d.detector) {
+ ucsdet_setText(UCSD(d.detector), data.constData(), data.length(), &status);
+ if (!U_FAILURE(status)) {
+ const UCharsetMatch* match = ucsdet_detect(UCSD(d.detector), &status);
+ if (match && !U_FAILURE(status))
+ encoding = ucsdet_getName(match, &status);
+ }
+ }
+ if (U_FAILURE(status))
+ qWarning("IrcMessageDecoder::codecForData() failed: %s", u_errorName(status));
+ return encoding;
+}
+#endif // IRC_DOXYGEN
+
+IRC_END_NAMESPACE
diff --git a/libcommuni/src/core/ircmessagedecoder_uchardet.cpp b/libcommuni/src/core/ircmessagedecoder_uchardet.cpp
new file mode 100644
index 0000000..8f0be8b
--- /dev/null
+++ b/libcommuni/src/core/ircmessagedecoder_uchardet.cpp
@@ -0,0 +1,56 @@
+/*
+ Copyright (C) 2008-2014 The Communi Project
+
+ You may use this file under the terms of BSD license as follows:
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "ircmessagedecoder_p.h"
+#include "uchardet.h"
+
+IRC_BEGIN_NAMESPACE
+
+#ifndef IRC_DOXYGEN
+#define UCD(x) reinterpret_cast<uchardet_t>(x)
+
+void IrcMessageDecoder::initialize()
+{
+ d.detector = uchardet_new();
+}
+
+void IrcMessageDecoder::uninitialize()
+{
+ uchardet_delete(UCD(d.detector));
+}
+
+QByteArray IrcMessageDecoder::codecForData(const QByteArray &data) const
+{
+ uchardet_reset(UCD(d.detector));
+ uchardet_handle_data(UCD(d.detector), data.constData(), data.length());
+ uchardet_data_end(UCD(d.detector));
+ return uchardet_get_charset(UCD(d.detector));
+}
+#endif // IRC_DOXYGEN
+
+IRC_END_NAMESPACE
diff --git a/libcommuni/src/core/ircnetwork.cpp b/libcommuni/src/core/ircnetwork.cpp
new file mode 100644
index 0000000..d73a9be
--- /dev/null
+++ b/libcommuni/src/core/ircnetwork.cpp
@@ -0,0 +1,687 @@
+/*
+ Copyright (C) 2008-2014 The Communi Project
+
+ You may use this file under the terms of BSD license as follows:
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "ircnetwork.h"
+#include "ircnetwork_p.h"
+#include "ircconnection_p.h"
+#include "ircprotocol.h"
+#include "ircconnection.h"
+#include "irccommand.h"
+#include <QMetaEnum>
+#include <QPointer>
+
+IRC_BEGIN_NAMESPACE
+
+/*!
+ \file ircnetwork.h
+ \brief \#include &lt;IrcNetwork&gt;
+ */
+
+/*!
+ \class IrcNetwork ircnetwork.h IrcNetwork
+ \ingroup core
+ \brief Provides network information and capability management.
+
+ \section info Network information
+
+ IrcNetwork provides various information about the IRC network of a
+ \ref IrcConnection::network "connection". This includes the \ref name
+ "network name", supported \ref channelTypes "channel types", channel
+ user \ref modes "mode characters" and \ref prefixes "prefix letters",
+ and various \ref numericLimit "numeric limitations", such as the maximum
+ nick, channel, topic and message lengths.
+
+ Furthermore, IrcNetwork provides convenient methods for converting channel user
+ \ref modeToPrefix() "modes to prefixes" and \ref prefixToMode() "vice versa" and
+ testing whether a target name \ref isChannel() "is a channel".
+
+ \note Most properties have empty values until the network
+ information has been \ref initialized.
+
+ \section capabilities Capability management
+
+ IrcNetwork also provides means for capability management. It maintais a
+ list of \ref availableCapabilities "available" and \ref activeCapabilities
+ "active" capabilities, automatically \ref requestedCapabilities "requests"
+ desired capabilities, and provides convenient methods for \ref requestCapability()
+ "manual capability requests".
+
+ \sa IrcConnection::network
+ */
+
+/*!
+ \fn void IrcNetwork::requestingCapabilities()
+
+ This signal is emitted when capabilities are being requested.
+
+ Normally it is enough to add the desired capabilities to the
+ list of \ref requestedCapabilities "requested capabilities".
+ Connect to this signal in order to implement more advanced
+ capability handling eg. based on which capabilities are \ref
+ availableCapabilities "available".
+
+ \sa requestedCapabilities, availableCapabilities
+ */
+
+/*!
+ \enum IrcNetwork::ModeType
+ This enum describes the channel mode types.
+ */
+
+/*!
+ \var IrcNetwork::TypeA
+ \brief Type A modes
+
+ Modes that add or remove an address to or from a list.
+ These modes always take a parameter when sent by the server to a
+ client; when sent by a client, they may be specified without a
+ parameter, which requests the server to display the current
+ contents of the corresponding list on the channel to the client.
+ */
+
+/*!
+ \var IrcNetwork::TypeB
+ \brief Type B modes
+
+ Modes that change a setting on the channel. These modes
+ always take a parameter.
+ */
+
+/*!
+ \var IrcNetwork::TypeC
+ \brief Type C modes
+
+ Modes that change a setting on the channel. These modes
+ take a parameter only when set; the parameter is absent when the
+ mode is removed both in the client's and server's MODE command.
+ */
+
+/*!
+ \var IrcNetwork::TypeD
+ \brief Type D modes
+
+ Modes that change a setting on the channel. These modes
+ never take a parameter.
+ */
+
+/*!
+ \var IrcNetwork::AllTypes
+ \brief All type modes
+ */
+
+/*!
+ \enum IrcNetwork::Limit
+ This enum describes the numeric limit types.
+ */
+
+/*!
+ \var IrcNetwork::NickLength
+ \brief The maximum nick name length
+ */
+
+/*!
+ \var IrcNetwork::ChannelLength
+ \brief The maximum channel name length
+ */
+
+/*!
+ \var IrcNetwork::TopicLength
+ \brief The maximum channel topic length
+ */
+
+/*!
+ \var IrcNetwork::MessageLength
+ \brief The maximum message length
+ */
+
+/*!
+ \var IrcNetwork::KickReasonLength
+ \brief The maximum kick reason length
+ */
+
+/*!
+ \var IrcNetwork::AwayReasonLength
+ \brief The maximum away reason length
+ */
+
+/*!
+ \var IrcNetwork::ModeCount
+ \brief The maximum number of channel modes allowed per mode command
+ */
+
+#ifndef IRC_DOXYGEN
+IrcNetworkPrivate::IrcNetworkPrivate() : q_ptr(0), initialized(false)
+{
+}
+
+static QHash<QString, int> numericValues(const QString& parameter)
+{
+ QHash<QString, int> values;
+ const QStringList keyValues = parameter.split(",", QString::SkipEmptyParts);
+ foreach (const QString& keyValue, keyValues)
+ values.insert(keyValue.section(":", 0, 0), keyValue.section(":", 1, 1).toInt());
+ return values;
+}
+
+void IrcNetworkPrivate::setInfo(const QHash<QString, QString>& info)
+{
+ Q_Q(IrcNetwork);
+ if (info.contains("NETWORK"))
+ setName(info.value("NETWORK"));
+ if (info.contains("PREFIX")) {
+ const QString pfx = info.value("PREFIX");
+ setModes(pfx.mid(1, pfx.indexOf(')') - 1).split("", QString::SkipEmptyParts));
+ setPrefixes(pfx.mid(pfx.indexOf(')') + 1).split("", QString::SkipEmptyParts));
+ }
+ if (info.contains("CHANTYPES"))
+ setChannelTypes(info.value("CHANTYPES").split("", QString::SkipEmptyParts));
+
+ // TODO:
+ if (info.contains("NICKLEN"))
+ numericLimits.insert("NICKLEN", info.value("NICKLEN").toInt());
+ if (info.contains("CHANNELLEN"))
+ numericLimits.insert("CHANNELLEN", info.value("CHANNELLEN").toInt());
+ if (info.contains("TOPICLEN"))
+ numericLimits.insert("TOPICLEN", info.value("TOPICLEN").toInt());
+ if (info.contains("KICKLEN"))
+ numericLimits.insert("KICKLEN", info.value("KICKLEN").toInt());
+ if (info.contains("AWAYLEN"))
+ numericLimits.insert("AWAYLEN", info.value("AWAYLEN").toInt());
+ if (info.contains("MODES"))
+ numericLimits.insert("MODES", info.value("MODES").toInt());
+ if (info.contains("CHANMODES"))
+ channelModes = info.value("CHANMODES").split(",", QString::SkipEmptyParts);
+ if (info.contains("MAXLIST"))
+ modeLimits = numericValues(info.value("MAXLIST"));
+ if (info.contains("CHANLIMIT"))
+ channelLimits = numericValues(info.value("CHANLIMIT"));
+ if (info.contains("TARGMAX"))
+ targetLimits = numericValues(info.value("TARGMAX"));
+
+ if (!initialized) {
+ initialized = true;
+ emit q->initialized();
+ }
+}
+
+void IrcNetworkPrivate::setAvailableCapabilities(const QSet<QString>& capabilities)
+{
+ Q_Q(IrcNetwork);
+ if (availableCaps != capabilities) {
+ availableCaps = capabilities;
+ emit q->availableCapabilitiesChanged(availableCaps.toList());
+ }
+}
+
+void IrcNetworkPrivate::setActiveCapabilities(const QSet<QString>& capabilities)
+{
+ Q_Q(IrcNetwork);
+ if (activeCaps != capabilities) {
+ activeCaps = capabilities;
+ emit q->activeCapabilitiesChanged(activeCaps.toList());
+ }
+}
+
+void IrcNetworkPrivate::setName(const QString& value)
+{
+ Q_Q(IrcNetwork);
+ if (name != value) {
+ name = value;
+ emit q->nameChanged(value);
+ }
+}
+
+void IrcNetworkPrivate::setModes(const QStringList& value)
+{
+ Q_Q(IrcNetwork);
+ if (modes != value) {
+ modes = value;
+ emit q->modesChanged(value);
+ }
+}
+
+void IrcNetworkPrivate::setPrefixes(const QStringList& value)
+{
+ Q_Q(IrcNetwork);
+ if (prefixes != value) {
+ prefixes = value;
+ emit q->prefixesChanged(value);
+ }
+}
+
+void IrcNetworkPrivate::setChannelTypes(const QStringList& value)
+{
+ Q_Q(IrcNetwork);
+ if (channelTypes != value) {
+ channelTypes = value;
+ emit q->channelTypesChanged(value);
+ }
+}
+#endif // IRC_DOXYGEN
+
+/*!
+ \internal
+ Constructs a new network object for IRC \a connection.
+ */
+IrcNetwork::IrcNetwork(IrcConnection* connection) : QObject(connection), d_ptr(new IrcNetworkPrivate)
+{
+ Q_D(IrcNetwork);
+ d->q_ptr = this;
+ d->connection = connection;
+}
+
+/*!
+ \internal
+ Destructs the IRC network.
+ */
+IrcNetwork::~IrcNetwork()
+{
+}
+
+/*!
+ \property bool IrcNetwork::initialized
+ This property holds whether the network information has been initialized.
+
+ Most properties have empty values until the server provides the
+ relevant network information during the client-server handshake.
+
+ \par Access function:
+ \li bool <b>isInitialized</b>() const
+
+ \par Notifier signal:
+ \li void <b>initialized</b>()
+ */
+bool IrcNetwork::isInitialized()
+{
+ Q_D(const IrcNetwork);
+ return d->initialized;
+}
+
+/*!
+ This property holds the network name.
+
+ \par Access function:
+ \li QString <b>name</b>() const
+
+ \par Notifier signal:
+ \li void <b>nameChanged</b>(const QString& name)
+ */
+QString IrcNetwork::name() const
+{
+ Q_D(const IrcNetwork);
+ return d->name;
+}
+
+/*!
+ This property holds the supported channel user mode letters.
+
+ Examples of typical channel user modes:
+ Description | Mode | Prefix
+ -----------------|------------|-------
+ Channel operator | \b o | @
+ Voiced user | \b v | +
+
+ \par Access function:
+ \li QStringList <b>modes</b>() const
+
+ \par Notifier signal:
+ \li void <b>modesChanged</b>(const QStringList& modes)
+
+ \sa prefixes, modeToPrefix()
+ */
+QStringList IrcNetwork::modes() const
+{
+ Q_D(const IrcNetwork);
+ return d->modes;
+}
+
+/*!
+ This property holds the supported channel user mode prefix characters.
+
+ Examples of typical channel user modes:
+ Description | Mode | Prefix
+ -----------------|------------|-------
+ Channel operator | o | \b @
+ Voiced user | v | \b +
+
+ \par Access function:
+ \li QStringList <b>prefixes</b>() const
+
+ \par Notifier signal:
+ \li void <b>prefixesChanged</b>(const QStringList& prefixes)
+
+ \sa modes, prefixToMode()
+ */
+QStringList IrcNetwork::prefixes() const
+{
+ Q_D(const IrcNetwork);
+ return d->prefixes;
+}
+
+/*!
+ Converts a channel user mode letter to a prefix character.
+
+ \sa modes, prefixToMode()
+ */
+QString IrcNetwork::modeToPrefix(const QString& mode) const
+{
+ Q_D(const IrcNetwork);
+ return d->prefixes.value(d->modes.indexOf(mode));
+}
+
+/*!
+ Converts a channel mode prefix character to a mode letter.
+
+ \sa prefixes, modeToPrefix()
+ */
+QString IrcNetwork::prefixToMode(const QString& prefix) const
+{
+ Q_D(const IrcNetwork);
+ return d->modes.value(d->prefixes.indexOf(prefix));
+}
+
+/*!
+ This property holds the supported channel type prefix characters.
+
+ Examples of typical channel types:
+ Description | Type | Example
+ -----------------|------|---------
+ Normal channel | \# | \#communi
+ Local channel | & | &foo
+
+ \par Access function:
+ \li QStringList <b>channelTypes</b>() const
+
+ \par Notifier signal:
+ \li void <b>channelTypesChanged</b>(const QStringList& types)
+ */
+QStringList IrcNetwork::channelTypes() const
+{
+ Q_D(const IrcNetwork);
+ return d->channelTypes;
+}
+
+/*!
+ Returns \c true if the \a name is a channel.
+
+ \code
+ QString name = ...;
+ if (connection->network()->isChannel(name))
+ doSomeChannelAction(name);
+ \endcode
+
+ \sa channelTypes
+ */
+bool IrcNetwork::isChannel(const QString& name) const
+{
+ Q_D(const IrcNetwork);
+ return !name.isEmpty() && d->channelTypes.contains(name.at(0));
+}
+
+/*!
+ Returns the supported channel modes for specified \a types.
+
+ \sa ModeType
+ */
+QStringList IrcNetwork::channelModes(IrcNetwork::ModeTypes types) const
+{
+ Q_D(const IrcNetwork);
+ QStringList modes;
+ if (types & TypeA)
+ modes += d->channelModes.value(0).split("", QString::SkipEmptyParts);
+ if (types & TypeB)
+ modes += d->channelModes.value(1).split("", QString::SkipEmptyParts);
+ if (types & TypeC)
+ modes += d->channelModes.value(2).split("", QString::SkipEmptyParts);
+ if (types & TypeD)
+ modes += d->channelModes.value(3).split("", QString::SkipEmptyParts);
+ return modes;
+}
+
+/*!
+ Returns a numeric type of \a limit, or \c -1 if the limitation is not known.
+
+ \sa modeLimit(), channelLimit(), targetLimit()
+ */
+int IrcNetwork::numericLimit(Limit limit) const
+{
+ Q_D(const IrcNetwork);
+ QString key;
+ switch (limit) {
+ case NickLength: key = QLatin1String("NICKLEN"); break;
+ case ChannelLength: key = QLatin1String("CHANNELLEN"); break;
+ case TopicLength: key = QLatin1String("TOPICLEN"); break;
+ case MessageLength: return 512; // RFC 1459
+ case KickReasonLength: key = QLatin1String("KICKLEN"); break;
+ case AwayReasonLength: key = QLatin1String("AWAYLEN"); break;
+ case ModeCount: key = QLatin1String("MODES"); break;
+ }
+ return d->numericLimits.value(key, -1);
+}
+
+/*!
+ Returns the limit of entries in the list per \a mode, or \c -1 if the limitation is not known.
+
+ \sa modes()
+ */
+int IrcNetwork::modeLimit(const QString& mode) const
+{
+ Q_D(const IrcNetwork);
+ return d->modeLimits.value(mode);
+}
+
+/*!
+ Returns the limit for a \a type of channels, or \c -1 if the limitation is not known.
+
+ \sa channelTypes()
+ */
+int IrcNetwork::channelLimit(const QString& type) const
+{
+ Q_D(const IrcNetwork);
+ return d->channelLimits.value(type);
+}
+
+/*!
+ Returns the limit of targets for a \a command, or \c -1 if the limitation is not known.
+ */
+int IrcNetwork::targetLimit(const QString& command) const
+{
+ Q_D(const IrcNetwork);
+ return d->targetLimits.value(command);
+}
+
+/*!
+ This property holds the available capabilities.
+
+ \par Access function:
+ \li QStringList <b>availableCapabilities</b>() const
+
+ \par Notifier signal:
+ \li void <b>availableCapabilitiesChanged</b>(const QStringList& capabilities)
+
+ \sa requestedCapabilities, activeCapabilities
+ */
+QStringList IrcNetwork::availableCapabilities() const
+{
+ Q_D(const IrcNetwork);
+ return d->availableCaps.toList();
+}
+
+/*!
+ This property holds the active capabilities.
+
+ \par Access function:
+ \li QStringList <b>activeCapabilities</b>() const
+
+ \par Notifier signal:
+ \li void <b>activeCapabilitiesChanged</b>(const QStringList& capabilities)
+
+ \sa requestedCapabilities, availableCapabilities
+ */
+QStringList IrcNetwork::activeCapabilities() const
+{
+ Q_D(const IrcNetwork);
+ return d->activeCaps.toList();
+}
+
+/*!
+ Returns \c true if the \a capability is \b available.
+
+ \sa availableCapabilities
+ */
+bool IrcNetwork::hasCapability(const QString& capability) const
+{
+ Q_D(const IrcNetwork);
+ return d->availableCaps.contains(capability);
+}
+
+/*!
+ Returns \c true if the \a capability is \b active.
+
+ \sa activeCapabilities
+ */
+bool IrcNetwork::isCapable(const QString& capability) const
+{
+ Q_D(const IrcNetwork);
+ return d->activeCaps.contains(capability);
+}
+
+/*!
+ Requests the specified \a capability.
+
+ \note The \a capability is NOT added to the list of \ref requestedCapabilities
+ "requested capabilities" to avoid them "piling up".
+ */
+bool IrcNetwork::requestCapability(const QString& capability)
+{
+ Q_D(IrcNetwork);
+ if (d->connection)
+ return d->connection->sendCommand(IrcCommand::createCapability(QLatin1String("REQ"), capability));
+ return false;
+}
+
+/*!
+ Requests the specified \a capabilities.
+
+ \note The \a capabilities are NOT added to the list of \ref requestedCapabilities
+ "requested capabilities" to avoid them "piling up".
+ */
+bool IrcNetwork::requestCapabilities(const QStringList& capabilities)
+{
+ Q_D(IrcNetwork);
+ if (d->connection && d->connection->isActive())
+ return d->connection->sendCommand(IrcCommand::createCapability(QLatin1String("REQ"), capabilities));
+ return false;
+}
+
+/*!
+ This property holds the requested capabilities.
+
+ These capabilities are automatically requested during the handshake,
+ right after requestingCapabilities() has been emitted.
+
+ \par Access functions:
+ \li QStringList <b>requestedCapabilities</b>() const
+ \li void <b>setRequestedCapabilities</b>(const QStringList& capabilities)
+
+ \par Notifier signal:
+ \li void <b>requestedCapabilitiesChanged</b>(const QStringList& capabilities)
+
+ \sa availableCapabilities, activeCapabilities
+ */
+QStringList IrcNetwork::requestedCapabilities() const
+{
+ Q_D(const IrcNetwork);
+ return d->requestedCaps.toList();
+}
+
+void IrcNetwork::setRequestedCapabilities(const QStringList& capabilities)
+{
+ Q_D(IrcNetwork);
+ const QSet<QString> caps = capabilities.toSet();
+ if (d->requestedCaps != caps) {
+ d->requestedCaps = caps;
+ emit requestedCapabilitiesChanged(caps.toList());
+ }
+}
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug debug, IrcNetwork::Limit limit)
+{
+ const int index = IrcNetwork::staticMetaObject.indexOfEnumerator("Limit");
+ QMetaEnum enumerator = IrcNetwork::staticMetaObject.enumerator(index);
+ const char* key = enumerator.valueToKey(limit);
+ debug << (key ? key : "Unknown");
+ return debug;
+}
+
+QDebug operator<<(QDebug debug, IrcNetwork::ModeType type)
+{
+ const int index = IrcNetwork::staticMetaObject.indexOfEnumerator("ModeType");
+ QMetaEnum enumerator = IrcNetwork::staticMetaObject.enumerator(index);
+ const char* key = enumerator.valueToKey(type);
+ debug << (key ? key : "Unknown");
+ return debug;
+}
+
+QDebug operator<<(QDebug debug, IrcNetwork::ModeTypes types)
+{
+ QStringList lst;
+ if (types == IrcNetwork::AllTypes) {
+ lst << "AllTypes";
+ } else {
+ if (types & IrcNetwork::TypeA)
+ lst << "TypeA";
+ if (types & IrcNetwork::TypeB)
+ lst << "TypeB";
+ if (types & IrcNetwork::TypeC)
+ lst << "TypeC";
+ if (types & IrcNetwork::TypeD)
+ lst << "TypeD";
+ }
+ debug.nospace() << '(' << qPrintable(lst.join("|")) << ')';
+ return debug;
+}
+
+QDebug operator<<(QDebug debug, const IrcNetwork* network)
+{
+ if (!network)
+ return debug << "IrcNetwork(0x0) ";
+ debug.nospace() << network->metaObject()->className() << '(' << (void*) network;
+ if (!network->objectName().isEmpty())
+ debug.nospace() << ", name=" << qPrintable(network->objectName());
+ if (!network->name().isEmpty())
+ debug.nospace() << ", network=" << qPrintable(network->name());
+ debug.nospace() << ')';
+ return debug.space();
+}
+#endif // QT_NO_DEBUG_STREAM
+
+#include "moc_ircnetwork.cpp"
+
+IRC_END_NAMESPACE
diff --git a/libcommuni/src/core/ircprotocol.cpp b/libcommuni/src/core/ircprotocol.cpp
new file mode 100644
index 0000000..9d42126
--- /dev/null
+++ b/libcommuni/src/core/ircprotocol.cpp
@@ -0,0 +1,480 @@
+/*
+ Copyright (C) 2008-2014 The Communi Project
+
+ You may use this file under the terms of BSD license as follows:
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR
+ ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "ircprotocol.h"
+#include "ircconnection_p.h"
+#include "ircmessagebuilder_p.h"
+#include "ircnetwork_p.h"
+#include "ircconnection.h"
+#include "ircmessage.h"
+#include "irccommand.h"
+#include "irc.h"
+#include <QDebug>
+
+IRC_BEGIN_NAMESPACE
+
+/*!
+ \file ircprotocol.h
+ \brief \#include &lt;IrcProtocol&gt;
+ */
+
+/*!
+ \since 3.2
+ \class IrcProtocol ircprotocol.h IrcProtocol
+ \ingroup core
+ \brief Implements the IRC protocol and provides means for implementing support for custom protocols.
+
+ \sa IrcConnection::protocol
+ */
+
+#ifndef IRC_DOXYGEN
+class IrcProtocolPrivate
+{
+ Q_DECLARE_PUBLIC(IrcProtocol)
+
+public:
+ IrcProtocolPrivate();
+
+ void authenticate(bool secure);
+
+ void readLines(const QByteArray& delimiter);
+ void processLine(const QByteArray& line);
+
+ void handleNumericMessage(IrcNumericMessage* msg);
+ void handlePrivateMessage(IrcPrivateMessage* msg);
+ void handleCapabilityMessage(IrcCapabilityMessage* msg);
+
+ void _irc_pauseHandshake();
+ void _irc_resumeHandshake();
+
+ IrcProtocol* q_ptr;
+ IrcConnection* connection;
+ IrcMessageBuilder* builder;
+ QHash<QString, QString> info;
+ QByteArray buffer;
+ bool resumed;
+ bool authed;
+};
+
+IrcProtocolPrivate::IrcProtocolPrivate() : q_ptr(0), connection(0), builder(0), resumed(false), authed(false)
+{
+}
+
+void IrcProtocolPrivate::authenticate(bool secure)
+{
+ const QString password = connection->password();
+ if (!password.isEmpty()) {
+ if (secure) {
+ const QByteArray userName = connection->userName().toUtf8();
+ const QByteArray data = userName + '\0' + userName + '\0' + password.toUtf8();
+ authed = connection->sendData("AUTHENTICATE " + data.toBase64());
+ } else {
+ authed = connection->sendRaw(QString("PASS %1").arg(password));
+ }
+ }
+}
+
+void IrcProtocolPrivate::readLines(const QByteArray& delimiter)
+{
+ int i = -1;
+ while ((i = buffer.indexOf(delimiter)) != -1) {
+ QByteArray line = buffer.left(i).trimmed();
+ buffer = buffer.mid(i + delimiter.length());
+ if (!line.isEmpty())
+ processLine(line);
+ }
+}
+
+void IrcProtocolPrivate::processLine(const QByteArray& line)
+{
+ Q_Q(IrcProtocol);
+ static bool dbg = qgetenv("IRC_DEBUG").toInt();
+ if (dbg) qDebug() << line;
+
+ if (line.startsWith("AUTHENTICATE") && !connection->saslMechanism().isEmpty()) {
+ const QList<QByteArray> args = line.split(' ');
+ if (args.count() == 2 && args.at(1) == "+")
+ authenticate(true);
+ if (!connection->isConnected())
+ QMetaObject::invokeMethod(q, "_irc_resumeHandshake", Qt::QueuedConnection);
+ return;
+ }
+
+ IrcMessage* msg = IrcMessage::fromData(line, connection);
+ if (msg) {
+ msg->setEncoding(connection->encoding());
+
+ switch (msg->type()) {
+ case IrcMessage::Capability:
+ handleCapabilityMessage(static_cast<IrcCapabilityMessage*>(msg));
+ break;
+ case IrcMessage::Nick:
+ if (msg->flags() & IrcMessage::Own)
+ q->setNickName(static_cast<IrcNickMessage*>(msg)->newNick());
+ break;
+ case IrcMessage::Numeric:
+ handleNumericMessage(static_cast<IrcNumericMessage*>(msg));
+ break;
+ case IrcMessage::Ping:
+ connection->sendRaw("PONG " + static_cast<IrcPingMessage*>(msg)->argument());
+ break;
+ case IrcMessage::Private:
+ handlePrivateMessage(static_cast<IrcPrivateMessage*>(msg));
+ break;
+ default:
+ break;
+ }
+ q->receiveMessage(msg);
+ }
+}
+
+void IrcProtocolPrivate::handleNumericMessage(IrcNumericMessage* msg)
+{
+ Q_Q(IrcProtocol);
+ switch (msg->code()) {
+ case Irc::RPL_WELCOME:
+ q->setNickName(msg->parameters().value(0));
+ q->setStatus(IrcConnection::Connected);
+ break;
+ case Irc::RPL_ISUPPORT: {
+ foreach (const QString& param, msg->parameters().mid(1)) {
+ QStringList keyValue = param.split("=", QString::SkipEmptyParts);
+ info.insert(keyValue.value(0), keyValue.value(1));
+ }
+ break;
+ }
+ case Irc::ERR_NOMOTD:
+ case Irc::RPL_MOTDSTART:
+ q->setInfo(info);
+ break;
+ case Irc::ERR_NICKNAMEINUSE:
+ case Irc::ERR_NICKCOLLISION: {
+ QString alternate = connection->nickName();
+ emit connection->nickNameReserved(&alternate);
+ if (!alternate.isEmpty() && alternate != connection->nickName()) {
+ connection->setNickName(alternate);
+ } else {
+ emit connection->nickNameRequired(msg->parameters().value(1), &alternate);
+ if (!alternate.isEmpty() && alternate != connection->nickName())
+ connection->setNickName(alternate);
+ }
+ break;
+ }
+ case Irc::ERR_BADCHANNELKEY: {
+ QString key;
+ QString channel = msg->parameters().value(1);
+ emit connection->channelKeyRequired(channel, &key);
+ if (!key.isEmpty())
+ connection->sendCommand(IrcCommand::createJoin(channel, key));
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+void IrcProtocolPrivate::handlePrivateMessage(IrcPrivateMessage* msg)
+{
+ if (msg->isRequest()) {
+ IrcCommand* reply = IrcConnectionPrivate::get(connection)->createCtcpReply(msg);
+ if (reply)
+ connection->sendCommand(reply);
+ }
+}
+
+static void handleCapability(QSet<QString>* caps, const QString& cap)
+{
+ Q_ASSERT(caps);
+ // sticky modifier (once the cap is enabled, it cannot be disabled)
+ QLatin1Char stickyMod('=');
+ // ack modifier (the cap must be acked by the client to fully enable/disable)
+ QLatin1Char ackMod('~');
+ // disable modifier (the cap should be disabled)
+ QLatin1Char disMod('-');
+
+ QString name = cap;
+ while (name.startsWith(stickyMod) || name.startsWith(ackMod))
+ name.remove(0, 1);
+
+ if (name.startsWith(disMod))
+ caps->remove(name.mid(1));
+ else
+ caps->insert(name);
+}
+
+void IrcProtocolPrivate::handleCapabilityMessage(IrcCapabilityMessage* msg)
+{
+ Q_Q(IrcProtocol);
+ const bool connected = connection->isConnected();
+ const QString subCommand = msg->subCommand();
+ if (subCommand == "LS") {
+ QSet<QString> availableCaps = connection->network()->availableCapabilities().toSet();
+ foreach (const QString& cap, msg->capabilities())
+ handleCapability(&availableCaps, cap);
+ q->setAvailableCapabilities(availableCaps);
+
+ if (!connected) {
+ QMetaObject::invokeMethod(connection->network(), "requestingCapabilities");
+ QStringList requestedCaps = connection->network()->requestedCapabilities();
+ const QStringList params = msg->parameters();
+ if (params.value(params.count() - 1) != QLatin1String("*")) {
+ if (!connection->saslMechanism().isEmpty() && availableCaps.contains(QLatin1String("sasl")))
+ requestedCaps += QLatin1String("sasl");
+ }
+ if (!requestedCaps.isEmpty())
+ connection->sendRaw("CAP REQ :" + requestedCaps.join(" "));
+ else
+ QMetaObject::invokeMethod(q, "_irc_resumeHandshake", Qt::QueuedConnection);
+ }
+ } else if (subCommand == "ACK" || subCommand == "NAK") {
+ bool auth = false;
+ if (subCommand == "ACK") {
+ QSet<QString> activeCaps = connection->network()->activeCapabilities().toSet();
+ foreach (const QString& cap, msg->capabilities()) {
+ handleCapability(&activeCaps, cap);
+ if (cap == "sasl" && !connection->saslMechanism().isEmpty() && !connection->password().isEmpty())
+ auth = connection->sendRaw("AUTHENTICATE " + connection->saslMechanism());
+ }
+ q->setActiveCapabilities(activeCaps);
+ }
+
+ if (!connected && !auth)
+ QMetaObject::invokeMethod(q, "_irc_resumeHandshake", Qt::QueuedConnection);
+ }
+}
+
+void IrcProtocolPrivate::_irc_pauseHandshake()
+{
+ // Send CAP LS first; if the server understands it this will
+ // temporarily pause the handshake until CAP END is sent, so we
+ // know whether the server supports the CAP extension.
+ connection->sendData("CAP LS");
+ resumed = false;
+ authed = false;
+}
+
+void IrcProtocolPrivate::_irc_resumeHandshake()
+{
+ if (!resumed && !connection->isConnected()) {
+ if (!authed && !connection->saslMechanism().isEmpty() && !connection->password().isEmpty())
+ authenticate(false);
+ connection->sendData("CAP END");
+ }
+ resumed = true;
+}
+#endif // IRC_DOXYGEN
+
+/*!
+ Constructs a new IRC protocol for \a connection.
+ */
+IrcProtocol::IrcProtocol(IrcConnection* connection) : QObject(connection), d_ptr(new IrcProtocolPrivate)
+{
+ Q_D(IrcProtocol);
+ d->q_ptr = this;
+ d->connection = connection;
+ d->builder = new IrcMessageBuilder(connection);
+ connect(d->builder, SIGNAL(messageReceived(IrcMessage*)), this, SLOT(receiveMessage(IrcMessage*)));
+}
+
+/*!
+ Destructs the IRC protocol.
+ */
+IrcProtocol::~IrcProtocol()
+{
+ Q_D(IrcProtocol);
+ delete d->builder;
+}
+
+/*!
+ This property holds the connection.
+
+ \par Access function:
+ \li \ref IrcConnection* <b>connection</b>() const
+ */
+IrcConnection* IrcProtocol::connection() const
+{
+ Q_D(const IrcProtocol);
+ return d->connection;
+}
+
+/*!
+ This property holds the socket.
+
+ \par Access functions:
+ \li \ref QAbstractSocket* <b>socket</b>() const
+ */
+QAbstractSocket* IrcProtocol::socket() const
+{
+ Q_D(const IrcProtocol);
+ return d->connection->socket();
+}
+
+/*!
+ This method is called when the connection has been established.
+
+ The default implementation sends the \c NICK, \c USER and \c PASSWORD commands as defined in
+ <a href="http://tools.ietf.org/html/rfc1459">RFC 1459</a>.
+
+ Furthermore, it sends a <tt>CAP LS</tt> command as specified in
+ <a href="http://tools.ietf.org/html/draft-mitchell-irc-capabilities-01">IRC Client Capabilities Extension</a>.
+ */
+void IrcProtocol::open()
+{
+ Q_D(IrcProtocol);
+ d->_irc_pauseHandshake();
+
+ if (d->connection->saslMechanism().isEmpty() && !d->connection->password().isEmpty())
+ d->authenticate(false);
+
+ d->connection->sendRaw(QString("NICK %1").arg(d->connection->nickName()));
+ d->connection->sendRaw(QString("USER %1 hostname servername :%2").arg(d->connection->userName(), d->connection->realName()));
+}
+
+/*!
+ This method is called when the connection has been lost.
+ */
+void IrcProtocol::close()
+{
+}
+
+/*!
+ This method is called when the \ref socket has new data available for read.
+
+ The default implementation reads lines as specified in
+ <a href="http://tools.ietf.org/html/rfc1459">RFC 1459</a>.
+
+ \sa socket
+ */
+void IrcProtocol::read()
+{
+ Q_D(IrcProtocol);
+ d->buffer += socket()->readAll();
+ // try reading RFC compliant message lines first
+ d->readLines("\r\n");
+ // fall back to RFC incompliant lines...
+ d->readLines("\n");
+}
+
+/*!
+ This method is called when raw \a data should be written to the \ref socket.
+
+ The default implementation writes the data and appends \c "\r\n" as specified in
+ <a href="http://tools.ietf.org/html/rfc1459">RFC 1459</a>.
+
+ \sa socket
+ */
+bool IrcProtocol::write(const QByteArray& data)
+{
+ return socket()->write(data + QByteArray("\r\n")) != -1;
+}
+
+/*!
+ This method should be called by the protocol implementation
+ to make the underlying IRC connection receive a \a message.
+
+ \sa IrcConnection::messageReceived()
+ */
+void IrcProtocol::receiveMessage(IrcMessage* message)
+{
+ Q_D(IrcProtocol);
+ IrcConnectionPrivate* priv = IrcConnectionPrivate::get(d->connection);
+ priv->receiveMessage(message);
+ if (message->type() == IrcMessage::Numeric)
+ d->builder->processMessage(static_cast<IrcNumericMessage*>(message));
+}
+
+/*!
+ This method should be called by the protocol implementation to
+ notify the underlying IRC connection about a nick \a name change.
+
+ \sa IrcConnection::nickName
+ */
+void IrcProtocol::setNickName(const QString& name)
+{
+ Q_D(IrcProtocol);
+ IrcConnectionPrivate* priv = IrcConnectionPrivate::get(d->connection);
+ priv->setNick(name);
+}
+
+/*!
+ This method should be called by the protocol implementation
+ to notify the underlying IRC connection about a \a status change.
+
+ \sa IrcConnection::status
+ */
+void IrcProtocol::setStatus(IrcConnection::Status status)
+{
+ Q_D(IrcProtocol);
+ IrcConnectionPrivate* priv = IrcConnectionPrivate::get(d->connection);
+ priv->setStatus(status);
+}
+
+/*!
+ This method should be called by the protocol implementation
+ to initialize the underlying IRC network connection \a info.
+
+ \sa IrcNetwork::initialized
+ */
+void IrcProtocol::setInfo(const QHash<QString, QString>& info)
+{
+ Q_D(IrcProtocol);
+ if (!info.isEmpty()) {
+ IrcConnectionPrivate* priv = IrcConnectionPrivate::get(d->connection);
+ priv->setInfo(info);
+ }
+}
+
+/*!
+ This method should be called by the protocol implementation to notify
+ the underlying IRC network about a change in available \a capabilities.
+
+ \sa IrcNetwork::availableCapabilities
+ */
+void IrcProtocol::setAvailableCapabilities(const QSet<QString>& capabilities)
+{
+ Q_D(IrcProtocol);
+ IrcNetworkPrivate* priv = IrcNetworkPrivate::get(d->connection->network());
+ priv->setAvailableCapabilities(capabilities);
+}
+
+/*!
+ This method should be called by the protocol implementation to notify
+ the underlying IRC network about a change in active \a capabilities.
+
+ \sa IrcNetwork::activeCapabilities
+ */
+void IrcProtocol::setActiveCapabilities(const QSet<QString>& capabilities)
+{
+ Q_D(IrcProtocol);
+ IrcNetworkPrivate* priv = IrcNetworkPrivate::get(d->connection->network());
+ priv->setActiveCapabilities(capabilities);
+}
+
+#include "moc_ircprotocol.cpp"
+
+IRC_END_NAMESPACE
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2026-01-13 01:29:51 +0000