connection of an imap operation is now set when it's started (#783)

6 files changed, 267 insertions, 72 deletions

diff --git a/src/async/imap/MCIMAPAsyncConnection.cc b/src/async/imap/MCIMAPAsyncConnection.cc
index 2f685ca3..12eeff38 100755
--- a/src/async/imap/MCIMAPAsyncConnection.cc
+++ b/src/async/imap/MCIMAPAsyncConnection.cc
@@ -249,6 +249,7 @@ IMAPIdentity * IMAPAsyncConnection::clientIdentity()
     return mClientIdentity;
 }
 
+#if 0
 IMAPFolderInfoOperation * IMAPAsyncConnection::folderInfoOperation(String * folder)
 {
     IMAPFolderInfoOperation * op = new IMAPFolderInfoOperation();
@@ -537,6 +538,7 @@ IMAPQuotaOperation * IMAPAsyncConnection::quotaOperation()
     op->autorelease();
     return op;
 }
+#endif
 
 IMAPOperation * IMAPAsyncConnection::disconnectOperation()
 {
@@ -679,6 +681,7 @@ void IMAPAsyncConnection::logConnection(ConnectionLogType logType, Data * buffer
     pthread_mutex_unlock(&mConnectionLoggerLock);
 }
 
+#if 0
 IMAPMessageRenderingOperation * IMAPAsyncConnection::renderingOperation(IMAPMessage * message,
                                                                         String * folder,
                                                                         IMAPMessageRenderingType type)
@@ -718,6 +721,7 @@ IMAPMessageRenderingOperation * IMAPAsyncConnection::plainTextBodyRenderingOpera
                               stripWhitespace ? IMAPMessageRenderingTypePlainTextBodyAndStripWhitespace :
                                                 IMAPMessageRenderingTypePlainTextBody);
 }
