kopete/protocols/oscar/liboscar/client.cpp

   1 /*
   2         client.cpp - Kopete Oscar Protocol
   3
   4         Copyright (c) 2004-2005 Matt Rogers <mattr@kde.org>
   5     Copyright (c) 2007 Roman Jarosz <kedgedev@centrum.cz>
   6
   7         Based on code Copyright (c) 2004 SuSE Linux AG <http://www.suse.com>
   8         Based on Iris, Copyright (C) 2003  Justin Karneges
   9
  10         Kopete (c) 2002-2007 by the Kopete developers <kopete-devel@kde.org>
  11
  12         *************************************************************************
  13         *                                                                       *
  14         * This library is free software; you can redistribute it and/or         *
  15         * modify it under the terms of the GNU Lesser General Public            *
  16         * License as published by the Free Software Foundation; either          *
  17         * version 2 of the License, or (at your option) any later version.      *
  18         *                                                                       *
  19         *************************************************************************
  20 */
  21
  22 #include "client.h"
  23
  24 #include <qtimer.h>
  25 #include <QList>
  26 #include <QByteArray>
  27 #include <qtextcodec.h>
  28 #include <QtNetwork/QTcpSocket>
  29
  30 #include <kdebug.h> //for kDebug()
  31 #include <klocale.h>
  32
  33 #include "filetransfertask.h"
  34 #include "buddyicontask.h"
  35 #include "clientreadytask.h"
  36 #include "connectionhandler.h"
  37 #include "changevisibilitytask.h"
  38 #include "chatnavservicetask.h"
  39 #include "errortask.h"
  40 #include "icquserinfo.h"
  41 #include "icquserinfotask.h"
  42 #include "logintask.h"
  43 #include "connection.h"
  44 #include "messagereceivertask.h"
  45 #include "onlinenotifiertask.h"
  46 #include "oscarclientstream.h"
  47 #include "oscarsettings.h"
  48 #include "oscarutils.h"
  49 #include "ownuserinfotask.h"
  50 #include "profiletask.h"
  51 #include "senddcinfotask.h"
  52 #include "sendmessagetask.h"
  53 #include "serverredirecttask.h"
  54 #include "servicesetuptask.h"
  55 #include "contactmanager.h"
  56 #include "ssimodifytask.h"
  57 #include "ssiauthtask.h"
  58 #include "offlinemessagestask.h"
  59 #include "task.h"
  60 #include "typingnotifytask.h"
  61 #include "userinfotask.h"
  62 #include "usersearchtask.h"
  63 #include "warningtask.h"
  64 #include "chatservicetask.h"
  65 #include "rateclassmanager.h"
  66 #include "icquserinfoupdatetask.h"
  67 #include "icqchangepasswordtask.h"
  68 #include "oscarmessageplugin.h"
  69 #include "xtrazxtraznotify.h"
  70 #include "xtrazxawayservice.h"
  71 #include "closeconnectiontask.h"
  72 #include "icqtlvinforequesttask.h"
  73 #include "icqtlvinfoupdatetask.h"
  74
  75
  76 namespace
  77 {
  78         class DefaultCodecProvider : public Client::CodecProvider
  79         {
  80         public:
  81                 virtual QTextCodec* codecForContact( const QString& ) const
  82                 {
  83                         return QTextCodec::codecForMib( 4 );
  84                 }
  85                 virtual QTextCodec* codecForAccount() const
  86                 {
  87                         return QTextCodec::codecForMib( 4 );
  88                 }
  89         };
  90
  91         DefaultCodecProvider defaultCodecProvider;
  92 }
  93
  94 class Client::ClientPrivate
  95 {
  96 public:
  97         ClientPrivate() {}
  98
  99         QString host, user, pass;
 100         uint port;
 101         int tzoffset;
 102         bool active;
 103
 104         enum { StageOne, StageTwo };
 105         int stage;
 106
 107         //Protocol specific data
 108         bool isIcq;
 109         bool redirectRequested;
 110         QList<Oscar::WORD> redirectionServices;
 111     Oscar::WORD currentRedirect;
 112         QByteArray cookie;
 113         Oscar::Settings* settings;
 114
 115         //Tasks
 116         ErrorTask* errorTask;
 117         OnlineNotifierTask* onlineNotifier;
 118         OwnUserInfoTask* ownStatusTask;
 119         MessageReceiverTask* messageReceiverTask;
 120         SSIAuthTask* ssiAuthTask;
 121         ICQUserInfoRequestTask* icqInfoTask;
 122         ICQTlvInfoRequestTask* icqTlvInfoTask;
 123         UserInfoTask* userInfoTask;
 124         TypingNotifyTask * typingNotifyTask;
 125         SSIModifyTask* ssiModifyTask;
 126         //Managers
 127         ContactManager* ssiManager;
 128         ConnectionHandler connections;
 129
 130         //Our Userinfo
 131         UserDetails ourDetails;
 132
 133     //Infos
 134     QList<int> exchanges;
 135
 136         struct Status
 137         {
 138                 Oscar::DWORD status;
 139                 QString message;     // for away-,DND-message etc., and for Xtraz status
 140                 int xtraz;           // Xtraz status
 141                 QString description; // Xtraz description
 142                 bool sent;
 143         } status;
 144
 145         //away messages
 146         struct AwayMsgRequest
 147         {
 148                 QString contact;
 149                 ICQStatus contactStatus;
 150         };
 151         QList<AwayMsgRequest> awayMsgRequestQueue;
 152         QTimer* awayMsgRequestTimer;
 153         CodecProvider* codecProvider;
 154
 155         const Oscar::ClientVersion* version;
 156         Guid versionCap;
 157 };
 158
 159 Client::Client( QObject* parent )
 160 :QObject( parent )
 161 {
 162         setObjectName( "oscarclient" );
 163         m_loginTask = 0L;
 164         m_loginTaskTwo = 0L;
 165
 166         d = new ClientPrivate;
 167         d->tzoffset = 0;
 168         d->active = false;
 169         d->isIcq = false; //default to AIM
 170         d->redirectRequested = false;
 171     d->currentRedirect = 0;
 172         d->status.status = 0x0; // default to online
 173         d->status.xtraz = -1; // default to no Xtraz
 174         d->status.sent = false;
 175         d->ssiManager = new ContactManager( this );
 176         d->settings = new Oscar::Settings();
 177         d->errorTask = 0L;
 178         d->onlineNotifier = 0L;
 179         d->ownStatusTask = 0L;
 180         d->messageReceiverTask = 0L;
 181         d->ssiAuthTask = 0L;
 182         d->icqInfoTask = 0L;
 183         d->icqTlvInfoTask = 0L;
 184         d->userInfoTask = 0L;
 185         d->stage = ClientPrivate::StageOne;
 186         d->typingNotifyTask = 0L;
 187         d->ssiModifyTask = 0L;
 188         d->awayMsgRequestTimer = new QTimer();
 189         d->codecProvider = &defaultCodecProvider;
 190
 191         connect( this, SIGNAL( redirectionFinished( Oscar::WORD ) ),
 192                  this, SLOT( checkRedirectionQueue( Oscar::WORD ) ) );
 193         connect( d->awayMsgRequestTimer, SIGNAL( timeout() ),
 194                  this, SLOT( nextICQAwayMessageRequest() ) );
 195 }
 196
 197 Client::~Client()
 198 {
 199
 200         //delete the connections differently than in deleteConnections()
 201         //deleteLater() seems to cause destruction order issues
 202         deleteStaticTasks();
 203     delete d->settings;
 204         delete d->ssiManager;
 205         delete d->awayMsgRequestTimer;
 206         delete d;
 207 }
 208
 209 Oscar::Settings* Client::clientSettings() const
 210 {
 211         return d->settings;
 212 }
 213
 214 void Client::connectToServer( Connection *c, const QString& host, quint16 port, bool auth )
 215 {
 216         d->connections.append( c );
 217         if ( auth == true )
 218         {
 219                 m_loginTask = new StageOneLoginTask( c->rootTask() );
 220                 connect( m_loginTask, SIGNAL( finished() ), this, SLOT( lt_loginFinished() ) );
 221         }
 222
 223         connect( c, SIGNAL( socketError( int, const QString& ) ), this, SLOT( determineDisconnection( int, const QString& ) ) );
 224         c->connectToServer( host, port );
 225 }
 226
 227 void Client::start( const QString &host, const uint port, const QString &userId, const QString &pass )
 228 {
 229         Q_UNUSED( host );
 230         Q_UNUSED( port );
 231         d->user = userId;
 232         d->pass = pass;
 233         d->stage = ClientPrivate::StageOne;
 234         d->active = false;
 235 }
 236
 237 void Client::close()
 238 {
 239         QList<Connection*> cList = d->connections.connections();
 240         for ( int i = 0; i < cList.size(); i++ )
 241                 (new CloseConnectionTask( cList.at(i)->rootTask() ))->go( Task::AutoDelete );
 242
 243         d->active = false;
 244         d->awayMsgRequestTimer->stop();
 245         d->awayMsgRequestQueue.clear();
 246         d->connections.clear();
 247         deleteStaticTasks();
 248
 249         //don't clear the stored status between stage one and two
 250         if ( d->stage == ClientPrivate::StageTwo )
 251         {
 252                 d->status.status = 0x0;
 253                 d->status.xtraz = -1;
 254                 d->status.sent = false;
 255                 d->status.message.clear();
 256                 d->status.description.clear();
 257         }
 258
 259     d->exchanges.clear();
 260     d->redirectRequested = false;
 261     d->currentRedirect = 0;
 262     d->redirectionServices.clear();
 263     d->ssiManager->clear();
 264 }
 265
 266 void Client::setStatus( Oscar::DWORD status, const QString &message, int xtraz, const QString &description )
 267 {
 268         kDebug(OSCAR_RAW_DEBUG) << "Setting status message to "<< message;
 269
 270         // remember the values to reply with, when requested
 271         bool xtrazChanged = (xtraz > -1 || d->status.xtraz != xtraz);
 272         bool statusInfoChanged = ( !d->status.sent || message != d->status.message || description != d->status.description );
 273         d->status.status = status;
 274         d->status.message = message;
 275         d->status.xtraz = xtraz;
 276         d->status.description = description;
 277         d->status.sent = false;
 278
 279         if ( d->active )
 280         {
 281                 if ( d->isIcq )
 282                 {
 283                         //the first connection is always the BOS connection
 284                         Connection* c = d->connections.connectionForFamily( 0x0013 );
 285                         if ( !c )
 286                                 return; //TODO trigger an error of some sort?
 287
 288                         ChangeVisibilityTask* cvt = new ChangeVisibilityTask( c->rootTask() );
 289                         if ( ( status & 0x0100 ) == 0x0100 )
 290                         {
 291                                 kDebug(OSCAR_RAW_DEBUG) << "Setting invisible";
 292                                 cvt->setVisible( false );
 293                         }
 294                         else
 295                         {
 296                                 kDebug(OSCAR_RAW_DEBUG) << "Setting visible";
 297                                 cvt->setVisible( true );
 298                         }
 299                         cvt->go( Task::AutoDelete );
 300                 }
 301
 302                 Connection* c = d->connections.connectionForFamily( 0x0002 );
 303                 if ( !c )
 304                         return;
 305
 306                 SendDCInfoTask* sdcit = new SendDCInfoTask( c->rootTask(), status );
 307                 sdcit->go( Task::AutoDelete ); //autodelete
 308
 309                 QString msg;
 310                 // AIM: you're away exactly when your away message isn't empty.
 311                 // can't use QString() as a message either; ProfileTask
 312                 // interprets null as "don't change".
 313                 if ( (status & 0xFF) == 0x00 ) //is status online?
 314                 {
 315                         msg = QString::fromAscii("");
 316                 }
 317                 else
 318                 {
 319                         if ( message.isEmpty() )
 320                                 msg = QString::fromAscii(" ");
 321                         else
 322                                 msg = message;
 323                 }
 324
 325                 ProfileTask* pt = new ProfileTask( c->rootTask() );
 326                 pt->setAwayMessage( msg );
 327
 328                 if ( d->isIcq && xtrazChanged )
 329                         pt->setXtrazStatus( xtraz );
 330
 331                 pt->go( Task::AutoDelete );
 332
 333                 if ( d->isIcq && statusInfoChanged )
 334                 {
 335                         ICQFullInfo info( false );
 336                         info.statusDescription.set( description.toUtf8() );
 337
 338                         ICQTlvInfoUpdateTask* infoUpdateTask = new ICQTlvInfoUpdateTask( c->rootTask() );
 339                         infoUpdateTask->setInfo( info );
 340                         infoUpdateTask->go( Task::AutoDelete );
 341                 }
 342                 d->status.sent = true;
 343         }
 344 }
 345
 346 UserDetails Client::ourInfo() const
 347 {
 348         return d->ourDetails;
 349 }
 350
 351 QString Client::host()
 352 {
 353         return d->host;
 354 }
 355
 356 int Client::port()
 357 {
 358         return d->port;
 359 }
 360
 361 ContactManager* Client::ssiManager() const
 362 {
 363         return d->ssiManager;
 364 }
 365
 366 const Oscar::ClientVersion* Client::version() const
 367 {
 368         return d->version;
 369 }
 370
 371 Guid Client::versionCap() const
 372 {
 373         return d->versionCap;
 374 }
 375
 376 // SLOTS //
 377
 378 void Client::streamConnected()
 379 {
 380         kDebug(OSCAR_RAW_DEBUG) ;
 381         d->stage = ClientPrivate::StageTwo;
 382         if ( m_loginTaskTwo )
 383                 m_loginTaskTwo->go();
 384 }
 385
 386 void Client::lt_loginFinished()
 387 {
 388         /* Check for stage two login first, since we create the stage two
 389          * task when we finish stage one
 390          */
 391         if ( d->stage == ClientPrivate::StageTwo )
 392         {
 393                 //we've finished logging in. start the services setup
 394                 kDebug(OSCAR_RAW_DEBUG) << "stage two done. setting up services";
 395                 initializeStaticTasks();
 396                 ServiceSetupTask* ssTask = new ServiceSetupTask( d->connections.defaultConnection()->rootTask() );
 397                 connect( ssTask, SIGNAL( finished() ), this, SLOT( serviceSetupFinished() ) );
 398                 ssTask->go( Task::AutoDelete ); //fire and forget
 399                 m_loginTaskTwo->deleteLater();
 400                 m_loginTaskTwo = 0;
 401         }
 402         else if ( d->stage == ClientPrivate::StageOne )
 403         {
 404                 kDebug(OSCAR_RAW_DEBUG) << "stage one login done";
 405                 disconnect( m_loginTask, SIGNAL( finished() ), this, SLOT( lt_loginFinished() ) );
 406
 407                 if ( m_loginTask->statusCode() == 0 ) //we can start stage two
 408                 {
 409                         kDebug(OSCAR_RAW_DEBUG) << "no errors from stage one. moving to stage two";
 410
 411                         //cache these values since they'll be deleted when we close the connections (which deletes the tasks)
 412                         d->host = m_loginTask->bosServer();
 413                         d->port = m_loginTask->bosPort().toUInt();
 414                         d->cookie = m_loginTask->loginCookie();
 415                         close();
 416                         QTimer::singleShot( 100, this, SLOT(startStageTwo() ) );
 417                 }
 418                 else
 419                 {
 420                         kDebug(OSCAR_RAW_DEBUG) << "errors reported. not moving to stage two";
 421                         close(); //deletes the connections for us
 422                 }
 423
 424                 m_loginTask->deleteLater();
 425                 m_loginTask = 0;
 426         }
 427
 428 }
 429
 430 void Client::startStageTwo()
 431 {
 432         //create a new connection and set it up
 433         Connection* c = createConnection();
 434         new CloseConnectionTask( c->rootTask() );
 435
 436         //create the new login task
 437         m_loginTaskTwo = new StageTwoLoginTask( c->rootTask() );
 438         m_loginTaskTwo->setCookie( d->cookie );
 439         QObject::connect( m_loginTaskTwo, SIGNAL( finished() ), this, SLOT( lt_loginFinished() ) );
 440
 441
 442         //connect
 443         QObject::connect( c, SIGNAL( connected() ), this, SLOT( streamConnected() ) );
 444         connectToServer( c, d->host, d->port, false ) ;
 445
 446 }
 447
 448 void Client::serviceSetupFinished()
 449 {
 450         d->active = true;
 451
 452         setStatus( d->status.status, d->status.message, d->status.xtraz, d->status.description );
 453         d->ownStatusTask->go();
 454
 455         if ( isIcq() )
 456         {
 457                 //retrieve offline messages
 458                 Connection* c = d->connections.connectionForFamily( 0x0015 );
 459                 if ( !c )
 460                         return;
 461
 462                 OfflineMessagesTask *offlineMsgTask = new OfflineMessagesTask( c->rootTask() );
 463                 connect( offlineMsgTask, SIGNAL( receivedOfflineMessage(const Oscar::Message& ) ),
 464                                 this, SIGNAL( messageReceived(const Oscar::Message& ) ) );
 465                 offlineMsgTask->go( Task::AutoDelete );
 466         }
 467
 468         emit haveContactList();
 469         emit loggedIn();
 470 }
 471
 472 void Client::receivedIcqInfo( const QString& contact, unsigned int type )
 473 {
 474         kDebug(OSCAR_RAW_DEBUG) << "received icq info for " << contact
 475                 << " of type " << type << endl;
 476
 477         if ( type == ICQUserInfoRequestTask::Short )
 478                 emit receivedIcqShortInfo( contact );
 479         else
 480                 emit receivedIcqLongInfo( contact );
 481 }
 482
 483 void Client::receivedInfo( quint16 sequence )
 484 {
 485         UserDetails details = d->userInfoTask->getInfoFor( sequence );
 486         emit receivedUserInfo( details.userId(), details );
 487 }
 488
 489 void Client::offlineUser( const QString& user, const UserDetails& )
 490 {
 491         emit userIsOffline( user );
 492 }
 493
 494 void Client::haveOwnUserInfo()
 495 {
 496         kDebug( OSCAR_RAW_DEBUG ) ;
 497         UserDetails ud = d->ownStatusTask->getInfo();
 498         d->ourDetails = ud;
 499         emit haveOwnInfo();
 500 }
 501
 502 void Client::setCodecProvider( Client::CodecProvider* codecProvider )
 503 {
 504         d->codecProvider = codecProvider;
 505 }
 506
 507 void Client::setVersion( const Oscar::ClientVersion* version )
 508 {
 509         d->version = version;
 510 }
 511
 512 void Client::setVersionCap( const QByteArray &cap )
 513 {
 514         d->versionCap = Guid( cap );
 515 }
 516
 517 // INTERNALS //
 518
 519 QString Client::userId() const
 520 {
 521         return d->user;
 522 }
 523
 524 QString Client::password() const
 525 {
 526         return d->pass;
 527 }
 528
 529 int Client::statusXtraz() const
 530 {
 531         return d->status.xtraz;
 532 }
 533
 534 QString Client::statusDescription() const
 535 {
 536         return d->status.description;
 537 }
 538
 539 QString Client::statusMessage() const
 540 {
 541         return d->status.message;
 542 }
 543
 544 void Client::setStatusMessage( const QString &message )
 545 {
 546         d->status.message = message;
 547 }
 548
 549 QByteArray Client::ipAddress() const
 550 {
 551         //!TODO determine ip address
 552         return "127.0.0.1";
 553 }
 554
 555 void Client::notifyTaskError( const Oscar::SNAC& s, int errCode, bool fatal )
 556 {
 557         emit taskError( s, errCode, fatal );
 558 }
 559
 560 void Client::notifySocketError( int errCode, const QString& msg )
 561 {
 562         emit socketError( errCode, msg );
 563 }
 564
 565 void Client::sendMessage( const Oscar::Message& msg, bool isAuto)
 566 {
 567     Connection* c = 0L;
 568     if ( msg.channel() == 0x0003 )
 569     {
 570         c = d->connections.connectionForChatRoom( msg.exchange(), msg.chatRoom() );
 571         if ( !c )
 572             return;
 573
 574         kDebug(OSCAR_RAW_DEBUG) << "sending message to chat room";
 575         ChatServiceTask* cst = new ChatServiceTask( c->rootTask(), msg.exchange(), msg.chatRoom() );
 576         cst->setMessage( msg );
 577         cst->setEncoding( d->codecProvider->codecForAccount()->name() );
 578         cst->go( Task::AutoDelete );
 579     }
 580     else
 581     {
 582         c = d->connections.connectionForFamily( 0x0004 );
 583         if ( !c )
 584             return;
 585         SendMessageTask *sendMsgTask = new SendMessageTask( c->rootTask() );
 586         // Set whether or not the message is an automated response
 587         sendMsgTask->setAutoResponse( isAuto );
 588         sendMsgTask->setMessage( msg );
 589         sendMsgTask->go( Task::AutoDelete );
 590     }
 591 }
 592
 593 void Client::receivedMessage( const Oscar::Message& msg )
 594 {
 595         if ( msg.channel() == 2 && !msg.hasProperty( Oscar::Message::AutoResponse ) )
 596         {
 597                 // channel 2 message needs an autoresponse, regardless of type
 598                 Connection* c = d->connections.connectionForFamily( 0x0004 );
 599                 if ( !c )
 600                         return;
 601
 602                 Oscar::Message response ( msg );
 603                 if ( msg.hasProperty( Oscar::Message::StatusMessageRequest ) )
 604                 {
 605                         QTextCodec* codec = d->codecProvider->codecForContact( msg.sender() );
 606                         response.setText( Oscar::Message::UserDefined, statusMessage(), codec );
 607                         emit userReadsStatusMessage( msg.sender() );
 608                 }
 609                 else if ( msg.messageType() == Oscar::MessageType::Plugin )
 610                 {
 611                         Oscar::MessagePlugin::Types type = msg.plugin()->type();
 612                         Oscar::WORD subType = msg.plugin()->subTypeId();
 613                         if ( type == Oscar::MessagePlugin::XtrazScript )
 614                         {
 615                                 if ( subType == Oscar::MessagePlugin::SubScriptNotify )
 616                                 {
 617                                         using namespace Xtraz;
 618                                         XtrazNotify xNotify;
 619                                         xNotify.handle( msg.plugin() );
 620                                         if ( xNotify.type() == XtrazNotify::Request && xNotify.pluginId() == "srvMng" )
 621                                         {
 622                                                 if ( xNotify.findService( "cAwaySrv" ) )
 623                                                 {
 624                                                         XtrazNotify xNotifyResponse;
 625                                                         xNotifyResponse.setSenderUni( userId() );
 626                                                         response.setPlugin( xNotifyResponse.statusResponse( statusXtraz(), statusDescription(), statusMessage() ) );
 627                                                         emit userReadsStatusMessage( msg.sender() );
 628                                                 }
 629                                         }
 630                                 }
 631                         }
 632                         else if ( type == Oscar::MessagePlugin::StatusMsgExt )
 633                         {
 634                                 Buffer buffer;
 635
 636                                 QTextCodec* codec = d->codecProvider->codecForContact( msg.sender() );
 637                                 buffer.addLEDBlock( codec->fromUnicode( statusMessage() ) );
 638                                 //TODO: Change this to text/x-aolrtf
 639                                 buffer.addLEDBlock( "text/plain" );
 640
 641                                 msg.plugin()->setData( buffer.buffer() );
 642                                 emit userReadsStatusMessage( msg.sender() );
 643                         }
 644                 }
 645                 else
 646                 {
 647                         response.setEncoding( Oscar::Message::UserDefined );
 648                         response.setTextArray( QByteArray() );
 649                 }
 650                 response.setReceiver( msg.sender() );
 651                 response.addProperty( Oscar::Message::AutoResponse );
 652                 SendMessageTask *sendMsgTask = new SendMessageTask( c->rootTask() );
 653                 sendMsgTask->setMessage( response );
 654                 sendMsgTask->go( Task::AutoDelete );
 655         }
 656
 657         if ( msg.hasProperty( Oscar::Message::AutoResponse ) )
 658         {
 659                 if ( msg.hasProperty( Oscar::Message::StatusMessageRequest ) )
 660                 {
 661                         // we got a response to a status message request.
 662                         QString awayMessage( msg.text( d->codecProvider->codecForContact( msg.sender() ) ) );
 663                         kDebug( OSCAR_RAW_DEBUG ) << "Received an away message: " << awayMessage;
 664                         emit receivedAwayMessage( msg.sender(), awayMessage );
 665                 }
 666                 else if ( msg.messageType() == Oscar::MessageType::Plugin )
 667                 {
 668                         kDebug( OSCAR_RAW_DEBUG ) << "Received an plugin message response.";
 669
 670                         Oscar::MessagePlugin::Types type = msg.plugin()->type();
 671                         Oscar::WORD subType = msg.plugin()->subTypeId();
 672                         if ( type == Oscar::MessagePlugin::XtrazScript )
 673                         {
 674                                 if ( subType == Oscar::MessagePlugin::SubScriptNotify )
 675                                 {
 676                                         using namespace Xtraz;
 677                                         XtrazNotify xNotify;
 678                                         xNotify.handle( msg.plugin() );
 679                                         if ( xNotify.type() == XtrazNotify::Response )
 680                                         {
 681                                                 const Xtraz::XAwayService* service = dynamic_cast<const XAwayService*>(xNotify.findService( "cAwaySrv" ));
 682                                                 if ( service )
 683                                                         emit receivedXStatusMessage( service->senderId(), service->iconIndex(),
 684                                                                                      service->description(), service->message() );
 685                                         }
 686                                 }
 687                         }
 688                         else if ( type == Oscar::MessagePlugin::StatusMsgExt )
 689                         {
 690                                 // we got a response to a status message request.
 691                                 Buffer buffer( msg.plugin()->data() );
 692
 693                                 QTextCodec* codec = d->codecProvider->codecForContact( msg.sender() );
 694                                 QString awayMessage = codec->toUnicode( buffer.getLEDBlock() );
 695                                 kDebug( OSCAR_RAW_DEBUG ) << "Received an away message: " << awayMessage;
 696                                 emit receivedAwayMessage( msg.sender(), awayMessage );
 697                         }
 698                 }
 699         }
 700         else
 701         {
 702                 if ( msg.messageType() == Oscar::MessageType::Plugin )
 703                 {
 704                         kDebug( OSCAR_RAW_DEBUG ) << "Received a plugin message.";
 705                 }
 706                 else if ( !msg.hasProperty( Oscar::Message::StatusMessageRequest ) )
 707                 {
 708                         // let application handle it
 709                         kDebug( OSCAR_RAW_DEBUG ) << "Emitting receivedMessage";
 710                         emit messageReceived( msg );
 711                 }
 712         }
 713 }
 714
 715 void Client::fileMessage( const Oscar::Message& msg )
 716 {
 717         Connection* c = d->connections.connectionForFamily( 0x0004 );
 718         if ( !c )
 719                 return;
 720
 721         kDebug( OSCAR_RAW_DEBUG ) << "internal ip: " << c->localAddress().toString();
 722         kDebug( OSCAR_RAW_DEBUG ) << "external ip: " << ourInfo().dcExternalIp().toString();
 723
 724         SendMessageTask *sendMsgTask = new SendMessageTask( c->rootTask() );
 725         // Set whether or not the message is an automated response
 726         sendMsgTask->setAutoResponse( false );
 727         sendMsgTask->setMessage( msg );
 728         sendMsgTask->setIp( c->localAddress().toIPv4Address() );
 729         sendMsgTask->go( Task::AutoDelete );
 730 }
 731
 732 void Client::requestAuth( const QString& contactid, const QString& reason )
 733 {
 734         Connection* c = d->connections.connectionForFamily( 0x0013 );
 735         if ( !c )
 736                 return;
 737         d->ssiAuthTask->sendAuthRequest( contactid, reason );
 738 }
 739
 740 void Client::sendAuth( const QString& contactid, const QString& reason, bool auth )
 741 {
 742         Connection* c = d->connections.connectionForFamily( 0x0013 );
 743         if ( !c )
 744                 return;
 745         d->ssiAuthTask->sendAuthReply( contactid, reason, auth );
 746 }
 747
 748 bool Client::isActive() const
 749 {
 750         return d->active;
 751 }
 752
 753 bool Client::isIcq() const
 754 {
 755         return d->isIcq;
 756 }
 757
 758 void Client::setIsIcq( bool isIcq )
 759 {
 760         d->isIcq = isIcq;
 761 }
 762
 763 void Client::debug( const QString& str )
 764 {
 765         Q_UNUSED(str);
 766 //      qDebug( "CLIENT: %s", str.toAscii() );
 767 }
 768
 769 void Client::initializeStaticTasks()
 770 {
 771         //set up the extra tasks
 772         Connection* c = d->connections.defaultConnection();
 773         if ( !c )
 774                 return;
 775         d->errorTask = new ErrorTask( c->rootTask() );
 776         d->onlineNotifier = new OnlineNotifierTask( c->rootTask() );
 777         d->ownStatusTask = new OwnUserInfoTask( c->rootTask() );
 778         d->messageReceiverTask = new MessageReceiverTask( c->rootTask() );
 779         d->ssiAuthTask = new SSIAuthTask( c->rootTask() );
 780         d->icqInfoTask = new ICQUserInfoRequestTask( c->rootTask() );
 781         d->icqTlvInfoTask = new ICQTlvInfoRequestTask( c->rootTask() );
 782         d->userInfoTask = new UserInfoTask( c->rootTask() );
 783         d->typingNotifyTask = new TypingNotifyTask( c->rootTask() );
 784         d->ssiModifyTask = new SSIModifyTask( c->rootTask(), true );
 785
 786         connect( d->onlineNotifier, SIGNAL( userIsOnline( const QString&, const UserDetails& ) ),
 787                  this, SIGNAL( receivedUserInfo( const QString&, const UserDetails& ) ) );
 788         connect( d->onlineNotifier, SIGNAL( userIsOffline( const QString&, const UserDetails& ) ),
 789                  this, SLOT( offlineUser( const QString&, const UserDetails & ) ) );
 790
 791         connect( d->ownStatusTask, SIGNAL( gotInfo() ), this, SLOT( haveOwnUserInfo() ) );
 792         connect( d->ownStatusTask, SIGNAL( buddyIconUploadRequested() ), this,
 793                  SIGNAL( iconNeedsUploading() ) );
 794
 795         connect( d->messageReceiverTask, SIGNAL( receivedMessage( const Oscar::Message& ) ),
 796                  this, SLOT( receivedMessage( const Oscar::Message& ) ) );
 797         connect( d->messageReceiverTask, SIGNAL( fileMessage( int, const QString, const QByteArray, Buffer ) ),
 798                  this, SLOT( gotFileMessage( int, const QString, const QByteArray, Buffer ) ) );
 799
 800         connect( d->ssiAuthTask, SIGNAL( authRequested( const QString&, const QString& ) ),
 801                  this, SIGNAL( authRequestReceived( const QString&, const QString& ) ) );
 802         connect( d->ssiAuthTask, SIGNAL( authReplied( const QString&, const QString&, bool ) ),
 803                  this, SIGNAL( authReplyReceived( const QString&, const QString&, bool ) ) );
 804
 805         connect( d->icqInfoTask, SIGNAL( receivedInfoFor( const QString&, unsigned int ) ),
 806                  this, SLOT( receivedIcqInfo( const QString&, unsigned int ) ) );
 807         connect( d->icqTlvInfoTask, SIGNAL(receivedInfoFor(const QString&)),
 808                  this, SIGNAL(receivedIcqTlvInfo(const QString&)) );
 809
 810         connect( d->userInfoTask, SIGNAL( receivedProfile( const QString&, const QString& ) ),
 811                  this, SIGNAL( receivedProfile( const QString&, const QString& ) ) );
 812         connect( d->userInfoTask, SIGNAL( receivedAwayMessage( const QString&, const QString& ) ),
 813                  this, SIGNAL( receivedAwayMessage( const QString&, const QString& ) ) );
 814         connect( d->typingNotifyTask, SIGNAL( typingStarted( const QString& ) ),
 815                  this, SIGNAL( userStartedTyping( const QString& ) ) );
 816         connect( d->typingNotifyTask, SIGNAL( typingFinished( const QString& ) ),
 817                  this, SIGNAL( userStoppedTyping( const QString& ) ) );
 818 }
 819
 820 void Client::removeGroup( const QString& groupName )
 821 {
 822         Connection* c = d->connections.connectionForFamily( 0x0013 );
 823         if ( !c )
 824                 return;
 825
 826         kDebug( OSCAR_RAW_DEBUG ) << "Removing group " << groupName << " from Contact";
 827         SSIModifyTask* ssimt = new SSIModifyTask( c->rootTask() );
 828         if ( ssimt->removeGroup( groupName ) )
 829                 ssimt->go( Task::AutoDelete );
 830         else
 831                 delete ssimt;
 832 }
 833
 834 void Client::addGroup( const QString& groupName )
 835 {
 836         Connection* c = d->connections.connectionForFamily( 0x0013 );
 837         if ( !c )
 838                 return;
 839
 840         kDebug( OSCAR_RAW_DEBUG ) << "Adding group " << groupName << " to Contact";
 841         SSIModifyTask* ssimt = new SSIModifyTask( c->rootTask() );
 842         if ( ssimt->addGroup( groupName ) )
 843                 ssimt->go( Task::AutoDelete );
 844         else
 845                 delete ssimt;
 846 }
 847
 848 void Client::addContact( const QString& contactName, const QString& groupName )
 849 {
 850         Connection* c = d->connections.connectionForFamily( 0x0013 );
 851         if ( !c )
 852                 return;
 853
 854         kDebug( OSCAR_RAW_DEBUG ) << "Adding contact " << contactName << " to ssi in group " << groupName;
 855         SSIModifyTask* ssimt = new SSIModifyTask( c->rootTask() );
 856         if ( ssimt->addContact( contactName, groupName )  )
 857                 ssimt->go( Task::AutoDelete );
 858         else
 859                 delete ssimt;
 860 }
 861
 862 void Client::removeContact( const QString& contactName )
 863 {
 864         Connection* c = d->connections.connectionForFamily( 0x0013 );
 865         if ( !c )
 866                 return;
 867
 868         kDebug( OSCAR_RAW_DEBUG ) << "Removing contact " << contactName << " from ssi";
 869         SSIModifyTask* ssimt = new SSIModifyTask( c->rootTask() );
 870         if ( ssimt->removeContact( contactName ) )
 871                 ssimt->go( Task::AutoDelete );
 872         else
 873                 delete ssimt;
 874 }
 875
 876 void Client::renameGroup( const QString & oldGroupName, const QString & newGroupName )
 877 {
 878         Connection* c = d->connections.connectionForFamily( 0x0013 );
 879         if ( !c )
 880                 return;
 881
 882         kDebug( OSCAR_RAW_DEBUG ) << "Renaming group " << oldGroupName << " to " << newGroupName;
 883         SSIModifyTask* ssimt = new SSIModifyTask( c->rootTask() );
 884         if ( ssimt->renameGroup( oldGroupName, newGroupName ) )
 885                 ssimt->go( Task::AutoDelete );
 886         else
 887                 delete ssimt;
 888 }
 889
 890 void Client::modifyContactItem( const OContact& oldItem, const OContact& newItem )
 891 {
 892         int action = 0; //0 modify, 1 add, 2 remove TODO cleanup!
 893         Connection* c = d->connections.connectionForFamily( 0x0013 );
 894         if ( !c )
 895                 return;
 896
 897         if ( !oldItem && newItem )
 898                 action = 1;
 899         if ( oldItem && !newItem )
 900                 action = 2;
 901
 902         kDebug(OSCAR_RAW_DEBUG) << "Add/Mod/Del item on server";
 903         SSIModifyTask* ssimt = new SSIModifyTask( c->rootTask() );
 904         switch ( action )
 905         {
 906         case 0:
 907                 if ( ssimt->modifyItem( oldItem, newItem ) )
 908                         ssimt->go( Task::AutoDelete );
 909                 else
 910                         delete ssimt;
 911                 break;
 912         case 1:
 913                 if ( ssimt->addItem( newItem ) )
 914                         ssimt->go( Task::AutoDelete );
 915                 else
 916                         delete ssimt;
 917                 break;
 918         case 2:
 919                 if ( ssimt->removeItem( oldItem ) )
 920                         ssimt->go( Task::AutoDelete );
 921                 else
 922                         delete ssimt;
 923                 break;
 924         }
 925 }
 926
 927 void Client::changeContactGroup( const QString& contact, const QString& newGroupName )
 928 {
 929         Connection* c = d->connections.connectionForFamily( 0x0013 );
 930         if ( !c )
 931                 return;
 932
 933         kDebug(OSCAR_RAW_DEBUG) << "Changing " << contact << "'s group to "
 934                 << newGroupName << endl;
 935         SSIModifyTask* ssimt = new SSIModifyTask( c->rootTask() );
 936         if ( ssimt->changeGroup( contact, newGroupName ) )
 937                 ssimt->go( Task::AutoDelete );
 938         else
 939                 delete ssimt;
 940 }
 941
 942 void Client::changeContactAlias( const QString& contact, const QString& alias )
 943 {
 944         Connection* c = d->connections.connectionForFamily( 0x0013 );
 945         if ( !c )
 946                 return;
 947
 948         OContact item = ssiManager()->findContact( contact );
 949         if ( item )
 950         {
 951                 OContact oldItem(item);
 952
 953                 if ( alias.isEmpty() )
 954                 {
 955                         QList<TLV> tList( item.tlvList() );
 956                         TLV tlv = Oscar::findTLV( tList, 0x0131 );
 957                         if ( !tlv )
 958                                 return;
 959
 960                         tList.removeAll( tlv );
 961                         item.setTLVList( tList );
 962                 }
 963                 else
 964                 {
 965                         QList<TLV> tList;
 966
 967                         QByteArray data = alias.toUtf8();
 968                         tList.append( TLV( 0x0131, data.size(), data ) );
 969
 970                         if ( !Oscar::updateTLVs( item, tList ) )
 971                                 return;
 972                 }
 973
 974                 kDebug( OSCAR_RAW_DEBUG ) << "Changing " << contact << "'s alias to " << alias << endl;
 975                 SSIModifyTask* ssimt = new SSIModifyTask( c->rootTask() );
 976                 if ( ssimt->modifyContact( oldItem, item ) )
 977                         ssimt->go( Task::AutoDelete );
 978                 else
 979                         delete ssimt;
 980         }
 981 }
 982
 983 void Client::requestShortTlvInfo( const QString& contactId, const QByteArray &metaInfoId )
 984 {
 985         Connection* c = d->connections.connectionForFamily( 0x0015 );
 986         if ( !c )
 987                 return;
 988
 989         d->icqTlvInfoTask->setUser( Oscar::normalize( contactId ) );
 990         d->icqTlvInfoTask->setMetaInfoId( metaInfoId );
 991         d->icqTlvInfoTask->setType( ICQTlvInfoRequestTask::Short );
 992         d->icqTlvInfoTask->go();
 993 }
 994
 995 void Client::requestMediumTlvInfo( const QString& contactId, const QByteArray &metaInfoId )
 996 {
 997         Connection* c = d->connections.connectionForFamily( 0x0015 );
 998         if ( !c )
 999                 return;
1000
1001         d->icqTlvInfoTask->setUser( Oscar::normalize( contactId ) );
1002         d->icqTlvInfoTask->setMetaInfoId( metaInfoId );
1003         d->icqTlvInfoTask->setType( ICQTlvInfoRequestTask::Medium );
1004         d->icqTlvInfoTask->go();
1005 }
1006
1007 void Client::requestLongTlvInfo( const QString& contactId, const QByteArray &metaInfoId )
1008 {
1009         Connection* c = d->connections.connectionForFamily( 0x0015 );
1010         if ( !c )
1011                 return;
1012
1013         d->icqTlvInfoTask->setUser( Oscar::normalize( contactId ) );
1014         d->icqTlvInfoTask->setMetaInfoId( metaInfoId );
1015         d->icqTlvInfoTask->setType( ICQTlvInfoRequestTask::Long );
1016         d->icqTlvInfoTask->go();
1017 }
1018
1019 void Client::requestFullInfo( const QString& contactId )
1020 {
1021         Connection* c = d->connections.connectionForFamily( 0x0015 );
1022         if ( !c )
1023                 return;
1024         d->icqInfoTask->setUser( contactId );
1025         d->icqInfoTask->setType( ICQUserInfoRequestTask::Long );
1026         d->icqInfoTask->go();
1027 }
1028
1029 void Client::requestShortInfo( const QString& contactId )
1030 {
1031         Connection* c = d->connections.connectionForFamily( 0x0015 );
1032         if ( !c )
1033                 return;
1034         d->icqInfoTask->setUser( contactId );
1035         d->icqInfoTask->setType( ICQUserInfoRequestTask::Short );
1036         d->icqInfoTask->go();
1037 }
1038
1039 void Client::sendWarning( const QString& contact, bool anonymous )
1040 {
1041         Connection* c = d->connections.connectionForFamily( 0x0004 );
1042         if ( !c )
1043                 return;
1044         WarningTask* warnTask = new WarningTask( c->rootTask() );
1045         warnTask->setContact( contact );
1046         warnTask->setAnonymous( anonymous );
1047         QObject::connect( warnTask, SIGNAL( userWarned( const QString&, quint16, quint16 ) ),
1048                           this, SIGNAL( userWarned( const QString&, quint16, quint16 ) ) );
1049         warnTask->go( Task::AutoDelete );
1050 }
1051
1052 bool Client::changeICQPassword( const QString& password )
1053 {
1054         Connection* c = d->connections.connectionForFamily( 0x0015 );
1055         if ( !c )
1056                 return false;
1057
1058         ICQChangePasswordTask* task = new ICQChangePasswordTask( c->rootTask() );
1059         QObject::connect( task, SIGNAL(finished()), this, SLOT(changeICQPasswordFinished()) );
1060         task->setPassword( password );
1061         task->go( Task::AutoDelete );
1062         return true;
1063 }
1064
1065 void Client::changeICQPasswordFinished()
1066 {
1067         ICQChangePasswordTask* task = (ICQChangePasswordTask*)sender();
1068         if ( task->success() )
1069                 d->pass = task->password();
1070
1071         emit icqPasswordChanged( !task->success() );
1072 }
1073
1074 ICQFullInfo Client::getFullInfo( const QString& contact )
1075 {
1076         return d->icqTlvInfoTask->fullInfoFor( contact );
1077 }
1078
1079 ICQGeneralUserInfo Client::getGeneralInfo( const QString& contact )
1080 {
1081         return d->icqInfoTask->generalInfoFor( contact );
1082 }
1083
1084 ICQWorkUserInfo Client::getWorkInfo( const QString& contact )
1085 {
1086         return d->icqInfoTask->workInfoFor( contact );
1087 }
1088
1089 ICQEmailInfo Client::getEmailInfo( const QString& contact )
1090 {
1091         return d->icqInfoTask->emailInfoFor( contact );
1092 }
1093
1094 ICQNotesInfo Client::getNotesInfo( const QString& contact )
1095 {
1096         return d->icqInfoTask->notesInfoFor( contact );
1097 }
1098
1099 ICQMoreUserInfo Client::getMoreInfo( const QString& contact )
1100 {
1101         return d->icqInfoTask->moreInfoFor( contact );
1102 }
1103
1104 ICQInterestInfo Client::getInterestInfo( const QString& contact )
1105 {
1106         return d->icqInfoTask->interestInfoFor( contact );
1107 }
1108
1109 ICQOrgAffInfo Client::getOrgAffInfo( const QString& contact )
1110 {
1111         return d->icqInfoTask->orgAffInfoFor( contact );
1112 }
1113
1114 ICQShortInfo Client::getShortInfo( const QString& contact )
1115 {
1116         return d->icqInfoTask->shortInfoFor( contact );
1117 }
1118
1119 QList<int> Client::chatExchangeList() const
1120 {
1121     return d->exchanges;
1122 }
1123
1124 void Client::setChatExchangeList( const QList<int>& exchanges )
1125 {
1126     d->exchanges = exchanges;
1127 }
1128
1129 void Client::requestAIMProfile( const QString& contact )
1130 {
1131         d->userInfoTask->requestInfoFor( contact, UserInfoTask::Profile );
1132 }
1133
1134 void Client::requestAIMAwayMessage( const QString& contact )
1135 {
1136         d->userInfoTask->requestInfoFor( contact, UserInfoTask::AwayMessage );
1137 }
1138
1139 void Client::requestICQAwayMessage( const QString& contact, ICQStatus contactStatus )
1140 {
1141         kDebug(OSCAR_RAW_DEBUG) << "requesting away message for " << contact;
1142         Oscar::Message msg;
1143         msg.setChannel( 2 );
1144         msg.setReceiver( contact );
1145
1146         if ( (contactStatus & ICQXStatus) == ICQXStatus )
1147         {
1148                 Xtraz::XtrazNotify xNotify;
1149                 xNotify.setSenderUni( userId() );
1150
1151                 msg.setMessageType( Oscar::MessageType::Plugin ); // plugin message
1152                 msg.setPlugin( xNotify.statusRequest() );
1153         }
1154         else if ( (contactStatus & ICQPluginStatus) == ICQPluginStatus )
1155         {
1156                 Oscar::WORD subTypeId = 0xFFFF;
1157                 QByteArray subTypeText;
1158
1159                 switch ( contactStatus & ICQStatusMask )
1160                 {
1161                 case ICQOnline:
1162                 case ICQFreeForChat:
1163                 case ICQAway:
1164                         subTypeId = 1;
1165                         subTypeText = "Away Status Message";
1166                         break;
1167                 case ICQOccupied:
1168                 case ICQDoNotDisturb:
1169                         subTypeId = 2;
1170                         subTypeText = "Busy Status Message";
1171                         break;
1172                 case ICQNotAvailable:
1173                         subTypeId = 3;
1174                         subTypeText = "N/A Status Message";
1175                         break;
1176                 default:
1177                         // may be a good way to deal with possible error and lack of online status message?
1178                         emit receivedAwayMessage( contact, "Sorry, this protocol does not support this type of status message" );
1179                         return;
1180                 }
1181
1182                 Oscar::MessagePlugin *plugin = new Oscar::MessagePlugin();
1183                 plugin->setType( Oscar::MessagePlugin::StatusMsgExt );
1184                 plugin->setSubTypeId( subTypeId );
1185                 plugin->setSubTypeText( subTypeText );
1186
1187                 Buffer buffer;
1188                 buffer.addLEDWord( 0x00000000 );
1189                 //TODO: Change this to text/x-aolrtf
1190                 buffer.addLEDBlock( "text/plain" );
1191                 plugin->setData( buffer.buffer() );
1192
1193                 msg.setMessageType( Oscar::MessageType::Plugin ); // plugin message
1194                 msg.setPlugin( plugin );
1195         }
1196         else
1197         {
1198                 msg.addProperty( Oscar::Message::StatusMessageRequest );
1199                 switch ( contactStatus & ICQStatusMask )
1200                 {
1201                 case ICQAway:
1202                         msg.setMessageType( Oscar::MessageType::AutoAway ); // away
1203                         break;
1204                 case ICQOccupied:
1205                         msg.setMessageType( Oscar::MessageType::AutoBusy ); // occupied
1206                         break;
1207                 case ICQNotAvailable:
1208                         msg.setMessageType( Oscar::MessageType::AutoNA ); // not awailable
1209                         break;
1210                 case ICQDoNotDisturb:
1211                         msg.setMessageType( Oscar::MessageType::AutoDND ); // do not disturb
1212                         break;
1213                 case ICQFreeForChat:
1214                         msg.setMessageType( Oscar::MessageType::AutoFFC ); // free for chat
1215                         break;
1216                 default:
1217                         // may be a good way to deal with possible error and lack of online status message?
1218                         emit receivedAwayMessage( contact, "Sorry, this protocol does not support this type of status message" );
1219                         return;
1220                 }
1221         }
1222         sendMessage( msg );
1223 }
1224
1225 void Client::addICQAwayMessageRequest( const QString& contact, ICQStatus contactStatus )
1226 {
1227         kDebug(OSCAR_RAW_DEBUG) << "adding away message request for "
1228                                  << contact << " to queue" << endl;
1229
1230         //remove old request if still exists
1231         removeICQAwayMessageRequest( contact );
1232
1233         ClientPrivate::AwayMsgRequest amr = { contact, contactStatus };
1234         d->awayMsgRequestQueue.prepend( amr );
1235
1236         if ( !d->awayMsgRequestTimer->isActive() )
1237                 d->awayMsgRequestTimer->start( 1000 );
1238 }
1239
1240 void Client::removeICQAwayMessageRequest( const QString& contact )
1241 {
1242         kDebug(OSCAR_RAW_DEBUG) << "removing away message request for "
1243                                  << contact << " from queue" << endl;
1244
1245         QList<ClientPrivate::AwayMsgRequest>::iterator it = d->awayMsgRequestQueue.begin();
1246         while ( it != d->awayMsgRequestQueue.end() )
1247         {
1248                 if ( (*it).contact == contact )
1249                         it = d->awayMsgRequestQueue.erase( it );
1250                 else
1251                         it++;
1252         }
1253 }
1254
1255 void Client::nextICQAwayMessageRequest()
1256 {
1257         kDebug(OSCAR_RAW_DEBUG) << "request queue count " << d->awayMsgRequestQueue.count();
1258
1259         if ( d->awayMsgRequestQueue.empty() )
1260         {
1261                 d->awayMsgRequestTimer->stop();
1262                 return;
1263         }
1264         else
1265         {
1266                 Connection* c = d->connections.connectionForFamily( 0x0004 );
1267                 if ( !c )
1268                         return;
1269
1270                 SNAC s = { 0x0004, 0x0006, 0x0000, 0x00000000 };
1271                 //get time needed to restore level to initial
1272                 //for some reason when we are long under initial level
1273                 //icq server will start to block our messages
1274                 int time = c->rateManager()->timeToInitialLevel( s );
1275                 if ( time > 0 )
1276                 {
1277                         d->awayMsgRequestTimer->start( time );
1278                         return;
1279                 }
1280                 else
1281                 {
1282                         d->awayMsgRequestTimer->start( 5000 );
1283                 }
1284         }
1285
1286         ClientPrivate::AwayMsgRequest amr;
1287
1288         amr = d->awayMsgRequestQueue.back();
1289         d->awayMsgRequestQueue.pop_back();
1290         requestICQAwayMessage( amr.contact, amr.contactStatus );
1291 }
1292
1293 void Client::requestStatusInfo( const QString& contact )
1294 {
1295         d->userInfoTask->requestInfoFor( contact, UserInfoTask::General );
1296 }
1297
1298 void Client::whitePagesSearch( const ICQWPSearchInfo& info )
1299 {
1300         Connection* c = d->connections.connectionForFamily( 0x0015 );
1301         if ( !c )
1302                 return;
1303         UserSearchTask* ust = new UserSearchTask( c->rootTask() );
1304         connect( ust, SIGNAL( foundUser( const ICQSearchResult& ) ),
1305                  this, SIGNAL( gotSearchResults( const ICQSearchResult& ) ) );
1306         connect( ust, SIGNAL( searchFinished( int ) ), this, SIGNAL( endOfSearch( int ) ) );
1307         ust->go( Task::AutoDelete ); //onGo does nothing in this task. This is just here so autodelete works
1308         ust->searchWhitePages( info );
1309 }
1310
1311 void Client::uinSearch( const QString& uin )
1312 {
1313         Connection* c = d->connections.connectionForFamily( 0x0015 );
1314         if ( !c )
1315                 return;
1316         UserSearchTask* ust = new UserSearchTask( c->rootTask() );
1317         connect( ust, SIGNAL( foundUser( const ICQSearchResult& ) ),
1318                  this, SIGNAL( gotSearchResults( const ICQSearchResult& ) ) );
1319         connect( ust, SIGNAL( searchFinished( int ) ), this, SIGNAL( endOfSearch( int ) ) );
1320         ust->go( Task::AutoDelete ); //onGo does nothing in this task. This is just here so autodelete works
1321         ust->searchUserByUIN( uin );
1322 }
1323
1324 void Client::updateProfile( const QString& profile )
1325 {
1326         Connection* c = d->connections.connectionForFamily( 0x0002 );
1327         if ( !c )
1328                 return;
1329         ProfileTask* pt = new ProfileTask( c->rootTask() );
1330         pt->setProfileText( profile );
1331         pt->go( Task::AutoDelete );
1332 }
1333
1334 bool Client::updateProfile( const QList<ICQInfoBase*>& infoList )
1335 {
1336         Connection* c = d->connections.connectionForFamily( 0x0015 );
1337         if ( !c )
1338                 return false;
1339
1340         ICQUserInfoUpdateTask* ui = new ICQUserInfoUpdateTask( c->rootTask() );
1341         ui->setInfo( infoList );
1342         ui->go( Task::AutoDelete );
1343         return true;
1344 }
1345
1346 void Client::sendTyping( const QString & contact, bool typing )
1347 {
1348         Connection* c = d->connections.connectionForFamily( 0x0004 );
1349         if ( !c )
1350                 return;
1351         d->typingNotifyTask->setParams( contact, ( typing ? TypingNotifyTask::Begin : TypingNotifyTask::Finished ) );
1352         d->typingNotifyTask->go();      // don't delete the task after sending
1353 }
1354
1355 void Client::connectToIconServer()
1356 {
1357         Connection* c = d->connections.connectionForFamily( 0x0010 );
1358         if ( c )
1359                 return;
1360
1361         requestServerRedirect( 0x0010 );
1362         return;
1363 }
1364
1365 void Client::setIgnore( const QString& user, bool ignore )
1366 {
1367         OContact item = ssiManager()->findItem( user,  ROSTER_IGNORE );
1368         if ( item && !ignore )
1369         {
1370                 kDebug(OSCAR_RAW_DEBUG) << "Removing " << user << " from ignore list";
1371                 this->modifyContactItem( item, OContact() );
1372         }
1373         else if ( !item && ignore )
1374         {
1375                 kDebug(OSCAR_RAW_DEBUG) << "Adding " << user << " to ignore list";
1376                 OContact s( user, 0, ssiManager()->nextContactId(), ROSTER_IGNORE, QList<TLV>() );
1377                 this->modifyContactItem( OContact(), s );
1378         }
1379 }
1380
1381 void Client::setVisibleTo( const QString& user, bool visible )
1382 {
1383         OContact item = ssiManager()->findItem( user,  ROSTER_VISIBLE );
1384         if ( item && !visible )
1385         {
1386                 kDebug(OSCAR_RAW_DEBUG) << "Removing " << user << " from visible list";
1387                 this->modifyContactItem( item, OContact() );
1388         }
1389         else if ( !item && visible )
1390         {
1391                 kDebug(OSCAR_RAW_DEBUG) << "Adding " << user << " to visible list";
1392                 OContact s( user, 0, ssiManager()->nextContactId(), ROSTER_VISIBLE, QList<TLV>() );
1393                 this->modifyContactItem( OContact(), s );
1394         }
1395 }
1396
1397 void Client::setInvisibleTo( const QString& user, bool invisible )
1398 {
1399         OContact item = ssiManager()->findItem( user,  ROSTER_INVISIBLE );
1400         if ( item && !invisible )
1401         {
1402                 kDebug(OSCAR_RAW_DEBUG) << "Removing " << user << " from invisible list";
1403                 this->modifyContactItem( item, OContact() );
1404         }
1405         else if ( !item && invisible )
1406         {
1407                 kDebug(OSCAR_RAW_DEBUG) << "Adding " << user << " to invisible list";
1408                 OContact s( user, 0, ssiManager()->nextContactId(), ROSTER_INVISIBLE, QList<TLV>() );
1409                 this->modifyContactItem( OContact(), s );
1410         }
1411 }
1412
1413 void Client::requestBuddyIcon( const QString& user, const QByteArray& hash, Oscar::BYTE hashType )
1414 {
1415         Connection* c = d->connections.connectionForFamily( 0x0010 );
1416         if ( !c )
1417                 return;
1418
1419         BuddyIconTask* bit = new BuddyIconTask( c->rootTask() );
1420         connect( bit, SIGNAL( haveIcon( const QString&, QByteArray ) ),
1421                  this, SIGNAL( haveIconForContact( const QString&, QByteArray ) ) );
1422         bit->requestIconFor( user );
1423         bit->setHashType( hashType );
1424         bit->setHash( hash );
1425         bit->go( Task::AutoDelete );
1426 }
1427
1428 void Client::requestServerRedirect( Oscar::WORD family, Oscar::WORD exchange,
1429                                     QByteArray cookie, Oscar::WORD instance,
1430                                     const QString& room )
1431 {
1432         //making the assumption that family 2 will always be the BOS connection
1433         //use it instead since we can't query for family 1
1434         Connection* c = d->connections.connectionForFamily( family );
1435         if ( c && family != 0x000E )
1436                 return; //we already have the connection
1437
1438         c = d->connections.connectionForFamily( 0x0002 );
1439         if ( !c )
1440                 return;
1441
1442     if ( d->redirectionServices.indexOf( family ) == -1 )
1443         d->redirectionServices.append( family ); //don't add families twice
1444
1445     if ( d->currentRedirect != 0 )
1446         return; //we're already doing one redirection
1447
1448         d->currentRedirect = family;
1449
1450     //FIXME. this won't work if we have to defer the connection because we're
1451     //already connecting to something
1452         ServerRedirectTask* srt = new ServerRedirectTask( c->rootTask() );
1453     if ( family == 0x000E )
1454     {
1455         srt->setChatParams( exchange, cookie, instance );
1456         srt->setChatRoom( room );
1457     }
1458
1459         connect( srt, SIGNAL( haveServer( const QString&, const QByteArray&, Oscar::WORD ) ),
1460                  this, SLOT( haveServerForRedirect( const QString&, const QByteArray&, Oscar::WORD ) ) );
1461         srt->setService( family );
1462         srt->go( Task::AutoDelete );
1463 }
1464
1465 void Client::haveServerForRedirect( const QString& host, const QByteArray& cookie, Oscar::WORD )
1466 {
1467     //nasty sender() usage to get the task with chat room info
1468         QObject* o = const_cast<QObject*>( sender() );
1469     ServerRedirectTask* srt = dynamic_cast<ServerRedirectTask*>( o );
1470
1471         //create a new connection and set it up
1472         int colonPos = host.indexOf(':');
1473         QString realHost, realPort;
1474         if ( colonPos != -1 )
1475         {
1476                 realHost = host.left( colonPos );
1477                 realPort = host.right(4); //we only need 4 bytes
1478         }
1479         else
1480         {
1481                 realHost = host;
1482                 realPort = QString::fromLatin1("5190");
1483         }
1484
1485         Connection* c = createConnection();
1486         //create the new login task
1487         m_loginTaskTwo = new StageTwoLoginTask( c->rootTask() );
1488         m_loginTaskTwo->setCookie( cookie );
1489         QObject::connect( m_loginTaskTwo, SIGNAL( finished() ), this, SLOT( serverRedirectFinished() ) );
1490
1491         //connect
1492         connectToServer( c, realHost, realPort.toInt(), false );
1493         QObject::connect( c, SIGNAL( connected() ), this, SLOT( streamConnected() ) );
1494
1495     if ( srt )
1496         d->connections.addChatInfoForConnection( c, srt->chatExchange(), srt->chatRoomName() );
1497 }
1498
1499 void Client::serverRedirectFinished()
1500 {
1501         if ( m_loginTaskTwo &&  m_loginTaskTwo->statusCode() == 0 )
1502         { //stage two was successful
1503                 Connection* c = d->connections.connectionForFamily( d->currentRedirect );
1504                 if ( !c )
1505                         return;
1506                 ClientReadyTask* crt = new ClientReadyTask( c->rootTask() );
1507                 crt->setFamilies( c->supportedFamilies() );
1508                 crt->go( Task::AutoDelete );
1509         }
1510
1511         kDebug(OSCAR_RAW_DEBUG) << "redirection finished for service "
1512                                  << d->currentRedirect << endl;
1513
1514         if ( d->currentRedirect == 0x0010 )
1515                 emit iconServerConnected();
1516
1517         if ( d->currentRedirect == 0x000D )
1518         {
1519                 connect( this, SIGNAL( chatNavigationConnected() ),
1520                                  this, SLOT( requestChatNavLimits() ) );
1521                 emit chatNavigationConnected();
1522         }
1523
1524     if ( d->currentRedirect == 0x000E )
1525     {
1526         //HACK! such abuse! think of a better way
1527         if ( !m_loginTaskTwo )
1528         {
1529             kWarning(OSCAR_RAW_DEBUG) << "no login task to get connection from!";
1530             emit redirectionFinished( d->currentRedirect );
1531             return;
1532         }
1533
1534         Connection* c = m_loginTaskTwo->client();
1535         QString roomName = d->connections.chatRoomForConnection( c );
1536         Oscar::WORD exchange = d->connections.exchangeForConnection( c );
1537         if ( c )
1538         {
1539             kDebug(OSCAR_RAW_DEBUG) << "setting up chat connection";
1540             ChatServiceTask* cst = new ChatServiceTask( c->rootTask(), exchange, roomName );
1541             connect( cst, SIGNAL( userJoinedChat( Oscar::Oscar::WORD, const QString&, const QString& ) ),
1542                      this, SIGNAL( userJoinedChat( Oscar::Oscar::WORD, const QString&, const QString& ) ) );
1543             connect( cst, SIGNAL( userLeftChat( Oscar::Oscar::WORD, const QString&, const QString& ) ),
1544                      this, SIGNAL( userLeftChat( Oscar::Oscar::WORD, const QString&, const QString& ) ) );
1545             connect( cst, SIGNAL( newChatMessage( const Oscar::Message& ) ),
1546                      this, SIGNAL( messageReceived( const Oscar::Message& ) ) );
1547         }
1548         emit chatRoomConnected( exchange, roomName );
1549     }
1550
1551         emit redirectionFinished( d->currentRedirect );
1552
1553 }
1554
1555 void Client::checkRedirectionQueue( Oscar::WORD family )
1556 {
1557         kDebug(OSCAR_RAW_DEBUG) << "checking redirection queue";
1558         d->redirectionServices.removeAll( family );
1559     d->currentRedirect = 0;
1560         if ( !d->redirectionServices.isEmpty() )
1561         {
1562                 kDebug(OSCAR_RAW_DEBUG) << "scheduling new redirection";
1563                 requestServerRedirect( d->redirectionServices.front() );
1564         }
1565 }
1566
1567
1568 void Client::requestChatNavLimits()
1569 {
1570         Connection* c = d->connections.connectionForFamily( 0x000D );
1571         if ( !c )
1572                 return;
1573
1574         kDebug(OSCAR_RAW_DEBUG) << "requesting chat nav service limits";
1575         ChatNavServiceTask* cnst = new ChatNavServiceTask( c->rootTask() );
1576     cnst->setRequestType( ChatNavServiceTask::Limits );
1577     QObject::connect( cnst, SIGNAL( haveChatExchanges( const QList<int>& ) ),
1578                       this, SLOT( setChatExchangeList( const QList<int>& ) ) );
1579         cnst->go( Task::AutoDelete ); //autodelete
1580
1581 }
1582
1583 void Client::determineDisconnection( int code, const QString& string )
1584 {
1585     if ( !sender() )
1586         return;
1587
1588     //yay for the sender() hack!
1589     QObject* obj = const_cast<QObject*>( sender() );
1590     Connection* c = dynamic_cast<Connection*>( obj );
1591     if ( !c )
1592         return;
1593
1594         if ( c->isSupported( 0x0002 ) ||
1595              d->stage == ClientPrivate::StageOne ) //emit on login
1596         {
1597                 emit socketError( code, string );
1598         }
1599
1600     //connection is deleted. deleteLater() is used
1601     d->connections.remove( c );
1602     c = 0;
1603 }
1604
1605 void Client::sendBuddyIcon( const QByteArray& iconData )
1606 {
1607         Connection* c = d->connections.connectionForFamily( 0x0010 );
1608         if ( !c )
1609                 return;
1610
1611         kDebug(OSCAR_RAW_DEBUG) << "icon length is " << iconData.size();
1612         BuddyIconTask* bit = new BuddyIconTask( c->rootTask() );
1613         bit->uploadIcon( iconData.size(), iconData );
1614         bit->go( Task::AutoDelete );
1615 }
1616
1617 void Client::joinChatRoom( const QString& roomName, int exchange )
1618 {
1619     Connection* c = d->connections.connectionForFamily( 0x000D );
1620     if ( !c )
1621         return;
1622
1623     kDebug(OSCAR_RAW_DEBUG) << "joining the chat room '" << roomName
1624                              << "' on exchange " << exchange << endl;
1625     ChatNavServiceTask* cnst = new ChatNavServiceTask( c->rootTask() );
1626     connect( cnst, SIGNAL( connectChat( Oscar::WORD, QByteArray, Oscar::WORD, const QString& ) ),
1627              this, SLOT( setupChatConnection( Oscar::WORD, QByteArray, Oscar::WORD, const QString& ) ) );
1628     cnst->createRoom( exchange, roomName );
1629
1630 }
1631
1632 void Client::setupChatConnection( Oscar::WORD exchange, QByteArray cookie, Oscar::WORD instance, const QString& room )
1633 {
1634     kDebug(OSCAR_RAW_DEBUG) << "cookie is:" << cookie;
1635     QByteArray realCookie( cookie );
1636     kDebug(OSCAR_RAW_DEBUG) << "connection to chat room";
1637     requestServerRedirect( 0x000E, exchange, realCookie, instance, room );
1638 }
1639
1640 void Client::disconnectChatRoom( Oscar::WORD exchange, const QString& room )
1641 {
1642     Connection* c = d->connections.connectionForChatRoom( exchange, room );
1643     if ( !c )
1644         return;
1645
1646     d->connections.remove( c );
1647     c = 0;
1648 }
1649
1650 Connection* Client::createConnection()
1651 {
1652         ClientStream* cs = new ClientStream( new QTcpSocket(), 0 );
1653         cs->setNoopTime( 60000 );
1654         Connection* c = new Connection( cs, "BOS" );
1655         cs->setConnection( c );
1656         c->setClient( this );
1657         return c;
1658 }
1659
1660 void Client::deleteStaticTasks()
1661 {
1662         delete d->errorTask;
1663         delete d->onlineNotifier;
1664         delete d->ownStatusTask;
1665         delete d->messageReceiverTask;
1666         delete d->ssiAuthTask;
1667         delete d->icqInfoTask;
1668         delete d->icqTlvInfoTask;
1669         delete d->userInfoTask;
1670         delete d->typingNotifyTask;
1671         delete d->ssiModifyTask;
1672
1673         d->errorTask = 0;
1674         d->onlineNotifier = 0;
1675         d->ownStatusTask = 0;
1676         d->messageReceiverTask = 0;
1677         d->ssiAuthTask = 0;
1678         d->icqInfoTask = 0;
1679         d->icqTlvInfoTask = 0;
1680         d->userInfoTask = 0;
1681         d->typingNotifyTask = 0;
1682         d->ssiModifyTask = 0;
1683 }
1684
1685 bool Client::hasIconConnection( ) const
1686 {
1687         Connection* c = d->connections.connectionForFamily( 0x0010 );
1688         return c;
1689 }
1690
1691 void Client::sendFiles( const QString& contact, const QStringList& files, Kopete::Transfer *t )
1692 {
1693         Connection* c = d->connections.connectionForFamily( 0x0004 );
1694         if ( !c )
1695                 return;
1696
1697         FileTransferTask *ft = new FileTransferTask( c->rootTask(), contact, ourInfo().userId(), files, t );
1698         connect( ft, SIGNAL( sendMessage( const Oscar::Message& ) ),
1699                  this, SLOT( fileMessage( const Oscar::Message& ) ) );
1700         ft->go( Task::AutoDelete );
1701 }
1702
1703 void Client::gotFileMessage( int type, const QString from, const QByteArray cookie, Buffer buf)
1704 {
1705         Connection* c = d->connections.connectionForFamily( 0x0004 );
1706         if ( !c )
1707                 return;
1708         //pass the message to the matching task if we can
1709         const QList<FileTransferTask*> p = c->rootTask()->findChildren<FileTransferTask*>();
1710         foreach( FileTransferTask *t, p)
1711         {
1712                 if ( t->take( type, cookie, buf ) )
1713                 {
1714                         return;
1715                 }
1716         }
1717         //maybe it's a new request!
1718         if ( type == 0 )
1719         {
1720                 kDebug(14151) << "new request :)";
1721                 FileTransferTask *ft = new FileTransferTask( c->rootTask(), from, ourInfo().userId(), cookie, buf );
1722                 connect( ft, SIGNAL( getTransferManager( Kopete::TransferManager ** ) ),
1723                                 SIGNAL( getTransferManager( Kopete::TransferManager ** ) ) );
1724                 connect( ft, SIGNAL( askIncoming( QString, QString, Oscar::DWORD, QString, QString ) ),
1725                                 SIGNAL( askIncoming( QString, QString, Oscar::DWORD, QString, QString ) ) );
1726                 connect( ft, SIGNAL( sendMessage( const Oscar::Message& ) ),
1727                                 this, SLOT( fileMessage( const Oscar::Message& ) ) );
1728                 ft->go( Task::AutoDelete );
1729                 return;
1730         }
1731
1732         kDebug(14151) << "nobody wants it :(";
1733 }
1734
1735 #include "client.moc"
1736 //kate: tab-width 4; indent-mode csands; space-indent off; replace-tabs off;