src/core/ircserverhandler.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 "ircserverhandler.h"
  21
  22 #include "util.h"
  23
  24 #include "coresession.h"
  25 #include "coreirclisthelper.h"
  26 #include "coreidentity.h"
  27 #include "ctcphandler.h"
  28
  29 #include "ircuser.h"
  30 #include "coreircchannel.h"
  31 #include "logger.h"
  32
  33 #include <QDebug>
  34
  35 IrcServerHandler::IrcServerHandler(CoreNetwork *parent)
  36   : BasicHandler(parent),
  37     _whois(false)
  38 {
  39 }
  40
  41 IrcServerHandler::~IrcServerHandler() {
  42   if(!_netsplits.empty())
  43     qDeleteAll(_netsplits);
  44 }
  45
  46 /*! Handle a raw message string sent by the server. We try to find a suitable handler, otherwise we call a default handler. */
  47 void IrcServerHandler::handleServerMsg(QByteArray msg) {
  48   if(msg.isEmpty()) {
  49     qWarning() << "Received empty string from server!";
  50     return;
  51   }
  52
  53   // Now we split the raw message into its various parts...
  54   QString prefix = "";
  55   QByteArray trailing;
  56   QString cmd;
  57
  58   // First, check for a trailing parameter introduced by " :", since this might screw up splitting the msg
  59   // NOTE: This assumes that this is true in raw encoding, but well, hopefully there are no servers running in japanese on protocol level...
  60   int idx = msg.indexOf(" :");
  61   if(idx >= 0) {
  62     if(msg.length() > idx + 2)
  63       trailing = msg.mid(idx + 2);
  64     msg = msg.left(idx);
  65   }
  66   // OK, now it is safe to split...
  67   QList<QByteArray> params = msg.split(' ');
  68
  69   // This could still contain empty elements due to (faulty?) ircds sending multiple spaces in a row
  70   // Also, QByteArray is not nearly as convenient to work with as QString for such things :)
  71   QList<QByteArray>::iterator iter = params.begin();
  72   while(iter != params.end()) {
  73     if(iter->isEmpty())
  74       iter = params.erase(iter);
  75     else
  76       ++iter;
  77   }
  78
  79   if(!trailing.isEmpty()) params << trailing;
  80   if(params.count() < 1) {
  81     qWarning() << "Received invalid string from server!";
  82     return;
  83   }
  84
  85   QString foo = serverDecode(params.takeFirst());
  86
  87   // a colon as the first chars indicates the existence of a prefix
  88   if(foo[0] == ':') {
  89     foo.remove(0, 1);
  90     prefix = foo;
  91     if(params.count() < 1) {
  92       qWarning() << "Received invalid string from server!";
  93       return;
  94     }
  95     foo = serverDecode(params.takeFirst());
  96   }
  97
  98   // next string without a whitespace is the command
  99   cmd = foo.trimmed().toUpper();
 100
 101   // numeric replies have the target as first param (RFC 2812 - 2.4). this is usually our own nick. Remove this!
 102   uint num = cmd.toUInt();
 103   if(num > 0) {
 104     if(params.count() == 0) {
 105       qWarning() << "Message received from server violates RFC and is ignored!" << msg;
 106       return;
 107     }
 108     _target = serverDecode(params.takeFirst());
 109   } else {
 110     _target = QString();
 111   }
 112
 113   // note that the IRC server is still alive
 114   network()->resetPingTimeout();
 115
 116   // Now we try to find a handler for this message. BTW, I do love the Trolltech guys ;-)
 117   handle(cmd, Q_ARG(QString, prefix), Q_ARG(QList<QByteArray>, params));
 118 }
 119
 120
 121 void IrcServerHandler::defaultHandler(QString cmd, const QString &prefix, const QList<QByteArray> &rawparams) {
 122   // we assume that all this happens in server encoding
 123   QStringList params = serverDecode(rawparams);
 124   uint num = cmd.toUInt();
 125   if(num) {
 126     // A lot of server messages don't really need their own handler because they don't do much.
 127     // Catch and handle these here.
 128     switch(num) {
 129       // Welcome, status, info messages. Just display these.
 130       case 2: case 3: case 4: case 5: case 251: case 252: case 253: case 254: case 255: case 372: case 375:
 131         emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", params.join(" "), prefix);
 132         break;
 133       // Server error messages without param, just display them
 134       case 409: case 411: case 412: case 422: case 424: case 445: case 446: case 451: case 462:
 135       case 463: case 464: case 465: case 466: case 472: case 481: case 483: case 485: case 491: case 501: case 502:
 136       case 431: // ERR_NONICKNAMEGIVEN
 137         emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", params.join(" "), prefix);
 138         break;
 139       // Server error messages, display them in red. First param will be appended.
 140       case 401: {
 141         QString target = params.takeFirst();
 142         emit displayMsg(Message::Error, target, params.join(" ") + " " + target, prefix, Message::Redirected);
 143         break;
 144       }
 145       case 402: case 403: case 404: case 406: case 408: case 415: case 421: case 442: {
 146         QString channelName = params.takeFirst();
 147         emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", params.join(" ") + " " + channelName, prefix);
 148         break;
 149       }
 150       // Server error messages which will be displayed with a colon between the first param and the rest
 151       case 413: case 414: case 423: case 441: case 444: case 461:  // FIXME see below for the 47x codes
 152       case 467: case 471: case 473: case 474: case 475: case 476: case 477: case 478: case 482:
 153       case 436: // ERR_NICKCOLLISION
 154       {
 155         QString p = params.takeFirst();
 156         emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", p + ": " + params.join(" "));
 157         break;
 158       }
 159       // Ignore these commands.
 160       case 321: case 366: case 376:
 161         break;
 162
 163       // Everything else will be marked in red, so we can add them somewhere.
 164       default:
 165         if(_whois) {
 166           // many nets define their own WHOIS fields. we fetch those not in need of special attention here:
 167           emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", "[Whois] " + params.join(" "), prefix);
 168         } else {
 169           if(coreSession()->ircListHelper()->requestInProgress(network()->networkId()))
 170             coreSession()->ircListHelper()->reportError(params.join(" "));
 171           else
 172             emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", cmd + " " + params.join(" "), prefix);
 173         }
 174     }
 175     //qDebug() << prefix <<":"<<cmd<<params;
 176   } else {
 177     emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", QString("Unknown: ") + cmd + " " + params.join(" "), prefix);
 178     //qDebug() << prefix <<":"<<cmd<<params;
 179   }
 180 }
 181
 182 //******************************/
 183 // IRC SERVER HANDLER
 184 //******************************/
 185 void IrcServerHandler::handleJoin(const QString &prefix, const QList<QByteArray> &params) {
 186   if(!checkParamCount("IrcServerHandler::handleJoin()", params, 1))
 187     return;
 188
 189   QString channel = serverDecode(params[0]);
 190   IrcUser *ircuser = network()->updateNickFromMask(prefix);
 191
 192   bool handledByNetsplit = false;
 193   if(!_netsplits.empty()) {
 194     foreach(Netsplit* n, _netsplits) {
 195       handledByNetsplit = n->userJoined(prefix, channel);
 196       if(handledByNetsplit)
 197         break;
 198     }
 199   }
 200
 201   // normal join
 202   if(!handledByNetsplit) {
 203     emit displayMsg(Message::Join, BufferInfo::ChannelBuffer, channel, channel, prefix);
 204     ircuser->joinChannel(channel);
 205   }
 206   //qDebug() << "IrcServerHandler::handleJoin()" << prefix << params;
 207
 208   if(network()->isMe(ircuser)) {
 209     network()->setChannelJoined(channel);
 210     putCmd("MODE", params[0]); // we want to know the modes of the channel we just joined, so we ask politely
 211   }
 212 }
 213
 214 void IrcServerHandler::handleKick(const QString &prefix, const QList<QByteArray> &params) {
 215   if(!checkParamCount("IrcServerHandler::handleKick()", params, 2))
 216     return;
 217
 218   network()->updateNickFromMask(prefix);
 219   IrcUser *victim = network()->ircUser(params[1]);
 220   if(!victim)
 221     return;
 222
 223   QString channel = serverDecode(params[0]);
 224   victim->partChannel(channel);
 225
 226   QString msg;
 227   if(params.count() > 2) // someone got a reason!
 228     msg = QString("%1 %2").arg(victim->nick()).arg(channelDecode(channel, params[2]));
 229   else
 230     msg = victim->nick();
 231
 232   emit displayMsg(Message::Kick, BufferInfo::ChannelBuffer, channel, msg, prefix);
 233   //if(network()->isMe(victim)) network()->setKickedFromChannel(channel);
 234 }
 235
 236 void IrcServerHandler::handleMode(const QString &prefix, const QList<QByteArray> &params) {
 237   if(!checkParamCount("IrcServerHandler::handleMode()", params, 2))
 238     return;
 239
 240   if(network()->isChannelName(serverDecode(params[0]))) {
 241     // Channel Modes
 242     emit displayMsg(Message::Mode, BufferInfo::ChannelBuffer, serverDecode(params[0]), serverDecode(params).join(" "), prefix);
 243
 244     IrcChannel *channel = network()->ircChannel(params[0]);
 245     if(!channel) {
 246       // we received mode information for a channel we're not in. that means probably we've just been kicked out or something like that
 247       // anyways: we don't have a place to store the data --> discard the info.
 248       return;
 249     }
 250
 251     QString modes = params[1];
 252     bool add = true;
 253     int paramOffset = 2;
 254     for(int c = 0; c < modes.length(); c++) {
 255       if(modes[c] == '+') {
 256         add = true;
 257         continue;
 258       }
 259       if(modes[c] == '-') {
 260         add = false;
 261         continue;
 262       }
 263
 264       if(network()->prefixModes().contains(modes[c])) {
 265         // user channel modes (op, voice, etc...)
 266         if(paramOffset < params.count()) {
 267           IrcUser *ircUser = network()->ircUser(params[paramOffset]);
 268           if(add) {
 269             bool handledByNetsplit = false;
 270             if(!_netsplits.empty()) {
 271               foreach(Netsplit* n, _netsplits) {
 272                 handledByNetsplit = n->userAlreadyJoined(ircUser->hostmask(), channel->name());
 273                 if(handledByNetsplit) {
 274                   n->addMode(ircUser->hostmask(), channel->name(), QString(modes[c]));
 275                   break;
 276                 }
 277               }
 278             }
 279             if(!handledByNetsplit)
 280               channel->addUserMode(ircUser, QString(modes[c]));
 281           }
 282           else
 283             channel->removeUserMode(ircUser, QString(modes[c]));
 284         } else {
 285           qWarning() << "Received MODE with too few parameters:" << serverDecode(params);
 286         }
 287         paramOffset++;
 288       } else {
 289         // regular channel modes
 290         QString value;
 291         Network::ChannelModeType modeType = network()->channelModeType(modes[c]);
 292         if(modeType == Network::A_CHANMODE || modeType == Network::B_CHANMODE || (modeType == Network::C_CHANMODE && add)) {
 293           if(paramOffset < params.count()) {
 294             value = params[paramOffset];
 295           } else {
 296             qWarning() << "Received MODE with too few parameters:" << serverDecode(params);
 297           }
 298           paramOffset++;
 299         }
 300
 301         if(add)
 302           channel->addChannelMode(modes[c], value);
 303         else
 304           channel->removeChannelMode(modes[c], value);
 305       }
 306     }
 307
 308   } else {
 309     // pure User Modes
 310     IrcUser *ircUser = network()->newIrcUser(params[0]);
 311     QString modeString(serverDecode(params[1]));
 312     QString addModes;
 313     QString removeModes;
 314     bool add = false;
 315     for(int c = 0; c < modeString.count(); c++) {
 316       if(modeString[c] == '+') {
 317         add = true;
 318         continue;
 319       }
 320       if(modeString[c] == '-') {
 321         add = false;
 322         continue;
 323       }
 324       if(add)
 325         addModes += modeString[c];
 326       else
 327         removeModes += modeString[c];
 328     }
 329     if(!addModes.isEmpty())
 330       ircUser->addUserModes(addModes);
 331     if(!removeModes.isEmpty())
 332       ircUser->removeUserModes(removeModes);
 333
 334     // FIXME: redirect
 335     emit displayMsg(Message::Mode, BufferInfo::StatusBuffer, "", serverDecode(params).join(" "), prefix);
 336   }
 337 }
 338
 339 void IrcServerHandler::handleNick(const QString &prefix, const QList<QByteArray> &params) {
 340   if(!checkParamCount("IrcServerHandler::handleNick()", params, 1))
 341     return;
 342
 343   IrcUser *ircuser = network()->updateNickFromMask(prefix);
 344   if(!ircuser) {
 345     qWarning() << "IrcServerHandler::handleNick(): Unknown IrcUser!";
 346     return;
 347   }
 348   QString newnick = serverDecode(params[0]);
 349   QString oldnick = ircuser->nick();
 350
 351   QString sender = network()->isMyNick(oldnick)
 352     ? newnick
 353     : prefix;
 354
 355
 356   // the order is cruicial
 357   // otherwise the client would rename the buffer, see that the assigned ircuser doesn't match anymore
 358   // and remove the ircuser from the querybuffer leading to a wrong on/offline state
 359   ircuser->setNick(newnick);
 360   coreSession()->renameBuffer(network()->networkId(), newnick, oldnick);
 361
 362   foreach(QString channel, ircuser->channels())
 363     emit displayMsg(Message::Nick, BufferInfo::ChannelBuffer, channel, newnick, sender);
 364 }
 365
 366 void IrcServerHandler::handleNotice(const QString &prefix, const QList<QByteArray> &params) {
 367   if(!checkParamCount("IrcServerHandler::handleNotice()", params, 2))
 368     return;
 369
 370
 371   QStringList targets = serverDecode(params[0]).split(',', QString::SkipEmptyParts);
 372   QStringList::const_iterator targetIter;
 373   for(targetIter = targets.constBegin(); targetIter != targets.constEnd(); targetIter++) {
 374     QString target = *targetIter;
 375
 376     // special treatment for welcome messages like:
 377     // :ChanServ!ChanServ@services. NOTICE egst :[#apache] Welcome, this is #apache. Please read the in-channel topic message. This channel is being logged by IRSeekBot. If you have any question please see http://blog.freenode.net/?p=68
 378     if(!network()->isChannelName(target)) {
 379       QString msg = serverDecode(params[1]);
 380       QRegExp welcomeRegExp("^\\[([^\\]]+)\\] ");
 381       if(welcomeRegExp.indexIn(msg) != -1) {
 382         QString channelname = welcomeRegExp.cap(1);
 383         msg = msg.mid(welcomeRegExp.matchedLength());
 384         CoreIrcChannel *chan = static_cast<CoreIrcChannel *>(network()->ircChannel(channelname)); // we only have CoreIrcChannels in the core, so this cast is safe
 385         if(chan && !chan->receivedWelcomeMsg()) {
 386           chan->setReceivedWelcomeMsg();
 387           emit displayMsg(Message::Notice, BufferInfo::ChannelBuffer, channelname, msg, prefix);
 388           continue;
 389         }
 390       }
 391     }
 392
 393     if(prefix.isEmpty() || target == "AUTH") {
 394       target = "";
 395     } else {
 396       if(!target.isEmpty() && network()->prefixes().contains(target[0]))
 397         target = target.mid(1);
 398       if(!network()->isChannelName(target))
 399         target = nickFromMask(prefix);
 400     }
 401
 402     network()->ctcpHandler()->parse(Message::Notice, prefix, target, params[1]);
 403   }
 404
 405 }
 406
 407 void IrcServerHandler::handlePart(const QString &prefix, const QList<QByteArray> &params) {
 408   if(!checkParamCount("IrcServerHandler::handlePart()", params, 1))
 409     return;
 410
 411   IrcUser *ircuser = network()->updateNickFromMask(prefix);
 412   QString channel = serverDecode(params[0]);
 413   if(!ircuser) {
 414     qWarning() << "IrcServerHandler::handlePart(): Unknown IrcUser!";
 415     return;
 416   }
 417
 418   ircuser->partChannel(channel);
 419
 420   QString msg;
 421   if(params.count() > 1)
 422     msg = userDecode(ircuser->nick(), params[1]);
 423
 424   emit displayMsg(Message::Part, BufferInfo::ChannelBuffer, channel, msg, prefix);
 425   if(network()->isMe(ircuser)) network()->setChannelParted(channel);
 426 }
 427
 428 void IrcServerHandler::handlePing(const QString &prefix, const QList<QByteArray> &params) {
 429   Q_UNUSED(prefix);
 430   putCmd("PONG", params);
 431 }
 432
 433 void IrcServerHandler::handlePong(const QString &prefix, const QList<QByteArray> &params) {
 434   Q_UNUSED(prefix);
 435   // the server is supposed to send back what we passed as param. and we send a timestamp
 436   // but using quote and whatnought one can send arbitrary pings, so we have to do some sanity checks
 437   if(params.count() < 2)
 438     return;
 439
 440   QString timestamp = serverDecode(params[1]);
 441   QTime sendTime = QTime::fromString(timestamp, "hh:mm:ss.zzz");
 442   if(!sendTime.isValid()) {
 443     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", "PONG " + serverDecode(params).join(" "), prefix);
 444     return;
 445   }
 446
 447   network()->setLatency(sendTime.msecsTo(QTime::currentTime()) / 2);
 448 }
 449
 450 void IrcServerHandler::handlePrivmsg(const QString &prefix, const QList<QByteArray> &params) {
 451   if(!checkParamCount("IrcServerHandler::handlePrivmsg()", params, 1))
 452     return;
 453
 454   IrcUser *ircuser = network()->updateNickFromMask(prefix);
 455   if(!ircuser) {
 456     qWarning() << "IrcServerHandler::handlePrivmsg(): Unknown IrcUser!";
 457     return;
 458   }
 459
 460   if(params.isEmpty()) {
 461     qWarning() << "IrcServerHandler::handlePrivmsg(): received PRIVMSG without target or message from:" << prefix;
 462     return;
 463   }
 464
 465   QString senderNick = nickFromMask(prefix);
 466
 467   QByteArray msg = params.count() < 2
 468     ? QByteArray("")
 469     : params[1];
 470
 471   QStringList targets = serverDecode(params[0]).split(',', QString::SkipEmptyParts);
 472   QStringList::const_iterator targetIter;
 473   for(targetIter = targets.constBegin(); targetIter != targets.constEnd(); targetIter++) {
 474     const QString &target = network()->isChannelName(*targetIter)
 475       ? *targetIter
 476       : senderNick;
 477
 478     // it's possible to pack multiple privmsgs into one param using ctcp
 479     // - > we let the ctcpHandler do the work
 480     network()->ctcpHandler()->parse(Message::Plain, prefix, target, msg);
 481   }
 482 }
 483
 484 void IrcServerHandler::handleQuit(const QString &prefix, const QList<QByteArray> &params) {
 485   IrcUser *ircuser = network()->updateNickFromMask(prefix);
 486   if(!ircuser) return;
 487
 488   QString msg;
 489   if(params.count() > 0)
 490     msg = userDecode(ircuser->nick(), params[0]);
 491
 492   // check if netsplit
 493   if(Netsplit::isNetsplit(msg)) {
 494     Netsplit *n;
 495     if(!_netsplits.contains(msg)) {
 496       n = new Netsplit();
 497       connect(n, SIGNAL(finished()), this, SLOT(handleNetsplitFinished()));
 498       connect(n, SIGNAL(netsplitJoin(const QString&, const QStringList&, const QStringList&, const QString&)),
 499               this, SLOT(handleNetsplitJoin(const QString&, const QStringList&, const QStringList&, const QString&)));
 500       connect(n, SIGNAL(netsplitQuit(const QString&, const QStringList&, const QString&)),
 501               this, SLOT(handleNetsplitQuit(const QString&, const QStringList&, const QString&)));
 502       connect(n, SIGNAL(earlyJoin(const QString&, const QStringList&, const QStringList&)),
 503               this, SLOT(handleEarlyNetsplitJoin(const QString&, const QStringList&, const QStringList&)));
 504       _netsplits.insert(msg, n);
 505     }
 506     else {
 507       n = _netsplits[msg];
 508     }
 509     // add this user to the netsplit
 510     n->userQuit(prefix, ircuser->channels(),msg);
 511   }
 512   // normal quit
 513   else {
 514     foreach(QString channel, ircuser->channels())
 515       emit displayMsg(Message::Quit, BufferInfo::ChannelBuffer, channel, msg, prefix);
 516     ircuser->quit();
 517   }
 518 }
 519
 520 void IrcServerHandler::handleTopic(const QString &prefix, const QList<QByteArray> &params) {
 521   if(!checkParamCount("IrcServerHandler::handleTopic()", params, 1))
 522     return;
 523
 524   IrcUser *ircuser = network()->updateNickFromMask(prefix);
 525   if(!ircuser)
 526     return;
 527
 528   IrcChannel *channel = network()->ircChannel(serverDecode(params[0]));
 529   if(!channel)
 530     return;
 531
 532   QString topic;
 533   if(params.count() > 1)
 534     topic = channelDecode(channel->name(), params[1]);
 535
 536   channel->setTopic(topic);
 537
 538   emit displayMsg(Message::Topic, BufferInfo::ChannelBuffer, channel->name(), tr("%1 has changed topic for %2 to: \"%3\"").arg(ircuser->nick()).arg(channel->name()).arg(topic));
 539 }
 540
 541 /* RPL_WELCOME */
 542 void IrcServerHandler::handle001(const QString &prefix, const QList<QByteArray> &params) {
 543   network()->setCurrentServer(prefix);
 544
 545   if(params.isEmpty()) {
 546     emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", QString("%1 didn't supply a valid welcome message... expect some serious issues..."));
 547   }
 548   // there should be only one param: "Welcome to the Internet Relay Network <nick>!<user>@<host>"
 549   QString param = serverDecode(params[0]);
 550   QString myhostmask = param.section(' ', -1, -1);
 551
 552   network()->setMyNick(nickFromMask(myhostmask));
 553
 554   emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", param, prefix);
 555 }
 556
 557 /* RPL_ISUPPORT */
 558 // TODO Complete 005 handling, also use sensible defaults for non-sent stuff
 559 void IrcServerHandler::handle005(const QString &prefix, const QList<QByteArray> &params) {
 560   Q_UNUSED(prefix);
 561   const int numParams = params.size();
 562   if(numParams == 0) {
 563     emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", tr("Received RPL_ISUPPORT (005) without parameters!"), prefix);
 564     return;
 565   }
 566
 567   emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", serverDecode(params).join(" "), prefix);
 568
 569   QString rpl_isupport_suffix = serverDecode(params.last());
 570   if(!rpl_isupport_suffix.toLower().contains("are supported by this server")) {
 571     emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", tr("Received non RFC compliant RPL_ISUPPORT: this can lead to unexpected behavior!"), prefix);
 572   }
 573
 574   QString rawSupport;
 575   QString key, value;
 576   for(int i = 0; i < numParams - 1; i++) {
 577     QString rawSupport = serverDecode(params[i]);
 578     QString key = rawSupport.section("=", 0, 0);
 579     QString value = rawSupport.section("=", 1);
 580     network()->addSupport(key, value);
 581   }
 582 }
 583
 584 /* RPL_UMODEIS - "<user_modes> [<user_mode_params>]" */
 585 void IrcServerHandler::handle221(const QString &prefix, const QList<QByteArray> &params) {
 586   Q_UNUSED(prefix)
 587   //TODO: save information in network object
 588   emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("%1").arg(serverDecode(params).join(" ")));
 589 }
 590
 591 /* RPL_STATSCONN - "Highest connection cout: 8000 (7999 clients)" */
 592 void IrcServerHandler::handle250(const QString &prefix, const QList<QByteArray> &params) {
 593   Q_UNUSED(prefix)
 594   //TODO: save information in network object
 595   emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("%1").arg(serverDecode(params).join(" ")));
 596 }
 597
 598 /* RPL_LOCALUSERS - "Current local user: 5024  Max: 7999 */
 599 void IrcServerHandler::handle265(const QString &prefix, const QList<QByteArray> &params) {
 600   Q_UNUSED(prefix)
 601   //TODO: save information in network object
 602   emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("%1").arg(serverDecode(params).join(" ")));
 603 }
 604
 605 /* RPL_GLOBALUSERS - "Current global users: 46093  Max: 47650" */
 606 void IrcServerHandler::handle266(const QString &prefix, const QList<QByteArray> &params) {
 607   Q_UNUSED(prefix)
 608   //TODO: save information in network object
 609   emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("%1").arg(serverDecode(params).join(" ")));
 610 }
 611
 612 /*
 613 WHOIS-Message:
 614    Replies 311 - 313, 317 - 319 are all replies generated in response to a WHOIS message.
 615   and 301 (RPL_AWAY)
 616               "<nick> :<away message>"
 617 WHO-Message:
 618    Replies 352 and 315 paired are used to answer a WHO message.
 619
 620 WHOWAS-Message:
 621    Replies 314 and 369 are responses to a WHOWAS message.
 622
 623 */
 624
 625
 626 /*   RPL_AWAY - "<nick> :<away message>" */
 627 void IrcServerHandler::handle301(const QString &prefix, const QList<QByteArray> &params) {
 628   Q_UNUSED(prefix);
 629   if(!checkParamCount("IrcServerHandler::handle301()", params, 2))
 630     return;
 631
 632
 633   QString nickName = serverDecode(params[0]);
 634   QString awayMessage = userDecode(nickName, params[1]);
 635
 636   IrcUser *ircuser = network()->ircUser(nickName);
 637   if(ircuser) {
 638     ircuser->setAwayMessage(awayMessage);
 639     ircuser->setAway(true);
 640   }
 641
 642   // FIXME: proper redirection needed
 643   if(_whois) {
 644     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] %1 is away: \"%2\"").arg(nickName).arg(awayMessage));
 645   } else {
 646     if(ircuser) {
 647       int now = QDateTime::currentDateTime().toTime_t();
 648       int silenceTime = 60;
 649       if(ircuser->lastAwayMessage() + silenceTime < now) {
 650         emit displayMsg(Message::Server, BufferInfo::QueryBuffer, params[0], tr("%1 is away: \"%2\"").arg(nickName).arg(awayMessage));
 651       }
 652       ircuser->setLastAwayMessage(now);
 653     } else {
 654       // probably should not happen
 655       emit displayMsg(Message::Server, BufferInfo::QueryBuffer, params[0], tr("%1 is away: \"%2\"").arg(nickName).arg(awayMessage));
 656     }
 657   }
 658 }
 659
 660 // 305  RPL_UNAWAY
 661 //      ":You are no longer marked as being away"
 662 void IrcServerHandler::handle305(const QString &prefix, const QList<QByteArray> &params) {
 663   Q_UNUSED(prefix);
 664   IrcUser *me = network()->me();
 665   if(me)
 666     me->setAway(false);
 667
 668   if(!network()->autoAwayActive()) {
 669     if(!params.isEmpty())
 670       emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", serverDecode(params[0]));
 671   } else {
 672     network()->setAutoAwayActive(false);
 673   }
 674 }
 675
 676 // 306  RPL_NOWAWAY
 677 //      ":You have been marked as being away"
 678 void IrcServerHandler::handle306(const QString &prefix, const QList<QByteArray> &params) {
 679   Q_UNUSED(prefix);
 680   IrcUser *me = network()->me();
 681   if(me)
 682     me->setAway(true);
 683
 684   if(!params.isEmpty() && !network()->autoAwayActive())
 685     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", serverDecode(params[0]));
 686 }
 687
 688 /* RPL_WHOISSERVICE - "<user> is registered nick" */
 689 void IrcServerHandler::handle307(const QString &prefix, const QList<QByteArray> &params) {
 690   Q_UNUSED(prefix)
 691   if(!checkParamCount("IrcServerHandler::handle307()", params, 1))
 692     return;
 693
 694   QString whoisServiceReply = serverDecode(params).join(" ");
 695   IrcUser *ircuser = network()->ircUser(serverDecode(params[0]));
 696   if(ircuser) {
 697     ircuser->setWhoisServiceReply(whoisServiceReply);
 698   }
 699   emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] %1").arg(whoisServiceReply));
 700 }
 701
 702 /* RPL_SUSERHOST - "<user> is available for help." */
 703 void IrcServerHandler::handle310(const QString &prefix, const QList<QByteArray> &params) {
 704   Q_UNUSED(prefix)
 705   if(!checkParamCount("IrcServerHandler::handle310()", params, 1))
 706     return;
 707
 708   QString suserHost = serverDecode(params).join(" ");
 709   IrcUser *ircuser = network()->ircUser(serverDecode(params[0]));
 710   if(ircuser) {
 711     ircuser->setSuserHost(suserHost);
 712   }
 713   emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] %1").arg(suserHost));
 714 }
 715
 716 /*  RPL_WHOISUSER - "<nick> <user> <host> * :<real name>" */
 717 void IrcServerHandler::handle311(const QString &prefix, const QList<QByteArray> &params) {
 718   Q_UNUSED(prefix)
 719   if(!checkParamCount("IrcServerHandler::handle311()", params, 3))
 720     return;
 721
 722   _whois = true;
 723   IrcUser *ircuser = network()->ircUser(serverDecode(params[0]));
 724   if(ircuser) {
 725     ircuser->setUser(serverDecode(params[1]));
 726     ircuser->setHost(serverDecode(params[2]));
 727     ircuser->setRealName(serverDecode(params.last()));
 728     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] %1 is %2 (%3)") .arg(ircuser->nick()).arg(ircuser->hostmask()).arg(ircuser->realName()));
 729   } else {
 730     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] %1 is %2 (%3)") .arg(serverDecode(params[1])).arg(serverDecode(params[2])).arg(serverDecode(params.last())));
 731   }
 732 }
 733
 734 /*  RPL_WHOISSERVER -  "<nick> <server> :<server info>" */
 735 void IrcServerHandler::handle312(const QString &prefix, const QList<QByteArray> &params) {
 736   Q_UNUSED(prefix)
 737   if(!checkParamCount("IrcServerHandler::handle312()", params, 2))
 738     return;
 739
 740   IrcUser *ircuser = network()->ircUser(serverDecode(params[0]));
 741   if(ircuser) {
 742     ircuser->setServer(serverDecode(params[1]));
 743   }
 744
 745   QString returnString = tr("%1 is online via %2 (%3)").arg(serverDecode(params[0])).arg(serverDecode(params[1])).arg(serverDecode(params.last()));
 746   if(_whois) {
 747     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] %1").arg(returnString));
 748   } else {
 749     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whowas] %1").arg(returnString));
 750   }
 751 }
 752
 753 /*  RPL_WHOISOPERATOR - "<nick> :is an IRC operator" */
 754 void IrcServerHandler::handle313(const QString &prefix, const QList<QByteArray> &params) {
 755   Q_UNUSED(prefix)
 756   if(!checkParamCount("IrcServerHandler::handle313()", params, 1))
 757     return;
 758
 759   IrcUser *ircuser = network()->ircUser(serverDecode(params[0]));
 760   if(ircuser) {
 761     ircuser->setIrcOperator(params.last());
 762   }
 763   emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] %1").arg(serverDecode(params).join(" ")));
 764 }
 765
 766 /*  RPL_WHOWASUSER - "<nick> <user> <host> * :<real name>" */
 767 void IrcServerHandler::handle314(const QString &prefix, const QList<QByteArray> &params) {
 768   Q_UNUSED(prefix)
 769   if(!checkParamCount("IrcServerHandler::handle314()", params, 3))
 770     return;
 771
 772   QString nick = serverDecode(params[0]);
 773   QString hostmask = QString("%1@%2").arg(serverDecode(params[1])).arg(serverDecode(params[2]));
 774   QString realName = serverDecode(params.last());
 775   emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whowas] %1 was %2 (%3)").arg(nick).arg(hostmask).arg(realName));
 776 }
 777
 778 /*  RPL_ENDOFWHO: "<name> :End of WHO list" */
 779 void IrcServerHandler::handle315(const QString &prefix, const QList<QByteArray> &params) {
 780   Q_UNUSED(prefix);
 781   if(!checkParamCount("IrcServerHandler::handle315()", params, 1))
 782     return;
 783
 784   QStringList p = serverDecode(params);
 785   if(network()->setAutoWhoDone(p[0])) {
 786     return; // stay silent
 787   }
 788   p.takeLast(); // should be "End of WHO list"
 789   emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Who] End of /WHO list for %1").arg(p.join(" ")));
 790 }
 791
 792 /*  RPL_WHOISIDLE - "<nick> <integer> :seconds idle"
 793    (real life: "<nick> <integer> <integer> :seconds idle, signon time) */
 794 void IrcServerHandler::handle317(const QString &prefix, const QList<QByteArray> &params) {
 795   Q_UNUSED(prefix);
 796   if(!checkParamCount("IrcServerHandler::handle317()", params, 2))
 797     return;
 798
 799   QString nick = serverDecode(params[0]);
 800   IrcUser *ircuser = network()->ircUser(nick);
 801   if(ircuser) {
 802     QDateTime now = QDateTime::currentDateTime();
 803     int idleSecs = serverDecode(params[1]).toInt();
 804     idleSecs *= -1;
 805     ircuser->setIdleTime(now.addSecs(idleSecs));
 806     if(params.size() > 3) { // if we have more then 3 params we have the above mentioned "real life" situation
 807       int loginTime = serverDecode(params[2]).toInt();
 808       ircuser->setLoginTime(QDateTime::fromTime_t(loginTime));
 809       emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] %1 is logged in since %2").arg(ircuser->nick()).arg(ircuser->loginTime().toString()));
 810     }
 811     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] %1 is idling for %2 (%3)").arg(ircuser->nick()).arg(secondsToString(ircuser->idleTime().secsTo(now))).arg(ircuser->idleTime().toString()));
 812
 813   } else {
 814     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] idle message: %1").arg(userDecode(nick, params).join(" ")));
 815   }
 816 }
 817
 818 /*  RPL_ENDOFWHOIS - "<nick> :End of WHOIS list" */
 819 void IrcServerHandler::handle318(const QString &prefix, const QList<QByteArray> &params) {
 820   Q_UNUSED(prefix)
 821   _whois = false;
 822   QStringList parameter = serverDecode(params);
 823   parameter.removeFirst();
 824   emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] %1").arg(parameter.join(" ")));
 825 }
 826
 827 /*  RPL_WHOISCHANNELS - "<nick> :*( ( "@" / "+" ) <channel> " " )" */
 828 void IrcServerHandler::handle319(const QString &prefix, const QList<QByteArray> &params) {
 829   Q_UNUSED(prefix)
 830   if(!checkParamCount("IrcServerHandler::handle319()", params, 2))
 831     return;
 832
 833   QString nick = serverDecode(params.first());
 834   QStringList op;
 835   QStringList voice;
 836   QStringList user;
 837   foreach (QString channel, serverDecode(params.last()).split(" ")) {
 838     if(channel.startsWith("@"))
 839        op.append(channel.remove(0,1));
 840     else if(channel.startsWith("+"))
 841       voice.append(channel.remove(0,1));
 842     else
 843       user.append(channel);
 844   }
 845   if(!user.isEmpty())
 846     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] %1 is a user on channels: %2").arg(nick).arg(user.join(" ")));
 847   if(!voice.isEmpty())
 848     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] %1 has voice on channels: %2").arg(nick).arg(voice.join(" ")));
 849   if(!op.isEmpty())
 850     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] %1 is an operator on channels: %2").arg(nick).arg(op.join(" ")));
 851 }
 852
 853 /*  RPL_WHOISVIRT - "<nick> is identified to services" */
 854 void IrcServerHandler::handle320(const QString &prefix, const QList<QByteArray> &params) {
 855   Q_UNUSED(prefix);
 856   emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whois] %1").arg(serverDecode(params).join(" ")));
 857 }
 858
 859 /* RPL_LIST -  "<channel> <# visible> :<topic>" */
 860 void IrcServerHandler::handle322(const QString &prefix, const QList<QByteArray> &params) {
 861   Q_UNUSED(prefix)
 862   QString channelName;
 863   quint32 userCount = 0;
 864   QString topic;
 865
 866   int paramCount = params.count();
 867   switch(paramCount) {
 868   case 3:
 869     topic = serverDecode(params[2]);
 870   case 2:
 871     userCount = serverDecode(params[1]).toUInt();
 872   case 1:
 873     channelName = serverDecode(params[0]);
 874   default:
 875     break;
 876   }
 877   if(!coreSession()->ircListHelper()->addChannel(network()->networkId(), channelName, userCount, topic))
 878     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Channel %1 has %2 users. Topic is: %3").arg(channelName).arg(userCount).arg(topic));
 879 }
 880
 881 /* RPL_LISTEND ":End of LIST" */
 882 void IrcServerHandler::handle323(const QString &prefix, const QList<QByteArray> &params) {
 883   Q_UNUSED(prefix)
 884   Q_UNUSED(params)
 885
 886   if(!coreSession()->ircListHelper()->endOfChannelList(network()->networkId()))
 887     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("End of channel list"));
 888 }
 889
 890 /* RPL_CHANNELMODEIS - "<channel> <mode> <mode params>" */
 891 void IrcServerHandler::handle324(const QString &prefix, const QList<QByteArray> &params) {
 892   Q_UNUSED(prefix);
 893   handleMode(prefix, params);
 894 }
 895
 896 /* RPL_??? - "<channel> <homepage> */
 897 void IrcServerHandler::handle328(const QString &prefix, const QList<QByteArray> &params) {
 898   Q_UNUSED(prefix);
 899   if(!checkParamCount("IrcServerHandler::handle328()", params, 2))
 900     return;
 901
 902   QString channel = serverDecode(params[0]);
 903   QString homepage = serverDecode(params[1]);
 904
 905   emit displayMsg(Message::Server, BufferInfo::ChannelBuffer, channel, tr("Homepage for %1 is %2").arg(channel, homepage));
 906 }
 907
 908
 909 /* RPL_??? - "<channel> <creation time (unix)>" */
 910 void IrcServerHandler::handle329(const QString &prefix, const QList<QByteArray> &params) {
 911   Q_UNUSED(prefix);
 912   if(!checkParamCount("IrcServerHandler::handle329()", params, 2))
 913     return;
 914
 915   QString channel = serverDecode(params[0]);
 916   uint unixtime = params[1].toUInt();
 917   if(!unixtime) {
 918     qWarning() << Q_FUNC_INFO << "received invalid timestamp:" << params[1];
 919     return;
 920   }
 921   QDateTime time = QDateTime::fromTime_t(unixtime);
 922
 923   emit displayMsg(Message::Server, BufferInfo::ChannelBuffer, channel, tr("Channel %1 created on %2").arg(channel, time.toString()));
 924 }
 925
 926 /* RPL_NOTOPIC */
 927 void IrcServerHandler::handle331(const QString &prefix, const QList<QByteArray> &params) {
 928   Q_UNUSED(prefix);
 929   if(!checkParamCount("IrcServerHandler::handle331()", params, 1))
 930     return;
 931
 932   QString channel = serverDecode(params[0]);
 933   IrcChannel *chan = network()->ircChannel(channel);
 934   if(chan)
 935     chan->setTopic(QString());
 936
 937   emit displayMsg(Message::Topic, BufferInfo::ChannelBuffer, channel, tr("No topic is set for %1.").arg(channel));
 938 }
 939
 940 /* RPL_TOPIC */
 941 void IrcServerHandler::handle332(const QString &prefix, const QList<QByteArray> &params) {
 942   Q_UNUSED(prefix);
 943   if(!checkParamCount("IrcServerHandler::handle332()", params, 2))
 944     return;
 945
 946   QString channel = serverDecode(params[0]);
 947   QString topic = channelDecode(channel, params[1]);
 948   IrcChannel *chan = network()->ircChannel(channel);
 949   if(chan)
 950     chan->setTopic(topic);
 951
 952   emit displayMsg(Message::Topic, BufferInfo::ChannelBuffer, channel, tr("Topic for %1 is \"%2\"").arg(channel, topic));
 953 }
 954
 955 /* Topic set by... */
 956 void IrcServerHandler::handle333(const QString &prefix, const QList<QByteArray> &params) {
 957   Q_UNUSED(prefix);
 958   if(!checkParamCount("IrcServerHandler::handle333()", params, 3))
 959     return;
 960
 961   QString channel = serverDecode(params[0]);
 962   emit displayMsg(Message::Topic, BufferInfo::ChannelBuffer, channel,
 963                   tr("Topic set by %1 on %2") .arg(serverDecode(params[1]), QDateTime::fromTime_t(channelDecode(channel, params[2]).toUInt()).toString()));
 964 }
 965
 966 /*  RPL_WHOREPLY: "<channel> <user> <host> <server> <nick>
 967               ( "H" / "G" > ["*"] [ ( "@" / "+" ) ] :<hopcount> <real name>" */
 968 void IrcServerHandler::handle352(const QString &prefix, const QList<QByteArray> &params) {
 969   Q_UNUSED(prefix)
 970   if(!checkParamCount("IrcServerHandler::handle352()", params, 6))
 971     return;
 972
 973   QString channel = serverDecode(params[0]);
 974   IrcUser *ircuser = network()->ircUser(serverDecode(params[4]));
 975   if(ircuser) {
 976     ircuser->setUser(serverDecode(params[1]));
 977     ircuser->setHost(serverDecode(params[2]));
 978
 979     bool away = serverDecode(params[5]).startsWith("G") ? true : false;
 980     ircuser->setAway(away);
 981     ircuser->setServer(serverDecode(params[3]));
 982     ircuser->setRealName(serverDecode(params.last()).section(" ", 1));
 983   }
 984
 985   if(!network()->isAutoWhoInProgress(channel)) {
 986     emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Who] %1").arg(serverDecode(params).join(" ")));
 987   }
 988 }
 989
 990 /* RPL_NAMREPLY */
 991 void IrcServerHandler::handle353(const QString &prefix, const QList<QByteArray> &params) {
 992   Q_UNUSED(prefix);
 993   if(!checkParamCount("IrcServerHandler::handle353()", params, 3))
 994     return;
 995
 996   // param[0] is either "=", "*" or "@" indicating a public, private or secret channel
 997   // we don't use this information at the time beeing
 998   QString channelname = serverDecode(params[1]);
 999
1000   IrcChannel *channel = network()->ircChannel(channelname);
1001   if(!channel) {
1002     qWarning() << "IrcServerHandler::handle353(): received unknown target channel:" << channelname;
1003     return;
1004   }
1005
1006   QStringList nicks;
1007   QStringList modes;
1008
1009   foreach(QString nick, serverDecode(params[2]).split(' ')) {
1010     QString mode = QString();
1011
1012     if(network()->prefixes().contains(nick[0])) {
1013       mode = network()->prefixToMode(nick[0]);
1014       nick = nick.mid(1);
1015     }
1016
1017     nicks << nick;
1018     modes << mode;
1019   }
1020
1021   channel->joinIrcUsers(nicks, modes);
1022 }
1023
1024 /*  RPL_ENDOFWHOWAS - "<nick> :End of WHOWAS" */
1025 void IrcServerHandler::handle369(const QString &prefix, const QList<QByteArray> &params) {
1026   Q_UNUSED(prefix)
1027   emit displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("[Whowas] %1").arg(serverDecode(params).join(" ")));
1028 }
1029
1030 /* ERR_ERRONEUSNICKNAME */
1031 void IrcServerHandler::handle432(const QString &prefix, const QList<QByteArray> &params) {
1032   Q_UNUSED(prefix);
1033
1034   QString errnick;
1035   if(params.size() < 2) {
1036     // handle unreal-ircd bug, where unreal ircd doesnt supply a TARGET in ERR_ERRONEUSNICKNAME during registration phase:
1037     // nick @@@
1038     // :irc.scortum.moep.net 432  @@@ :Erroneous Nickname: Illegal characters
1039     // correct server reply:
1040     // :irc.scortum.moep.net 432 * @@@ :Erroneous Nickname: Illegal characters
1041     errnick = target();
1042   } else {
1043     errnick = params[0];
1044   }
1045   emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", tr("Nick %1 contains illegal characters").arg(errnick));
1046   tryNextNick(errnick, true /* erroneus */);
1047 }
1048
1049 /* ERR_NICKNAMEINUSE */
1050 void IrcServerHandler::handle433(const QString &prefix, const QList<QByteArray> &params) {
1051   Q_UNUSED(prefix);
1052   if(!checkParamCount("IrcServerHandler::handle433()", params, 1))
1053     return;
1054
1055   QString errnick = serverDecode(params[0]);
1056   emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", tr("Nick already in use: %1").arg(errnick));
1057
1058   // if there is a problem while connecting to the server -> we handle it
1059   // but only if our connection has not been finished yet...
1060   if(!network()->currentServer().isEmpty())
1061     return;
1062
1063   tryNextNick(errnick);
1064 }
1065
1066 /* Handle signals from Netsplit objects  */
1067
1068 void IrcServerHandler::handleNetsplitJoin(const QString &channel, const QStringList &users, const QStringList &modes, const QString& quitMessage)
1069 {
1070   IrcChannel *ircChannel = network()->ircChannel(channel);
1071   if(!ircChannel) {
1072     return;
1073   }
1074   QList<IrcUser *> ircUsers;
1075   QStringList newModes = modes;
1076
1077   foreach(QString user, users) {
1078     IrcUser *iu = network()->updateNickFromMask(user);
1079     if(iu)
1080       ircUsers.append(iu);
1081     else {
1082       newModes.removeAt(users.indexOf(user));
1083     }
1084   }
1085
1086   QString msg = users.join("#:#").append("#:#").append(quitMessage);
1087   emit displayMsg(Message::NetsplitJoin, BufferInfo::ChannelBuffer, channel, msg);
1088   ircChannel->joinIrcUsers(ircUsers, newModes);
1089 }
1090
1091 void IrcServerHandler::handleNetsplitQuit(const QString &channel, const QStringList &users, const QString& quitMessage)
1092 {
1093   QString msg = users.join("#:#").append("#:#").append(quitMessage);
1094   emit displayMsg(Message::NetsplitQuit, BufferInfo::ChannelBuffer, channel, msg);
1095   foreach(QString user, users) {
1096     IrcUser *iu = network()->ircUser(nickFromMask(user));
1097     if(iu)
1098       iu->quit();
1099   }
1100 }
1101
1102 void IrcServerHandler::handleEarlyNetsplitJoin(const QString &channel, const QStringList &users, const QStringList &modes) {
1103   IrcChannel *ircChannel = network()->ircChannel(channel);
1104   if(!ircChannel) {
1105     qDebug() << "handleEarlyNetsplitJoin(): channel " << channel << " invalid";
1106     return;
1107   }
1108   QList<IrcUser *> ircUsers;
1109   QStringList newModes = modes;
1110
1111   foreach(QString user, users) {
1112     IrcUser *iu = network()->updateNickFromMask(user);
1113     if(iu) {
1114       ircUsers.append(iu);
1115       emit displayMsg(Message::Join, BufferInfo::ChannelBuffer, channel, channel, user);
1116     }
1117     else {
1118       newModes.removeAt(users.indexOf(user));
1119     }
1120   }
1121   ircChannel->joinIrcUsers(ircUsers, newModes);
1122 }
1123 void IrcServerHandler::handleNetsplitFinished()
1124 {
1125   Netsplit* n = qobject_cast<Netsplit*>(sender());
1126   _netsplits.remove(_netsplits.key(n));
1127   n->deleteLater();
1128 }
1129
1130 /* */
1131
1132 // FIXME networkConnection()->setChannelKey("") for all ERR replies indicating that a JOIN went wrong
1133 //       mostly, these are codes in the 47x range
1134
1135 /* */
1136
1137 void IrcServerHandler::tryNextNick(const QString &errnick, bool erroneus) {
1138   QStringList desiredNicks = coreSession()->identity(network()->identity())->nicks();
1139   int nextNickIdx = desiredNicks.indexOf(errnick) + 1;
1140   QString nextNick;
1141   if(nextNickIdx > 0 && desiredNicks.size() > nextNickIdx) {
1142     nextNick = desiredNicks[nextNickIdx];
1143   } else {
1144     if(erroneus) {
1145       emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", tr("No free and valid nicks in nicklist found. use: /nick <othernick> to continue"));
1146       return;
1147     } else {
1148       nextNick = errnick + "_";
1149     }
1150   }
1151   putCmd("NICK", serverEncode(nextNick));
1152 }
1153
1154 bool IrcServerHandler::checkParamCount(const QString &methodName, const QList<QByteArray> &params, int minParams) {
1155   if(params.count() < minParams) {
1156     qWarning() << qPrintable(methodName) << "requires" << minParams << "parameters but received only" << params.count() << serverDecode(params);
1157     return false;
1158   } else {
1159     return true;
1160   }
1161 }
1162
1163
1164 /***********************************************************************************/
1165
1166