src/core/ctcphandler.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-10 by the Quassel Project                          *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   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.                                           *
   9  *                                                                         *
  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.                          *
  14  *                                                                         *
  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  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #include "ctcphandler.h"
  21
  22 #include "message.h"
  23 #include "network.h"
  24 #include "quassel.h"
  25 #include "util.h"
  26 #include "coreignorelistmanager.h"
  27
  28 CtcpHandler::CtcpHandler(CoreNetwork *parent)
  29   : CoreBasicHandler(parent),
  30     XDELIM("\001"),
  31     _ignoreListManager(parent->ignoreListManager())
  32 {
  33
  34   QByteArray MQUOTE = QByteArray("\020");
  35   ctcpMDequoteHash[MQUOTE + '0'] = QByteArray(1, '\000');
  36   ctcpMDequoteHash[MQUOTE + 'n'] = QByteArray(1, '\n');
  37   ctcpMDequoteHash[MQUOTE + 'r'] = QByteArray(1, '\r');
  38   ctcpMDequoteHash[MQUOTE + MQUOTE] = MQUOTE;
  39
  40   QByteArray XQUOTE = QByteArray("\134");
  41   ctcpXDelimDequoteHash[XQUOTE + XQUOTE] = XQUOTE;
  42   ctcpXDelimDequoteHash[XQUOTE + QByteArray("a")] = XDELIM;
  43 }
  44
  45 QByteArray CtcpHandler::lowLevelQuote(const QByteArray &message) {
  46   QByteArray quotedMessage = message;
  47
  48   QHash<QByteArray, QByteArray> quoteHash = ctcpMDequoteHash;
  49   QByteArray MQUOTE = QByteArray("\020");
  50   quoteHash.remove(MQUOTE + MQUOTE);
  51   quotedMessage.replace(MQUOTE, MQUOTE + MQUOTE);
  52
  53   QHash<QByteArray, QByteArray>::const_iterator quoteIter = quoteHash.constBegin();
  54   while(quoteIter != quoteHash.constEnd()) {
  55     quotedMessage.replace(quoteIter.value(), quoteIter.key());
  56     quoteIter++;
  57   }
  58   return quotedMessage;
  59 }
  60
  61 QByteArray CtcpHandler::lowLevelDequote(const QByteArray &message) {
  62   QByteArray dequotedMessage;
  63   QByteArray messagepart;
  64   QHash<QByteArray, QByteArray>::iterator ctcpquote;
  65
  66   // copy dequote Message
  67   for(int i = 0; i < message.size(); i++) {
  68     messagepart = message.mid(i,1);
  69     if(i+1 < message.size()) {
  70       for(ctcpquote = ctcpMDequoteHash.begin(); ctcpquote != ctcpMDequoteHash.end(); ++ctcpquote) {
  71         if(message.mid(i,2) == ctcpquote.key()) {
  72           messagepart = ctcpquote.value();
  73           i++;
  74           break;
  75         }
  76       }
  77     }
  78     dequotedMessage += messagepart;
  79   }
  80   return dequotedMessage;
  81 }
  82
  83 QByteArray CtcpHandler::xdelimQuote(const QByteArray &message) {
  84   QByteArray quotedMessage = message;
  85   QHash<QByteArray, QByteArray>::const_iterator quoteIter = ctcpXDelimDequoteHash.constBegin();
  86   while(quoteIter != ctcpXDelimDequoteHash.constEnd()) {
  87     quotedMessage.replace(quoteIter.value(), quoteIter.key());
  88     quoteIter++;
  89   }
  90   return quotedMessage;
  91 }
  92
  93 QByteArray CtcpHandler::xdelimDequote(const QByteArray &message) {
  94   QByteArray dequotedMessage;
  95   QByteArray messagepart;
  96   QHash<QByteArray, QByteArray>::iterator xdelimquote;
  97
  98   for(int i = 0; i < message.size(); i++) {
  99     messagepart = message.mid(i,1);
 100     if(i+1 < message.size()) {
 101       for(xdelimquote = ctcpXDelimDequoteHash.begin(); xdelimquote != ctcpXDelimDequoteHash.end(); ++xdelimquote) {
 102         if(message.mid(i,2) == xdelimquote.key()) {
 103           messagepart = xdelimquote.value();
 104           i++;
 105           break;
 106         }
 107       }
 108     }
 109     dequotedMessage += messagepart;
 110   }
 111   return dequotedMessage;
 112 }
 113
 114 void CtcpHandler::parse(Message::Type messageType, const QString &prefix, const QString &target, const QByteArray &message) {
 115   QByteArray ctcp;
 116
 117   //lowlevel message dequote
 118   QByteArray dequotedMessage = lowLevelDequote(message);
 119
 120   CtcpType ctcptype = messageType == Message::Notice
 121     ? CtcpReply
 122     : CtcpQuery;
 123
 124   Message::Flags flags = (messageType == Message::Notice && !network()->isChannelName(target))
 125     ? Message::Redirected
 126     : Message::None;
 127
 128   // extract tagged / extended data
 129   int xdelimPos = -1;
 130   int xdelimEndPos = -1;
 131   int spacePos = -1;
 132   QList<QByteArray> replies;
 133   while((xdelimPos = dequotedMessage.indexOf(XDELIM)) != -1) {
 134     if(xdelimPos > 0)
 135       displayMsg(messageType, target, userDecode(target, dequotedMessage.left(xdelimPos)), prefix, flags);
 136
 137     xdelimEndPos = dequotedMessage.indexOf(XDELIM, xdelimPos + 1);
 138     if(xdelimEndPos == -1) {
 139       // no matching end delimiter found... treat rest of the message as ctcp
 140       xdelimEndPos = dequotedMessage.count();
 141     }
 142     ctcp = xdelimDequote(dequotedMessage.mid(xdelimPos + 1, xdelimEndPos - xdelimPos - 1));
 143     dequotedMessage = dequotedMessage.mid(xdelimEndPos + 1);
 144
 145     //dispatch the ctcp command
 146     QString ctcpcmd = userDecode(target, ctcp.left(spacePos));
 147     QString ctcpparam = userDecode(target, ctcp.mid(spacePos + 1));
 148
 149     spacePos = ctcp.indexOf(' ');
 150     if(spacePos != -1) {
 151       ctcpcmd = userDecode(target, ctcp.left(spacePos));
 152       ctcpparam = userDecode(target, ctcp.mid(spacePos + 1));
 153     } else {
 154       ctcpcmd = userDecode(target, ctcp);
 155       ctcpparam = QString();
 156     }
 157
 158     if(!_ignoreListManager->ctcpMatch(prefix, network()->networkName(), ctcpcmd.toUpper())) {
 159       QString reply_;
 160       handle(ctcpcmd, Q_ARG(CtcpType, ctcptype), Q_ARG(QString, prefix), Q_ARG(QString, target), Q_ARG(QString, ctcpparam), Q_ARG(QString, reply_));
 161       if(ctcptype == CtcpQuery && !reply_.isNull()) {
 162         replies << lowLevelQuote(pack(serverEncode(ctcpcmd), userEncode(nickFromMask(prefix), reply_)));
 163       }
 164     }
 165   }
 166   if(ctcptype == CtcpQuery && !replies.isEmpty()) {
 167     packedReply(nickFromMask(prefix), replies);
 168   }
 169
 170   if(!dequotedMessage.isEmpty())
 171     displayMsg(messageType, target, userDecode(target, dequotedMessage), prefix, flags);
 172 }
 173
 174 QByteArray CtcpHandler::pack(const QByteArray &ctcpTag, const QByteArray &message) {
 175   if(message.isEmpty())
 176     return XDELIM + ctcpTag + XDELIM;
 177
 178   return XDELIM + ctcpTag + ' ' + xdelimQuote(message) + XDELIM;
 179 }
 180
 181 void CtcpHandler::query(const QString &bufname, const QString &ctcpTag, const QString &message) {
 182   QList<QByteArray> params;
 183   params << serverEncode(bufname) << lowLevelQuote(pack(serverEncode(ctcpTag), userEncode(bufname, message)));
 184   emit putCmd("PRIVMSG", params);
 185 }
 186
 187 void CtcpHandler::reply(const QString &bufname, const QString &ctcpTag, const QString &message) {
 188   QList<QByteArray> params;
 189   params << serverEncode(bufname) << lowLevelQuote(pack(serverEncode(ctcpTag), userEncode(bufname, message)));
 190   emit putCmd("NOTICE", params);
 191 }
 192
 193 void CtcpHandler::packedReply(const QString &bufname, const QList<QByteArray> &replies) {
 194   QList<QByteArray> params;
 195
 196   int answerSize = 0;
 197   for(int i = 0; i < replies.count(); i++) {
 198     answerSize += replies.at(i).size();
 199   }
 200
 201   QByteArray quotedReply(answerSize, 0);
 202   int nextPos = 0;
 203   QByteArray &reply = quotedReply;
 204   for(int i = 0; i < replies.count(); i++) {
 205     reply = replies.at(i);
 206     quotedReply.replace(nextPos, reply.size(), reply);
 207     nextPos += reply.size();
 208   }
 209
 210   params << serverEncode(bufname) << quotedReply;
 211   emit putCmd("NOTICE", params);
 212 }
 213
 214 //******************************/
 215 // CTCP HANDLER
 216 //******************************/
 217 void CtcpHandler::handleAction(CtcpType ctcptype, const QString &prefix, const QString &target, const QString &param, QString &/*reply*/) {
 218   Q_UNUSED(ctcptype)
 219   emit displayMsg(Message::Action, typeByTarget(target), target, param, prefix);
 220 }
 221
 222 void CtcpHandler::handleClientinfo(CtcpType ctcptype, const QString &prefix, const QString &target, const QString &param, QString &reply) {
 223   Q_UNUSED(target)
 224   if(ctcptype == CtcpQuery) {
 225     QStringList supportedHandlers;
 226     foreach(QString handler, providesHandlers()) {
 227       supportedHandlers << handler.toUpper();
 228     }
 229     reply = supportedHandlers.join(" ");
 230     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Received CTCP CLIENTINFO request from %1").arg(prefix));
 231   } else {
 232     // display clientinfo answer
 233     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Received CTCP CLIENTINFO answer from %1: %2")
 234                     .arg(nickFromMask(prefix)).arg(param));
 235   }
 236 }
 237
 238 void CtcpHandler::handlePing(CtcpType ctcptype, const QString &prefix, const QString &target, const QString &param, QString &reply) {
 239   Q_UNUSED(target)
 240   if(ctcptype == CtcpQuery) {
 241     reply = param;
 242     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Received CTCP PING request from %1").arg(prefix));
 243   } else {
 244     // display ping answer
 245     uint now = QDateTime::currentDateTime().toTime_t();
 246     uint then = QDateTime().fromTime_t(param.toInt()).toTime_t();
 247     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Received CTCP PING answer from %1 with %2 seconds round trip time")
 248                     .arg(nickFromMask(prefix)).arg(now-then));
 249   }
 250 }
 251
 252 void CtcpHandler::handleVersion(CtcpType ctcptype, const QString &prefix, const QString &target, const QString &param, QString &reply) {
 253   Q_UNUSED(target)
 254   if(ctcptype == CtcpQuery) {
 255     reply = QString("Quassel IRC %1 (built on %2) -- http://www.quassel-irc.org").arg(Quassel::buildInfo().plainVersionString).arg(Quassel::buildInfo().buildDate);
 256     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Received CTCP VERSION request by %1").arg(prefix));
 257   } else {
 258     // display Version answer
 259     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Received CTCP VERSION answer from %1: %2")
 260                     .arg(nickFromMask(prefix)).arg(param));
 261   }
 262 }
 263
 264 void CtcpHandler::handleTime(CtcpType ctcptype, const QString &prefix, const QString &target, const QString &param, QString &reply) {
 265   Q_UNUSED(target)
 266   if(ctcptype == CtcpQuery) {
 267     reply = QDateTime::currentDateTime().toString();
 268     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Received CTCP TIME request by %1").arg(prefix));
 269   } else {
 270     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Received CTCP TIME answer from %1: %2")
 271                     .arg(nickFromMask(prefix)).arg(param));
 272   }
 273 }
 274
 275 void CtcpHandler::defaultHandler(const QString &cmd, CtcpType ctcptype, const QString &prefix, const QString &target, const QString &param, QString &reply) {
 276   Q_UNUSED(ctcptype);
 277   Q_UNUSED(target);
 278   Q_UNUSED(reply);
 279   QString str = tr("Received unknown CTCP %1 by %2").arg(cmd).arg(prefix);
 280   if(!param.isEmpty())
 281     str.append(tr(" with arguments: %1").arg(param));
 282   emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", str);
 283 }
 284