Added getNetworkId(UserId user, const QString &network) to make the transition to...
[quassel.git] / src / core / server.cpp
1 /***************************************************************************
2  *   Copyright (C) 2005-07 by The Quassel Team                             *
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) any later version.                                   *
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 "server.h"
21
22 #include <QMetaObject>
23 #include <QMetaMethod>
24 #include <QDateTime>
25
26 #include "util.h"
27 #include "core.h"
28 #include "coresession.h"
29
30 Server::Server(UserId uid, QString net) : user(uid), network(net) {
31   QString MQUOTE = QString('\020');
32   ctcpMDequoteHash[MQUOTE + '0'] = QString('\000');
33   ctcpMDequoteHash[MQUOTE + 'n'] = QString('\n');
34   ctcpMDequoteHash[MQUOTE + 'r'] = QString('\r');
35   ctcpMDequoteHash[MQUOTE + MQUOTE] = MQUOTE;
36
37   XDELIM = QString('\001');
38   QString XQUOTE = QString('\134');
39   ctcpXDelimDequoteHash[XQUOTE + XQUOTE] = XQUOTE;
40   ctcpXDelimDequoteHash[XQUOTE + QString('a')] = XDELIM;
41   
42   serverinfo = new ServerInfo();
43 }
44
45 Server::~Server() {
46   delete serverinfo;
47 }
48
49 void Server::run() {
50   connect(&socket, SIGNAL(connected()), this, SLOT(socketConnected()));
51   connect(&socket, SIGNAL(disconnected()), this, SLOT(socketDisconnected()));
52   connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(socketError(QAbstractSocket::SocketError)));
53   connect(&socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(socketStateChanged(QAbstractSocket::SocketState)));
54   connect(&socket, SIGNAL(readyRead()), this, SLOT(socketHasData()));
55
56   exec();
57 }
58
59 void Server::sendState() {
60   QVariantMap s;
61   QVariantMap n, t;
62   foreach(QString key, nicks.keys())  { n[key] = nicks[key]; }
63   foreach(QString key, topics.keys()) { t[key] = topics[key];}
64   s["Nicks"] = n;
65   s["Topics"] = t;
66   s["OwnNick"] = ownNick;
67   s["ServerSupports"] = serverSupports;
68   emit serverState(network, s);
69 }
70
71 void Server::connectToIrc(QString net) {
72   if(net != network) return; // not me!
73   CoreSession *sess = Core::session(user);
74   //networkSettings = Global::data(user, "Networks").toMap()[net].toMap();
75   networkSettings = sess->retrieveSessionData("Networks").toMap()[net].toMap();
76   //identity = Global::data(user, "Identities").toMap()[networkSettings["Identity"].toString()].toMap();
77   identity = sess->retrieveSessionData("Identities").toMap()[networkSettings["Identity"].toString()].toMap();
78   QList<QVariant> servers = networkSettings["Servers"].toList();
79   QString host = servers[0].toMap()["Address"].toString();
80   quint16 port = servers[0].toMap()["Port"].toUInt();
81   displayStatusMsg(QString("Connecting to %1:%2...").arg(host).arg(port));
82   socket.connectToHost(host, port);
83 }
84
85 void Server::disconnectFromIrc(QString net) {
86   if(net != network) return; // not me!
87   socket.disconnectFromHost();
88 }
89
90 void Server::socketHasData() {
91   while(socket.canReadLine()) {
92     QByteArray s = socket.readLine().trimmed();
93     //qDebug() << "Read" << s;
94     //emit recvRawServerMsg(s); // signal not needed, and we should make sure we consider encodings where we need them
95     //Message *msg = Message::createFromServerString(this, s);
96     handleServerMsg(s);
97   }
98 }
99
100 void Server::socketError( QAbstractSocket::SocketError err ) {
101   //qDebug() << "Socket Error!";
102   //emit error(err);
103 }
104
105 void Server::socketConnected( ) {
106   emit connected(network);
107   putRawLine(QString("NICK :%1").arg(identity["NickList"].toStringList()[0]));  // FIXME: try more nicks if error occurs
108   putRawLine(QString("USER %1 8 * :%2").arg(identity["Ident"].toString()).arg(identity["RealName"].toString()));
109 }
110
111 void Server::socketDisconnected( ) {
112   //qDebug() << "Socket disconnected!";
113   emit disconnected(network);
114   topics.clear();
115   nicks.clear();
116 }
117
118 void Server::socketStateChanged(QAbstractSocket::SocketState state) {
119   //qDebug() << "Socket state changed: " << state;
120 }
121
122 QString Server::updateNickFromMask(QString mask) {
123   QString user = userFromMask(mask);
124   QString host = hostFromMask(mask);
125   QString nick = nickFromMask(mask);
126   if(nicks.contains(nick) && !user.isEmpty() && !host.isEmpty()) {
127     QVariantMap n = nicks[nick];
128     if(n["User"].toString() != user || n["Host"].toString() != host) {
129       if(!n["User"].toString().isEmpty() || !n["Host"].toString().isEmpty())
130         qWarning(QString("Strange: Hostmask for nick %1 has changed!").arg(nick).toAscii());
131       n["User"] = user; n["Host"] = host;
132       nicks[nick] = n;
133       emit nickUpdated(network, nick, n);
134     }
135   }
136   return nick;
137 }
138
139 void Server::userInput(QString net, QString buf, QString msg) {
140   if(net != network) return; // not me!
141   //msg = msg.trimmed(); // remove whitespace from start and end
142   if(msg.isEmpty()) return;
143   if(!msg.startsWith('/')) {
144     msg = QString("/SAY ") + msg;
145   }
146   handleUserInput(buf, msg);
147 }
148
149 void Server::putRawLine(QString s) {
150 //  qDebug() << "SentRaw: " << s;
151   s += "\r\n";
152   socket.write(s.toAscii());
153 }
154
155 void Server::putCmd(QString cmd, QStringList params, QString prefix) {
156   QString m;
157   if(!prefix.isEmpty()) m += ":" + prefix + " ";
158   m += cmd.toUpper();
159   for(int i = 0; i < params.size() - 1; i++) {
160     m += " " + params[i];
161   }
162   if(!params.isEmpty()) m += " :" + params.last();
163 //  qDebug() << "Sent: " << m;
164   m += "\r\n";
165   socket.write(m.toAscii());
166 }
167
168 /*! Handle a raw message string sent by the server. We try to find a suitable handler, otherwise we call a default handler. */
169 void Server::handleServerMsg(QByteArray rawmsg) {
170   try {
171     if(rawmsg.isEmpty()) {
172       qWarning() << "Received empty string from server!";
173       return;
174     }
175     // TODO Implement encoding conversion
176     /* At this point, we have a raw message as a byte array. This needs to be converted to a QString somewhere.
177      * Problem is, that at this point we don't know which encoding to use for the various parts of the message.
178      * This is something the command handler needs to take care of (e.g. PRIVMSG needs to first parse for CTCP,
179      * and then convert the raw strings into the correct encoding.
180      * We _can_ safely assume Server encoding for prefix and cmd, but not for the params. Therefore, we need to
181      * change from a QStringList to a QList<QByteArray> in all the handlers, and have the handlers call decodeString
182      * where needed...
183     */
184     QString msg = QString::fromLatin1(rawmsg);
185
186     // OK, first we split the raw message into its various parts...
187     QString prefix = "";
188     QString cmd;
189     QStringList params;
190
191     // check for prefix by checking for a colon as the first char
192     if(msg[0] == ':') {
193       msg.remove(0,1);
194       prefix = msg.section(' ', 0, 0);
195       msg = msg.section(' ', 1);
196     }
197
198     // next string without a whitespace is the command
199     cmd = msg.section(' ', 0, 0).toUpper();
200     msg = msg.mid(cmd.length());
201
202     // get the parameters
203     QString trailing = "";
204     if(msg.contains(" :")) {
205       trailing = msg.section(" :", 1);
206       msg = msg.section(" :", 0, 0);
207     }
208     if(!msg.isEmpty()) {
209       params << msg.split(' ', QString::SkipEmptyParts);
210     }
211     if(!trailing.isEmpty()) {
212       params << trailing;
213     }
214
215     // numeric replies have the target as first param (RFC 2812 - 2.4). this is usually our own nick. Remove this!
216     uint num = cmd.toUInt();
217     if(num > 0) {
218       Q_ASSERT(params.count() > 0); // Violation to RFC
219       params.removeFirst();
220     }
221
222     // Now we try to find a handler for this message. BTW, I do love the Trolltech guys ;-)
223     QString hname = cmd.toLower();
224     hname[0] = hname[0].toUpper();
225     hname = "handleServer" + hname;
226     if(!QMetaObject::invokeMethod(this, hname.toAscii(), Q_ARG(QString, prefix), Q_ARG(QStringList, params))) {
227       // Ok. Default handler it is.
228       defaultServerHandler(cmd, prefix, params);
229     }
230   } catch(Exception e) {
231     emit displayMsg(Message::Error, "", e.msg());
232   }
233 }
234
235 void Server::defaultServerHandler(QString cmd, QString prefix, QStringList params) {
236   uint num = cmd.toUInt();
237   if(num) {
238     // A lot of server messages don't really need their own handler because they don't do much.
239     // Catch and handle these here.
240     switch(num) {
241       // Welcome, status, info messages. Just display these.
242       case 2: case 3: case 4: case 5: case 251: case 252: case 253: case 254: case 255: case 372: case 375:
243         emit displayMsg(Message::Server, "", params.join(" "), prefix);
244         break;
245       // Server error messages without param, just display them
246       case 409: case 411: case 412: case 422: case 424: case 445: case 446: case 451: case 462:
247       case 463: case 464: case 465: case 466: case 472: case 481: case 483: case 485: case 491: case 501: case 502:
248       case 431: // ERR_NONICKNAMEGIVEN 
249         emit displayMsg(Message::Error, "", params.join(" "), prefix);
250         break;
251       // Server error messages, display them in red. First param will be appended.
252       case 401: case 402: case 403: case 404: case 406: case 408: case 415: case 421: case 442:
253       { QString p = params.takeFirst();
254         emit displayMsg(Message::Error, "", params.join(" ") + " " + p, prefix);
255         break;
256       }
257       // Server error messages which will be displayed with a colon between the first param and the rest
258       case 413: case 414: case 423: case 441: case 444: case 461:
259       case 467: case 471: case 473: case 474: case 475: case 476: case 477: case 478: case 482:
260       case 436: // ERR_NICKCOLLISION
261       { QString p = params.takeFirst();
262         emit displayMsg(Message::Error, "", p + ": " + params.join(" "));
263         break;
264       }
265       // Ignore these commands.
266       case 366: case 376:
267         break;
268
269       // Everything else will be marked in red, so we can add them somewhere.
270       default:
271         emit displayMsg(Message::Error, "", cmd + " " + params.join(" "), prefix);
272     }
273     //qDebug() << prefix <<":"<<cmd<<params;
274   } else {
275     emit displayMsg(Message::Error, "", QString("Unknown: ") + cmd + " " + params.join(" "), prefix);
276     //qDebug() << prefix <<":"<<cmd<<params;
277   }
278 }
279
280 void Server::handleUserInput(QString bufname, QString usrMsg) {
281   try {
282     /* Looks like we don't need core-side buffers...
283     Buffer *buffer = 0;
284     if(!bufname.isEmpty()) {
285       Q_ASSERT(buffers.contains(bufname));
286       buffer = buffers[bufname];
287     }
288     */
289     QString cmd = usrMsg.section(' ', 0, 0).remove(0, 1).toUpper();
290     QString msg = usrMsg.section(' ', 1);
291     QString hname = cmd.toLower();
292     hname[0] = hname[0].toUpper();
293     hname = "handleUser" + hname;
294     if(!QMetaObject::invokeMethod(this, hname.toAscii(), Q_ARG(QString, bufname), Q_ARG(QString, msg))) {
295         // Ok. Default handler it is.
296       defaultUserHandler(bufname, cmd, msg);
297     }
298   } catch(Exception e) {
299     emit displayMsg(Message::Error, "", e.msg());
300   }
301 }
302
303 void Server::defaultUserHandler(QString bufname, QString cmd, QString msg) {
304   emit displayMsg(Message::Error, "", QString("Error: %1 %2").arg(cmd).arg(msg));
305
306 }
307
308 QStringList Server::providesUserHandlers() {
309   QStringList userHandlers;
310   for(int i=0; i < metaObject()->methodCount(); i++) {
311     QString methodSignature(metaObject()->method(i).signature());
312     if (methodSignature.startsWith("handleUser")) {
313       methodSignature = methodSignature.section('(',0,0);  // chop the attribute list
314       methodSignature = methodSignature.mid(10); // strip "handleUser"
315       userHandlers << methodSignature;
316     }
317   }
318   return userHandlers;
319 }
320
321 QString Server::ctcpDequote(QString message) {
322   QString dequotedMessage;
323   QString messagepart;
324   QHash<QString, QString>::iterator ctcpquote;
325   
326   // copy dequote Message
327   for(int i = 0; i < message.size(); i++) {
328     messagepart = message[i];
329     if(i+1 < message.size()) {
330       for(ctcpquote = ctcpMDequoteHash.begin(); ctcpquote != ctcpMDequoteHash.end(); ++ctcpquote) {
331         if(message.mid(i,2) == ctcpquote.key()) {
332           dequotedMessage += ctcpquote.value();
333           i++;
334           break;
335         }
336       }
337     }
338     dequotedMessage += messagepart;
339   }
340   return dequotedMessage;
341 }
342
343
344 QString Server::ctcpXdelimDequote(QString message) {
345   QString dequotedMessage;
346   QString messagepart;
347   QHash<QString, QString>::iterator xdelimquote;
348
349   for(int i = 0; i < message.size(); i++) {
350     messagepart = message[i];
351     if(i+1 < message.size()) {
352       for(xdelimquote = ctcpXDelimDequoteHash.begin(); xdelimquote != ctcpXDelimDequoteHash.end(); ++xdelimquote) {
353         if(message.mid(i,2) == xdelimquote.key()) {
354           messagepart = xdelimquote.value();
355           i++;
356           break;
357         }
358       }
359     }
360     dequotedMessage += messagepart;
361   }
362   return dequotedMessage;
363 }
364
365 QStringList Server::parseCtcp(CtcpType ctcptype, QString prefix, QString target, QString message) {
366   QStringList messages;
367   QString ctcp;
368   
369   //lowlevel message dequote
370   QString dequotedMessage = ctcpDequote(message);
371   
372   // extract tagged / extended data
373   while(dequotedMessage.contains(XDELIM)) {
374     messages << dequotedMessage.section(XDELIM,0,0);
375     ctcp = ctcpXdelimDequote(dequotedMessage.section(XDELIM,1,1));
376     dequotedMessage = dequotedMessage.section(XDELIM,2,2);
377     
378     //dispatch the ctcp command
379     QString ctcpcmd = ctcp.section(' ', 0, 0);
380     QString ctcpparam = ctcp.section(' ', 1);
381     
382     QString hname = ctcpcmd.toLower();
383     hname[0] = hname[0].toUpper();
384     hname = "handleCtcp" + hname;
385     if(!QMetaObject::invokeMethod(this, hname.toAscii(), Q_ARG(CtcpType, ctcptype), Q_ARG(QString, prefix), Q_ARG(QString, target), Q_ARG(QString, ctcpparam))) {
386       // Ok. Default handler it is.
387       defaultCtcpHandler(ctcptype, prefix, ctcpcmd, target, ctcpparam);
388     }
389   }
390   if(!dequotedMessage.isEmpty()) {
391     messages << dequotedMessage;
392   }
393   return messages;
394 }
395
396 QString Server::ctcpPack(QString ctcpTag, QString message) {
397   return XDELIM + ctcpTag + ' ' + message + XDELIM;
398 }
399
400 void Server::ctcpQuery(QString bufname, QString ctcpTag, QString message) {
401   QStringList params;
402   params << bufname << ctcpPack(ctcpTag, message);
403   putCmd("PRIVMSG", params); 
404 }
405
406 void Server::ctcpReply(QString bufname, QString ctcpTag, QString message) {
407   QStringList params;
408   params << bufname << ctcpPack(ctcpTag, message);
409   putCmd("NOTICE", params);
410 }
411
412 /**********************************************************************************/
413
414 /*
415 void Server::handleUser(QString bufname, QString msg) {
416
417
418 }
419 */
420
421 void Server::handleUserAway(QString bufname, QString msg) {
422   putCmd("AWAY", QStringList(msg));
423 }
424
425 void Server::handleUserDeop(QString bufname, QString msg) {
426   QStringList nicks = msg.split(' ', QString::SkipEmptyParts);
427   QString m = "-"; for(int i = 0; i < nicks.count(); i++) m += 'o';
428   QStringList params;
429   params << bufname << m << nicks;
430   putCmd("MODE", params);
431 }
432
433 void Server::handleUserDevoice(QString bufname, QString msg) {
434   QStringList nicks = msg.split(' ', QString::SkipEmptyParts);
435   QString m = "-"; for(int i = 0; i < nicks.count(); i++) m += 'v';
436   QStringList params;
437   params << bufname << m << nicks;
438   putCmd("MODE", params);
439 }
440
441 void Server::handleUserInvite(QString bufname, QString msg) {
442   QStringList params;
443   params << msg << bufname;
444   putCmd("INVITE", params);
445 }
446
447 void Server::handleUserJoin(QString bufname, QString msg) {
448   putCmd("JOIN", QStringList(msg));
449 }
450
451 void Server::handleUserKick(QString bufname, QString msg) {
452   QStringList params;
453   params << bufname << msg.split(' ', QString::SkipEmptyParts);
454   putCmd("KICK", params);
455 }
456
457 void Server::handleUserList(QString bufname, QString msg) {
458   putCmd("LIST", msg.split(' ', QString::SkipEmptyParts));
459 }
460
461 void Server::handleUserMode(QString bufname, QString msg) {
462   putCmd("MODE", msg.split(' ', QString::SkipEmptyParts));
463 }
464
465 // TODO: show privmsgs
466 void Server::handleUserMsg(QString bufname, QString msg) {
467   QString nick = msg.section(" ", 0, 0);
468   msg = msg.section(" ", 1);
469   if(nick.isEmpty() || msg.isEmpty()) return;
470   QStringList params;
471   params << nick << msg;
472   putCmd("PRIVMSG", params);
473 }
474
475 void Server::handleUserNick(QString bufname, QString msg) {
476   QString nick = msg.section(' ', 0, 0);
477   putCmd("NICK", QStringList(nick));
478 }
479
480 void Server::handleUserOp(QString bufname, QString msg) {
481   QStringList nicks = msg.split(' ', QString::SkipEmptyParts);
482   QString m = "+"; for(int i = 0; i < nicks.count(); i++) m += 'o';
483   QStringList params;
484   params << bufname << m << nicks;
485   putCmd("MODE", params);
486 }
487
488 void Server::handleUserPart(QString bufname, QString msg) {
489   QStringList params;
490   params << bufname << msg;
491   putCmd("PART", params);
492 }
493
494 // TODO: implement queries
495 void Server::handleUserQuery(QString bufname, QString msg) {
496   QString nick = msg.section(' ', 0, 0);
497   if(!nick.isEmpty()) emit queryRequested(network, nick);
498 }
499
500 void Server::handleUserQuit(QString bufname, QString msg) {
501   putCmd("QUIT", QStringList(msg));
502 }
503
504 void Server::handleUserQuote(QString bufname, QString msg) {
505   putRawLine(msg);
506 }
507
508 void Server::handleUserSay(QString bufname, QString msg) {
509   if(bufname.isEmpty()) return;  // server buffer
510   QStringList params;
511   params << bufname << msg;
512   putCmd("PRIVMSG", params);
513   if(isChannelName(bufname)) {
514     emit displayMsg(Message::Plain, params[0], msg, ownNick, Message::Self);
515   } else {
516     emit displayMsg(Message::Plain, params[0], msg, ownNick, Message::Self|Message::PrivMsg);
517   }
518 }
519
520 void Server::handleUserMe(QString bufname, QString msg) {
521   if(bufname.isEmpty()) return; // server buffer
522   ctcpQuery(bufname, "ACTION", msg);
523   emit displayMsg(Message::Action, bufname, msg, ownNick);
524 }
525
526 void Server::handleUserTopic(QString bufname, QString msg) {
527   if(bufname.isEmpty()) return;
528   QStringList params;
529   params << bufname << msg;
530   putCmd("TOPIC", params);
531 }
532
533 void Server::handleUserVoice(QString bufname, QString msg) {
534   QStringList nicks = msg.split(' ', QString::SkipEmptyParts);
535   QString m = "+"; for(int i = 0; i < nicks.count(); i++) m += 'v';
536   QStringList params;
537   params << bufname << m << nicks;
538   putCmd("MODE", params);
539 }
540
541 /**********************************************************************************/
542
543 void Server::handleServerJoin(QString prefix, QStringList params) {
544   Q_ASSERT(params.count() == 1);
545   QString nick = updateNickFromMask(prefix);
546   emit displayMsg(Message::Join, params[0], params[0], prefix);
547   if(nick == ownNick) {
548   //  Q_ASSERT(!buffers.contains(params[0]));  // cannot join a buffer twice!
549   //  Buffer *buf = new Buffer(params[0]);
550   //  buffers[params[0]] = buf;
551     topics[params[0]] = "";
552     emit topicSet(network, params[0], "");
553   } //else {
554     QVariantMap n;
555     if(nicks.contains(nick)) {
556       n = nicks[nick];
557       QVariantMap chans = n["Channels"].toMap();
558       // Q_ASSERT(!chans.keys().contains(params[0])); TODO uncomment
559       chans[params[0]] = QVariantMap();
560       n["Channels"] = chans;
561       nicks[nick] = n; qDebug() << network << nick << n;
562       emit nickUpdated(network, nick, n);
563     } else {
564       QVariantMap chans;
565       chans[params[0]] = QVariantMap();
566       n["Channels"] = chans;
567       n["User"] = userFromMask(prefix);
568       n["Host"] = hostFromMask(prefix);
569       nicks[nick] = n;
570       emit nickAdded(network, nick, n);
571     }
572     //emit displayMsg(Message::Join, params[0], params[0], prefix);
573   //}
574 }
575
576 void Server::handleServerKick(QString prefix, QStringList params) {
577   QString kicker = updateNickFromMask(prefix);
578   QString nick = params[1];
579   Q_ASSERT(nicks.contains(nick));
580   QVariantMap n = nicks[nick];
581   QVariantMap chans = n["Channels"].toMap();
582   Q_ASSERT(chans.contains(params[0]));
583   chans.remove(params[0]);
584   QString msg = nick;
585   if(params.count() > 2) msg = QString("%1 %2").arg(msg).arg(params[2]);
586   emit displayMsg(Message::Kick, params[0], msg, prefix);
587   if(chans.count() > 0) {
588     n["Channels"] = chans;
589     nicks[nick] = n;
590     emit nickUpdated(network, nick, n);
591   } else {
592     nicks.remove(nick);
593     emit nickRemoved(network, nick);
594   }
595   if(nick == ownNick) {
596     topics.remove(params[0]);
597   }
598 }
599
600 void Server::handleServerMode(QString prefix, QStringList params) {
601   if(isChannelName(params[0])) {
602     // TODO only channel-user modes supported by now
603     QString prefixes = serverSupports["PrefixModes"].toString();
604     QString modes = params[1];
605     int p = 2;
606     int m = 0;
607     bool add = true;
608     while(m < modes.length()) {
609       if(modes[m] == '+') { add = true; m++; continue; }
610       if(modes[m] == '-') { add = false; m++; continue; }
611       if(prefixes.contains(modes[m])) {  // it's a user channel mode
612         Q_ASSERT(params.count() > m);
613         QString nick = params[p++];
614         if(nicks.contains(nick)) {  // sometimes, a server might try to set a MODE on a nick that is no longer there
615           QVariantMap n = nicks[nick]; QVariantMap clist = n["Channels"].toMap(); QVariantMap chan = clist[params[0]].toMap();
616           QString mstr = chan["Mode"].toString();
617           add ? mstr += modes[m] : mstr.remove(modes[m]);
618           chan["Mode"] = mstr; clist[params[0]] = chan; n["Channels"] = clist; nicks[nick] = n;
619           emit nickUpdated(network, nick, n);
620         }
621         m++;
622       } else {
623         // TODO add more modes
624         m++;
625       }
626     }
627     emit displayMsg(Message::Mode, params[0], params.join(" "), prefix);
628   } else {
629     //Q_ASSERT(nicks.contains(params[0]));
630     //QVariantMap n = nicks[params[0]].toMap();
631     //QString mode = n["Mode"].toString();
632     emit displayMsg(Message::Mode, "", params.join(" "));
633   }
634 }
635
636 void Server::handleServerNick(QString prefix, QStringList params) {
637   QString oldnick = updateNickFromMask(prefix);
638   QString newnick = params[0];
639   QVariantMap v = nicks.take(oldnick);
640   nicks[newnick] = v;
641   QVariantMap chans = v["Channels"].toMap();
642   foreach(QString c, chans.keys()) {
643     if(oldnick != ownNick) { emit displayMsg(Message::Nick, c, newnick, prefix); }
644     else { emit displayMsg(Message::Nick, c, newnick, newnick); }
645   }
646   emit nickRenamed(network, oldnick, newnick);
647   if(oldnick == ownNick) {
648     ownNick = newnick;
649     emit ownNickSet(network, newnick);
650   }
651 }
652
653 void Server::handleServerNotice(QString prefix, QStringList params) {
654   //Message msg(Message::Notice, params[1], prefix);
655   if(currentServer.isEmpty() || prefix == currentServer) emit displayMsg(Message::Server, "", params[1], prefix);
656   else emit displayMsg(Message::Notice, "", params[1], prefix);
657 }
658
659 void Server::handleServerPart(QString prefix, QStringList params) {
660   QString nick = updateNickFromMask(prefix);
661   Q_ASSERT(nicks.contains(nick));
662   QVariantMap n = nicks[nick];
663   QVariantMap chans = n["Channels"].toMap();
664   Q_ASSERT(chans.contains(params[0]));
665   chans.remove(params[0]);
666   QString msg;
667   if(params.count() > 1) msg = params[1];
668   emit displayMsg(Message::Part, params[0], msg, prefix);
669   if(chans.count() > 0) {
670     n["Channels"] = chans;
671     nicks[nick] = n;
672     emit nickUpdated(network, nick, n);
673   } else {
674     nicks.remove(nick);
675     emit nickRemoved(network, nick);
676   }
677   if(nick == ownNick) {
678     Q_ASSERT(topics.contains(params[0]));
679     topics.remove(params[0]);
680   }
681 }
682
683 void Server::handleServerPing(QString prefix, QStringList params) {
684   putCmd("PONG", params);
685 }
686
687 void Server::handleServerPrivmsg(QString prefix, QStringList params) {
688   updateNickFromMask(prefix);
689   Q_ASSERT(params.count() >= 2);
690   if(params.count()<2) emit displayMsg(Message::Plain, params[0], "", prefix);
691   else {
692     // it's possible to pack multiple privmsgs into one param using ctcp
693     QStringList messages = parseCtcp(Server::CtcpQuery, prefix, params[0], params[1]);
694     if(params[0].toLower() == ownNick.toLower()) {  // Freenode sends nickname in lower case!
695       foreach(QString message, messages) {
696         if(!message.isEmpty()) {
697           emit displayMsg(Message::Plain, "", message, prefix, Message::PrivMsg);
698         }
699       }
700       
701     } else {
702       //qDebug() << prefix << params;
703       Q_ASSERT(isChannelName(params[0]));  // should be channel!
704       foreach(QString message, messages) {
705         if(!message.isEmpty()) {
706           emit displayMsg(Message::Plain, params[0], message, prefix);
707         }
708       }
709     }
710   }
711 }
712
713 void Server::handleServerQuit(QString prefix, QStringList params) {
714   QString nick = updateNickFromMask(prefix);
715   Q_ASSERT(nicks.contains(nick));
716   QVariantMap chans = nicks[nick]["Channels"].toMap();
717   QString msg;
718   if(params.count()) msg = params[0];
719   foreach(QString c, chans.keys()) {
720     emit displayMsg(Message::Quit, c, msg, prefix);
721   }
722   nicks.remove(nick);
723   emit nickRemoved(network, nick);
724 }
725
726 void Server::handleServerTopic(QString prefix, QStringList params) {
727   QString nick = updateNickFromMask(prefix);
728   Q_ASSERT(nicks.contains(nick));
729   topics[params[0]] = params[1];
730   emit topicSet(network, params[0], params[1]);
731   emit displayMsg(Message::Server, params[0], tr("%1 has changed topic for %2 to: \"%3\"").arg(nick).arg(params[0]).arg(params[1]));
732 }
733
734 /* RPL_WELCOME */
735 void Server::handleServer001(QString prefix, QStringList params) {
736   // there should be only one param: "Welcome to the Internet Relay Network <nick>!<user>@<host>"
737   currentServer = prefix;
738   ownNick = params[0].section(' ', -1, -1).section('!', 0, 0);
739   QVariantMap n;
740   n["Channels"] = QVariantMap();
741   nicks[ownNick] = n;
742   emit ownNickSet(network, ownNick);
743   emit nickAdded(network, ownNick, QVariantMap());
744   emit displayMsg(Message::Server, "", params[0], prefix);
745   // send performlist
746   QStringList performList = networkSettings["Perform"].toString().split( "\n" );
747   int count = performList.count();
748   for(int a = 0; a < count; a++) {
749     if(!performList[a].isEmpty() ) {
750       userInput(network, "", performList[a]);
751     }
752   }
753 }
754
755 /* RPL_ISUPPORT */
756 // TODO Complete 005 handling, also use sensible defaults for non-sent stuff
757 void Server::handleServer005(QString prefix, QStringList params) {
758   //qDebug() << prefix << params;
759   params.removeLast();
760   foreach(QString p, params) {
761     QString key = p.section("=", 0, 0);
762     QString val = p.section("=", 1);
763     serverSupports[key] = val;
764     // handle some special cases
765     if(key == "PREFIX") {
766       QVariantMap foo; QString modes, prefixes;
767       Q_ASSERT(val.contains(')') && val.startsWith('('));
768       int m = 1, p;
769       for(p = 2; p < val.length(); p++) if(val[p] == ')') break;
770       p++;
771       for(; val[m] != ')'; m++, p++) {
772         Q_ASSERT(p < val.length());
773         foo[QString(val[m])] = QString(val[p]);
774         modes += val[m]; prefixes += val[p];
775       }
776       serverSupports["PrefixModes"] = modes; serverSupports["Prefixes"] = prefixes;
777       serverSupports["ModePrefixMap"] = foo;
778     }
779   }
780 }
781
782
783 /* RPL_NOTOPIC */
784 void Server::handleServer331(QString prefix, QStringList params) {
785   topics[params[0]] = "";
786   emit topicSet(network, params[0], "");
787   emit displayMsg(Message::Server, params[0], tr("No topic is set for %1.").arg(params[0]));
788 }
789
790 /* RPL_TOPIC */
791 void Server::handleServer332(QString prefix, QStringList params) {
792   topics[params[0]] = params[1];
793   emit topicSet(network, params[0], params[1]);
794   emit displayMsg(Message::Server, params[0], tr("Topic for %1 is \"%2\"").arg(params[0]).arg(params[1]));
795 }
796
797 /* Topic set by... */
798 void Server::handleServer333(QString prefix, QStringList params) {
799   emit displayMsg(Message::Server, params[0],
800                     tr("Topic set by %1 on %2").arg(params[1]).arg(QDateTime::fromTime_t(params[2].toUInt()).toString()));
801 }
802
803 /* RPL_NAMREPLY */
804 void Server::handleServer353(QString prefix, QStringList params) {
805   params.removeFirst(); // = or *
806   QString buf = params.takeFirst();
807   QString prefixes = serverSupports["Prefixes"].toString();
808   foreach(QString nick, params[0].split(' ')) {
809     QString mode = "", pfx = "";
810     if(prefixes.contains(nick[0])) {
811       pfx = nick[0];
812       for(int i = 0;; i++)
813         if(prefixes[i] == nick[0]) { mode = serverSupports["PrefixModes"].toString()[i]; break; }
814       nick.remove(0,1);
815     }
816     QVariantMap c; c["Mode"] = mode; c["Prefix"] = pfx;
817     if(nicks.contains(nick)) {
818       QVariantMap n = nicks[nick];
819       QVariantMap chans = n["Channels"].toMap();
820       chans[buf] = c;
821       n["Channels"] = chans;
822       nicks[nick] = n;
823       emit nickUpdated(network, nick, n);
824     } else {
825       QVariantMap n; QVariantMap c; QVariantMap chans;
826       c["Mode"] = mode;
827       chans[buf] = c;
828       n["Channels"] = chans;
829       nicks[nick] = n;
830       emit nickAdded(network, nick, n);
831     }
832   }
833 }
834
835 /* ERR_ERRONEUSNICKNAME */
836 void Server::handleServer432(QString prefix, QStringList params) {
837   if(params.size() < 2) {
838     // handle unreal-ircd bug, where unreal ircd doesnt supply a TARGET in ERR_ERRONEUSNICKNAME during registration phase:
839     // nick @@@
840     // :irc.scortum.moep.net 432  @@@ :Erroneous Nickname: Illegal characters
841     // correct server reply:
842     // :irc.scortum.moep.net 432 * @@@ :Erroneous Nickname: Illegal characters
843     emit displayMsg(Message::Error, "", tr("There is a nickname in your identity's nicklist which contains illegal characters"));
844     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"));
845     emit displayMsg(Message::Error, "", tr("Please use: /nick <othernick> to continue or clean up your nicklist"));
846   } else {
847     QString errnick = params[0];
848     emit displayMsg(Message::Error, "", tr("Nick %1 contains illegal characters").arg(errnick));
849     // if there is a problem while connecting to the server -> we handle it
850     // TODO rely on another source...
851     if(currentServer.isEmpty()) {
852       QStringList desiredNicks = identity["NickList"].toStringList();
853       int nextNick = desiredNicks.indexOf(errnick) + 1;
854       if (desiredNicks.size() > nextNick) {
855         putCmd("NICK", QStringList(desiredNicks[nextNick]));
856       } else {
857         emit displayMsg(Message::Error, "", tr("No free and valid nicks in nicklist found. use: /nick <othernick> to continue"));
858       }
859     }
860   }
861 }
862
863 /* ERR_NICKNAMEINUSE */
864 void Server::handleServer433(QString prefix, QStringList params) {
865   QString errnick = params[0];
866   emit displayMsg(Message::Error, "", tr("Nick %1 is already taken").arg(errnick));
867   // if there is a problem while connecting to the server -> we handle it
868   // TODO rely on another source...
869   if(currentServer.isEmpty()) {
870     QStringList desiredNicks = identity["NickList"].toStringList();
871     int nextNick = desiredNicks.indexOf(errnick) + 1;
872     if (desiredNicks.size() > nextNick) {
873       putCmd("NICK", QStringList(desiredNicks[nextNick]));
874     } else {
875       emit displayMsg(Message::Error, "", tr("No free and valid nicks in nicklist found. use: /nick <othernick> to continue"));
876     }
877   }
878 }
879
880 /***********************************************************************************/
881 // CTCP HANDLER
882
883 void Server::handleCtcpAction(CtcpType ctcptype, QString prefix, QString target, QString param) {
884   emit displayMsg(Message::Action, target, param, prefix);
885 }
886
887 void Server::handleCtcpPing(CtcpType ctcptype, QString prefix, QString target, QString param) {
888   if(ctcptype == CtcpQuery) {
889     ctcpReply(nickFromMask(prefix), "PING", param);
890     emit displayMsg(Message::Server, "", tr("Received CTCP PING request by %1").arg(prefix));
891   } else {
892     // display ping answer
893   }
894 }
895
896 void Server::handleCtcpVersion(CtcpType ctcptype, QString prefix, QString target, QString param) {
897   if(ctcptype == CtcpQuery) {
898     // FIXME use real Info about quassel :)
899     //ctcpReply(nickFromMask(prefix), "VERSION", QString("Quassel:pre Release:*nix"));
900     ctcpReply(nickFromMask(prefix), "VERSION", QString("Quassel IRC (Pre-Release) - http://www.quassel-irc.org"));
901     emit displayMsg(Message::Server, "", tr("Received CTCP VERSION request by %1").arg(prefix));
902   } else {
903     // TODO display Version answer
904   }
905 }
906
907 void Server::defaultCtcpHandler(CtcpType ctcptype, QString prefix, QString cmd, QString target, QString param) {
908   emit displayMsg(Message::Error, "", tr("Received unknown CTCP %1 by %2").arg(cmd).arg(prefix));
909 }
910
911
912 /***********************************************************************************/
913
914 /* Exception classes for message handling */
915 Server::ParseError::ParseError(QString cmd, QString prefix, QStringList params) {
916   _msg = QString("Command Parse Error: ") + cmd + params.join(" ");
917
918 }
919
920 Server::UnknownCmdError::UnknownCmdError(QString cmd, QString prefix, QStringList params) {
921   _msg = QString("Unknown Command: ") + cmd;
922
923 }