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/gadu/gaduaccount.cpp

1262 lines
33 KiB

// -*- Mode: c++-mode; c-basic-offset: 2; indent-tabs-mode: t; tab-width: 2; -*-
//
// Copyright (C) 2003-2004 Grzegorz Jaskiewicz <gj at pointblue.com.pl>
// Copyright (C) 2003 Zack Rusin <zack@kde.org>
//
// gaduaccount.cpp
//
// 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.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA
#include "gaduaccount.h"
#include "gaducontact.h"
#include "gaduprotocol.h"
#include "gaduawayui.h"
#include "gaduaway.h"
#include "gadupubdir.h"
#include "gadudcc.h"
#include "gadudcctransaction.h"
#include "kopetemetacontact.h"
#include "kopetecontactlist.h"
#include "kopetegroup.h"
#include "kopetepassword.h"
#include "kopeteuiglobal.h"
#include "kopeteglobal.h"
#include <kpassdlg.h>
#include <kconfig.h>
#include <kdebug.h>
#include <klocale.h>
#include <kpopupmenu.h>
#include <kmessagebox.h>
#include <knotifyclient.h>
#include <ktempfile.h>
#include <kio/netaccess.h>
#include <tqapplication.h>
#include <tqdialog.h>
#include <tqtimer.h>
#include <tqtextcodec.h>
#include <tqptrlist.h>
#include <tqtextstream.h>
#include <tqhostaddress.h>
#include <netinet/in.h>
class GaduAccountPrivate {
public:
GaduAccountPrivate() {}
GaduSession* session_;
GaduDCC* gaduDcc_;
TQTimer* pingTimer_;
TQTextCodec* textcodec_;
KFileDialog* saveListDialog;
KFileDialog* loadListDialog;
KActionMenu* actionMenu_;
KAction* searchAction;
KAction* listputAction;
KAction* listToFileAction;
KAction* listFromFileAction;
KAction* friendsModeAction;
bool connectWithSSL;
int currentServer;
unsigned int serverIP;
TQString lastDescription;
bool forFriends;
bool ignoreAnons;
TQTimer* exportTimer_;
bool exportUserlist;
KConfigGroup* config;
Kopete::OnlineStatus status;
TQValueList<unsigned int> servers;
KGaduLoginParams loginInfo;
};
// 10s is enough ;p
#define USERLISTEXPORT_TIMEOUT (10*1000)
// FIXME: use dynamic cache please, i consider this as broken resolution of this problem
static const char* const servers_ip[] = {
"217.17.41.85",
"217.17.41.83",
"217.17.41.84",
"217.17.41.86",
"217.17.41.87",
"217.17.41.88",
"217.17.41.92",
"217.17.41.93",
"217.17.45.133",
"217.17.45.143",
"217.17.45.144"
};
#define NUM_SERVERS (sizeof(servers_ip)/sizeof(char*))
GaduAccount::GaduAccount( Kopete::Protocol* tqparent, const TQString& accountID,const char* name )
: Kopete::PasswordedAccount( tqparent, accountID, 0, name )
{
TQHostAddress ip;
p = new GaduAccountPrivate;
p->pingTimer_ = NULL;
p->saveListDialog = NULL;
p->loadListDialog = NULL;
p->forFriends = false;
p->textcodec_ = TQTextCodec::codecForName( "CP1250" );
p->session_ = new GaduSession( this, "GaduSession" );
KGlobal::config()->setGroup( "Gadu" );
setMyself( new GaduContact( accountId().toInt(), accountId(), this, Kopete::ContactList::self()->myself() ) );
p->status = GaduProtocol::protocol()->converttqStatus( GG_STATUS_NOT_AVAIL );
p->lastDescription = TQString();
for ( unsigned int i = 0; i < NUM_SERVERS ; i++ ) {
ip.setAddress( TQString( servers_ip[i] ) );
p->servers.append( htonl( ip.toIPv4Address() ) );
kdDebug( 14100 ) << "adding IP: " << p->servers[ i ] << " to cache" << endl;
}
p->currentServer = -1;
p->serverIP = 0;
// initialize KGaduLogin structure to default values
p->loginInfo.uin = accountId().toInt();
p->loginInfo.useTls = false;
p->loginInfo.status = GG_STATUS_AVAIL;
p->loginInfo.server = 0;
p->loginInfo.client_port = 0;
p->loginInfo.client_addr = 0;
p->pingTimer_ = new TQTimer( this );
p->exportTimer_ = new TQTimer( this );
p->exportUserlist = false;
p->gaduDcc_ = NULL;
p->config = configGroup();
p->ignoreAnons = ignoreAnons();
p->forFriends = loadFriendsMode();
initConnections();
initActions();
TQString nick = p->config->readEntry( TQString::fromAscii( "nickName" ) );
if ( !nick.isNull() ) {
myself()->setProperty( Kopete::Global::Properties::self()->nickName(), nick );
}
else {
myself()->setProperty( Kopete::Global::Properties::self()->nickName(), accountId() );
p->config->writeEntry( TQString::fromAscii( "nickName" ), accountId() );
}
}
GaduAccount::~GaduAccount()
{
delete p;
}
void
GaduAccount::initActions()
{
p->searchAction = new KAction( i18n( "&Search for Friends" ), "", 0,
this, TQT_SLOT( slotSearch() ), this, "actionSearch" );
p->listputAction = new KAction( i18n( "Export Contacts to Server" ), "", 0,
this, TQT_SLOT( slotExportContactsList() ), this, "actionListput" );
p->listToFileAction = new KAction( i18n( "Export Contacts to File..." ), "", 0,
this, TQT_SLOT( slotExportContactsListToFile() ), this, "actionListputFile" );
p->listFromFileAction = new KAction( i18n( "Import Contacts From File..." ), "", 0,
this, TQT_SLOT( slotImportContactsFromFile() ), this, "actionListgetFile" );
p->friendsModeAction = new KToggleAction( i18n( "Only for Friends" ), "", 0,
this, TQT_SLOT( slotFriendsMode() ), this,
"actionFriendsMode" );
static_cast<KToggleAction*>(p->friendsModeAction)->setChecked( p->forFriends );
}
void
GaduAccount::initConnections()
{
TQObject::connect( p->session_, TQT_SIGNAL( error( const TQString&, const TQString& ) ),
TQT_SLOT( error( const TQString&, const TQString& ) ) );
TQObject::connect( p->session_, TQT_SIGNAL( messageReceived( KGaduMessage* ) ),
TQT_SLOT( messageReceived( KGaduMessage* ) ) );
TQObject::connect( p->session_, TQT_SIGNAL( contactStatusChanged( KGaduNotify* ) ),
TQT_SLOT( contactStatusChanged( KGaduNotify* ) ) );
TQObject::connect( p->session_, TQT_SIGNAL( connectionFailed( gg_failure_t )),
TQT_SLOT( connectionFailed( gg_failure_t ) ) );
TQObject::connect( p->session_, TQT_SIGNAL( connectionSucceed( ) ),
TQT_SLOT( connectionSucceed( ) ) );
TQObject::connect( p->session_, TQT_SIGNAL( disconnect( Kopete::Account::DisconnectReason ) ),
TQT_SLOT( slotSessionDisconnect( Kopete::Account::DisconnectReason ) ) );
TQObject::connect( p->session_, TQT_SIGNAL( ackReceived( unsigned int ) ),
TQT_SLOT( ackReceived( unsigned int ) ) );
TQObject::connect( p->session_, TQT_SIGNAL( pubDirSearchResult( const SearchResult&, unsigned int ) ),
TQT_SLOT( slotSearchResult( const SearchResult&, unsigned int ) ) );
TQObject::connect( p->session_, TQT_SIGNAL( userListExported() ),
TQT_SLOT( userListExportDone() ) );
TQObject::connect( p->session_, TQT_SIGNAL( userListRecieved( const TQString& ) ),
TQT_SLOT( userlist( const TQString& ) ) );
TQObject::connect( p->session_, TQT_SIGNAL( incomingCtcp( unsigned int ) ),
TQT_SLOT( slotIncomingDcc( unsigned int ) ) );
TQObject::connect( p->pingTimer_, TQT_SIGNAL( timeout() ),
TQT_SLOT( pingServer() ) );
TQObject::connect( p->exportTimer_, TQT_SIGNAL( timeout() ),
TQT_SLOT( slotUserlistSynch() ) );
}
void
GaduAccount::setAway( bool isAway, const TQString& awayMessage )
{
unsigned int currenttqStatus;
if ( isAway ) {
currenttqStatus = ( awayMessage.isEmpty() ) ? GG_STATUS_BUSY : GG_STATUS_BUSY_DESCR;
}
else{
currenttqStatus = ( awayMessage.isEmpty() ) ? GG_STATUS_AVAIL : GG_STATUS_AVAIL_DESCR;
}
changetqStatus( GaduProtocol::protocol()->converttqStatus( currenttqStatus ), awayMessage );
}
KActionMenu*
GaduAccount::actionMenu()
{
kdDebug(14100) << "actionMenu() " << endl;
p->actionMenu_ = new KActionMenu( accountId(), myself()->onlinetqStatus().iconFor( this ), this );
p->actionMenu_->popupMenu()->insertTitle( myself()->onlinetqStatus().iconFor( myself() ), i18n( "%1 <%2> " ).
arg( myself()->property( Kopete::Global::Properties::self()->nickName()).value().toString(), accountId() ) );
if ( p->session_->isConnected() ) {
p->searchAction->setEnabled( TRUE );
p->listputAction->setEnabled( TRUE );
p->friendsModeAction->setEnabled( TRUE );
}
else {
p->searchAction->setEnabled( FALSE );
p->listputAction->setEnabled( FALSE );
p->friendsModeAction->setEnabled( FALSE );
}
if ( contacts().count() > 1 ) {
if ( p->saveListDialog ) {
p->listToFileAction->setEnabled( FALSE );
}
else {
p->listToFileAction->setEnabled( TRUE );
}
p->listToFileAction->setEnabled( TRUE );
}
else {
p->listToFileAction->setEnabled( FALSE );
}
if ( p->loadListDialog ) {
p->listFromFileAction->setEnabled( FALSE );
}
else {
p->listFromFileAction->setEnabled( TRUE );
}
p->actionMenu_->insert( new KAction( i18n( "Go O&nline" ),
GaduProtocol::protocol()->converttqStatus( GG_STATUS_AVAIL ).iconFor( this ),
0, this, TQT_SLOT( slotGoOnline() ), this, "actionGaduConnect" ) );
p->actionMenu_->insert( new KAction( i18n( "Set &Busy" ),
GaduProtocol::protocol()->converttqStatus( GG_STATUS_BUSY ).iconFor( this ),
0, this, TQT_SLOT( slotGoBusy() ), this, "actionGaduConnect" ) );
p->actionMenu_->insert( new KAction( i18n( "Set &Invisible" ),
GaduProtocol::protocol()->converttqStatus( GG_STATUS_INVISIBLE ).iconFor( this ),
0, this, TQT_SLOT( slotGoInvisible() ), this, "actionGaduConnect" ) );
p->actionMenu_->insert( new KAction( i18n( "Go &Offline" ),
GaduProtocol::protocol()->converttqStatus( GG_STATUS_NOT_AVAIL ).iconFor( this ),
0, this, TQT_SLOT( slotGoOffline() ), this, "actionGaduConnect" ) );
p->actionMenu_->insert( new KAction( i18n( "Set &Description..." ), "info",
0, this, TQT_SLOT( slotDescription() ), this, "actionGaduDescription" ) );
p->actionMenu_->insert( p->friendsModeAction );
p->actionMenu_->popupMenu()->insertSeparator();
p->actionMenu_->insert( p->searchAction );
p->actionMenu_->popupMenu()->insertSeparator();
p->actionMenu_->insert( p->listputAction );
p->actionMenu_->popupMenu()->insertSeparator();
p->actionMenu_->insert( p->listToFileAction );
p->actionMenu_->insert( p->listFromFileAction );
return p->actionMenu_;
}
void
GaduAccount::connectWithPassword(const TQString& password)
{
if (password.isEmpty()) {
return;
}
if (isConnected ())
return;
// FIXME: add status description to this mechainsm, this is a hack now. libkopete design issue.
changetqStatus( initialtqStatus(), p->lastDescription );
}
void
GaduAccount::disconnect()
{
disconnect( Manual );
}
void
GaduAccount::disconnect( DisconnectReason reason )
{
slotGoOffline();
p->connectWithSSL = true;
Kopete::Account::disconnected( reason );
}
void
GaduAccount::setOnlineStatus( const Kopete::OnlineStatus& status , const TQString &reason )
{
kdDebug(14100) << k_funcinfo << "Called" << endl;
changetqStatus( status, reason);
}
void
GaduAccount::slotUserlistSynch()
{
if ( !p->exportUserlist ) {
return;
}
p->exportUserlist = false;
kdDebug(14100) << "userlist changed, exporting" << endl;
slotExportContactsList();
}
void
GaduAccount::userlistChanged()
{
p->exportUserlist = true;
p->exportTimer_->changeInterval( USERLISTEXPORT_TIMEOUT );
}
bool
GaduAccount::createContact( const TQString& contactId, Kopete::MetaContact* parentContact )
{
kdDebug(14100) << "createContact " << contactId << endl;
uin_t uinNumber = contactId.toUInt();
GaduContact* newContact = new GaduContact( uinNumber, parentContact->displayName(),this, parentContact );
newContact->setParentIdentity( accountId() );
addNotify( uinNumber );
userlistChanged();
return true;
}
void
GaduAccount::changetqStatus( const Kopete::OnlineStatus& status, const TQString& descr )
{
unsigned int ns;
kdDebug(14100) << "##### change status #####" << endl;
kdDebug(14100) << "### tqStatus = " << p->session_->isConnected() << endl;
kdDebug(14100) << "### tqStatus description = \"" << descr << "\"" << endl;
// if change to not available, log off
if ( GG_S_NA( status.internalStatus() ) ) {
if ( !p->session_->isConnected() ) {
return;//already logged off
}
else {
if ( status.internalStatus() == GG_STATUS_NOT_AVAIL_DESCR ) {
if ( p->session_->changeStatusDescription( status.internalStatus(), descr, p->forFriends ) != 0 ) {
return;
}
}
}
p->session_->logoff();
dccOff();
}
else {
// if status is for no desc, but we get some desc, than convert it to status with desc
if (!descr.isEmpty() && !GaduProtocol::protocol()->statusWithDescription( status.internalStatus() ) ) {
// and rerun us again. This won't cause any recursive call, as both conversions are static
ns = GaduProtocol::protocol()->statusToWithDescription( status );
changetqStatus( GaduProtocol::protocol()->converttqStatus( ns ), descr );
return;
}
// well, if it's empty but we want to set status with desc, change it too
if (descr.isEmpty() && GaduProtocol::protocol()->statusWithDescription( status.internalStatus() ) ) {
ns = GaduProtocol::protocol()->statusToWithoutDescription( status );
changetqStatus( GaduProtocol::protocol()->converttqStatus( ns ), descr );
return;
}
if ( !p->session_->isConnected() ) {
if ( password().cachedValue().isEmpty() ) {
// FIXME: when status string added to connect(), use it here
p->lastDescription = descr;
connect( status/*, descr*/ );
return;
}
if ( useTls() != TLS_no ) {
p->connectWithSSL = true;
}
else {
p->connectWithSSL = false;
}
dccOn();
p->serverIP = 0;
p->currentServer = -1;
p->status = status;
kdDebug(14100) << "#### Connecting..., tls option "<< (int)useTls() << " " << endl;
p->lastDescription = descr;
slotLogin( status.internalStatus(), descr );
return;
}
else {
p->status = status;
if ( descr.isEmpty() ) {
if ( p->session_->changetqStatus( status.internalStatus(), p->forFriends ) != 0 )
return;
}
else {
if ( p->session_->changeStatusDescription( status.internalStatus(), descr, p->forFriends ) != 0 )
return;
}
}
}
myself()->setOnlineStatus( status );
myself()->setProperty( GaduProtocol::protocol()->propAwayMessage, descr );
if ( status.internalStatus() == GG_STATUS_NOT_AVAIL || status.internalStatus() == GG_STATUS_NOT_AVAIL_DESCR ) {
if ( p->pingTimer_ ){
p->pingTimer_->stop();
}
}
p->lastDescription = descr;
}
void
GaduAccount::slotLogin( int status, const TQString& dscr )
{
p->lastDescription = dscr;
myself()->setOnlineStatus( GaduProtocol::protocol()->converttqStatus( GG_STATUS_CONNECTING ));
myself()->setProperty( GaduProtocol::protocol()->propAwayMessage, dscr );
if ( !p->session_->isConnected() ) {
if ( password().cachedValue().isEmpty() ) {
connectionFailed( GG_FAILURE_PASSWORD );
}
else {
p->loginInfo.password = password().cachedValue();
p->loginInfo.useTls = p->connectWithSSL;
p->loginInfo.status = status;
p->loginInfo.statusDescr = dscr;
p->loginInfo.forFriends = p->forFriends;
p->loginInfo.server = p->serverIP;
if ( dccEnabled() ) {
p->loginInfo.client_addr = gg_dcc_ip;
p->loginInfo.client_port = gg_dcc_port;
}
else {
p->loginInfo.client_addr = 0;
p->loginInfo.client_port = 0;
}
p->session_->login( &p->loginInfo );
}
}
else {
p->session_->changetqStatus( status );
}
}
void
GaduAccount::slotLogoff()
{
if ( p->session_->isConnected() || p->status == GaduProtocol::protocol()->converttqStatus( GG_STATUS_CONNECTING )) {
p->status = GaduProtocol::protocol()->converttqStatus( GG_STATUS_NOT_AVAIL );
changetqStatus( p->status );
p->session_->logoff();
dccOff();
}
}
void
GaduAccount::slotGoOnline()
{
changetqStatus( GaduProtocol::protocol()->converttqStatus( GG_STATUS_AVAIL ) );
}
void
GaduAccount::slotGoOffline()
{
slotLogoff();
dccOff();
}
void
GaduAccount::slotGoInvisible()
{
changetqStatus( GaduProtocol::protocol()->converttqStatus( GG_STATUS_INVISIBLE ) );
}
void
GaduAccount::slotGoBusy()
{
changetqStatus( GaduProtocol::protocol()->converttqStatus( GG_STATUS_BUSY ) );
}
void
GaduAccount::removeContact( const GaduContact* c )
{
if ( isConnected() ) {
const uin_t u = c->uin();
p->session_->removeNotify( u );
userlistChanged();
}
}
void
GaduAccount::addNotify( uin_t uin )
{
if ( p->session_->isConnected() ) {
p->session_->addNotify( uin );
}
}
void
GaduAccount::notify( uin_t* userlist, int count )
{
if ( p->session_->isConnected() ) {
p->session_->notify( userlist, count );
}
}
void
GaduAccount::sendMessage( uin_t recipient, const Kopete::Message& msg, int msgClass )
{
if ( p->session_->isConnected() ) {
p->session_->sendMessage( recipient, msg, msgClass );
}
}
void
GaduAccount::error( const TQString& title, const TQString& message )
{
KMessageBox::error( Kopete::UI::Global::mainWidget(), title, message );
}
void
GaduAccount::messageReceived( KGaduMessage* gaduMessage )
{
GaduContact* contact = 0;
TQPtrList<Kopete::Contact> contactsListTmp;
// FIXME:check for ignored users list
if ( gaduMessage->sender_id == 0 ) {
//system message, display them or not?
kdDebug(14100) << "####" << " System Message " << gaduMessage->message << endl;
return;
}
contact = static_cast<GaduContact*> ( contacts()[ TQString::number( gaduMessage->sender_id ) ] );
if ( !contact ) {
if ( p->ignoreAnons == true ) {
return;
}
Kopete::MetaContact* metaContact = new Kopete::MetaContact ();
metaContact->setTemporary ( true );
contact = new GaduContact( gaduMessage->sender_id,
TQString::number( gaduMessage->sender_id ), this, metaContact );
Kopete::ContactList::self ()->addMetaContact( metaContact );
addNotify( gaduMessage->sender_id );
}
contactsListTmp.append( myself() );
Kopete::Message msg( gaduMessage->sendTime, contact, contactsListTmp, gaduMessage->message, Kopete::Message::Inbound, Kopete::Message::RichText );
contact->messageReceived( msg );
}
void
GaduAccount::ackReceived( unsigned int recipient )
{
GaduContact* contact;
contact = static_cast<GaduContact*> ( contacts()[ TQString::number( recipient ) ] );
if ( contact ) {
kdDebug(14100) << "####" << "Received an ACK from " << contact->uin() << endl;
contact->messageAck();
}
else {
kdDebug(14100) << "####" << "Received an ACK from an unknown user : " << recipient << endl;
}
}
void
GaduAccount::contactStatusChanged( KGaduNotify* gaduNotify )
{
kdDebug(14100) << "####" << " contact's status changed, uin:" << gaduNotify->contact_id <<endl;
GaduContact* contact;
contact = static_cast<GaduContact*>( contacts()[ TQString::number( gaduNotify->contact_id ) ] );
if( !contact ) {
kdDebug(14100) << "Notify not in the list " << gaduNotify->contact_id << endl;
return;
}
contact->changedtqStatus( gaduNotify );
}
void
GaduAccount::pong()
{
kdDebug(14100) << "####" << " Pong..." << endl;
}
void
GaduAccount::pingServer()
{
kdDebug(14100) << "####" << " Ping..." << endl;
p->session_->ping();
}
void
GaduAccount::connectionFailed( gg_failure_t failure )
{
bool tryReconnect = false;
TQString pass;
switch (failure) {
case GG_FAILURE_PASSWORD:
password().setWrong();
// user pressed CANCEL
p->status = GaduProtocol::protocol()->converttqStatus( GG_STATUS_NOT_AVAIL );
myself()->setOnlineStatus( p->status );
disconnected( BadPassword );
return;
default:
if ( p->connectWithSSL ) {
if ( useTls() != TLS_only ) {
slotCommandDone( TQString(), i18n( "connection using SSL was not possible, retrying without." ) );
kdDebug( 14100 ) << "try without tls now" << endl;
p->connectWithSSL = false;
tryReconnect = true;
p->currentServer = -1;
p->serverIP = 0;
break;
}
}
else {
if ( p->currentServer == NUM_SERVERS - 1 ) {
p->serverIP = 0;
p->currentServer = -1;
kdDebug(14100) << "trying : " << "IP from hub " << endl;
}
else {
p->serverIP = p->servers[ ++p->currentServer ];
kdDebug(14100) << "trying : " << p->currentServer << " IP " << p->serverIP << endl;
tryReconnect = true;
}
}
break;
}
if ( tryReconnect ) {
slotLogin( p->status.internalStatus() , p->lastDescription );
}
else {
error( i18n( "unable to connect to the Gadu-Gadu server(\"%1\")." ).tqarg( GaduSession::failureDescription( failure ) ),
i18n( "Connection Error" ) );
p->status = GaduProtocol::protocol()->converttqStatus( GG_STATUS_NOT_AVAIL );
myself()->setOnlineStatus( p->status );
disconnected( InvalidHost );
}
}
void
GaduAccount::dccOn()
{
if ( dccEnabled() ) {
if ( !p->gaduDcc_ ) {
p->gaduDcc_ = new GaduDCC( this );
}
kdDebug( 14100 ) << " turn DCC on for " << accountId() << endl;
p->gaduDcc_->registerAccount( this );
p->loginInfo.client_port = p->gaduDcc_->listeingPort();
}
}
void
GaduAccount::dccOff()
{
if ( p->gaduDcc_ ) {
kdDebug( 14100 ) << "destroying dcc in gaduaccount " << endl;
delete p->gaduDcc_;
p->gaduDcc_ = NULL;
p->loginInfo.client_port = 0;
p->loginInfo.client_addr = 0;
}
}
void
GaduAccount::slotIncomingDcc( unsigned int uin )
{
GaduContact* contact;
GaduDCCTransaction* trans;
if ( !uin ) {
return;
}
contact = static_cast<GaduContact*>( contacts()[ TQString::number( uin ) ] );
if ( !contact ) {
kdDebug(14100) << "attempt to make dcc connection from unknown uin " << uin << endl;
return;
}
// if incapabile to transfer files, forget about it.
if ( contact->contactPort() < 10 ) {
kdDebug(14100) << "can't respond to " << uin << " request, his listeing port is too low" << endl;
return;
}
trans = new GaduDCCTransaction( p->gaduDcc_ );
if ( trans->setupIncoming( p->loginInfo.uin, contact ) == false ) {
delete trans;
}
}
void
GaduAccount::connectionSucceed( )
{
kdDebug(14100) << "#### Gadu-Gadu connected! " << endl;
p->status = GaduProtocol::protocol()->converttqStatus( p->session_->status() );
myself()->setOnlineStatus( p->status );
myself()->setProperty( GaduProtocol::protocol()->propAwayMessage, p->lastDescription );
startNotify();
p->session_->requestContacts();
p->pingTimer_->start( 3*60*1000 );//3 minute timeout
pingServer();
// check if we need to export userlist every USERLISTEXPORT_TIMEOUT ms
p->exportTimer_->start( USERLISTEXPORT_TIMEOUT );
}
void
GaduAccount::startNotify()
{
int i = 0;
if ( !contacts().count() ) {
return;
}
TQDictIterator<Kopete::Contact> kopeteContactsList( contacts() );
uin_t* userlist = 0;
userlist = new uin_t[ contacts().count() ];
for( i=0 ; kopeteContactsList.current() ; ++kopeteContactsList ) {
userlist[i++] = static_cast<GaduContact*> ((*kopeteContactsList))->uin();
}
p->session_->notify( userlist, contacts().count() );
delete [] userlist;
}
void
GaduAccount::slotSessionDisconnect( Kopete::Account::DisconnectReason reason )
{
uin_t status;
kdDebug(14100) << "Disconnecting" << endl;
if (p->pingTimer_) {
p->pingTimer_->stop();
}
setAllContactstqStatus( GaduProtocol::protocol()->converttqStatus( GG_STATUS_NOT_AVAIL ) );
status = myself()->onlinetqStatus().internalStatus();
if ( status != GG_STATUS_NOT_AVAIL || status != GG_STATUS_NOT_AVAIL_DESCR ) {
myself()->setOnlineStatus( GaduProtocol::protocol()->converttqStatus( GG_STATUS_NOT_AVAIL ) );
}
GaduAccount::disconnect( reason );
}
void
GaduAccount::userlist( const TQString& contactsListString )
{
kdDebug(14100)<<"### Got userlist - gadu account"<<endl;
GaduContactsList contactsList( contactsListString );
TQString contactName;
TQStringList groups;
GaduContact* contact;
Kopete::MetaContact* metaContact;
unsigned int i;
// don't export any new changes that were just imported :-)
p->exportTimer_->stop();
for ( i = 0; i != contactsList.size() ; i++ ) {
kdDebug(14100) << "uin " << contactsList[i].uin << endl;
if ( contactsList[i].uin.isNull() ) {
kdDebug(14100) << "no Uin, strange.. "<<endl;
continue;
}
if ( contacts()[ contactsList[i].uin ] ) {
kdDebug(14100) << "UIN already exists in contacts "<< contactsList[i].uin << endl;
}
else {
contactName = GaduContact::findBestContactName( &contactsList[i] );
bool s = addContact( contactsList[i].uin, contactName, 0L, Kopete::Account::DontChangeKABC);
if ( s == false ) {
kdDebug(14100) << "There was a problem adding UIN "<< contactsList[i].uin << "to users list" << endl;
continue;
}
}
contact = static_cast<GaduContact*>( contacts()[ contactsList[i].uin ] );
if ( contact == NULL ) {
kdDebug(14100) << "oops, no Kopete::Contact in contacts()[] for some reason, for \"" << contactsList[i].uin << "\"" << endl;
continue;
}
// update/add infor for contact
contact->setContactDetails( &contactsList[i] );
if ( !( contactsList[i].group.isEmpty() ) ) {
// FIXME: libkopete bug i guess, by default contact goes to top level group
// if user desrired to see contact somewhere else, remove it from top level one
metaContact = contact->metaContact();
metaContact->removeFromGroup( Kopete::Group::topLevel() );
// put him in all desired groups:
groups = TQStringList::split( ",", contactsList[i].group );
for ( TQStringList::Iterator groupsIterator = groups.begin(); groupsIterator != groups.end(); ++groupsIterator ) {
metaContact->addToGroup( Kopete::ContactList::self ()->findGroup ( *groupsIterator) );
}
}
}
// start to check if we need to export userlist
p->exportUserlist = false;
p->exportTimer_->start( USERLISTEXPORT_TIMEOUT );
}
void
GaduAccount::userListExportDone()
{
slotCommandDone( TQString(), i18n( "Contacts exported to the server.") );
}
void
GaduAccount::slotFriendsMode()
{
p->forFriends = !p->forFriends;
kdDebug( 14100 ) << "for friends mode: " << p->forFriends << " desc" << p->lastDescription << endl;
// now change status, it will changing it with p->forFriends flag
changetqStatus( p->status, p->lastDescription );
saveFriendsMode( p->forFriends );
}
// FIXME: make loading and saving nonblocking (at the moment KFileDialog stops plugin/kopete)
void
GaduAccount::slotExportContactsListToFile()
{
KTempFile tempFile;
tempFile.setAutoDelete( true );
if ( p->saveListDialog ) {
kdDebug( 14100 ) << " save contacts to file: alread waiting for input " << endl ;
return;
}
p->saveListDialog = new KFileDialog( "::kopete-gadu" + accountId(), TQString(),
Kopete::UI::Global::mainWidget(), "gadu-list-save", false );
p->saveListDialog->setCaption(
i18n("Save Contacts List for Account %1 As").tqarg(
myself()->property( Kopete::Global::Properties::self()->nickName()).value().toString() ) );
if ( p->saveListDialog->exec() == TQDialog::Accepted ) {
TQCString list = p->textcodec_->fromUnicode( userlist()->asString() );
if ( tempFile.status() ) {
// say cheese, can't create file.....
error( i18n( "Unable to create temporary file." ), i18n( "Save Contacts List Failed" ) );
}
else {
TQTextStream* tempStream = tempFile.textStream();
(*tempStream) << list.data();
tempFile.close();
bool res = KIO::NetAccess::upload(
tempFile.name() ,
p->saveListDialog->selectedURL() ,
Kopete::UI::Global::mainWidget()
);
if ( !res ) {
// say it failed
error( KIO::NetAccess::lastErrorString(), i18n( "Save Contacts List Failed" ) );
}
}
}
delete p->saveListDialog;
p->saveListDialog = NULL;
}
void
GaduAccount::slotImportContactsFromFile()
{
KURL url;
TQCString list;
TQString oname;
if ( p->loadListDialog ) {
kdDebug( 14100 ) << "load contacts from file: alread waiting for input " << endl ;
return;
}
p->loadListDialog = new KFileDialog( "::kopete-gadu" + accountId(), TQString(),
Kopete::UI::Global::mainWidget(), "gadu-list-load", true );
p->loadListDialog->setCaption(
i18n("Load Contacts List for Account %1 As").tqarg(
myself()->property( Kopete::Global::Properties::self()->nickName()).value().toString() ) );
if ( p->loadListDialog->exec() == TQDialog::Accepted ) {
url = p->loadListDialog->selectedURL();
kdDebug(14100) << "a:" << url << "\nb:" << oname << endl;
if ( KIO::NetAccess::download( url, oname, Kopete::UI::Global::mainWidget() ) ) {
TQFile tempFile( oname );
if ( tempFile.open( IO_ReadOnly ) ) {
list = tempFile.readAll();
tempFile.close();
KIO::NetAccess::removeTempFile( oname );
// and store it
kdDebug( 14100 ) << "loaded list:" << endl;
kdDebug( 14100 ) << list << endl;
kdDebug( 14100 ) << " --------------- " << endl;
userlist( p->textcodec_->toUnicode( list ) );
}
else {
error( tempFile.errorString(),
i18n( "Contacts List Load Has Failed" ) );
}
}
else {
// say, it failed misourably
error( KIO::NetAccess::lastErrorString(),
i18n( "Contacts List Load Has Failed" ) );
}
}
delete p->loadListDialog;
p->loadListDialog = NULL;
}
unsigned int
GaduAccount::getPersonalInformation()
{
return p->session_->getPersonalInformation();
}
bool
GaduAccount::publishPersonalInformation( ResLine& d )
{
return p->session_->publishPersonalInformation( d );
}
void
GaduAccount::slotExportContactsList()
{
p->session_->exportContactsOnServer( userlist() );
}
GaduContactsList*
GaduAccount::userlist()
{
GaduContact* contact;
GaduContactsList* contactsList = new GaduContactsList();
int i;
if ( !contacts().count() ) {
return contactsList;
}
TQDictIterator<Kopete::Contact> contactsIterator( contacts() );
for( i=0 ; contactsIterator.current() ; ++contactsIterator ) {
contact = static_cast<GaduContact*>( *contactsIterator );
if ( contact->uin() != static_cast<GaduContact*>( myself() )->uin() ) {
contactsList->addContact( *contact->contactDetails() );
}
}
return contactsList;
}
void
GaduAccount::slotSearch( int uin )
{
new GaduPublicDir( this, uin );
}
void
GaduAccount::slotChangePassword()
{
}
void
GaduAccount::slotCommandDone( const TQString& /*title*/, const TQString& what )
{
//FIXME: any chance to have my own title in event popup ?
KNotifyClient::userEvent( 0, what,
KNotifyClient::PassivePopup, KNotifyClient::Notification );
}
void
GaduAccount::slotCommandError(const TQString& title, const TQString& what )
{
error( title, what );
}
void
GaduAccount::slotDescription()
{
GaduAway* away = new GaduAway( this );
if( away->exec() == TQDialog::Accepted ) {
changetqStatus( GaduProtocol::protocol()->converttqStatus( away->status() ),
away->awayText() );
}
delete away;
}
unsigned int
GaduAccount::pubDirSearch( ResLine& query, int ageFrom, int ageTo, bool onlyAlive )
{
return p->session_->pubDirSearch( query, ageFrom, ageTo, onlyAlive );
}
void
GaduAccount::pubDirSearchClose()
{
p->session_->pubDirSearchClose();
}
void
GaduAccount::slotSearchResult( const SearchResult& result, unsigned int seq )
{
emit pubDirSearchResult( result, seq );
}
void
GaduAccount::sendFile( GaduContact* peer, TQString& filePath )
{
GaduDCCTransaction* gtran = new GaduDCCTransaction( p->gaduDcc_ );
gtran->setupOutgoing( peer, filePath );
}
void
GaduAccount::dccRequest( GaduContact* peer )
{
if ( peer && p->session_ ) {
p->session_->dccRequest( peer->uin() );
}
}
// dcc settings
bool
GaduAccount::dccEnabled()
{
TQString s = p->config->readEntry( TQString::fromAscii( "useDcc" ) );
kdDebug( 14100 ) << "dccEnabled: "<< s << endl;
if ( s == TQString::fromAscii( "enabled" ) ) {
return true;
}
return false;
}
bool
GaduAccount::setDcc( bool d )
{
TQString s;
bool f = true;
if ( d == false ) {
dccOff();
s = TQString::fromAscii( "disabled" );
}
else {
s = TQString::fromAscii( "enabled" );
}
p->config->writeEntry( TQString::fromAscii( "useDcc" ), s );
if ( p->session_->isConnected() && d ) {
dccOn();
}
kdDebug( 14100 ) << "s: "<<s<<endl;
return f;
}
void
GaduAccount::saveFriendsMode( bool i )
{
p->config->writeEntry( TQString(TQString::fromAscii( "forFriends" )),
TQString(i == true ? TQString::fromAscii( "1" ) : TQString::fromAscii( "0" ) ));
}
bool
GaduAccount::loadFriendsMode()
{
TQString s;
bool r;
int n;
s = p->config->readEntry( TQString::fromAscii( "forFriends" ) );
n = s.toInt( &r );
if ( n ) {
return true;
}
return false;
}
// might be bit inconsistent with what I used in DCC, but hell, it is so much easier to parse :-)
bool
GaduAccount::ignoreAnons()
{
TQString s;
bool r;
int n;
s = p->config->readEntry( TQString::fromAscii( "ignoreAnons" ) );
n = s.toInt( &r );
if ( n ) {
return true;
}
return false;
}
void
GaduAccount::setIgnoreAnons( bool i )
{
p->ignoreAnons = i;
p->config->writeEntry( TQString(TQString::fromAscii( "ignoreAnons" )),
TQString(i == true ? TQString::fromAscii( "1" ) : TQString::fromAscii( "0" ) ));
}
GaduAccount::tlsConnection
GaduAccount::useTls()
{
TQString s;
bool c;
unsigned int oldC;
tlsConnection Tls;
s = p->config->readEntry( TQString::fromAscii( "useEncryptedConnection" ) );
oldC = s.toUInt( &c );
// we have old format
if ( c ) {
kdDebug( 14100 ) << "old format for param useEncryptedConnection, value " <<
oldC << " willl be converted to new string value" << endl;
setUseTls( (tlsConnection) oldC );
// should be string now, unless there was an error reading
s = p->config->readEntry( TQString::fromAscii( "useEncryptedConnection" ) );
kdDebug( 14100 ) << "new useEncryptedConnection value : " << s << endl;
}
Tls = TLS_no;
if ( s == "TLS_ifAvaliable" ) {
Tls = TLS_ifAvaliable;
}
if ( s == "TLS_only" ) {
Tls = TLS_only;
}
return Tls;
}
void
GaduAccount::setUseTls( tlsConnection ut )
{
TQString s;
switch( ut ) {
case TLS_ifAvaliable:
s = "TLS_ifAvaliable";
break;
case TLS_only:
s = "TLS_only";
break;
default:
case TLS_no:
s = "TLS_no";
break;
}
p->config->writeEntry( TQString::fromAscii( "useEncryptedConnection" ), s );
}
#include "gaduaccount.moc"