You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdenetwork/kopete/protocols/jabber/jabberclient.cpp

1138 lines
24 KiB

/***************************************************************************
jabberclient.cpp - Generic Jabber Client Class
-------------------
begin : Sat May 25 2005
copyright : (C) 2005 by Till Gerken <till@tantalo.net>
(C) 2006 by Michaël Larouche <michael.larouche@kdemail.net>
Kopete (C) 2001-2006 Kopete developers
<kopete-devel@kde.org>.
***************************************************************************/
/***************************************************************************
* *
* 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 <tqtimer.h>
#include <tqregexp.h>
#include <qca.h>
#include <bsocket.h>
#include <filetransfer.h>
#include <xmpp_tasks.h>
#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;
TQString 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 TQStringList s5bAddressList;
// port of S5B server
static int s5bServerPort;
// local IP address
TQString 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;
TQString server;
int port;
// allow transmission of plaintext passwords
bool allowPlainTextPassword;
// enable file transfers
bool fileTransfersEnabled;
// current penalty time
int currentPenaltyTime;
// client information
TQString clientName, clientVersion, osName;
// timezone information
TQString timeZoneName;
int timeZoneOffset;
// Caps(JEP-0115: Entity Capabilities) information
TQString capsNode, capsVersion;
DiscoItem::Identity discoIdentity;
};
XMPP::S5BServer *JabberClient::Private::s5bServer = 0L;
TQStringList JabberClient::Private::s5bAddressList;
int JabberClient::Private::s5bServerPort = 8010;
JabberClient::JabberClient ()
{
d = new Private();
cleanUp ();
// initiate penalty timer
TQTimer::singleShot ( JABBER_PENALTY_TIME * 1000, this, TQT_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 = TQString::null;
setForceTLS ( false );
setUseSSL ( false );
setUseXMPP09 ( false );
setProbeSSL ( false );
setOverrideHost ( false );
setAllowPlainTextPassword ( true );
setFileTransfersEnabled ( false );
setS5BServerPort ( 8010 );
setClientName ( TQString::null );
setClientVersion ( TQString::null );
setOSName ( TQString::null );
setTimeZone ( "UTC", 0 );
setIgnoreTLSWarnings ( false );
}
void JabberClient::slotUpdatePenaltyTime ()
{
if ( d->currentPenaltyTime >= JABBER_PENALTY_TIME )
d->currentPenaltyTime -= JABBER_PENALTY_TIME;
else
d->currentPenaltyTime = 0;
TQTimer::singleShot ( JABBER_PENALTY_TIME * 1000, this, TQT_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 ();
TQObject::connect ( d->s5bServer, TQT_SIGNAL ( destroyed () ), this, TQT_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 TQString &address )
{
TQStringList newList;
d->s5bAddressList.append ( address );
// now filter the list without dupes
for ( TQStringList::Iterator it = d->s5bAddressList.begin (); it != d->s5bAddressList.end (); ++it )
{
if ( !newList.contains ( *it ) )
newList.append ( *it );
}
s5bServer()->setHostList ( newList );
}
void JabberClient::removeS5BServerAddress ( const TQString &address )
{
TQStringList newList;
TQStringList::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 ( TQStringList::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 TQString &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 TQString &localAddress )
{
d->fileTransfersEnabled = flag;
d->localAddress = localAddress;
}
TQString JabberClient::localAddress () const
{
return d->localAddress;
}
bool JabberClient::fileTransfersEnabled () const
{
return d->fileTransfersEnabled;
}
void JabberClient::setClientName ( const TQString &clientName )
{
d->clientName = clientName;
}
TQString JabberClient::clientName () const
{
return d->clientName;
}
void JabberClient::setClientVersion ( const TQString &clientVersion )
{
d->clientVersion = clientVersion;
}
TQString JabberClient::clientVersion () const
{
return d->clientVersion;
}
void JabberClient::setOSName ( const TQString &osName )
{
d->osName = osName;
}
TQString JabberClient::osName () const
{
return d->osName;
}
void JabberClient::setCapsNode( const TQString &capsNode )
{
d->capsNode = capsNode;
}
TQString JabberClient::capsNode() const
{
return d->capsNode;
}
void JabberClient::setCapsVersion( const TQString &capsVersion )
{
d->capsVersion = capsVersion;
}
TQString JabberClient::capsVersion() const
{
return d->capsVersion;
}
TQString JabberClient::capsExt() const
{
if(d->jabberClient)
{
return d->jabberClient->capsExt();
}
return TQString();
}
void JabberClient::setDiscoIdentity( DiscoItem::Identity identity )
{
d->discoIdentity = identity;
}
DiscoItem::Identity JabberClient::discoIdentity() const
{
return d->discoIdentity;
}
void JabberClient::setTimeZone ( const TQString &timeZoneName, int timeZoneOffset )
{
d->timeZoneName = timeZoneName;
d->timeZoneOffset = timeZoneOffset;
}
TQString 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 TQString &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;
TQObject::connect ( d->jabberTLSHandler, TQT_SIGNAL ( tlsHandshaken() ), this, TQT_SLOT ( slotTLSHandshaken () ) );
}
TQPtrList<QCA::Cert> 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;
TQObject::connect ( d->jabberClientStream, TQT_SIGNAL ( needAuthParams(bool, bool, bool) ),
this, TQT_SLOT ( slotCSNeedAuthParams (bool, bool, bool) ) );
TQObject::connect ( d->jabberClientStream, TQT_SIGNAL ( authenticated () ),
this, TQT_SLOT ( slotCSAuthenticated () ) );
TQObject::connect ( d->jabberClientStream, TQT_SIGNAL ( connectionClosed () ),
this, TQT_SLOT ( slotCSDisconnected () ) );
TQObject::connect ( d->jabberClientStream, TQT_SIGNAL ( delayedCloseFinished () ),
this, TQT_SLOT ( slotCSDisconnected () ) );
TQObject::connect ( d->jabberClientStream, TQT_SIGNAL ( warning (int) ),
this, TQT_SLOT ( slotCSWarning (int) ) );
TQObject::connect ( d->jabberClientStream, TQT_SIGNAL ( error (int) ),
this, TQT_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;
TQObject::connect ( d->jabberClient->fileTransferManager(), TQT_SIGNAL ( incomingReady() ),
this, TQT_SLOT ( slotIncomingFileTransfer () ) );
}
}
/* This should only be done here to connect the signals, otherwise it is a
* bad idea.
*/
{
using namespace XMPP;
TQObject::connect ( d->jabberClient, TQT_SIGNAL ( subscription (const Jid &, const TQString &) ),
this, TQT_SLOT ( slotSubscription (const Jid &, const TQString &) ) );
TQObject::connect ( d->jabberClient, TQT_SIGNAL ( rosterRequestFinished ( bool, int, const TQString & ) ),
this, TQT_SLOT ( slotRosterRequestFinished ( bool, int, const TQString & ) ) );
TQObject::connect ( d->jabberClient, TQT_SIGNAL ( rosterItemAdded (const RosterItem &) ),
this, TQT_SLOT ( slotNewContact (const RosterItem &) ) );
TQObject::connect ( d->jabberClient, TQT_SIGNAL ( rosterItemUpdated (const RosterItem &) ),
this, TQT_SLOT ( slotContactUpdated (const RosterItem &) ) );
TQObject::connect ( d->jabberClient, TQT_SIGNAL ( rosterItemRemoved (const RosterItem &) ),
this, TQT_SLOT ( slotContactDeleted (const RosterItem &) ) );
TQObject::connect ( d->jabberClient, TQT_SIGNAL ( resourceAvailable (const Jid &, const Resource &) ),
this, TQT_SLOT ( slotResourceAvailable (const Jid &, const Resource &) ) );
TQObject::connect ( d->jabberClient, TQT_SIGNAL ( resourceUnavailable (const Jid &, const Resource &) ),
this, TQT_SLOT ( slotResourceUnavailable (const Jid &, const Resource &) ) );
TQObject::connect ( d->jabberClient, TQT_SIGNAL ( messageReceived (const Message &) ),
this, TQT_SLOT ( slotReceivedMessage (const Message &) ) );
TQObject::connect ( d->jabberClient, TQT_SIGNAL ( groupChatJoined (const Jid &) ),
this, TQT_SLOT ( slotGroupChatJoined (const Jid &) ) );
TQObject::connect ( d->jabberClient, TQT_SIGNAL ( groupChatLeft (const Jid &) ),
this, TQT_SLOT ( slotGroupChatLeft (const Jid &) ) );
TQObject::connect ( d->jabberClient, TQT_SIGNAL ( groupChatPresence (const Jid &, const Status &) ),
this, TQT_SLOT ( slotGroupChatPresence (const Jid &, const Status &) ) );
TQObject::connect ( d->jabberClient, TQT_SIGNAL ( groupChatError (const Jid &, int, const TQString &) ),
this, TQT_SLOT ( slotGroupChatError (const Jid &, int, const TQString &) ) );
//TQObject::connect ( d->jabberClient, TQT_SIGNAL (debugText (const TQString &) ),
// this, TQT_SLOT ( slotPsiDebug (const TQString &) ) );
TQObject::connect ( d->jabberClient, TQT_SIGNAL ( xmlIncoming(const TQString& ) ),
this, TQT_SLOT ( slotIncomingXML (const TQString &) ) );
TQObject::connect ( d->jabberClient, TQT_SIGNAL ( xmlOutgoing(const TQString& ) ),
this, TQT_SLOT ( slotOutgoingXML (const TQString &) ) );
}
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 TQString &host, const TQString &room, const TQString &nick )
{
client()->groupChatJoin ( host, room, nick );
}
void JabberClient::joinGroupChat ( const TQString &host, const TQString &room, const TQString &nick, const TQString &password )
{
client()->groupChatJoin ( host, room, nick, password );
}
void JabberClient::leaveGroupChat ( const TQString &host, const TQString &room )
{
client()->groupChatLeave ( host, room );
}
void JabberClient::setGroupChatStatus( const TQString & host, const TQString & room, const XMPP::Status & status )
{
client()->groupChatSetStatus( host, room, status);
}
void JabberClient::changeGroupChatNick( const TQString & host, const TQString & room, const TQString & 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 TQString &packet )
{
client()->send ( packet );
}
void JabberClient::requestRoster ()
{
client()->rosterRequest ();
}
void JabberClient::slotPsiDebug ( const TQString & _msg )
{
TQString msg = _msg;
msg = msg.replace( TQRegExp( "<password>[^<]*</password>\n" ), "<password>[Filtered]</password>\n" );
msg = msg.replace( TQRegExp( "<digest>[^<]*</digest>\n" ), "<digest>[Filtered]</digest>\n" );
emit debugMessage ( "Psi: " + msg );
}
void JabberClient::slotIncomingXML ( const TQString & _msg )
{
TQString msg = _msg;
msg = msg.replace( TQRegExp( "<password>[^<]*</password>\n" ), "<password>[Filtered]</password>\n" );
msg = msg.replace( TQRegExp( "<digest>[^<]*</digest>\n" ), "<digest>[Filtered]</digest>\n" );
emit debugMessage ( "XML IN: " + msg );
}
void JabberClient::slotOutgoingXML ( const TQString & _msg )
{
TQString msg = _msg;
msg = msg.replace( TQRegExp( "<password>[^<]*</password>\n" ), "<password>[Filtered]</password>\n" );
msg = msg.replace( TQRegExp( "<digest>[^<]*</digest>\n" ), "<digest>[Filtered]</digest>\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<JabberByteStream*>(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 TQString &/*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 TQString &reason)
{
emit groupChatError ( jid, error, reason );
}
void JabberClient::slotSubscription ( const Jid &jid, const TQString &type )
{
emit subscription ( jid, type );
}
#include "jabberclient.moc"