src/core/ctcphandler.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-09 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   : BasicHandler(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   while((xdelimPos = dequotedMessage.indexOf(XDELIM)) != -1) {
 133     if(xdelimPos > 0)
 134       displayMsg(messageType, target, userDecode(target, dequotedMessage.left(xdelimPos)), prefix, flags);
 135
 136     xdelimEndPos = dequotedMessage.indexOf(XDELIM, xdelimPos + 1);
 137     if(xdelimEndPos == -1) {
 138       // no matching end delimiter found... treat rest of the message as ctcp
 139       xdelimEndPos = dequotedMessage.count();
 140     }
 141     ctcp = xdelimDequote(dequotedMessage.mid(xdelimPos + 1, xdelimEndPos - xdelimPos - 1));
 142     dequotedMessage = dequotedMessage.mid(xdelimEndPos + 1);
 143
 144     //dispatch the ctcp command
 145     QString ctcpcmd = userDecode(target, ctcp.left(spacePos));
 146     QString ctcpparam = userDecode(target, ctcp.mid(spacePos + 1));
 147
 148     spacePos = ctcp.indexOf(' ');
 149     if(spacePos != -1) {
 150       ctcpcmd = userDecode(target, ctcp.left(spacePos));
 151       ctcpparam = userDecode(target, ctcp.mid(spacePos + 1));
 152     } else {
 153       ctcpcmd = userDecode(target, ctcp);
 154       ctcpparam = QString();
 155     }
 156
 157     handle(ctcpcmd, Q_ARG(CtcpType, ctcptype), Q_ARG(QString, prefix), Q_ARG(QString, target), Q_ARG(QString, ctcpparam));
 158   }
 159
 160   if(!dequotedMessage.isEmpty())
 161     displayMsg(messageType, target, userDecode(target, dequotedMessage), prefix, flags);
 162 }
 163
 164 QByteArray CtcpHandler::pack(const QByteArray &ctcpTag, const QByteArray &message) {
 165   return XDELIM + ctcpTag + ' ' + xdelimQuote(message) + XDELIM;
 166 }
 167
 168 void CtcpHandler::query(const QString &bufname, const QString &ctcpTag, const QString &message) {
 169   QList<QByteArray> params;
 170   params << serverEncode(bufname) << lowLevelQuote(pack(serverEncode(ctcpTag), userEncode(bufname, message)));
 171   emit putCmd("PRIVMSG", params);
 172 }
 173
 174 void CtcpHandler::reply(const QString &bufname, const QString &ctcpTag, const QString &message) {
 175   QList<QByteArray> params;
 176   params << serverEncode(bufname) << lowLevelQuote(pack(serverEncode(ctcpTag), userEncode(bufname, message)));
 177   emit putCmd("NOTICE", params);
 178 }
 179
 180 //******************************/
 181 // CTCP HANDLER
 182 //******************************/
 183 void CtcpHandler::handleAction(CtcpType ctcptype, const QString &prefix, const QString &target, const QString &param) {
 184   Q_UNUSED(ctcptype)
 185   emit displayMsg(Message::Action, typeByTarget(target), target, param, prefix);
 186 }
 187
 188 void CtcpHandler::handlePing(CtcpType ctcptype, const QString &prefix, const QString &target, const QString &param) {
 189   Q_UNUSED(target)
 190   if(ctcptype == CtcpQuery) {
 191     if(!_ignoreListManager->ctcpMatch(prefix, network()->networkName(), "PING")) {
 192       reply(nickFromMask(prefix), "PING", param);
 193       emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Received CTCP PING request from %1").arg(prefix));
 194     }
 195   } else {
 196     // display ping answer
 197     uint now = QDateTime::currentDateTime().toTime_t();
 198     uint then = QDateTime().fromTime_t(param.toInt()).toTime_t();
 199     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Received CTCP PING answer from %1 with %2 seconds round trip time").arg(prefix).arg(now-then));
 200   }
 201 }
 202
 203 void CtcpHandler::handleVersion(CtcpType ctcptype, const QString &prefix, const QString &target, const QString &param) {
 204   Q_UNUSED(target)
 205   if(ctcptype == CtcpQuery) {
 206     if(!_ignoreListManager->ctcpMatch(prefix, network()->networkName(), "VERSION")) {
 207       reply(nickFromMask(prefix), "VERSION", QString("Quassel IRC %1 (built on %2) -- http://www.quassel-irc.org")
 208           .arg(Quassel::buildInfo().plainVersionString)
 209           .arg(Quassel::buildInfo().buildDate));
 210       emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Received CTCP VERSION request by %1").arg(prefix));
 211     }
 212   } else {
 213     // display Version answer
 214     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Received CTCP VERSION answer from %1: %2").arg(prefix).arg(param));
 215   }
 216 }
 217
 218 void CtcpHandler::defaultHandler(const QString &cmd, CtcpType ctcptype, const QString &prefix, const QString &target, const QString &param) {
 219   Q_UNUSED(ctcptype);
 220   Q_UNUSED(target);
 221   if(!_ignoreListManager->ctcpMatch(prefix, network()->networkName())) {
 222     QString str = tr("Received unknown CTCP %1 by %2").arg(cmd).arg(prefix);
 223     if(!param.isEmpty())
 224       str.append(tr(" with arguments: %1").arg(param));
 225     emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", str);
 226   }
 227 }
 228
 229