made the NickSelector at least show your current nick
[quassel.git] / src / core / ircserverhandler.cpp
1 /***************************************************************************
2  *   Copyright (C) 2005-08 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 "ircserverhandler.h"
21
22 #include "util.h"
23
24 #include "networkconnection.h"
25 #include "network.h"
26 #include "ctcphandler.h"
27
28 #include "ircuser.h"
29 #include "ircchannel.h"
30
31 #include <QDebug>
32
33 IrcServerHandler::IrcServerHandler(NetworkConnection *parent)
34   : BasicHandler(parent), server(parent) {
35 }
36
37 IrcServerHandler::~IrcServerHandler() {
38
39 }
40
41 QString IrcServerHandler::serverDecode(const QByteArray &string) {
42   return server->serverDecode(string);
43 }
44
45 QStringList IrcServerHandler::serverDecode(const QList<QByteArray> &stringlist) {
46   QStringList list;
47   foreach(QByteArray s, stringlist) list << server->serverDecode(s);
48   return list;
49 }
50
51 QString IrcServerHandler::bufferDecode(const QString &bufferName, const QByteArray &string) {
52   return server->bufferDecode(bufferName, string);
53 }
54
55 QStringList IrcServerHandler::bufferDecode(const QString &bufferName, const QList<QByteArray> &stringlist) {
56   QStringList list;
57   foreach(QByteArray s, stringlist) list << server->bufferDecode(bufferName, s);
58   return list;
59 }
60
61 QString IrcServerHandler::userDecode(const QString &userNick, const QByteArray &string) {
62   return server->userDecode(userNick, string);
63 }
64
65 QStringList IrcServerHandler::userDecode(const QString &userNick, const QList<QByteArray> &stringlist) {
66   QStringList list;
67   foreach(QByteArray s, stringlist) list << server->userDecode(userNick, s);
68   return list;
69 }
70
71 /*! Handle a raw message string sent by the server. We try to find a suitable handler, otherwise we call a default handler. */
72 void IrcServerHandler::handleServerMsg(QByteArray msg) {
73   try {
74     if(msg.isEmpty()) {
75       qWarning() << "Received empty string from server!";
76       return;
77     }
78
79     // Now we split the raw message into its various parts...
80     QString prefix = "";
81     QByteArray trailing;
82     QString cmd;
83
84     // First, check for a trailing parameter introduced by " :", since this might screw up splitting the msg
85     // NOTE: This assumes that this is true in raw encoding, but well, hopefully there are no servers running in japanese on protocol level...
86     int idx = msg.indexOf(" :");
87     if(idx >= 0) {
88       if(msg.length() > idx + 2) trailing = msg.mid(idx + 2);
89       msg = msg.left(idx);
90     }
91     // OK, now it is safe to split...
92     QList<QByteArray> params = msg.split(' ');
93     if(!trailing.isEmpty()) params << trailing;
94     if(params.count() < 1) {
95       qWarning() << "Received invalid string from server!";
96       return;
97     }
98
99     QString foo = serverDecode(params.takeFirst());
100
101     // a colon as the first chars indicates the existence of a prefix
102     if(foo[0] == ':') {
103       foo.remove(0, 1);
104       prefix = foo;
105       if(params.count() < 1) {
106         qWarning() << "Received invalid string from server!";
107         return;
108       }
109       foo = serverDecode(params.takeFirst());
110     }
111
112     // next string without a whitespace is the command
113     cmd = foo.trimmed().toUpper();
114
115     // numeric replies have the target as first param (RFC 2812 - 2.4). this is usually our own nick. Remove this!
116     uint num = cmd.toUInt();
117     if(num > 0) {
118       if(params.count() == 0) {
119         qWarning() << "Message received from server violates RFC and is ignored!";
120         return;
121       }
122       params.removeFirst();
123     }
124
125     // Now we try to find a handler for this message. BTW, I do love the Trolltech guys ;-)
126     handle(cmd, Q_ARG(QString, prefix), Q_ARG(QList<QByteArray>, params));
127     //handle(cmd, Q_ARG(QString, prefix));
128   } catch(Exception e) {
129     emit displayMsg(Message::Error, "", e.msg());
130   }
131 }
132
133
134 void IrcServerHandler::defaultHandler(QString cmd, QString prefix, QList<QByteArray> rawparams) {
135   // we assume that all this happens in server encoding
136   QStringList params;
137   foreach(QByteArray r, rawparams) params << serverDecode(r);
138   uint num = cmd.toUInt();
139   if(num) {
140     // A lot of server messages don't really need their own handler because they don't do much.
141     // Catch and handle these here.
142     switch(num) {
143       // Welcome, status, info messages. Just display these.
144       case 2: case 3: case 4: case 5: case 251: case 252: case 253: case 254: case 255: case 372: case 375:
145         emit displayMsg(Message::Server, "", params.join(" "), prefix);
146         break;
147       // Server error messages without param, just display them
148       case 409: case 411: case 412: case 422: case 424: case 445: case 446: case 451: case 462:
149       case 463: case 464: case 465: case 466: case 472: case 481: case 483: case 485: case 491: case 501: case 502:
150       case 431: // ERR_NONICKNAMEGIVEN 
151         emit displayMsg(Message::Error, "", params.join(" "), prefix);
152         break;
153       // Server error messages, display them in red. First param will be appended.
154       case 401: case 402: case 403: case 404: case 406: case 408: case 415: case 421: case 442:
155       { QString p = params.takeFirst();
156         emit displayMsg(Message::Error, "", params.join(" ") + " " + p, prefix);
157         break;
158       }
159       // Server error messages which will be displayed with a colon between the first param and the rest
160       case 413: case 414: case 423: case 441: case 444: case 461:
161       case 467: case 471: case 473: case 474: case 475: case 476: case 477: case 478: case 482:
162       case 436: // ERR_NICKCOLLISION
163       { QString p = params.takeFirst();
164         emit displayMsg(Message::Error, "", p + ": " + params.join(" "));
165         break;
166       }
167       // Ignore these commands.
168       case 366: case 376:
169         break;
170
171       // Everything else will be marked in red, so we can add them somewhere.
172       default:
173         emit displayMsg(Message::Error, "", cmd + " " + params.join(" "), prefix);
174     }
175     //qDebug() << prefix <<":"<<cmd<<params;
176   } else {
177     emit displayMsg(Message::Error, "", QString("Unknown: ") + cmd + " " + params.join(" "), prefix);
178     //qDebug() << prefix <<":"<<cmd<<params;
179   }
180 }
181
182 //******************************/
183 // IRC SERVER HANDLER
184 //******************************/
185 void IrcServerHandler::handleJoin(QString prefix, QList<QByteArray> params) {
186   Q_ASSERT(params.count() == 1);
187   QString channel = serverDecode(params[0]);
188   IrcUser *ircuser = network()->updateNickFromMask(prefix);
189   emit displayMsg(Message::Join, channel, channel, prefix);
190   //qDebug() << "IrcServerHandler::handleJoin()" << prefix << params;
191   ircuser->joinChannel(channel);
192 }
193
194 void IrcServerHandler::handleKick(QString prefix, QList<QByteArray> params) {
195   network()->updateNickFromMask(prefix);
196   IrcUser *victim = network()->ircUser(serverDecode(params[1]));
197   QString channel = serverDecode(params[0]);
198   Q_ASSERT(victim);
199
200   victim->partChannel(channel);
201
202   QString msg;
203   if(params.count() > 2) // someone got a reason!
204     msg = QString("%1 %2").arg(victim->nick()).arg(bufferDecode(channel, params[2]));
205   else
206     msg = victim->nick();
207
208   emit displayMsg(Message::Kick, channel, msg, prefix);
209 }
210
211 void IrcServerHandler::handleMode(QString prefix, QList<QByteArray> params) {
212   if(params.count() < 2) {
213     emit displayMsg(Message::Error, "", tr("Received invalid MODE from %s: %s").arg(prefix).arg(serverDecode(params).join(" ")));
214     return;
215   }
216
217   if(network()->isChannelName(params[0])) {
218     // Channel Modes
219     emit displayMsg(Message::Mode, serverDecode(params[0]), serverDecode(params).join(" "), prefix);
220
221     IrcChannel *channel = network()->ircChannel(params.takeFirst());
222     // FIXME: currently the IrcChannels only support PREFIX-Modes for users
223     // This cannot be fixed unless the SignalProxy() doesn't rely on methodIds anymore
224     QString modes = params.takeFirst();
225     bool add = true;
226     int modeIndex = 0;
227     for(int c = 0; c < modes.length(); c++) {
228       if(modes[c] == '+') {
229         add = true;
230         continue;
231       }
232       if(modes[c] == '-') {
233         add = false;
234         continue;
235       }
236
237       // this is the part where we restrict the mode changes to PREFIXES:
238       if(network()->prefixModes().contains(modes[c]) && modeIndex < params.count()) {
239         IrcUser *ircUser = network()->ircUser(params[modeIndex]);
240         if(add)
241           channel->addUserMode(ircUser, QString(modes[c]));
242         else
243           channel->removeUserMode(ircUser, QString(modes[c]));
244       }
245       modeIndex++;
246     }
247     
248   } else {
249     // pure User Modes
250     emit displayMsg(Message::Mode, "", serverDecode(params).join(" "), prefix);
251   }
252 }
253
254 void IrcServerHandler::handleNick(QString prefix, QList<QByteArray> params) {
255   IrcUser *ircuser = network()->updateNickFromMask(prefix);
256   Q_ASSERT(ircuser);
257   QString newnick = serverDecode(params[0]);
258   QString oldnick = ircuser->nick();
259
260   foreach(QString channel, ircuser->channels()) {
261     if(network()->isMyNick(oldnick)) {
262       emit displayMsg(Message::Nick, channel, newnick, newnick);
263     } else {
264       emit displayMsg(Message::Nick, channel, newnick, prefix);
265     }
266   }
267   ircuser->setNick(newnick);
268 }
269
270 void IrcServerHandler::handleNotice(QString prefix, QList<QByteArray> params) {
271   if(network()->currentServer().isEmpty() || network()->currentServer() == prefix)
272     emit displayMsg(Message::Server, "", serverDecode(params[1]), prefix);
273   else
274     emit displayMsg(Message::Notice, "", userDecode(prefix, params[1]), prefix);
275 }
276
277 void IrcServerHandler::handlePart(QString prefix, QList<QByteArray> params) {
278   IrcUser *ircuser = network()->updateNickFromMask(prefix);
279   QString channel = serverDecode(params[0]);
280   Q_ASSERT(ircuser);
281
282   ircuser->partChannel(channel);
283
284   QString msg;
285   if(params.count() > 1)
286     msg = userDecode(ircuser->nick(), params[1]);
287
288   emit displayMsg(Message::Part, channel, msg, prefix);
289 }
290
291 void IrcServerHandler::handlePing(QString prefix, QList<QByteArray> params) {
292   Q_UNUSED(prefix);
293   emit putCmd("PONG", serverDecode(params));
294 }
295
296 void IrcServerHandler::handlePrivmsg(QString prefix, QList<QByteArray> params) {
297   IrcUser *ircuser = network()->updateNickFromMask(prefix);
298   Q_ASSERT(ircuser);
299   if(params.count() < 2)
300     params << QByteArray("");
301
302   QString target = serverDecode(params[0]);
303
304   // are we the target or is it a channel?
305   if(network()->isMyNick(target)) {
306     // it's possible to pack multiple privmsgs into one param using ctcp
307     QStringList messages = server->ctcpHandler()->parse(CtcpHandler::CtcpQuery, prefix, target, userDecode(ircuser->nick(), params[1]));
308     foreach(QString message, messages) {
309       if(!message.isEmpty()) {
310         emit displayMsg(Message::Plain, "", message, prefix, Message::PrivMsg);
311       }
312     }
313   } else {
314     Q_ASSERT(isChannelName(target));  // should be channel!
315     QStringList messages = server->ctcpHandler()->parse(CtcpHandler::CtcpQuery, prefix, target, bufferDecode(target, params[1]));
316     foreach(QString message, messages) {
317       if(!message.isEmpty()) {
318         emit displayMsg(Message::Plain, target, message, prefix);
319       }
320     }
321   }
322
323 }
324
325 void IrcServerHandler::handleQuit(QString prefix, QList<QByteArray> params) {
326   IrcUser *ircuser = network()->updateNickFromMask(prefix);
327   Q_ASSERT(ircuser);
328
329   QString msg;
330   if(params.count())
331     msg = userDecode(ircuser->nick(), params[0]);
332
333   foreach(QString channel, ircuser->channels())
334     emit displayMsg(Message::Quit, channel, msg, prefix);
335
336   network()->removeIrcUser(nickFromMask(prefix));
337 }
338
339 void IrcServerHandler::handleTopic(QString prefix, QList<QByteArray> params) {
340   IrcUser *ircuser = network()->updateNickFromMask(prefix);
341   QString channel = serverDecode(params[0]);
342   QString topic = bufferDecode(channel, params[1]);
343   Q_ASSERT(ircuser);
344
345   network()->ircChannel(channel)->setTopic(topic);
346
347   emit displayMsg(Message::Server, channel, tr("%1 has changed topic for %2 to: \"%3\"").arg(ircuser->nick()).arg(channel).arg(topic));
348 }
349
350 /* RPL_WELCOME */
351 void IrcServerHandler::handle001(QString prefix, QList<QByteArray> params) {
352   // there should be only one param: "Welcome to the Internet Relay Network <nick>!<user>@<host>"
353   QString param = serverDecode(params[0]);
354   QString myhostmask = param.section(' ', -1, -1);
355   network()->setCurrentServer(prefix);
356   network()->setMyNick(nickFromMask(myhostmask));
357
358   emit displayMsg(Message::Server, "", param, prefix);
359 }
360
361 /* RPL_ISUPPORT */
362 // TODO Complete 005 handling, also use sensible defaults for non-sent stuff
363 void IrcServerHandler::handle005(QString prefix, QList<QByteArray> params) {
364   Q_UNUSED(prefix)
365   QString rpl_isupport_suffix = serverDecode(params.takeLast());
366   if(rpl_isupport_suffix.toLower() != QString("are supported by this server")) {
367     qWarning() << "Received invalid RPL_ISUPPORT! Suffix is:" << rpl_isupport_suffix << "Excpected: are supported by this server";
368     return;
369   }
370   
371   foreach(QString param, serverDecode(params)) {
372     QString key = param.section("=", 0, 0);
373     QString value = param.section("=", 1);
374     network()->addSupport(key, value);
375   }
376 }
377
378
379 /* RPL_NOTOPIC */
380 void IrcServerHandler::handle331(QString prefix, QList<QByteArray> params) {
381   Q_UNUSED(prefix);
382   QString channel = serverDecode(params[0]);
383   network()->ircChannel(channel)->setTopic(QString());
384   emit displayMsg(Message::Server, channel, tr("No topic is set for %1.").arg(channel));
385 }
386
387 /* RPL_TOPIC */
388 void IrcServerHandler::handle332(QString prefix, QList<QByteArray> params) {
389   Q_UNUSED(prefix);
390   QString channel = serverDecode(params[0]);
391   QString topic = bufferDecode(channel, params[1]);
392   network()->ircChannel(channel)->setTopic(topic);
393   emit displayMsg(Message::Server, channel, tr("Topic for %1 is \"%2\"").arg(channel, topic));
394 }
395
396 /* Topic set by... */
397 void IrcServerHandler::handle333(QString prefix, QList<QByteArray> params) {
398   Q_UNUSED(prefix);
399   QString channel = serverDecode(params[0]);
400   emit displayMsg(Message::Server, channel, tr("Topic set by %1 on %2")
401       .arg(bufferDecode(channel, params[1]), QDateTime::fromTime_t(bufferDecode(channel, params[2]).toUInt()).toString()));
402 }
403
404 /* RPL_NAMREPLY */
405 void IrcServerHandler::handle353(QString prefix, QList<QByteArray> params) {
406   Q_UNUSED(prefix)
407   params.removeFirst(); // either "=", "*" or "@" indicating a public, private or secret channel
408   QString channelname = serverDecode(params.takeFirst());
409
410   foreach(QString nick, serverDecode(params.takeFirst()).split(' ')) {
411     QString mode = QString();
412
413     if(network()->prefixes().contains(nick[0])) {
414       mode = network()->prefixToMode(nick[0]);
415       nick = nick.mid(1);
416     }
417
418     IrcUser *ircuser = network()->newIrcUser(nick);
419     ircuser->joinChannel(channelname);
420
421     if(!mode.isNull())
422       network()->ircChannel(channelname)->addUserMode(ircuser, mode);
423   }
424 }
425
426 /* ERR_ERRONEUSNICKNAME */
427 void IrcServerHandler::handle432(QString prefix, QList<QByteArray> params) {
428   Q_UNUSED(prefix)
429   Q_UNUSED(params)
430   emit displayMsg(Message::Error, "", tr("Your desired nickname contains illegal characters!"));
431   emit displayMsg(Message::Error, "", tr("Please use /nick <othernick> to continue your IRC-Session!"));
432   // FIXME!
433
434 //   if(params.size() < 2) {
435 //     // handle unreal-ircd bug, where unreal ircd doesnt supply a TARGET in ERR_ERRONEUSNICKNAME during registration phase:
436 //     // nick @@@
437 //     // :irc.scortum.moep.net 432  @@@ :Erroneous Nickname: Illegal characters
438 //     // correct server reply:
439 //     // :irc.scortum.moep.net 432 * @@@ :Erroneous Nickname: Illegal characters
440 //     emit displayMsg(Message::Error, "", tr("There is a nickname in your identity's nicklist which contains illegal characters"));
441 //     emit displayMsg(Message::Error, "", tr("Due to a bug in Unreal IRCd (and maybe other irc-servers too) we're unable to determine the erroneous nick"));
442 //     emit displayMsg(Message::Error, "", tr("Please use: /nick <othernick> to continue or clean up your nicklist"));
443 //   } else {
444 //     QString errnick = params[0];
445 //     emit displayMsg(Message::Error, "", tr("Nick %1 contains illegal characters").arg(errnick));
446 //     // if there is a problem while connecting to the server -> we handle it
447 //     // TODO rely on another source...
448 //     if(currentServer.isEmpty()) {
449 //       QStringList desiredNicks = identity["NickList"].toStringList();
450 //       int nextNick = desiredNicks.indexOf(errnick) + 1;
451 //       if (desiredNicks.size() > nextNick) {
452 //         putCmd("NICK", QStringList(desiredNicks[nextNick]));
453 //       } else {
454 //         emit displayMsg(Message::Error, "", tr("No free and valid nicks in nicklist found. use: /nick <othernick> to continue"));
455 //       }
456 //     }
457 //   }
458 }
459
460 /* ERR_NICKNAMEINUSE */
461 void IrcServerHandler::handle433(QString prefix, QList<QByteArray> params) {
462   Q_UNUSED(prefix)
463   QString errnick = serverDecode(params[0]);
464   emit displayMsg(Message::Error, "", tr("Nick %1 is already taken").arg(errnick));
465   emit displayMsg(Message::Error, "", tr("Please use /nick <othernick> to continue your IRC-Session!"));
466   // FIXME!
467   
468 //   // if there is a problem while connecting to the server -> we handle it
469 //   // TODO rely on another source...
470 //   if(currentServer.isEmpty()) {
471 //     QStringList desiredNicks = identity["NickList"].toStringList();
472 //     int nextNick = desiredNicks.indexOf(errnick) + 1;
473 //     if (desiredNicks.size() > nextNick) {
474 //       putCmd("NICK", QStringList(desiredNicks[nextNick]));
475 //     } else {
476 //       emit displayMsg(Message::Error, "", tr("No free and valid nicks in nicklist found. use: /nick <othernick> to continue"));
477 //     }
478 //   }
479 }
480
481 /***********************************************************************************/
482
483