kopete/protocols/jabber/jabberclient.cpp

   1
   2 /***************************************************************************
   3                 jabberclient.cpp - Generic Jabber Client Class
   4                              -------------------
   5     begin                : Sat May 25 2005
   6     copyright            : (C) 2005 by Till Gerken <till@tantalo.net>
   7                            (C) 2006 by Michaël Larouche <larouche@kde.org>
   8     Copyright 2006 by Tommi Rantala <tommi.rantala@cs.helsinki.fi>
   9
  10                            Kopete (C) 2001-2006 Kopete developers
  11                            <kopete-devel@kde.org>.
  12  ***************************************************************************/
  13
  14 /***************************************************************************
  15  *                                                                         *
  16  *   This program is free software; you can redistribute it and/or modify  *
  17  *   it under the terms of the GNU General Public License as published by  *
  18  *   the Free Software Foundation; either version 2 of the License, or     *
  19  *   (at your option) any later version.                                   *
  20  *                                                                         *
  21  ***************************************************************************/
  22
  23 #include "jabberclient.h"
  24
  25 #include <kdebug.h>
  26
  27 #include <QTimer>
  28 #include <QRegExp>
  29 #include <QtCrypto>
  30
  31 #include <bsocket.h>
  32 #include <filetransfer.h>
  33 #include <jinglesessionmanager.h>
  34 #include <xmpp_tasks.h>
  35
  36 #include "privacymanager.h"
  37
  38 #define JABBER_PENALTY_TIME     2
  39
  40 class JabberClient::Private
  41 {
  42 public:
  43         Private()
  44         : jabberClient(0L), jabberClientStream(0L), jabberClientConnector(0L), jabberTLS(0L),
  45                        jabberTLSHandler(0L), privacyManager(0L)
  46         {}
  47         ~Private()
  48         {
  49                 if ( jabberClient )
  50                 {
  51                         jabberClient->close ();
  52                 }
  53
  54                 delete jabberClient;
  55                 delete jabberClientStream;
  56                 delete jabberClientConnector;
  57                 delete jabberTLSHandler;
  58                 delete jabberTLS;
  59                 // privacyManager will be deleted with jabberClient, its parent's parent
  60         }
  61
  62         // connection details
  63         XMPP::Jid jid;
  64         QString password;
  65
  66         // XMPP backend
  67         XMPP::Client *jabberClient;
  68         XMPP::ClientStream *jabberClientStream;
  69         XMPP::AdvancedConnector *jabberClientConnector;
  70         QCA::TLS *jabberTLS;
  71         XMPP::QCATLSHandler *jabberTLSHandler;
  72         QCA::Initializer qcaInit;
  73         PrivacyManager *privacyManager;
  74
  75         // ignore TLS warnings
  76         bool ignoreTLSWarnings;
  77
  78         // current S5B server instance
  79         static XMPP::S5BServer *s5bServer;
  80         // address list being handled by the S5B server instance
  81         static QStringList s5bAddressList;
  82         // port of S5B server
  83         static int s5bServerPort;
  84
  85         // local IP address
  86         QString localAddress;
  87
  88         // whether TLS (or direct SSL in case of the old protocol) should be used
  89         bool forceTLS;
  90
  91         // whether direct SSL connections should be used
  92         bool useSSL;
  93
  94         // use XMPP 1.0 or the older protocol version
  95         bool useXMPP09;
  96
  97         // whether SSL support should be probed in case the old protocol is used
  98         bool probeSSL;
  99
 100         // override the default server name and port (only pre-XMPP 1.0)
 101         bool overrideHost;
 102         QString server;
 103         int port;
 104
 105         // allow transmission of plaintext passwords
 106         bool allowPlainTextPassword;
 107
 108         // enable file transfers
 109         bool fileTransfersEnabled;
 110
 111         // current penalty time
 112         int currentPenaltyTime;
 113
 114         // client information
 115         QString clientName, clientVersion, osName;
 116
 117         // timezone information
 118         QString timeZoneName;
 119         int timeZoneOffset;
 120
 121         // Caps(JEP-0115: Entity Capabilities) information
 122         QString capsNode, capsVersion;
 123         DiscoItem::Identity discoIdentity;
 124 };
 125
 126 XMPP::S5BServer *JabberClient::Private::s5bServer = 0L;
 127 QStringList JabberClient::Private::s5bAddressList;
 128 int JabberClient::Private::s5bServerPort = 8010;
 129
 130 JabberClient::JabberClient ()
 131  : d(new Private())
 132 {
 133         cleanUp ();
 134
 135         // initiate penalty timer
 136         QTimer::singleShot ( JABBER_PENALTY_TIME * 1000, this, SLOT ( slotUpdatePenaltyTime () ) );
 137
 138 }
 139
 140 JabberClient::~JabberClient ()
 141 {
 142         delete d;
 143 }
 144
 145 void JabberClient::cleanUp ()
 146 {
 147         if ( d->jabberClient )
 148         {
 149                 d->jabberClient->close ();
 150         }
 151
 152         delete d->jabberClient;
 153         delete d->jabberClientStream;
 154         delete d->jabberClientConnector;
 155         delete d->jabberTLSHandler;
 156         delete d->jabberTLS;
 157         // privacyManager will be deleted with jabberClient, its parent's parent
 158
 159         d->jabberClient = 0L;
 160         d->jabberClientStream = 0L;
 161         d->jabberClientConnector = 0L;
 162         d->jabberTLSHandler = 0L;
 163         d->jabberTLS = 0L;
 164         d->privacyManager = 0L;
 165
 166         d->currentPenaltyTime = 0;
 167
 168         d->jid = XMPP::Jid ();
 169         d->password.clear();
 170
 171         setForceTLS ( false );
 172         setUseSSL ( false );
 173         setUseXMPP09 ( false );
 174         setProbeSSL ( false );
 175
 176         setOverrideHost ( false );
 177
 178         setAllowPlainTextPassword ( true );
 179
 180         setFileTransfersEnabled ( false );
 181         setS5BServerPort ( 8010 );
 182
 183         setClientName ( QString() );
 184         setClientVersion ( QString() );
 185         setOSName ( QString() );
 186
 187         setTimeZone ( "UTC", 0 );
 188
 189         setIgnoreTLSWarnings ( false );
 190
 191 }
 192
 193 void JabberClient::slotUpdatePenaltyTime ()
 194 {
 195
 196         if ( d->currentPenaltyTime >= JABBER_PENALTY_TIME )
 197                 d->currentPenaltyTime -= JABBER_PENALTY_TIME;
 198         else
 199                 d->currentPenaltyTime = 0;
 200
 201         QTimer::singleShot ( JABBER_PENALTY_TIME * 1000, this, SLOT ( slotUpdatePenaltyTime () ) );
 202
 203 }
 204
 205 void JabberClient::setIgnoreTLSWarnings ( bool flag )
 206 {
 207
 208         d->ignoreTLSWarnings = flag;
 209
 210 }
 211
 212 bool JabberClient::ignoreTLSWarnings ()
 213 {
 214
 215         return d->ignoreTLSWarnings;
 216
 217 }
 218
 219 bool JabberClient::setS5BServerPort ( int port )
 220 {
 221
 222         d->s5bServerPort = port;
 223
 224         if ( fileTransfersEnabled () )
 225         {
 226                 return s5bServer()->start ( port );
 227         }
 228
 229         return true;
 230
 231 }
 232
 233 int JabberClient::s5bServerPort () const
 234 {
 235
 236         return d->s5bServerPort;
 237
 238 }
 239
 240 XMPP::S5BServer *JabberClient::s5bServer ()
 241 {
 242
 243         if ( !d->s5bServer )
 244         {
 245                 d->s5bServer = new XMPP::S5BServer ();
 246                 QObject::connect ( d->s5bServer, SIGNAL ( destroyed () ), this, SLOT ( slotS5BServerGone () ) );
 247
 248                 /*
 249                  * Try to start the server at the default port here.
 250                  * We have no way of notifying the caller of an error.
 251                  * However, since the caller will usually also
 252                  * use setS5BServerPort() to ensure the correct
 253                  * port, we can return an error code there.
 254                  */
 255                 if ( fileTransfersEnabled () )
 256                 {
 257                         s5bServer()->start ( d->s5bServerPort );
 258                 }
 259         }
 260
 261         return d->s5bServer;
 262
 263 }
 264
 265 void JabberClient::slotS5BServerGone ()
 266 {
 267
 268         d->s5bServer = 0L;
 269
 270         if ( d->jabberClient )
 271                 d->jabberClient->s5bManager()->setServer( 0L );
 272
 273 }
 274
 275 void JabberClient::addS5BServerAddress ( const QString &address )
 276 {
 277         QStringList newList;
 278
 279         d->s5bAddressList.append ( address );
 280
 281         // now filter the list without dupes
 282         foreach( QStringList::const_reference str, d->s5bAddressList )
 283         {
 284                 if ( !newList.contains ( str ) )
 285                         newList.append ( str );
 286         }
 287
 288         s5bServer()->setHostList ( newList );
 289
 290 }
 291
 292 void JabberClient::removeS5BServerAddress ( const QString &address )
 293 {
 294         QStringList newList;
 295
 296         int idx = d->s5bAddressList.indexOf( address );
 297
 298         if ( idx != -1 )
 299                 d->s5bAddressList.removeAt(idx);
 300
 301         if ( d->s5bAddressList.isEmpty () )
 302         {
 303                 delete d->s5bServer;
 304                 d->s5bServer = 0L;
 305         }
 306         else
 307         {
 308                 // now filter the list without dupes
 309                 foreach( QStringList::const_reference str, d->s5bAddressList )
 310                 {
 311                         if ( !newList.contains ( str ) )
 312                                 newList.append ( str );
 313                 }
 314
 315                 s5bServer()->setHostList ( newList );
 316         }
 317
 318 }
 319
 320 void JabberClient::setForceTLS ( bool flag )
 321 {
 322
 323         d->forceTLS = flag;
 324
 325 }
 326
 327 bool JabberClient::forceTLS () const
 328 {
 329
 330         return d->forceTLS;
 331
 332 }
 333
 334 void JabberClient::setUseSSL ( bool flag )
 335 {
 336
 337         d->useSSL = flag;
 338
 339 }
 340
 341 bool JabberClient::useSSL () const
 342 {
 343
 344         return d->useSSL;
 345
 346 }
 347
 348 void JabberClient::setUseXMPP09 ( bool flag )
 349 {
 350
 351         d->useXMPP09 = flag;
 352
 353 }
 354
 355 bool JabberClient::useXMPP09 () const
 356 {
 357
 358         return d->useXMPP09;
 359
 360 }
 361
 362 void JabberClient::setProbeSSL ( bool flag )
 363 {
 364
 365         d->probeSSL = flag;
 366
 367 }
 368
 369 bool JabberClient::probeSSL () const
 370 {
 371
 372         return d->probeSSL;
 373
 374 }
 375
 376 void JabberClient::setOverrideHost ( bool flag, const QString &server, int port )
 377 {
 378
 379         d->overrideHost = flag;
 380         d->server = server;
 381         d->port = port;
 382
 383 }
 384
 385 bool JabberClient::overrideHost () const
 386 {
 387
 388         return d->overrideHost;
 389
 390 }
 391
 392 void JabberClient::setAllowPlainTextPassword ( bool flag )
 393 {
 394
 395         d->allowPlainTextPassword = flag;
 396
 397 }
 398
 399 bool JabberClient::allowPlainTextPassword () const
 400 {
 401
 402         return d->allowPlainTextPassword;
 403
 404 }
 405
 406 void JabberClient::setFileTransfersEnabled ( bool flag, const QString &localAddress )
 407 {
 408
 409         d->fileTransfersEnabled = flag;
 410         d->localAddress = localAddress;
 411
 412 }
 413
 414 QString JabberClient::localAddress () const
 415 {
 416
 417         return d->localAddress;
 418
 419 }
 420
 421 bool JabberClient::fileTransfersEnabled () const
 422 {
 423
 424         return d->fileTransfersEnabled;
 425
 426 }
 427
 428 void JabberClient::setClientName ( const QString &clientName )
 429 {
 430
 431         d->clientName = clientName;
 432
 433 }
 434
 435 QString JabberClient::clientName () const
 436 {
 437
 438         return d->clientName;
 439
 440 }
 441
 442 void JabberClient::setClientVersion ( const QString &clientVersion )
 443 {
 444
 445         d->clientVersion = clientVersion;
 446
 447 }
 448
 449 QString JabberClient::clientVersion () const
 450 {
 451
 452         return d->clientVersion;
 453
 454 }
 455
 456 void JabberClient::setOSName ( const QString &osName )
 457 {
 458
 459         d->osName = osName;
 460
 461 }
 462
 463 QString JabberClient::osName () const
 464 {
 465
 466         return d->osName;
 467
 468 }
 469
 470 void JabberClient::setCapsNode( const QString &capsNode )
 471 {
 472         d->capsNode = capsNode;
 473 }
 474
 475 QString JabberClient::capsNode() const
 476 {
 477         return d->capsNode;
 478 }
 479
 480 void JabberClient::setCapsVersion( const QString &capsVersion )
 481 {
 482         d->capsVersion = capsVersion;
 483 }
 484
 485 QString JabberClient::capsVersion() const
 486 {
 487         return d->capsVersion;
 488 }
 489
 490 QString JabberClient::capsExt() const
 491 {
 492         if(d->jabberClient)
 493         {
 494                 return d->jabberClient->capsExt();
 495         }
 496
 497         return QString();
 498 }
 499 void JabberClient::setDiscoIdentity( DiscoItem::Identity identity )
 500 {
 501         d->discoIdentity = identity;
 502 }
 503
 504 DiscoItem::Identity JabberClient::discoIdentity() const
 505 {
 506         return d->discoIdentity;
 507 }
 508
 509 void JabberClient::setTimeZone ( const QString &timeZoneName, int timeZoneOffset )
 510 {
 511
 512         d->timeZoneName = timeZoneName;
 513         d->timeZoneOffset = timeZoneOffset;
 514
 515 }
 516
 517 QString JabberClient::timeZoneName () const
 518 {
 519
 520         return d->timeZoneName;
 521
 522 }
 523
 524 int JabberClient::timeZoneOffset () const
 525 {
 526
 527         return d->timeZoneOffset;
 528
 529 }
 530
 531 int JabberClient::getPenaltyTime ()
 532 {
 533
 534         int currentTime = d->currentPenaltyTime;
 535
 536         d->currentPenaltyTime += JABBER_PENALTY_TIME;
 537
 538         return currentTime;
 539
 540 }
 541
 542 XMPP::Client *JabberClient::client () const
 543 {
 544
 545         return d->jabberClient;
 546
 547 }
 548
 549 XMPP::ClientStream *JabberClient::clientStream () const
 550 {
 551
 552         return d->jabberClientStream;
 553
 554 }
 555
 556 XMPP::AdvancedConnector *JabberClient::clientConnector () const
 557 {
 558
 559         return d->jabberClientConnector;
 560
 561 }
 562
 563 XMPP::Task *JabberClient::rootTask () const
 564 {
 565
 566         if ( client () )
 567         {
 568                 return client()->rootTask ();
 569         }
 570         else
 571         {
 572                 return 0l;
 573         }
 574
 575 }
 576
 577 XMPP::FileTransferManager *JabberClient::fileTransferManager () const
 578 {
 579
 580         if ( client () )
 581         {
 582                 return client()->fileTransferManager ();
 583         }
 584         else
 585         {
 586                 return 0L;
 587         }
 588
 589 }
 590
 591 PrivacyManager *JabberClient::privacyManager () const
 592 {
 593         return d->privacyManager;
 594 }
 595
 596 XMPP::Jid JabberClient::jid () const
 597 {
 598
 599         return d->jid;
 600
 601 }
 602
 603 JabberClient::ErrorCode JabberClient::connect ( const XMPP::Jid &jid, const QString &password, bool auth )
 604 {
 605         /*
 606          * Close any existing connection.
 607          */
 608         if ( d->jabberClient )
 609         {
 610                 d->jabberClient->close ();
 611         }
 612         d->jid = jid;
 613         d->password = password;
 614
 615         /*
 616          * Return an error if we should force TLS but it's not available.
 617          */
 618         if ( ( forceTLS () || useSSL () || probeSSL () ) && !QCA::isSupported ("tls" ) )
 619         {
 620                 qDebug ("no TLS");
 621                 return NoTLS;
 622         }
 623
 624         /*
 625          * Instantiate connector, responsible for dealing with the socket.
 626          * This class uses KDE's socket code, which in turn makes use of
 627          * the global proxy settings.
 628          */
 629         d->jabberClientConnector = new XMPP::AdvancedConnector;
 630
 631         d->jabberClientConnector->setOptSSL ( useSSL () );
 632
 633         if ( useXMPP09 () )
 634         {
 635                 if ( overrideHost () )
 636                 {
 637                         d->jabberClientConnector->setOptHostPort ( d->server, d->port );
 638                 }
 639
 640                 d->jabberClientConnector->setOptProbe ( probeSSL () );
 641
 642         }
 643
 644         /*
 645          * Setup authentication layer
 646          */
 647         if ( QCA::isSupported ("tls") )
 648         {
 649                 d->jabberTLS = new QCA::TLS;
 650                 d->jabberTLS->setTrustedCertificates(QCA::systemStore());
 651                 d->jabberTLSHandler = new QCATLSHandler(d->jabberTLS);
 652                 d->jabberTLSHandler->setXMPPCertCheck(true);
 653
 654                 QObject::connect ( d->jabberTLSHandler, SIGNAL ( tlsHandshaken() ), SLOT ( slotTLSHandshaken () ) );
 655         }
 656
 657         /*
 658          * Instantiate client stream which handles the network communication by referring
 659          * to a connector (proxying etc.) and a TLS handler (security layer)
 660          */
 661         d->jabberClientStream = new XMPP::ClientStream ( d->jabberClientConnector, d->jabberTLSHandler );
 662
 663         {
 664                 using namespace XMPP;
 665                 QObject::connect ( d->jabberClientStream, SIGNAL ( needAuthParams(bool, bool, bool) ),
 666                                    this, SLOT ( slotCSNeedAuthParams (bool, bool, bool) ) );
 667                 QObject::connect ( d->jabberClientStream, SIGNAL ( authenticated () ),
 668                                    this, SLOT ( slotCSAuthenticated () ) );
 669                 QObject::connect ( d->jabberClientStream, SIGNAL ( connectionClosed () ),
 670                                    this, SLOT ( slotCSDisconnected () ) );
 671                 QObject::connect ( d->jabberClientStream, SIGNAL ( delayedCloseFinished () ),
 672                                    this, SLOT ( slotCSDisconnected () ) );
 673                 QObject::connect ( d->jabberClientStream, SIGNAL ( warning (int) ),
 674                                    this, SLOT ( slotCSWarning (int) ) );
 675                 QObject::connect ( d->jabberClientStream, SIGNAL ( error (int) ),
 676                                    this, SLOT ( slotCSError (int) ) );
 677         }
 678
 679         d->jabberClientStream->setOldOnly ( useXMPP09 () );
 680
 681         /*
 682          * Initiate anti-idle timer (will be triggered every 55 seconds).
 683          */
 684         d->jabberClientStream->setNoopTime ( 55000 );
 685
 686         /*
 687          * Allow plaintext password authentication or not?
 688          */
 689         d->jabberClientStream->setAllowPlain( allowPlainTextPassword () ?  XMPP::ClientStream::AllowPlain : XMPP::ClientStream::NoAllowPlain );
 690
 691         /*
 692          * Setup client layer.
 693          */
 694         d->jabberClient = new XMPP::Client ( this );
 695
 696         /*
 697          * Setup privacy manager
 698          */
 699         d->privacyManager = new PrivacyManager ( rootTask() );
 700
 701         /*
 702          * Enable file transfer (IP and server will be set after connection
 703          * has been established.
 704          */
 705         if ( fileTransfersEnabled () )
 706         {
 707                 d->jabberClient->setFileTransferEnabled ( true );
 708
 709                 {
 710                         using namespace XMPP;
 711                         QObject::connect ( d->jabberClient->fileTransferManager(), SIGNAL ( incomingReady() ),
 712                                            this, SLOT ( slotIncomingFileTransfer () ) );
 713                 }
 714         }
 715
 716         /*if (jingleEnabled())
 717         {*/
 718
 719 #ifdef JINGLE_SUPPORT
 720                 d->jabberClient->setJingleEnabled(true);
 721
 722                 {
 723                         using namespace XMPP;
 724                         QObject::connect ( d->jabberClient->jingleSessionManager(), SIGNAL ( incomingSession() ),
 725                                            this, SLOT ( slotIncomingJingleSession () ) );
 726                 }
 727 #else
 728                 d->jabberClient->setJingleEnabled(false);
 729 #endif
 730         /*}*/
 731
 732         /* This should only be done here to connect the signals, otherwise it is a
 733          * bad idea.
 734          */
 735         {
 736                 using namespace XMPP;
 737                 QObject::connect ( d->jabberClient, SIGNAL ( subscription (const Jid &, const QString &, const QString &) ),
 738                                    this, SLOT ( slotSubscription (const Jid &, const QString &) ) );
 739                 QObject::connect ( d->jabberClient, SIGNAL ( rosterRequestFinished ( bool, int, const QString & ) ),
 740                                    this, SLOT ( slotRosterRequestFinished ( bool, int, const QString & ) ) );
 741                 QObject::connect ( d->jabberClient, SIGNAL ( rosterItemAdded (const RosterItem &) ),
 742                                    this, SLOT ( slotNewContact (const RosterItem &) ) );
 743                 QObject::connect ( d->jabberClient, SIGNAL ( rosterItemUpdated (const RosterItem &) ),
 744                                    this, SLOT ( slotContactUpdated (const RosterItem &) ) );
 745                 QObject::connect ( d->jabberClient, SIGNAL ( rosterItemRemoved (const RosterItem &) ),
 746                                    this, SLOT ( slotContactDeleted (const RosterItem &) ) );
 747                 QObject::connect ( d->jabberClient, SIGNAL ( resourceAvailable (const Jid &, const Resource &) ),
 748                                    this, SLOT ( slotResourceAvailable (const Jid &, const Resource &) ) );
 749                 QObject::connect ( d->jabberClient, SIGNAL ( resourceUnavailable (const Jid &, const Resource &) ),
 750                                    this, SLOT ( slotResourceUnavailable (const Jid &, const Resource &) ) );
 751                 QObject::connect ( d->jabberClient, SIGNAL ( messageReceived (const Message &) ),
 752                                    this, SLOT ( slotReceivedMessage (const Message &) ) );
 753                 QObject::connect ( d->jabberClient, SIGNAL ( groupChatJoined (const Jid &) ),
 754                                    this, SLOT ( slotGroupChatJoined (const Jid &) ) );
 755                 QObject::connect ( d->jabberClient, SIGNAL ( groupChatLeft (const Jid &) ),
 756                                    this, SLOT ( slotGroupChatLeft (const Jid &) ) );
 757                 QObject::connect ( d->jabberClient, SIGNAL ( groupChatPresence (const Jid &, const Status &) ),
 758                                    this, SLOT ( slotGroupChatPresence (const Jid &, const Status &) ) );
 759                 QObject::connect ( d->jabberClient, SIGNAL ( groupChatError (const Jid &, int, const QString &) ),
 760                                    this, SLOT ( slotGroupChatError (const Jid &, int, const QString &) ) );
 761                 //QObject::connect ( d->jabberClient, SIGNAL (debugText (const QString &) ),
 762                 //                 this, SLOT ( slotPsiDebug (const QString &) ) );
 763                 QObject::connect ( d->jabberClient, SIGNAL ( xmlIncoming(const QString& ) ),
 764                                    this, SLOT ( slotIncomingXML (const QString &) ) );
 765                 QObject::connect ( d->jabberClient, SIGNAL ( xmlOutgoing(const QString& ) ),
 766                                    this, SLOT ( slotOutgoingXML (const QString &) ) );
 767         }
 768
 769         d->jabberClient->setClientName ( clientName () );
 770         d->jabberClient->setClientVersion ( clientVersion () );
 771         d->jabberClient->setOSName ( osName () );
 772
 773         // Set caps information
 774         d->jabberClient->setCapsNode( capsNode() );
 775         d->jabberClient->setCapsVersion( capsVersion() );
 776
 777         // Set Disco Identity
 778         d->jabberClient->setIdentity( discoIdentity() );
 779
 780         d->jabberClient->setTimeZone ( timeZoneName (), timeZoneOffset () );
 781
 782         // Additional features
 783         d->jabberClient->setFeatures(Features("http://jabber.org/protocol/xhtml-im"));
 784
 785         d->jabberClient->connectToServer ( d->jabberClientStream, jid, auth );
 786
 787         return Ok;
 788
 789 }
 790
 791 void JabberClient::disconnect ()
 792 {
 793
 794         if ( d->jabberClient )
 795         {
 796                 d->jabberClient->close ();
 797         }
 798         else
 799         {
 800                 cleanUp ();
 801         }
 802
 803 }
 804
 805 void JabberClient::disconnect( XMPP::Status &reason )
 806 {
 807     if ( d->jabberClient )
 808     {
 809         if ( d->jabberClientStream->isActive() )
 810         {
 811             XMPP::JT_Presence *pres = new JT_Presence(rootTask());
 812             reason.setIsAvailable( false );
 813             pres->pres( reason );
 814             pres->go();
 815
 816             d->jabberClientStream->close();
 817             d->jabberClient->close();
 818         }
 819     }
 820     else
 821     {
 822         cleanUp();
 823     }
 824 }
 825
 826 bool JabberClient::isConnected () const
 827 {
 828
 829         if ( d->jabberClient )
 830         {
 831                 return d->jabberClient->isActive ();
 832         }
 833
 834         return false;
 835
 836 }
 837
 838 void JabberClient::joinGroupChat ( const QString &host, const QString &room, const QString &nick )
 839 {
 840
 841         client()->groupChatJoin ( host, room, nick );
 842
 843 }
 844
 845 void JabberClient::joinGroupChat ( const QString &host, const QString &room, const QString &nick, const QString &password )
 846 {
 847         client()->groupChatJoin ( host, room, nick, password );
 848
 849 }
 850
 851 void JabberClient::leaveGroupChat ( const QString &host, const QString &room )
 852 {
 853
 854         client()->groupChatLeave ( host, room );
 855
 856 }
 857
 858 void JabberClient::setGroupChatStatus( const QString & host, const QString & room, const XMPP::Status & status )
 859 {
 860         client()->groupChatSetStatus( host, room, status);
 861 }
 862
 863 void JabberClient::changeGroupChatNick( const QString & host, const QString & room, const QString & nick, const XMPP::Status & status )
 864 {
 865         client()->groupChatChangeNick( host, room, nick, status );
 866 }
 867
 868
 869 void JabberClient::sendMessage ( const XMPP::Message &message )
 870 {
 871
 872         client()->sendMessage ( message );
 873
 874 }
 875
 876 void JabberClient::send ( const QString &packet )
 877 {
 878
 879         client()->send ( packet );
 880
 881 }
 882
 883 void JabberClient::requestRoster ()
 884 {
 885
 886         client()->rosterRequest ();
 887
 888 }
 889
 890 void JabberClient::slotPsiDebug ( const QString & _msg )
 891 {
 892         QString msg = _msg;
 893
 894         msg = msg.replace( QRegExp( "<password>[^<]*</password>\n" ), "<password>[Filtered]</password>\n" );
 895         msg = msg.replace( QRegExp( "<digest>[^<]*</digest>\n" ), "<digest>[Filtered]</digest>\n" );
 896
 897         emit debugMessage ( "Psi: " + msg );
 898
 899 }
 900
 901 void JabberClient::slotIncomingXML ( const QString & _msg )
 902 {
 903         QString msg = _msg;
 904
 905         msg = msg.replace( QRegExp( "<password>[^<]*</password>\n" ), "<password>[Filtered]</password>\n" );
 906         msg = msg.replace( QRegExp( "<digest>[^<]*</digest>\n" ), "<digest>[Filtered]</digest>\n" );
 907
 908         emit debugMessage ( "XML IN: " + msg );
 909         emit incomingXML ( msg );
 910 }
 911
 912 void JabberClient::slotOutgoingXML ( const QString & _msg )
 913 {
 914         QString msg = _msg;
 915
 916         msg = msg.replace( QRegExp( "<password>[^<]*</password>\n" ), "<password>[Filtered]</password>\n" );
 917         msg = msg.replace( QRegExp( "<digest>[^<]*</digest>\n" ), "<digest>[Filtered]</digest>\n" );
 918
 919         emit debugMessage ( "XML OUT: " + msg );
 920         emit outgoingXML ( msg );
 921 }
 922
 923 void JabberClient::slotTLSHandshaken ()
 924 {
 925
 926         emit debugMessage ( "TLS handshake done, testing certificate validity..." );
 927
 928         // FIXME: in the future, this should be handled by KDE, not QCA
 929
 930         QCA::TLS::IdentityResult identityResult = d->jabberTLS->peerIdentityResult();
 931         QCA::Validity            validityResult = d->jabberTLS->peerCertificateValidity();
 932
 933         if ( identityResult == QCA::TLS::Valid && validityResult == QCA::ValidityGood )
 934         {
 935                 emit debugMessage ( "Identity and certificate valid, continuing." );
 936
 937                 // valid certificate, continue
 938                 d->jabberTLSHandler->continueAfterHandshake ();
 939         }
 940         else
 941         {
 942                 emit debugMessage ( "Certificate is not valid, asking user what to do next." );
 943
 944                 // certificate is not valid, query the user
 945                 if ( ignoreTLSWarnings () )
 946                 {
 947                         emit debugMessage ( "We are supposed to ignore TLS warnings, continuing." );
 948                         d->jabberTLSHandler->continueAfterHandshake ();
 949                 }
 950
 951                 emit tlsWarning ( identityResult, validityResult );
 952         }
 953
 954 }
 955
 956 void JabberClient::continueAfterTLSWarning ()
 957 {
 958
 959         if ( d->jabberTLSHandler )
 960         {
 961                 d->jabberTLSHandler->continueAfterHandshake ();
 962         }
 963
 964 }
 965
 966 void JabberClient::slotCSNeedAuthParams ( bool user, bool pass, bool realm )
 967 {
 968         emit debugMessage ( "Sending auth credentials..." );
 969
 970         if ( user )
 971         {
 972                 d->jabberClientStream->setUsername ( jid().node () );
 973         }
 974
 975         if ( pass )
 976         {
 977                 d->jabberClientStream->setPassword ( d->password );
 978         }
 979
 980         if ( realm )
 981         {
 982                 d->jabberClientStream->setRealm ( jid().domain () );
 983         }
 984
 985         d->jabberClientStream->continueAfterParams ();
 986
 987 }
 988
 989 void JabberClient::slotCSAuthenticated ()
 990 {
 991         emit debugMessage ( "Connected to Jabber server." );
 992
 993         /*
 994          * Determine local IP address.
 995          * FIXME: This is ugly!
 996          */
 997         if ( localAddress().isEmpty () )
 998         {
 999                 // code for Iris-type bytestreams
1000                 ByteStream *irisByteStream = d->jabberClientConnector->stream();
1001                 if ( irisByteStream->inherits ( "BSocket" ) || irisByteStream->inherits ( "XMPP::BSocket" ) )
1002                 {
1003                         d->localAddress = ( (BSocket *)irisByteStream )->address().toString ();
1004                 }
1005         }
1006
1007         if ( fileTransfersEnabled () )
1008         {
1009                 // setup file transfer
1010                 addS5BServerAddress ( localAddress () );
1011                 d->jabberClient->s5bManager()->setServer ( s5bServer () );
1012         }
1013
1014
1015         //update the ressource:
1016         d->jid = d->jabberClientStream->jid();
1017
1018         // start the client operation
1019         d->jabberClient->start ( jid().domain (), jid().node (), d->password, jid().resource () );
1020
1021         if (!d->jabberClientStream->old())
1022         {
1023                 XMPP::JT_Session *j = new XMPP::JT_Session(rootTask());
1024                 QObject::connect(j, SIGNAL(finished()), this, SLOT(slotSessionStarted()));
1025                 j->go(true);
1026         }
1027         else
1028         {
1029                 emit connected();
1030         }
1031 }
1032
1033 void JabberClient::slotSessionStarted()
1034 {
1035         XMPP::JT_Session *j = static_cast<XMPP::JT_Session*>(sender());
1036         if ( j->success() )
1037                 emit connected();
1038         else
1039                 emit csError ( -1 );
1040 }
1041
1042
1043 void JabberClient::slotCSDisconnected ()
1044 {
1045
1046         /* FIXME:
1047          * We should delete the XMPP::Client instance here,
1048          * but timers etc prevent us from doing so. (Psi does
1049          * not like to be deleted from a slot).
1050          */
1051
1052         emit debugMessage ( "Disconnected, freeing up file transfer port..." );
1053
1054         // delete local address from S5B server
1055         removeS5BServerAddress ( localAddress () );
1056
1057         emit csDisconnected ();
1058
1059 }
1060
1061 void JabberClient::slotCSWarning ( int warning )
1062 {
1063
1064         emit debugMessage ( "Client stream warning." );
1065
1066         /*
1067          * FIXME: process all other warnings
1068          */
1069         switch ( warning )
1070         {
1071                 //case XMPP::ClientStream::WarnOldVersion:
1072                 case XMPP::ClientStream::WarnNoTLS:
1073                         if ( forceTLS () )
1074                         {
1075                                 disconnect ();
1076                                 emit error ( NoTLS );
1077                                 return;
1078                         }
1079                         break;
1080         }
1081
1082         d->jabberClientStream->continueAfterWarning ();
1083
1084 }
1085
1086 void JabberClient::slotCSError ( int error )
1087 {
1088
1089         emit debugMessage ( "Client stream error." );
1090
1091         emit csError ( error );
1092
1093 }
1094
1095 void JabberClient::slotRosterRequestFinished ( bool success, int /*statusCode*/, const QString &/*statusString*/ )
1096 {
1097
1098         emit rosterRequestFinished ( success );
1099
1100 }
1101
1102 void JabberClient::slotIncomingFileTransfer ()
1103 {
1104
1105         emit incomingFileTransfer ();
1106
1107 }
1108
1109 void JabberClient::slotNewContact ( const XMPP::RosterItem &item )
1110 {
1111
1112         emit newContact ( item );
1113
1114 }
1115
1116 void JabberClient::slotContactDeleted ( const RosterItem &item )
1117 {
1118
1119         emit contactDeleted ( item );
1120
1121 }
1122
1123 void JabberClient::slotContactUpdated ( const RosterItem &item )
1124 {
1125
1126         emit contactUpdated ( item );
1127
1128 }
1129
1130 void JabberClient::slotResourceAvailable ( const Jid &jid, const Resource &resource )
1131 {
1132
1133         emit resourceAvailable ( jid, resource );
1134
1135 }
1136
1137 void JabberClient::slotResourceUnavailable ( const Jid &jid, const Resource &resource )
1138 {
1139
1140         emit resourceUnavailable ( jid, resource );
1141
1142 }
1143
1144 void JabberClient::slotReceivedMessage ( const Message &message )
1145 {
1146
1147         emit messageReceived ( message );
1148
1149 }
1150
1151 void JabberClient::slotGroupChatJoined ( const Jid &jid )
1152 {
1153
1154         emit groupChatJoined ( jid );
1155
1156 }
1157
1158 void JabberClient::slotGroupChatLeft ( const Jid &jid )
1159 {
1160
1161         emit groupChatLeft ( jid );
1162
1163 }
1164
1165 void JabberClient::slotGroupChatPresence ( const Jid &jid, const Status &status)
1166 {
1167
1168         emit groupChatPresence ( jid, status );
1169
1170 }
1171
1172 void JabberClient::slotGroupChatError ( const Jid &jid, int error, const QString &reason)
1173 {
1174
1175         emit groupChatError ( jid, error, reason );
1176
1177 }
1178
1179 void JabberClient::slotSubscription ( const Jid &jid, const QString &type )
1180 {
1181
1182         emit subscription ( jid, type );
1183
1184 }
1185
1186
1187 #include "jabberclient.moc"