1 /***************************************************************************
2 * Copyright (C) 2005-2020 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 if (event->testFlag(EventManager::Self)) {
70 msgEvent->setFlag(EventManager::Self);
72 emit newEvent(msgEvent);
75 QByteArray CtcpParser::lowLevelQuote(const QByteArray& message)
77 QByteArray quotedMessage = message;
79 QHash<QByteArray, QByteArray> quoteHash = _ctcpMDequoteHash;
80 QByteArray MQUOTE = QByteArray("\020");
81 quoteHash.remove(MQUOTE + MQUOTE);
82 quotedMessage.replace(MQUOTE, MQUOTE + MQUOTE);
84 QHash<QByteArray, QByteArray>::const_iterator quoteIter = quoteHash.constBegin();
85 while (quoteIter != quoteHash.constEnd()) {
86 quotedMessage.replace(quoteIter.value(), quoteIter.key());
92 QByteArray CtcpParser::lowLevelDequote(const QByteArray& message)
94 QByteArray dequotedMessage;
95 QByteArray messagepart;
96 QHash<QByteArray, QByteArray>::iterator ctcpquote;
98 // copy dequote Message
99 for (int i = 0; i < message.size(); i++) {
100 messagepart = message.mid(i, 1);
101 if (i + 1 < message.size()) {
102 for (ctcpquote = _ctcpMDequoteHash.begin(); ctcpquote != _ctcpMDequoteHash.end(); ++ctcpquote) {
103 if (message.mid(i, 2) == ctcpquote.key()) {
104 messagepart = ctcpquote.value();
110 dequotedMessage += messagepart;
112 return dequotedMessage;
115 QByteArray CtcpParser::xdelimQuote(const QByteArray& message)
117 QByteArray quotedMessage = message;
118 QHash<QByteArray, QByteArray>::const_iterator quoteIter = _ctcpXDelimDequoteHash.constBegin();
119 while (quoteIter != _ctcpXDelimDequoteHash.constEnd()) {
120 quotedMessage.replace(quoteIter.value(), quoteIter.key());
123 return quotedMessage;
126 QByteArray CtcpParser::xdelimDequote(const QByteArray& message)
128 QByteArray dequotedMessage;
129 QByteArray messagepart;
130 QHash<QByteArray, QByteArray>::iterator xdelimquote;
132 for (int i = 0; i < message.size(); i++) {
133 messagepart = message.mid(i, 1);
134 if (i + 1 < message.size()) {
135 for (xdelimquote = _ctcpXDelimDequoteHash.begin(); xdelimquote != _ctcpXDelimDequoteHash.end(); ++xdelimquote) {
136 if (message.mid(i, 2) == xdelimquote.key()) {
137 messagepart = xdelimquote.value();
143 dequotedMessage += messagepart;
145 return dequotedMessage;
148 void CtcpParser::processIrcEventRawNotice(IrcEventRawMessage* event)
150 parse(event, Message::Notice);
153 void CtcpParser::processIrcEventRawPrivmsg(IrcEventRawMessage* event)
155 parse(event, Message::Plain);
158 void CtcpParser::parse(IrcEventRawMessage* e, Message::Type messagetype)
160 // lowlevel message dequote
161 QByteArray dequotedMessage = lowLevelDequote(e->rawMessage());
163 CtcpEvent::CtcpType ctcptype = e->type() == EventManager::IrcEventRawNotice ? CtcpEvent::Reply : CtcpEvent::Query;
165 Message::Flags flags = (ctcptype == CtcpEvent::Reply && !e->network()->isChannelName(e->target())) ? Message::Redirected : Message::None;
167 bool isStatusMsg = false;
169 // First remove all statusmsg prefix characters that are not also channel prefix characters.
170 while (e->network()->isStatusMsg(e->target()) && !e->network()->isChannelName(e->target())) {
172 e->setTarget(e->target().remove(0, 1));
175 // Then continue removing statusmsg characters as long as removing the character will still result in a
176 // valid channel name. This prevents removing the channel prefix character if said character is in the
177 // overlap between the statusmsg characters and the channel prefix characters.
178 while (e->network()->isStatusMsg(e->target()) && e->network()->isChannelName(e->target().remove(0, 1))) {
180 e->setTarget(e->target().remove(0, 1));
183 // If any statusmsg characters were removed, Flag the message as a StatusMsg.
185 flags |= Message::StatusMsg;
188 // For self-messages, pass the flag on to the message, too
189 if (e->testFlag(EventManager::Self)) {
190 flags |= Message::Self;
193 if (coreSession()->networkConfig()->standardCtcp())
194 parseStandard(e, messagetype, dequotedMessage, ctcptype, flags);
196 parseSimple(e, messagetype, dequotedMessage, ctcptype, flags);
199 // only accept CTCPs in their simplest form, i.e. one ctcp, from start to
200 // end, no text around it; not as per the 'specs', but makes people happier
201 void CtcpParser::parseSimple(IrcEventRawMessage* e,
202 Message::Type messagetype,
203 const QByteArray& dequotedMessage,
204 CtcpEvent::CtcpType ctcptype,
205 Message::Flags flags)
207 if (dequotedMessage.count(XDELIM) != 2 || dequotedMessage[0] != '\001' || dequotedMessage[dequotedMessage.count() - 1] != '\001') {
208 displayMsg(e, messagetype, targetDecode(e, dequotedMessage), e->prefix(), e->target(), flags);
212 QString ctcpcmd, ctcpparam;
214 QByteArray ctcp = xdelimDequote(dequotedMessage.mid(1, dequotedMessage.count() - 2));
215 spacePos = ctcp.indexOf(' ');
216 if (spacePos != -1) {
217 ctcpcmd = targetDecode(e, ctcp.left(spacePos));
218 ctcpparam = targetDecode(e, ctcp.mid(spacePos + 1));
221 ctcpcmd = targetDecode(e, ctcp);
222 ctcpparam = QString();
224 ctcpcmd = ctcpcmd.toUpper();
226 bool isAction = ctcpcmd == QLatin1String("ACTION");
227 // we don't want to block /me messages by the CTCP ignore list
229 || !coreSession()->ignoreListManager()->ctcpMatch(e->prefix(), e->network()->networkName(), ctcpcmd)) {
230 QUuid uuid = QUuid::createUuid();
231 _replies.insert(uuid, CtcpReply(coreNetwork(e), nickFromMask(e->prefix())));
232 CtcpEvent* event = new CtcpEvent(EventManager::CtcpEvent,
234 isAction ? QHash<IrcTagKey, QString>() : e->tags(),
242 if (e->testFlag(EventManager::Self)) {
243 event->setFlag(EventManager::Self);
245 emit newEvent(event);
246 CtcpEvent* flushEvent = new CtcpEvent(EventManager::CtcpEventFlush,
256 emit newEvent(flushEvent);
261 void CtcpParser::parseStandard(IrcEventRawMessage* e,
262 Message::Type messagetype,
263 const QByteArray& dequotedMessage_,
264 CtcpEvent::CtcpType ctcptype,
265 Message::Flags flags)
267 auto dequotedMessage = dequotedMessage_;
270 QList<CtcpEvent*> ctcpEvents;
271 QUuid uuid; // needed to group all replies together
273 // extract tagged / extended data
275 int xdelimEndPos = -1;
277 while ((xdelimPos = dequotedMessage.indexOf(XDELIM)) != -1) {
279 displayMsg(e, messagetype, targetDecode(e, dequotedMessage.left(xdelimPos)), e->prefix(), e->target(), flags);
281 xdelimEndPos = dequotedMessage.indexOf(XDELIM, xdelimPos + 1);
282 if (xdelimEndPos == -1) {
283 // no matching end delimiter found... treat rest of the message as ctcp
284 xdelimEndPos = dequotedMessage.count();
286 ctcp = xdelimDequote(dequotedMessage.mid(xdelimPos + 1, xdelimEndPos - xdelimPos - 1));
287 dequotedMessage = dequotedMessage.mid(xdelimEndPos + 1);
289 // dispatch the ctcp command
290 QString ctcpcmd = targetDecode(e, ctcp.left(spacePos));
291 QString ctcpparam = targetDecode(e, ctcp.mid(spacePos + 1));
293 spacePos = ctcp.indexOf(' ');
294 if (spacePos != -1) {
295 ctcpcmd = targetDecode(e, ctcp.left(spacePos));
296 ctcpparam = targetDecode(e, ctcp.mid(spacePos + 1));
299 ctcpcmd = targetDecode(e, ctcp);
300 ctcpparam = QString();
303 ctcpcmd = ctcpcmd.toUpper();
305 bool isAction = ctcpcmd == QLatin1String("ACTION");
306 // we don't want to block /me messages by the CTCP ignore list
308 || !coreSession()->ignoreListManager()->ctcpMatch(e->prefix(), e->network()->networkName(), ctcpcmd)) {
310 uuid = QUuid::createUuid();
312 CtcpEvent* event = new CtcpEvent(EventManager::CtcpEvent,
314 isAction ? QHash<IrcTagKey, QString>() : e->tags(),
322 if (e->testFlag(EventManager::Self)) {
323 event->setFlag(EventManager::Self);
328 if (!ctcpEvents.isEmpty()) {
329 _replies.insert(uuid, CtcpReply(coreNetwork(e), nickFromMask(e->prefix())));
330 CtcpEvent* flushEvent = new CtcpEvent(EventManager::CtcpEventFlush,
340 ctcpEvents << flushEvent;
341 for (CtcpEvent* event : ctcpEvents) {
342 emit newEvent(event);
346 if (!dequotedMessage.isEmpty())
347 displayMsg(e, messagetype, targetDecode(e, dequotedMessage), e->prefix(), e->target(), flags);
350 void CtcpParser::sendCtcpEvent(CtcpEvent* e)
352 CoreNetwork* net = coreNetwork(e);
353 if (e->type() == EventManager::CtcpEvent) {
354 QByteArray quotedReply;
355 QString bufname = nickFromMask(e->prefix());
356 if (e->ctcpType() == CtcpEvent::Query && !e->reply().isNull()) {
357 if (_replies.contains(e->uuid()))
358 _replies[e->uuid()].replies << lowLevelQuote(pack(net->serverEncode(e->ctcpCmd()), net->userEncode(bufname, e->reply())));
360 // reply not caused by a request processed in here, so send it off immediately
361 reply(net, bufname, e->ctcpCmd(), e->reply());
364 else if (e->type() == EventManager::CtcpEventFlush && _replies.contains(e->uuid())) {
365 CtcpReply reply = _replies.take(e->uuid());
366 if (reply.replies.count())
367 packedReply(net, reply.bufferName, reply.replies);
371 QByteArray CtcpParser::pack(const QByteArray& ctcpTag, const QByteArray& message)
373 if (message.isEmpty())
374 return XDELIM + ctcpTag + XDELIM;
376 return XDELIM + ctcpTag + ' ' + xdelimQuote(message) + XDELIM;
379 void CtcpParser::query(CoreNetwork* net, const QString& bufname, const QString& ctcpTag, const QString& message)
381 QString cmd("PRIVMSG");
383 std::function<QList<QByteArray>(QString&)> cmdGenerator = [&](QString& splitMsg) -> QList<QByteArray> {
384 return QList<QByteArray>() << net->serverEncode(bufname)
385 << lowLevelQuote(pack(net->serverEncode(ctcpTag), net->userEncode(bufname, splitMsg)));
388 net->putCmd(cmd, net->splitMessage(cmd, message, cmdGenerator));
391 void CtcpParser::reply(CoreNetwork* net, const QString& bufname, const QString& ctcpTag, const QString& message)
393 QList<QByteArray> params;
394 params << net->serverEncode(bufname) << lowLevelQuote(pack(net->serverEncode(ctcpTag), net->userEncode(bufname, message)));
395 net->putCmd("NOTICE", params);
398 void CtcpParser::packedReply(CoreNetwork* net, const QString& bufname, const QList<QByteArray>& replies)
400 QList<QByteArray> params;
403 for (int i = 0; i < replies.count(); i++) {
404 answerSize += replies.at(i).size();
407 QByteArray quotedReply;
408 quotedReply.reserve(answerSize);
409 for (int i = 0; i < replies.count(); i++) {
410 quotedReply.append(replies.at(i));
413 params << net->serverEncode(bufname) << quotedReply;
414 // FIXME user proper event
415 net->putCmd("NOTICE", params);