kopete/libkopete/kopetecommandhandler.cpp

   1 /*
   2     kopetecommandhandler.cpp - Command Handler
   3
   4     Copyright (c) 2003      by Jason Keirstead       <jason@keirstead.org>
   5     Kopete    (c) 2002-2003 by the Kopete developers <kopete-devel@kde.org>
   6
   7     *************************************************************************
   8     *                                                                       *
   9     * This library is free software; you can redistribute it and/or         *
  10     * modify it under the terms of the GNU Lesser General Public            *
  11     * License as published by the Free Software Foundation; either          *
  12     * version 2 of the License, or (at your option) any later version.      *
  13     *                                                                       *
  14     *************************************************************************
  15 */
  16
  17 #include <qregexp.h>
  18 #include <QList>
  19 #include <QApplication>
  20 #include <kdebug.h>
  21 #include <klocale.h>
  22 #include <kdeversion.h>
  23 #include <kxmlguiclient.h>
  24 #include <kaction.h>
  25 #include <qdom.h>
  26 #include <kauthorized.h>
  27 #include <kactioncollection.h>
  28 #ifndef Q_OS_WIN
  29 #include <k3process.h>
  30 #else
  31 class K3Process : public QObject {
  32 public:
  33     enum RunMode {
  34         NotifyOnExit,
  35     };
  36     enum Communication {
  37         NoCommunication,
  38         AllOutput,
  39     };
  40     K3Process(QObject *) {}
  41
  42     K3Process &operator<< (const QString &arg) { return *this; }
  43     K3Process &operator<< (const char *arg) { return *this; }
  44     K3Process &operator<< (const QByteArray &arg) { return *this; }
  45     K3Process &operator<< (const QStringList &args) { return *this; }
  46     virtual bool start (RunMode runmode=NotifyOnExit, Communication comm=NoCommunication) { return true; }
  47 };
  48 #endif
  49
  50 #include "kopetechatsessionmanager.h"
  51 #include "kopeteprotocol.h"
  52 #include "kopetepluginmanager.h"
  53 #include "kopeteview.h"
  54 #include "kopeteaccountmanager.h"
  55 #include "kopeteaccount.h"
  56 #include "kopetecommandhandler.h"
  57 #include "kopetecontact.h"
  58 #include "kopetecommand.h"
  59 #include "kopeteonlinestatusmanager.h"
  60
  61 using Kopete::CommandList;
  62
  63 typedef QMap<QObject*, CommandList> PluginCommandMap;
  64 typedef QMap<QString,QString> CommandMap;
  65 typedef QPair<Kopete::ChatSession*, Kopete::Message::MessageDirection> ManagerPair;
  66
  67 class KopeteCommandGUIClient : public QObject, public KXMLGUIClient
  68 {
  69         public:
  70                 KopeteCommandGUIClient( Kopete::ChatSession *manager ) : QObject(manager), KXMLGUIClient(manager)
  71                 {
  72                         setXMLFile( QString::fromLatin1("kopetecommandui.rc") );
  73
  74                         QDomDocument doc = domDocument();
  75                         QDomNode menu = doc.documentElement().firstChild().firstChild().firstChild();
  76                         CommandList mCommands = Kopete::CommandHandler::commandHandler()->commands(
  77                                         manager->protocol()
  78                         );
  79
  80                         CommandList::Iterator it, itEnd = mCommands.end();
  81                         for( it = mCommands.begin(); it != itEnd; ++it )
  82                         {
  83                                 KAction *a = static_cast<KAction*>( it.value() );
  84                                 actionCollection()->addAction( a->objectName(), a );
  85                                 QDomElement newNode = doc.createElement( QString::fromLatin1("Action") );
  86                                 newNode.setAttribute( QString::fromLatin1("name"), a->objectName() );
  87
  88                                 bool added = false;
  89                                 for( QDomElement n = menu.firstChild().toElement();
  90                                         !n.isNull(); n = n.nextSibling().toElement() )
  91                                 {
  92                                         if( a->objectName() < n.attribute(QString::fromLatin1("name")))
  93                                         {
  94                                                 menu.insertBefore( newNode, n );
  95                                                 added = true;
  96                                                 break;
  97                                         }
  98                                 }
  99
 100                                 if( !added )
 101                                 {
 102                                         menu.appendChild( newNode );
 103                                 }
 104                         }
 105
 106                         setDOMDocument( doc );
 107                 }
 108 };
 109
 110 struct CommandHandlerPrivate
 111 {
 112         PluginCommandMap pluginCommands;
 113         Kopete::CommandHandler *s_handler;
 114         QMap<K3Process*,ManagerPair> processMap;
 115         bool inCommand;
 116         QList<KAction *> m_commands;
 117 };
 118
 119 CommandHandlerPrivate *Kopete::CommandHandler::p = 0L;
 120
 121 Kopete::CommandHandler::CommandHandler() : QObject( qApp )
 122 {
 123         p->s_handler = this;
 124         p->inCommand = false;
 125
 126         CommandList mCommands;
 127         mCommands.reserve(31);
 128         p->pluginCommands.insert( this, mCommands );
 129
 130         registerCommand( this, QString::fromLatin1("help"), SLOT( slotHelpCommand( const QString &, Kopete::ChatSession * ) ),
 131                 i18n( "USAGE: /help [<command>] - Used to list available commands, or show help for a specified command." ), 0, 1 );
 132
 133         registerCommand( this, QString::fromLatin1("close"), SLOT( slotCloseCommand( const QString &, Kopete::ChatSession * ) ),
 134                 i18n( "USAGE: /close - Closes the current view." ) );
 135
 136         // FIXME: What's the difference with /close? The help doesn't explain it - Martijn
 137         registerCommand( this, QString::fromLatin1("part"), SLOT( slotPartCommand( const QString &, Kopete::ChatSession * ) ),
 138                 i18n( "USAGE: /part - Closes the current view." ) );
 139
 140         registerCommand( this, QString::fromLatin1("clear"), SLOT( slotClearCommand( const QString &, Kopete::ChatSession * ) ),
 141                 i18n( "USAGE: /clear - Clears the active view's chat buffer." ) );
 142
 143         //registerCommand( this, QString::fromLatin1("me"), SLOT( slotMeCommand( const QString &, Kopete::ChatSession * ) ),
 144         //      i18n( "USAGE: /me <text> - Formats message as in '<nickname> went to the store'." ) );
 145
 146         registerCommand( this, QString::fromLatin1("away"), SLOT( slotAwayCommand( const QString &, Kopete::ChatSession * ) ),
 147                 i18n( "USAGE: /away [<reason>] - Marks you as away/back for the current account only." ) );
 148
 149         registerCommand( this, QString::fromLatin1("awayall"), SLOT( slotAwayAllCommand( const QString &, Kopete::ChatSession * ) ),
 150                 i18n( "USAGE: /awayall [<reason>] - Marks you as away/back for all accounts." ) );
 151
 152         registerCommand( this, QString::fromLatin1("say"), SLOT( slotSayCommand( const QString &, Kopete::ChatSession * ) ),
 153                 i18n( "USAGE: /say <text> - Say text in this chat. This is the same as just typing a message, but is very "
 154                         "useful for scripts." ), 1 );
 155
 156         registerCommand( this, QString::fromLatin1("exec"), SLOT( slotExecCommand( const QString &, Kopete::ChatSession * ) ),
 157                 i18n( "USAGE: /exec [-o] <command> - Executes the specified command and displays the output in the chat buffer. "
 158                 "If -o is specified, the output is sent to all members of the chat."), 1 );
 159
 160         connect( Kopete::PluginManager::self(), SIGNAL( pluginLoaded( Kopete::Plugin*) ),
 161                 this, SLOT(slotPluginLoaded(Kopete::Plugin*) ) );
 162
 163         connect( Kopete::ChatSessionManager::self(), SIGNAL( viewCreated( KopeteView * ) ),
 164                 this, SLOT( slotViewCreated( KopeteView* ) ) );
 165 }
 166
 167 Kopete::CommandHandler::~CommandHandler()
 168 {
 169         CommandList commandList = p->pluginCommands[this];
 170         while (!commandList.isEmpty())
 171         {
 172                 Kopete::Command *value = *commandList.begin();
 173                 commandList.erase(commandList.begin());
 174                 delete value;
 175         }
 176
 177         delete p;
 178 }
 179
 180 Kopete::CommandHandler *Kopete::CommandHandler::commandHandler()
 181 {
 182         if( !p )
 183         {
 184                 p = new CommandHandlerPrivate;
 185                 p->s_handler = new Kopete::CommandHandler();
 186         }
 187
 188         return p->s_handler;
 189 }
 190
 191 void Kopete::CommandHandler::registerCommand( QObject *parent, const QString &command, const char* handlerSlot,
 192         const QString &help, uint minArgs, int maxArgs, const KShortcut &cut, const QString &pix )
 193 {
 194         QString lowerCommand = command.toLower();
 195
 196         Kopete::Command *mCommand = new Kopete::Command( parent, lowerCommand, handlerSlot, help,
 197                 Normal, QString::null, minArgs, maxArgs, cut, pix);     //krazy:exclude=nullstrassign for old broken gcc
 198         p->pluginCommands[ parent ].insert( lowerCommand, mCommand );
 199 }
 200
 201 void Kopete::CommandHandler::unregisterCommand( QObject *parent, const QString &command )
 202 {
 203         if( p->pluginCommands[ parent ].contains(command) )
 204                 p->pluginCommands[ parent ].remove( command );
 205 }
 206
 207 void Kopete::CommandHandler::registerAlias( QObject *parent, const QString &alias, const QString &formatString,
 208         const QString &help, CommandType type, uint minArgs, int maxArgs, const KShortcut &cut, const QString &pix )
 209 {
 210         QString lowerAlias = alias.toLower();
 211
 212         Kopete::Command *mCommand = new Kopete::Command( parent, lowerAlias, 0L, help, type,
 213                 formatString, minArgs, maxArgs, cut, pix );
 214         p->pluginCommands[ parent ].insert( lowerAlias, mCommand );
 215 }
 216
 217 void Kopete::CommandHandler::unregisterAlias( QObject *parent, const QString &alias )
 218 {
 219         if( p->pluginCommands[ parent ].contains(alias) )
 220                 p->pluginCommands[ parent ].remove( alias );
 221 }
 222
 223 bool Kopete::CommandHandler::processMessage( const QString &msg, Kopete::ChatSession *manager )
 224 {
 225         if( p->inCommand )
 226                 return false;
 227         QRegExp splitRx( QString::fromLatin1("^/([\\S]+)(.*)") );
 228         QString command;
 229         QString args;
 230         if(splitRx.indexIn(msg) != -1)
 231         {
 232                 command = splitRx.cap(1);
 233                 args = splitRx.cap(2).mid(1);
 234         }
 235         else
 236                 return false;
 237
 238         CommandList mCommands = commands( manager->protocol() );
 239         Kopete::Command *c = mCommands.value(command);
 240         if(c)
 241         {
 242                 kDebug(14010) << "Handled Command";
 243                 if( c->type() != SystemAlias && c->type() != UserAlias )
 244                         p->inCommand = true;
 245
 246                 c->processCommand( args, manager );
 247                 p->inCommand = false;
 248
 249                 return true;
 250         }
 251
 252         return false;
 253 }
 254
 255 bool Kopete::CommandHandler::processMessage( Kopete::Message &msg, Kopete::ChatSession *manager )
 256 {
 257         QString messageBody = msg.plainBody();
 258
 259         return processMessage( messageBody, manager );
 260 }
 261
 262 void Kopete::CommandHandler::slotHelpCommand( const QString &args, Kopete::ChatSession *manager )
 263 {
 264         QString output;
 265         if( args.isEmpty() )
 266         {
 267                 int commandCount = 0;
 268                 output = i18n( "Available Commands:\n" );
 269
 270                 CommandList mCommands = commands( manager->myself()->protocol() );
 271                 CommandList::Iterator it, itEnd = mCommands.end();
 272                 for( it = mCommands.begin(); it != itEnd; ++it )
 273                 {
 274                         output.append( it.value()->command().toUpper() + '\t' );
 275                         if( commandCount++ == 5 )
 276                         {
 277                                 commandCount = 0;
 278                                 output.append( '\n' );
 279                         }
 280                 }
 281                 output.append( i18n( "\nType /help <command> for more information." ) );
 282         }
 283         else
 284         {
 285                 QString command = parseArguments( args ).front().toLower();
 286                 Kopete::Command *c = commands( manager->myself()->protocol() ).value( command );
 287                 if( c && !c->help().isNull() )
 288                         output = c->help();
 289                 else
 290                         output = i18n("There is no help available for '%1'.", command );
 291         }
 292
 293         Kopete::Message msg(manager->myself(), manager->members());
 294         msg.setDirection( Kopete::Message::Internal );
 295         msg.setPlainBody( output );
 296
 297         manager->appendMessage(msg);
 298 }
 299
 300 void Kopete::CommandHandler::slotSayCommand( const QString &args, Kopete::ChatSession *manager )
 301 {
 302         //Just say whatever is passed
 303         Kopete::Message msg(manager->myself(), manager->members());
 304         msg.setPlainBody( args );
 305         msg.setDirection( Kopete::Message::Outbound );
 306
 307         manager->sendMessage(msg);
 308 }
 309
 310 void Kopete::CommandHandler::slotExecCommand( const QString &args, Kopete::ChatSession *manager )
 311 {
 312         if( !args.isEmpty() )
 313         {
 314                 K3Process *proc = 0L;
 315                 if ( KAuthorized::authorizeKAction( "shell_access" ) )
 316                                 proc = new K3Process(manager);
 317                 if( proc )
 318                 {
 319                         *proc << QString::fromLatin1("sh") << QString::fromLatin1("-c");
 320
 321                         QStringList argsList = parseArguments( args );
 322                         if( argsList.front() == QString::fromLatin1("-o") )
 323                         {
 324                                 p->processMap.insert( proc, ManagerPair(manager, Kopete::Message::Outbound) );
 325                                 *proc << args.section(QRegExp(QString::fromLatin1("\\s+")), 1);
 326                         }
 327                         else
 328                         {
 329                                 p->processMap.insert( proc, ManagerPair(manager, Kopete::Message::Internal) );
 330                                 *proc << args;
 331                         }
 332
 333                         connect(proc, SIGNAL(receivedStdout(K3Process *, char *, int)), this, SLOT(slotExecReturnedData(K3Process *, char *, int)));
 334                         connect(proc, SIGNAL(receivedStderr(K3Process *, char *, int)), this, SLOT(slotExecReturnedData(K3Process *, char *, int)));
 335                         proc->start( K3Process::NotifyOnExit, K3Process::AllOutput );
 336                 }
 337                 else
 338                 {
 339                         Kopete::Message msg(manager->myself(), manager->members()  );
 340                         msg.setDirection( Kopete::Message::Internal );
 341                         msg.setPlainBody( i18n( "ERROR: Shell access has been restricted on your system. The /exec command will not function." ) );
 342                         manager->sendMessage( msg );
 343                 }
 344         }
 345 }
 346
 347 void Kopete::CommandHandler::slotClearCommand( const QString &, Kopete::ChatSession *manager )
 348 {
 349         if( manager->view() )
 350                 manager->view()->clear();
 351 }
 352
 353 void Kopete::CommandHandler::slotPartCommand( const QString &, Kopete::ChatSession *manager )
 354 {
 355         if( manager->view() )
 356                 manager->view()->closeView();
 357 }
 358
 359 void Kopete::CommandHandler::slotAwayCommand( const QString &args, Kopete::ChatSession *manager )
 360 {
 361         bool goAway = !manager->account()->isAway();
 362
 363         if( args.isEmpty() )
 364                 manager->account()->setOnlineStatus( OnlineStatusManager::self()->onlineStatus(manager->account()->protocol() , goAway ? OnlineStatusManager::Away : OnlineStatusManager::Online) );
 365         else
 366                 manager->account()->setOnlineStatus( OnlineStatusManager::self()->onlineStatus(manager->account()->protocol() , goAway ? OnlineStatusManager::Away : OnlineStatusManager::Online) , args);
 367 }
 368
 369 void Kopete::CommandHandler::slotAwayAllCommand( const QString &args, Kopete::ChatSession *manager )
 370 {
 371         if( manager->account()->isAway() ) {
 372                 Kopete::AccountManager::self()->setOnlineStatus( Kopete::OnlineStatusManager::Online );
 373         }
 374         else {
 375                 Kopete::AccountManager::self()->setOnlineStatus( Kopete::OnlineStatusManager::Away, args );
 376         }
 377 }
 378
 379 void Kopete::CommandHandler::slotCloseCommand( const QString &, Kopete::ChatSession *manager )
 380 {
 381         if( manager->view() )
 382                 manager->view()->closeView();
 383 }
 384
 385 void Kopete::CommandHandler::slotExecReturnedData(K3Process *proc, char *buff, int bufflen )
 386 {
 387         kDebug(14010) ;
 388         QString buffer = QString::fromLocal8Bit( buff, bufflen );
 389         ManagerPair mgrPair = p->processMap[ proc ];
 390         Kopete::Message msg( mgrPair.first->myself(), mgrPair.first->members()  );
 391         msg.setDirection( mgrPair.second );
 392         msg.setPlainBody( buffer );
 393
 394         if( mgrPair.second == Kopete::Message::Outbound )
 395                 mgrPair.first->sendMessage( msg );
 396         else
 397                 mgrPair.first->appendMessage( msg );
 398 }
 399
 400 void Kopete::CommandHandler::slotExecFinished(K3Process *proc)
 401 {
 402         delete proc;
 403         p->processMap.remove( proc );
 404 }
 405
 406 QStringList Kopete::CommandHandler::parseArguments( const QString &args )
 407 {
 408         QStringList arguments;
 409         QRegExp quotedArgs( QString::fromLatin1("\"(.*)\"") );
 410         quotedArgs.setMinimal( true );
 411
 412         if ( quotedArgs.indexIn( args ) != -1 )
 413         {
 414                 for( int i = 0; i< quotedArgs.numCaptures(); i++ )
 415                         arguments.append( quotedArgs.cap(i) );
 416         }
 417
 418         QStringList otherArgs = args.section( quotedArgs, 0 ).split( QRegExp(QString::fromLatin1("\\s+")), QString::SkipEmptyParts);
 419         for( QStringList::Iterator it = otherArgs.begin(); it != otherArgs.end(); ++it )
 420                 arguments.append( *it );
 421
 422         return arguments;
 423 }
 424
 425 bool Kopete::CommandHandler::commandHandled( const QString &command )
 426 {
 427         for( PluginCommandMap::Iterator it = p->pluginCommands.begin(); it != p->pluginCommands.end(); ++it )
 428         {
 429                 if( it.value().value( command ) )
 430                         return true;
 431         }
 432
 433         return false;
 434 }
 435
 436 bool Kopete::CommandHandler::commandHandledByProtocol( const QString &command, Kopete::Protocol *protocol )
 437 {
 438         // Make sure the protocol is not NULL
 439         if(!protocol)
 440                 return false;
 441
 442         // Fetch the commands for the protocol
 443         CommandList commandList = commands( protocol );
 444         CommandList::Iterator it, itEnd = commandList.end();
 445
 446         // Loop through commands and check if they match the supplied command
 447         for( it = commandList.begin(); it != itEnd; ++it )
 448         {
 449                 if( it.value()->command().toLower() == command )
 450                         return true;
 451         }
 452
 453         // No commands found
 454         return false;
 455 }
 456
 457 CommandList Kopete::CommandHandler::commands( Kopete::Protocol *protocol )
 458 {
 459         CommandList commandList;
 460         commandList.reserve(63);
 461
 462         //Add plugin user aliases first
 463         addCommands( p->pluginCommands[protocol], commandList, UserAlias );
 464
 465         //Add plugin system aliases next
 466         addCommands( p->pluginCommands[protocol], commandList, SystemAlias );
 467
 468         //Add the commands for this protocol next
 469         addCommands( p->pluginCommands[protocol], commandList );
 470
 471         //Add plugin commands
 472         for( PluginCommandMap::Iterator it = p->pluginCommands.begin(); it != p->pluginCommands.end(); ++it )
 473         {
 474                 if( !it.key()->inherits("Kopete::Protocol") && it.key()->inherits("Kopete::Plugin") )
 475                         addCommands( it.value(), commandList );
 476         }
 477
 478         //Add global user aliases first
 479         addCommands( p->pluginCommands[this], commandList, UserAlias );
 480
 481         //Add global system aliases next
 482         addCommands( p->pluginCommands[this], commandList, SystemAlias );
 483
 484         //Add the internal commands *last*
 485         addCommands( p->pluginCommands[this], commandList );
 486
 487         return commandList;
 488 }
 489
 490 void Kopete::CommandHandler::addCommands( CommandList &from, CommandList &to, CommandType type )
 491 {
 492         CommandList::Iterator itDict, itDictEnd = from.end();
 493         for( itDict = from.begin(); itDict != itDictEnd; ++itDict )
 494         {
 495                 if( !to.value( itDict.key() ) &&
 496                                 ( type == Undefined || itDict.value()->type() == type ) )
 497                         to.insert( itDict.key(), itDict.value() );
 498         }
 499 }
 500
 501 void Kopete::CommandHandler::slotViewCreated( KopeteView *view )
 502 {
 503         new KopeteCommandGUIClient( view->msgManager() );
 504 }
 505
 506 void Kopete::CommandHandler::slotPluginLoaded( Kopete::Plugin *plugin )
 507 {
 508         connect( plugin, SIGNAL( destroyed( QObject * ) ), this, SLOT( slotPluginDestroyed( QObject * ) ) );
 509         if( !p->pluginCommands.contains( plugin ) )
 510         {
 511                 //Create a QDict optomized for a larger # of commands, and case insensitive
 512                 CommandList mCommands;
 513                 mCommands.reserve(31);
 514                 p->pluginCommands.insert( plugin, mCommands );
 515         }
 516 }
 517
 518 void Kopete::CommandHandler::slotPluginDestroyed( QObject *plugin )
 519 {
 520         p->pluginCommands.remove( static_cast<Kopete::Plugin*>(plugin)  );
 521 }
 522
 523 #include "kopetecommandhandler.moc"
 524
 525 // vim: set noet ts=4 sts=4 sw=4:
 526