+#endif
 
 void IMAPAsyncConnection::setAutomaticConfigurationEnabled(bool enabled)
 {
diff --git a/src/async/imap/MCIMAPAsyncConnection.h b/src/async/imap/MCIMAPAsyncConnection.h
index 6af22b50..baeb04b9 100755
--- a/src/async/imap/MCIMAPAsyncConnection.h
+++ b/src/async/imap/MCIMAPAsyncConnection.h
@@ -86,6 +86,7 @@ namespace mailcore {
         virtual dispatch_queue_t dispatchQueue();
 #endif
         
+#if 0
         virtual IMAPFolderInfoOperation * folderInfoOperation(String * folder);
         virtual IMAPFolderStatusOperation * folderStatusOperation(String * folder);
         
@@ -130,18 +131,20 @@ namespace mailcore {
         
         virtual IMAPOperation * connectOperation();
         virtual IMAPOperation * checkAccountOperation();
-        virtual IMAPOperation * disconnectOperation();
         
         virtual IMAPOperation * noopOperation();
         
         virtual IMAPCapabilityOperation * capabilityOperation();
         virtual IMAPQuotaOperation * quotaOperation();
+#endif
+        virtual IMAPOperation * disconnectOperation();
         
+#if 0
         virtual IMAPMessageRenderingOperation * htmlRenderingOperation(IMAPMessage * message, String * folder);
         virtual IMAPMessageRenderingOperation * htmlBodyRenderingOperation(IMAPMessage * message, String * folder);
         virtual IMAPMessageRenderingOperation * plainTextRenderingOperation(IMAPMessage * message, String * folder);
         virtual IMAPMessageRenderingOperation * plainTextBodyRenderingOperation(IMAPMessage * message, String * folder, bool stripWhitespace);
-        
+#endif
         
     private:
         IMAPSession * mSession;
diff --git a/src/async/imap/MCIMAPAsyncSession.cc b/src/async/imap/MCIMAPAsyncSession.cc
index 1f1808df..68625746 100755
--- a/src/async/imap/MCIMAPAsyncSession.cc
+++ b/src/async/imap/MCIMAPAsyncSession.cc
@@ -16,6 +16,33 @@
 #include "MCIMAPIdentity.h"
 #include "MCIMAPMultiDisconnectOperation.h"
 
+#include "MCIMAPFolderInfoOperation.h"
+#include "MCIMAPFolderStatusOperation.h"
+#include "MCIMAPFetchFoldersOperation.h"
+#include "MCIMAPRenameFolderOperation.h"
+#include "MCIMAPDeleteFolderOperation.h"
+#include "MCIMAPCreateFolderOperation.h"
+#include "MCIMAPSubscribeFolderOperation.h"
+#include "MCIMAPExpungeOperation.h"
+#include "MCIMAPAppendMessageOperation.h"
+#include "MCIMAPCopyMessagesOperation.h"
+#include "MCIMAPFetchMessagesOperation.h"
+#include "MCIMAPFetchContentOperation.h"
+#include "MCIMAPFetchContentOperation.h"
+#include "MCIMAPStoreFlagsOperation.h"
+#include "MCIMAPStoreLabelsOperation.h"
+#include "MCIMAPSearchOperation.h"
+#include "MCIMAPConnectOperation.h"
+#include "MCIMAPCheckAccountOperation.h"
+#include "MCIMAPFetchNamespaceOperation.h"
+#include "MCIMAPIdleOperation.h"
+#include "MCIMAPIdentityOperation.h"
+#include "MCIMAPCapabilityOperation.h"
+#include "MCIMAPQuotaOperation.h"
+#include "MCIMAPDisconnectOperation.h"
+#include "MCIMAPNoopOperation.h"
+#include "MCIMAPMessageRenderingOperation.h"
+
 #define DEFAULT_MAX_CONNECTIONS 3
 
 using namespace mailcore;
@@ -321,180 +348,293 @@ IMAPAsyncConnection * IMAPAsyncSession::matchingSessionForFolder(String * folder
 
 IMAPFolderInfoOperation * IMAPAsyncSession::folderInfoOperation(String * folder)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->folderInfoOperation(folder);
+    IMAPFolderInfoOperation * op = new IMAPFolderInfoOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->autorelease();
+    return op;
 }
 
 IMAPFolderStatusOperation * IMAPAsyncSession::folderStatusOperation(String * folder)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->folderStatusOperation(folder);
+    IMAPFolderStatusOperation * op = new IMAPFolderStatusOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->autorelease();
+    return op;
 }
 
 IMAPFetchFoldersOperation * IMAPAsyncSession::fetchSubscribedFoldersOperation()
 {
-    IMAPAsyncConnection * session = sessionForFolder(NULL);
-    return session->fetchSubscribedFoldersOperation();
+    IMAPFetchFoldersOperation * op = new IMAPFetchFoldersOperation();
+    op->setMainSession(this);
+    op->setFetchSubscribedEnabled(true);
+    op->autorelease();
+    return op;
 }
 
 IMAPFetchFoldersOperation * IMAPAsyncSession::fetchAllFoldersOperation()
 {
-    IMAPAsyncConnection * session = sessionForFolder(NULL);
-    return session->fetchAllFoldersOperation();
+    IMAPFetchFoldersOperation * op = new IMAPFetchFoldersOperation();
+    op->setMainSession(this);
+    op->autorelease();
+    return op;
 }
 
 IMAPOperation * IMAPAsyncSession::renameFolderOperation(String * folder, String * otherName)
 {
-    IMAPAsyncConnection * session = sessionForFolder(NULL);
-    return session->renameFolderOperation(folder, otherName);
+    IMAPRenameFolderOperation * op = new IMAPRenameFolderOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->setOtherName(otherName);
+    op->autorelease();
+    return op;
 }
 
 IMAPOperation * IMAPAsyncSession::deleteFolderOperation(String * folder)
 {
-    IMAPAsyncConnection * session = sessionForFolder(NULL);
-    return session->deleteFolderOperation(folder);
+    IMAPDeleteFolderOperation * op = new IMAPDeleteFolderOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->autorelease();
+    return op;
 }
 
 IMAPOperation * IMAPAsyncSession::createFolderOperation(String * folder)
 {
-    IMAPAsyncConnection * session = sessionForFolder(NULL);
-    return session->createFolderOperation(folder);
+    IMAPCreateFolderOperation * op = new IMAPCreateFolderOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->autorelease();
+    return op;
 }
 
 IMAPOperation * IMAPAsyncSession::subscribeFolderOperation(String * folder)
 {
-    IMAPAsyncConnection * session = sessionForFolder(NULL);
-    return session->subscribeFolderOperation(folder);
+    IMAPSubscribeFolderOperation * op = new IMAPSubscribeFolderOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->autorelease();
+    return op;
 }
 
 IMAPOperation * IMAPAsyncSession::unsubscribeFolderOperation(String * folder)
 {
-    IMAPAsyncConnection * session = sessionForFolder(NULL);
-    return session->unsubscribeFolderOperation(folder);
+    IMAPSubscribeFolderOperation * op = new IMAPSubscribeFolderOperation();
+    op->setMainSession(this);
+    op->setUnsubscribeEnabled(true);
+    op->setFolder(folder);
+    op->autorelease();
+    return op;
 }
 
 IMAPAppendMessageOperation * IMAPAsyncSession::appendMessageOperation(String * folder, Data * messageData, MessageFlag flags, Array * customFlags)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->appendMessageOperation(folder, messageData, flags, customFlags);
+    IMAPAppendMessageOperation * op = new IMAPAppendMessageOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->setMessageData(messageData);
+    op->setFlags(flags);
+    op->setCustomFlags(customFlags);
+    op->autorelease();
+    return op;
 }
 
 IMAPCopyMessagesOperation * IMAPAsyncSession::copyMessagesOperation(String * folder, IndexSet * uids, String * destFolder)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->copyMessagesOperation(folder, uids, destFolder);
+    IMAPCopyMessagesOperation * op = new IMAPCopyMessagesOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->setUids(uids);
+    op->setDestFolder(destFolder);
+    op->autorelease();
+    return op;
 }
 
 IMAPOperation * IMAPAsyncSession::expungeOperation(String * folder)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->expungeOperation(folder);
