diff --git a/akonadi/agentbase.cpp b/akonadi/agentbase.cpp
index 296e47ebb..099739667 100644
--- a/akonadi/agentbase.cpp
+++ b/akonadi/agentbase.cpp
@@ -1,523 +1,523 @@
 /*
     Copyright (c) 2006 Till Adam <adam@kde.org>
     Copyright (c) 2007 Volker Krause <vkrause@kde.org>
     Copyright (c) 2007 Bruno Virlet <bruno.virlet@gmail.com>
     Copyright (c) 2008 Kevin Krammer <kevin.krammer@gmx.at>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library 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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "agentbase.h"
 #include "agentbase_p.h"
 
 #include "controladaptor.h"
 #include "statusadaptor.h"
 #include "monitor_p.h"
 #include "xdgbasedirs_p.h"
 
 #include "session.h"
 #include "session_p.h"
 #include "changerecorder.h"
 #include "itemfetchjob.h"
 
 #include <kaboutdata.h>
 #include <kcmdlineargs.h>
 #include <kdebug.h>
 #include <klocale.h>
 #include <kstandarddirs.h>
 
 #include <QtCore/QDir>
 #include <QtCore/QSettings>
 #include <QtCore/QTimer>
 #include <QtGui/QApplication>
 #include <QtDBus/QtDBus>
 
 #include <signal.h>
 #include <stdlib.h>
 
 using namespace Akonadi;
 
 static AgentBase *sAgentBase = 0;
 
 AgentBase::Observer::Observer()
 {
 }
 
 AgentBase::Observer::~Observer()
 {
 }
 
 void AgentBase::Observer::itemAdded( const Item &item, const Collection &collection )
 {
   kDebug() << "sAgentBase=" << (void*) sAgentBase << "this=" << (void*) this;
   Q_UNUSED( item );
   Q_UNUSED( collection );
   if ( sAgentBase != 0 )
     sAgentBase->d_ptr->changeProcessed();
 }
 
 void AgentBase::Observer::itemChanged( const Item &item, const QSet<QByteArray> &partIdentifiers )
 {
   kDebug() << "sAgentBase=" << (void*) sAgentBase << "this=" << (void*) this;
   Q_UNUSED( item );
   Q_UNUSED( partIdentifiers );
   if ( sAgentBase != 0 )
     sAgentBase->d_ptr->changeProcessed();
 }
 
 void AgentBase::Observer::itemRemoved( const Item &item )
 {
   kDebug() << "sAgentBase=" << (void*) sAgentBase << "this=" << (void*) this;
   Q_UNUSED( item );
   if ( sAgentBase != 0 )
     sAgentBase->d_ptr->changeProcessed();
 }
 
 void AgentBase::Observer::collectionAdded( const Akonadi::Collection &collection, const Akonadi::Collection &parent )
 {
   kDebug() << "sAgentBase=" << (void*) sAgentBase << "this=" << (void*) this;
   Q_UNUSED( collection );
   Q_UNUSED( parent );
   if ( sAgentBase != 0 )
     sAgentBase->d_ptr->changeProcessed();
 }
 
 void AgentBase::Observer::collectionChanged( const Collection &collection )
 {
   kDebug() << "sAgentBase=" << (void*) sAgentBase << "this=" << (void*) this;
   Q_UNUSED( collection );
   if ( sAgentBase != 0 )
     sAgentBase->d_ptr->changeProcessed();
 }
 
 void AgentBase::Observer::collectionRemoved( const Collection &collection )
 {
   kDebug() << "sAgentBase=" << (void*) sAgentBase << "this=" << (void*) this;
   Q_UNUSED( collection );
   if ( sAgentBase != 0 )
     sAgentBase->d_ptr->changeProcessed();
 }
 
 //@cond PRIVATE
 
 AgentBasePrivate::AgentBasePrivate( AgentBase *parent )
   : q_ptr( parent ),
     mStatusCode( AgentBase::Idle ),
     mProgress( 0 ),
     mNeedsNetwork( false ),
     mOnline( false ),
     mSettings( 0 ),
     mObserver( 0 )
 {
 }
 
 AgentBasePrivate::~AgentBasePrivate()
 {
   mMonitor->setConfig( 0 );
   delete mSettings;
 }
 
 void AgentBasePrivate::init()
 {
   Q_Q( AgentBase );
 
   /**
    * Create a default session for this process.
    */
   SessionPrivate::createDefaultSession( mId.toLatin1() );
 
   mTracer = new org::freedesktop::Akonadi::Tracer( QLatin1String( "org.freedesktop.Akonadi" ), QLatin1String( "/tracing" ),
                                            QDBusConnection::sessionBus(), q );
 
   new ControlAdaptor( q );
   new StatusAdaptor( q );
   if ( !QDBusConnection::sessionBus().registerObject( QLatin1String( "/" ), q, QDBusConnection::ExportAdaptors ) )
     q->error( QString::fromLatin1( "Unable to register object at dbus: %1" ).arg( QDBusConnection::sessionBus().lastError().message() ) );
 
   mSettings = new QSettings( QString::fromLatin1( "%1/agent_config_%2" ).arg( XdgBaseDirs::saveDir( "config", QLatin1String( "akonadi" ) ), mId ), QSettings::IniFormat );
 
   mMonitor = new ChangeRecorder( q );
   mMonitor->ignoreSession( Session::defaultSession() );
   mMonitor->itemFetchScope().setCacheOnly( true );
   mMonitor->setConfig( mSettings );
 
   mOnline = mSettings->value( QLatin1String( "Agent/Online" ), true ).toBool();
 
   connect( mMonitor, SIGNAL( itemAdded( const Akonadi::Item&, const Akonadi::Collection& ) ),
            SLOT( itemAdded( const Akonadi::Item&, const Akonadi::Collection& ) ) );
   connect( mMonitor, SIGNAL( itemChanged( const Akonadi::Item&, const QSet<QByteArray>& ) ),
            SLOT( itemChanged( const Akonadi::Item&, const QSet<QByteArray>& ) ) );
   connect( mMonitor, SIGNAL( itemRemoved( const Akonadi::Item& ) ),
            SLOT( itemRemoved( const Akonadi::Item& ) ) );
   connect( mMonitor, SIGNAL(collectionAdded(Akonadi::Collection,Akonadi::Collection)),
            SLOT(collectionAdded(Akonadi::Collection,Akonadi::Collection)) );
   connect( mMonitor, SIGNAL( collectionChanged( const Akonadi::Collection& ) ),
            SLOT( collectionChanged( const Akonadi::Collection& ) ) );
   connect( mMonitor, SIGNAL( collectionRemoved( const Akonadi::Collection& ) ),
            SLOT( collectionRemoved( const Akonadi::Collection& ) ) );
 
   connect( q, SIGNAL( status( int, QString ) ), q, SLOT( slotStatus( int, QString ) ) );
   connect( q, SIGNAL( percent( int ) ), q, SLOT( slotPercent( int ) ) );
   connect( q, SIGNAL( warning( QString ) ), q, SLOT( slotWarning( QString ) ) );
   connect( q, SIGNAL( error( QString ) ), q, SLOT( slotError( QString ) ) );
 
   // Use reference counting to allow agents to finish internal jobs when the
   // agent is stopped.
   KGlobal::ref();
   KGlobal::setAllowQuit(true);
 
   QTimer::singleShot( 0, q, SLOT( delayedInit() ) );
 }
 
 void AgentBasePrivate::delayedInit()
 {
   Q_Q( AgentBase );
   if ( !QDBusConnection::sessionBus().registerService( QLatin1String( "org.freedesktop.Akonadi.Agent." ) + mId ) )
     kFatal() << "Unable to register service at dbus:" << QDBusConnection::sessionBus().lastError().message();
   q->setOnline( mOnline );
 }
 
 void AgentBasePrivate::itemAdded( const Akonadi::Item &item, const Akonadi::Collection &collection )
 {
   kDebug() << "mObserver=" << (void*) mObserver << "this=" << (void*) this;
   if ( mObserver != 0 )
     mObserver->itemAdded( item, collection );
 }
 
 void AgentBasePrivate::itemChanged( const Akonadi::Item &item, const QSet<QByteArray> &partIdentifiers )
 {
   kDebug() << "mObserver=" << (void*) mObserver << "this=" << (void*) this;
   if ( mObserver != 0 )
     mObserver->itemChanged( item, partIdentifiers );
 }
 
 void AgentBasePrivate::itemRemoved( const Akonadi::Item &item )
 {
   kDebug() << "mObserver=" << (void*) mObserver << "this=" << (void*) this;
   if ( mObserver != 0 )
     mObserver->itemRemoved( item );
 }
 
 void AgentBasePrivate::collectionAdded( const Akonadi::Collection &collection, const Akonadi::Collection &parent )
 {
   kDebug() << "mObserver=" << (void*) mObserver << "this=" << (void*) this;
   if ( mObserver != 0 )
     mObserver->collectionAdded( collection, parent );
 }
 
 void AgentBasePrivate::collectionChanged( const Akonadi::Collection &collection )
 {
   kDebug() << "mObserver=" << (void*) mObserver << "this=" << (void*) this;
   if ( mObserver != 0 )
     mObserver->collectionChanged( collection );
 }
 
 void AgentBasePrivate::collectionRemoved( const Akonadi::Collection &collection )
 {
   kDebug() << "mObserver=" << (void*) mObserver << "this=" << (void*) this;
   if ( mObserver != 0 )
     mObserver->collectionRemoved( collection );
 }
 
 void AgentBasePrivate::changeProcessed()
 {
   mMonitor->changeProcessed();
   QTimer::singleShot( 0, mMonitor, SLOT( replayNext() ) );
 }
 
 void AgentBasePrivate::slotStatus( int status, const QString &message )
 {
   mStatusMessage = message;
   mStatusCode = 0;
 
   switch ( status ) {
     case AgentBase::Idle:
       if ( mStatusMessage.isEmpty() )
         mStatusMessage = defaultReadyMessage();
 
       mStatusCode = 0;
       break;
     case AgentBase::Running:
       if ( mStatusMessage.isEmpty() )
         mStatusMessage = defaultSyncingMessage();
 
       mStatusCode = 1;
       break;
     case AgentBase::Broken:
       if ( mStatusMessage.isEmpty() )
         mStatusMessage = defaultErrorMessage();
 
       mStatusCode = 2;
       break;
     default:
       Q_ASSERT( !"Unknown status passed" );
       break;
   }
 }
 
 void AgentBasePrivate::slotPercent( int progress )
 {
   mProgress = progress;
 }
 
 void AgentBasePrivate::slotWarning( const QString& message )
 {
   mTracer->warning( QString::fromLatin1( "AgentBase(%1)" ).arg( mId ), message );
 }
 
 void AgentBasePrivate::slotError( const QString& message )
 {
   mTracer->error( QString::fromLatin1( "AgentBase(%1)" ).arg( mId ), message );
 }
 
 void AgentBasePrivate::slotNetworkStatusChange( Solid::Networking::Status stat )
 {
   Q_Q( AgentBase );
   q->setOnline( stat == Solid::Networking::Connected );
 }
 
 
 AgentBase::AgentBase( const QString & id )
   : d_ptr( new AgentBasePrivate( this ) )
 {
   sAgentBase = this;
   d_ptr->mId = id;
   d_ptr->init();
   if ( KApplication::kApplication() )
     KApplication::kApplication()->disableSessionManagement();
 }
 
 AgentBase::AgentBase( AgentBasePrivate* d, const QString &id ) :
     d_ptr( d )
 {
   sAgentBase = this;
   d_ptr->mId = id;
   d_ptr->init();
 }
 
 AgentBase::~AgentBase()
 {
   delete d_ptr;
 }
 
 static char* sAgentAppName = 0;
 
 QString AgentBase::parseArguments( int argc, char **argv )
 {
   QString identifier;
   if ( argc < 3 ) {
     kDebug( 5250 ) << "Not enough arguments passed...";
     exit( 1 );
   }
 
   for ( int i = 1; i < argc - 1; ++i ) {
     if ( QLatin1String( argv[ i ] ) == QLatin1String( "--identifier" ) )
       identifier = QLatin1String( argv[ i + 1 ] );
   }
 
   if ( identifier.isEmpty() ) {
     kDebug( 5250 ) << "Identifier argument missing";
     exit( 1 );
   }
 
   sAgentAppName = qstrdup( identifier.toLatin1().constData() );
   KCmdLineArgs::init( argc, argv, sAgentAppName, 0, ki18n("Akonadi Agent"),"0.1" ,
                       ki18n("Akonadi Agent") );
 
   KCmdLineOptions options;
   options.add("identifier <argument>", ki18n("Agent identifier"));
   KCmdLineArgs::addCmdLineOptions( options );
 
   return identifier;
 }
 
 // @endcond
 
 int AgentBase::init( AgentBase *r )
 {
   QApplication::setQuitOnLastWindowClosed( false );
   KGlobal::locale()->insertCatalog( QLatin1String("libakonadi") );
   int rv = kapp->exec();
   delete r;
   delete[] sAgentAppName;
   return rv;
 }
 
 int AgentBase::status() const
 {
   Q_D( const AgentBase );
 
   return d->mStatusCode;
 }
 
 QString AgentBase::statusMessage() const
 {
   Q_D( const AgentBase );
 
   return d->mStatusMessage;
 }
 
 int AgentBase::progress() const
 {
   Q_D( const AgentBase );
 
   return d->mProgress;
 }
 
 QString AgentBase::progressMessage() const
 {
   Q_D( const AgentBase );
 
   return d->mProgressMessage;
 }
 
 bool AgentBase::isOnline() const
 {
   Q_D( const AgentBase );
 
   return d->mOnline;
 }
 
 void AgentBase::setNeedsNetwork( bool needsNetwork )
 {
   Q_D( AgentBase );
   d->mNeedsNetwork = needsNetwork;
 
   if ( d->mNeedsNetwork ) {
     connect( Solid::Networking::notifier()
            , SIGNAL( statusChanged( Solid::Networking::Status ) )
            , d, SLOT( slotNetworkStatusChange( Solid::Networking::Status ) ) );
   } else {
     disconnect( Solid::Networking::notifier(), 0, 0, 0 );
     setOnline( true );
   }
 }
 
 void AgentBase::setOnline( bool state )
 {
   Q_D( AgentBase );
   d->mOnline = state;
   d->mSettings->setValue( QLatin1String( "Agent/Online" ), state );
   doSetOnline( state );
   emit onlineChanged( state );
 }
 
 void AgentBase::doSetOnline( bool online )
 {
   Q_UNUSED( online );
 }
 
 void AgentBase::configure( WId windowId )
 {
   Q_UNUSED( windowId );
 }
 
