kopete/protocols/irc/ircprotocol.cpp

   1 /*
   2     ircprotocol - IRC Protocol
   3
   4     Copyright (c) 2002      by Nick Betcher <nbetcher@kde.org>
   5     Copyright (c) 2003-2007 by Michel Hermier <michel.hermier@gmail.com>
   6
   7     Kopete    (c) 2002-2007 by the Kopete developers <kopete-devel@kde.org>
   8
   9     *************************************************************************
  10     *                                                                       *
  11     * This program is free software; you can redistribute it and/or modify  *
  12     * it under the terms of the GNU General Public License as published by  *
  13     * the Free Software Foundation; either version 2 of the License, or     *
  14     * (at your option) any later version.                                   *
  15     *                                                                       *
  16     *************************************************************************
  17 */
  18
  19 #include "ircprotocol.moc"
  20
  21 #include "ircaccount.h"
  22 #include "irccontact.h"
  23 #include "irctransferhandler.h"
  24 #include "ksparser.h"
  25
  26 #include "networkconfigwidget.h"
  27 //#include "channellist.h"
  28 #include "ircaddcontactpage.h"
  29 //#include "ircguiclient.h"
  30 #include "irceditaccountwidget.h"
  31
  32 #include "kircclientsocket.h"
  33
  34 #include "kopeteaccountmanager.h"
  35 #include "kopetechatsessionmanager.h"
  36 #include "kopetecommandhandler.h"
  37 #include "kopeteglobal.h"
  38 #include "kopeteonlinestatusmanager.h"
  39 #include "kopeteonlinestatus.h"
  40 #include "kopeteview.h"
  41 #include "kopeteuiglobal.h"
  42
  43 #include <kaboutdata.h>
  44 #include <kaction.h>
  45 #include <kcharsets.h>
  46 #include <kdebug.h>
  47 #include <kgenericfactory.h>
  48 #include <kglobal.h>
  49 #include <kinputdialog.h>
  50 #include <kiconloader.h>
  51 #include <kmessagebox.h>
  52 #include <kstandarddirs.h>
  53 #include <kuser.h>
  54
  55 #include <qcheckbox.h>
  56 #include <qdom.h>
  57 #include <qfile.h>
  58 #include <qlineedit.h>
  59 #include <qpushbutton.h>
  60 #include <qregexp.h>
  61 #include <qspinbox.h>
  62 #include <qvalidator.h>
  63
  64 #include <dom/html_element.h>
  65 #include <unistd.h>
  66
  67 using namespace Kopete;
  68
  69 K_PLUGIN_FACTORY( IRCProtocolFactory, registerPlugin<IRCProtocol>(); )
  70 K_EXPORT_PLUGIN( IRCProtocolFactory( "kopete_irc" ) )
  71
  72 static IRCProtocol *s_protocol = 0L;
  73
  74 IRCProtocolHandler::IRCProtocolHandler()
  75         : MimeTypeHandler(false)
  76 {
  77         registerAsProtocolHandler(QString::fromLatin1("irc"));
  78 }
  79
  80 void IRCProtocolHandler::handleURL(const KUrl &url) const
  81 {
  82         kDebug(14120) << url;
  83         if (!url.isValid())
  84                 return;
  85
  86         unsigned short port = url.port();
  87         if (port == 0)
  88                 port = 6667;
  89
  90         QString chan = url.url().section('/',3);
  91         if (chan.isEmpty())
  92                 return;
  93
  94         KUser user(getuid());
  95         QString accountId = QString::fromLatin1("%1@%2:%3").arg(
  96                 user.loginName(),
  97                 url.host(),
  98                 QString::number(port)
  99         );
 100
 101         kDebug(14120) << accountId;
 102
 103         IRCAccount *newAccount = new IRCAccount( accountId, chan );
 104         newAccount->setNickName( user.loginName() );
 105         newAccount->setUserName( user.loginName() );
 106         newAccount->connect();
 107 }
 108
 109 IRCProtocol::IRCProtocol( QObject *parent, const QVariantList & /* args */ )
 110         : Protocol(IRCProtocolFactory::componentData(), parent)
 111 //      , m_StatusUnknown(OnlineStatus::Unknown, 999, this, 999, "status_unknown", i18n("Status not available"))
 112 {
 113         kDebug(14120) ;
 114
 115         s_protocol = this;
 116
 117         initOnlineStatus();
 118
 119         //m_status = m_unknownStatus = m_Unknown;
 120
 121         addAddressBookField("messaging/irc", Plugin::MakeIndexField);
 122 /*
 123         CommandHandler *commandHandler = CommandHandler::self();
 124
 125         // Statically implemented commands
 126         commandHandler->registerCommand(this, QString::fromLatin1("all"),
 127                 SLOT( slotAllCommand(const QString &, Kopete::ChatSession*)),
 128                 i18n("USAGE: /all <command> - Exectute the given command in all the chats."), 2);
 129
 130         commandHandler->registerCommand(this, QString::fromLatin1("ctcp"),
 131                 SLOT( slotCtcpCommand(const QString &, Kopete::ChatSession *)),
 132                 i18n("USAGE: /ctcp <nick> <message> - Send the CTCP message to nick."), 2);
 133
 134         commandHandler->registerCommand(this, QString::fromLatin1("quote"),
 135                 SLOT( slotQuoteCommand(const QString &, Kopete::ChatSession*)),
 136                 i18n("USAGE: /quote <text> - Sends the text in quoted form to the server."), 1);
 137
 138         commandHandler->registerCommand(this, QString::fromLatin1("raw"),
 139                 SLOT( slotRawCommand( const QString &, Kopete::ChatSession*)),
 140                 i18n("USAGE: /raw <text> - Sends the text in raw form to the server."), 1);
 141
 142         // Alias implemented commands
 143         commandHandler->registerAlias(this, QString::fromLatin1("ame"),
 144                 QString::fromLatin1("all ME"),
 145                 i18n("USAGE: /ame <action> - Do something in every open chat."),
 146                 CommandHandler::SystemAlias, 1);
 147 /*
 148         commandHandler->registerAlias(this, QString::fromLatin1("ban"),
 149                 SLOT(slotBanCommand(const QString &, Kopete::ChatSession*)),
 150                 i18n("USAGE: /ban <mask> - Add someone to this channel's ban list. (requires operator status)."),
 151                 CommandHandler::SystemAlias, 1, 1);
 152 */
 153 /*      commandHandler->registerAlias(this, QString::fromLatin1("bannick"),
 154                 QString::fromLatin1("ban %1!*@*"),
 155                 i18n("USAGE: /bannick <nickname> - Add someone to this channel's ban list. Uses the hostmask nickname!*@* (requires operator status)."),
 156                 CommandHandler::SystemAlias, 1, 1);
 157
 158         commandHandler->registerAlias(this, QString::fromLatin1("deop"),
 159                 SLOT(slotDeopCommand(const QString &, Kopete::ChatSession*)),
 160                 i18n("USAGE: /deop <nickname> [<nickname 2> <...>] - Remove channel operator status from someone (requires operator status)."),
 161                 CommandHandler::SystemAlias, 1);
 162
 163         commandHandler->registerAlias(this, QString::fromLatin1("devoice"),
 164                 SLOT( slotDevoiceCommand( const QString &, Kopete::ChatSession*) ),
 165                 i18n("USAGE: /devoice <nickname> [<nickname 2> <...>] - Remove channel voice status from someone (requires operator status)."),
 166                 CommandHandler::SystemAlias, 1);
 167
 168         commandHandler->registerAlias(this, QString::fromLatin1("invite"),
 169                 QString::fromLatin1("raw invite %s"),
 170                 i18n("USAGE: /invite <nickname> [<channel>] - Invite a user to join a channel."),
 171                 CommandHandler::SystemAlias, 1);
 172
 173         commandHandler->registerAlias(this, QString::fromLatin1("join"),
 174                 QString::fromLatin1("raw join %s"),
 175                 i18n("USAGE: /join <#channel 1> [<password>] - Joins the specified channel."),
 176                 CommandHandler::SystemAlias, 1, 2);
 177
 178         commandHandler->registerAlias( this, QString::fromLatin1("kick"),
 179                 SLOT( slotKickCommand( const QString &, Kopete::ChatSession*) ),
 180                 i18n("USAGE: /kick <nickname> [<reason>] - Kick someone from the channel (requires operator status)."),
 181                 CommandHandler::SystemAlias, 1);
 182
 183         commandHandler->registerAlias(this, QString::fromLatin1("list"),
 184                 QString::fromLatin1( "raw list %s"),
 185                 i18n("USAGE: /list - List the public channels on the server."),
 186                 CommandHandler::SystemAlias );
 187
 188         commandHandler->registerAlias(this, QString::fromLatin1("me"),
 189                 QString::fromLatin1("ctcp me"),
 190                 i18n("USAGE: /me <action> - Do something."),
 191                 CommandHandler::SystemAlias, 1 );
 192
 193         // FIX help string, MODE is also available for user
 194         commandHandler->registerAlias( this, QString::fromLatin1("mode"),
 195                 QString::fromLatin1("raw mode %s"),
 196                 i18n("USAGE: /mode <channel> <modes> - Set modes on the given channel."),
 197                 CommandHandler::SystemAlias, 2);
 198
 199         commandHandler->registerAlias(this, QString::fromLatin1("motd"),
 200                 QString::fromLatin1("raw motd %s"),
 201                 i18n("USAGE: /motd [<server>] - Shows the message of the day for the current or the given server."),
 202                 CommandHandler::SystemAlias);
 203
 204         commandHandler->registerAlias(this, QString::fromLatin1("nick"),
 205                 QString::fromLatin1 ("raw nick %s"),
 206                 i18n("USAGE: /nick <nickname> - Change your nickname to the given one."),
 207                 CommandHandler::SystemAlias, 1, 1);
 208
 209         commandHandler->registerAlias(this, QString::fromLatin1("op"),
 210                 SLOT( slotOpCommand(const QString &, Kopete::ChatSession*)),
 211                 i18n("USAGE: /op <nickname 1> [<nickname 2> <...>] - Give channel operator status to someone (requires operator status)."),
 212                 CommandHandler::SystemAlias, 1);
 213
 214         commandHandler->registerAlias(this, QString::fromLatin1("part"),
 215                 QString::fromLatin1( "raw part %c :%s" ),
 216                 i18n("USAGE: /part [<reason>] - Part from a channel, optionally leaving a message."),
 217                 CommandHandler::SystemAlias);
 218
 219         commandHandler->registerAlias(this, QString::fromLatin1("ping"),
 220                 QString::fromLatin1( "ctcp %1 PING" ),
 221                 i18n("USAGE: /ping <nickname> - Alias for /CTCP <nickname> PING."),
 222                 CommandHandler::SystemAlias, 1, 1);*/
 223 /*
 224         commandHandler->registerCommand(this, QString::fromLatin1("query"),
 225                 SLOT(slotQueryCommand(const QString &, Kopete::ChatSession*)),
 226                 i18n("USAGE: /query <nickname> [<message>] - Open a private chat with this user."),
 227                 CommandHandler::SystemAlias, 1);
 228 */
 229 /*      commandHandler->registerAlias(this, QString::fromLatin1("quit"),
 230                 QString::fromLatin1("raw quit :%s"),
 231                 i18n("USAGE: /quit [<reason>] - Disconnect from IRC, optionally leaving a message."),
 232                 CommandHandler::SystemAlias);*/
 233 /*
 234         commandHandler->registerAlias(this, QString::fromLatin1("topic"),
 235                 QString::fromLatin1("raw TOPIC :%s"),
 236                 i18n("USAGE: /topic [<topic>] - Sets and/or displays the topic for the active channel."),
 237                 CommandHandler::SystemAlias);
 238
 239         commandHandler->registerAlias(this, QString::fromLatin1("voice"),
 240                 SLOT(slotVoiceCommand( const QString &, Kopete::ChatSession*)),
 241                 i18n("USAGE: /voice <nickname> [<nickname 2> <...>] - Give channel voice status to someone (requires operator status)."),
 242                 CommandHandler::SystemAlias, 1);
 243 */
 244 /*      commandHandler->registerAlias( this, QString::fromLatin1("who"),
 245                 QString::fromLatin1( "raw WHO %1" ),
 246                 i18n("USAGE: /who <nickname|channel> - Display who info on this user/channel."),
 247                 CommandHandler::SystemAlias, 1, 1 );
 248
 249         commandHandler->registerAlias( this, QString::fromLatin1("whois"),
 250                 QString::fromLatin1("raw WHOIS %1"),
 251                 i18n("USAGE: /whois <nickname> - Display whois info on this user."),
 252                 CommandHandler::SystemAlias, 1, 1);
 253
 254         commandHandler->registerAlias( this, QString::fromLatin1("whowas"),
 255                 QString::fromLatin1( "raw WHOWAS %1" ),
 256                 i18n("USAGE: /whowas <nickname> - Display whowas info on this user."),
 257                 CommandHandler::SystemAlias, 1, 1);
 258
 259         // Alias of alias
 260         commandHandler->registerAlias( this, QString::fromLatin1("j"),
 261                 QString::fromLatin1("join %1"),
 262                 i18n("USAGE: /j <#channel 1> [<password>] - Alias for JOIN."),
 263                 CommandHandler::SystemAlias, 1, 2);
 264 /*
 265         commandHandler->registerAlias( this, QString::fromLatin1("msg"),
 266                 QString::fromLatin1("query %s"),
 267                 i18n("USAGE: /msg <nickname> [<message>] - Alias for QUERY <nickname> <message>."),
 268                 CommandHandler::SystemAlias, 1);
 269 */
 270
 271         // Utility alias
 272 /*
 273         commandHandler->registerAlias( this, QString::fromLatin1("ns"),
 274                 QString::fromLatin1("msg nickserv %s"),
 275                 i18n("USAGE: /ns <message> - Alias for MSG NickServ <message>."),
 276                 CommandHandler::SystemAlias, 1);
 277 */
 278         QObject::connect( ChatSessionManager::self(), SIGNAL(aboutToDisplay(Kopete::Message &)),
 279                 this, SLOT(slotMessageFilter(Kopete::Message &)) );
 280
 281         QObject::connect( ChatSessionManager::self(), SIGNAL( viewCreated( KopeteView* ) ),
 282                 this, SLOT( slotViewCreated( KopeteView* ) ) );
 283
 284         setCapabilities(Protocol::RichBFormatting | Kopete::Protocol::RichUFormatting | Kopete::Protocol::RichColor);
 285
 286         m_protocolHandler = new IRCProtocolHandler();
 287 }
 288
 289 IRCProtocol * IRCProtocol::self()
 290 {
 291         return s_protocol;
 292 }
 293
 294 IRCProtocol::~IRCProtocol()
 295 {
 296         delete m_protocolHandler;
 297 }
 298
 299 void IRCProtocol::initOnlineStatus()
 300 {
 301 /*
 302         OnlineStatus ServerOnline(OnlineStatus::Online, 100, this, 0,
 303                 QString(), i18n("Online"));
 304
 305         OnlineStatus ServerOffline(OnlineStatus::Offline, 90, this, 0,
 306                 QString(), i18n("Offline"));
 307
 308         m_statusMap.insert(ServerOnline.internalStatus(), ServerOnline);
 309         m_statusMap.insert(ServerOffline.internalStatus(), ServerOffline);
 310
 311         ChannelOnline(OnlineStatus::Online, 80, this, EntityType::Channel|EntityType::Online,
 312                 QString(), i18n("Online")),
 313         m_statusMap.insert(ChannelOnline.internalStatus(), ChannelOnline);
 314
 315         ChannelOffline(OnlineStatus::Offline, 70, this, EntityType::Channel|EntityType::OfflineChannel,
 316                 QString(), i18n("Offline")),
 317         m_statusMap.insert(ChannelOffline.internalStatus(), ChannelOffline);
 318
 319         KIrc::EntityStatus status;
 320         status.type = KIrc::User;
 321
 322         onlineStatusFor(status, OnlineStatusManager::Offline);
 323
 324         status.online = true;
 325         onlineStatusFor(status,  OnlineStatusManager::Online);
 326
 327         status.mode_a = true;
 328         onlineStatusFor(status,  OnlineStatusManager::Away);
 329
 330         OnlineStatus UserOnline(OnlineStatus::Online, 25, this, 0,
 331                 QString(), i18n("Online"), i18n("Online"), OnlineStatusManager::Online);
 332
 333         OnlineStatus UserAway(OnlineStatus::Away, 2, this, 0,
 334                 "contact_away_overlay", i18n("Away"), i18n("Away"), OnlineStatusManager::Away);
 335
 336         OnlineStatus UserConnecting(OnlineStatus::Connecting, 1, this, 0,
 337                 "irc_connecting", i18n("Connecting"));
 338
 339         OnlineStatus UserOffline(OnlineStatus::Offline, 0, this, 0,
 340                 QString(), i18n("Offline"), i18n("Offline"), OnlineStatusManager::Offline);
 341 */
 342 }
 343
 344 OnlineStatus IRCProtocol::onlineStatusFor(const KIrc::Entity::Ptr &entity)
 345 {
 346 //      return onlineStatusFor(entity, 0);
 347         return OnlineStatus::Unknown;
 348 }
 349 /*
 350 OnlineStatus IRCProtocol::onlineStatusFor(const KIrc::Entity::Ptr &entity, unsigned categories)
 351 {
 352         // Only copy the needed status
 353         KIrc::EntityStatus status;
 354         status.online = _status.online;
 355         status.mode_a = _status.mode_a;
 356 //      status.mode_i = _status.mode_i;
 357         status.mode_o = _status.mode_o;
 358         status.mode_v = _status.mode_v;
 359         status.mode_O = _status.mode_O;
 360
 361         OnlineStatus ret = m_statusMap[status];
 362         if (ret.status() == OnlineStatus::Unknown)
 363         {
 364                 kDebug(14120) << "New online status.";
 365
 366                 OnlineStatus::StatusType statusType;
 367                 unsigned weight = 0;
 368                 QStringList overlayIcons;
 369                 QString description;
 370
 371                 if (status.online)
 372                 {
 373                         statusType = OnlineStatus::Online;
 374
 375                         weight += 1;
 376                         description = i18n("Online");
 377                         weight <<= 1;
 378
 379                         // Is operator
 380                         if (status.mode_o || status.mode_O)
 381                         {
 382                                 weight += 1;
 383                                 overlayIcons << "irc_op";
 384                                 description = i18n("Operator");
 385                         }
 386                         weight <<= 1;
 387
 388                         // Is Voiced
 389                         if (status.mode_v)
 390                         {
 391                                 weight += 1;
 392                                 overlayIcons << "irc_voice";
 393                                 description = i18n("Voiced");
 394                         }
 395                         weight <<= 1;
 396
 397                         // Is away
 398                         if (status.mode_a)
 399                         {
 400                                 statusType = OnlineStatus::Away;
 401                                 weight += 1;
 402                                 overlayIcons << "contact_away_overlay";
 403                                 description = i18n("Away");
 404                         }
 405                         weight <<= 1;
 406
 407                         // Is Invisible
 408                         if (status.mode_i)
 409                         {
 410                                 statusType = OnlineStatus::Invisible;
 411                                 weight += 1;
 412                         }
 413                         weight <<= 1;
 414
 415                 }
 416                 else
 417                 {
 418                         statusType = OnlineStatus::Offline;
 419                         description = i18n("Offline");
 420                 }
 421
 422                 OnlineStatus onlineStatus(statusType, weight, this,
 423                         0, overlayIcons, description, description, categories);
 424
 425                 m_statusMap.insert(status, onlineStatus);
 426         }
 427
 428         return ret;
 429 }
 430 */
 431 void IRCProtocol::slotViewCreated(KopeteView *view)
 432 {
 433 //      if (view->msgManager()->protocol() == this)
 434 //              new IRCGUIClient(view->msgManager());
 435 }
 436
 437 void IRCProtocol::slotMessageFilter(Message &msg)
 438 {
 439         if (msg.from()->protocol() == this)
 440         {
 441                 QString messageText = msg.escapedBody();
 442
 443                 //Add right click for channels, only replace text not in HTML tags
 444                 messageText.replace(QRegExp( QString::fromLatin1("(?![^<]+>)(#[^#\\s]+)(?![^<]+>)")), QString::fromLatin1("<span class=\"KopeteLink\" type=\"IRCChannel\">\\1</span>") );
 445
 446                 msg.setHtmlBody(messageText);
 447         }
 448 }
 449 /*
 450 QList<KAction *> *IRCProtocol::customChatWindowPopupActions(const Message &m, DOM::Node &n)
 451 {
 452         DOM::HTMLElement e = n;
 453
 454         //isNull checks that the cast was successful
 455         if (!e.isNull() && !m.to().isEmpty())
 456         {
 457                 activeNode = n;
 458                 activeAccount = static_cast<IRCAccount*>( m.from()->account() );
 459 //              if (e.getAttribute(QString::fromLatin1("type")) == QString::fromLatin1("IRCChannel"))
 460 //                      return activeAccount->contactManager()->findChannel(
 461 //                              e.innerText().string() )->customContextMenuActions();
 462         }
 463         return 0;
 464 }
 465 */
 466 AddContactPage *IRCProtocol::createAddContactWidget(QWidget *parent, Account *account)
 467 {
 468         return new IRCAddContactPage(parent,static_cast<IRCAccount*>(account));
 469 }
 470
 471 KopeteEditAccountWidget *IRCProtocol::createEditAccountWidget(Account *account, QWidget *parent)
 472 {
 473         return new IRCEditAccountWidget(qobject_cast<IRCAccount*>(account), parent);
 474 }
 475
 476 Account *IRCProtocol::createNewAccount(const QString &accountId)
 477 {
 478         return new IRCAccount(accountId);
 479 }
 480
 481 Contact *IRCProtocol::deserializeContact(MetaContact *metaContact, const QMap<QString, QString> &serializedData,
 482         const QMap<QString, QString> &/*addressBookData*/)
 483 {
 484         kDebug(14120) ;
 485
 486         QString contactId = serializedData[ "contactId" ];
 487         QString displayName = serializedData[ "displayName" ];
 488
 489         if( displayName.isEmpty() )
 490                 displayName = contactId;
 491
 492         QList<Account*> accounts = AccountManager::self()->accounts( this );
 493         if( !accounts.isEmpty() )
 494         {
 495 /*              Account *a = accounts[ serializedData[ "accountId" ] ];
 496                 if( a )
 497                 {
 498                         a->addContact( contactId, metaContact );
 499                         return a->contacts()[contactId];
 500                 }
 501                 else
 502                         kDebug(14120) << serializedData[ "accountId" ] << " was a contact's account,"
 503                                 " but we don't have it in the accounts list" << endl; */
 504         }
 505         else
 506                 kDebug(14120) << "No accounts loaded!";
 507
 508         return 0;
 509 }
 510
 511 void IRCProtocol::slotAllCommand(const QString &args, ChatSession *manager)
 512 {
 513 #ifdef __GNUC__
 514 #warning IMPLEMENT ME
 515 #endif
 516 }
 517
 518 void IRCProtocol::slotCtcpCommand(const QString &args, ChatSession *manager)
 519 {
 520         if (!args.isEmpty())
 521         {
 522                 QString user = args.section( ' ', 0, 0 );
 523                 QString message = args.section( ' ', 1 );
 524 //              static_cast<IRCAccount*>(manager->account())->client()->writeCtcpQueryMessage(
 525 //                      user, QString(), message);
 526         }
 527 }
 528
 529 void IRCProtocol::slotQuoteCommand( const QString &args, ChatSession *manager )
 530 {
 531 //      static_cast<IRCAccount *>(manager->account())->client()->writeRawMessage(args);
 532 }
 533
 534 void IRCProtocol::slotRawCommand( const QString &args, ChatSession *manager )
 535 {
 536 //      static_cast<IRCAccount*>(manager->account())->client()->writeRawMessage(args);
 537 }
 538
 539 void IRCProtocol::editNetworks(const QString &networkName)
 540 {
 541
 542         IRCNetworkConfigWidget *netConf = new IRCNetworkConfigWidget(UI::Global::mainWidget() );
 543         netConf->setAttribute( Qt::WA_DeleteOnClose );
 544         netConf->editNetworks(networkName);
 545         netConf->show();
 546 }
 547