+    IMAPExpungeOperation * op = new IMAPExpungeOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->autorelease();
+    return op;
 }
 
 IMAPFetchMessagesOperation * IMAPAsyncSession::fetchMessagesByUIDOperation(String * folder, IMAPMessagesRequestKind requestKind,
                                                                            IndexSet * uids)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->fetchMessagesByUIDOperation(folder, requestKind, uids);
+    IMAPFetchMessagesOperation * op = new IMAPFetchMessagesOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->setKind(requestKind);
+    op->setFetchByUidEnabled(true);
+    op->setIndexes(uids);
+    op->autorelease();
+    return op;
 }
 
 IMAPFetchMessagesOperation * IMAPAsyncSession::fetchMessagesByNumberOperation(String * folder, IMAPMessagesRequestKind requestKind,
                                                                               IndexSet * numbers)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->fetchMessagesByNumberOperation(folder, requestKind, numbers);
+    IMAPFetchMessagesOperation * op = new IMAPFetchMessagesOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->setKind(requestKind);
+    op->setIndexes(numbers);
+    op->autorelease();
+    return op;
 }
 
 IMAPFetchMessagesOperation * IMAPAsyncSession::syncMessagesByUID(String * folder, IMAPMessagesRequestKind requestKind,
                                                                  IndexSet * uids, uint64_t modSeq)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->syncMessagesByUID(folder, requestKind, uids, modSeq);
+    IMAPFetchMessagesOperation * op = new IMAPFetchMessagesOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->setKind(requestKind);
+    op->setFetchByUidEnabled(true);
+    op->setIndexes(uids);
+    op->setModSequenceValue(modSeq);
+    op->autorelease();
+    return op;
 }
 
 IMAPFetchContentOperation * IMAPAsyncSession::fetchMessageByUIDOperation(String * folder, uint32_t uid, bool urgent)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder, urgent);
-    return session->fetchMessageByUIDOperation(folder, uid);
+    IMAPFetchContentOperation * op = new IMAPFetchContentOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->setUid(uid);
+    op->setUrgent(urgent);
+    op->autorelease();
+    return op;
 }
 
 IMAPFetchContentOperation * IMAPAsyncSession::fetchMessageAttachmentByUIDOperation(String * folder, uint32_t uid, String * partID,
                                                                          Encoding encoding, bool urgent)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder, urgent);
