1 /***************************************************************************
2 * Copyright (C) 2005-2019 by the Quassel Project *
3 * devel@quassel-irc.org *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) version 3. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
19 ***************************************************************************/
21 #include "ctcpparser.h"
23 #include "corenetworkconfig.h"
24 #include "coresession.h"
25 #include "coreuserinputhandler.h"
26 #include "ctcpevent.h"
28 #include "messageevent.h"
30 const QByteArray XDELIM = "\001";
32 CtcpParser::CtcpParser(CoreSession* coreSession, QObject* parent)
34 , _coreSession(coreSession)
36 QByteArray MQUOTE = QByteArray("\020");
37 _ctcpMDequoteHash[MQUOTE + '0'] = QByteArray(1, '\000');
38 _ctcpMDequoteHash[MQUOTE + 'n'] = QByteArray(1, '\n');
39 _ctcpMDequoteHash[MQUOTE + 'r'] = QByteArray(1, '\r');
40 _ctcpMDequoteHash[MQUOTE + MQUOTE] = MQUOTE;
42 setStandardCtcp(_coreSession->networkConfig()->standardCtcp());
44 connect(_coreSession->networkConfig(), &NetworkConfig::standardCtcpSet, this, &CtcpParser::setStandardCtcp);
45 connect(this, &CtcpParser::newEvent, _coreSession->eventManager(), &EventManager::postEvent);
48 void CtcpParser::setStandardCtcp(bool enabled)
50 QByteArray XQUOTE = QByteArray(R"(\)");
52 _ctcpXDelimDequoteHash[XQUOTE + XQUOTE] = XQUOTE;
54 _ctcpXDelimDequoteHash.remove(XQUOTE + XQUOTE);
55 _ctcpXDelimDequoteHash[XQUOTE + QByteArray("a")] = XDELIM;
58 void CtcpParser::displayMsg(NetworkEvent* event,
59 Message::Type msgType,
63 Message::Flags msgFlags)
65 if (event->testFlag(EventManager::Silent))
68 MessageEvent* msgEvent = new MessageEvent(msgType, event->network(), std::move(msg), std::move(sender), std::move(target), msgFlags, event->timestamp());
69 emit newEvent(msgEvent);
72 QByteArray CtcpParser::lowLevelQuote(const QByteArray& message)
74 QByteArray quotedMessage = message;
76 QHash<QByteArray, QByteArray> quoteHash = _ctcpMDequoteHash;
77 QByteArray MQUOTE = QByteArray("\020");
78 quoteHash.remove(MQUOTE + MQUOTE);
79 quotedMessage.replace(MQUOTE, MQUOTE + MQUOTE);
81 QHash<QByteArray, QByteArray>::const_iterator quoteIter = quoteHash.constBegin();
82 while (quoteIter != quoteHash.constEnd()) {
83 quotedMessage.replace(quoteIter.value(), quoteIter.key());
89 QByteArray CtcpParser::lowLevelDequote(const QByteArray& message)
91 QByteArray dequotedMessage;
92 QByteArray messagepart;
93 QHash<QByteArray, QByteArray>::iterator ctcpquote;
95 // copy dequote Message
96 for (int i = 0; i < message.size(); i++) {
97 messagepart = message.mid(i, 1);
98 if (i + 1 < message.size()) {
99 for (ctcpquote = _ctcpMDequoteHash.begin(); ctcpquote != _ctcpMDequoteHash.end(); ++ctcpquote) {
100 if (message.mid(i, 2) == ctcpquote.key()) {
101 messagepart = ctcpquote.value();
107 dequotedMessage += messagepart;
109 return dequotedMessage;
112 QByteArray CtcpParser::xdelimQuote(const QByteArray& message)
114 QByteArray quotedMessage = message;
115 QHash<QByteArray, QByteArray>::const_iterator quoteIter = _ctcpXDelimDequoteHash.constBegin();
116 while (quoteIter != _ctcpXDelimDequoteHash.constEnd()) {
117 quotedMessage.replace(quoteIter.value(), quoteIter.key());
120 return quotedMessage;
123 QByteArray CtcpParser::xdelimDequote(const QByteArray& message)
125 QByteArray dequotedMessage;
126 QByteArray messagepart;
127 QHash<QByteArray, QByteArray>::iterator xdelimquote;
129 for (int i = 0; i < message.size(); i++) {
130 messagepart = message.mid(i, 1);
131 if (i + 1 < message.size()) {
132 for (xdelimquote = _ctcpXDelimDequoteHash.begin(); xdelimquote != _ctcpXDelimDequoteHash.end(); ++xdelimquote) {
133 if (message.mid(i, 2) == xdelimquote.key()) {
134 messagepart = xdelimquote.value();
140 dequotedMessage += messagepart;
142 return dequotedMessage;
145 void CtcpParser::processIrcEventRawNotice(IrcEventRawMessage* event)
147 parse(event, Message::Notice);
150 void CtcpParser::processIrcEventRawPrivmsg(IrcEventRawMessage* event)
152 parse(event, Message::Plain);
155 void CtcpParser::parse(IrcEventRawMessage* e, Message::Type messagetype)
157 // lowlevel message dequote
158 QByteArray dequotedMessage = lowLevelDequote(e->rawMessage());
160 CtcpEvent::CtcpType ctcptype = e->type() == EventManager::IrcEventRawNotice ? CtcpEvent::Reply : CtcpEvent::Query;
162 Message::Flags flags = (ctcptype == CtcpEvent::Reply && !e->network()->isChannelName(e->target())) ? Message::Redirected : Message::None;
164 bool isStatusMsg = false;
166 // First remove all statusmsg prefix characters that are not also channel prefix characters.
167 while (e->network()->isStatusMsg(e->target()) && !e->network()->isChannelName(e->target())) {
169 e->setTarget(e->target().remove(0, 1));
172 // Then continue removing statusmsg characters as long as removing the character will still result in a
173 // valid channel name. This prevents removing the channel prefix character if said character is in the
174 // overlap between the statusmsg characters and the channel prefix characters.
175 while (e->network()->isStatusMsg(e->target()) && e->network()->isChannelName(e->target().remove(0, 1))) {
177 e->setTarget(e->target().remove(0, 1));
180 // If any statusmsg characters were removed, Flag the message as a StatusMsg.
182 flags |= Message::StatusMsg;
185 // For self-messages, pass the flag on to the message, too
186 if (e->testFlag(EventManager::Self)) {
187 flags |= Message::Self;
190 if (coreSession()->networkConfig()->standardCtcp())
191 parseStandard(e, messagetype, dequotedMessage, ctcptype, flags);
193 parseSimple(e, messagetype, dequotedMessage, ctcptype, flags);
196 // only accept CTCPs in their simplest form, i.e. one ctcp, from start to
197 // end, no text around it; not as per the 'specs', but makes people happier
198 void CtcpParser::parseSimple(IrcEventRawMessage* e,
199 Message::Type messagetype,
200 const QByteArray& dequotedMessage,
201 CtcpEvent::CtcpType ctcptype,
202 Message::Flags flags)
204 if (dequotedMessage.count(XDELIM) != 2 || dequotedMessage[0] != '\001' || dequotedMessage[dequotedMessage.count() - 1] != '\001') {
205 displayMsg(e, messagetype, targetDecode(e, dequotedMessage), e->prefix(), e->target(), flags);
209 QString ctcpcmd, ctcpparam;
211 QByteArray ctcp = xdelimDequote(dequotedMessage.mid(1, dequotedMessage.count() - 2));
212 spacePos = ctcp.indexOf(' ');
213 if (spacePos != -1) {
214 ctcpcmd = targetDecode(e, ctcp.left(spacePos));
215 ctcpparam = targetDecode(e, ctcp.mid(spacePos + 1));
218 ctcpcmd = targetDecode(e, ctcp);
219 ctcpparam = QString();
221 ctcpcmd = ctcpcmd.toUpper();
223 bool isAction = ctcpcmd == QLatin1String("ACTION");
224 // we don't want to block /me messages by the CTCP ignore list
226 || !coreSession()->ignoreListManager()->ctcpMatch(e->prefix(), e->network()->networkName(), ctcpcmd)) {
227 QUuid uuid = QUuid::createUuid();
228 _replies.insert(uuid, CtcpReply(coreNetwork(e), nickFromMask(e->prefix())));
229 CtcpEvent* event = new CtcpEvent(EventManager::CtcpEvent,
231 isAction ? QHash<IrcTagKey, QString>() : e->tags(),
239 emit newEvent(event);
240 CtcpEvent* flushEvent = new CtcpEvent(EventManager::CtcpEventFlush,
250 emit newEvent(flushEvent);
255 void CtcpParser::parseStandard(IrcEventRawMessage* e,
256 Message::Type messagetype,
257 const QByteArray& dequotedMessage_,
258 CtcpEvent::CtcpType ctcptype,
259 Message::Flags flags)
261 auto dequotedMessage = dequotedMessage_;
264 QList<CtcpEvent*> ctcpEvents;
265 QUuid uuid; // needed to group all replies together
267 // extract tagged / extended data
269 int xdelimEndPos = -1;
271 while ((xdelimPos = dequotedMessage.indexOf(XDELIM)) != -1) {
273 displayMsg(e, messagetype, targetDecode(e, dequotedMessage.left(xdelimPos)), e->prefix(), e->target(), flags);
275 xdelimEndPos = dequotedMessage.indexOf(XDELIM, xdelimPos + 1);
276 if (xdelimEndPos == -1) {
277 // no matching end delimiter found... treat rest of the message as ctcp
278 xdelimEndPos = dequotedMessage.count();
280 ctcp = xdelimDequote(dequotedMessage.mid(xdelimPos + 1, xdelimEndPos - xdelimPos - 1));
281 dequotedMessage = dequotedMessage.mid(xdelimEndPos + 1);
283 // dispatch the ctcp command
284 QString ctcpcmd = targetDecode(e, ctcp.left(spacePos));
285 QString ctcpparam = targetDecode(e, ctcp.mid(spacePos + 1));
287 spacePos = ctcp.indexOf(' ');
288 if (spacePos != -1) {
289 ctcpcmd = targetDecode(e, ctcp.left(spacePos));
290 ctcpparam = targetDecode(e, ctcp.mid(spacePos + 1));
293 ctcpcmd = targetDecode(e, ctcp);
294 ctcpparam = QString();
297 ctcpcmd = ctcpcmd.toUpper();
299 bool isAction = ctcpcmd == QLatin1String("ACTION");
300 // we don't want to block /me messages by the CTCP ignore list
302 || !coreSession()->ignoreListManager()->ctcpMatch(e->prefix(), e->network()->networkName(), ctcpcmd)) {
304 uuid = QUuid::createUuid();
306 CtcpEvent* event = new CtcpEvent(EventManager::CtcpEvent,
308 isAction ? QHash<IrcTagKey, QString>() : e->tags(),
319 if (!ctcpEvents.isEmpty()) {
320 _replies.insert(uuid, CtcpReply(coreNetwork(e), nickFromMask(e->prefix())));
321 CtcpEvent* flushEvent = new CtcpEvent(EventManager::CtcpEventFlush,
331 ctcpEvents << flushEvent;
332 for (CtcpEvent* event : ctcpEvents) {
333 emit newEvent(event);
337 if (!dequotedMessage.isEmpty())
338 displayMsg(e, messagetype, targetDecode(e, dequotedMessage), e->prefix(), e->target(), flags);
341 void CtcpParser::sendCtcpEvent(CtcpEvent* e)
343 CoreNetwork* net = coreNetwork(e);
344 if (e->type() == EventManager::CtcpEvent) {
345 QByteArray quotedReply;
346 QString bufname = nickFromMask(e->prefix());
347 if (e->ctcpType() == CtcpEvent::Query && !e->reply().isNull()) {
348 if (_replies.contains(e->uuid()))
349 _replies[e->uuid()].replies << lowLevelQuote(pack(net->serverEncode(e->ctcpCmd()), net->userEncode(bufname, e->reply())));
351 // reply not caused by a request processed in here, so send it off immediately
352 reply(net, bufname, e->ctcpCmd(), e->reply());
355 else if (e->type() == EventManager::CtcpEventFlush && _replies.contains(e->uuid())) {
356 CtcpReply reply = _replies.take(e->uuid());
357 if (reply.replies.count())
358 packedReply(net, reply.bufferName, reply.replies);
362 QByteArray CtcpParser::pack(const QByteArray& ctcpTag, const QByteArray& message)
364 if (message.isEmpty())
365 return XDELIM + ctcpTag + XDELIM;
367 return XDELIM + ctcpTag + ' ' + xdelimQuote(message) + XDELIM;
370 void CtcpParser::query(CoreNetwork* net, const QString& bufname, const QString& ctcpTag, const QString& message)
372 QString cmd("PRIVMSG");
374 std::function<QList<QByteArray>(QString&)> cmdGenerator = [&](QString& splitMsg) -> QList<QByteArray> {
375 return QList<QByteArray>() << net->serverEncode(bufname)
376 << lowLevelQuote(pack(net->serverEncode(ctcpTag), net->userEncode(bufname, splitMsg)));
379 net->putCmd(cmd, net->splitMessage(cmd, message, cmdGenerator));
382 void CtcpParser::reply(CoreNetwork* net, const QString& bufname, const QString& ctcpTag, const QString& message)
384 QList<QByteArray> params;
385 params << net->serverEncode(bufname) << lowLevelQuote(pack(net->serverEncode(ctcpTag), net->userEncode(bufname, message)));
386 net->putCmd("NOTICE", params);
389 void CtcpParser::packedReply(CoreNetwork* net, const QString& bufname, const QList<QByteArray>& replies)
391 QList<QByteArray> params;
394 for (int i = 0; i < replies.count(); i++) {
395 answerSize += replies.at(i).size();
398 QByteArray quotedReply;
399 quotedReply.reserve(answerSize);
400 for (int i = 0; i < replies.count(); i++) {
401 quotedReply.append(replies.at(i));
404 params << net->serverEncode(bufname) << quotedReply;
405 // FIXME user proper event
406 net->putCmd("NOTICE", params);