1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 

    17 #include "cimapsession.h"

    18 

    19 #include "moutputstream.h"

    20 #include "minputstream.h"

    21 

    22 #include "cimapsessionconsts.h"

    23 

    24 #include "cimapidle.h"

    25 #include "cimapservereventwait.h"

    26 #include "cimapservergreeting.h"

    27 #include "cimapservergreetinginfo.h"

    28 #include "cimapcapability.h"

    29 #include "cimapcapabilityinfo.h"

    30 #include "cimapnoop.h"

    31 #include "cimaplogout.h"

    32 #include "cimaplogin.h"

    33 #include "cimapstarttls.h"

    34 #include "cimapselect.h"

    35 #include "cimapexamine.h"

    36 #include "cimapcreate.h"

    37 #include "cimapdelete.h"

    38 #include "cimaprename.h"

    39 #include "cimapsubscribe.h"

    40 #include "cimapunsubscribe.h"

    41 #include "cimaplist.h"

    42 #include "cimaplsub.h"

    43 #include "cimapstatus.h"

    44 #include "cimapappend.h"

    45 #include "cimapsearch.h"

    46 #include "cimapclose.h"

    47 #include "cimapstore.h"

    48 #include "cimapcopy.h"

    49 #include "cimapexpunge.h"

    50 #include "cimapfetchflags.h"

    51 #include "cimapfetchbody.h"

    52 #include "cimapfetchsinglebodystructure.h"

    53 #include "cimapfetchmultibodystructures.h"

    54 #include "cimapfetchbodyresponse.h"

    55 #include "cimaplogger.h"

    56 #include "imappaniccodes.h"

    57 

    58 #if (defined SYMBIAN_EMAIL_CAPABILITY_SUPPORT)

    59 	#include "cimapauthhelpers.h"

    60 #endif

    61 /**

    62 An RBuf buffer is used to create the sequence set string.

    63 This specifies by how the buffer should grow each time it needs to be expanded.

    64 */

    65 const TInt KSequenceSetGranularity = 32;

    66 /**

    67 A CBufFlat buffer is used to store incoming string data whenever incoming data needs to be spliced

    68 together in order to form a contiguous line or literal block.

    69 This specifies by how the buffer should grow each time it needs to be expanded.

    70 */

    71 const TInt KInputCacheGranularity = 1024;

    72 /**

    73 During a flush (after cancelling a command),

    74 time out if data is not received within 10 seconds of requesting it.

    75 */

    76 const TInt KFlushTimeoutPeriod = 10*1000*1000;

    77 

    78 #ifdef __IMAP_LOGGING

    79 _LIT(KLogFileName, "imlog%d");

    80 #endif //__IMAP_LOGGING

    81 

    82 /**

    83 The factory constructor. Part of two phased construction.

    84 */

    85 EXPORT_C CImapSession* CImapSession::NewL(CImapSettings& aImapSettings, CImapMailStore& aImapMailStore, MInputStream& aInputStream, MOutputStream& aOutputStream)

    86 // static method

    87 	{

    88 	CImapSession* self = new(ELeave) CImapSession(aImapSettings, aImapMailStore, aInputStream, aOutputStream);

    89 	CleanupStack::PushL(self);

    90 	self->ConstructL();

    91 	CleanupStack::Pop(self);

    92 	return self;

    93 	}

    94 

    95 CImapSession::CImapSession(CImapSettings& aImapSettings, CImapMailStore& aImapMailStore, MInputStream& aInputStream, MOutputStream& aOutputStream)

    96 	: iImapSettings(aImapSettings), iImapMailStore(aImapMailStore) 

    97 	, iInputStream(&aInputStream), iOutputStream(&aOutputStream)

    98 	{}

    99 

   100 void CImapSession::ConstructL()

   101 	{

   102 	__ASSERT_DEBUG(iInputStream != NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionNullInputStream));

   103 	__ASSERT_DEBUG(iOutputStream != NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionNullOutputStream));

   104 

   105 #ifdef __IMAP_LOGGING	

   106 	//Getting the server port number for creating the IMAP log file

   107 	TInt portNum = 143;

   108 	TBuf<10> fileName;

   109 	fileName.AppendFormat(KLogFileName, portNum);

   110 	__LOG_CREATE_STANDARD(fileName, iLogId);

   111 #endif //__IMAP_LOGGING	

   112 

   113 	iServerGreetingInfo = CImapServerGreetingInfo::NewL();

   114 	iCapabilityInfo = CImapCapabilityInfo::NewL();

   115 	iInputCache = CBufFlat::NewL(KInputCacheGranularity);

   116 

   117 	TCallBack callBack(CImapSession::AsyncCallBack, this);

   118 	iAsyncCallBack = new(ELeave)CAsyncCallBack(callBack, CActive::EPriorityStandard);

   119 	

   120 	iFlushCommandTimeout = CImapObservableTimer::NewL(*this);

   121 	

   122 	iInputStream->Bind(*this, iLogId);

   123 	iOutputStream->Bind(*this, iLogId);

   124 	}

   125 	

   126 CImapSession::~CImapSession()

   127 	{

   128 	Cancel();

   129 

   130 	// Close the streams if they are not already closed. Just closing the

   131 	// output stream will also close the input stream.

   132 	if (iOutputStream != NULL)

   133 		{

   134 		iOutputStream->Close();

   135 		}

   136 

   137 	delete iFlushCommandTimeout;

   138 	delete iAsyncCallBack;

   139 	

   140 	delete iCurrentCommand;

   141 	

   142 	delete iSelectedFolderInfo;

   143 	delete iCapabilityInfo;	

   144 	delete iServerGreetingInfo;

   145 	

   146 	delete iInputCache;

   147 

   148 	__LOG_CLOSE(iLogId);

   149 	}

   150 

   151 /**

   152 Returns the current server state.

   153 EServerStateNone indicates that the server greeting has not yet been received.

   154 CImapSession will panic if an attempt is made to call invoke an IMAP command when the IMAP server is 

   155 not in the correct state for the command.

   156 This method can be called to check the state before invoking such a command.

   157 @return The current server state.

   158 */

   159 EXPORT_C CImapSession::TImapServerState CImapSession::ServerState()

   160 	{

   161 	return iServerState;

   162 	}

   163 

   164 /**

   165 Returns inforamtion about the currently selected folder.

   166 If no folder is currently selected, then NULL will be returned.

   167 @return information about the currently selected folder or NULL if no folder is currently selected.

   168 */

   169 EXPORT_C CImapFolderInfo* CImapSession::SelectedFolderInfo()

   170 	{

   171 	return iSelectedFolderInfo;

   172 	}

   173 

   174 /** 

   175 Returns the server greeting information object.

   176 The data in the object will only be valid after a greeting has been received from the server.

   177 This must be requested using the ReadServerGreetingL() method immediately after connection has been made.

   178 @return The server greeting information object.

   179 */

   180 EXPORT_C const CImapServerGreetingInfo& CImapSession::ServerGreetingInfo()

   181 	{

   182 	return *iServerGreetingInfo;

   183 	}

   184 

   185 /** 

   186 Returns the server capability information object.

   187 The data in the object will only be valid after a capability response has been received from the server.

   188 This can be requested using the CapabilityL() method.

   189 @return The server capability information object.

   190 */

   191 EXPORT_C const CImapCapabilityInfo& CImapSession::CapabilityInfo()

   192 	{

   193 	return *iCapabilityInfo;

   194 	}

   195 

   196 /** 

   197 @return ETrue if IMAP IDLE mode is supported by the server.

   198 */

   199 EXPORT_C TBool CImapSession::ImapIdleSupported() const

   200 	{

   201 	return iCapabilityInfo->QueryFlag(CImapCapabilityInfo::EIdle);

   202 	}

   203 

   204 /** 

   205 Request to enter IMAP IDLE mode.

   206 This method will complete when confirmation of entering IDLE mode has been received 

   207 from the server, via the '+' continuation response.

   208 The server may send untagged status information BEFORE sending the continuation response.

   209 This will be recorded and can be accessed via SelectedFolderInfo().

   210 Upon completion of EnterIdleL(), 

   211 WaitForIdleEvent() should be called in order to wait for the next status information event, 

   212 or DoneIdle() should be called to stop receiving further status information.

   213 @param aStatus Signals the receipt of the continuation response.

   214 */

   215 EXPORT_C void CImapSession::EnterIdleL(TRequestStatus& aStatus)

   216 	{

   217 	__LOG_TEXT(iLogId, "CImapSession::EnterIdleL()");

   218 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleWhenServerUnAuthenticated));

   219 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleWhenInvalidOperationPending));

   220 	if (CompleteIfStreamsClosed(aStatus)) 

   221 		{

   222 		return;

   223 		}

   224 	

   225 	StartCommandL(aStatus, CImapIdle::NewL(iSelectedFolderInfo, iLogId));

   226 	

   227 	SetPendingOperation(EOpIdleEnter);

   228 	}

   229 	

   230 /**

   231 Request to be notified of an IMAP IDLE event.

   232 This method will complete when the next line of status information is received.

   233 The updated information can be accessed via SelectedFolderInfo().

   234 However, the information might not be complete as further lines of status information may 

   235 have been sent but not yet received.

   236 Upon completion of WaitForIdleEvent(), 

   237 WaitForIdleEvent() should be called again in order to receive the next event

   238 or DoneIdle() should be called to receive complete status information 

   239 and to stop receiving further information.

   240 This method will panic if the session is not currently in IDLE mode.

   241 Use EnterIdleL() to enter IDLE mode.

   242 @param aStatus Signals the receipt of a line of status information.

   243 */

   244 EXPORT_C void CImapSession::WaitForIdleEvent(TRequestStatus& aStatus)

   245 	{

   246 	__LOG_TEXT(iLogId, "CImapSession::WaitForIdleEvent()");

   247 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleWaitWhenServerUnAuthenticated));

   248 	__ASSERT_DEBUG(iPendingOperation == EOpIdleEnter || iPendingOperation == EOpIdleWait, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleWaitWhenOperationPendingNotIdle));

   249 	__ASSERT_DEBUG(iSessionState == ESessionNormal, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleWaitWhenSessionNonNormal));

   250 	if (CompleteIfStreamsClosed(aStatus)) 

   251 		{

   252 		return;

   253 		}

   254 	

   255 	SetPendingOperation(EOpIdleWait);

   256 		

   257 	Queue(aStatus);

   258 	

   259 	// Restart the ProcessInputBufferL() loop asynchronously

   260 	ProcessInputBufferAsync();

   261 	}

   262 	

   263 /** 

   264 Request to exit IMAP IDLE mode.

   265 This will cause the session to send a DONE message to the server.

   266 The method will complete when a tagged response is received.

   267 Upon completion, up-to-date status information can be accessed via SelectedFolderInfo().

   268 This method will panic if the session is not currently in IDLE mode.

   269 Use EnterIdleL() to enter IDLE mode.

   270 @param aStatus Signals completion of the request.

   271 */

   272 EXPORT_C void CImapSession::DoneIdle(TRequestStatus& aStatus)

   273 	{

   274 	__LOG_TEXT(iLogId, "CImapSession::DoneIdle()");

   275 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleDoneWhenServerUnAuthenticated));

   276 	__ASSERT_DEBUG(iPendingOperation == EOpIdleEnter || iPendingOperation == EOpIdleWait, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleDoneWhenWhenInvalidOperationPending));

   277 	__ASSERT_DEBUG(iSessionState == ESessionNormal, TImapServerPanic::ImapPanic(TImapServerPanic::EIdleDoneWhenSessionNonNormal));

   278 	__ASSERT_DEBUG(iCurrentCommand != NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionNullCurrentCommand));

   279 	if (CompleteIfStreamsClosed(aStatus)) 

   280 		{

   281 		return;

   282 		}

   283 	

   284 	CImapIdle* idleCommand = static_cast<CImapIdle*>(iCurrentCommand);

   285 

   286 	SetPendingOperation(EOpIdleDone); // Treat as a normal command.

   287 	SetSessionState(ESessionNormal); // If called after cancel, then set the session back to normal state.

   288 	

   289 	// iOutputStream must be non-null because CompleteIfStreamsClosed() returned EFalse.

   290 	idleCommand->SendDone(*iOutputStream);

   291 	

   292 	Queue(aStatus);

   293 	

   294 	// Restart the ProcessInputBufferL() loop asynchronously

   295 	ProcessInputBufferAsync();

   296 	}

   297 

   298 /**

   299 This method does not send a command to the server, 

   300 but simply waits on the input stream for any unsolicited response message

   301 that the server might decide to send.  See section 5.3 of RFC3501.

   302 This method should be used in place of the IDLE methods when no command is

   303 being processed.

   304 To cancel this method, call Cancel() followed by FlushCancelledCommand() to 

   305 ensure that partial responses are not left on the input stream before 

   306 the issuing the next command

   307 @param aStatus Signals that an unsolicited response has been received.

   308 */

   309 EXPORT_C void CImapSession::WaitForServerEventL(TRequestStatus& aStatus)

   310 	{

   311 	__LOG_TEXT(iLogId, "CImapSession::WaitForServerEventL()");

   312 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EWaitForServerEventWhenServerUnAuthenticated));

   313 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EWaitForServerEventWhenInvalidOperationPending));

   314 	if (CompleteIfStreamsClosed(aStatus)) 

   315 		{

   316 		return;

   317 		}

   318 	

   319 	StartCommandL(aStatus, CImapServerEventWait::NewL(iSelectedFolderInfo, iLogId));

   320 	}

   321 

   322 /** 

   323 Reads and parses the server greeting from the input stream.

   324 This method must (and must only) be called immediately after making a connection to the server.

   325 Once this method has completed succesfully, the server greeting information will be accessible 

   326 from the ServerGreetingInfo() method of this object.

   327 @return The server greeting information object.

   328 */

   329 EXPORT_C void CImapSession::ReadServerGreetingL(TRequestStatus& aStatus)

   330 	{

   331 	__LOG_TEXT(iLogId, "CImapSession::ReadServerGreetingL()");

   332 	__ASSERT_DEBUG(iServerState == EServerStateNone, TImapServerPanic::ImapPanic(TImapServerPanic::EReadServerGreetingWhenServerUnAuthenticated));

   333 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EReadServerGreetingWhenInvalidOperationPending));

   334 	if (CompleteIfStreamsClosed(aStatus)) 

   335 		{

   336 		return;

   337 		}

   338 	

   339 	SetPendingOperation(EOpServerGreeting); // Next server state depends on ServerGreeting result: could be PreAuth

   340 	StartCommandL(aStatus, CImapServerGreeting::NewL(iSelectedFolderInfo, iLogId, *iServerGreetingInfo));

   341 	}

   342 

   343 /** 

   344 Issue the IMAP capability command to gather IMAP capability information from the remote server.

   345 Once this method has completed successfully, the capability information will be accessible 

   346 from the CapabilityInfo() method of this object.

   347 @param aStatus Signals completion of the request

   348 @see CapabilityInfo()

   349 */

   350 EXPORT_C void CImapSession::CapabilityL(TRequestStatus& aStatus)

   351 	{

   352 	__LOG_TEXT(iLogId, "CImapSession::CapabilityL()");

   353 	__ASSERT_DEBUG(iServerState != EServerStateNone, TImapServerPanic::ImapPanic(TImapServerPanic::ECapabilityWhenServerStateUnknown));

   354 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ECapabilityWhenInvalidOperationPending));

   355 	if (CompleteIfStreamsClosed(aStatus)) 

   356 		{

   357 		return;

   358 		}

   359 	

   360 	StartCommandL(aStatus, CImapCapability::NewL(iSelectedFolderInfo, iLogId, *iCapabilityInfo));

   361 	}

   362 /** 

   363 Issue the IMAP noop command.

   364 When in selected state, and upon completions, the caller should 

   365 check SelectedFolderInfo() for any updates.

   366 @param aStatus 		Signals completion of the request

   367 */

   368 EXPORT_C void CImapSession::NoopL(TRequestStatus& aStatus)

   369 	{

   370 	__LOG_TEXT(iLogId, "CImapSession::NoopL()");

   371 	__ASSERT_DEBUG(iServerState != EServerStateNone, TImapServerPanic::ImapPanic(TImapServerPanic::ENoopWhenServerStateUnknown));

   372 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ENoopWhenInvalidOperationPending));

   373 	if (CompleteIfStreamsClosed(aStatus)) 

   374 		{

   375 		return;

   376 		}

   377 	

   378 	StartCommandL(aStatus, CImapNoop::NewL(iSelectedFolderInfo, iLogId));

   379 	}

   380 

   381 /**

   382 Issue the IMAP logout command.

   383 @param aStatus Signals completion of the request

   384 */

   385 EXPORT_C void CImapSession::LogoutL(TRequestStatus& aStatus)

   386 	{

   387 	__LOG_TEXT(iLogId, "CImapSession::LogoutL()");

   388 	__ASSERT_DEBUG(iServerState != EServerStateNone, TImapServerPanic::ImapPanic(TImapServerPanic::ELogOutWhenNotSelected));

   389 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ELogOutWhenInvalidOperationPending));

   390 	if (CompleteIfStreamsClosed(aStatus)) 

   391 		{

   392 		return;

   393 		}

   394 	

   395 	SetPendingOperation(EOpLogout); // Server state becomes None (i.e. disconnected)

   396 	StartCommandL(aStatus, CImapLogout::NewL(iSelectedFolderInfo, iLogId));

   397 	}

   398 	

   399 /**

   400 Issue the IMAP login command.

   401 @param aStatus Signals completion of the request

   402 @param aUserName A user name supplied by the user

   403 @param aPassword A password supplied by the user

   404 */

   405 EXPORT_C void CImapSession::LoginL(TRequestStatus& aStatus, const TDesC8& aUserName, const TDesC8& aPassword)

   406 	{

   407 	__LOG_TEXT(iLogId, "CImapSession::LoginL()");

   408 	__ASSERT_DEBUG(iServerState == EServerStateNotAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::ELoginWhenServerStateUnknown));

   409 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ELoginWhenInvalidOperationPending));

   410 	if (CompleteIfStreamsClosed(aStatus)) 

   411 		{

   412 		return;

   413 		}

   414 	

   415 	SetPendingOperation(EOpLogin); // << Server state becomes Authenticated

   416 	StartCommandL(aStatus, CImapLogin::NewL(iSelectedFolderInfo, iLogId, aUserName, aPassword, *iCapabilityInfo));

   417 	}

   418 	

   419 /** 

   420 Issue the IMAP StartTLS command

   421 @param aStatus Signals completion of the request

   422 */

   423 EXPORT_C void CImapSession::StartTlsL(TRequestStatus& aStatus)

   424 	{

   425 	__LOG_TEXT(iLogId, "CImapSession::StartTlsL()");

   426 	__ASSERT_DEBUG(iServerState == EServerStateNotAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EStartTLSWhenServerUnAuthenticated));

   427 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EStartTLSWhenInvalidOperationPending));

   428 	if (CompleteIfStreamsClosed(aStatus)) 

   429 		{

   430 		return;

   431 		}

   432 	

   433 	StartCommandL(aStatus, CImapStartTls::NewL(iSelectedFolderInfo, iLogId));

   434 	}

   435 

   436 /**

   437 Issue the IMAP select command.

   438 Opens the folder identified by aFolderInfo.Name() for read-write operations.

   439 @param aStatus Signals completion of the request

   440 @param aFolderInfo The folder object that represents the mailbox.  CImapSession takes ownership of this object.

   441 The folder object initially contains the name of the folder to select.

   442 The folder object will be updated upon successful completion of the command.

   443 The folder object will be updated when any subsequent command receives folder information from the server.

   444 */

   445 EXPORT_C void CImapSession::SelectL(TRequestStatus& aStatus, CImapFolderInfo* aFolderInfo, TBool aSelectBox)

   446 	{

   447 	__LOG_TEXT(iLogId, "CImapSession::SelectL()");

   448 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::ESelectWhenServerUnAuthenticated));

   449 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ESelectWhenInvalidOperationPending));

   450 	__ASSERT_DEBUG(aFolderInfo != NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionImapFolderInfoIsNull));

   451 	

   452 	if (CompleteIfStreamsClosed(aStatus)) 

   453 		{

   454 		// Attempt to select while the stream is closed.

   455 		// This failed select effectively puts us into the authenticated server state, 

   456 		// where iSelectedFolderInfo should be NULL.

   457 		delete iSelectedFolderInfo;

   458 		iSelectedFolderInfo = NULL;		

   459 

   460 		delete aFolderInfo; // No need to set to NULL as we're returning.

   461 		return;

   462 		}

   463 			// Folder is already SELECTed so dont select again.. Hope this saves users bandwidth 

   464 	if(aSelectBox)		

   465 	{

   466 		if(iSelectedFolderInfo && iSelectedFolderInfo->MsvId() == aFolderInfo->MsvId())

   467 			{

   468 			Queue(aStatus);

   469 			Complete(KErrNone);

   470 			delete aFolderInfo;

   471 			return;

   472 			}	

   473 	}

   474 	CleanupStack::PushL(aFolderInfo); // Take ownership but don't assign as a data member yet

   475 	

   476 	SetPendingOperation(EOpSelect); // Server state becomes Selected if successful, otherwise becomes Authenticated - and selected folder info becomes NULL

   477 	StartCommandL(aStatus, CImapSelect::NewL(aFolderInfo, iLogId));

   478 	

   479 	// Overwrite any existing folder info, prior to performing the select

   480 	// If select succeeds, iSelectedFolderInfo will be correct.

   481 	// If select fails then iSelectedFolderInfo will be deleted and set to NULL later, as the state will 

   482 	//   revert from Selected to Authenticated.

   483 	

   484 	CleanupStack::Pop(aFolderInfo); // Now we can assign aFolderInfo as a data member

   485 	

   486 	delete iSelectedFolderInfo;

   487 	iSelectedFolderInfo = aFolderInfo;

   488 	}

   489 

   490 /**

   491 Issue the IMAP examine command.

   492 Opens the folder identified by aFolderInfo.Name() for read-only operations.

   493 @param aStatus Signals completion of the request

   494 @param aFolderInfo The folder object that represents the mailbox.  CImapSession takes ownership of this object.

   495 The folder object initially contains the name of the folder to examine.

   496 The folder object will be updated upon successful completion of the command.

   497 The folder object will be updated when any subsequent command receives folder information from the server.

   498 */

   499 EXPORT_C void CImapSession::ExamineL(TRequestStatus& aStatus, CImapFolderInfo* aFolderInfo)

   500 	{

   501 	__LOG_TEXT(iLogId, "CImapSession::ExamineL()");

   502 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EExamineWhenServerUnAuthenticated));

   503 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EExamineWhenInvalidOperationPending));

   504 	__ASSERT_DEBUG(aFolderInfo != NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionImapFolderInfoIsNull));

   505 

   506 	if (CompleteIfStreamsClosed(aStatus)) 

   507 		{

   508 		// Attempt to select while the stream is closed.

   509 		// This failed select effectively puts us into the authenticated server state, 

   510 		// where iSelectedFolderInfo should be NULL.

   511 		delete iSelectedFolderInfo;

   512 		iSelectedFolderInfo = NULL;		

   513 		

   514 		delete aFolderInfo; // No need to set to NULL as we're returning.		

   515 		return;

   516 		}

   517 	

   518 	CleanupStack::PushL(aFolderInfo); // Take ownership but don't assign as a data member yet

   519 	

   520 	SetPendingOperation(EOpSelect); // Server state becomes Selected if successful, otherwise becomes Authenticated - and selected folder info becomes NULL

   521 	StartCommandL(aStatus, CImapExamine::NewL(aFolderInfo, iLogId));

   522 	

   523 	// Overwrite any existing folder info, prior to performing the select

   524 	// If select succeeds, iSelectedFolderInfo will be correct.

   525 	// If select fails then iSelectedFolderInfo will be deleted and set to NULL later, as the state will 

   526 	//   revert from Selected to Authenticated.

   527 	

   528 	CleanupStack::Pop(aFolderInfo); // Now we can assign aFolderInfo as a data member

   529 	

   530 	delete iSelectedFolderInfo;

   531 	iSelectedFolderInfo = aFolderInfo;

   532 	}

   533 

   534 /**

   535 Issue the IMAP create command

   536 Creates a remote mailbox with the name given by aMailboxName

   537 @param aStatus Signals completion of the request

   538 @param aMailboxName The name to be given to the new mailbox.

   539 					This is the FULL PATH to the mailbox, as understood by the remote server.

   540 */

   541 EXPORT_C void CImapSession::CreateL(TRequestStatus& aStatus, const TDesC& aMailboxName)

   542 	{

   543 	__LOG_TEXT(iLogId, "CImapSession::CreateL()");

   544 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::ECreateWhenServerUnAuthenticated));

   545 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ECreateWhenInvalidOperationPending));

   546 	if (CompleteIfStreamsClosed(aStatus)) 

   547 		{

   548 		return;

   549 		}

   550 	

   551 	StartCommandL(aStatus, CImapCreate::NewL(iSelectedFolderInfo, iLogId, aMailboxName));

   552 	}

   553 

   554 /** 

   555 Issue the IMAP delete command

   556 Deletes the folder identified by aMailboxName.

   557 @param aStatus Signals completion of the request.

   558 @param aMailboxName The name of the mailbox that is to be selected.

   559 					This is the FULL PATH to the mailbox, as understood by the remote server.

   560 */

   561 EXPORT_C void CImapSession::DeleteL(TRequestStatus& aStatus, const TDesC& aMailboxName)

   562 	{

   563 	__LOG_TEXT(iLogId, "CImapSession::DeleteL()");

   564 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EDeleteWhenServerUnAuthenticated));

   565 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EDeleteWhenInvalidOperationPending));

   566 	if (CompleteIfStreamsClosed(aStatus)) 

   567 		{

   568 		return;

   569 		}

   570 		

   571 	StartCommandL(aStatus, CImapDelete::NewL(iSelectedFolderInfo, iLogId, aMailboxName));

   572 	}

   573 

   574 /**

   575 Issue the IMAP rename command.

   576 Renames the folder identified by aExistingMailboxName to aNewMailboxName.

   577 @param aStatus Signals completion of the request.

   578 @param aExistingMailboxName The current name of the mailbox that is to be renamed

   579 @param aNewMailboxName The new name to be given to the mailbox

   580 */

   581 EXPORT_C void CImapSession::RenameL(TRequestStatus& aStatus, const TDesC& aExistingMailboxName, const TDesC& aNewMailboxName)

   582 	{

   583 	__LOG_TEXT(iLogId, "CImapSession::RenameL()");

   584 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::ERenameWhenServerUnAuthenticated));

   585 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ERenameWhenInvalidOperationPending));

   586 	if (CompleteIfStreamsClosed(aStatus)) 

   587 		{

   588 		return;

   589 		}

   590 		

   591 	StartCommandL(aStatus, CImapRename::NewL(iSelectedFolderInfo, iLogId, aExistingMailboxName, aNewMailboxName));

   592 	}

   593 

   594 /** 

   595 Issue the IMAP subscribe command.

   596 Subscribes to the folder identified by aMailboxName.

   597 @param aStatus Signals completion of the request.

   598 @param aMailboxName The name of the mailbox that is to be subscribed to.

   599 					This is the FULL PATH to the mailbox, as understood by the remote server.

   600 */

   601 EXPORT_C void CImapSession::SubscribeL(TRequestStatus& aStatus, const TDesC& aMailboxName)

   602 	{

   603 	__LOG_TEXT(iLogId, "CImapSession::SubscribeL()");

   604 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::ESubscribeWhenServerUnAuthenticated));

   605 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ESubscribeWhenInvalidOperationPending));

   606 	if (CompleteIfStreamsClosed(aStatus)) 

   607 		{

   608 		return;

   609 		}

   610 		

   611 	StartCommandL(aStatus, CImapSubscribe::NewL(iSelectedFolderInfo, iLogId, aMailboxName));

   612 	}

   613 

   614 /**

   615 Issue the IMAP unsubscribe command

   616 Unsubscribes from the folder identified by aMailboxName.

   617 @param aStatus Signals completion of the request.

   618 @param aMailboxName The name of the mailbox that is to be unsubscribed from.

   619 					This is the FULL PATH to the mailbox, as understood by the remote server.

   620 */

   621 EXPORT_C void CImapSession::UnsubscribeL(TRequestStatus& aStatus, const TDesC& aMailboxName)

   622 	{

   623 	__LOG_TEXT(iLogId, "CImapSession::UnsubscribeL()");

   624 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EUnSubscribeWhenServerUnAuthenticated));

   625 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EUnSubscribeWhenInvalidOperationPending));

   626 	if (CompleteIfStreamsClosed(aStatus)) 

   627 		{

   628 		return;

   629 		}

   630 		

   631 	StartCommandL(aStatus, CImapUnsubscribe::NewL(iSelectedFolderInfo, iLogId, aMailboxName));

   632 	}

   633 

   634 /**

   635 Issue the IMAP list command

   636 Populates aFolderList with information about the requested mailbox.

   637 @param aStatus Signals completion of the request.

   638 @param aReferenceName	The reference name can be used to qualify the path of the mailbox.  See section 6.3.8 of RFC 3501

   639 @param aMailboxName		Specifies which mailbox to list.  Only subfolders of the specified mailbox will be listed.

   640 						This is the FULL PATH to the mailbox, as understood by the remote server.

   641 @param aFolderList An array which will be populated with the list of folders upon successful completion of the command.

   642 */

   643 EXPORT_C void CImapSession::ListL(TRequestStatus& aStatus, const TDesC& aReferenceName, const TDesC& aMailboxName, RArrayImapListFolderInfo& aFolderList)

   644 	{

   645 	__LOG_TEXT(iLogId, "CImapSession::ListL()");

   646 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EListWhenServerUnAuthenticated));

   647 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EListWhenInvalidOperationPending));

   648 	if (CompleteIfStreamsClosed(aStatus)) 

   649 		{

   650 		return;

   651 		}

   652 		

   653 	StartCommandL(aStatus, CImapList::NewL(iSelectedFolderInfo, iLogId, aReferenceName, aMailboxName, aFolderList, iImapSettings));

   654 	}

   655 

   656 /**

   657 Issue the IMAP lsub command

   658 Populates aFolderList with information about the requested remotely subscribed mailbox.

   659 @param aStatus Signals completion of the request.

   660 @param aReferenceName	The reference name can be used to qualify the path of the mailbox.  See section 6.3.9 of RFC 3501

   661 @param aMailboxName		Specifies which mailbox to list.  Only subscribed subfolders of the specified mailbox will be listed.

   662 						This is the FULL PATH to the mailbox, as understood by the remote server.

   663 @param aFolderList		An array which will be populated with the list of folders upon successful completion of the command.

   664 */

   665 EXPORT_C void CImapSession::LsubL(TRequestStatus& aStatus, const TDesC& aReferenceName, const TDesC& aMailboxName, RArrayImapListFolderInfo& aFolderList)

   666 	{

   667 	__LOG_TEXT(iLogId, "CImapSession::LsubL()");

   668 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::ELsubWhenServerUnAuthenticated));

   669 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ELsubWhenInvalidOperationPending));

   670 	if (CompleteIfStreamsClosed(aStatus)) 

   671 		{

   672 		return;

   673 		}

   674 		

   675 	StartCommandL(aStatus, CImapLsub::NewL(iSelectedFolderInfo, iLogId, aReferenceName, aMailboxName, aFolderList, iImapSettings));

   676 	}

   677 

   678 /**

   679 Issue the IMAP status command

   680 Populates aFolderInfo with information about the folder identified by aMailboxName

   681 This method SHOULD NOT be used to access information on this session's currently selected mailbox.

   682 @param aStatus Signals completion of the request.

   683 @param aMailboxName The name of the mailbox whose status information is to be fetched.

   684 					This is the FULL PATH to the mailbox, as understood by the remote server.

   685 @param aDataItemNames Specifies what information about the folder to request.

   686 @param aFolderInfo The folder object that represents the mailbox that whose status information is to be fetched.

   687 The folder object will be updated upon successful completion of the command.

   688 Ownership of aFolderInfo will NOT be taken by CImapSession.

   689 */

   690 EXPORT_C void CImapSession::StatusL(TRequestStatus& aStatus, const TDesC& aMailboxName, const TDesC8& aDataItemNames, CImapFolderInfo& aFolderInfo)

   691 	{

   692 	__LOG_TEXT(iLogId, "CImapSession::StatusL()");

   693 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EStatusWhenServerUnAuthenticated));

   694 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EStatusWhenInvalidOperationPending));

   695 	if (CompleteIfStreamsClosed(aStatus)) 

   696 		{

   697 		return;

   698 		}

   699 		

   700 	StartCommandL(aStatus, CImapStatus::NewL(iSelectedFolderInfo, iLogId, aMailboxName, aDataItemNames, aFolderInfo));

   701 	}

   702 

   703 /**

   704 Issue the IMAP append command

   705 @param aStatus Signals completion of the request.

   706 @param aSource An object from which the message source can be obtained

   707 @param aDestinationMailboxName The name of the mailbox to which the message is to be appended

   708 */

   709 EXPORT_C void CImapSession::AppendL(TRequestStatus& aStatus, CImSendMessage& aSource, const TDesC& aDestinationMailboxName)

   710 	{

   711 	__LOG_TEXT(iLogId, "CImapSession::AppendL()");

   712 	__ASSERT_DEBUG(iServerState >= EServerStateAuthenticated, TImapServerPanic::ImapPanic(TImapServerPanic::EAppendWhenServerUnAuthenticated));

   713 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EAppendWhenInvalidOperationPending));

   714 	if (CompleteIfStreamsClosed(aStatus)) 

   715 		{

   716 		return;

   717 		}

   718 

   719 	StartCommandL(aStatus, CImapAppend::NewL(iSelectedFolderInfo, iLogId, aSource, aDestinationMailboxName, *this));

   720 	}

   721 

   722 /**

   723 Issue the IMAP close command

   724 @param aStatus Signals completion of the request.

   725 */

   726 EXPORT_C void CImapSession::CloseL(TRequestStatus& aStatus)

   727 	{

   728 	__LOG_TEXT(iLogId, "CImapSession::CloseL()");

   729 	__ASSERT_DEBUG(iServerState == EServerStateSelected, TImapServerPanic::ImapPanic(TImapServerPanic::ECloseWhenNotSelected));

   730 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ECloseWhenInvalidOperationPending));

   731 	if (CompleteIfStreamsClosed(aStatus)) 

   732 		{

   733 		return;

   734 		}

   735 		

   736 	SetPendingOperation(EOpClose); // Server state becomes Authenticated, iSelectedFolderInfo becomes NULL

   737 	StartCommandL(aStatus, CImapClose::NewL(iSelectedFolderInfo, iLogId));

   738 	}

   739 

   740 /**

   741 Issue the IMAP search command

   742 This returns a list of id's of messages that match the specified search critera.

   743 @param aStatus Signals completion of the request.

   744 @param aSearchCriteria Specifies the set of message id's to return.

   745 @param aMatchingMessageIds An array of message id's that will receive the result of the search.

   746 The array will be populated upon successful completion of the command.

   747 */

   748 EXPORT_C void CImapSession::SearchL(TRequestStatus& aStatus, const TDesC8& aSearchCriteria, RArray<TUint>& aMatchingMessageIds)

   749 	{

   750 	__LOG_TEXT(iLogId, "CImapSession::SearchL()");

   751 	__ASSERT_DEBUG(iServerState == EServerStateSelected, TImapServerPanic::ImapPanic(TImapServerPanic::ESearchWhenNotSelected));

   752 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ESearchInvalidOperationPending));

   753 	if (CompleteIfStreamsClosed(aStatus)) 

   754 		{

   755 		return;

   756 		}

   757 		

   758 	StartCommandL(aStatus, CImapSearch::NewL(iSelectedFolderInfo, iLogId, aSearchCriteria, aMatchingMessageIds));

   759 	}

   760 

   761 /**

   762 Issues the IMAP fetch command with FLAGS as the only message data item.

   763 The flags for a range of messages may be asked for in a single request.

   764 @param aStatus Signals completion of the request.

   765 @param aSequenceSet Specifies the messages to fetch

   766 @param aOutFlagInfo An array which will be populated with the list of messages and their flags upon successful completion of the command.

   767 */

   768 EXPORT_C void CImapSession::FetchFlagsL(TRequestStatus& aStatus, const TDesC8& aSequenceSet, RArrayMessageFlagInfo& aOutFlagInfo)

   769 	{

   770 	__LOG_TEXT(iLogId, "CImapSession::FetchFlagsL()");

   771 	__ASSERT_DEBUG(iServerState == EServerStateSelected, TImapServerPanic::ImapPanic(TImapServerPanic::EFetchFlagsWhenNotSelected));

   772 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EFetchFlagsInvalidOperationPending));

   773 	if (CompleteIfStreamsClosed(aStatus)) 

   774 		{

   775 		return;

   776 		}

   777 		

   778 	StartCommandL(aStatus, CImapFetchFlags::NewL(iSelectedFolderInfo, iLogId, aSequenceSet, aOutFlagInfo));

   779 	}

   780 	

   781 /**

   782 Issues the IMAP fetch command with a BODY (or BODY.PEEK) as the only message data item.

   783 Only one message body may be fetched at a time, although the implementaton may transparently pipeline the fetch.

   784 The caller only provides the <section> information for the BODY.  The rest of the request is built up by the method.

   785 The BODY response data will be stored in the mailstore by the session.

   786 The sessison will use the supplied TMsvId to instruct the mailstore which entry to populate.

   787 @param aStatus Signals completion of the request.

   788 @param aMessageUid Specifies the message to fetch.  This is the IMAP message UID.

   789 @param aPeek Whether the \\Seen flag of the message should be updated by the IMAP server.

   790 @param aFetchBodyInfo container class with extra information about the part being fetched. 

   791 */	

   792 EXPORT_C void CImapSession::FetchBodyL(TRequestStatus& aStatus, TUint aMessageUid, TBool aPeek, CFetchBodyInfo& aFetchBodyInfo, CImapFetchBodyResponse& aFetchBodyResponse)

   793 	{

   794 	__LOG_TEXT(iLogId, "CImapSession::FetchBodyL()");

   795 	__ASSERT_DEBUG(iServerState == EServerStateSelected, TImapServerPanic::ImapPanic(TImapServerPanic::EFetchBodyWhenNotSelected));

   796 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EFetchBodyWhenInvalidOperationPending));

   797 	if (CompleteIfStreamsClosed(aStatus)) 

   798 		{

   799 		return;

   800 		}

   801 	

   802 	SetPendingOperation(EOpWaitForBodyOperationComplete);

   803 	StartCommandL(aStatus, CImapFetchBody::NewL(iSelectedFolderInfo, iLogId, aMessageUid, aPeek, aFetchBodyInfo, aFetchBodyResponse, iImapSettings, iImapMailStore, *this));

   804 	}

   805 	

   806 /**

   807 Issues the IMAP fetch command with the FLAGS, BODYSTRUCTURE and BODY.PEEK[HEADER.FIELDS(<fields>)] data items set.

   808 Only one message may be fetched with this method.  An override exists for a range of messages.

   809 @param aStatus Signals completion of the request.

   810 @param aMessageUid Specifies the message to fetch.  This is the IMAP message UID.

   811 @param aFieldNames A space separated list of header fields that are to be fetched by this method.

   812 @param aOutFetchResponse An object that will be populated with all requested structural information upon successful completion of the command.

   813 */	

   814 EXPORT_C void CImapSession::FetchBodyStructureAndHeadersL(TRequestStatus& aStatus, TUint aMessageUid, const TDesC8& aFieldNames, CImapFetchResponse& aOutFetchResponse)

   815 	{

   816 	__LOG_TEXT(iLogId, "CImapSession::FetchBodyStructureAndHeadersL()-single");

   817 	__ASSERT_DEBUG(iServerState == EServerStateSelected, TImapServerPanic::ImapPanic(TImapServerPanic::FetchBodyStructureSingleWhenNotSelected));

   818 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::FetchBodyStructureSingleWhenInvalidOperationPending));

   819 	if (CompleteIfStreamsClosed(aStatus)) 

   820 		{

   821 		return;

   822 		}

   823 	

   824 	StartCommandL(aStatus, CImapFetchSingleBodyStructure::NewL(iSelectedFolderInfo, iLogId, aMessageUid, aFieldNames, aOutFetchResponse));

   825 	}

   826 

   827 /**

   828 Issues the IMAP fetch command with the FLAGS, BODYSTRUCTURE and BODY.PEEK[HEADER.FIELDS(<fields>)] data items set.

   829 A range of messages can be fetched with this method.  An override exists for single message fetches.

   830 @param aStatus Signals completion of the request.

   831 @param aMessageUid Specifies the message to fetch.  This is the IMAP message UID.

   832 @param aFieldNames A space separated list of header fields that are to be fetched by this method.

   833 @param aObserver The implementor of this interface will be called each time a fetch response has been received and parsed.

   834 */	

   835 EXPORT_C void CImapSession::FetchBodyStructureAndHeadersL(TRequestStatus& aStatus, const TDesC8& aSequenceSet, const TDesC8& aFieldNames, MImapFetchStructureObserver& aObserver)

   836 	{

   837 	__LOG_TEXT(iLogId, "CImapSession::FetchBodyStructureAndHeadersL()-multi");

   838 	__ASSERT_DEBUG(iServerState == EServerStateSelected, TImapServerPanic::ImapPanic(TImapServerPanic::FetchBodyStructureMultiWhenNotSelected));

   839 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::FetchBodyStructureMultiWhenInvalidOperationPending));

   840 	if (CompleteIfStreamsClosed(aStatus)) 

   841 		{

   842 		return;

   843 		}

   844 	

   845 	StartCommandL(aStatus, CImapFetchMultiBodyStructures::NewL(iSelectedFolderInfo, iLogId, aSequenceSet, aFieldNames, aObserver));

   846 	}

   847 

   848 /**

   849 Issues the IMAP store command

   850 aSequenceSet, aMessageDataItem and aValue are the STORE parameters defined in RFC3501 - see section 6.4.6

   851 If aUseSilent is true, then the .SILENT is appended to end of the aMessageDataItem specifier.

   852 @param aStatus Signals completion of the request.

   853 @param aSequenceSet Specifies the range of messages to modify.

   854 @param aMessageDataItem Specifies the name of the message data item to be stored.

   855 @param aValue Provides the new value of the message item.

   856 @param aUseSilent Whether the server should return the updated data value.  

   857 If ETrue, then .SILENT is appended to end of the aMessageDataItem specifier.

   858 */

   859 EXPORT_C void CImapSession::StoreL(TRequestStatus& aStatus, const TDesC8& aSequenceSet, const TDesC8& aMessageDataItem, const TDesC8& aValue, TBool aUseSilent, RArrayMessageFlagInfo& aOutMessageFlagInfo)

   860 	{

   861 	__LOG_TEXT(iLogId, "CImapSession::StoreL()");

   862 	__ASSERT_DEBUG(iServerState == EServerStateSelected, TImapServerPanic::ImapPanic(TImapServerPanic::EStoreWhenNotSelected));

   863 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EStoreWhenInvalidOperationPending));

   864 	if (CompleteIfStreamsClosed(aStatus)) 

   865 		{

   866 		return;

   867 		}

   868 	

   869 	StartCommandL(aStatus, CImapStore::NewL(iSelectedFolderInfo, iLogId, aSequenceSet, aMessageDataItem, aValue, aUseSilent, aOutMessageFlagInfo));

   870 	}

   871 

   872 /**

   873 Issue the IMAP copy command

   874 This instructs the server to copy the messages identified by aSequence from the currently 

   875 selected folder to the folder identified by aDestinationMailbox.

   876 @param aStatus Signals completion of the request.

   877 @param aSequenceSet Specifies the range of messages to copy.

   878 @param aDestinationMailboxName The name of the mailbox to which the message(s) is(are) to be copied.

   879 */

   880 EXPORT_C void CImapSession::CopyL(TRequestStatus& aStatus, const TDesC8& aSequenceSet, const TDesC& aDestinationMailboxName)

   881 	{

   882 	__LOG_TEXT(iLogId, "CImapSession::CopyL()");

   883 	__ASSERT_DEBUG(iServerState == EServerStateSelected, TImapServerPanic::ImapPanic(TImapServerPanic::ECopyWhenNotSelected));

   884 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::ECopyWhenInvalidOperationPending));

   885 	if (CompleteIfStreamsClosed(aStatus)) 

   886 		{

   887 		return;

   888 		}

   889 	

   890 	StartCommandL(aStatus, CImapCopy::NewL(iSelectedFolderInfo, iLogId, aSequenceSet, aDestinationMailboxName));

   891 	}

   892 

   893 /**

   894 Issues the IMAP expunge command.

   895 @param aStatus Signals completion of the request.

   896 */

   897 EXPORT_C void CImapSession::ExpungeL(TRequestStatus& aStatus)

   898 	{

   899 	__LOG_TEXT(iLogId, "CImapSession::ExpungeL()");

   900 	__ASSERT_DEBUG(iServerState == EServerStateSelected, TImapServerPanic::ImapPanic(TImapServerPanic::EExpungeWhenNotSelected));

   901 	__ASSERT_DEBUG(iPendingOperation == EOpNone, TImapServerPanic::ImapPanic(TImapServerPanic::EExpungeWhenInvalidOperationPending));

   902 	if (CompleteIfStreamsClosed(aStatus)) 

   903 		{

   904 		return;

   905 		}

   906 	

   907 	StartCommandL(aStatus, CImapExpunge::NewL(iSelectedFolderInfo, iLogId));

   908 	}

   909 

   910 /**

   911 Produces an efficient sequence-set string for the given set of message uids.

   912 For instance, the set (3 4 5 6 21) would produce the string 3:6,21

   913 Methods that take the aSequenceSet parameter can also accept wildcard sequence sets such as "24:*"

   914 which cannot be produced by this method (it would make no sense from finite set of uids).

   915 @param aMessageUids the set of messages to include in the sequence set

   916 @return the sequence set that represents the message uids.  The caller takes ownership of the returned object.

   917 */

   918 EXPORT_C HBufC8* CImapSession::CreateSequenceSetLC(RArray<TUint>& aMessageUids)

   919 // static method

   920 	{

   921 	_LIT8(KFormatFirstUid, "%d");

   922 	_LIT8(KFormatEndRangeAndNextUid, ":%d,%d");

   923 	_LIT8(KFormatNextUid, ",%d");

   924 	_LIT8(KFormatFinalEndRangeUid, ":%d");

   925 	

   926 	aMessageUids.Sort();

   927 	

   928 	TBool inRange = EFalse;

   929 	TUint prevUid = 0;

   930 	

   931 	TImapOverflowDetector overflowHandler;

   932 	

   933 	RBuf8 sequenceSet;

   934 	sequenceSet.CleanupClosePushL();

   935 	sequenceSet.CreateL(KSequenceSetGranularity);

   936 	

   937 	TInt countUids = aMessageUids.Count();

   938 	for (TInt i=0; i<countUids; i++)

   939 		{

   940 		// First (and lowest) uid always gets written

   941 		if (i==0)

   942 			{

   943 			prevUid = aMessageUids[0];

   944 			AppendAndGrowFormatL(sequenceSet, KFormatFirstUid(), &overflowHandler, prevUid);

   945 			}

   946 		// Avoid duplicate uids

   947 		else if (aMessageUids[i] > prevUid)

   948 			{

   949 			if (inRange && aMessageUids[i] > prevUid + 1 )

   950 				{

   951 				// Next uid is more than 1 greater than the last.  The range has ended.

   952 				AppendAndGrowFormatL(sequenceSet, KFormatEndRangeAndNextUid(), &overflowHandler, prevUid, aMessageUids[i]);

   953 				inRange = EFalse;

   954 				}

   955 			else if (!inRange)

   956 				{

   957 				if (aMessageUids[i] == prevUid + 1)

   958 					{

   959 					// One greater than the last uid means a range has started.  

   960 					// Wait until the end of the range before outputing anything.

   961 					inRange = ETrue;

   962 					}

   963 				else

   964 					{

   965 					// This one is on its own.

   966 					AppendAndGrowFormatL(sequenceSet, KFormatNextUid(), &overflowHandler, aMessageUids[i]);

   967 					}			

   968 				}

   969 			}

   970 			

   971 		prevUid = aMessageUids[i];

   972 		}

   973 	

   974 	// Output the final (range ending) value as it was skipped earlier.

   975 	if (inRange)

   976 		{

   977 		AppendAndGrowFormatL(sequenceSet, KFormatFinalEndRangeUid(), &overflowHandler, prevUid);

   978 		}

   979 	

   980 	// Allocate on the heap.

   981 	HBufC8* sequenceSetOnHeap = sequenceSet.AllocL();

   982 	// Rbuf no longer needed...

   983 	CleanupStack::PopAndDestroy(&sequenceSet);

   984 	

   985 	// But heap version needs to be put onto the cleanup stack.

   986 	CleanupStack::PushL(sequenceSetOnHeap);

   987 	return sequenceSetOnHeap;

   988 	}

   989 

   990 /**

   991 @return A pointer to the input stream

   992 @internalComponent

   993 */

   994 MInputStream* CImapSession::InputStream()

   995 	{

   996 	return iInputStream;

   997 	}

   998 

   999 /**

  1000 @return A pointer to the output stream

  1001 @internalComponent

  1002 */

  1003 MOutputStream* CImapSession::OutputStream()

  1004 	{

  1005 	return iOutputStream;

  1006 	}

  1007 

  1008 void CImapSession::StartCommandL(TRequestStatus& aStatus, CImapCommand* aCommand)

  1009 	{

  1010 	__ASSERT_DEBUG(iCurrentCommand == NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionNotNullCurrentCommand));

  1011 	__ASSERT_DEBUG(iOutputStream != NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionNullOutputStream));

  1012 	__ASSERT_DEBUG(iInputStream != NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionNullInputStream));

  1013 	__ASSERT_DEBUG(!iInputStream->IsReading(), TImapServerPanic::ImapPanic(TImapServerPanic::ESessionBadInputStreamState));

  1014 	__ASSERT_DEBUG(iSessionState == ESessionNormal, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionInvalidSessionState));

  1015 	

  1016 	iCurrentCommand = aCommand; // Take ownership immediately before there's a chance of leaving...

  1017 		

  1018 	iCurrentCommand->SendMessageL(++iNextTagId, *iOutputStream);

  1019 	

  1020 	// Start supplying Imap Server data to the command.

  1021 	if (iInputBuffer.Length() > 0)

  1022 		{

  1023 		// Use data that was previously delivered by the input stream

  1024 		// but which has not yet been consumed.

  1025 		ProcessInputBufferAsync();

  1026 		}

  1027 	else

  1028 		{

  1029 		RequestReadData();

  1030 		}

  1031 			

  1032 	// Queue should always be the last method, so as to avoid leaving!

  1033 	Queue(aStatus);

  1034 	}

  1035 

  1036 /**

  1037 Requests data from the input stream

  1038 */

  1039 void CImapSession::RequestReadData()

  1040 	{

  1041 	// Check that there is no asynchronous call to ProcessInputBuffer outstanding

  1042 	__ASSERT_DEBUG(iAsyncCallBackOpCode != EAsyncCallBackOpProcessInputBuffer, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionAsyncCallBackOpInvalid));

  1043 	__ASSERT_DEBUG(iInputStream!=NULL, TImapServerPanic::ImapPanic(TImapServerPanic::ESessionNullInputStream));

  1044 	

  1045 	__LOG_TEXT(iLogId, "CImapSession::RequestReadData()");

  1046 	

  1047 	if (iInputStream != NULL)

  1048 		{

  1049 		if( iPendingOperation == EOpIdleDone)

  1050 			{

  1051 			__LOG_TEXT(iLogId, "CImapSession iInputStream->ReadReq() for DONE");

  1052 			SetPendingOperation(EOpNone);

  1053 			iInputStream->ReadReq(10);

  1054 			}

  1055 		else 

  1056 			{

  1057 			__LOG_TEXT(iLogId, "CImapSession iInputStream->ReadReq()");

  1058 			iInputStream->ReadReq();

  1059 			}

  1060 		

  1061 		if (iSessionState == ESessionFlushing)

  1062 			{

  1063 			__LOG_TEXT(iLogId, "CImapSession Start FlushTimeout");

  1064 			iFlushCommandTimeout->After(KFlushTimeoutPeriod);

  1065 			}

  1066 		}

  1067 	}

  1068 

  1069 /**

  1070 Stops reading server data and completes any Queued operation with KErrCancel.

  1071 Call FlushCancelledCommand() to read and discard any data associated with the command

  1072 Or call DoneIdle() to complete an idle command.

  1073 */

  1074 EXPORT_C void CImapSession::Cancel()

  1075 	{

  1076 	__LOG_TEXT(iLogId, "CImapSession::Cancel() - START");

  1077 	DoCancel();

  1078 	__LOG_TEXT(iLogId, "CImapSession::Cancel() - done DoCancel");

  1079 	Complete(KErrCancel);

  1080 	__LOG_TEXT(iLogId, "CImapSession::Cancel() - END");

  1081 	}

  1082 

  1083 /**

  1084 Stops reading server data, but does not complete any Queued operation.

  1085 This should either be called by Cancel() itself - which will complete the queued operation with KErrCancel

  1086 or from methods internal to CImapSession.  

  1087 Internal methods that call DoCancel() are reponsible for ensuring that any queued operation will get completed.

  1088  - either by completing with some error code just before or after calling this method.

  1089  - or by initiating a new async step that will complete the queued operation later

  1090 */

  1091 void CImapSession::DoCancel()

  1092 	{

  1093 	__LOG_FORMAT((iLogId, "CImapSession::DoCancel() - START - iSessionState: %d, iPendingOperation: %d, iCurrentCommand: 0x%08x", iSessionState, iPendingOperation, iCurrentCommand ));

  1094 	// Stop processing server data

  1095 	if (iInputStream != NULL)

  1096 		{

  1097 		__LOG_TEXT(iLogId, "CImapSession::DoCancel() - iInputStream->CancelReadReq()");

  1098 		iInputStream->CancelReadReq();

  1099 		__LOG_TEXT(iLogId, "CImapSession::DoCancel() - iInputStream->CancelReadReq() cancelled");

  1100 		}

  1101 		

  1102 	iAsyncCallBack->Cancel();

  1103 	iAsyncCallBackOpCode = EAsyncCallBackOpNone;

  1104 	__LOG_TEXT(iLogId, "CImapSession::DoCancel() - iAsyncCallBackOpCode = EAsyncCallBackOpNone");

  1105 	

  1106 	iFlushCommandTimeout->Cancel();

  1107 	__LOG_TEXT(iLogId, "CImapSession::DoCancel() - iFlushCommandTimeout cancelled");

  1108 	

  1109 	if (iSessionState == ESessionNormal && iCurrentCommand != NULL)

  1110 		{

  1111 		__LOG_TEXT(iLogId, "CImapSession::DoCancel() - cancelling the current command");

  1112 		

  1113 		iCurrentCommand->Cancel();

  1114 		DoPendingOperationForCancel();

  1115 		

  1116 		// Most commands need to flush after cancel, but commands such as Idle may have different behaviours.

  1117 		if (iCurrentCommand->Flushing())

  1118 			{

  1119 			SetSessionState(ESessionFlushing);

  1120 			}

  1121 		}

  1122 	__LOG_FORMAT((iLogId, "CImapSession::DoCancel() - END - iSessionState: %d, iCurrentCommand: 0x%08x", iSessionState, iCurrentCommand ));

  1123 	}

  1124 

  1125 /**

  1126 This method reads and discards incoming data from the IMAP server until 

  1127 no more data is expected.

  1128 It can be called after calling Cancel() on any asynchronous method other 

  1129 than EnterIdleL() or WaitForIdleEvent().

  1130 It usually will complete when all the data for the cancelled command has been received.

  1131 The method will also complete after a 10 second timeout - indicating that the 

  1132 expected data has not been received from the server.

  1133 @param aStatus Signals completion of the request or a timeout.

  1134 */