-    return session->fetchMessageAttachmentByUIDOperation(folder, uid, partID, encoding);
+    IMAPFetchContentOperation * op = new IMAPFetchContentOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->setUid(uid);
+    op->setPartID(partID);
+    op->setEncoding(encoding);
+    op->setUrgent(urgent);
+    op->autorelease();
+    return op;
 }
 
 IMAPOperation * IMAPAsyncSession::storeFlagsOperation(String * folder, IndexSet * uids, IMAPStoreFlagsRequestKind kind, MessageFlag flags, Array * customFlags)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->storeFlagsOperation(folder, uids, kind, flags, customFlags);
+    IMAPStoreFlagsOperation * op = new IMAPStoreFlagsOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->setUids(uids);
+    op->setKind(kind);
+    op->setFlags(flags);
+    op->setCustomFlags(customFlags);
+    op->autorelease();
+    return op;
 }
 
 IMAPOperation * IMAPAsyncSession::storeLabelsOperation(String * folder, IndexSet * uids, IMAPStoreFlagsRequestKind kind, Array * labels)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->storeLabelsOperation(folder, uids, kind, labels);
+    IMAPStoreLabelsOperation * op = new IMAPStoreLabelsOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->setUids(uids);
+    op->setKind(kind);
+    op->setLabels(labels);
+    op->autorelease();
+    return op;
 }
 
 IMAPSearchOperation * IMAPAsyncSession::searchOperation(String * folder, IMAPSearchKind kind, String * searchString)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->searchOperation(folder, kind, searchString);
+    IMAPSearchOperation * op = new IMAPSearchOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->setSearchKind(kind);
+    op->setSearchString(searchString);
+    op->autorelease();
+    return op;
 }
 
 IMAPSearchOperation * IMAPAsyncSession::searchOperation(String * folder, IMAPSearchExpression * expression)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->searchOperation(folder, expression);
+    IMAPSearchOperation * op = new IMAPSearchOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->setSearchExpression(expression);
+    op->autorelease();
+    return op;
 }
 
 IMAPIdleOperation * IMAPAsyncSession::idleOperation(String * folder, uint32_t lastKnownUID)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->idleOperation(folder, lastKnownUID);
+    IMAPIdleOperation * op = new IMAPIdleOperation();
+    op->setMainSession(this);
+    op->setFolder(folder);
+    op->setLastKnownUID(lastKnownUID);
+    op->autorelease();
+    return op;
 }
 
 IMAPFetchNamespaceOperation * IMAPAsyncSession::fetchNamespaceOperation()
 {
-    IMAPAsyncConnection * session = sessionForFolder(NULL);
-    return session->fetchNamespaceOperation();
+    IMAPFetchNamespaceOperation * op = new IMAPFetchNamespaceOperation();
+    op->setMainSession(this);
+    op->autorelease();
+    return op;
 }
 
 IMAPIdentityOperation * IMAPAsyncSession::identityOperation(IMAPIdentity * identity)
 {
-    IMAPAsyncConnection * session = sessionForFolder(NULL);
-    return session->identityOperation(identity);
+    IMAPIdentityOperation * op = new IMAPIdentityOperation();
+    op->setMainSession(this);
+    op->setClientIdentity(identity);
+    op->autorelease();
+    return op;
 }
 
 IMAPOperation * IMAPAsyncSession::connectOperation()
 {
-    IMAPAsyncConnection * session = sessionForFolder(NULL);
-    return session->connectOperation();
+    IMAPConnectOperation * op = new IMAPConnectOperation();
+    op->setMainSession(this);
+    op->autorelease();
+    return op;
 }
 
 IMAPOperation * IMAPAsyncSession::checkAccountOperation()
 {
-    IMAPAsyncConnection * session = sessionForFolder(NULL);
-    return session->checkAccountOperation();
+    IMAPCheckAccountOperation * op = new IMAPCheckAccountOperation();
+    op->setMainSession(this);
+    op->autorelease();
+    return op;
 }
 
 IMAPCapabilityOperation * IMAPAsyncSession::capabilityOperation()
 {
-    IMAPAsyncConnection * session = sessionForFolder(NULL);
-    return session->capabilityOperation();
+    IMAPCapabilityOperation * op = new IMAPCapabilityOperation();
+    op->setMainSession(this);
+    op->autorelease();
+    return op;
 }
 
 IMAPQuotaOperation * IMAPAsyncSession::quotaOperation()
 {
-    IMAPAsyncConnection * session = sessionForFolder(NULL);
-    return session->quotaOperation();
+    IMAPQuotaOperation * op = new IMAPQuotaOperation();
+    op->setMainSession(this);
+    op->autorelease();
+    return op;
 }
 
 IMAPOperation * IMAPAsyncSession::noopOperation()
 {
-    IMAPAsyncConnection * session = sessionForFolder(NULL);
-    return session->noopOperation();
+    IMAPNoopOperation * op = new IMAPNoopOperation();
+    op->setMainSession(this);
+    op->autorelease();
+    return op;
 }
 
 IMAPOperation * IMAPAsyncSession::disconnectOperation()