-#ifdef Q_OS_WIN
+#ifdef Q_OS_WIN //krazy:exclude=cpp
 void AgentBase::configure( qlonglong windowId )
 {
   configure( reinterpret_cast<WId>( windowId ) );
 }
 #endif
 
 WId AgentBase::winIdForDialogs() const
 {
   bool registered = QDBusConnection::sessionBus().interface()->isServiceRegistered( QLatin1String("org.freedesktop.akonaditray") );
   if ( !registered )
     return 0;
 
   QDBusInterface dbus( QLatin1String("org.freedesktop.akonaditray"), QLatin1String("/Actions"),
                        QLatin1String("org.freedesktop.Akonadi.Tray") );
   QDBusMessage reply = dbus.call( QLatin1String("getWinId") );
 
   if ( reply.type() == QDBusMessage::ErrorMessage )
     return 0;
 
   WId winid = (WId)reply.arguments().at( 0 ).toLongLong();
   return winid;
 }
 
 void AgentBase::quit()
 {
   Q_D( AgentBase );
   aboutToQuit();
 
   if ( d->mSettings ) {
     d->mMonitor->setConfig( 0 );
     d->mSettings->sync();
   }
 
   KGlobal::deref();
 }
 
 void AgentBase::aboutToQuit()
 {
 }
 
 void AgentBase::cleanup()
 {
   Q_D( AgentBase );
   const QString fileName = d->mSettings->fileName();
 
   /*
    * First destroy the settings object...
    */
   d->mMonitor->setConfig( 0 );
   delete d->mSettings;
   d->mSettings = 0;
 
   /*
    * ... then remove the file from hd.
    */
   QFile::remove( fileName );
 
   /*
    * ... and also remove the agent configuration file if there is one.
    */
   QString configFile = KStandardDirs::locateLocal( "config", KGlobal::config()->name() );
   QFile::remove( configFile );
 
   QCoreApplication::quit();
 }
 
 void AgentBase::registerObserver( Observer *observer )
 {
   kDebug() << "observer=" << (void*) observer << "this=" << (void*) this;
   d_ptr->mObserver = observer;
 }
 
 QString AgentBase::identifier() const
 {
   return d_ptr->mId;
 }
 
 void AgentBase::changeProcessed()
 {
   Q_D( AgentBase );
   d->changeProcessed();
 }
 
 ChangeRecorder * AgentBase::changeRecorder() const
 {
   return d_ptr->mMonitor;
 }
 
 void AgentBase::reconfigure()
 {
   emit reloadConfiguration();
 }
 
 #include "agentbase.moc"
 #include "agentbase_p.moc"
