summaryrefslogtreecommitdiffstats
path: root/korn/kio.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit460c52653ab0dcca6f19a4f492ed2c5e4e963ab0 (patch)
tree67208f7c145782a7e90b123b982ca78d88cc2c87 /korn/kio.cpp
downloadtdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.tar.gz
tdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.zip
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/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'korn/kio.cpp')
-rw-r--r--korn/kio.cpp561
1 files changed, 561 insertions, 0 deletions
diff --git a/korn/kio.cpp b/korn/kio.cpp
new file mode 100644
index 000000000..4677c81cf
--- /dev/null
+++ b/korn/kio.cpp
@@ -0,0 +1,561 @@
+/*
+ * Copyright (C) Sirtaj Singh Kang
+ * Copyright (C) Kurt Granroth
+ * Copyright (C) 2004, Mart Kelder (mart.kde@hccnet.nl)
+ *
+ * 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
+ */
+
+/*
+ * kio.cpp -- Implementation of class KKIODrop.
+ * It is copyied from imap.cpp, with was writed by:
+ * Author: Kurt Granroth
+ * Version: $Id$
+ * Changed by:
+ * Mart Kelder <mart.kde@hccnet.nl>, 2004
+ */
+
+#include "kio.h"
+#include "kio_count.h"
+#include "kio_subjects.h"
+#include "kio_read.h"
+#include "kio_delete.h"
+#include "protocol.h"
+#include "protocols.h"
+#include "stringid.h"
+#include"utils.h"
+//#include"kiocfg.h"
+//#include"dropdlg.h"
+#include "mailsubject.h"
+
+#include<kconfig.h>
+#include<kconfigbase.h>
+#include<kdebug.h>
+#include<klocale.h>
+#include<kprocess.h>
+
+#include<qptrlist.h>
+#include<qregexp.h>
+#include<qvaluelist.h>
+#include<qvaluevector.h>
+
+#include<assert.h>
+#include<ctype.h>
+#include<stdio.h>
+#include<stdlib.h>
+
+//Headers of protocols
+#include"kio_proto.h"
+//#include"pop3_proto.h"
+//#include"pop3s_proto.h"
+//#include"imap_proto.h"
+//#include"imaps_proto.h"
+//#include"nntp_proto.h"
+//#include"maildir_proto.h"
+//#include"qmail_proto.h"
+//#include"process_proto.h"
+#include"mbox_proto.h"
+
+/*
+ * The 'process' maildrop is a lot different than the other protocols:
+ * it haven't a kioslave and could not result in file list. To prevent
+ * trowing it away, that functionality is hacked in this file.
+ */
+
+KKioDrop::KKioDrop()
+ : KPollableDrop(),
+ _kurl( 0 ),
+ _metadata( 0 ),
+ _valid(false),
+ _protocol( 0 ),
+ _ssl(false),
+ _count( 0 ),
+ _subjects( 0 ),
+ _read( 0 ),
+ _readSubjectsTotalSteps( 0 ),
+ _deleteMailsTotalSteps( 0 ),
+ _process( 0 ),
+ _mailurls( 0 )
+{
+ _kurl = new KURL;
+ _metadata = new KIO::MetaData;
+
+ //Initialising protocol; if no protocol is set before first use, it will use the first protocol
+ _protocol = Protocols::firstProtocol()->getKIOProtocol(); //The first protocol is the default
+ _kurl->setPort( _protocol->defaultPort( _ssl ) );
+
+ //Creating children and connect them to the outside world; this class passes the messages for them...
+ //This class handles all the counting.
+ _count = new KIO_Count( this, "kio_count" );
+
+ //This class is responsible for providing the available subjects
+ _subjects = new KIO_Subjects( this, "kio_subjects" );
+
+ //This class is used when a full message has to be read.
+ _read = new KIO_Read( this, "kio_read" );
+
+ //This class can delete mails.
+ _delete = new KIO_Delete( this, "kio_delete" );
+
+ _mailurls = new QValueList<FileInfo>;
+}
+
+KKioDrop::KKioDrop( KConfigGroup* )
+ : KPollableDrop(),
+ _kurl( 0 ),
+ _metadata( 0 ),
+ _valid(false),
+ _protocol( 0 ),
+ _ssl(false),
+ _count( 0 ),
+ _subjects( 0 ),
+ _read( 0 ),
+ _readSubjectsTotalSteps( 0 ),
+ _deleteMailsTotalSteps( 0 ),
+ _process( 0 ),
+ _mailurls( 0 )
+{
+ _kurl = new KURL;
+ _metadata = new KIO::MetaData;
+
+ //Initialising protocol; if no protocol is set before first use, it will use the first protocol
+ _protocol = Protocols::firstProtocol()->getKIOProtocol(); //The first protocol is the default
+ _kurl->setPort( _protocol->defaultPort( _ssl ) );
+
+ //Creating children and connect them to the outside world; this class passes the messages for them...
+ //This class handles all the counting.
+ _count = new KIO_Count( this, "kio_count" );
+
+ //This class is responsible for providing the available subjects
+ _subjects = new KIO_Subjects( this, "kio_subjects" );
+
+ //This class is used when a full message has to be read.
+ _read = new KIO_Read( this, "kio_read" );
+
+ //This class can delete mails.
+ _delete = new KIO_Delete( this, "kio_delete" );
+
+ _mailurls = new QValueList<FileInfo>;
+
+ //readConfigGroup( *config );
+}
+
+void KKioDrop::setKioServer( const QString & proto, const QString & server, int port )
+{
+ //Settings default for last vars; could not inline because KIO::MetaData-object is not defined in header.
+ setKioServer( proto, server, port, KIO::MetaData(), false, true );
+}
+
+void KKioDrop::setKioServer(const QString & proto, const QString & server, int port, const KIO::MetaData metadata, bool ssl,
+ bool setProtocol )
+{
+ QString auth;
+
+ if( port == -1 )
+ port = _protocol->defaultPort( ssl );
+
+ if( setProtocol ) //false if _protocol already made
+ {
+ _protocol = Protocols::getProto( proto )->getKIOProtocol();
+
+ if( ! _protocol )
+ _protocol = Protocols::firstProtocol()->getKIOProtocol();
+ }
+
+ _kurl->setProtocol( _protocol->protocol( ssl ) );
+ _kurl->setHost ( server );
+ _kurl->setPort ( port );
+ _ssl = ssl;
+
+ //Checking for authentication-settings.
+ //if( _metadata->contains("auth") )
+ //{
+ // auth = (*_metadata)["auth"];
+ // *_metadata = metadata;
+ // if( ! _metadata->contains("auth") )
+ // (*_metadata)["auth"] = auth;
+ //} else
+ *_metadata = metadata;
+
+ _count->stopActiveCount();
+}
+
+void KKioDrop::setUser(const QString & user, const QString & password,
+ const QString & mailbox, const QString & auth )
+{
+ _kurl->setUser( user );
+ _password = password ;
+ _kurl->setPass( _password );
+ _kurl->setPath( mailbox );
+ if( ! auth.isEmpty() && auth != "Plain" )
+ (*_metadata)["auth"] = auth;
+ else if( _metadata->contains( "auth" ) )
+ _metadata->erase( "auth" );
+
+ _valid = _kurl->isValid();
+ emit validChanged( valid() );
+
+ if( ! _valid )
+ kdWarning() << i18n( "url is not valid" ) << endl;
+
+ _count->stopActiveCount();
+}
+
+QString KKioDrop::protocol() const
+{
+ return _protocol->configName();
+}
+
+QString KKioDrop::server() const
+{
+ return _kurl->host();
+}
+int KKioDrop::port() const
+{
+ return _kurl->port();
+}
+
+QString KKioDrop::user() const
+{
+ return _kurl->user();
+}
+QString KKioDrop::password() const
+{
+ return _password ;
+}
+QString KKioDrop::mailbox() const
+{
+ return _kurl->path();
+}
+QString KKioDrop::auth() const
+{
+ return ( _metadata->contains("auth")?(*_metadata)["auth"]:"" );
+}
+
+void KKioDrop::recheck()
+{
+ if( _protocol->configName() == "process" ) //Process isn't pollable
+ {
+ emit rechecked();
+ return;
+ }
+
+ _count->count( this );
+
+ return;
+}
+
+void KKioDrop::forceRecheck()
+{
+ if( _protocol->configName() == "process" )
+ return;
+
+ _count->stopActiveCount();
+ _count->count( this );
+
+ return;
+}
+
+bool KKioDrop::valid()
+{
+ return _valid && _count->valid() && _subjects->valid();
+}
+
+KKioDrop::~KKioDrop()
+{
+ delete _count;
+ delete _subjects;
+ delete _kurl;
+ delete _metadata;
+ delete _mailurls;
+}
+
+bool KKioDrop::canReadSubjects( )
+{
+ return (_protocol!=0?_protocol->canReadSubjects():false);
+}
+
+QValueVector<KornMailSubject> * KKioDrop::doReadSubjects(bool * )
+{
+ _subjects->doReadSubjects( this );
+
+ /*
+ * A empty QValueVector is made here.
+ * After that, the size is expanded to the expected number of subjects.
+ * This way, reallocation of memmory is minimized, and thus more efficient.
+ */
+ QValueVector<KornMailSubject> *vector = new QValueVector<KornMailSubject>( );
+ vector->reserve( _mailurls->count() );
+ return vector;
+}
+
+bool KKioDrop::canReadMail( )
+{
+ return (_protocol!=0?_protocol->canReadMail():false);
+}
+
+bool KKioDrop::deleteMails(QPtrList<const KornMailId> * ids, bool * /*stop*/)
+{
+ _delete->deleteMails( ids, this );
+ return _delete->valid();
+}
+
+bool KKioDrop::canDeleteMails ()
+{
+ return (_protocol!=0?_protocol->canDeleteMail():false);
+}
+
+QString KKioDrop::readMail(const KornMailId * item, bool * )
+{
+ _read->readMail( item, this );
+
+ return "";
+}
+
+KMailDrop* KKioDrop::clone() const
+{
+ KKioDrop *clone = new KKioDrop;
+
+ *clone = *this;
+
+ return clone;
+}
+
+bool KKioDrop::readConfigGroup( const QMap< QString, QString > &map, const Protocol* protocol )
+{
+ QString val, val2;
+
+ if( !map.contains( "server" ) || !map.contains( "port" ) || !map.contains( "ssl" ) || !map.contains( "username" ) ||
+ !map.contains( "mailbox" ) || !map.contains( "password" ) || !map.contains( "metadata" ) || !map.contains( "name" ) )
+ {
+ kdWarning() << "Bug: map niet compleet" << endl;
+ return false;
+ }
+
+ this->setName( (*map.find( "name" )).utf8() );
+
+ _protocol = protocol->getKIOProtocol();
+ if( !_protocol )
+ _protocol = Protocols::firstProtocol()->getKIOProtocol();
+
+ val = *map.find( "server" );
+ setKioServer( val2, val, (*map.find( "port" )).toInt(), KIO::MetaData(), *map.find( "ssl" ) == "true", false );
+
+ _kurl->setUser( *map.find( "username" ) );
+ _kurl->setPath( *map.find( "mailbox" ) );
+
+ _kurl->setPass( *map.find( "password" ) );
+
+ QStringList list = QStringList::split( ',', *map.find( "metadata" ) );
+ QStringList::Iterator it;
+ for( it = list.begin(); it != list.end(); ++it )
+ {
+ int split = (*it).find( "=" );
+ if( split > 0 )
+ _metadata->insert( (*it).left( split ), (*it).right( (*it).length() - split - 1 ) );
+ }
+
+ _valid = true;
+ emitValidChanged();
+
+ return true;
+}
+
+bool KKioDrop::writeConfigGroup( KConfigBase& cfg ) const
+{
+ KPollableDrop::writeConfigGroup( cfg );
+ /*QString p;
+
+ if( _kurl->hasPass() ) {
+ p = _kurl->pass();
+ //encrypt ( p );
+ }
+
+ cfg.writeEntry(fu(ProtoConfigKey), _protocol->configName() );
+ if( ( _protocol->fields() | _protocol->urlFields() ) & KIO_Protocol::server )
+ cfg.writeEntry(fu(HostConfigKey), _kurl->host() );
+ if( ( _protocol->fields() | _protocol->urlFields() ) & KIO_Protocol::port )
+ cfg.writeEntry(fu(PortConfigKey), _kurl->port() );
+ if( ( _protocol->fields() | _protocol->urlFields() ) & KIO_Protocol::username )
+ cfg.writeEntry(fu(UserConfigKey), _kurl->user() );
+ if( ( _protocol->fields() | _protocol->urlFields() ) & KIO_Protocol::mailbox )
+ cfg.writeEntry(fu(MailboxConfigKey), _kurl->path() );
+ if( ( _protocol->fields() | _protocol->urlFields() ) & KIO_Protocol::password )
+ cfg.writeEntry(fu(PassConfigKey), p );
+ if( ( _protocol->fields() | _protocol->urlFields() ) & KIO_Protocol::auth )
+ cfg.writeEntry(fu(AuthConfigKey), auth() );
+ */
+ return true;
+}
+
+KKioDrop& KKioDrop::operator = ( const KKioDrop& other )
+{
+ *_kurl=*other._kurl;
+ setFreq( other.freq() );
+
+ if( other._protocol )
+ _protocol = other._protocol->getKIOProtocol();
+ _ssl = other._ssl;
+
+ return *this;
+}
+
+//Public slots
+void KKioDrop::readSubjectsCanceled()
+{
+ _subjects->cancelled();
+}
+
+void KKioDrop::readMailCanceled()
+{
+ _read->canceled( );
+}
+
+void KKioDrop::deleteMailsCanceled()
+{
+ _delete->canceled( );
+}
+
+//Private slots for displaying connection errors
+void KKioDrop::slotConnectionError( int number, const QString& arg )
+{
+ kdError() << KIO::buildErrorString( number, arg ) << endl;
+// if( passivePopup() )
+ emitShowPassivePopup( KIO::buildErrorString( number, arg ) );
+}
+
+void KKioDrop::slotConnectionWarning( const QString& msg )
+{
+ kdWarning() << msg << endl;
+}
+
+void KKioDrop::slotConnectionInfoMessage( const QString& msg )
+{
+ kdDebug() << msg << endl; //Display only in debug modes
+}
+
+//Private slots
+
+//The next functions are needed for process maildrops.
+bool KKioDrop::startProcess()
+{ //code copyied from edrop.cpp
+
+ if( _protocol->configName() != "process" )
+ return true;
+
+ if( _process != 0 ) {
+ return false;
+ }
+
+ // debug( "proc start: %s", _command.data() );
+
+ _process = new KProcess;
+ _process->setUseShell( true );
+
+ // only reading stdin yet
+
+ connect( _process,SIGNAL(receivedStdout( KProcess *, char *, int)),
+ this, SLOT(receivedStdout( KProcess *,char *,int)) );
+ connect( _process, SIGNAL(processExited(KProcess*)),
+ this, SLOT(processExit(KProcess*)) );
+ *_process << _kurl->path();
+ _process->start( KProcess::NotifyOnExit, KProcess::Stdout );
+
+ return true;
+}
+
+bool KKioDrop::stopProcess()
+{ //code copied from edrop.cpp
+ if( _protocol->configName() != "process" )
+ return true;
+
+ if( _process != 0 ) {
+ // debug( "proc stop" );
+ _process->kill( SIGHUP );
+ delete _process;
+ _process = 0;
+ }
+
+ return true;
+}
+
+void KKioDrop::receivedStdout( KProcess *proc, char * buffer, int /*len*/ )
+{
+ assert(static_cast<void *>(proc) == static_cast<void *>(_process));
+
+ //Original code
+ /*char *buf = new char[ len + 1 ];
+ memcpy( buf, buffer, len );
+ buf[ len ] = '\0';
+
+ char *ptr = buf, *start = buf;
+ int num = 0;
+
+ while( *ptr ) {
+ // find number
+ while( *ptr && !isdigit( *ptr ) ) {
+ ptr++;
+ }
+ start = ptr;
+ if( *ptr == 0 ) {
+ break;
+ }
+
+ // find end
+ while( *ptr && isdigit( *ptr ) ) {
+ ptr++;
+ }
+
+ // atoi number
+ char back = *ptr;
+ *ptr = 0;
+ num = atoi( start );
+ *ptr = back;
+ }
+
+ emit changed( num );
+ delete [] buf;*/
+
+ //Alternatieve code
+ QString buf = buffer;
+ QRegExp regexp( "^(.*\\D+|\\D*)(\\d+)\\D*$" );
+
+ if( regexp.search( buf ) == 0 )
+ { //Number found
+ emit changed( regexp.cap( 2 ).toInt(), this );
+ }
+
+
+}
+
+void KKioDrop::processExit(KProcess* proc)
+{
+ assert(static_cast<void *>(proc) == static_cast<void *>(_process));
+
+ _process = 0;
+
+// debug( "proc exited" );
+}
+
+const char *KKioDrop::ProtoConfigKey = "protocol";
+const char *KKioDrop::HostConfigKey = "server";
+const char *KKioDrop::PortConfigKey = "port";
+const char *KKioDrop::UserConfigKey = "username";
+const char *KKioDrop::PassConfigKey = "password";
+const char *KKioDrop::MailboxConfigKey = "mailbox";
+const char *KKioDrop::SavePassConfigKey = "savepass";
+const char *KKioDrop::MetadataConfigKey = "metadata";
+
+#include "kio.moc"