@@ -522,33 +662,44 @@ ConnectionLogger * IMAPAsyncSession::connectionLogger()
     return mConnectionLogger;
 }
 
+IMAPMessageRenderingOperation * IMAPAsyncSession::renderingOperation(IMAPMessage * message,
+                                                                     String * folder,
+                                                                     IMAPMessageRenderingType type)
+{
+    IMAPMessageRenderingOperation * op = new IMAPMessageRenderingOperation();
+    op->setMainSession(this);
+    op->setMessage(message);
+    op->setFolder(folder);
+    op->setRenderingType(type);
+    op->autorelease();
+    return op;
+}
+
 IMAPMessageRenderingOperation * IMAPAsyncSession::htmlRenderingOperation(IMAPMessage * message,
                                                                          String * folder)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->htmlRenderingOperation(message, folder);
+    return renderingOperation(message, folder, IMAPMessageRenderingTypeHTML);
 }
 
 IMAPMessageRenderingOperation * IMAPAsyncSession::htmlBodyRenderingOperation(IMAPMessage * message,
                                                                              String * folder)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->htmlBodyRenderingOperation(message, folder);
+    return renderingOperation(message, folder, IMAPMessageRenderingTypeHTMLBody);
 }
 
 IMAPMessageRenderingOperation * IMAPAsyncSession::plainTextRenderingOperation(IMAPMessage * message,
                                                                               String * folder)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->plainTextRenderingOperation(message, folder);
+    return renderingOperation(message, folder, IMAPMessageRenderingTypePlainText);
 }
 
 IMAPMessageRenderingOperation * IMAPAsyncSession::plainTextBodyRenderingOperation(IMAPMessage * message,
                                                                                   String * folder,
                                                                                   bool stripWhitespace)
 {
-    IMAPAsyncConnection * session = sessionForFolder(folder);
-    return session->plainTextBodyRenderingOperation(message, folder, stripWhitespace);
+    return renderingOperation(message, folder,
+                              stripWhitespace ? IMAPMessageRenderingTypePlainTextBodyAndStripWhitespace :
+                              IMAPMessageRenderingTypePlainTextBody);
 }
 
 void IMAPAsyncSession::automaticConfigurationDone(IMAPSession * session)
diff --git a/src/async/imap/MCIMAPAsyncSession.h b/src/async/imap/MCIMAPAsyncSession.h
index b00af1d3..333783b2 100755
--- a/src/async/imap/MCIMAPAsyncSession.h
+++ b/src/async/imap/MCIMAPAsyncSession.h
@@ -162,6 +162,7 @@ namespace mailcore {
     public: // private
         virtual void automaticConfigurationDone(IMAPSession * session);
         virtual void operationRunningStateChanged();
+        virtual IMAPAsyncConnection * sessionForFolder(String * folder, bool urgent = false);
         
     private:
         Array * mSessions;
@@ -190,10 +191,12 @@ namespace mailcore {
 #endif
         String * mGmailUserDisplayName;
         
-        virtual IMAPAsyncConnection * sessionForFolder(String * folder, bool urgent = false);
         virtual IMAPAsyncConnection * session();
         virtual IMAPAsyncConnection * matchingSessionForFolder(String * folder);
         virtual IMAPAsyncConnection * availableSession();
+        virtual IMAPMessageRenderingOperation * renderingOperation(IMAPMessage * message,
+                                                                   String * folder,
+                                                                   IMAPMessageRenderingType type);
     };
     
 }
