From bcb704366cb5e333a626c18c308c7e0448a8e69f Mon Sep 17 00:00:00 2001 From: toma Date: Wed, 25 Nov 2009 17:56:58 +0000 Subject: Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features. BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdenetwork@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- kopete/protocols/jabber/jabberclient.cpp | 1137 ++++++++++++++++++++++++++++++ 1 file changed, 1137 insertions(+) create mode 100644 kopete/protocols/jabber/jabberclient.cpp (limited to 'kopete/protocols/jabber/jabberclient.cpp') diff --git a/kopete/protocols/jabber/jabberclient.cpp b/kopete/protocols/jabber/jabberclient.cpp new file mode 100644 index 00000000..b8e05d48 --- /dev/null +++ b/kopete/protocols/jabber/jabberclient.cpp @@ -0,0 +1,1137 @@ + +/*************************************************************************** + jabberclient.cpp - Generic Jabber Client Class + ------------------- + begin : Sat May 25 2005 + copyright : (C) 2005 by Till Gerken + (C) 2006 by Michaël Larouche + + Kopete (C) 2001-2006 Kopete developers + . + ***************************************************************************/ + +/*************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + ***************************************************************************/ + +#include "jabberclient.h" + +#include +#include + +#include +#include +#include +#include + +#include "jabberconnector.h" + +#define JABBER_PENALTY_TIME 2 + +class JabberClient::Private +{ +public: + Private() + : jabberClient(0L), jabberClientStream(0L), jabberClientConnector(0L), jabberTLS(0L), jabberTLSHandler(0L) + {} + ~Private() + { + if ( jabberClient ) + { + jabberClient->close (); + } + + delete jabberClient; + delete jabberClientStream; + delete jabberClientConnector; + delete jabberTLSHandler; + delete jabberTLS; + } + + // connection details + XMPP::Jid jid; + QString password; + + // XMPP backend + XMPP::Client *jabberClient; + XMPP::ClientStream *jabberClientStream; + JabberConnector *jabberClientConnector; + QCA::TLS *jabberTLS; + XMPP::QCATLSHandler *jabberTLSHandler; + + // ignore TLS warnings + bool ignoreTLSWarnings; + + // current S5B server instance + static XMPP::S5BServer *s5bServer; + // address list being handled by the S5B server instance + static QStringList s5bAddressList; + // port of S5B server + static int s5bServerPort; + + // local IP address + QString localAddress; + + // whether TLS (or direct SSL in case of the old protocol) should be used + bool forceTLS; + + // whether direct SSL connections should be used + bool useSSL; + + // use XMPP 1.0 or the older protocol version + bool useXMPP09; + + // whether SSL support should be probed in case the old protocol is used + bool probeSSL; + + // override the default server name and port (only pre-XMPP 1.0) + bool overrideHost; + QString server; + int port; + + // allow transmission of plaintext passwords + bool allowPlainTextPassword; + + // enable file transfers + bool fileTransfersEnabled; + + // current penalty time + int currentPenaltyTime; + + // client information + QString clientName, clientVersion, osName; + + // timezone information + QString timeZoneName; + int timeZoneOffset; + + // Caps(JEP-0115: Entity Capabilities) information + QString capsNode, capsVersion; + DiscoItem::Identity discoIdentity; +}; + +XMPP::S5BServer *JabberClient::Private::s5bServer = 0L; +QStringList JabberClient::Private::s5bAddressList; +int JabberClient::Private::s5bServerPort = 8010; + +JabberClient::JabberClient () +{ + d = new Private(); + + cleanUp (); + + // initiate penalty timer + QTimer::singleShot ( JABBER_PENALTY_TIME * 1000, this, SLOT ( slotUpdatePenaltyTime () ) ); + +} + +JabberClient::~JabberClient () +{ + delete d; +} + +void JabberClient::cleanUp () +{ + if ( d->jabberClient ) + { + d->jabberClient->close (); + } + + delete d->jabberClient; + delete d->jabberClientStream; + delete d->jabberClientConnector; + delete d->jabberTLSHandler; + delete d->jabberTLS; + + d->jabberClient = 0L; + d->jabberClientStream = 0L; + d->jabberClientConnector = 0L; + d->jabberTLSHandler = 0L; + d->jabberTLS = 0L; + + d->currentPenaltyTime = 0; + + d->jid = XMPP::Jid (); + d->password = QString::null; + + setForceTLS ( false ); + setUseSSL ( false ); + setUseXMPP09 ( false ); + setProbeSSL ( false ); + + setOverrideHost ( false ); + + setAllowPlainTextPassword ( true ); + + setFileTransfersEnabled ( false ); + setS5BServerPort ( 8010 ); + + setClientName ( QString::null ); + setClientVersion ( QString::null ); + setOSName ( QString::null ); + + setTimeZone ( "UTC", 0 ); + + setIgnoreTLSWarnings ( false ); + +} + +void JabberClient::slotUpdatePenaltyTime () +{ + + if ( d->currentPenaltyTime >= JABBER_PENALTY_TIME ) + d->currentPenaltyTime -= JABBER_PENALTY_TIME; + else + d->currentPenaltyTime = 0; + + QTimer::singleShot ( JABBER_PENALTY_TIME * 1000, this, SLOT ( slotUpdatePenaltyTime () ) ); + +} + +void JabberClient::setIgnoreTLSWarnings ( bool flag ) +{ + + d->ignoreTLSWarnings = flag; + +} + +bool JabberClient::ignoreTLSWarnings () +{ + + return d->ignoreTLSWarnings; + +} + +bool JabberClient::setS5BServerPort ( int port ) +{ + + d->s5bServerPort = port; + + if ( fileTransfersEnabled () ) + { + return s5bServer()->start ( port ); + } + + return true; + +} + +int JabberClient::s5bServerPort () const +{ + + return d->s5bServerPort; + +} + +XMPP::S5BServer *JabberClient::s5bServer () +{ + + if ( !d->s5bServer ) + { + d->s5bServer = new XMPP::S5BServer (); + QObject::connect ( d->s5bServer, SIGNAL ( destroyed () ), this, SLOT ( slotS5BServerGone () ) ); + + /* + * Try to start the server at the default port here. + * We have no way of notifying the caller of an error. + * However, since the caller will usually also + * use setS5BServerPort() to ensure the correct + * port, we can return an error code there. + */ + if ( fileTransfersEnabled () ) + { + s5bServer()->start ( d->s5bServerPort ); + } + } + + return d->s5bServer; + +} + +void JabberClient::slotS5BServerGone () +{ + + d->s5bServer = 0L; + + if ( d->jabberClient ) + d->jabberClient->s5bManager()->setServer( 0L ); + +} + +void JabberClient::addS5BServerAddress ( const QString &address ) +{ + QStringList newList; + + d->s5bAddressList.append ( address ); + + // now filter the list without dupes + for ( QStringList::Iterator it = d->s5bAddressList.begin (); it != d->s5bAddressList.end (); ++it ) + { + if ( !newList.contains ( *it ) ) + newList.append ( *it ); + } + + s5bServer()->setHostList ( newList ); + +} + +void JabberClient::removeS5BServerAddress ( const QString &address ) +{ + QStringList newList; + + QStringList::iterator it = d->s5bAddressList.find ( address ); + if ( it != d->s5bAddressList.end () ) + { + d->s5bAddressList.remove ( it ); + } + + if ( d->s5bAddressList.isEmpty () ) + { + delete d->s5bServer; + d->s5bServer = 0L; + } + else + { + // now filter the list without dupes + for ( QStringList::Iterator it = d->s5bAddressList.begin (); it != d->s5bAddressList.end (); ++it ) + { + if ( !newList.contains ( *it ) ) + newList.append ( *it ); + } + + s5bServer()->setHostList ( newList ); + } + +} + +void JabberClient::setForceTLS ( bool flag ) +{ + + d->forceTLS = flag; + +} + +bool JabberClient::forceTLS () const +{ + + return d->forceTLS; + +} + +void JabberClient::setUseSSL ( bool flag ) +{ + + d->useSSL = flag; + +} + +bool JabberClient::useSSL () const +{ + + return d->useSSL; + +} + +void JabberClient::setUseXMPP09 ( bool flag ) +{ + + d->useXMPP09 = flag; + +} + +bool JabberClient::useXMPP09 () const +{ + + return d->useXMPP09; + +} + +void JabberClient::setProbeSSL ( bool flag ) +{ + + d->probeSSL = flag; + +} + +bool JabberClient::probeSSL () const +{ + + return d->probeSSL; + +} + +void JabberClient::setOverrideHost ( bool flag, const QString &server, int port ) +{ + + d->overrideHost = flag; + d->server = server; + d->port = port; + +} + +bool JabberClient::overrideHost () const +{ + + return d->overrideHost; + +} + +void JabberClient::setAllowPlainTextPassword ( bool flag ) +{ + + d->allowPlainTextPassword = flag; + +} + +bool JabberClient::allowPlainTextPassword () const +{ + + return d->allowPlainTextPassword; + +} + +void JabberClient::setFileTransfersEnabled ( bool flag, const QString &localAddress ) +{ + + d->fileTransfersEnabled = flag; + d->localAddress = localAddress; + +} + +QString JabberClient::localAddress () const +{ + + return d->localAddress; + +} + +bool JabberClient::fileTransfersEnabled () const +{ + + return d->fileTransfersEnabled; + +} + +void JabberClient::setClientName ( const QString &clientName ) +{ + + d->clientName = clientName; + +} + +QString JabberClient::clientName () const +{ + + return d->clientName; + +} + +void JabberClient::setClientVersion ( const QString &clientVersion ) +{ + + d->clientVersion = clientVersion; + +} + +QString JabberClient::clientVersion () const +{ + + return d->clientVersion; + +} + +void JabberClient::setOSName ( const QString &osName ) +{ + + d->osName = osName; + +} + +QString JabberClient::osName () const +{ + + return d->osName; + +} + +void JabberClient::setCapsNode( const QString &capsNode ) +{ + d->capsNode = capsNode; +} + +QString JabberClient::capsNode() const +{ + return d->capsNode; +} + +void JabberClient::setCapsVersion( const QString &capsVersion ) +{ + d->capsVersion = capsVersion; +} + +QString JabberClient::capsVersion() const +{ + return d->capsVersion; +} + +QString JabberClient::capsExt() const +{ + if(d->jabberClient) + { + return d->jabberClient->capsExt(); + } + + return QString(); +} +void JabberClient::setDiscoIdentity( DiscoItem::Identity identity ) +{ + d->discoIdentity = identity; +} + +DiscoItem::Identity JabberClient::discoIdentity() const +{ + return d->discoIdentity; +} + +void JabberClient::setTimeZone ( const QString &timeZoneName, int timeZoneOffset ) +{ + + d->timeZoneName = timeZoneName; + d->timeZoneOffset = timeZoneOffset; + +} + +QString JabberClient::timeZoneName () const +{ + + return d->timeZoneName; + +} + +int JabberClient::timeZoneOffset () const +{ + + return d->timeZoneOffset; + +} + +int JabberClient::getPenaltyTime () +{ + + int currentTime = d->currentPenaltyTime; + + d->currentPenaltyTime += JABBER_PENALTY_TIME; + + return currentTime; + +} + +XMPP::Client *JabberClient::client () const +{ + + return d->jabberClient; + +} + +XMPP::ClientStream *JabberClient::clientStream () const +{ + + return d->jabberClientStream; + +} + +JabberConnector *JabberClient::clientConnector () const +{ + + return d->jabberClientConnector; + +} + +XMPP::Task *JabberClient::rootTask () const +{ + + if ( client () ) + { + return client()->rootTask (); + } + else + { + return 0l; + } + +} + +XMPP::FileTransferManager *JabberClient::fileTransferManager () const +{ + + if ( client () ) + { + return client()->fileTransferManager (); + } + else + { + return 0L; + } + +} + +XMPP::Jid JabberClient::jid () const +{ + + return d->jid; + +} + +JabberClient::ErrorCode JabberClient::connect ( const XMPP::Jid &jid, const QString &password, bool auth ) +{ + /* + * Close any existing connection. + */ + if ( d->jabberClient ) + { + d->jabberClient->close (); + } + + d->jid = jid; + d->password = password; + + /* + * Return an error if we should force TLS but it's not available. + */ + if ( ( forceTLS () || useSSL () || probeSSL () ) && !QCA::isSupported ( QCA::CAP_TLS ) ) + { + return NoTLS; + } + + /* + * Instantiate connector, responsible for dealing with the socket. + * This class uses KDE's socket code, which in turn makes use of + * the global proxy settings. + */ + d->jabberClientConnector = new JabberConnector; + + d->jabberClientConnector->setOptSSL ( useSSL () ); + + if ( useXMPP09 () ) + { + if ( overrideHost () ) + { + d->jabberClientConnector->setOptHostPort ( d->server, d->port ); + } + + d->jabberClientConnector->setOptProbe ( probeSSL () ); + + } + + /* + * Setup authentication layer + */ + if ( QCA::isSupported ( QCA::CAP_TLS ) ) + { + d->jabberTLS = new QCA::TLS; + d->jabberTLSHandler = new XMPP::QCATLSHandler ( d->jabberTLS ); + + { + using namespace XMPP; + QObject::connect ( d->jabberTLSHandler, SIGNAL ( tlsHandshaken() ), this, SLOT ( slotTLSHandshaken () ) ); + } + + QPtrList certStore; + d->jabberTLS->setCertificateStore ( certStore ); + } + + /* + * Instantiate client stream which handles the network communication by referring + * to a connector (proxying etc.) and a TLS handler (security layer) + */ + d->jabberClientStream = new XMPP::ClientStream ( d->jabberClientConnector, d->jabberTLSHandler ); + + { + using namespace XMPP; + QObject::connect ( d->jabberClientStream, SIGNAL ( needAuthParams(bool, bool, bool) ), + this, SLOT ( slotCSNeedAuthParams (bool, bool, bool) ) ); + QObject::connect ( d->jabberClientStream, SIGNAL ( authenticated () ), + this, SLOT ( slotCSAuthenticated () ) ); + QObject::connect ( d->jabberClientStream, SIGNAL ( connectionClosed () ), + this, SLOT ( slotCSDisconnected () ) ); + QObject::connect ( d->jabberClientStream, SIGNAL ( delayedCloseFinished () ), + this, SLOT ( slotCSDisconnected () ) ); + QObject::connect ( d->jabberClientStream, SIGNAL ( warning (int) ), + this, SLOT ( slotCSWarning (int) ) ); + QObject::connect ( d->jabberClientStream, SIGNAL ( error (int) ), + this, SLOT ( slotCSError (int) ) ); + } + + d->jabberClientStream->setOldOnly ( useXMPP09 () ); + + /* + * Initiate anti-idle timer (will be triggered every 55 seconds). + */ + d->jabberClientStream->setNoopTime ( 55000 ); + + /* + * Allow plaintext password authentication or not? + */ + d->jabberClientStream->setAllowPlain( allowPlainTextPassword () ); + + /* + * Setup client layer. + */ + d->jabberClient = new XMPP::Client ( this ); + + /* + * Enable file transfer (IP and server will be set after connection + * has been established. + */ + if ( fileTransfersEnabled () ) + { + d->jabberClient->setFileTransferEnabled ( true ); + + { + using namespace XMPP; + QObject::connect ( d->jabberClient->fileTransferManager(), SIGNAL ( incomingReady() ), + this, SLOT ( slotIncomingFileTransfer () ) ); + } + } + + /* This should only be done here to connect the signals, otherwise it is a + * bad idea. + */ + { + using namespace XMPP; + QObject::connect ( d->jabberClient, SIGNAL ( subscription (const Jid &, const QString &) ), + this, SLOT ( slotSubscription (const Jid &, const QString &) ) ); + QObject::connect ( d->jabberClient, SIGNAL ( rosterRequestFinished ( bool, int, const QString & ) ), + this, SLOT ( slotRosterRequestFinished ( bool, int, const QString & ) ) ); + QObject::connect ( d->jabberClient, SIGNAL ( rosterItemAdded (const RosterItem &) ), + this, SLOT ( slotNewContact (const RosterItem &) ) ); + QObject::connect ( d->jabberClient, SIGNAL ( rosterItemUpdated (const RosterItem &) ), + this, SLOT ( slotContactUpdated (const RosterItem &) ) ); + QObject::connect ( d->jabberClient, SIGNAL ( rosterItemRemoved (const RosterItem &) ), + this, SLOT ( slotContactDeleted (const RosterItem &) ) ); + QObject::connect ( d->jabberClient, SIGNAL ( resourceAvailable (const Jid &, const Resource &) ), + this, SLOT ( slotResourceAvailable (const Jid &, const Resource &) ) ); + QObject::connect ( d->jabberClient, SIGNAL ( resourceUnavailable (const Jid &, const Resource &) ), + this, SLOT ( slotResourceUnavailable (const Jid &, const Resource &) ) ); + QObject::connect ( d->jabberClient, SIGNAL ( messageReceived (const Message &) ), + this, SLOT ( slotReceivedMessage (const Message &) ) ); + QObject::connect ( d->jabberClient, SIGNAL ( groupChatJoined (const Jid &) ), + this, SLOT ( slotGroupChatJoined (const Jid &) ) ); + QObject::connect ( d->jabberClient, SIGNAL ( groupChatLeft (const Jid &) ), + this, SLOT ( slotGroupChatLeft (const Jid &) ) ); + QObject::connect ( d->jabberClient, SIGNAL ( groupChatPresence (const Jid &, const Status &) ), + this, SLOT ( slotGroupChatPresence (const Jid &, const Status &) ) ); + QObject::connect ( d->jabberClient, SIGNAL ( groupChatError (const Jid &, int, const QString &) ), + this, SLOT ( slotGroupChatError (const Jid &, int, const QString &) ) ); + //QObject::connect ( d->jabberClient, SIGNAL (debugText (const QString &) ), + // this, SLOT ( slotPsiDebug (const QString &) ) ); + QObject::connect ( d->jabberClient, SIGNAL ( xmlIncoming(const QString& ) ), + this, SLOT ( slotIncomingXML (const QString &) ) ); + QObject::connect ( d->jabberClient, SIGNAL ( xmlOutgoing(const QString& ) ), + this, SLOT ( slotOutgoingXML (const QString &) ) ); + } + + d->jabberClient->setClientName ( clientName () ); + d->jabberClient->setClientVersion ( clientVersion () ); + d->jabberClient->setOSName ( osName () ); + + // Set caps information + d->jabberClient->setCapsNode( capsNode() ); + d->jabberClient->setCapsVersion( capsVersion() ); + + // Set Disco Identity + d->jabberClient->setIdentity( discoIdentity() ); + + d->jabberClient->setTimeZone ( timeZoneName (), timeZoneOffset () ); + + d->jabberClient->connectToServer ( d->jabberClientStream, jid, auth ); + + return Ok; + +} + +void JabberClient::disconnect () +{ + + if ( d->jabberClient ) + { + d->jabberClient->close (); + } + else + { + cleanUp (); + } + +} + +void JabberClient::disconnect( XMPP::Status &reason ) +{ + if ( d->jabberClient ) + { + if ( d->jabberClientStream->isActive() ) + { + XMPP::JT_Presence *pres = new JT_Presence(rootTask()); + reason.setIsAvailable( false ); + pres->pres( reason ); + pres->go(); + + d->jabberClientStream->close(); + d->jabberClient->close(); + } + } + else + { + cleanUp(); + } +} + +bool JabberClient::isConnected () const +{ + + if ( d->jabberClient ) + { + return d->jabberClient->isActive (); + } + + return false; + +} + +void JabberClient::joinGroupChat ( const QString &host, const QString &room, const QString &nick ) +{ + + client()->groupChatJoin ( host, room, nick ); + +} + +void JabberClient::joinGroupChat ( const QString &host, const QString &room, const QString &nick, const QString &password ) +{ + + client()->groupChatJoin ( host, room, nick, password ); + +} + +void JabberClient::leaveGroupChat ( const QString &host, const QString &room ) +{ + + client()->groupChatLeave ( host, room ); + +} + +void JabberClient::setGroupChatStatus( const QString & host, const QString & room, const XMPP::Status & status ) +{ + client()->groupChatSetStatus( host, room, status); +} + +void JabberClient::changeGroupChatNick( const QString & host, const QString & room, const QString & nick, const XMPP::Status & status ) +{ + client()->groupChatChangeNick( host, room, nick, status ); +} + + +void JabberClient::sendMessage ( const XMPP::Message &message ) +{ + + client()->sendMessage ( message ); + +} + +void JabberClient::send ( const QString &packet ) +{ + + client()->send ( packet ); + +} + +void JabberClient::requestRoster () +{ + + client()->rosterRequest (); + +} + +void JabberClient::slotPsiDebug ( const QString & _msg ) +{ + QString msg = _msg; + + msg = msg.replace( QRegExp( "[^<]*\n" ), "[Filtered]\n" ); + msg = msg.replace( QRegExp( "[^<]*\n" ), "[Filtered]\n" ); + + emit debugMessage ( "Psi: " + msg ); + +} + +void JabberClient::slotIncomingXML ( const QString & _msg ) +{ + QString msg = _msg; + + msg = msg.replace( QRegExp( "[^<]*\n" ), "[Filtered]\n" ); + msg = msg.replace( QRegExp( "[^<]*\n" ), "[Filtered]\n" ); + + emit debugMessage ( "XML IN: " + msg ); + +} + +void JabberClient::slotOutgoingXML ( const QString & _msg ) +{ + QString msg = _msg; + + msg = msg.replace( QRegExp( "[^<]*\n" ), "[Filtered]\n" ); + msg = msg.replace( QRegExp( "[^<]*\n" ), "[Filtered]\n" ); + + emit debugMessage ( "XML OUT: " + msg ); + +} + +void JabberClient::slotTLSHandshaken () +{ + + emit debugMessage ( "TLS handshake done, testing certificate validity..." ); + + // FIXME: in the future, this should be handled by KDE, not QCA + int validityResult = d->jabberTLS->certificateValidityResult (); + + if ( validityResult == QCA::TLS::Valid ) + { + emit debugMessage ( "Certificate is valid, continuing." ); + + // valid certificate, continue + d->jabberTLSHandler->continueAfterHandshake (); + } + else + { + emit debugMessage ( "Certificate is not valid, asking user what to do next." ); + + // certificate is not valid, query the user + if ( ignoreTLSWarnings () ) + { + emit debugMessage ( "We are supposed to ignore TLS warnings, continuing." ); + d->jabberTLSHandler->continueAfterHandshake (); + } + + emit tlsWarning ( validityResult ); + } + +} + +void JabberClient::continueAfterTLSWarning () +{ + + if ( d->jabberTLSHandler ) + { + d->jabberTLSHandler->continueAfterHandshake (); + } + +} + +void JabberClient::slotCSNeedAuthParams ( bool user, bool pass, bool realm ) +{ + emit debugMessage ( "Sending auth credentials..." ); + + if ( user ) + { + d->jabberClientStream->setUsername ( jid().node () ); + } + + if ( pass ) + { + d->jabberClientStream->setPassword ( d->password ); + } + + if ( realm ) + { + d->jabberClientStream->setRealm ( jid().domain () ); + } + + d->jabberClientStream->continueAfterParams (); + +} + +void JabberClient::slotCSAuthenticated () +{ + emit debugMessage ( "Connected to Jabber server." ); + + /* + * Determine local IP address. + * FIXME: This is ugly! + */ + if ( localAddress().isEmpty () ) + { + // code for Iris-type bytestreams + ByteStream *irisByteStream = d->jabberClientConnector->stream(); + if ( irisByteStream->inherits ( "BSocket" ) || irisByteStream->inherits ( "XMPP::BSocket" ) ) + { + d->localAddress = ( (BSocket *)irisByteStream )->address().toString (); + } + + // code for the KDE-type bytestream + JabberByteStream *kdeByteStream = dynamic_cast(d->jabberClientConnector->stream()); + if ( kdeByteStream ) + { + d->localAddress = kdeByteStream->socket()->localAddress().nodeName (); + } + } + + if ( fileTransfersEnabled () ) + { + // setup file transfer + addS5BServerAddress ( localAddress () ); + d->jabberClient->s5bManager()->setServer ( s5bServer () ); + } + + // start the client operation + d->jabberClient->start ( jid().domain (), jid().node (), d->password, jid().resource () ); + + emit connected (); +} + +void JabberClient::slotCSDisconnected () +{ + + /* FIXME: + * We should delete the XMPP::Client instance here, + * but timers etc prevent us from doing so. (Psi does + * not like to be deleted from a slot). + */ + + emit debugMessage ( "Disconnected, freeing up file transfer port..." ); + + // delete local address from S5B server + removeS5BServerAddress ( localAddress () ); + + emit csDisconnected (); + +} + +void JabberClient::slotCSWarning ( int warning ) +{ + + emit debugMessage ( "Client stream warning." ); + + /* + * FIXME: process all other warnings + */ + switch ( warning ) + { + //case XMPP::ClientStream::WarnOldVersion: + case XMPP::ClientStream::WarnNoTLS: + if ( forceTLS () ) + { + disconnect (); + emit error ( NoTLS ); + return; + } + break; + } + + d->jabberClientStream->continueAfterWarning (); + +} + +void JabberClient::slotCSError ( int error ) +{ + + emit debugMessage ( "Client stream error." ); + + emit csError ( error ); + +} + +void JabberClient::slotRosterRequestFinished ( bool success, int /*statusCode*/, const QString &/*statusString*/ ) +{ + + emit rosterRequestFinished ( success ); + +} + +void JabberClient::slotIncomingFileTransfer () +{ + + emit incomingFileTransfer (); + +} + +void JabberClient::slotNewContact ( const XMPP::RosterItem &item ) +{ + + emit newContact ( item ); + +} + +void JabberClient::slotContactDeleted ( const RosterItem &item ) +{ + + emit contactDeleted ( item ); + +} + +void JabberClient::slotContactUpdated ( const RosterItem &item ) +{ + + emit contactUpdated ( item ); + +} + +void JabberClient::slotResourceAvailable ( const Jid &jid, const Resource &resource ) +{ + + emit resourceAvailable ( jid, resource ); + +} + +void JabberClient::slotResourceUnavailable ( const Jid &jid, const Resource &resource ) +{ + + emit resourceUnavailable ( jid, resource ); + +} + +void JabberClient::slotReceivedMessage ( const Message &message ) +{ + + emit messageReceived ( message ); + +} + +void JabberClient::slotGroupChatJoined ( const Jid &jid ) +{ + + emit groupChatJoined ( jid ); + +} + +void JabberClient::slotGroupChatLeft ( const Jid &jid ) +{ + + emit groupChatLeft ( jid ); + +} + +void JabberClient::slotGroupChatPresence ( const Jid &jid, const Status &status) +{ + + emit groupChatPresence ( jid, status ); + +} + +void JabberClient::slotGroupChatError ( const Jid &jid, int error, const QString &reason) +{ + + emit groupChatError ( jid, error, reason ); + +} + +void JabberClient::slotSubscription ( const Jid &jid, const QString &type ) +{ + + emit subscription ( jid, type ); + +} + + +#include "jabberclient.moc" -- cgit v1.2.1