diff --git a/akonadi/collectionselectjob.cpp b/akonadi/collectionselectjob.cpp
index 1a413fab3..924c7571b 100644
--- a/akonadi/collectionselectjob.cpp
+++ b/akonadi/collectionselectjob.cpp
@@ -1,95 +1,95 @@
 /*
     Copyright (c) 2006 - 2007 Volker Krause <vkrause@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library 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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "collectionselectjob.h"
 
 #include "job_p.h"
 
 #include <QtCore/QDebug>
 
 using namespace Akonadi;
 
 class Akonadi::CollectionSelectJobPrivate : public JobPrivate
 {
   public:
     CollectionSelectJobPrivate( CollectionSelectJob *parent )
       : JobPrivate( parent ),
         mUnseen( -1 ),
         mSilent( true )
     {
     }
 
     Collection mCollection;
     int mUnseen;
     bool mSilent;
 };
 
 CollectionSelectJob::CollectionSelectJob( const Collection &collection, QObject *parent )
   : Job( new CollectionSelectJobPrivate( this ), parent )
 {
   Q_D( CollectionSelectJob );
 
   d->mCollection = collection;
 }
 
 CollectionSelectJob::~CollectionSelectJob( )
 {
 }
 
 void CollectionSelectJob::doStart( )
 {
   Q_D( CollectionSelectJob );
 
   QByteArray command( d->newTag() + " SELECT " );
   if ( d->mSilent )
     command += "SILENT ";
   d->writeData( command + QByteArray::number( d->mCollection.id() ) + '\n' );
 }
 
 void CollectionSelectJob::doHandleResponse( const QByteArray & tag, const QByteArray & data )
 {
   Q_D( CollectionSelectJob );
 
   if ( tag == "*" ) {
-    if ( data.startsWith( "OK [UNSEEN" ) ) {
+    if ( data.startsWith( "OK [UNSEEN" ) ) { //krazy:exclude=strings
       int begin = data.indexOf( ' ', 4 );
       int end = data.indexOf( ']' );
       QByteArray number = data.mid( begin + 1, end - begin - 1 );
       d->mUnseen = number.toInt();
       return;
     }
   }
 }
 
 int CollectionSelectJob::unseen( ) const
 {
   Q_D( const CollectionSelectJob );
 
   return d->mUnseen;
 }
 
 void CollectionSelectJob::setRetrieveStatus(bool status)
 {
   Q_D( CollectionSelectJob );
 
   d->mSilent = !status;
 }
 
 
 #include "collectionselectjob.moc"
diff --git a/akonadi/itemmodifyjob.cpp b/akonadi/itemmodifyjob.cpp
index ac2a6915c..e633478d4 100644
--- a/akonadi/itemmodifyjob.cpp
+++ b/akonadi/itemmodifyjob.cpp
@@ -1,229 +1,229 @@
 /*
     Copyright (c) 2006 - 2007 Volker Krause <vkrause@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library 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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "itemmodifyjob.h"
 #include "itemmodifyjob_p.h"
 
 #include "collection.h"
 #include "entity_p.h"
 #include "imapparser_p.h"
 #include "itemserializer.h"
 #include "job_p.h"
 #include "item_p.h"
 #include "protocolhelper.h"
 
 #include <kdebug.h>
 
 using namespace Akonadi;
 
 ItemModifyJobPrivate::ItemModifyJobPrivate( ItemModifyJob *parent, const Item &item )
   : JobPrivate( parent ),
     mItem( item ),
     mRevCheck( true ),
     mIgnorePayload( false )
 {
   mParts = mItem.loadedPayloadParts();
 }
 
 void ItemModifyJobPrivate::setClean()
 {
   mOperations.insert( Dirty );
 }
 
 QByteArray ItemModifyJobPrivate::nextPartHeader()
 {
   QByteArray command;
   if ( !mParts.isEmpty() ) {
     QSetIterator<QByteArray> it( mParts );
     const QByteArray label = it.next();
     mParts.remove( label );
 
     mPendingData.clear();
     int version = 0;
     ItemSerializer::serialize( mItem, label, mPendingData, version );
     command += ' ' + ProtocolHelper::encodePartIdentifier( ProtocolHelper::PartPayload, label, version );
     command += ".SILENT";
     if ( mPendingData.size() > 0 ) {
       command += " {" + QByteArray::number( mPendingData.size() ) + "}\n";
     } else {
       if ( mPendingData.isNull() )
         command += " NIL";
       else
         command += " \"\"";
       command += nextPartHeader();
     }
   } else {
     command += ")\n";
   }
   return command;
 }
 
 
 ItemModifyJob::ItemModifyJob( const Item &item, QObject * parent )
   : Job( new ItemModifyJobPrivate( this, item ), parent )
 {
   Q_D( ItemModifyJob );
 
   d->mOperations.insert( ItemModifyJobPrivate::RemoteId );
 }
 
 ItemModifyJob::~ItemModifyJob()
 {
 }
 
 void ItemModifyJob::doStart()
 {
   Q_D( ItemModifyJob );
 
   QList<QByteArray> changes;
   foreach ( int op, d->mOperations ) {
     switch ( op ) {
       case ItemModifyJobPrivate::RemoteId:
         if ( !d->mItem.remoteId().isNull() ) {
           changes << "REMOTEID.SILENT";
           changes << ImapParser::quote( d->mItem.remoteId().toLatin1() );
         }
         break;
       case ItemModifyJobPrivate::Dirty:
         changes << "DIRTY.SILENT";
         changes << "false";
         break;
     }
   }
 
   if ( d->mItem.d_func()->mFlagsOverwritten ) {
     changes << "FLAGS.SILENT";
     changes << '(' + ImapParser::join( d->mItem.flags(), " " ) + ')';
   } else {
     if ( !d->mItem.d_func()->mAddedFlags.isEmpty() ) {
       changes << "+FLAGS.SILENT";
       changes << '(' + ImapParser::join( d->mItem.d_func()->mAddedFlags, " " ) + ')';
     }
     if ( !d->mItem.d_func()->mDeletedFlags.isEmpty() ) {
       changes << "-FLAGS.SILENT";
       changes << '(' + ImapParser::join( d->mItem.d_func()->mDeletedFlags, " " ) + ')';
     }
   }
 
   if ( !d->mItem.d_func()->mDeletedAttributes.isEmpty() ) {
     changes << "-PARTS.SILENT";
     QList<QByteArray> attrs;
     foreach ( const QByteArray &attr, d->mItem.d_func()->mDeletedAttributes )
       attrs << ProtocolHelper::encodePartIdentifier( ProtocolHelper::PartAttribute, attr );
     changes << '(' + ImapParser::join( attrs, " " ) + ')';
   }
 
   // nothing to do
   if ( changes.isEmpty() && d->mParts.isEmpty() && d->mItem.attributes().isEmpty() ) {
     emitResult();
     return;
   }
 
   d->mTag = d->newTag();
   QByteArray command = d->mTag;
   command += " UID STORE " + QByteArray::number( d->mItem.id() ) + ' ';
   if ( !d->mRevCheck ) {
     command += "NOREV ";
   } else {
     command += "REV " + QByteArray::number( d->mItem.revision() ) + ' ';
   }
 
   command += "SIZE " + QByteArray::number( d->mItem.size() );
 
   command += " (" + ImapParser::join( changes, " " );
   const QByteArray attrs = ProtocolHelper::attributesToByteArray( d->mItem, true );
   if ( !attrs.isEmpty() )
     command += ' ' + attrs;
   command += d->nextPartHeader();
   d->writeData( command );
   d->newTag(); // hack to circumvent automatic response handling
 }
 
 void ItemModifyJob::doHandleResponse(const QByteArray &_tag, const QByteArray & data)
 {
   Q_D( ItemModifyJob );
 
   if ( _tag == "+" ) { // ready for literal data
     d->writeData( d->mPendingData );
     d->writeData( d->nextPartHeader() );
     return;
   }
   if ( _tag == d->mTag ) {
-    if ( data.startsWith( "OK" ) ) {
+    if ( data.startsWith( "OK" ) ) { //krazy:exclude=strings
       QDateTime modificationDateTime;
       if ( int pos = data.indexOf( "DATETIME" ) ) {
         int resultPos = ImapParser::parseDateTime( data, modificationDateTime, pos + 8 );
         if ( resultPos == (pos + 8) ) {
           kDebug( 5250 ) << "Invalid DATETIME response to STORE command: "
               << _tag << data;
         }
       }
 
       // increase item revision of own copy of item
       d->mItem.setRevision( d->mItem.revision() + 1 );
       d->mItem.setModificationTime( modificationDateTime );
       d->mItem.d_ptr->resetChangeLog();
     } else {
       setError( Unknown );
       setErrorText( QString::fromUtf8( data ) );
     }
     emitResult();
     return;
   }
   kDebug( 5250 ) << "Unhandled response: " << _tag << data;
 }
 
 void ItemModifyJob::setIgnorePayload( bool ignore )
 {
   Q_D( ItemModifyJob );
 
   if ( d->mIgnorePayload == ignore )
     return;
 
   d->mIgnorePayload = ignore;
   if ( d->mIgnorePayload )
     d->mParts = QSet<QByteArray>();
   else {
     Q_ASSERT( !d->mItem.mimeType().isEmpty() );
     d->mParts = d->mItem.loadedPayloadParts();
   }
 }
 
 bool ItemModifyJob::ignorePayload() const
 {
   Q_D( const ItemModifyJob );
 
   return d->mIgnorePayload;
 }
 
 void ItemModifyJob::disableRevisionCheck()
 {
   Q_D( ItemModifyJob );
 
   d->mRevCheck = false;
 }
 
 Item ItemModifyJob::item() const
 {
   Q_D( const ItemModifyJob );
 
   return d->mItem;
 }
 
 #include "itemmodifyjob.moc"
diff --git a/akonadi/job.cpp b/akonadi/job.cpp
index 954ab82de..e92a72095 100644
--- a/akonadi/job.cpp
+++ b/akonadi/job.cpp
@@ -1,246 +1,246 @@
 /*
     Copyright (c) 2006 Tobias Koenig <tokoe@kde.org>
                   2006 Marc Mutz <mutz@kde.org>
                   2006 - 2007 Volker Krause <vkrause@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library 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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "job.h"
 #include "job_p.h"
 #include "imapparser_p.h"
 #include "session.h"
 #include "session_p.h"
 
 #include <kdebug.h>
 #include <klocale.h>
 
 #include <QtCore/QEventLoop>
 #include <QtCore/QTimer>
 #include <QtCore/QTextStream>
 #include <QtNetwork/QHostAddress>
 #include <QtNetwork/QTcpSocket>
 
 using namespace Akonadi;
 
 //@cond PRIVATE
 void JobPrivate::handleResponse( const QByteArray & tag, const QByteArray & data )
 {
   Q_Q( Job );
 
   if ( mCurrentSubJob ) {
     mCurrentSubJob->d_ptr->handleResponse( tag, data );
     return;
   }
 
   if ( tag == mTag ) {
-    if ( data.startsWith( "NO " ) || data.startsWith( "BAD " ) ) {
+    if ( data.startsWith( "NO " ) || data.startsWith( "BAD " ) ) { //krazy:exclude=strings
       QString msg = QString::fromUtf8( data );
 
       msg.remove( 0, msg.startsWith( QLatin1String( "NO " ) ) ? 3 : 4 );
 
       if ( msg.endsWith( QLatin1String( "\r\n" ) ) )
         msg.chop( 2 );
 
       q->setError( Job::Unknown );
       q->setErrorText( msg );
       q->emitResult();
       return;
-    } else if ( data.startsWith( "OK" ) ) {
+    } else if ( data.startsWith( "OK" ) ) { //krazy:exclude=strings
       q->emitResult();
       return;
     }
   }
 
   q->doHandleResponse( tag, data );
 }
 
 void JobPrivate::init( QObject *parent )
 {
   Q_Q( Job );
 
   mParentJob = dynamic_cast<Job*>( parent );
   mSession = dynamic_cast<Session*>( parent );
 
   if ( !mSession ) {
     if ( !mParentJob )
       mSession = Session::defaultSession();
     else
       mSession = mParentJob->d_ptr->mSession;
   }
 
   if ( !mParentJob )
     mSession->d->addJob( q );
   else
     mParentJob->addSubjob( q );
 }
 
 void JobPrivate::startQueued()
 {
   Q_Q( Job );
   mStarted = true;
 
   emit q->aboutToStart( q );
   q->doStart();
   QTimer::singleShot( 0, q, SLOT(startNext()) );
 }
 
 void JobPrivate::lostConnection()
 {
   Q_Q( Job );
 
   if ( mCurrentSubJob ) {
     mCurrentSubJob->d_ptr->lostConnection();
   } else {
     q->setError( Job::ConnectionFailed );
     q->kill( KJob::EmitResult );
   }
 }
 
 void JobPrivate::slotSubJobAboutToStart( Job * job )
 {
   Q_ASSERT( mCurrentSubJob == 0 );
   mCurrentSubJob = job;
 }
 
 void JobPrivate::startNext()
 {
   Q_Q( Job );
 
   if ( mStarted && !mCurrentSubJob && q->hasSubjobs() ) {
     Job *job = dynamic_cast<Akonadi::Job*>( q->subjobs().first() );
     Q_ASSERT( job );
     job->d_ptr->startQueued();
   }
 }
 
 QByteArray JobPrivate::newTag( )
 {
   if ( mParentJob )
     mTag = mParentJob->d_ptr->newTag();
   else
     mTag = QByteArray::number( mSession->d->nextTag() );
   return mTag;
 }
 
 QByteArray JobPrivate::tag() const
 {
   return mTag;
 }
 
 void JobPrivate::writeData( const QByteArray & data )
 {
   Q_ASSERT_X( !mWriteFinished, "Job::writeData()", "Calling writeData() after emitting writeFinished()" );
   mSession->d->writeData( data );
 }
 //@endcond
 
 
 Job::Job( QObject *parent )
   : KCompositeJob( parent ),
     d_ptr( new JobPrivate( this ) )
 {
   d_ptr->init( parent );
 }
 
 Job::Job( JobPrivate *dd, QObject *parent )
   : KCompositeJob( parent ),
     d_ptr( dd )
 {
   d_ptr->init( parent );
 }
 
 Job::~Job()
 {
   delete d_ptr;
 }
 
 void Job::start()
 {
 }
 
 bool Job::doKill()
 {
   return true;
 }
 
 QString Job::errorString() const
 {
   QString str;
   switch ( error() ) {
     case NoError:
       break;
     case ConnectionFailed:
       str = i18n( "Cannot connect to the Akonadi service." );
       break;
     case ProtocolVersionMismatch:
       str = i18n( "The protocol version of the Akonadi server is incompatible. Make sure you have a compatible version installed." );
       break;
     case UserCanceled:
       str = i18n( "User canceled operation." );
       break;
     case Unknown:
     default:
       str = i18n( "Unknown error." );
       break;
   }
   if ( !errorText().isEmpty() ) {
     str += QString::fromLatin1( " (%1)" ).arg( errorText() );
   }
   return str;
 }
 
 bool Job::addSubjob( KJob * job )
 {
   bool rv = KCompositeJob::addSubjob( job );
   if ( rv ) {
     connect( job, SIGNAL(aboutToStart(Akonadi::Job*)), SLOT(slotSubJobAboutToStart(Akonadi::Job*)) );
     QTimer::singleShot( 0, this, SLOT(startNext()) );
   }
   return rv;
 }
 
 bool Job::removeSubjob(KJob * job)
 {
   bool rv = KCompositeJob::removeSubjob( job );
   if ( job == d_ptr->mCurrentSubJob ) {
     d_ptr->mCurrentSubJob = 0;
     QTimer::singleShot( 0, this, SLOT(startNext()) );
   }
   return rv;
 }
 
 void Job::doHandleResponse(const QByteArray & tag, const QByteArray & data)
 {
   kDebug( 5250 ) << "Unhandled response: " << tag << data;
 }
 
 void Job::slotResult(KJob * job)
 {
   Q_ASSERT( job == d_ptr->mCurrentSubJob );
   d_ptr->mCurrentSubJob = 0;
   KCompositeJob::slotResult( job );
   if ( !job->error() )
     QTimer::singleShot( 0, this, SLOT(startNext()) );
 }
 
 void Job::emitWriteFinished()
 {
   d_ptr->mWriteFinished = true;
   emit writeFinished( this );
 }
 
 #include "job.moc"
diff --git a/akonadi/protocolhelper.cpp b/akonadi/protocolhelper.cpp
index 81b6e60a4..344936bb6 100644
--- a/akonadi/protocolhelper.cpp
+++ b/akonadi/protocolhelper.cpp
@@ -1,172 +1,172 @@
 /*
     Copyright (c) 2008 Volker Krause <vkrause@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library 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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "protocolhelper.h"
 
 #include "attributefactory.h"
 #include "imapparser_p.h"
 
 #include <QtCore/QVarLengthArray>
 
 #include <kdebug.h>
 
 using namespace Akonadi;
 
 int ProtocolHelper::parseCachePolicy(const QByteArray & data, CachePolicy & policy, int start)
 {
   QVarLengthArray<QByteArray,16> params;
   int end = Akonadi::ImapParser::parseParenthesizedList( data, params, start );
   for ( int i = 0; i < params.count() - 1; i += 2 ) {
     const QByteArray key = params[i];
     const QByteArray value = params[i + 1];
 
     if ( key == "INHERIT" )
       policy.setInheritFromParent( value == "true" );
     else if ( key == "INTERVAL" )
       policy.setIntervalCheckTime( value.toInt() );
     else if ( key == "CACHETIMEOUT" )
       policy.setCacheTimeout( value.toInt() );
     else if ( key == "SYNCONDEMAND" )
       policy.setSyncOnDemand( value == "true" );
     else if ( key == "LOCALPARTS" ) {
       QVarLengthArray<QByteArray,16> tmp;
       QStringList parts;
       Akonadi::ImapParser::parseParenthesizedList( value, tmp );
       for ( int j=0; j<tmp.size(); j++ )
         parts << QString::fromLatin1( tmp[j] );
       policy.setLocalParts( parts );
     }
   }
   return end;
 }
 
 QByteArray ProtocolHelper::cachePolicyToByteArray(const CachePolicy & policy)
 {
   QByteArray rv = "CACHEPOLICY (";
   if ( policy.inheritFromParent() ) {
     rv += "INHERIT true";
   } else {
     rv += "INHERIT false";
     rv += " INTERVAL " + QByteArray::number( policy.intervalCheckTime() );
     rv += " CACHETIMEOUT " + QByteArray::number( policy.cacheTimeout() );
     rv += " SYNCONDEMAND " + ( policy.syncOnDemand() ? QByteArray("true") : QByteArray("false") );
     rv += " LOCALPARTS (" + policy.localParts().join( QLatin1String(" ") ).toLatin1() + ')';
   }
   rv += ')';
   return rv;
 }
 
 int ProtocolHelper::parseCollection(const QByteArray & data, Collection & collection, int start)
 {
   int pos = start;
 
   // collection and parent id
   Collection::Id colId = -1;
   bool ok = false;
   pos = ImapParser::parseNumber( data, colId, &ok, pos );
   if ( !ok || colId <= 0 ) {
     kDebug( 5250 ) << "Could not parse collection id from response:" << data;
     return start;
   }
 
   Collection::Id parentId = -1;
   pos = ImapParser::parseNumber( data, parentId, &ok, pos );
   if ( !ok || parentId < 0 ) {
     kDebug( 5250 ) << "Could not parse parent id from response:" << data;
     return start;
   }
 
   collection = Collection( colId );
   collection.setParent( parentId );
 
   // attributes
   QVarLengthArray<QByteArray,16> attributes;
   pos = ImapParser::parseParenthesizedList( data, attributes, pos );
 
   for ( int i = 0; i < attributes.count() - 1; i += 2 ) {
     const QByteArray key = attributes[i];
     const QByteArray value = attributes[i + 1];
 
     if ( key == "NAME" ) {
       collection.setName( QString::fromUtf8( value ) );
     } else if ( key == "REMOTEID" ) {
       collection.setRemoteId( QString::fromUtf8( value ) );
     } else if ( key == "RESOURCE" ) {
       collection.setResource( QString::fromUtf8( value ) );
     } else if ( key == "MIMETYPE" ) {
       QVarLengthArray<QByteArray,16> ct;
       ImapParser::parseParenthesizedList( value, ct );
       QStringList ct2;
       for ( int j = 0; j < ct.size(); j++ )
         ct2 << QString::fromLatin1( ct[j] );
       collection.setContentMimeTypes( ct2 );
     } else if ( key == "CACHEPOLICY" ) {
       CachePolicy policy;
       ProtocolHelper::parseCachePolicy( value, policy );
       collection.setCachePolicy( policy );
     } else {
       Attribute* attr = AttributeFactory::createAttribute( key );
       Q_ASSERT( attr );
       attr->deserialize( value );
       collection.addAttribute( attr );
     }
   }
 
   return pos;
 }
 
 QByteArray ProtocolHelper::attributesToByteArray(const Entity & entity, bool ns )
 {
   QList<QByteArray> l;
   foreach ( const Attribute *attr, entity.attributes() ) {
     l << encodePartIdentifier( ns ? PartAttribute : PartGlobal, attr->type() );
     l << ImapParser::quote( attr->serialized() );
   }
   return ImapParser::join( l, " " );
 }
 
 QByteArray ProtocolHelper::encodePartIdentifier(PartNamespace ns, const QByteArray & label, int version )
 {
   const QByteArray versionString( version != 0 ? '[' + QByteArray::number( version ) + ']' : "" );
   switch ( ns ) {
     case PartGlobal:
       return label + versionString;
     case PartPayload:
       return "PLD:" + label + versionString;
     case PartAttribute:
       return "ATR:" + label + versionString;
     default:
       Q_ASSERT( false );
   }
   return QByteArray();
 }
 
 QByteArray ProtocolHelper::decodePartIdentifier( const QByteArray &data, PartNamespace & ns )
 {
-  if ( data.startsWith( "PLD:" ) ) {
+  if ( data.startsWith( "PLD:" ) ) { //krazy:exclude=strings
     ns = PartPayload;
     return data.mid( 4 );
-  } else if ( data.startsWith( "ATR:" ) ) {
+  } else if ( data.startsWith( "ATR:" ) ) { //krazy:exclude=strings
     ns = PartAttribute;
     return data.mid( 4 );
   } else {
     ns = PartGlobal;
     return data;
   }
 }
diff --git a/akonadi/session.cpp b/akonadi/session.cpp
index cd67493f5..8d9fd663d 100644
--- a/akonadi/session.cpp
+++ b/akonadi/session.cpp
@@ -1,297 +1,297 @@
 /*
     Copyright (c) 2007 Volker Krause <vkrause@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library 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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "session.h"
 #include "session_p.h"
 
 #include "imapparser_p.h"
 #include "job.h"
 #include "job_p.h"
 #include "servermanager_p.h"
 #include "xdgbasedirs_p.h"
 
 #include <kdebug.h>
 #include <klocale.h>
 
 #include <QCoreApplication>
 #include <QtCore/QDir>
 #include <QtCore/QQueue>
 #include <QtCore/QThreadStorage>
 #include <QtCore/QTimer>
 
 #include <QtNetwork/QLocalSocket>
 
 #define PIPELINE_LENGTH 2
 
 using namespace Akonadi;
 
 
 //@cond PRIVATE
 
 void SessionPrivate::startNext()
 {
   QTimer::singleShot( 0, mParent, SLOT(doStartNext()) );
 }
 
 void SessionPrivate::reconnect()
 {
   // should be checking connection method and value validity
   if ( socket->state() != QLocalSocket::ConnectedState &&
        socket->state() != QLocalSocket::ConnectingState ) {
 #ifdef Q_OS_WIN  //krazy:exclude=cpp
     const QString namedPipe = mConnectionSettings->value( QLatin1String( "Data/NamedPipe" ), QLatin1String( "Akonadi" ) ).toString();
     socket->connectToServer( namedPipe );
 #else
     const QString defaultSocketDir = XdgBaseDirs::saveDir( "data", QLatin1String( "akonadi" ) );
     const QString path = mConnectionSettings->value( QLatin1String( "Data/UnixPath" ), defaultSocketDir + QLatin1String( "/akonadiserver.socket" ) ).toString();
     socket->connectToServer( path );
 #endif
   }
 }
 
 void SessionPrivate::socketError()
 {
   if ( currentJob )
     currentJob->d_ptr->lostConnection();
   connected = false;
   QTimer::singleShot( 1000, mParent, SLOT(reconnect()) );
 }
 
 void SessionPrivate::dataReceived()
 {
   while ( socket->bytesAvailable() > 0 ) {
     if ( parser->continuationSize() > 1 ) {
       const QByteArray data = socket->read( qMin( socket->bytesAvailable(), parser->continuationSize() - 1 ) );
       parser->parseBlock( data );
     } else if ( socket->canReadLine() ) {
       if ( !parser->parseNextLine( socket->readLine() ) )
         continue; // response not yet completed
 
       // handle login response
       if ( parser->tag() == QByteArray("0") ) {
-        if ( parser->data().startsWith( "OK" ) ) {
+        if ( parser->data().startsWith( "OK" ) ) { //krazy:exclude=strings
           connected = true;
           startNext();
         } else {
           kWarning( 5250 ) << "Unable to login to Akonadi server:" << parser->data();
           socket->close();
           QTimer::singleShot( 1000, mParent, SLOT(reconnect()) );
         }
       }
 
       // send login command
       if ( parser->tag() == "*" && parser->data().startsWith( "OK Akonadi" ) ) {
         const int pos = parser->data().indexOf( "[PROTOCOL" );
         if ( pos > 0 ) {
           qint64 tmp = 0;
           ImapParser::parseNumber( parser->data(), tmp, 0, pos + 9 );
           protocolVersion = tmp;
           Internal::setServerProtocolVersion( tmp );
         }
         kDebug( 5250 ) << "Server protocol version is:" << protocolVersion;
 
         writeData( "0 LOGIN " + sessionId + '\n' );
 
       // work for the current job
       } else {
         if ( currentJob )
           currentJob->d_ptr->handleResponse( parser->tag(), parser->data() );
       }
 
       // reset parser stuff
       parser->reset();
     } else {
       break; // nothing we can do for now
     }
   }
 }
 
 bool SessionPrivate::canPipelineNext()
 {
   if ( queue.isEmpty() || pipeline.count() >= PIPELINE_LENGTH )
     return false;
   if ( pipeline.isEmpty() && currentJob )
     return currentJob->d_ptr->mWriteFinished;
   if ( !pipeline.isEmpty() )
     return pipeline.last()->d_ptr->mWriteFinished;
   return false;
 }
 
 void SessionPrivate::doStartNext()
 {
   if ( !connected || (queue.isEmpty() && pipeline.isEmpty()) )
     return;
   if ( canPipelineNext() ) {
     Akonadi::Job *nextJob = queue.dequeue();
     pipeline.enqueue( nextJob );
     startJob( nextJob );
   }
   if ( jobRunning )
     return;
   jobRunning = true;
   if ( !pipeline.isEmpty() ) {
     currentJob = pipeline.dequeue();
   } else {
     currentJob = queue.dequeue();
     startJob( currentJob );
   }
 }
 
 void SessionPrivate::startJob( Job *job )
 {
   if ( protocolVersion < minimumProtocolVersion() ) {
     job->setError( Job::ProtocolVersionMismatch );
     job->setErrorText( i18n( "Protocol version %1 found, expected at least %2", protocolVersion, minimumProtocolVersion() ) );
     job->emitResult();
   } else {
     job->d_ptr->startQueued();
   }
 }
 
 void SessionPrivate::jobDone(KJob * job)
 {
   if( job == currentJob ) {
     if ( pipeline.isEmpty() ) {
       jobRunning = false;
       currentJob = 0;
     } else {
       currentJob = pipeline.dequeue();
     }
     startNext();
   }
   // ### better handle the other cases too, user might have canceled jobs
   else {
     kDebug( 5250 ) << job << "Non-current job finished.";
   }
 }
 
 void SessionPrivate::jobWriteFinished( Akonadi::Job* job )
 {
   Q_ASSERT( (job == currentJob && pipeline.isEmpty()) || (job = pipeline.last()) );
   startNext();
 }
 
 void SessionPrivate::jobDestroyed(QObject * job)
 {
   queue.removeAll( static_cast<Akonadi::Job*>( job ) );
   // ### likely not enough to really cancel already running jobs
   pipeline.removeAll( static_cast<Akonadi::Job*>( job ) );
   if ( currentJob == job )
     currentJob = 0;
 }
 
 void SessionPrivate::addJob(Job * job)
 {
   queue.append( job );
   QObject::connect( job, SIGNAL(result(KJob*)), mParent, SLOT(jobDone(KJob*)) );
   QObject::connect( job, SIGNAL(writeFinished(Akonadi::Job*)), mParent, SLOT(jobWriteFinished(Akonadi::Job*)) );
   QObject::connect( job, SIGNAL(destroyed(QObject*)), mParent, SLOT(jobDestroyed(QObject*)) );
   startNext();
 }
 
 int SessionPrivate::nextTag()
 {
   return theNextTag++;
 }
 
 void SessionPrivate::writeData(const QByteArray & data)
 {
   socket->write( data );
 }
 
 //@endcond
 
 
 Session::Session(const QByteArray & sessionId, QObject * parent) :
     QObject( parent ),
     d( new SessionPrivate( this ) )
 {
   if ( !sessionId.isEmpty() ) {
     d->sessionId = sessionId;
   } else {
     d->sessionId = QCoreApplication::instance()->applicationName().toUtf8()
-        + "-" + QByteArray::number( qrand() );
+        + '-' + QByteArray::number( qrand() );
   }
 
   d->connected = false;
   d->theNextTag = 1;
   d->currentJob = 0;
   d->jobRunning = false;
 
   const QString connectionConfigFile = XdgBaseDirs::akonadiConnectionConfigFile();
 
   QFileInfo fileInfo( connectionConfigFile );
   if ( !fileInfo.exists() ) {
     kWarning( 5250 ) << "Akonadi Client Session: connection config file '"
                      << "akonadi/akonadiconnectionrc can not be found in '"
                      << XdgBaseDirs::homePath( "config" ) << "' nor in any of "
                      << XdgBaseDirs::systemPathList( "config" );
   }
 
   d->mConnectionSettings = new QSettings( connectionConfigFile, QSettings::IniFormat );
 
   // should check connection method
   d->socket = new QLocalSocket( this );
 
   connect( d->socket, SIGNAL(disconnected()), SLOT(socketError()) );
   connect( d->socket, SIGNAL(error(QLocalSocket::LocalSocketError)), SLOT(socketError()) );
   connect( d->socket, SIGNAL(readyRead()), SLOT(dataReceived()) );
   d->reconnect();
 }
 
 Session::~Session()
 {
   clear();
   delete d;
 }
 
 QByteArray Session::sessionId() const
 {
   return d->sessionId;
 }
 
 QThreadStorage<Session*> instances;
 
 void SessionPrivate::createDefaultSession( const QByteArray &sessionId )
 {
   Q_ASSERT_X( !sessionId.isEmpty(), "SessionPrivate::createDefaultSession",
               "You tried to create a default session with empty session id!" );
   Q_ASSERT_X( !instances.hasLocalData(), "SessionPrivate::createDefaultSession",
               "You tried to create a default session twice!" );
 
   instances.setLocalData( new Session( sessionId ) );
 }
 
 Session* Session::defaultSession()
 {
   if ( !instances.hasLocalData() )
     instances.setLocalData( new Session() );
   return instances.localData();
 }
 
 void Session::clear()
 {
   foreach ( Job* job, d->queue )
     job->kill( KJob::EmitResult );
   d->queue.clear();
   if ( d->currentJob )
     d->currentJob->kill( KJob::EmitResult );
 }
 
 #include "session.moc"
diff --git a/akonadi/subscriptionjob.cpp b/akonadi/subscriptionjob.cpp
index 659c7381a..7b532e529 100644
--- a/akonadi/subscriptionjob.cpp
+++ b/akonadi/subscriptionjob.cpp
@@ -1,115 +1,115 @@
 /*
     Copyright (c) 2007 Volker Krause <vkrause@kde.org>
 
     This library is free software; you can redistribute it and/or modify it
     under the terms of the GNU Library General Public License as published by
     the Free Software Foundation; either version 2 of the License, or (at your
     option) any later version.
 
     This library 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 Library General Public
     License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     02110-1301, USA.
 */
 
 #include "subscriptionjob.h"
 
 #include "job_p.h"
 
 using namespace Akonadi;
 
 class Akonadi::SubscriptionJobPrivate : public JobPrivate
 {
   public:
     SubscriptionJobPrivate( SubscriptionJob *parent )
       : JobPrivate( parent )
     {
     }
 
     void sendCommand( const QByteArray &cmd, const Collection::List &list )
     {
       Q_Q( SubscriptionJob );
 
       mTag = newTag();
       QByteArray line = mTag + ' ' + cmd;
       foreach ( const Collection &col, list )
         line += ' ' + QByteArray::number( col.id() );
       line += '\n';
       writeData( line );
       newTag(); // prevent automatic response handling
     }
 
     void sendNextCommand()
     {
       Q_Q( SubscriptionJob );
 
       QByteArray cmd;
       if ( !mSub.isEmpty() ) {
         sendCommand( "SUBSCRIBE", mSub );
         mSub.clear();
       } else if ( !mUnsub.isEmpty() ) {
         sendCommand( "UNSUBSCRIBE", mUnsub );
         mUnsub.clear();
       } else {
         q->emitResult();
       }
     }
 
     Q_DECLARE_PUBLIC( SubscriptionJob )
 
     QByteArray mTag;
     Collection::List mSub, mUnsub;
 };
 
 SubscriptionJob::SubscriptionJob(QObject * parent)
   : Job( new SubscriptionJobPrivate( this ), parent )
 {
 }
 
 SubscriptionJob::~SubscriptionJob()
 {
 }
 
 void SubscriptionJob::subscribe(const Collection::List & list)
 {
   Q_D( SubscriptionJob );
 
   d->mSub = list;
 }
 
 void SubscriptionJob::unsubscribe(const Collection::List & list)
 {
   Q_D( SubscriptionJob );
 
   d->mUnsub = list;
 }
 
 void SubscriptionJob::doStart()
 {
   Q_D( SubscriptionJob );
 
   d->sendNextCommand();
 }
 
 void SubscriptionJob::doHandleResponse(const QByteArray &_tag, const QByteArray & data)
 {
   Q_D( SubscriptionJob );
 
   if ( _tag == d->mTag ) {
-    if ( data.startsWith( "OK" ) ) {
+    if ( data.startsWith( "OK" ) ) { //krazy:exclude=strings
       d->sendNextCommand();
     } else {
       setError( Unknown );
       setErrorText( QString::fromUtf8( data ) );
       emitResult();
     }
     return;
   }
 }
 
 #include "subscriptionjob.moc"