diff --git a/src/async/imap/MCIMAPOperation.cc b/src/async/imap/MCIMAPOperation.cc
index e4b3529b..a2214d81 100644
--- a/src/async/imap/MCIMAPOperation.cc
+++ b/src/async/imap/MCIMAPOperation.cc
@@ -20,13 +20,16 @@ using namespace mailcore;
 IMAPOperation::IMAPOperation()
 {
     mSession = NULL;
+    mMainSession = NULL;
     mImapCallback = NULL;
     mError = ErrorNone;
     mFolder = NULL;
+    mUrgent = false;
 }
 
 IMAPOperation::~IMAPOperation()
 {
+    MC_SAFE_RELEASE(mMainSession);
     MC_SAFE_RELEASE(mFolder);
     MC_SAFE_RELEASE(mSession);
 }
@@ -51,6 +54,16 @@ IMAPAsyncConnection * IMAPOperation::session()
     return mSession;
 }
 
+void IMAPOperation::setMainSession(IMAPAsyncSession * session)
+{
+    MC_SAFE_REPLACE_RETAIN(IMAPAsyncSession, mMainSession, session);
+}
+
+IMAPAsyncSession * IMAPOperation::mainSession()
+{
+    return mMainSession;
+}
+
 void IMAPOperation::setFolder(String * folder)
 {
     MC_SAFE_REPLACE_COPY(String, mFolder, folder);
@@ -61,6 +74,16 @@ String * IMAPOperation::folder()
     return mFolder;
 }
 
+void IMAPOperation::setUrgent(bool urgent)
+{
+    mUrgent = urgent;
+}
+
+bool IMAPOperation::isUrgent()
+{
+    return mUrgent;
+}
+
 void IMAPOperation::setImapCallback(IMAPOperationCallback * callback)
 {
     mImapCallback = callback;
@@ -83,6 +106,8 @@ ErrorCode IMAPOperation::error()
 
 void IMAPOperation::start()
 {
+    IMAPAsyncConnection * connection = mMainSession->sessionForFolder(mFolder, mUrgent);
+    setSession(connection);
     mSession->runOperation(this);
 }
 
diff --git a/src/async/imap/MCIMAPOperation.h b/src/async/imap/MCIMAPOperation.h
index 7455fdeb..5cce9968 100644
--- a/src/async/imap/MCIMAPOperation.h
+++ b/src/async/imap/MCIMAPOperation.h
@@ -18,6 +18,7 @@
 namespace mailcore {
     
     class IMAPAsyncConnection;
+    class IMAPAsyncSession;
     class IMAPOperationCallback;
     
     class IMAPOperation : public Operation, public IMAPProgressCallback {
@@ -25,12 +26,15 @@ namespace mailcore {
         IMAPOperation();
         virtual ~IMAPOperation();
         
-        virtual void setSession(IMAPAsyncConnection * session);
-        virtual IMAPAsyncConnection * session();
-        
+        virtual void setMainSession(IMAPAsyncSession * session);
+        virtual IMAPAsyncSession * mainSession();
+
         virtual void setFolder(String * folder);
         virtual String * folder();
         
+        virtual void setUrgent(bool urgent);
+        virtual bool isUrgent();
+        
         virtual void setImapCallback(IMAPOperationCallback * callback);
         virtual IMAPOperationCallback * imapCallback();
         
@@ -44,10 +48,15 @@ namespace mailcore {
         virtual ErrorCode error();
         
     private:
+        IMAPAsyncSession * mMainSession;
         IMAPAsyncConnection * mSession;
         String * mFolder;
         IMAPOperationCallback * mImapCallback;
         ErrorCode mError;
+        bool mUrgent;
+        
+        virtual void setSession(IMAPAsyncConnection * session);
+        virtual IMAPAsyncConnection * session();
         
     private:
         virtual void bodyProgress(IMAPSession * session, unsigned int current, unsigned int maximum);