diff options
Diffstat (limited to 'kmail/kmfoldercachedimap.cpp')
| -rw-r--r-- | kmail/kmfoldercachedimap.cpp | 2992 |
1 files changed, 2992 insertions, 0 deletions
diff --git a/kmail/kmfoldercachedimap.cpp b/kmail/kmfoldercachedimap.cpp new file mode 100644 index 000000000..405176c4e --- /dev/null +++ b/kmail/kmfoldercachedimap.cpp @@ -0,0 +1,2992 @@ +/** + * kmfoldercachedimap.cpp + * + * Copyright (c) 2002-2004 Bo Thorsen <bo@sonofthor.dk> + * Copyright (c) 2002-2003 Steffen Hansen <steffen@klaralvdalens-datakonsult.se> + * + * 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; version 2 of the License + * + * 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. + * + * In addition, as a special exception, the copyright holders give + * permission to link the code of this program with any edition of + * the Qt library by Trolltech AS, Norway (or with modified versions + * of Qt that use the same license as Qt), and distribute linked + * combinations including the two. You must obey the GNU General + * Public License in all respects for all of the code used other than + * Qt. If you modify this file, you may extend this exception to + * your version of the file, but you are not obligated to do so. If + * you do not wish to do so, delete this exception statement from + * your version. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <errno.h> + +#include <qvaluevector.h> + +#include "kmkernel.h" +#include "kmfoldercachedimap.h" +#include "undostack.h" +#include "kmfoldermgr.h" +#include "kmacctcachedimap.h" +#include "accountmanager.h" +using KMail::AccountManager; +#include "kmailicalifaceimpl.h" +#include "kmfolder.h" +#include "kmglobal.h" +#include "acljobs.h" +#include "broadcaststatus.h" +using KPIM::BroadcastStatus; +#include "progressmanager.h" + +using KMail::CachedImapJob; +#include "imapaccountbase.h" +using KMail::ImapAccountBase; +#include "listjob.h" +using KMail::ListJob; + +#include "kmfolderseldlg.h" +#include "kmcommands.h" +#include "kmmainwidget.h" + +#include <kapplication.h> +#include <kmessagebox.h> +#include <klocale.h> +#include <kdebug.h> +#include <kconfig.h> +#include <kio/global.h> +#include <kio/scheduler.h> +#include <qbuffer.h> +#include <qbuttongroup.h> +#include <qcombobox.h> +#include <qfile.h> +#include <qhbox.h> +#include <qlabel.h> +#include <qlayout.h> +#include <qradiobutton.h> +#include <qvaluelist.h> +#include "annotationjobs.h" +#include "quotajobs.h" +using namespace KMail; +#include <globalsettings.h> + +#define UIDCACHE_VERSION 1 +#define MAIL_LOSS_DEBUGGING 0 + +static QString incidencesForToString( KMFolderCachedImap::IncidencesFor r ) { + switch (r) { + case KMFolderCachedImap::IncForNobody: return "nobody"; + case KMFolderCachedImap::IncForAdmins: return "admins"; + case KMFolderCachedImap::IncForReaders: return "readers"; + } + return QString::null; // can't happen +} + +static KMFolderCachedImap::IncidencesFor incidencesForFromString( const QString& str ) { + if ( str == "nobody" ) return KMFolderCachedImap::IncForNobody; + if ( str == "admins" ) return KMFolderCachedImap::IncForAdmins; + if ( str == "readers" ) return KMFolderCachedImap::IncForReaders; + return KMFolderCachedImap::IncForAdmins; // by default +} + +DImapTroubleShootDialog::DImapTroubleShootDialog( QWidget* parent, + const char* name ) + : KDialogBase( Plain, i18n( "Troubleshooting IMAP Cache" ), + Ok | Cancel, Cancel, parent, name, true ), + rc( None ) +{ + QFrame* page = plainPage(); + QVBoxLayout *topLayout = new QVBoxLayout( page, 0 ); + // spell "lose" correctly. but don't cause a fuzzy. + QString txt = i18n( "<p><b>Troubleshooting the IMAP cache.</b></p>" + "<p>If you have problems with synchronizing an IMAP " + "folder, you should first try rebuilding the index " + "file. This will take some time to rebuild, but will " + "not cause any problems.</p><p>If that is not enough, " + "you can try refreshing the IMAP cache. If you do this, " + "you will loose all your local changes for this folder " + "and all its subfolders.</p>", + "<p><b>Troubleshooting the IMAP cache.</b></p>" + "<p>If you have problems with synchronizing an IMAP " + "folder, you should first try rebuilding the index " + "file. This will take some time to rebuild, but will " + "not cause any problems.</p><p>If that is not enough, " + "you can try refreshing the IMAP cache. If you do this, " + "you will lose all your local changes for this folder " + "and all its subfolders.</p>" ); + topLayout->addWidget( new QLabel( txt, page ) ); + + QButtonGroup *group = new QButtonGroup( 0 ); + + mIndexButton = new QRadioButton( page ); + mIndexButton->setText( i18n( "Rebuild &Index" ) ); + group->insert( mIndexButton ); + topLayout->addWidget( mIndexButton ); + + QHBox *hbox = new QHBox( page ); + QLabel *scopeLabel = new QLabel( i18n( "Scope:" ), hbox ); + scopeLabel->setEnabled( false ); + mIndexScope = new QComboBox( hbox ); + mIndexScope->insertItem( i18n( "Only current folder" ) ); + mIndexScope->insertItem( i18n( "Current folder and all subfolders" ) ); + mIndexScope->insertItem( i18n( "All folders of this account" ) ); + mIndexScope->setEnabled( false ); + topLayout->addWidget( hbox ); + + mCacheButton = new QRadioButton( page ); + mCacheButton->setText( i18n( "Refresh &Cache" ) ); + group->insert( mCacheButton ); + topLayout->addWidget( mCacheButton ); + + enableButtonSeparator( true ); + + connect ( mIndexButton, SIGNAL(toggled(bool)), mIndexScope, SLOT(setEnabled(bool)) ); + connect ( mIndexButton, SIGNAL(toggled(bool)), scopeLabel, SLOT(setEnabled(bool)) ); + + connect( this, SIGNAL( okClicked () ), this, SLOT( slotDone() ) ); +} + +int DImapTroubleShootDialog::run() +{ + DImapTroubleShootDialog d; + d.exec(); + return d.rc; +} + +void DImapTroubleShootDialog::slotDone() +{ + rc = None; + if ( mIndexButton->isOn() ) + rc = mIndexScope->currentItem(); + else if ( mCacheButton->isOn() ) + rc = RefreshCache; + done( Ok ); +} + +KMFolderCachedImap::KMFolderCachedImap( KMFolder* folder, const char* aName ) + : KMFolderMaildir( folder, aName ), + mSyncState( SYNC_STATE_INITIAL ), mContentState( imapNoInformation ), + mSubfolderState( imapNoInformation ), + mIncidencesFor( IncForAdmins ), + mIsSelected( false ), + mCheckFlags( true ), mReadOnly( false ), mAccount( NULL ), uidMapDirty( true ), + uidWriteTimer( -1 ), mLastUid( 0 ), mTentativeHighestUid( 0 ), + mFoundAnIMAPDigest( false ), + mUserRights( 0 ), mOldUserRights( 0 ), mSilentUpload( false ), + /*mHoldSyncs( false ),*/ + mFolderRemoved( false ), + mRecurse( true ), + mStatusChangedLocally( false ), mAnnotationFolderTypeChanged( false ), + mIncidencesForChanged( false ), mPersonalNamespacesCheckDone( true ), + mQuotaInfo(), mAlarmsBlocked( false ), + mRescueCommandCount( 0 ), + mPermanentFlags( 31 ) // assume standard flags by default (see imap4/imapinfo.h for bit fields values) +{ + setUidValidity(""); + // if we fail to read a uid file but there is one, nuke it + if ( readUidCache() == -1 ) { + if ( QFile::exists( uidCacheLocation() ) ) { + KMessageBox::error( 0, + i18n( "The UID cache file for folder %1 could not be read. There " + "could be a problem with file system permission, or it is corrupted." + ).arg( folder->prettyURL() ) ); + // try to unlink it, in case it was corruped. If it couldn't be read + // because of permissions, this will fail, which is fine + unlink( QFile::encodeName( uidCacheLocation() ) ); + } + } + + mProgress = 0; +} + +KMFolderCachedImap::~KMFolderCachedImap() +{ + if (kmkernel->undoStack()) kmkernel->undoStack()->folderDestroyed( folder() ); +} + +void KMFolderCachedImap::reallyDoClose( const char* owner ) +{ + if( !mFolderRemoved ) { + writeUidCache(); + } + KMFolderMaildir::reallyDoClose( owner ); +} + +void KMFolderCachedImap::initializeFrom( KMFolderCachedImap* parent ) +{ + setAccount( parent->account() ); + // Now that we have an account, tell it that this folder was created: + // if this folder was just removed, then we don't really want to remove it from the server. + mAccount->removeDeletedFolder( imapPath() ); + setUserRights( parent->userRights() ); +} + +void KMFolderCachedImap::readConfig() +{ + KConfig* config = KMKernel::config(); + KConfigGroupSaver saver( config, "Folder-" + folder()->idString() ); + if( mImapPath.isEmpty() ) mImapPath = config->readEntry( "ImapPath" ); + if( QString( name() ).upper() == "INBOX" && mImapPath == "/INBOX/" ) + { + folder()->setLabel( i18n( "inbox" ) ); + // for the icon + folder()->setSystemFolder( true ); + } + mNoContent = config->readBoolEntry( "NoContent", false ); + mReadOnly = config->readBoolEntry( "ReadOnly", false ); + if ( !config->readEntry( "FolderAttributes" ).isEmpty() ) + mFolderAttributes = config->readEntry( "FolderAttributes" ); + + if ( mAnnotationFolderType != "FROMSERVER" ) { + mAnnotationFolderType = config->readEntry( "Annotation-FolderType" ); + // if there is an annotation, it has to be XML + if ( !mAnnotationFolderType.isEmpty() && !mAnnotationFolderType.startsWith( "mail" ) ) + kmkernel->iCalIface().setStorageFormat( folder(), KMailICalIfaceImpl::StorageXML ); +// kdDebug(5006) << ( mImapPath.isEmpty() ? label() : mImapPath ) +// << " readConfig: mAnnotationFolderType=" << mAnnotationFolderType << endl; + } + mIncidencesFor = incidencesForFromString( config->readEntry( "IncidencesFor" ) ); + mAlarmsBlocked = config->readBoolEntry( "AlarmsBlocked", false ); +// kdDebug(5006) << ( mImapPath.isEmpty() ? label() : mImapPath ) +// << " readConfig: mIncidencesFor=" << mIncidencesFor << endl; + + mUserRights = config->readNumEntry( "UserRights", 0 ); // default is we don't know + mOldUserRights = mUserRights; + + int storageQuotaUsage = config->readNumEntry( "StorageQuotaUsage", -1 ); + int storageQuotaLimit = config->readNumEntry( "StorageQuotaLimit", -1 ); + QString storageQuotaRoot = config->readEntry( "StorageQuotaRoot", QString::null ); + if ( !storageQuotaRoot.isNull() ) { // isEmpty() means we know there is no quota set + mQuotaInfo.setName( "STORAGE" ); + mQuotaInfo.setRoot( storageQuotaRoot ); + + if ( storageQuotaUsage > -1 ) + mQuotaInfo.setCurrent( storageQuotaUsage ); + if ( storageQuotaLimit > -1 ) + mQuotaInfo.setMax( storageQuotaLimit ); + } + + KMFolderMaildir::readConfig(); + + mStatusChangedLocally = + config->readBoolEntry( "StatusChangedLocally", false ); + + mAnnotationFolderTypeChanged = config->readBoolEntry( "AnnotationFolderTypeChanged", false ); + mIncidencesForChanged = config->readBoolEntry( "IncidencesForChanged", false ); + if ( mImapPath.isEmpty() ) { + mImapPathCreation = config->readEntry("ImapPathCreation"); + } + + QStringList uids = config->readListEntry( "UIDSDeletedSinceLastSync" ); +#if MAIL_LOSS_DEBUGGING + kdDebug( 5006 ) << "READING IN UIDSDeletedSinceLastSync: " << folder()->prettyURL() << endl << uids << endl; +#endif + for ( QStringList::iterator it = uids.begin(); it != uids.end(); it++ ) { + mDeletedUIDsSinceLastSync.insert( (*it).toULong(), 0); + } +} + +void KMFolderCachedImap::writeConfig() +{ + // don't re-write the config of a removed folder, this has just been deleted in + // the folder manager + if ( mFolderRemoved ) + return; + + KConfigGroup configGroup( KMKernel::config(), "Folder-" + folder()->idString() ); + configGroup.writeEntry( "ImapPath", mImapPath ); + configGroup.writeEntry( "NoContent", mNoContent ); + configGroup.writeEntry( "ReadOnly", mReadOnly ); + configGroup.writeEntry( "FolderAttributes", mFolderAttributes ); + configGroup.writeEntry( "StatusChangedLocally", mStatusChangedLocally ); + if ( !mImapPathCreation.isEmpty() ) { + if ( mImapPath.isEmpty() ) { + configGroup.writeEntry( "ImapPathCreation", mImapPathCreation ); + } else { + configGroup.deleteEntry( "ImapPathCreation" ); + } + } + if ( !mDeletedUIDsSinceLastSync.isEmpty() ) { + QValueList<ulong> uids = mDeletedUIDsSinceLastSync.keys(); + QStringList uidstrings; + for( QValueList<ulong>::iterator it = uids.begin(); it != uids.end(); it++ ) { + uidstrings.append( QString::number( (*it) ) ); + } + configGroup.writeEntry( "UIDSDeletedSinceLastSync", uidstrings ); +#if MAIL_LOSS_DEBUGGING + kdDebug( 5006 ) << "WRITING OUT UIDSDeletedSinceLastSync in: " << folder( )->prettyURL( ) << endl << uidstrings << endl; +#endif + } else { + configGroup.deleteEntry( "UIDSDeletedSinceLastSync" ); + } + writeConfigKeysWhichShouldNotGetOverwrittenByReadConfig(); + KMFolderMaildir::writeConfig(); +} + +void KMFolderCachedImap::writeConfigKeysWhichShouldNotGetOverwrittenByReadConfig() +{ + KConfigGroup configGroup( KMKernel::config(), "Folder-" + folder()->idString() ); + if ( !folder()->noContent() ) + { + configGroup.writeEntry( "AnnotationFolderTypeChanged", mAnnotationFolderTypeChanged ); + configGroup.writeEntry( "Annotation-FolderType", mAnnotationFolderType ); + configGroup.writeEntry( "IncidencesForChanged", mIncidencesForChanged ); + configGroup.writeEntry( "IncidencesFor", incidencesForToString( mIncidencesFor ) ); + configGroup.writeEntry( "AlarmsBlocked", mAlarmsBlocked ); + configGroup.writeEntry( "UserRights", mUserRights ); + + configGroup.deleteEntry( "StorageQuotaUsage"); + configGroup.deleteEntry( "StorageQuotaRoot"); + configGroup.deleteEntry( "StorageQuotaLimit"); + + if ( mQuotaInfo.isValid() ) { + if ( mQuotaInfo.current().isValid() ) { + configGroup.writeEntry( "StorageQuotaUsage", mQuotaInfo.current().toInt() ); + } + if ( mQuotaInfo.max().isValid() ) { + configGroup.writeEntry( "StorageQuotaLimit", mQuotaInfo.max().toInt() ); + } + configGroup.writeEntry( "StorageQuotaRoot", mQuotaInfo.root() ); + } + } +} + +int KMFolderCachedImap::create() +{ + int rc = KMFolderMaildir::create(); + // FIXME why the below? - till + readConfig(); + mUnreadMsgs = -1; + return rc; +} + +void KMFolderCachedImap::remove() +{ + mFolderRemoved = true; + + QString part1 = folder()->path() + "/." + dotEscape(name()); + QString uidCacheFile = part1 + ".uidcache"; + // This is the account folder of an account that was just removed + // When this happens, be sure to delete all traces of the cache + if( QFile::exists(uidCacheFile) ) + unlink( QFile::encodeName( uidCacheFile ) ); + + FolderStorage::remove(); +} + +QString KMFolderCachedImap::uidCacheLocation() const +{ + QString sLocation(folder()->path()); + if (!sLocation.isEmpty()) sLocation += '/'; + return sLocation + '.' + dotEscape(fileName()) + ".uidcache"; +} + +int KMFolderCachedImap::readUidCache() +{ + QFile uidcache( uidCacheLocation() ); + if( uidcache.open( IO_ReadOnly ) ) { + char buf[1024]; + int len = uidcache.readLine( buf, sizeof(buf) ); + if( len > 0 ) { + int cacheVersion; + sscanf( buf, "# KMail-UidCache V%d\n", &cacheVersion ); + if( cacheVersion == UIDCACHE_VERSION ) { + len = uidcache.readLine( buf, sizeof(buf) ); + if( len > 0 ) { + setUidValidity( QString::fromLocal8Bit(buf).stripWhiteSpace() ); + len = uidcache.readLine( buf, sizeof(buf) ); + if( len > 0 ) { +#if MAIL_LOSS_DEBUGGING + kdDebug(5006) << "Reading in last uid from cache: " << QString::fromLocal8Bit(buf).stripWhiteSpace() << " in " << folder()->prettyURL() << endl; +#endif + // load the last known highest uid from the on disk cache + setLastUid( QString::fromLocal8Bit(buf).stripWhiteSpace().toULong() ); + return 0; + } + } + } + } + } + return -1; +} + +int KMFolderCachedImap::writeUidCache() +{ + if( uidValidity().isEmpty() || uidValidity() == "INVALID" ) { + // No info from the server yet, remove the file. + if( QFile::exists( uidCacheLocation() ) ) + return unlink( QFile::encodeName( uidCacheLocation() ) ); + return 0; + } +#if MAIL_LOSS_DEBUGGING + kdDebug(5006) << "Writing out UID cache lastuid: " << lastUid() << " in: " << folder()->prettyURL() << endl; +#endif + QFile uidcache( uidCacheLocation() ); + if( uidcache.open( IO_WriteOnly ) ) { + QTextStream str( &uidcache ); + str << "# KMail-UidCache V" << UIDCACHE_VERSION << endl; + str << uidValidity() << endl; + str << lastUid() << endl; + uidcache.flush(); + if ( uidcache.status() == IO_Ok ) { + fsync( uidcache.handle() ); /* this is probably overkill */ + uidcache.close(); + if ( uidcache.status() == IO_Ok ) + return 0; + } + } + KMessageBox::error( 0, + i18n( "The UID cache file for folder %1 could not be written. There " + "could be a problem with file system permission." ).arg( folder()->prettyURL() ) ); + + return -1; +} + +void KMFolderCachedImap::reloadUidMap() +{ + //kdDebug(5006) << "Reloading Uid Map " << endl; + uidMap.clear(); + open("reloadUdi"); + for( int i = 0; i < count(); ++i ) { + KMMsgBase *msg = getMsgBase( i ); + if( !msg ) continue; + ulong uid = msg->UID(); + //kdDebug(5006) << "Inserting: " << i << " with uid: " << uid << endl; + uidMap.insert( uid, i ); + } + close("reloadUdi"); + uidMapDirty = false; +} + +KMMessage* KMFolderCachedImap::take(int idx) +{ + uidMapDirty = true; + rememberDeletion( idx ); + return KMFolderMaildir::take(idx); +} + +void KMFolderCachedImap::takeTemporarily( int idx ) +{ + KMFolderMaildir::take( idx ); +} + +// Add a message without clearing it's X-UID field. +int KMFolderCachedImap::addMsgInternal( KMMessage* msg, bool newMail, + int* index_return ) +{ + // Possible optimization: Only dirty if not filtered below + ulong uid = msg->UID(); + if( uid != 0 ) { + uidMapDirty = true; + } + + KMFolderOpener openThis(folder(), "KMFolderCachedImap::addMsgInternal"); + int rc = openThis.openResult(); + if ( rc ) { + kdDebug(5006) << k_funcinfo << "open: " << rc << " of folder: " << label() << endl; + return rc; + } + + // Add the message + rc = KMFolderMaildir::addMsg(msg, index_return); + + if( newMail && ( imapPath() == "/INBOX/" || ( !GlobalSettings::self()->filterOnlyDIMAPInbox() + && (userRights() <= 0 || userRights() & ACLJobs::Administer ) + && (contentsType() == ContentsTypeMail || GlobalSettings::self()->filterGroupwareFolders()) ) ) ) + // This is a new message. Filter it + mAccount->processNewMsg( msg ); + + return rc; +} + +/* Reimplemented from KMFolderMaildir */ +int KMFolderCachedImap::addMsg(KMMessage* msg, int* index_return) +{ + if ( !canAddMsgNow( msg, index_return ) ) return 0; + // Add it to storage + int rc = KMFolderMaildir::addMsgInternal(msg, index_return, true /*stripUID*/); + return rc; +} + +void KMFolderCachedImap::rememberDeletion( int idx ) +{ + KMMsgBase *msg = getMsgBase( idx ); + assert(msg); + long uid = msg->UID(); + assert(uid>=0); + mDeletedUIDsSinceLastSync.insert(uid, 0); + kdDebug(5006) << "Explicit delete of UID " << uid << " at index: " << idx << " in " << folder()->prettyURL() << endl; +} + +/* Reimplemented from KMFolderMaildir */ +void KMFolderCachedImap::removeMsg(int idx, bool imapQuiet) +{ + uidMapDirty = true; + rememberDeletion( idx ); + // Remove it from disk + KMFolderMaildir::removeMsg(idx,imapQuiet); +} + +bool KMFolderCachedImap::canRemoveFolder() const { + // If this has subfolders it can't be removed + if( folder() && folder()->child() && folder()->child()->count() > 0 ) + return false; + +#if 0 + // No special condition here, so let base class decide + return KMFolderMaildir::canRemoveFolder(); +#endif + return true; +} + +/* Reimplemented from KMFolderDir */ +int KMFolderCachedImap::rename( const QString& aName, + KMFolderDir* /*aParent*/ ) +{ + QString oldName = mAccount->renamedFolder( imapPath() ); + if ( oldName.isEmpty() ) oldName = name(); + if ( aName == oldName ) + // Stupid user trying to rename it to it's old name :) + return 0; + + if( account() == 0 || imapPath().isEmpty() ) { // I don't think any of this can happen anymore + QString err = i18n("You must synchronize with the server before renaming IMAP folders."); + KMessageBox::error( 0, err ); + return -1; + } + + // Make the change appear to the user with setLabel, but we'll do the change + // on the server during the next sync. The name() is the name at the time of + // the last sync. Only rename if the new one is different. If it's the same, + // don't rename, but also make sure the rename is reset, in the case of + // A -> B -> A renames. + if ( name() != aName ) + mAccount->addRenamedFolder( imapPath(), folder()->label(), aName ); + else + mAccount->removeRenamedFolder( imapPath() ); + + folder()->setLabel( aName ); + emit nameChanged(); // for kmailicalifaceimpl + + return 0; +} + +KMFolder* KMFolderCachedImap::trashFolder() const +{ + QString trashStr = account()->trash(); + return kmkernel->dimapFolderMgr()->findIdString( trashStr ); +} + +void KMFolderCachedImap::setLastUid( ulong uid ) +{ +#if MAIL_LOSS_DEBUGGING + kdDebug(5006) << "Setting mLastUid to: " << uid << " in " << folder()->prettyURL() << endl; +#endif + mLastUid = uid; + if( uidWriteTimer == -1 ) + // Write in one minute + uidWriteTimer = startTimer( 60000 ); +} + +void KMFolderCachedImap::timerEvent( QTimerEvent* ) +{ + killTimer( uidWriteTimer ); + uidWriteTimer = -1; + if ( writeUidCache() == -1 ) + unlink( QFile::encodeName( uidCacheLocation() ) ); +} + +ulong KMFolderCachedImap::lastUid() +{ + return mLastUid; +} + +KMMsgBase* KMFolderCachedImap::findByUID( ulong uid ) +{ + bool mapReloaded = false; + if( uidMapDirty ) { + reloadUidMap(); + mapReloaded = true; + } + + QMap<ulong,int>::Iterator it = uidMap.find( uid ); + if( it != uidMap.end() ) { + KMMsgBase *msg = getMsgBase( *it ); +#if MAIL_LOSS_DEBUGGING + kdDebug(5006) << "Folder: " << folder()->prettyURL() << endl; + kdDebug(5006) << "UID " << uid << " is supposed to be in the map" << endl; + kdDebug(5006) << "UID's index is to be " << *it << endl; + kdDebug(5006) << "There is a message there? " << (msg != 0) << endl; + if ( msg ) { + kdDebug(5006) << "Its UID is: " << msg->UID() << endl; + } +#endif + + if( msg && msg->UID() == uid ) + return msg; + kdDebug(5006) << "########## Didn't find uid: " << uid << "in cache athough it's supposed to be there!" << endl; + } else { +#if MAIL_LOSS_DEBUGGING + kdDebug(5006) << "Didn't find uid: " << uid << "in cache!" << endl; +#endif + } + // Not found by now + // if( mapReloaded ) + // Not here then + return 0; + // There could be a problem in the maps. Rebuild them and try again + reloadUidMap(); + it = uidMap.find( uid ); + if( it != uidMap.end() ) + // Since the uid map is just rebuilt, no need for the sanity check + return getMsgBase( *it ); +#if MAIL_LOSS_DEBUGGING + else + kdDebug(5006) << "Reloaded, but stil didn't find uid: " << uid << endl; +#endif + // Then it's not here + return 0; +} + +// This finds and sets the proper account for this folder if it has +// not been done +KMAcctCachedImap *KMFolderCachedImap::account() const +{ + if( (KMAcctCachedImap *)mAccount == 0 && kmkernel && kmkernel->acctMgr() ) { + // Find the account + mAccount = static_cast<KMAcctCachedImap *>( kmkernel->acctMgr()->findByName( name() ) ); + } + + return mAccount; +} + +void KMFolderCachedImap::slotTroubleshoot() +{ + const int rc = DImapTroubleShootDialog::run(); + + if( rc == DImapTroubleShootDialog::RefreshCache ) { + // Refresh cache + if( !account() ) { + KMessageBox::sorry( 0, i18n("No account setup for this folder.\n" + "Please try running a sync before this.") ); + return; + } + QString str = i18n("Are you sure you want to refresh the IMAP cache of " + "the folder %1 and all its subfolders?\nThis will " + "remove all changes you have done locally to your " + "folders.").arg( label() ); + QString s1 = i18n("Refresh IMAP Cache"); + QString s2 = i18n("&Refresh"); + if( KMessageBox::warningContinueCancel( 0, str, s1, s2 ) == + KMessageBox::Continue ) + account()->invalidateIMAPFolders( this ); + } else { + // Rebuild index file + switch ( rc ) { + case DImapTroubleShootDialog::ReindexAll: + { + KMFolderCachedImap *rootStorage = dynamic_cast<KMFolderCachedImap*>( account()->rootFolder() ); + if ( rootStorage ) + rootStorage->createIndexFromContentsRecursive(); + break; + } + case DImapTroubleShootDialog::ReindexCurrent: + createIndexFromContents(); + break; + case DImapTroubleShootDialog::ReindexRecursive: + createIndexFromContentsRecursive(); + break; + default: + return; + } + KMessageBox::information( 0, i18n( "The index of this folder has been " + "recreated." ) ); + writeIndex(); + kmkernel->getKMMainWidget()->folderSelected(); + } +} + +void KMFolderCachedImap::serverSync( bool recurse ) +{ + if( mSyncState != SYNC_STATE_INITIAL ) { + if( KMessageBox::warningYesNo( 0, i18n("Folder %1 is not in initial sync state (state was %2). Do you want to reset it to initial sync state and sync anyway?" ).arg( imapPath() ).arg( mSyncState ), QString::null, i18n("Reset && Sync"), KStdGuiItem::cancel() ) == KMessageBox::Yes ) { + mSyncState = SYNC_STATE_INITIAL; + } else return; + } + + mRecurse = recurse; + assert( account() ); + + ProgressItem *progressItem = mAccount->mailCheckProgressItem(); + if ( progressItem ) { + progressItem->reset(); + progressItem->setTotalItems( 100 ); + } + mProgress = 0; + +#if 0 + if( mHoldSyncs ) { + // All done for this folder. + account()->mailCheckProgressItem()->setProgress( 100 ); + mProgress = 100; // all done + newState( mProgress, i18n("Synchronization skipped")); + mSyncState = SYNC_STATE_INITIAL; + emit folderComplete( this, true ); + return; + } +#endif + mTentativeHighestUid = 0; // reset, last sync could have been canceled + + serverSyncInternal(); +} + +QString KMFolderCachedImap::state2String( int state ) const +{ + switch( state ) { + case SYNC_STATE_INITIAL: return "SYNC_STATE_INITIAL"; + case SYNC_STATE_GET_USERRIGHTS: return "SYNC_STATE_GET_USERRIGHTS"; + case SYNC_STATE_PUT_MESSAGES: return "SYNC_STATE_PUT_MESSAGES"; + case SYNC_STATE_UPLOAD_FLAGS: return "SYNC_STATE_UPLOAD_FLAGS"; + case SYNC_STATE_CREATE_SUBFOLDERS: return "SYNC_STATE_CREATE_SUBFOLDERS"; + case SYNC_STATE_LIST_SUBFOLDERS: return "SYNC_STATE_LIST_SUBFOLDERS"; + case SYNC_STATE_LIST_NAMESPACES: return "SYNC_STATE_LIST_NAMESPACES"; + case SYNC_STATE_LIST_SUBFOLDERS2: return "SYNC_STATE_LIST_SUBFOLDERS2"; + case SYNC_STATE_DELETE_SUBFOLDERS: return "SYNC_STATE_DELETE_SUBFOLDERS"; + case SYNC_STATE_LIST_MESSAGES: return "SYNC_STATE_LIST_MESSAGES"; + case SYNC_STATE_DELETE_MESSAGES: return "SYNC_STATE_DELETE_MESSAGES"; + case SYNC_STATE_GET_MESSAGES: return "SYNC_STATE_GET_MESSAGES"; + case SYNC_STATE_EXPUNGE_MESSAGES: return "SYNC_STATE_EXPUNGE_MESSAGES"; + case SYNC_STATE_HANDLE_INBOX: return "SYNC_STATE_HANDLE_INBOX"; + case SYNC_STATE_TEST_ANNOTATIONS: return "SYNC_STATE_TEST_ANNOTATIONS"; + case SYNC_STATE_GET_ANNOTATIONS: return "SYNC_STATE_GET_ANNOTATIONS"; + case SYNC_STATE_SET_ANNOTATIONS: return "SYNC_STATE_SET_ANNOTATIONS"; + case SYNC_STATE_GET_ACLS: return "SYNC_STATE_GET_ACLS"; + case SYNC_STATE_SET_ACLS: return "SYNC_STATE_SET_ACLS"; + case SYNC_STATE_GET_QUOTA: return "SYNC_STATE_GET_QUOTA"; + case SYNC_STATE_FIND_SUBFOLDERS: return "SYNC_STATE_FIND_SUBFOLDERS"; + case SYNC_STATE_SYNC_SUBFOLDERS: return "SYNC_STATE_SYNC_SUBFOLDERS"; + case SYNC_STATE_RENAME_FOLDER: return "SYNC_STATE_RENAME_FOLDER"; + case SYNC_STATE_CHECK_UIDVALIDITY: return "SYNC_STATE_CHECK_UIDVALIDITY"; + default: return "Unknown state"; + } +} + +/* + Progress calculation: each step is assigned a span. Initially the total is 100. + But if we skip a step, don't increase the progress. + This leaves more room for the step a with variable size (get_messages) + connecting 5 + getuserrights 5 + rename 5 + check_uidvalidity 5 + create_subfolders 5 + put_messages 10 (but it can take a very long time, with many messages....) + upload_flags 5 + list_subfolders 5 + list_subfolders2 0 (all local) + delete_subfolders 5 + list_messages 10 + delete_messages 10 + expunge_messages 5 + get_messages variable (remaining-5) i.e. minimum 15. + check_annotations 0 (rare) + set_annotations 0 (rare) + get_annotations 2 + set_acls 0 (rare) + get_acls 3 + + noContent folders have only a few of the above steps + (permissions, and all subfolder stuff), so its steps should be given more span + + */ + +// While the server synchronization is running, mSyncState will hold +// the state that should be executed next +void KMFolderCachedImap::serverSyncInternal() +{ + // This is used to stop processing when we're about to exit + // and the current job wasn't cancellable. + // For user-requested abort, we'll use signalAbortRequested instead. + if( kmkernel->mailCheckAborted() ) { + resetSyncState(); + emit folderComplete( this, false ); + return; + } + + //kdDebug(5006) << label() << ": " << state2String( mSyncState ) << endl; + switch( mSyncState ) { + case SYNC_STATE_INITIAL: + { + mProgress = 0; + foldersForDeletionOnServer.clear(); + newState( mProgress, i18n("Synchronizing")); + + open("cachedimap"); + if ( !noContent() ) + mAccount->addLastUnreadMsgCount( this, countUnread() ); + + // Connect to the server (i.e. prepare the slave) + ImapAccountBase::ConnectionState cs = mAccount->makeConnection(); + if ( cs == ImapAccountBase::Error ) { + // Cancelled by user, or slave can't start + // kdDebug(5006) << "makeConnection said Error, aborting." << endl; + // We stop here. We're already in SYNC_STATE_INITIAL for the next time. + newState( mProgress, i18n( "Error connecting to server %1" ).arg( mAccount->host() ) ); + close("cachedimap"); + emit folderComplete(this, false); + break; + } else if ( cs == ImapAccountBase::Connecting ) { + mAccount->setAnnotationCheckPassed( false ); + // kdDebug(5006) << "makeConnection said Connecting, waiting for signal." << endl; + newState( mProgress, i18n("Connecting to %1").arg( mAccount->host() ) ); + // We'll wait for the connectionResult signal from the account. + connect( mAccount, SIGNAL( connectionResult(int, const QString&) ), + this, SLOT( slotConnectionResult(int, const QString&) ) ); + break; + } else { + // Connected + // kdDebug(5006) << "makeConnection said Connected, proceeding." << endl; + mSyncState = SYNC_STATE_GET_USERRIGHTS; + // Fall through to next state + } + } + + + case SYNC_STATE_GET_USERRIGHTS: + //kdDebug(5006) << "===== Syncing " << ( mImapPath.isEmpty() ? label() : mImapPath ) << endl; + + mSyncState = SYNC_STATE_RENAME_FOLDER; + + if( !noContent() && mAccount->hasACLSupport() ) { + // Check the user's own rights. We do this every time in case they changed. + mOldUserRights = mUserRights; + newState( mProgress, i18n("Checking permissions")); + connect( mAccount, SIGNAL( receivedUserRights( KMFolder* ) ), + this, SLOT( slotReceivedUserRights( KMFolder* ) ) ); + mAccount->getUserRights( folder(), imapPath() ); // after connecting, due to the INBOX case + break; + } + + case SYNC_STATE_RENAME_FOLDER: + { + mSyncState = SYNC_STATE_CHECK_UIDVALIDITY; + // Returns the new name if the folder was renamed, empty otherwise. + bool isResourceFolder = kmkernel->iCalIface().isStandardResourceFolder( folder() ); + QString newName = mAccount->renamedFolder( imapPath() ); + if ( !newName.isEmpty() && !folder()->isSystemFolder() && !isResourceFolder ) { + newState( mProgress, i18n("Renaming folder") ); + CachedImapJob *job = new CachedImapJob( newName, CachedImapJob::tRenameFolder, this ); + connect( job, SIGNAL( result(KMail::FolderJob *) ), this, SLOT( slotIncreaseProgress() ) ); + connect( job, SIGNAL( finished() ), this, SLOT( serverSyncInternal() ) ); + job->start(); + break; + } + } + + case SYNC_STATE_CHECK_UIDVALIDITY: + mSyncState = SYNC_STATE_CREATE_SUBFOLDERS; + if( !noContent() ) { + checkUidValidity(); + break; + } + // Else carry on + + case SYNC_STATE_CREATE_SUBFOLDERS: + mSyncState = SYNC_STATE_PUT_MESSAGES; + createNewFolders(); + break; + + case SYNC_STATE_PUT_MESSAGES: + mSyncState = SYNC_STATE_UPLOAD_FLAGS; + if( !noContent() ) { + uploadNewMessages(); + break; + } + // Else carry on + case SYNC_STATE_UPLOAD_FLAGS: + mSyncState = SYNC_STATE_LIST_NAMESPACES; + if( !noContent() ) { + // We haven't downloaded messages yet, so we need to build the map. + if( uidMapDirty ) + reloadUidMap(); + // Upload flags, unless we know from the ACL that we're not allowed + // to do that or they did not change locally + if ( mUserRights <= 0 || ( mUserRights & (KMail::ACLJobs::WriteFlags ) ) ) { + if ( mStatusChangedLocally ) { + uploadFlags(); + break; + } else { + //kdDebug(5006) << "Skipping flags upload, folder unchanged: " << label() << endl; + } + } else if ( mUserRights & KMail::ACLJobs::WriteSeenFlag ) { + if ( mStatusChangedLocally ) { + uploadSeenFlags(); + break; + } + } + } + // Else carry on + + case SYNC_STATE_LIST_NAMESPACES: + if ( this == mAccount->rootFolder() ) { + listNamespaces(); + break; + } + mSyncState = SYNC_STATE_LIST_SUBFOLDERS; + // Else carry on + + case SYNC_STATE_LIST_SUBFOLDERS: + newState( mProgress, i18n("Retrieving folderlist")); + mSyncState = SYNC_STATE_LIST_SUBFOLDERS2; + if( !listDirectory() ) { + mSyncState = SYNC_STATE_INITIAL; + KMessageBox::error(0, i18n("Error while retrieving the folderlist")); + } + break; + + case SYNC_STATE_LIST_SUBFOLDERS2: + mSyncState = SYNC_STATE_DELETE_SUBFOLDERS; + mProgress += 10; + newState( mProgress, i18n("Retrieving subfolders")); + listDirectory2(); + break; + + case SYNC_STATE_DELETE_SUBFOLDERS: + mSyncState = SYNC_STATE_LIST_MESSAGES; + if( !foldersForDeletionOnServer.isEmpty() ) { + newState( mProgress, i18n("Deleting folders from server")); + CachedImapJob* job = new CachedImapJob( foldersForDeletionOnServer, + CachedImapJob::tDeleteFolders, this ); + connect( job, SIGNAL( result(KMail::FolderJob *) ), this, SLOT( slotIncreaseProgress() ) ); + connect( job, SIGNAL( finished() ), this, SLOT( slotFolderDeletionOnServerFinished() ) ); + job->start(); + break; + } + // Not needed, the next step emits newState very quick + //newState( mProgress, i18n("No folders to delete from server")); + // Carry on + + case SYNC_STATE_LIST_MESSAGES: + mSyncState = SYNC_STATE_DELETE_MESSAGES; + if( !noContent() ) { + newState( mProgress, i18n("Retrieving message list")); + listMessages(); + break; + } + // Else carry on + + case SYNC_STATE_DELETE_MESSAGES: + mSyncState = SYNC_STATE_EXPUNGE_MESSAGES; + if( !noContent() ) { + if( deleteMessages() ) { + // Fine, we will continue with the next state + } else { + // No messages to delete, skip to GET_MESSAGES + newState( mProgress, i18n("No messages to delete...")); + mSyncState = SYNC_STATE_GET_MESSAGES; + serverSyncInternal(); + } + break; + } + // Else carry on + + case SYNC_STATE_EXPUNGE_MESSAGES: + mSyncState = SYNC_STATE_GET_MESSAGES; + if( !noContent() ) { + newState( mProgress, i18n("Expunging deleted messages")); + CachedImapJob *job = new CachedImapJob( QString::null, + CachedImapJob::tExpungeFolder, this ); + connect( job, SIGNAL( result(KMail::FolderJob *) ), this, SLOT( slotIncreaseProgress() ) ); + connect( job, SIGNAL( finished() ), this, SLOT( serverSyncInternal() ) ); + job->start(); + break; + } + // Else carry on + + case SYNC_STATE_GET_MESSAGES: + mSyncState = SYNC_STATE_HANDLE_INBOX; + if( !noContent() ) { + if( !mMsgsForDownload.isEmpty() ) { + newState( mProgress, i18n("Retrieving new messages")); + CachedImapJob *job = new CachedImapJob( mMsgsForDownload, + CachedImapJob::tGetMessage, + this ); + connect( job, SIGNAL( progress(unsigned long, unsigned long) ), + this, SLOT( slotProgress(unsigned long, unsigned long) ) ); + connect( job, SIGNAL( finished() ), this, SLOT( slotUpdateLastUid() ) ); + connect( job, SIGNAL( finished() ), this, SLOT( serverSyncInternal() ) ); + job->start(); + mMsgsForDownload.clear(); + break; + } else { + newState( mProgress, i18n("No new messages from server")); + /* There were no messages to download, but it could be that we uploaded some + which we didn't need to download again because we already knew the uid. + Now that we are sure there is nothing to download, and everything that had + to be deleted on the server has been deleted, adjust our local notion of the + highes uid seen thus far. */ + slotUpdateLastUid(); + if( mLastUid == 0 && uidWriteTimer == -1 ) { + // This is probably a new and empty folder. Write the UID cache + if ( writeUidCache() == -1 ) { + resetSyncState(); + emit folderComplete( this, false ); + return; + } + } + } + } + + // Else carry on + + case SYNC_STATE_HANDLE_INBOX: + // Wrap up the 'download emails' stage. We always end up at 95 here. + mProgress = 95; + mSyncState = SYNC_STATE_TEST_ANNOTATIONS; + + #define KOLAB_FOLDERTEST "/vendor/kolab/folder-test" + case SYNC_STATE_TEST_ANNOTATIONS: + mSyncState = SYNC_STATE_GET_ANNOTATIONS; + // The first folder with user rights to write annotations + if( !mAccount->annotationCheckPassed() && + ( mUserRights <= 0 || ( mUserRights & ACLJobs::Administer ) ) + && !imapPath().isEmpty() && imapPath() != "/" ) { + kdDebug(5006) << "Setting test attribute on folder: "<< folder()->prettyURL() << endl; + newState( mProgress, i18n("Checking annotation support")); + + KURL url = mAccount->getUrl(); + url.setPath( imapPath() ); + KMail::AnnotationList annotations; // to be set + + KMail::AnnotationAttribute attr( KOLAB_FOLDERTEST, "value.shared", "true" ); + annotations.append( attr ); + + kdDebug(5006) << "Setting test attribute to "<< url << endl; + KIO::Job* job = AnnotationJobs::multiSetAnnotation( mAccount->slave(), + url, annotations ); + ImapAccountBase::jobData jd( url.url(), folder() ); + jd.cancellable = true; // we can always do so later + mAccount->insertJob(job, jd); + connect(job, SIGNAL(result(KIO::Job *)), + SLOT(slotTestAnnotationResult(KIO::Job *))); + break; + } + + case SYNC_STATE_GET_ANNOTATIONS: { +#define KOLAB_FOLDERTYPE "/vendor/kolab/folder-type" +#define KOLAB_INCIDENCESFOR "/vendor/kolab/incidences-for" +//#define KOLAB_FOLDERTYPE "/comment" //for testing, while cyrus-imap doesn't support /vendor/* + mSyncState = SYNC_STATE_SET_ANNOTATIONS; + + bool needToGetInitialAnnotations = false; + if ( !noContent() ) { + // for a folder we didn't create ourselves: get annotation from server + if ( mAnnotationFolderType == "FROMSERVER" ) { + needToGetInitialAnnotations = true; + mAnnotationFolderType = QString::null; + } else { + updateAnnotationFolderType(); + } + } + + // First retrieve the annotation, so that we know we have to set it if it's not set. + // On the other hand, if the user changed the contentstype, there's no need to get first. + if ( !noContent() && mAccount->hasAnnotationSupport() && + ( kmkernel->iCalIface().isEnabled() || needToGetInitialAnnotations ) ) { + QStringList annotations; // list of annotations to be fetched + if ( !mAnnotationFolderTypeChanged || mAnnotationFolderType.isEmpty() ) + annotations << KOLAB_FOLDERTYPE; + if ( !mIncidencesForChanged ) + annotations << KOLAB_INCIDENCESFOR; + if ( !annotations.isEmpty() ) { + newState( mProgress, i18n("Retrieving annotations")); + KURL url = mAccount->getUrl(); + url.setPath( imapPath() ); + AnnotationJobs::MultiGetAnnotationJob* job = + AnnotationJobs::multiGetAnnotation( mAccount->slave(), url, annotations ); + ImapAccountBase::jobData jd( url.url(), folder() ); + jd.cancellable = true; + mAccount->insertJob(job, jd); + + connect( job, SIGNAL(annotationResult(const QString&, const QString&, bool)), + SLOT(slotAnnotationResult(const QString&, const QString&, bool)) ); + connect( job, SIGNAL(result(KIO::Job *)), + SLOT(slotGetAnnotationResult(KIO::Job *)) ); + break; + } + } + } // case + case SYNC_STATE_SET_ANNOTATIONS: + + mSyncState = SYNC_STATE_SET_ACLS; + if ( !noContent() && mAccount->hasAnnotationSupport() && + ( mUserRights <= 0 || ( mUserRights & ACLJobs::Administer ) ) ) { + newState( mProgress, i18n("Setting annotations")); + KURL url = mAccount->getUrl(); + url.setPath( imapPath() ); + KMail::AnnotationList annotations; // to be set + if ( mAnnotationFolderTypeChanged && !mAnnotationFolderType.isEmpty() ) { + KMail::AnnotationAttribute attr( KOLAB_FOLDERTYPE, "value.shared", mAnnotationFolderType ); + annotations.append( attr ); + kdDebug(5006) << "Setting folder-type annotation for " << label() << " to " << mAnnotationFolderType << endl; + } + if ( mIncidencesForChanged ) { + const QString val = incidencesForToString( mIncidencesFor ); + KMail::AnnotationAttribute attr( KOLAB_INCIDENCESFOR, "value.shared", val ); + annotations.append( attr ); + kdDebug(5006) << "Setting incidences-for annotation for " << label() << " to " << val << endl; + } + if ( !annotations.isEmpty() ) { + KIO::Job* job = + AnnotationJobs::multiSetAnnotation( mAccount->slave(), url, annotations ); + ImapAccountBase::jobData jd( url.url(), folder() ); + jd.cancellable = true; // we can always do so later + mAccount->insertJob(job, jd); + + connect(job, SIGNAL(annotationChanged( const QString&, const QString&, const QString& ) ), + SLOT( slotAnnotationChanged( const QString&, const QString&, const QString& ) )); + connect(job, SIGNAL(result(KIO::Job *)), + SLOT(slotSetAnnotationResult(KIO::Job *))); + break; + } + } + + case SYNC_STATE_SET_ACLS: + mSyncState = SYNC_STATE_GET_ACLS; + + if( !noContent() && mAccount->hasACLSupport() && + ( mUserRights <= 0 || ( mUserRights & ACLJobs::Administer ) ) ) { + bool hasChangedACLs = false; + ACLList::ConstIterator it = mACLList.begin(); + for ( ; it != mACLList.end() && !hasChangedACLs; ++it ) { + hasChangedACLs = (*it).changed; + } + if ( hasChangedACLs ) { + newState( mProgress, i18n("Setting permissions")); + KURL url = mAccount->getUrl(); + url.setPath( imapPath() ); + KIO::Job* job = KMail::ACLJobs::multiSetACL( mAccount->slave(), url, mACLList ); + ImapAccountBase::jobData jd( url.url(), folder() ); + mAccount->insertJob(job, jd); + + connect(job, SIGNAL(result(KIO::Job *)), + SLOT(slotMultiSetACLResult(KIO::Job *))); + connect(job, SIGNAL(aclChanged( const QString&, int )), + SLOT(slotACLChanged( const QString&, int )) ); + break; + } + } + + case SYNC_STATE_GET_ACLS: + mSyncState = SYNC_STATE_GET_QUOTA; + + if( !noContent() && mAccount->hasACLSupport() ) { + newState( mProgress, i18n( "Retrieving permissions" ) ); + mAccount->getACL( folder(), mImapPath ); + connect( mAccount, SIGNAL(receivedACL( KMFolder*, KIO::Job*, const KMail::ACLList& )), + this, SLOT(slotReceivedACL( KMFolder*, KIO::Job*, const KMail::ACLList& )) ); + break; + } + case SYNC_STATE_GET_QUOTA: + // Continue with the subfolders + mSyncState = SYNC_STATE_FIND_SUBFOLDERS; + if( !noContent() && mAccount->hasQuotaSupport() ) { + newState( mProgress, i18n("Getting quota information")); + KURL url = mAccount->getUrl(); + url.setPath( imapPath() ); + KIO::Job* job = KMail::QuotaJobs::getStorageQuota( mAccount->slave(), url ); + ImapAccountBase::jobData jd( url.url(), folder() ); + mAccount->insertJob(job, jd); + connect( job, SIGNAL( storageQuotaResult( const QuotaInfo& ) ), + SLOT( slotStorageQuotaResult( const QuotaInfo& ) ) ); + connect( job, SIGNAL(result(KIO::Job *)), + SLOT(slotQuotaResult(KIO::Job *)) ); + break; + } + case SYNC_STATE_FIND_SUBFOLDERS: + { + mProgress = 98; + newState( mProgress, i18n("Updating cache file")); + + mSyncState = SYNC_STATE_SYNC_SUBFOLDERS; + mSubfoldersForSync.clear(); + mCurrentSubfolder = 0; + if( folder() && folder()->child() ) { + KMFolderNode *node = folder()->child()->first(); + while( node ) { + if( !node->isDir() ) { + KMFolderCachedImap* storage = static_cast<KMFolderCachedImap*>(static_cast<KMFolder*>(node)->storage()); + // Only sync folders that have been accepted by the server + if ( !storage->imapPath().isEmpty() + // and that were not just deleted from it + && !foldersForDeletionOnServer.contains( storage->imapPath() ) ) { + mSubfoldersForSync << storage; + } else { + kdDebug(5006) << "Do not add " << storage->label() + << " to synclist" << endl; + } + } + node = folder()->child()->next(); + } + } + + // All done for this folder. + mProgress = 100; // all done + newState( mProgress, i18n("Synchronization done")); + KURL url = mAccount->getUrl(); + url.setPath( imapPath() ); + kmkernel->iCalIface().folderSynced( folder(), url ); + } + + if ( !mRecurse ) // "check mail for this folder" only + mSubfoldersForSync.clear(); + + // Carry on + case SYNC_STATE_SYNC_SUBFOLDERS: + { + if( mCurrentSubfolder ) { + disconnect( mCurrentSubfolder, SIGNAL( folderComplete(KMFolderCachedImap*, bool) ), + this, SLOT( slotSubFolderComplete(KMFolderCachedImap*, bool) ) ); + mCurrentSubfolder = 0; + } + + if( mSubfoldersForSync.isEmpty() ) { + mSyncState = SYNC_STATE_INITIAL; + mAccount->addUnreadMsgCount( this, countUnread() ); // before closing + close("cachedimap"); + emit folderComplete( this, true ); + } else { + mCurrentSubfolder = mSubfoldersForSync.front(); + mSubfoldersForSync.pop_front(); + connect( mCurrentSubfolder, SIGNAL( folderComplete(KMFolderCachedImap*, bool) ), + this, SLOT( slotSubFolderComplete(KMFolderCachedImap*, bool) ) ); + + //kdDebug(5006) << "Sync'ing subfolder " << mCurrentSubfolder->imapPath() << endl; + assert( !mCurrentSubfolder->imapPath().isEmpty() ); + mCurrentSubfolder->setAccount( account() ); + bool recurse = mCurrentSubfolder->noChildren() ? false : true; + mCurrentSubfolder->serverSync( recurse ); + } + } + break; + + default: + kdDebug(5006) << "KMFolderCachedImap::serverSyncInternal() WARNING: no such state " + << mSyncState << endl; + } +} + +/* Connected to the imap account's connectionResult signal. + Emitted when the slave connected or failed to connect. +*/ +void KMFolderCachedImap::slotConnectionResult( int errorCode, const QString& errorMsg ) +{ + disconnect( mAccount, SIGNAL( connectionResult(int, const QString&) ), + this, SLOT( slotConnectionResult(int, const QString&) ) ); + if ( !errorCode ) { + // Success + mSyncState = SYNC_STATE_GET_USERRIGHTS; + mProgress += 5; + serverSyncInternal(); + } else { + // Error (error message already shown by the account) + newState( mProgress, KIO::buildErrorString( errorCode, errorMsg )); + emit folderComplete(this, false); + } +} + +/* find new messages (messages without a UID) */ +QValueList<unsigned long> KMFolderCachedImap::findNewMessages() +{ + QValueList<unsigned long> result; + for( int i = 0; i < count(); ++i ) { + KMMsgBase *msg = getMsgBase( i ); + if( !msg ) continue; /* what goes on if getMsg() returns 0? */ + if ( msg->UID() == 0 ) + result.append( msg->getMsgSerNum() ); + } + return result; +} + +/* Upload new messages to server */ +void KMFolderCachedImap::uploadNewMessages() +{ + QValueList<unsigned long> newMsgs = findNewMessages(); + if( !newMsgs.isEmpty() ) { + if ( mUserRights <= 0 || ( mUserRights & ( KMail::ACLJobs::Insert ) ) ) { + newState( mProgress, i18n("Uploading messages to server")); + CachedImapJob *job = new CachedImapJob( newMsgs, CachedImapJob::tPutMessage, this ); + connect( job, SIGNAL( progress( unsigned long, unsigned long) ), + this, SLOT( slotPutProgress(unsigned long, unsigned long) ) ); + connect( job, SIGNAL( finished() ), this, SLOT( serverSyncInternal() ) ); + job->start(); + return; + } else { + KMCommand *command = rescueUnsyncedMessages(); + connect( command, SIGNAL( completed( KMCommand * ) ), + this, SLOT( serverSyncInternal() ) ); + } + } else { // nothing to upload + if ( mUserRights != mOldUserRights && (mOldUserRights & KMail::ACLJobs::Insert) + && !(mUserRights & KMail::ACLJobs::Insert) ) { + // write access revoked + KMessageBox::information( 0, i18n("<p>Your access rights to folder <b>%1</b> have been restricted, " + "it will no longer be possible to add messages to this folder.</p>").arg( folder()->prettyURL() ), + i18n("Acces rights revoked"), "KMailACLRevocationNotification" ); + } + } + newState( mProgress, i18n("No messages to upload to server")); + serverSyncInternal(); +} + +/* Progress info during uploadNewMessages */ +void KMFolderCachedImap::slotPutProgress( unsigned long done, unsigned long total ) +{ + // (going from mProgress to mProgress+10) + int progressSpan = 10; + newState( mProgress + (progressSpan * done) / total, QString::null ); + if ( done == total ) // we're done + mProgress += progressSpan; +} + +/* Upload message flags to server */ +void KMFolderCachedImap::uploadFlags() +{ + if ( !uidMap.isEmpty() ) { + mStatusFlagsJobs = 0; + newState( mProgress, i18n("Uploading status of messages to server")); + + // FIXME DUPLICATED FROM KMFOLDERIMAP + QMap< QString, QStringList > groups; + //open(); //already done + for( int i = 0; i < count(); ++i ) { + KMMsgBase* msg = getMsgBase( i ); + if( !msg || msg->UID() == 0 ) + // Either not a valid message or not one that is on the server yet + continue; + + QString flags = KMFolderImap::statusToFlags(msg->status(), mPermanentFlags); + // Collect uids for each typem of flags. + QString uid; + uid.setNum( msg->UID() ); + groups[flags].append(uid); + } + QMapIterator< QString, QStringList > dit; + for( dit = groups.begin(); dit != groups.end(); ++dit ) { + QCString flags = dit.key().latin1(); + QStringList sets = KMFolderImap::makeSets( (*dit), true ); + mStatusFlagsJobs += sets.count(); // ### that's not in kmfolderimap.... + // Send off a status setting job for each set. + for( QStringList::Iterator slit = sets.begin(); slit != sets.end(); ++slit ) { + QString imappath = imapPath() + ";UID=" + ( *slit ); + mAccount->setImapStatus(folder(), imappath, flags); + } + } + // FIXME END DUPLICATED FROM KMFOLDERIMAP + + if ( mStatusFlagsJobs ) { + connect( mAccount, SIGNAL( imapStatusChanged(KMFolder*, const QString&, bool) ), + this, SLOT( slotImapStatusChanged(KMFolder*, const QString&, bool) ) ); + return; + } + } + newState( mProgress, i18n("No messages to upload to server")); + serverSyncInternal(); +} + +void KMFolderCachedImap::uploadSeenFlags() +{ + if ( !uidMap.isEmpty() ) { + mStatusFlagsJobs = 0; + newState( mProgress, i18n("Uploading status of messages to server")); + + QValueList<ulong> seenUids, unseenUids; + for( int i = 0; i < count(); ++i ) { + KMMsgBase* msg = getMsgBase( i ); + if( !msg || msg->UID() == 0 ) + // Either not a valid message or not one that is on the server yet + continue; + + if ( msg->status() & KMMsgStatusOld || msg->status() & KMMsgStatusRead ) + seenUids.append( msg->UID() ); + else + unseenUids.append( msg->UID() ); + } + if ( !seenUids.isEmpty() ) { + QStringList sets = KMFolderImap::makeSets( seenUids, true ); + mStatusFlagsJobs += sets.count(); + for( QStringList::Iterator it = sets.begin(); it != sets.end(); ++it ) { + QString imappath = imapPath() + ";UID=" + ( *it ); + mAccount->setImapSeenStatus( folder(), imappath, true ); + } + } + if ( !unseenUids.isEmpty() ) { + QStringList sets = KMFolderImap::makeSets( unseenUids, true ); + mStatusFlagsJobs += sets.count(); + for( QStringList::Iterator it = sets.begin(); it != sets.end(); ++it ) { + QString imappath = imapPath() + ";UID=" + ( *it ); + mAccount->setImapSeenStatus( folder(), imappath, false ); + } + } + + if ( mStatusFlagsJobs ) { + connect( mAccount, SIGNAL( imapStatusChanged(KMFolder*, const QString&, bool) ), + this, SLOT( slotImapStatusChanged(KMFolder*, const QString&, bool) ) ); + return; + } + } + newState( mProgress, i18n("No messages to upload to server")); + serverSyncInternal(); +} + +void KMFolderCachedImap::slotImapStatusChanged(KMFolder* folder, const QString&, bool cont) +{ + if ( mSyncState == SYNC_STATE_INITIAL ){ + //kdDebug(5006) << "IMAP status changed but reset " << endl; + return; // we were reset + } + //kdDebug(5006) << "IMAP status changed for folder: " << folder->prettyURL() << endl; + if ( folder->storage() == this ) { + --mStatusFlagsJobs; + if ( mStatusFlagsJobs == 0 || !cont ) // done or aborting + disconnect( mAccount, SIGNAL( imapStatusChanged(KMFolder*, const QString&, bool) ), + this, SLOT( slotImapStatusChanged(KMFolder*, const QString&, bool) ) ); + if ( mStatusFlagsJobs == 0 && cont ) { + mProgress += 5; + serverSyncInternal(); + //kdDebug(5006) << "Proceeding with mailcheck." << endl; + } + } +} + +// This is not perfect, what if the status didn't really change? Oh well ... +void KMFolderCachedImap::setStatus( int idx, KMMsgStatus status, bool toggle) +{ + KMFolderMaildir::setStatus( idx, status, toggle ); + mStatusChangedLocally = true; +} + +void KMFolderCachedImap::setStatus(QValueList<int>& ids, KMMsgStatus status, bool toggle) +{ + KMFolderMaildir::setStatus(ids, status, toggle); + mStatusChangedLocally = true; +} + +/* Upload new folders to server */ +void KMFolderCachedImap::createNewFolders() +{ + QValueList<KMFolderCachedImap*> newFolders = findNewFolders(); + //kdDebug(5006) << label() << " createNewFolders:" << newFolders.count() << " new folders." << endl; + if( !newFolders.isEmpty() ) { + newState( mProgress, i18n("Creating subfolders on server")); + CachedImapJob *job = new CachedImapJob( newFolders, CachedImapJob::tAddSubfolders, this ); + connect( job, SIGNAL( result(KMail::FolderJob *) ), this, SLOT( slotIncreaseProgress() ) ); + connect( job, SIGNAL( finished() ), this, SLOT( serverSyncInternal() ) ); + job->start(); + } else { + serverSyncInternal(); + } +} + +QValueList<KMFolderCachedImap*> KMFolderCachedImap::findNewFolders() +{ + QValueList<KMFolderCachedImap*> newFolders; + if( folder() && folder()->child() ) { + KMFolderNode *node = folder()->child()->first(); + while( node ) { + if( !node->isDir() ) { + if( static_cast<KMFolder*>(node)->folderType() != KMFolderTypeCachedImap ) { + kdError(5006) << "KMFolderCachedImap::findNewFolders(): ARGH!!! " + << node->name() << " is not an IMAP folder\n"; + node = folder()->child()->next(); + assert(0); + } + KMFolderCachedImap* folder = static_cast<KMFolderCachedImap*>(static_cast<KMFolder*>(node)->storage()); + if( folder->imapPath().isEmpty() ) { + newFolders << folder; + } + } + node = folder()->child()->next(); + } + } + return newFolders; +} + +bool KMFolderCachedImap::deleteMessages() +{ + /* Delete messages from cache that are gone from the server */ + QPtrList<KMMessage> msgsForDeletion; + + // It is not possible to just go over all indices and remove + // them one by one because the index list can get resized under + // us. So use msg pointers instead + + QStringList uids; + QMap<ulong,int>::const_iterator it = uidMap.constBegin(); + for( ; it != uidMap.end(); it++ ) { + ulong uid ( it.key() ); + if( uid!=0 && !uidsOnServer.find( uid ) ) { + uids << QString::number( uid ); + msgsForDeletion.append( getMsg( *it ) ); + } + } + + if( !msgsForDeletion.isEmpty() ) { +#if MAIL_LOSS_DEBUGGING + if ( KMessageBox::warningYesNo( + 0, i18n( "<qt><p>Mails on the server in folder <b>%1</b> were deleted. " + "Do you want to delete them locally?<br>UIDs: %2</p></qt>" ) + .arg( folder()->prettyURL() ).arg( uids.join(",") ) ) == KMessageBox::Yes ) +#endif + removeMsg( msgsForDeletion ); + } + + if ( mUserRights > 0 && !( mUserRights & KMail::ACLJobs::Delete ) ) + return false; + + /* Delete messages from the server that we dont have anymore */ + if( !uidsForDeletionOnServer.isEmpty() ) { + newState( mProgress, i18n("Deleting removed messages from server")); + QStringList sets = KMFolderImap::makeSets( uidsForDeletionOnServer, true ); + uidsForDeletionOnServer.clear(); + kdDebug(5006) << "Deleting " << sets.count() << " sets of messages from server folder " << imapPath() << endl; + CachedImapJob *job = new CachedImapJob( sets, CachedImapJob::tDeleteMessage, this ); + connect( job, SIGNAL( result(KMail::FolderJob *) ), + this, SLOT( slotDeleteMessagesResult(KMail::FolderJob *) ) ); + job->start(); + return true; + } else { + + // Nothing to delete on the server, make sure the map is clear again. + // Normally this wouldn't be necessary, but there can be stale maps because of + // https://issues.kolab.org/issue3833. + mDeletedUIDsSinceLastSync.clear(); + return false; + } +} + +void KMFolderCachedImap::slotDeleteMessagesResult( KMail::FolderJob* job ) +{ + if ( job->error() ) { + // Skip the EXPUNGE state if deleting didn't work, no need to show two error messages + mSyncState = SYNC_STATE_GET_MESSAGES; + } else { + // deleting on the server went fine, clear the pending deletions cache + mDeletedUIDsSinceLastSync.clear(); + } + mProgress += 10; + serverSyncInternal(); +} + +void KMFolderCachedImap::checkUidValidity() { + // IMAP root folders don't seem to have a UID validity setting. + // Also, don't try the uid validity on new folders + if( imapPath().isEmpty() || imapPath() == "/" ) + // Just proceed + serverSyncInternal(); + else { + newState( mProgress, i18n("Checking folder validity")); + CachedImapJob *job = new CachedImapJob( FolderJob::tCheckUidValidity, this ); + connect( job, SIGNAL(permanentFlags(int)), SLOT(slotPermanentFlags(int)) ); + connect( job, SIGNAL( result( KMail::FolderJob* ) ), + this, SLOT( slotCheckUidValidityResult( KMail::FolderJob* ) ) ); + job->start(); + } +} + +void KMFolderCachedImap::slotCheckUidValidityResult( KMail::FolderJob* job ) +{ + if ( job->error() ) { // there was an error and the user chose "continue" + // We can't continue doing anything in the same folder though, it would delete all mails. + // But we can continue to subfolders if any. Well we can also try annotation/acl stuff... + mSyncState = SYNC_STATE_HANDLE_INBOX; + } + mProgress += 5; + serverSyncInternal(); +} + +void KMFolderCachedImap::slotPermanentFlags(int flags) +{ + mPermanentFlags = flags; +} + +/* This will only list the messages in a folder. + No directory listing done*/ +void KMFolderCachedImap::listMessages() { + bool groupwareOnly = GlobalSettings::self()->showOnlyGroupwareFoldersForGroupwareAccount() + && GlobalSettings::self()->theIMAPResourceAccount() == (int)mAccount->id() + && folder()->isSystemFolder() + && mImapPath == "/INBOX/"; + // Don't list messages on the root folder, and skip the inbox, if this is + // the inbox of a groupware-only dimap account + if( imapPath() == "/" || groupwareOnly ) { + serverSyncInternal(); + return; + } + + if( !mAccount->slave() ) { // sync aborted + resetSyncState(); + emit folderComplete( this, false ); + return; + } + uidsOnServer.clear(); + uidsOnServer.resize( count() * 2 ); + uidsForDeletionOnServer.clear(); + mMsgsForDownload.clear(); + mUidsForDownload.clear(); + // listing is only considered successful if saw a syntactically correct imapdigest + mFoundAnIMAPDigest = false; + + CachedImapJob* job = new CachedImapJob( FolderJob::tListMessages, this ); + connect( job, SIGNAL( result(KMail::FolderJob *) ), + this, SLOT( slotGetLastMessagesResult(KMail::FolderJob *) ) ); + job->start(); +} + +void KMFolderCachedImap::slotGetLastMessagesResult(KMail::FolderJob *job) +{ + getMessagesResult(job, true); +} + +// Connected to the listMessages job in CachedImapJob +void KMFolderCachedImap::slotGetMessagesData(KIO::Job * job, const QByteArray & data) +{ + KMAcctCachedImap::JobIterator it = mAccount->findJob(job); + if ( it == mAccount->jobsEnd() ) { // Shouldn't happen + kdDebug(5006) << "could not find job!?!?!" << endl; + // be sure to reset the sync state, if the listing was partial we would + // otherwise delete not-listed mail locally, and on the next sync on the server + // as well + mSyncState = SYNC_STATE_HANDLE_INBOX; + serverSyncInternal(); /* HACK^W Fix: we should at least try to keep going */ + return; + } + (*it).cdata += QCString(data, data.size() + 1); + int pos = (*it).cdata.find("\r\n--IMAPDIGEST"); + if (pos > 0) { + int a = (*it).cdata.find("\r\nX-uidValidity:"); + if (a != -1) { + int b = (*it).cdata.find("\r\n", a + 17); + setUidValidity((*it).cdata.mid(a + 17, b - a - 17)); + } + a = (*it).cdata.find("\r\nX-Access:"); + // Only trust X-Access (i.e. the imap select info) if we don't know mUserRights. + // The latter is more accurate (checked on every sync) whereas X-Access is only + // updated when selecting the folder again, which might not happen if using + // RMB / Check Mail in this folder. We don't need two (potentially conflicting) + // sources for the readonly setting, in any case. + if (a != -1 && mUserRights == -1 ) { + int b = (*it).cdata.find("\r\n", a + 12); + const QString access = (*it).cdata.mid(a + 12, b - a - 12); + setReadOnly( access == "Read only" ); + } + (*it).cdata.remove(0, pos); + mFoundAnIMAPDigest = true; + } + pos = (*it).cdata.find("\r\n--IMAPDIGEST", 1); + // Start with something largish when rebuilding the cache + if ( uidsOnServer.size() == 0 ) + uidsOnServer.resize( KMail::nextPrime( 2000 ) ); + const int v = 42; + while (pos >= 0) { + /* + KMMessage msg; + msg.fromString((*it).cdata.mid(16, pos - 16)); + const int flags = msg.headerField("X-Flags").toInt(); + const ulong size = msg.headerField("X-Length").toULong(); + const ulong uid = msg.UID(); + */ + // The below is optimized for speed, not prettiness. The commented out chunk + // above was the solution copied from kmfolderimap, and it's 15-20% slower. + const QCString& entry( (*it).cdata ); + const int indexOfUID = entry.find("X-UID", 16); + const int startOfUIDValue = indexOfUID + 7; + const int indexOfLength = entry.find("X-Length", startOfUIDValue ); // we know length comes after UID + const int startOfLengthValue = indexOfLength + 10; + const int indexOfFlags = entry.find("X-Flags", startOfLengthValue ); // we know flags comes last + const int startOfFlagsValue = indexOfFlags + 9; + + const int flags = entry.mid( startOfFlagsValue, entry.find( '\r', startOfFlagsValue ) - startOfFlagsValue ).toInt(); + const ulong size = entry.mid( startOfLengthValue, entry.find( '\r', startOfLengthValue ) - startOfLengthValue ).toULong(); + const ulong uid = entry.mid( startOfUIDValue, entry.find( '\r', startOfUIDValue ) - startOfUIDValue ).toULong(); + + const bool deleted = ( flags & 8 ); + if ( !deleted ) { + if( uid != 0 ) { + if ( uidsOnServer.count() == uidsOnServer.size() ) { + uidsOnServer.resize( KMail::nextPrime( uidsOnServer.size() * 2 ) ); + //kdDebug( 5006 ) << "Resizing to: " << uidsOnServer.size() << endl; + } + uidsOnServer.insert( uid, &v ); + } + bool redownload = false; + if ( uid <= lastUid() ) { + /* + * If this message UID is not present locally, then it must + * have been deleted by the user, so we delete it on the + * server also. If we don't have delete permissions on the server, + * re-download the message, it must have vanished by some error, or + * while we still thought we were allowed to delete (ACL change). + * + * This relies heavily on lastUid() being correct at all times. + */ + // kdDebug(5006) << "KMFolderCachedImap::slotGetMessagesData() : folder "<<label()<<" already has msg="<<msg->headerField("Subject") << ", UID="<<uid << ", lastUid = " << mLastUid << endl; + KMMsgBase *existingMessage = findByUID(uid); + if( !existingMessage ) { +#if MAIL_LOSS_DEBUGGING + kdDebug(5006) << "Looking at uid " << uid << " high water is: " << lastUid() << " we should delete it" << endl; +#endif + // double check we deleted it since the last sync + if ( mDeletedUIDsSinceLastSync.contains(uid) ) { + if ( mUserRights <= 0 || ( mUserRights & KMail::ACLJobs::Delete ) ) { +#if MAIL_LOSS_DEBUGGING + kdDebug(5006) << "message with uid " << uid << " is gone from local cache. Must be deleted on server!!!" << endl; +#endif + uidsForDeletionOnServer << uid; + } else { + redownload = true; + } + } else { + kdDebug(5006) << "WARNING: ####### " << endl; + kdDebug(5006) << "Message locally missing but not deleted in folder: " << folder()->prettyURL() << endl; + kdDebug(5006) << "The missing UID: " << uid << ". It will be redownloaded " << endl; + redownload = true; + } + + } else { + // if this is a read only folder, ignore status updates from the server + // since we can't write our status back our local version is what has to + // be considered correct. + if ( !mReadOnly || !GlobalSettings::allowLocalFlags() ) { + /* The message is OK, update flags */ + KMFolderImap::flagsToStatus( existingMessage, flags, false, mReadOnly ? INT_MAX : mPermanentFlags ); + } else if ( mUserRights & KMail::ACLJobs::WriteSeenFlag ) { + KMFolderImap::seenFlagToStatus( existingMessage, flags ); + } + } + // kdDebug(5006) << "message with uid " << uid << " found in the local cache. " << endl; + } + if ( uid > lastUid() || redownload ) { +#if MAIL_LOSS_DEBUGGING + kdDebug(5006) << "Looking at uid " << uid << " high water is: " << lastUid() << " we should download it" << endl; +#endif + // The message is new since the last sync, but we might have just uploaded it, in which case + // the uid map already contains it. + if ( !uidMap.contains( uid ) ) { + mMsgsForDownload << KMail::CachedImapJob::MsgForDownload(uid, flags, size); + if( imapPath() == "/INBOX/" ) + mUidsForDownload << uid; + } + // Remember the highest uid and once the download is completed, update mLastUid + if ( uid > mTentativeHighestUid ) { +#if MAIL_LOSS_DEBUGGING + kdDebug(5006) << "Setting the tentative highest UID to: " << uid << endl; +#endif + mTentativeHighestUid = uid; + } + } + } + (*it).cdata.remove(0, pos); + (*it).done++; + pos = (*it).cdata.find("\r\n--IMAPDIGEST", 1); + } +} + +void KMFolderCachedImap::getMessagesResult( KMail::FolderJob *job, bool lastSet ) +{ + mProgress += 10; + if ( !job->error() && !mFoundAnIMAPDigest ) { + kdWarning(5006) << "######## Folderlisting did not complete, but there was no error! " + "Aborting sync of folder: " << folder()->prettyURL() << endl; +#if MAIL_LOSS_DEBUGGING + kmkernel->emergencyExit( i18n("Folder listing failed in interesting ways." ) ); +#endif + } + if( job->error() ) { // error listing messages but the user chose to continue + mContentState = imapNoInformation; + mSyncState = SYNC_STATE_HANDLE_INBOX; // be sure not to continue in this folder + } else { + if( lastSet ) { // always true here (this comes from online-imap...) + mContentState = imapFinished; + mStatusChangedLocally = false; // we are up to date again + } + } + serverSyncInternal(); +} + +void KMFolderCachedImap::slotProgress(unsigned long done, unsigned long total) +{ + int progressSpan = 100 - 5 - mProgress; + //kdDebug(5006) << "KMFolderCachedImap::slotProgress done=" << done << " total=" << total << "=> mProgress=" << mProgress + ( progressSpan * done ) / total << endl; + // Progress info while retrieving new emails + // (going from mProgress to mProgress+progressSpan) + newState( mProgress + (progressSpan * done) / total, QString::null ); +} + +void KMFolderCachedImap::setAccount(KMAcctCachedImap *aAccount) +{ + assert( aAccount->isA("KMAcctCachedImap") ); + mAccount = aAccount; + if( imapPath()=="/" ) aAccount->setFolder( folder() ); + + // Folder was renamed in a previous session, and the user didn't sync yet + QString newName = mAccount->renamedFolder( imapPath() ); + if ( !newName.isEmpty() ) + folder()->setLabel( newName ); + + if( !folder() || !folder()->child() || !folder()->child()->count() ) return; + for( KMFolderNode* node = folder()->child()->first(); node; + node = folder()->child()->next() ) + if (!node->isDir()) + static_cast<KMFolderCachedImap*>(static_cast<KMFolder*>(node)->storage())->setAccount(aAccount); +} + +void KMFolderCachedImap::listNamespaces() +{ + ImapAccountBase::ListType type = ImapAccountBase::List; + if ( mAccount->onlySubscribedFolders() ) + type = ImapAccountBase::ListSubscribed; + + kdDebug(5006) << "listNamespaces " << mNamespacesToList << endl; + if ( mNamespacesToList.isEmpty() ) { + mSyncState = SYNC_STATE_DELETE_SUBFOLDERS; + mPersonalNamespacesCheckDone = true; + + QStringList ns = mAccount->namespaces()[ImapAccountBase::OtherUsersNS]; + ns += mAccount->namespaces()[ImapAccountBase::SharedNS]; + mNamespacesToCheck = ns.count(); + for ( QStringList::Iterator it = ns.begin(); it != ns.end(); ++it ) + { + if ( (*it).isEmpty() ) { + // ignore empty listings as they have been listed before + --mNamespacesToCheck; + continue; + } + KMail::ListJob* job = new KMail::ListJob( mAccount, type, this, mAccount->addPathToNamespace( *it ) ); + job->setHonorLocalSubscription( true ); + connect( job, SIGNAL(receivedFolders(const QStringList&, const QStringList&, + const QStringList&, const QStringList&, const ImapAccountBase::jobData&)), + this, SLOT(slotCheckNamespace(const QStringList&, const QStringList&, + const QStringList&, const QStringList&, const ImapAccountBase::jobData&))); + job->start(); + } + if ( mNamespacesToCheck == 0 ) { + serverSyncInternal(); + } + return; + } + mPersonalNamespacesCheckDone = false; + + QString ns = mNamespacesToList.front(); + mNamespacesToList.pop_front(); + + mSyncState = SYNC_STATE_LIST_SUBFOLDERS2; + newState( mProgress, i18n("Retrieving folders for namespace %1").arg(ns)); + KMail::ListJob* job = new KMail::ListJob( mAccount, type, this, + mAccount->addPathToNamespace( ns ) ); + job->setNamespace( ns ); + job->setHonorLocalSubscription( true ); + connect( job, SIGNAL(receivedFolders(const QStringList&, const QStringList&, + const QStringList&, const QStringList&, const ImapAccountBase::jobData&)), + this, SLOT(slotListResult(const QStringList&, const QStringList&, + const QStringList&, const QStringList&, const ImapAccountBase::jobData&))); + job->start(); +} + +void KMFolderCachedImap::slotCheckNamespace( const QStringList& subfolderNames, + const QStringList& subfolderPaths, + const QStringList& subfolderMimeTypes, + const QStringList& subfolderAttributes, + const ImapAccountBase::jobData& jobData ) +{ + Q_UNUSED( subfolderPaths ); + Q_UNUSED( subfolderMimeTypes ); + Q_UNUSED( subfolderAttributes ); + --mNamespacesToCheck; + kdDebug(5006) << "slotCheckNamespace " << subfolderNames << ",remain=" << + mNamespacesToCheck << endl; + + // get a correct foldername: + // strip / and make sure it does not contain the delimiter + QString name = jobData.path.mid( 1, jobData.path.length()-2 ); + name.remove( mAccount->delimiterForNamespace( name ) ); + if ( name.isEmpty() ) { + // should not happen + kdWarning(5006) << "slotCheckNamespace: ignoring empty folder!" << endl; + return; + } + + folder()->createChildFolder(); + KMFolderNode *node = 0; + for ( node = folder()->child()->first(); node; + node = folder()->child()->next()) + { + if ( !node->isDir() && node->name() == name ) + break; + } + if ( !subfolderNames.isEmpty() ) { + if ( node ) { + // folder exists so we have nothing to do - it will be listed later + kdDebug(5006) << "found namespace folder " << name << endl; + } else + { + // create folder + kdDebug(5006) << "create namespace folder " << name << endl; + KMFolder* newFolder = folder()->child()->createFolder( name, false, + KMFolderTypeCachedImap ); + if ( newFolder ) { + KMFolderCachedImap *f = static_cast<KMFolderCachedImap*>( newFolder->storage() ); + f->setImapPath( mAccount->addPathToNamespace( name ) ); + f->setNoContent( true ); + f->setAccount( mAccount ); + f->close("cachedimap"); + kmkernel->dimapFolderMgr()->contentsChanged(); + } + } + } else { + if ( node ) { + kdDebug(5006) << "delete namespace folder " << name << endl; + KMFolder* fld = static_cast<KMFolder*>(node); + kmkernel->dimapFolderMgr()->remove( fld ); + } + } + + if ( mNamespacesToCheck == 0 ) { + // all namespaces are done so continue with the next step + serverSyncInternal(); + } +} + +// This lists the subfolders on the server +// and (in slotListResult) takes care of folders that have been removed on the server +bool KMFolderCachedImap::listDirectory() +{ + if( !mAccount->slave() ) { // sync aborted + resetSyncState(); + emit folderComplete( this, false ); + return false; + } + mSubfolderState = imapInProgress; + + // get the folders + ImapAccountBase::ListType type = ImapAccountBase::List; + if ( mAccount->onlySubscribedFolders() ) + type = ImapAccountBase::ListSubscribed; + KMail::ListJob* job = new KMail::ListJob( mAccount, type, this ); + job->setHonorLocalSubscription( true ); + connect( job, SIGNAL(receivedFolders(const QStringList&, const QStringList&, + const QStringList&, const QStringList&, const ImapAccountBase::jobData&)), + this, SLOT(slotListResult(const QStringList&, const QStringList&, + const QStringList&, const QStringList&, const ImapAccountBase::jobData&))); + job->start(); + + return true; +} + +void KMFolderCachedImap::slotListResult( const QStringList& folderNames, + const QStringList& folderPaths, + const QStringList& folderMimeTypes, + const QStringList& folderAttributes, + const ImapAccountBase::jobData& jobData ) +{ + Q_UNUSED( jobData ); + //kdDebug(5006) << label() << ": folderNames=" << folderNames << " folderPaths=" + //<< folderPaths << " mimeTypes=" << folderMimeTypes << endl; + mSubfolderNames = folderNames; + mSubfolderPaths = folderPaths; + mSubfolderMimeTypes = folderMimeTypes; + mSubfolderState = imapFinished; + mSubfolderAttributes = folderAttributes; + kdDebug(5006) << "##### setting subfolder attributes: " << mSubfolderAttributes << endl; + + folder()->createChildFolder(); + KMFolderNode *node = folder()->child()->first(); + bool root = ( this == mAccount->rootFolder() ); + + QPtrList<KMFolder> toRemove; + bool emptyList = ( root && mSubfolderNames.empty() ); + if ( !emptyList ) { + while (node) { + if (!node->isDir() ) { + KMFolderCachedImap *f = static_cast<KMFolderCachedImap*>(static_cast<KMFolder*>(node)->storage()); + + if ( mSubfolderNames.findIndex(node->name()) == -1 ) { + QString name = node->name(); + // as more than one namespace can be listed in the root folder we need to make sure + // that the folder is within the current namespace + bool isInNamespace = ( jobData.curNamespace.isEmpty() || + jobData.curNamespace == mAccount->namespaceForFolder( f ) ); + // ignore some cases + bool ignore = root && ( f->imapPath() == "/INBOX/" || + mAccount->isNamespaceFolder( name ) || !isInNamespace ); + + // This subfolder isn't present on the server + if( !f->imapPath().isEmpty() && !ignore ) { + // The folder has an imap path set, so it has been + // on the server before. Delete it locally. + toRemove.append( f->folder() ); + kdDebug(5006) << node->name() << " isn't on the server. It has an imapPath -> delete it locally" << endl; + } + } else { // folder both local and on server + //kdDebug(5006) << node->name() << " is on the server." << endl; + + /** + * Store the folder attributes for every subfolder. + */ + int index = mSubfolderNames.findIndex( node->name() ); + f->mFolderAttributes = folderAttributes[ index ]; + } + } else { + //kdDebug(5006) << "skipping dir node:" << node->name() << endl; + } + node = folder()->child()->next(); + } + } + + for ( KMFolder* doomed=toRemove.first(); doomed; doomed = toRemove.next() ) { + rescueUnsyncedMessagesAndDeleteFolder( doomed ); + } + + mProgress += 5; + + // just in case there is nothing to rescue + slotRescueDone( 0 ); +} + +// This synchronizes the local folders as needed (creation/deletion). No network communication here. +void KMFolderCachedImap::listDirectory2() +{ + QString path = folder()->path(); + kmkernel->dimapFolderMgr()->quiet(true); + + bool root = ( this == mAccount->rootFolder() ); + if ( root && !mAccount->hasInbox() ) + { + KMFolderCachedImap *f = 0; + KMFolderNode *node; + // create the INBOX + for (node = folder()->child()->first(); node; node = folder()->child()->next()) + if (!node->isDir() && node->name() == "INBOX") break; + if (node) { + f = static_cast<KMFolderCachedImap*>(static_cast<KMFolder*>(node)->storage()); + } else { + KMFolder* newFolder = folder()->child()->createFolder("INBOX", true, KMFolderTypeCachedImap); + if ( newFolder ) { + f = static_cast<KMFolderCachedImap*>(newFolder->storage()); + } + } + if ( f ) { + f->setAccount( mAccount ); + f->setImapPath( "/INBOX/" ); + f->folder()->setLabel( i18n("inbox") ); + } + if (!node) { + if ( f ) + f->close("cachedimap"); + kmkernel->dimapFolderMgr()->contentsChanged(); + } + // so we have an INBOX + mAccount->setHasInbox( true ); + } + + if ( root && !mSubfolderNames.isEmpty() ) { + KMFolderCachedImap* parent = + findParent( mSubfolderPaths.first(), mSubfolderNames.first() ); + if ( parent ) { + kdDebug(5006) << "KMFolderCachedImap::listDirectory2 - pass listing to " + << parent->label() << endl; + mSubfolderNames.clear(); + } + } + + // Find all subfolders present on server but not on disk + QValueVector<int> foldersNewOnServer; + for (uint i = 0; i < mSubfolderNames.count(); i++) { + + // Find the subdir, if already present + KMFolderCachedImap *f = 0; + KMFolderNode *node = 0; + for (node = folder()->child()->first(); node; + node = folder()->child()->next()) + if (!node->isDir() && node->name() == mSubfolderNames[i]) break; + + if (!node) { + // This folder is not present here + // Either it's new on the server, or we just deleted it. + QString subfolderPath = mSubfolderPaths[i]; + // The code used to look at the uidcache to know if it was "just deleted". + // But this breaks with noContent folders and with shared folders. + // So instead we keep a list in the account. + bool locallyDeleted = mAccount->isDeletedFolder( subfolderPath ); + // That list is saved/restored across sessions, but to avoid any mistake, + // ask for confirmation if the folder was deleted in a previous session + // (could be that the folder was deleted & recreated meanwhile from another client...) + if ( !locallyDeleted && mAccount->isPreviouslyDeletedFolder( subfolderPath ) ) { + locallyDeleted = KMessageBox::warningYesNo( + 0, i18n( "<qt><p>It seems that the folder <b>%1</b> was deleted. Do you want to delete it from the server?</p></qt>" ).arg( mSubfolderNames[i] ), QString::null, KStdGuiItem::del(), KStdGuiItem::cancel() ) == KMessageBox::Yes; + } + + if ( locallyDeleted ) { + kdDebug(5006) << subfolderPath << " was deleted locally => delete on server." << endl; + foldersForDeletionOnServer += mAccount->deletedFolderPaths( subfolderPath ); // grab all subsubfolders too + } else { + kdDebug(5006) << subfolderPath << " is a new folder on the server => create local cache" << endl; + foldersNewOnServer.append( i ); + } + } else { // Folder found locally + if( static_cast<KMFolder*>(node)->folderType() == KMFolderTypeCachedImap ) + f = dynamic_cast<KMFolderCachedImap*>(static_cast<KMFolder*>(node)->storage()); + if( f ) { + // kdDebug(5006) << "folder("<<f->name()<<")->imapPath()=" << f->imapPath() + // << "\nSetting imapPath " << mSubfolderPaths[i] << endl; + // Write folder settings + f->setAccount(mAccount); + f->setNoContent(mSubfolderMimeTypes[i] == "inode/directory"); + f->setNoChildren(mSubfolderMimeTypes[i] == "message/digest"); + f->setImapPath(mSubfolderPaths[i]); + } + } + } + + /* In case we are ignoring non-groupware folders, and this is the groupware + * main account, find out the contents types of folders that have newly + * appeared on the server. Otherwise just create them and finish listing. + * If a folder is already known to be locally unsubscribed, it won't be + * listed at all, on this level, so these are only folders that we are + * seeing for the first time. */ + + /* Note: We ask the globalsettings, and not the current state of the + * kmkernel->iCalIface().isEnabled(), since that is false during the + * very first sync, where we already want to filter. */ + if ( GlobalSettings::self()->showOnlyGroupwareFoldersForGroupwareAccount() + && GlobalSettings::self()->theIMAPResourceAccount() == (int)mAccount->id() + && mAccount->hasAnnotationSupport() + && GlobalSettings::self()->theIMAPResourceEnabled() + && !foldersNewOnServer.isEmpty() ) { + + QStringList paths; + for ( uint i = 0; i < foldersNewOnServer.count(); ++i ) + paths << mSubfolderPaths[ foldersNewOnServer[i] ]; + + AnnotationJobs::MultiUrlGetAnnotationJob* job = + AnnotationJobs::multiUrlGetAnnotation( mAccount->slave(), mAccount->getUrl(), paths, KOLAB_FOLDERTYPE ); + ImapAccountBase::jobData jd( QString::null, folder() ); + jd.cancellable = true; + mAccount->insertJob(job, jd); + connect( job, SIGNAL(result(KIO::Job *)), + SLOT(slotMultiUrlGetAnnotationResult(KIO::Job *)) ); + + } else { + createFoldersNewOnServerAndFinishListing( foldersNewOnServer ); + } +} + +void KMFolderCachedImap::createFoldersNewOnServerAndFinishListing( const QValueVector<int> foldersNewOnServer ) +{ + for ( uint i = 0; i < foldersNewOnServer.count(); ++i ) { + int idx = foldersNewOnServer[i]; + KMFolder* newFolder = folder()->child()->createFolder( mSubfolderNames[idx], false, KMFolderTypeCachedImap); + if (newFolder) { + KMFolderCachedImap *f = dynamic_cast<KMFolderCachedImap*>(newFolder->storage()); + kdDebug(5006) << " ####### Locally creating folder " << mSubfolderNames[idx] <<endl; + f->close("cachedimap"); + f->setAccount(mAccount); + f->mAnnotationFolderType = "FROMSERVER"; + f->setNoContent(mSubfolderMimeTypes[idx] == "inode/directory"); + f->setNoChildren(mSubfolderMimeTypes[idx] == "message/digest"); + f->setImapPath(mSubfolderPaths[idx]); + f->mFolderAttributes = mSubfolderAttributes[idx]; + kdDebug(5006) << " ####### Attributes: " << f->mFolderAttributes <<endl; + //kdDebug(5006) << subfolderPath << ": mAnnotationFolderType set to FROMSERVER" << endl; + kmkernel->dimapFolderMgr()->contentsChanged(); + } else { + kdDebug(5006) << "can't create folder " << mSubfolderNames[idx] <<endl; + } + } + + kmkernel->dimapFolderMgr()->quiet(false); + emit listComplete(this); + if ( !mPersonalNamespacesCheckDone ) { + // we're not done with the namespaces + mSyncState = SYNC_STATE_LIST_NAMESPACES; + } + serverSyncInternal(); +} + +//----------------------------------------------------------------------------- +KMFolderCachedImap* KMFolderCachedImap::findParent( const QString& path, + const QString& name ) +{ + QString parent = path.left( path.length() - name.length() - 2 ); + if ( parent.length() > 1 ) + { + // extract name of the parent + parent = parent.right( parent.length() - 1 ); + if ( parent != label() ) + { + KMFolderNode *node = folder()->child()->first(); + // look for a better parent + while ( node ) + { + if ( node->name() == parent ) + { + KMFolder* fld = static_cast<KMFolder*>(node); + KMFolderCachedImap* imapFld = + static_cast<KMFolderCachedImap*>( fld->storage() ); + return imapFld; + } + node = folder()->child()->next(); + } + } + } + return 0; +} + +void KMFolderCachedImap::slotSubFolderComplete(KMFolderCachedImap* sub, bool success) +{ + Q_UNUSED(sub); + //kdDebug(5006) << label() << " slotSubFolderComplete: " << sub->label() << endl; + if ( success ) { + serverSyncInternal(); + } + else + { + // success == false means the sync was aborted. + if ( mCurrentSubfolder ) { + Q_ASSERT( sub == mCurrentSubfolder ); + disconnect( mCurrentSubfolder, SIGNAL( folderComplete(KMFolderCachedImap*, bool) ), + this, SLOT( slotSubFolderComplete(KMFolderCachedImap*, bool) ) ); + mCurrentSubfolder = 0; + } + + mSubfoldersForSync.clear(); + mSyncState = SYNC_STATE_INITIAL; + close("cachedimap"); + emit folderComplete( this, false ); + } +} + +void KMFolderCachedImap::slotSimpleData(KIO::Job * job, const QByteArray & data) +{ + KMAcctCachedImap::JobIterator it = mAccount->findJob(job); + if (it == mAccount->jobsEnd()) return; + QBuffer buff((*it).data); + buff.open(IO_WriteOnly | IO_Append); + buff.writeBlock(data.data(), data.size()); + buff.close(); +} + +FolderJob* +KMFolderCachedImap::doCreateJob( KMMessage *msg, FolderJob::JobType jt, KMFolder *folder, + QString, const AttachmentStrategy* ) const +{ + QPtrList<KMMessage> msgList; + msgList.append( msg ); + CachedImapJob *job = new CachedImapJob( msgList, jt, folder? static_cast<KMFolderCachedImap*>( folder->storage() ):0 ); + job->setParentFolder( this ); + return job; +} + +FolderJob* +KMFolderCachedImap::doCreateJob( QPtrList<KMMessage>& msgList, const QString& sets, + FolderJob::JobType jt, KMFolder *folder ) const +{ + //FIXME: how to handle sets here? + Q_UNUSED( sets ); + CachedImapJob *job = new CachedImapJob( msgList, jt, folder? static_cast<KMFolderCachedImap*>( folder->storage() ):0 ); + job->setParentFolder( this ); + return job; +} + +void +KMFolderCachedImap::setUserRights( unsigned int userRights ) +{ + mUserRights = userRights; + writeConfigKeysWhichShouldNotGetOverwrittenByReadConfig(); +} + +void +KMFolderCachedImap::slotReceivedUserRights( KMFolder* folder ) +{ + if ( folder->storage() == this ) { + disconnect( mAccount, SIGNAL( receivedUserRights( KMFolder* ) ), + this, SLOT( slotReceivedUserRights( KMFolder* ) ) ); + if ( mUserRights == 0 ) // didn't work + mUserRights = -1; // error code (used in folderdia) + else + setReadOnly( ( mUserRights & KMail::ACLJobs::Insert ) == 0 ); + mProgress += 5; + serverSyncInternal(); + } +} + +void +KMFolderCachedImap::setReadOnly( bool readOnly ) +{ + if ( readOnly != mReadOnly ) { + mReadOnly = readOnly; + emit readOnlyChanged( folder() ); + } +} + +void +KMFolderCachedImap::slotReceivedACL( KMFolder* folder, KIO::Job*, const KMail::ACLList& aclList ) +{ + if ( folder->storage() == this ) { + disconnect( mAccount, SIGNAL(receivedACL( KMFolder*, KIO::Job*, const KMail::ACLList& )), + this, SLOT(slotReceivedACL( KMFolder*, KIO::Job*, const KMail::ACLList& )) ); + mACLList = aclList; + serverSyncInternal(); + } +} + +void +KMFolderCachedImap::slotStorageQuotaResult( const QuotaInfo& info ) +{ + setQuotaInfo( info ); +} + +void KMFolderCachedImap::setQuotaInfo( const QuotaInfo & info ) +{ + if ( info != mQuotaInfo ) { + mQuotaInfo = info; + writeConfigKeysWhichShouldNotGetOverwrittenByReadConfig(); + emit folderSizeChanged(); + } +} + +void +KMFolderCachedImap::setACLList( const ACLList& arr ) +{ + mACLList = arr; +} + +void +KMFolderCachedImap::slotMultiSetACLResult(KIO::Job *job) +{ + KMAcctCachedImap::JobIterator it = mAccount->findJob(job); + if ( it == mAccount->jobsEnd() ) return; // Shouldn't happen + if ( (*it).parent != folder() ) return; // Shouldn't happen + + if ( job->error() ) + // Display error but don't abort the sync just for this + // PENDING(dfaure) reconsider using handleJobError now that it offers continue/cancel + job->showErrorDialog(); + else + kmkernel->iCalIface().addFolderChange( folder(), KMailICalIfaceImpl::ACL ); + + if (mAccount->slave()) mAccount->removeJob(job); + serverSyncInternal(); +} + +void +KMFolderCachedImap::slotACLChanged( const QString& userId, int permissions ) +{ + // The job indicates success in changing the permissions for this user + // -> we note that it's been done. + for( ACLList::Iterator it = mACLList.begin(); it != mACLList.end(); ++it ) { + if ( (*it).userId == userId && (*it).permissions == permissions ) { + if ( permissions == -1 ) // deleted + mACLList.erase( it ); + else // added/modified + (*it).changed = false; + return; + } + } +} + +// called by KMAcctCachedImap::killAllJobs +void KMFolderCachedImap::resetSyncState() +{ + if ( mSyncState == SYNC_STATE_INITIAL ) return; + mSubfoldersForSync.clear(); + mSyncState = SYNC_STATE_INITIAL; + close("cachedimap"); + // Don't use newState here, it would revert to mProgress (which is < current value when listing messages) + KPIM::ProgressItem *progressItem = mAccount->mailCheckProgressItem(); + QString str = i18n("Aborted"); + if (progressItem) + progressItem->setStatus( str ); + emit statusMsg( str ); +} + +void KMFolderCachedImap::slotIncreaseProgress() +{ + mProgress += 5; +} + +void KMFolderCachedImap::newState( int progress, const QString& syncStatus ) +{ + //kdDebug() << k_funcinfo << folder() << " " << mProgress << " " << syncStatus << endl; + KPIM::ProgressItem *progressItem = mAccount->mailCheckProgressItem(); + if( progressItem ) + progressItem->setCompletedItems( progress ); + if ( !syncStatus.isEmpty() ) { + QString str; + // For a subfolder, show the label. But for the main folder, it's already shown. + if ( mAccount->imapFolder() == this ) + str = syncStatus; + else + str = QString( "%1: %2" ).arg( label() ).arg( syncStatus ); + if( progressItem ) + progressItem->setStatus( str ); + emit statusMsg( str ); + } + if( progressItem ) + progressItem->updateProgress(); +} + +void KMFolderCachedImap::setSubfolderState( imapState state ) +{ + mSubfolderState = state; + if ( state == imapNoInformation && folder()->child() ) + { + // pass through to childs + KMFolderNode* node; + QPtrListIterator<KMFolderNode> it( *folder()->child() ); + for ( ; (node = it.current()); ) + { + ++it; + if (node->isDir()) continue; + KMFolder *folder = static_cast<KMFolder*>(node); + static_cast<KMFolderCachedImap*>(folder->storage())->setSubfolderState( state ); + } + } +} + +void KMFolderCachedImap::setImapPath(const QString &path) +{ + mImapPath = path; +} + +// mAnnotationFolderType is the annotation as known to the server (and stored in kmailrc) +// It is updated from the folder contents type and whether it's a standard resource folder. +// This happens during the syncing phase and during initFolder for a new folder. +// Don't do it earlier, e.g. from setContentsType: +// on startup, it's too early there to know if this is a standard resource folder. +void KMFolderCachedImap::updateAnnotationFolderType() +{ + QString oldType = mAnnotationFolderType; + QString oldSubType; + int dot = oldType.find( '.' ); + if ( dot != -1 ) { + oldType.truncate( dot ); + oldSubType = mAnnotationFolderType.mid( dot + 1 ); + } + + QString newType, newSubType; + // We want to store an annotation on the folder only if using the kolab storage. + if ( kmkernel->iCalIface().storageFormat( folder() ) == KMailICalIfaceImpl::StorageXML ) { + newType = KMailICalIfaceImpl::annotationForContentsType( mContentsType ); + if ( kmkernel->iCalIface().isStandardResourceFolder( folder() ) ) + newSubType = "default"; + else + newSubType = oldSubType; // preserve unknown subtypes, like drafts etc. And preserve ".default" too. + } + + //kdDebug(5006) << mImapPath << ": updateAnnotationFolderType: " << newType << " " << newSubType << endl; + if ( newType != oldType || newSubType != oldSubType ) { + mAnnotationFolderType = newType + ( newSubType.isEmpty() ? QString::null : "."+newSubType ); + mAnnotationFolderTypeChanged = true; // force a "set annotation" on next sync + kdDebug(5006) << mImapPath << ": updateAnnotationFolderType: '" << mAnnotationFolderType << "', was (" << oldType << " " << oldSubType << ") => mAnnotationFolderTypeChanged set to TRUE" << endl; + } + // Ensure that further readConfig()s don't lose mAnnotationFolderType + writeConfigKeysWhichShouldNotGetOverwrittenByReadConfig(); +} + +void KMFolderCachedImap::setIncidencesFor( IncidencesFor incfor ) +{ + if ( mIncidencesFor != incfor ) { + mIncidencesFor = incfor; + mIncidencesForChanged = true; + } +} + +void KMFolderCachedImap::slotAnnotationResult(const QString& entry, const QString& value, bool found) +{ + if ( entry == KOLAB_FOLDERTYPE ) { + // There are four cases. + // 1) no content-type on server -> set it + // 2) different content-type on server, locally changed -> set it (we don't even come here) + // 3) different (known) content-type on server, no local change -> get it + // 4) different unknown content-type on server, probably some older version -> set it + if ( found ) { + QString type = value; + QString subtype; + int dot = value.find( '.' ); + if ( dot != -1 ) { + type.truncate( dot ); + subtype = value.mid( dot + 1 ); + } + bool foundKnownType = false; + for ( uint i = 0 ; i <= ContentsTypeLast; ++i ) { + FolderContentsType contentsType = static_cast<KMail::FolderContentsType>( i ); + if ( type == KMailICalIfaceImpl::annotationForContentsType( contentsType ) ) { + // Case 3: known content-type on server, get it + //kdDebug(5006) << mImapPath << ": slotGetAnnotationResult: found known type of annotation" << endl; + if ( contentsType != ContentsTypeMail ) + kmkernel->iCalIface().setStorageFormat( folder(), KMailICalIfaceImpl::StorageXML ); + mAnnotationFolderType = value; + if ( folder()->parent()->owner()->idString() != GlobalSettings::self()->theIMAPResourceFolderParent() + && GlobalSettings::self()->theIMAPResourceEnabled() + && subtype == "default" ) { + // Truncate subtype if this folder can't be a default resource folder for us, + // although it apparently is for someone else. + mAnnotationFolderType = type; + kdDebug(5006) << mImapPath << ": slotGetAnnotationResult: parent folder is " << folder()->parent()->owner()->idString() << " => truncating annotation to " << value << endl; + } + setContentsType( contentsType ); + mAnnotationFolderTypeChanged = false; // we changed it, not the user + foundKnownType = true; + + // Users don't read events/contacts/etc. in kmail, so mark them all as read. + // This is done in cachedimapjob when getting new messages, but do it here too, + // for the initial set of messages when we didn't know this was a resource folder yet, + // for old folders, etc. + if ( contentsType != ContentsTypeMail ) + markUnreadAsRead(); + + // Ensure that further readConfig()s don't lose mAnnotationFolderType + writeConfigKeysWhichShouldNotGetOverwrittenByReadConfig(); + break; + } + } + if ( !foundKnownType && !mReadOnly ) { + //kdDebug(5006) << "slotGetAnnotationResult: no known type of annotation found, will need to set it" << endl; + // Case 4: server has strange content-type, set it to what we need + mAnnotationFolderTypeChanged = true; + } + // TODO handle subtype (inbox, drafts, sentitems, junkemail) + } + else if ( !mReadOnly ) { + // Case 1: server doesn't have content-type, set it + //kdDebug(5006) << "slotGetAnnotationResult: no annotation found, will need to set it" << endl; + mAnnotationFolderTypeChanged = true; + } + } else if ( entry == KOLAB_INCIDENCESFOR ) { + if ( found ) { + mIncidencesFor = incidencesForFromString( value ); + Q_ASSERT( mIncidencesForChanged == false ); + } + } +} + +void KMFolderCachedImap::slotGetAnnotationResult( KIO::Job* job ) +{ + KMAcctCachedImap::JobIterator it = mAccount->findJob(job); + Q_ASSERT( it != mAccount->jobsEnd() ); + if ( it == mAccount->jobsEnd() ) return; // Shouldn't happen + Q_ASSERT( (*it).parent == folder() ); + if ( (*it).parent != folder() ) return; // Shouldn't happen + + AnnotationJobs::GetAnnotationJob* annjob = static_cast<AnnotationJobs::GetAnnotationJob *>( job ); + if ( annjob->error() ) { + if ( job->error() == KIO::ERR_UNSUPPORTED_ACTION ) { + // that's when the imap server doesn't support annotations + if ( GlobalSettings::self()->theIMAPResourceStorageFormat() == GlobalSettings::EnumTheIMAPResourceStorageFormat::XML + && (uint)GlobalSettings::self()->theIMAPResourceAccount() == mAccount->id() ) + KMessageBox::error( 0, i18n( "The IMAP server %1 does not have support for IMAP annotations. The XML storage cannot be used on this server; please re-configure KMail differently." ).arg( mAccount->host() ) ); + mAccount->setHasNoAnnotationSupport(); + } + else + kdWarning(5006) << "slotGetAnnotationResult: " << job->errorString() << endl; + } + + if (mAccount->slave()) mAccount->removeJob(job); + mProgress += 2; + serverSyncInternal(); +} + +void KMFolderCachedImap::slotMultiUrlGetAnnotationResult( KIO::Job* job ) +{ + KMAcctCachedImap::JobIterator it = mAccount->findJob(job); + Q_ASSERT( it != mAccount->jobsEnd() ); + if ( it == mAccount->jobsEnd() ) return; // Shouldn't happen + Q_ASSERT( (*it).parent == folder() ); + if ( (*it).parent != folder() ) return; // Shouldn't happen + + QValueVector<int> folders; + AnnotationJobs::MultiUrlGetAnnotationJob* annjob + = static_cast<AnnotationJobs::MultiUrlGetAnnotationJob *>( job ); + if ( annjob->error() ) { + if ( job->error() == KIO::ERR_UNSUPPORTED_ACTION ) { + // that's when the imap server doesn't support annotations + if ( GlobalSettings::self()->theIMAPResourceStorageFormat() == GlobalSettings::EnumTheIMAPResourceStorageFormat::XML + && (uint)GlobalSettings::self()->theIMAPResourceAccount() == mAccount->id() ) + KMessageBox::error( 0, i18n( "The IMAP server %1 doesn't have support for imap annotations. The XML storage cannot be used on this server, please re-configure KMail differently" ).arg( mAccount->host() ) ); + mAccount->setHasNoAnnotationSupport(); + } + else + kdWarning(5006) << "slotGetMultiUrlAnnotationResult: " << job->errorString() << endl; + } else { + // we got the annotation allright, let's filter out the ones with the wrong type + QMap<QString, QString> annotations = annjob->annotations(); + QMap<QString, QString>::Iterator it = annotations.begin(); + for ( ; it != annotations.end(); ++it ) { + const QString folderPath = it.key(); + const QString annotation = it.data(); + kdDebug(5006) << k_funcinfo << "Folder: " << folderPath << " has type: " << annotation << endl; + // we're only interested in the main type + QString type(annotation); + int dot = annotation.find( '.' ); + if ( dot != -1 ) type.truncate( dot ); + type = type.simplifyWhiteSpace(); + + const int idx = mSubfolderPaths.findIndex( folderPath ); + const bool isNoContent = mSubfolderMimeTypes[idx] == "inode/directory"; + if ( ( isNoContent && type.isEmpty() ) + || ( !type.isEmpty() && type != KMailICalIfaceImpl::annotationForContentsType( ContentsTypeMail ) ) ) { + folders.append( idx ); + kdDebug(5006) << k_funcinfo << " subscribing to: " << folderPath << endl; + } else { + kdDebug(5006) << k_funcinfo << " automatically unsubscribing from: " << folderPath << endl; + mAccount->changeLocalSubscription( folderPath, false ); + } + } + } + + if (mAccount->slave()) mAccount->removeJob(job); + createFoldersNewOnServerAndFinishListing( folders ); +} + +void KMFolderCachedImap::slotQuotaResult( KIO::Job* job ) +{ + KMAcctCachedImap::JobIterator it = mAccount->findJob(job); + Q_ASSERT( it != mAccount->jobsEnd() ); + if ( it == mAccount->jobsEnd() ) return; // Shouldn't happen + Q_ASSERT( (*it).parent == folder() ); + if ( (*it).parent != folder() ) return; // Shouldn't happen + + QuotaJobs::GetStorageQuotaJob* quotajob = static_cast<QuotaJobs::GetStorageQuotaJob *>( job ); + QuotaInfo empty; + if ( quotajob->error() ) { + if ( job->error() == KIO::ERR_UNSUPPORTED_ACTION ) { + // that's when the imap server doesn't support quota + mAccount->setHasNoQuotaSupport(); + setQuotaInfo( empty ); + } + else + kdWarning(5006) << "slotGetQuotaResult: " << job->errorString() << endl; + } + + if (mAccount->slave()) mAccount->removeJob(job); + mProgress += 2; + serverSyncInternal(); +} + +void +KMFolderCachedImap::slotAnnotationChanged( const QString& entry, const QString& attribute, const QString& value ) +{ + Q_UNUSED( attribute ); + Q_UNUSED( value ); + //kdDebug(5006) << k_funcinfo << entry << " " << attribute << " " << value << endl; + if ( entry == KOLAB_FOLDERTYPE ) + mAnnotationFolderTypeChanged = false; + else if ( entry == KOLAB_INCIDENCESFOR ) { + mIncidencesForChanged = false; + // The incidences-for changed, we must trigger the freebusy creation. + // HACK: in theory we would need a new enum value for this. + kmkernel->iCalIface().addFolderChange( folder(), KMailICalIfaceImpl::ACL ); + } +} + +void KMFolderCachedImap::slotTestAnnotationResult(KIO::Job *job) +{ + KMAcctCachedImap::JobIterator it = mAccount->findJob(job); + Q_ASSERT( it != mAccount->jobsEnd() ); + if ( it == mAccount->jobsEnd() ) return; // Shouldn't happen + Q_ASSERT( (*it).parent == folder() ); + if ( (*it).parent != folder() ) return; // Shouldn't happen + + mAccount->setAnnotationCheckPassed( true ); + if ( job->error() ) { + kdDebug(5006) << "Test Annotation was not passed, disabling annotation support" << endl; + mAccount->setHasNoAnnotationSupport( ); + } else { + kdDebug(5006) << "Test Annotation was passed OK" << endl; + } + if (mAccount->slave()) mAccount->removeJob(job); + serverSyncInternal(); +} + +void +KMFolderCachedImap::slotSetAnnotationResult(KIO::Job *job) +{ + KMAcctCachedImap::JobIterator it = mAccount->findJob(job); + if ( it == mAccount->jobsEnd() ) return; // Shouldn't happen + if ( (*it).parent != folder() ) return; // Shouldn't happen + + bool cont = true; + if ( job->error() ) { + // Don't show error if the server doesn't support ANNOTATEMORE and this folder only contains mail + if ( job->error() == KIO::ERR_UNSUPPORTED_ACTION && contentsType() == ContentsTypeMail ) { + if (mAccount->slave()) mAccount->removeJob(job); + } else { + cont = mAccount->handleJobError( job, i18n( "Error while setting annotation: " ) + '\n' ); + } + } else { + if (mAccount->slave()) mAccount->removeJob(job); + } + if ( cont ) + serverSyncInternal(); +} + +void KMFolderCachedImap::slotUpdateLastUid() +{ + if( mTentativeHighestUid != 0 ) { + + // Sanity checking: + // By now all new mails should be downloaded, which means + // that iteration over the folder should yield only UIDs + // lower or equal to what we think the highes ist, and the + // highest one as well. If not, our notion of the highest + // uid we've seen thus far is wrong, which is dangerous, so + // don't update the mLastUid, then. + // Not entirely true though, mails might have been moved out + // of the folder already by filters, thus giving us a higher tentative + // uid than we actually observe here. + bool sane = count() == 0; + + for (int i=0;i<count(); i++ ) { + ulong uid = getMsgBase(i)->UID(); + if ( uid > mTentativeHighestUid && uid > lastUid() ) { + kdWarning(5006) << "DANGER: Either the server listed a wrong highest uid, " + "or we parsed it wrong. Send email to adam@kde.org, please, and include this log." << endl; + kdWarning(5006) << "uid: " << uid << " mTentativeHighestUid: " << mTentativeHighestUid << endl; + assert( false ); + break; + } else { + sane = true; + } + } + if (sane) { +#if MAIL_LOSS_DEBUGGING + kdDebug(5006) << "Tentative highest UID test was sane, writing out: " << mTentativeHighestUid << endl; +#endif + setLastUid( mTentativeHighestUid ); + } + } + mTentativeHighestUid = 0; +} + +bool KMFolderCachedImap::isMoveable() const +{ + return ( hasChildren() == HasNoChildren && + !folder()->isSystemFolder() ) ? true : false; +} + +void KMFolderCachedImap::slotFolderDeletionOnServerFinished() +{ + for ( QStringList::const_iterator it = foldersForDeletionOnServer.constBegin(); + it != foldersForDeletionOnServer.constEnd(); ++it ) { + KURL url( mAccount->getUrl() ); + url.setPath( *it ); + kmkernel->iCalIface().folderDeletedOnServer( url ); + } + serverSyncInternal(); +} + +int KMFolderCachedImap::createIndexFromContentsRecursive() +{ + if ( !folder() || !folder()->child() ) + return 0; + + KMFolderNode *node = 0; + for( QPtrListIterator<KMFolderNode> it( *folder()->child() ); (node = it.current()); ++it ) { + if( !node->isDir() ) { + KMFolderCachedImap* storage = static_cast<KMFolderCachedImap*>(static_cast<KMFolder*>(node)->storage()); + kdDebug() << k_funcinfo << "Re-indexing: " << storage->folder()->label() << endl; + int rv = storage->createIndexFromContentsRecursive(); + if ( rv > 0 ) + return rv; + } + } + + return createIndexFromContents(); +} + +void KMFolderCachedImap::setAlarmsBlocked( bool blocked ) +{ + mAlarmsBlocked = blocked; +} + +bool KMFolderCachedImap::alarmsBlocked() const +{ + return mAlarmsBlocked; +} + +bool KMFolderCachedImap::isCloseToQuota() const +{ + bool closeToQuota = false; + if ( mQuotaInfo.isValid() && mQuotaInfo.max().toInt() > 0 ) { + const int ratio = mQuotaInfo.current().toInt() * 100 / mQuotaInfo.max().toInt(); + //kdDebug(5006) << "Quota ratio: " << ratio << "% " << mQuotaInfo.toString() << endl; + closeToQuota = ( ratio > 0 && ratio >= GlobalSettings::closeToQuotaThreshold() ); + } + //kdDebug(5006) << "Folder: " << folder()->prettyURL() << " is over quota: " << closeToQuota << endl; + return closeToQuota; +} + +KMCommand* KMFolderCachedImap::rescueUnsyncedMessages() +{ + QValueList<unsigned long> newMsgs = findNewMessages(); + kdDebug() << k_funcinfo << newMsgs << " of " << count() << endl; + if ( newMsgs.isEmpty() ) + return 0; + KMFolder *dest = 0; + bool manualMove = true; + while ( GlobalSettings::autoLostFoundMove() ) { + // find the inbox of this account + KMFolder *inboxFolder = kmkernel->findFolderById( QString(".%1.directory/INBOX").arg( account()->id() ) ); + if ( !inboxFolder ) { + kdWarning(5006) << k_funcinfo << "inbox not found!" << endl; + break; + } + KMFolderDir *inboxDir = inboxFolder->child(); + if ( !inboxDir && !inboxFolder->storage() ) + break; + assert( inboxFolder->storage()->folderType() == KMFolderTypeCachedImap ); + + // create lost+found folder if needed + KMFolderNode *node; + KMFolder *lfFolder = 0; + if ( !(node = inboxDir->hasNamedFolder( i18n("lost+found") )) ) { + kdDebug(5006) << k_funcinfo << "creating lost+found folder" << endl; + KMFolder* folder = kmkernel->dimapFolderMgr()->createFolder( + i18n("lost+found"), false, KMFolderTypeCachedImap, inboxDir ); + if ( !folder || !folder->storage() ) + break; + static_cast<KMFolderCachedImap*>( folder->storage() )->initializeFrom( + static_cast<KMFolderCachedImap*>( inboxFolder->storage() ) ); + folder->storage()->setContentsType( KMail::ContentsTypeMail ); + folder->storage()->writeConfig(); + lfFolder = folder; + } else { + kdDebug(5006) << k_funcinfo << "found lost+found folder" << endl; + lfFolder = dynamic_cast<KMFolder*>( node ); + } + if ( !lfFolder || !lfFolder->createChildFolder() || !lfFolder->storage() ) + break; + + // create subfolder for this incident + QDate today = QDate::currentDate(); + QString baseName = folder()->label() + "-" + QString::number( today.year() ) + + (today.month() < 10 ? "0" : "" ) + QString::number( today.month() ) + + (today.day() < 10 ? "0" : "" ) + QString::number( today.day() ); + QString name = baseName; + int suffix = 0; + while ( (node = lfFolder->child()->hasNamedFolder( name )) ) { + ++suffix; + name = baseName + '-' + QString::number( suffix ); + } + kdDebug(5006) << k_funcinfo << "creating lost+found folder " << name << endl; + dest = kmkernel->dimapFolderMgr()->createFolder( name, false, KMFolderTypeCachedImap, lfFolder->child() ); + if ( !dest || !dest->storage() ) + break; + static_cast<KMFolderCachedImap*>( dest->storage() )->initializeFrom( + static_cast<KMFolderCachedImap*>( lfFolder->storage() ) ); + dest->storage()->setContentsType( contentsType() ); + dest->storage()->writeConfig(); + + KMessageBox::sorry( 0, i18n("<p>There are new messages in folder <b>%1</b>, which " + "have not been uploaded to the server yet, but the folder has been deleted " + "on the server or you do not " + "have sufficient access rights on the folder to upload them.</p>" + "<p>All affected messages will therefore be moved to <b>%2</b> " + "to avoid data loss.</p>").arg( folder()->prettyURL() ).arg( dest->prettyURL() ), + i18n("Insufficient access rights") ); + manualMove = false; + break; + } + + if ( manualMove ) { + const QString msg ( i18n( "<p>There are new messages in this folder (%1), which " + "have not been uploaded to the server yet, but the folder has been deleted " + "on the server or you do not " + "have sufficient access rights on the folder now to upload them. " + "Please contact your administrator to allow upload of new messages " + "to you, or move them out of this folder.</p> " + "<p>Do you want to move these messages to another folder now?</p>").arg( folder()->prettyURL() ) ); + if ( KMessageBox::warningYesNo( 0, msg, QString::null, i18n("Move"), i18n("Do Not Move") ) == KMessageBox::Yes ) { + KMail::KMFolderSelDlg dlg( kmkernel->getKMMainWidget(), + i18n("Move Messages to Folder"), true ); + if ( dlg.exec() ) { + dest = dlg.folder(); + } + } + } + if ( dest ) { + QPtrList<KMMsgBase> msgs; + for( int i = 0; i < count(); ++i ) { + KMMsgBase *msg = getMsgBase( i ); + if( !msg ) continue; /* what goes on if getMsg() returns 0? */ + if ( msg->UID() == 0 ) + msgs.append( msg ); + } + KMCommand *command = new KMMoveCommand( dest, msgs ); + command->start(); + return command; + } + return 0; +} + +void KMFolderCachedImap::rescueUnsyncedMessagesAndDeleteFolder( KMFolder *folder, bool root ) +{ + kdDebug() << k_funcinfo << folder << " " << root << endl; + if ( root ) + mToBeDeletedAfterRescue.append( folder ); + folder->open("cachedimap"); + KMFolderCachedImap* storage = dynamic_cast<KMFolderCachedImap*>( folder->storage() ); + if ( storage ) { + KMCommand *command = storage->rescueUnsyncedMessages(); + if ( command ) { + connect( command, SIGNAL(completed(KMCommand*)), + SLOT(slotRescueDone(KMCommand*)) ); + ++mRescueCommandCount; + } else { + // nothing to rescue, close folder + // (we don't need to close it in the other case, it will be deleted anyway) + folder->close("cachedimap"); + } + } + if ( folder->child() ) { + KMFolderNode *node = folder->child()->first(); + while (node) { + if (!node->isDir() ) { + KMFolder *subFolder = static_cast<KMFolder*>( node ); + rescueUnsyncedMessagesAndDeleteFolder( subFolder, false ); + } + node = folder->child()->next(); + } + } +} + +void KMFolderCachedImap::slotRescueDone(KMCommand * command) +{ + // FIXME: check command result + if ( command ) + --mRescueCommandCount; + if ( mRescueCommandCount > 0 ) + return; + for ( QValueList<KMFolder*>::ConstIterator it = mToBeDeletedAfterRescue.constBegin(); + it != mToBeDeletedAfterRescue.constEnd(); ++it ) { + kmkernel->dimapFolderMgr()->remove( *it ); + } + mToBeDeletedAfterRescue.clear(); + serverSyncInternal(); +} + +#include "kmfoldercachedimap.moc" |