diff -r 9b2cffad4b5e -r 6646c35e558c htiui/HtiServicePlugins/HtiMessagesServicePlugin/src/HtiMailboxHandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/htiui/HtiServicePlugins/HtiMessagesServicePlugin/src/HtiMailboxHandler.cpp Wed Oct 13 14:32:52 2010 +0300 @@ -0,0 +1,1198 @@ +/* +* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Implementation of HTI mailbox settings handling. +* +*/ + + +// INCLUDE FILES +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include "HtiMessagesServicePlugin.h" +#include "HtiMailboxHandler.h" + +// EXTERNAL DATA STRUCTURES + +// EXTERNAL FUNCTION PROTOTYPES + +// CONSTANTS +const TInt KMinCreateMsgLength = 36; +const TInt KMinDeleteMsgLength = 3; + +const TInt KImeiLength = 15; + +const TInt KDefaultImapPortSSL = 993; +const TInt KDefaultPopPortSSL = 995; +const TInt KDefaultSmtpPortSSL = 465; + +// MACROS + +// LOCAL CONSTANTS AND MACROS +_LIT8( KErrorInvalidParameters, "Invalid command parameters" ); +_LIT8( KErrorCreateFailed, "Mailbox creation failed" ); +_LIT8( KErrorDeleteFailed, "Mailbox deletion failed" ); + +#ifdef __WINS__ +_LIT( KWinsImei, "123456789012345" ); +#else +_LIT( KTsyName, "phonetsy" ); +#endif + +// MODULE DATA STRUCTURES + +// LOCAL FUNCTION PROTOTYPES + +// FORWARD DECLARATIONS + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CHtiMailboxHandler::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +CHtiMailboxHandler* CHtiMailboxHandler::NewL() + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::NewL" ); + CHtiMailboxHandler* self = new (ELeave) CHtiMailboxHandler(); + CleanupStack::PushL ( self ); + self->ConstructL(); + CleanupStack::Pop(); + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::NewL" ); + return self; + } + + +// ---------------------------------------------------------------------------- +// CHtiMailboxHandler::CHtiMailboxHandler +// C++ default constructor can NOT contain any code, that +// might leave. +// ---------------------------------------------------------------------------- +CHtiMailboxHandler::CHtiMailboxHandler() + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::CHtiMailboxHandler" ); + + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::CHtiMailboxHandler" ); + } + + +// ----------------------------------------------------------------------------- +// CHtiMailboxHandler::~CHtiMailboxHandler +// Destructor. +// ----------------------------------------------------------------------------- +CHtiMailboxHandler::~CHtiMailboxHandler() + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::~CHtiMailboxHandler" ); + delete iMailboxName; + delete iIncomingServer; + delete iIncomingApName; + delete iIncomingUserName; + delete iIncomingPassword; + delete iOutgoingServer; + delete iOutgoingApName; + delete iOutgoingUserName; + delete iOutgoingPassword; + delete iOwnMailAddress; + delete iOwnName; + delete iSignatureText; + delete iImapFolderPath; + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::~CHtiMailboxHandler" ); + } + + +// ----------------------------------------------------------------------------- +// CHtiMailboxHandler::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +void CHtiMailboxHandler::ConstructL() + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::ConstructL" ); + + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::ConstructL" ); + } + + +// ----------------------------------------------------------------------------- +// CHtiMailboxHandler::SetDispatcher +// Sets the dispatcher pointer. +// ----------------------------------------------------------------------------- + +void CHtiMailboxHandler::SetDispatcher( MHtiDispatcher* aDispatcher ) + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::SetDispatcher" ); + iDispatcher = aDispatcher; + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::SetDispatcher" ); + } + + +// ----------------------------------------------------------------------------- +// CHtiMailboxHandler::ProcessMessageL +// Parses the received message and calls handler functions. +// ----------------------------------------------------------------------------- +void CHtiMailboxHandler::ProcessMessageL( const TDesC8& aMessage, + THtiMessagePriority /*aPriority*/ ) + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::ProcessMessageL" ); + + // Zero length message and command code validity already checked + // in HtiMessagesServicePlugin. + + if ( aMessage[0] == CHtiMessagesServicePlugin::ECreateMailBox ) + { + if ( aMessage.Length() < KMinCreateMsgLength ) + { + SendErrorMessageL( KErrArgument, KErrorInvalidParameters ); + } + else + { + iCmManager.OpenL(); + TRAPD( err, HandleCreateMailboxL( + aMessage.Right( aMessage.Length() - 1 ) ) ); + if ( err != KErrNone ) + { + if ( err == KErrArgument ) + { + SendErrorMessageL( err, KErrorInvalidParameters ); + } + else + { + HTI_LOG_FORMAT( "Create error %d", err ); + SendErrorMessageL( err, KErrorCreateFailed ); + } + } + else + { + SendOkMsgL( KNullDesC8 ); + } + ResetVariables(); + } + } + + else + { + if ( aMessage.Length() < KMinDeleteMsgLength ) + { + SendErrorMessageL( KErrArgument, KErrorInvalidParameters ); + } + else + { + TRAPD( err, HandleDeleteMailboxL( + aMessage.Right( aMessage.Length() - 1 ) ) ); + if ( err != KErrNone ) + { + HTI_LOG_FORMAT( "Delete error %d", err ); + SendErrorMessageL( err, KErrorDeleteFailed ); + } + else + { + SendOkMsgL( KNullDesC8 ); + } + } + } + + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::ProcessMessageL" ); + } + +// ---------------------------------------------------------------------------- +// CHtiMailboxHandler::HandleCreateMailboxL +// Creates new mailbox. +// ---------------------------------------------------------------------------- +void CHtiMailboxHandler::HandleCreateMailboxL( const TDesC8& aData ) + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::HandleCreateMailboxL" ); + + ParseCreateMsgL( aData ); + + TSmtpAccount smtpAcc; + TInt result = FindSmtpAccount( *iMailboxName, smtpAcc ); + if ( result != KErrNotFound ) + { + User::Leave( KErrAlreadyExists ); + } + + CImImap4Settings* imap4Set = new (ELeave) CImImap4Settings; + CleanupStack::PushL( imap4Set ); + CImPop3Settings* pop3Set = new (ELeave) CImPop3Settings; + CleanupStack::PushL( pop3Set ); + CImSmtpSettings* smtpSet = new (ELeave) CImSmtpSettings; + CleanupStack::PushL( smtpSet ); + + CImIAPPreferences* incomingIapSet = CImIAPPreferences::NewLC(); + CImIAPPreferences* outgoingIapSet = CImIAPPreferences::NewLC(); + + CEmailAccounts* accounts = CEmailAccounts::NewLC(); + accounts->PopulateDefaultSmtpSettingsL( *smtpSet, *outgoingIapSet ); + if ( iMailboxType == 0 ) // POP3 + { + accounts->PopulateDefaultPopSettingsL( *pop3Set, *incomingIapSet ); + } + else // IMAP4 + { + accounts->PopulateDefaultImapSettingsL( *imap4Set, *incomingIapSet ); + } + + // Set access point settings + TImIAPChoice imIAPChoice; + imIAPChoice.iIAP = 0; + imIAPChoice.iDialogPref = ECommDbDialogPrefPrompt; + + if ( iIncomingApName->Length() > 0 ) + { + User::LeaveIfError( + imIAPChoice.iIAP = AccessPointUIDL( *iIncomingApName ) ); + imIAPChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt; + HTI_LOG_TEXT( "Incoming IAP user defined" ); + } + incomingIapSet->AddIAPL( imIAPChoice ); + + imIAPChoice.iIAP = 0; + imIAPChoice.iDialogPref = ECommDbDialogPrefPrompt; + + if ( iOutgoingApName->Length() > 0 ) + { + User::LeaveIfError( + imIAPChoice.iIAP = AccessPointUIDL( *iOutgoingApName ) ); + imIAPChoice.iDialogPref = ECommDbDialogPrefDoNotPrompt; + HTI_LOG_TEXT( "Outgoing IAP user defined" ); + } + outgoingIapSet->AddIAPL( imIAPChoice ); + + // Set SMTP settings + HTI_LOG_TEXT( "Setting SMTP settings" ); + smtpSet->SetServerAddressL( *iOutgoingServer ); + smtpSet->SetLoginNameL( *iOutgoingUserName ); + smtpSet->SetPasswordL( *iOutgoingPassword ); + smtpSet->SetEmailAddressL( *iOwnMailAddress ); + smtpSet->SetReplyToAddressL( *iOwnMailAddress ); + smtpSet->SetEmailAliasL( *iOwnName ); + if ( iSignatureText->Length() > 0 ) + { + smtpSet->SetAddSignatureToEmail( ETrue ); + } + else + { + smtpSet->SetAddSignatureToEmail( EFalse ); + } + smtpSet->SetSendCopyToSelf( (TImSMTPSendCopyToSelf) iSendCopyToOwnAddress ); + smtpSet->SetSendMessageOption( (TImSMTPSendMessageOption) iSendOption ); + if ( iOutgoingSecurity == 0 ) + { + smtpSet->SetSecureSockets( EFalse ); + } + else + { + smtpSet->SetSecureSockets( ETrue ); + if ( iOutgoingSecurity == 1 ) + { + smtpSet->SetSSLWrapper( EFalse ); + } + else // 2 = SSL + { + smtpSet->SetSSLWrapper( ETrue ); + } + } + if ( iOutgoingPort > 0 ) + { + smtpSet->SetPort( (TUint) iOutgoingPort ); + } + else + { + if ( iOutgoingSecurity == 2 ) // SSL + { + smtpSet->SetPort( KDefaultSmtpPortSSL ); + } + else + { + smtpSet->SetPort( KSMTPDefaultPortNumber ); + } + } + smtpSet->SetBodyEncoding( EMsgOutboxMIME ); + smtpSet->SetAddVCardToEmail( EFalse ); + smtpSet->SetRequestReceipts( EFalse ); + smtpSet->SetSMTPAuth( ETrue ); + + TSmtpAccount smtpAccount; + TPopAccount popAccount; + TImapAccount imapAccount; + + // Set POP3 settings + if ( iMailboxType == 0 ) // POP3 + { + HTI_LOG_TEXT( "Setting POP3 settings" ); + pop3Set->SetServerAddressL( *iIncomingServer ); + pop3Set->SetLoginNameL( *iIncomingUserName ); + pop3Set->SetPasswordL( *iIncomingPassword ); + pop3Set->SetApop( iAPopSecureLogin ); + if ( iIncomingSecurity == 0 ) + { + pop3Set->SetSecureSockets( EFalse ); + } + else + { + pop3Set->SetSecureSockets( ETrue ); + if ( iIncomingSecurity == 1 ) + { + pop3Set->SetSSLWrapper( EFalse ); + } + else + { + pop3Set->SetSSLWrapper( ETrue ); + } + } + if ( iIncomingPort > 0 ) + { + pop3Set->SetPort( (TUint) iIncomingPort ); + } + else + { + if ( iIncomingSecurity == 2 ) // SSL + { + pop3Set->SetPort( KDefaultPopPortSSL ); + } + else + { + pop3Set->SetPort( KPOP3DefaultPortNumber ); + } + } + if ( iRetrievedParts == 0 ) // Only headers + { + pop3Set->SetGetMailOptions( EGetPop3EmailHeaders ); + pop3Set->SetPopulationLimitL( -2 ); // -2 = headers only (EmailUtils.h) + } + else + { + pop3Set->SetGetMailOptions( EGetPop3EmailMessages ); + if ( iRetrievedParts == 1 ) // Less than (kb) + { + pop3Set->SetMaxEmailSize( iRetrieveSizeLimitKb ); + pop3Set->SetPopulationLimitL( iRetrieveSizeLimitKb ); + } + else + { + pop3Set->SetPopulationLimitL( -1 ); // -1 = body and attachment (EmailUtils.h) + } + } + + if ( iEmailsToRetrieve > 0 ) + { + pop3Set->SetInboxSynchronisationLimit( iEmailsToRetrieve ); + } + else + { + // If limit is not set (zero), retrieves all + pop3Set->SetInboxSynchronisationLimit( KErrNotFound ); + } + + pop3Set->SetAcknowledgeReceipts( EFalse ); + pop3Set->SetDisconnectedUserMode( ETrue ); + pop3Set->SetAutoSendOnConnect( ETrue ); + pop3Set->SetDeleteEmailsWhenDisconnecting( EFalse ); + + popAccount = accounts->CreatePopAccountL( + *iMailboxName, *pop3Set, *incomingIapSet, EFalse ); + HTI_LOG_FORMAT( "Created POP3 account %d", popAccount.iPopAccountId ); + smtpAccount = accounts->CreateSmtpAccountL( + popAccount, *smtpSet, *outgoingIapSet, EFalse ); + HTI_LOG_FORMAT( "Created SMTP account %d", smtpAccount.iSmtpAccountId ); + } + + // Set IMAP4 settings + else + { + HTI_LOG_TEXT( "Setting IMAP4 settings" ); + imap4Set->SetServerAddressL( *iIncomingServer ); + imap4Set->SetLoginNameL( *iIncomingUserName ); + imap4Set->SetPasswordL( *iIncomingPassword ); + if ( iIncomingSecurity == 0 ) + { + imap4Set->SetSecureSockets( EFalse ); + } + else + { + imap4Set->SetSecureSockets( ETrue ); + if ( iIncomingSecurity == 1 ) + { + imap4Set->SetSSLWrapper( EFalse ); + } + else + { + imap4Set->SetSSLWrapper( ETrue ); + } + } + if ( iIncomingPort > 0 ) + { + imap4Set->SetPort( (TUint) iIncomingPort ); + } + else + { + if ( iIncomingSecurity == 2 ) // SSL + { + imap4Set->SetPort( KDefaultImapPortSSL ); + } + else + { + imap4Set->SetPort( KIMAPDefaultPortNumber ); + } + } + if ( iEmailsToRetrieve > 0 ) + { + imap4Set->SetInboxSynchronisationLimit( iEmailsToRetrieve ); + imap4Set->SetMailboxSynchronisationLimit( iEmailsToRetrieve ); + } + else + { + // If limit is not set (zero), retrieves all + imap4Set->SetInboxSynchronisationLimit( KErrNotFound ); + imap4Set->SetMailboxSynchronisationLimit( KErrNotFound ); + } + + imap4Set->SetFolderPathL( *iImapFolderPath ); + + imap4Set->SetGetMailOptions( EGetImap4EmailHeaders ); + imap4Set->SetPartialMailOptionsL( ENoSizeLimits ); + imap4Set->SetBodyTextSizeLimitL( KMaxTInt ); + imap4Set->SetAttachmentSizeLimitL( KMaxTInt ); + imap4Set->SetAcknowledgeReceipts( EFalse ); + imap4Set->SetDisconnectedUserMode( ETrue ); + imap4Set->SetSynchronise( EUseLocal ); + imap4Set->SetSubscribe( EUpdateNeither ); + imap4Set->SetAutoSendOnConnect( ETrue ); + imap4Set->SetDeleteEmailsWhenDisconnecting( EFalse ); + imap4Set->SetImapIdle( ETrue ); + imap4Set->SetUpdatingSeenFlags( ETrue ); + + imapAccount = accounts->CreateImapAccountL( + *iMailboxName, *imap4Set, *incomingIapSet, EFalse ); + HTI_LOG_FORMAT( "Created IMAP4 account %d", imapAccount.iImapAccountId ); + smtpAccount = accounts->CreateSmtpAccountL( + imapAccount, *smtpSet, *outgoingIapSet, EFalse ); + HTI_LOG_FORMAT( "Created SMTP account %d", smtpAccount.iSmtpAccountId ); + } + + // Set as default if requested + if ( iSetAsDefault ) + { + accounts->SetDefaultSmtpAccountL( smtpAccount ); + } + + // accounts, outgoingIapSet, incomingIapSet, smtpSet, pop3Set, imap4set + CleanupStack::PopAndDestroy( 6 ); + + // Get IDs of created incoming mail account + TMsvId mailboxId = 0; + TUint32 accountId = 0; + TUid protocol = TUid::Null(); + if ( iMailboxType == 0 ) // POP3 + { + mailboxId = popAccount.iPopService; + accountId = popAccount.iPopAccountId; + protocol.iUid = KSenduiMtmPop3UidValue; + } + + else // IMAP4 + { + mailboxId = imapAccount.iImapService; + accountId = imapAccount.iImapAccountId; + protocol.iUid = KSenduiMtmImap4UidValue; + iRetrievedParts = 0; + } + + // Get the created mailbox entries + HTI_LOG_TEXT( "Opening MSV session" ); + CMsvSession* session = CMsvSession::OpenSyncL( *this ); + CleanupStack::PushL( session ); + HTI_LOG_TEXT( "Getting mailbox MSV entries" ); + CMsvEntry* incomingEntry = session->GetEntryL( mailboxId ); + CleanupStack::PushL( incomingEntry ); + CMsvEntry* outgoingEntry = session->GetEntryL( smtpAccount.iSmtpService ); + CleanupStack::PushL( outgoingEntry ); + + // Store account IDs and device IMEI to entries + HTI_LOG_TEXT( "Storing account IDs and IMEI" ); + TBuf phoneImei; + GetDeviceImeiL( phoneImei ); + HTI_LOG_FORMAT( "Got IMEI: %S", &phoneImei ); + TMsvEntry inTEntry = incomingEntry->Entry(); + inTEntry.iMtmData2 = accountId; + inTEntry.iDescription.Set( phoneImei ); + incomingEntry->ChangeL( inTEntry ); + TMsvEntry outTEntry = outgoingEntry->Entry(); + outTEntry.iMtmData2 = smtpAccount.iSmtpAccountId; + outTEntry.iDescription.Set( phoneImei ); + outgoingEntry->ChangeL( outTEntry ); + + // Create the signature text if given + if ( iSignatureText->Length() > 0 ) + { + // Get signature store + HTI_LOG_TEXT( "Getting signature store" ); + CMsvStore* store = outgoingEntry->EditStoreL(); + CleanupStack::PushL( store ); + + // Create signarure rich text + HTI_LOG_TEXT( "Creating signature CRichText" ); + CParaFormatLayer* paraFormatLayer = CParaFormatLayer::NewL(); + CleanupStack::PushL( paraFormatLayer ); + CCharFormatLayer* charFormatLayer = CCharFormatLayer::NewL(); + CleanupStack::PushL( charFormatLayer ); + CRichText* signature = CRichText::NewL( paraFormatLayer, + charFormatLayer ); + CleanupStack::PushL( signature ); + signature->InsertL( 0, *iSignatureText ); + + // Store the signature + store->StoreBodyTextL( *signature ); + store->CommitL(); + + // signature, charFormatLayer, paraFormatLayer, store + CleanupStack::PopAndDestroy( 4 ); + } + + CleanupStack::PopAndDestroy( 3 ); // outgoingEntry, incomingEntry, session + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::HandleCreateMailboxL" ); + } + + +// ---------------------------------------------------------------------------- +// CHtiMailboxHandler::HandleDeleteMailboxL +// Deletes a mailbox. +// ---------------------------------------------------------------------------- +void CHtiMailboxHandler::HandleDeleteMailboxL( const TDesC8& aData ) + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::HandleDeleteMailboxL" ); + + // Delete by name - name should be unique + TInt nameLength = aData[0]; + if ( nameLength > KEmailAccountNameSize || nameLength == 0 || + aData.Length() != ( nameLength + 1 ) ) + { + User::Leave( KErrArgument ); + } + + TBuf accountName; + accountName.Copy( aData.Mid( 1, nameLength ) ); + HTI_LOG_FORMAT( "Searching account with name: %S", &accountName ); + + TSmtpAccount smtpAcc; + User::LeaveIfError( FindSmtpAccount( accountName, smtpAcc ) ); + HTI_LOG_FORMAT( "Found SMTP: %d", smtpAcc.iSmtpAccountId ); + TMsvId relatedAcc = smtpAcc.iRelatedService; + + CEmailAccounts* accounts = CEmailAccounts::NewLC(); + + // Delete the SMTP account + accounts->DeleteSmtpAccountL( smtpAcc ); + + // Search for related POP & IMAP acconts and delete if found + TInt result = KErrNone; + TPopAccount popAcc; + TRAP( result, accounts->GetPopAccountL( relatedAcc, popAcc ) ); + if ( result == KErrNone ) + { + HTI_LOG_FORMAT( "Found related POP: %d", popAcc.iPopAccountId ); + accounts->DeletePopAccountL( popAcc ); + } + + TImapAccount imapAcc; + TRAP( result, accounts->GetImapAccountL( relatedAcc, imapAcc ) ); + if ( result == KErrNone ) + { + HTI_LOG_FORMAT( "Found related IMAP: %d", imapAcc.iImapAccountId ); + accounts->DeleteImapAccountL( imapAcc ); + } + + CleanupStack::PopAndDestroy( 1 ); // accounts + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::HandleDeleteMailboxL" ); + } + + +// ---------------------------------------------------------------------------- +// CHtiMailboxHandler::ParseCreateMsgL +// Parses the parameters from the create account message. +// ---------------------------------------------------------------------------- +void CHtiMailboxHandler::ParseCreateMsgL( const TDesC8& aData ) + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::ParseCreateMsgL" ); + /* ACCOUNT SETTINGS + * Field Size Values Mandatory + * --------------------------------------------------------------------- + * Mailbox type 1 byte 0,1 YES + * Mailbox name length 1 byte 1-30 YES + * Mailbox name 1-30 YES + * Incoming mail server length 1 byte 3-50 YES + * Incoming mail server 3-50 YES + * Incoming access point name length 1 byte 0-255 YES + * Incoming access point name 0-255 NO + * Incoming user name length 1 byte 0-50 YES + * Incoming user name 0-50 NO + * Incoming password length 1 byte 0-50 YES + * Incoming password 0-50 NO + * Incoming security 1 byte 0,1,2 YES + * Incoming port 2 bytes 0-999 YES + * A POP secure login 1 byte 0,1 YES + * Outgoing mail server length 1 byte 1-50 YES + * Outgoing mail server 1-50 YES + * Outgoing access point name length 1 byte 0-255 YES + * Outgoing access point name 0-255 NO + * Outgoing user name length 1 byte 0-50 YES + * Outgoing user name 0-50 NO + * Outgoing password length 1 byte 0-50 YES + * Outgoing password 0-50 NO + * Outgoing security 1 byte 0,1,2 YES + * Outgoing port 2 bytes 0-999 YES + * Own mail address length 1 byte 1-100 YES + * Own mail address 1-100 YES + * Own name length 1 byte 0-100 YES + * Own name 0-100 NO + * Send message option 1 byte 0,1,2 YES + * Copy to own mail address 1 byte 0,1,2,3 YES + * Signature length 2 bytes 0-500 YES + * Signature text 0-500 NO + * New mail indicators 1 byte 0,1 YES + * Retrieved parts 1 byte 0,1,2 YES + * Retrieve size limit 2 bytes 1-999 YES + * Emails to retrieve 2 bytes 0-999 YES + * IMAP4 folder path length 1 byte 0-100 YES + * IMAP4 folder path 0-100 NO + * Automatic update 1 byte 0,1,2 YES + * Set as default for outgoing mail 1 byte 0,1 YES + */ + + TInt dataLength = aData.Length(); + HTI_LOG_FORMAT( "Data length = %d", dataLength ); + TInt offset = 0; + iMailboxType = aData[offset]; + HTI_LOG_FORMAT( "Mailbox type = %d", iMailboxType ); + if ( iMailboxType != 0 && iMailboxType != 1 ) + { + User::Leave( KErrArgument ); + } + offset++; + + iMailboxName = ParseStringL( aData, offset ); + offset += iMailboxName->Length() + 1; + + iIncomingServer = ParseStringL( aData, offset ); + offset += iIncomingServer->Length() + 1; + + + iIncomingApName = ParseStringL( aData, offset ); + offset += iIncomingApName->Length() + 1; + + iIncomingUserName = ParseString8L( aData, offset ); + offset += iIncomingUserName->Length() + 1; + + iIncomingPassword = ParseString8L( aData, offset ); + offset += iIncomingPassword->Length() + 1; + + // Check that it's safe to read next 4 bytes + if ( offset + 3 >= dataLength ) + { + User::Leave( KErrArgument ); + } + + iIncomingSecurity = aData[offset]; + offset++; + HTI_LOG_FORMAT( "Incoming security = %d", iIncomingSecurity ); + + iIncomingPort = aData[offset] + ( aData[offset+1] << 8 ); + offset += 2; + HTI_LOG_FORMAT( "Incoming port = %d", iIncomingPort ); + + iAPopSecureLogin = (TBool) aData[offset]; + offset++; + HTI_LOG_FORMAT( "A POP secure login = %d", iAPopSecureLogin ); + + iOutgoingServer = ParseStringL( aData, offset ); + offset += iOutgoingServer->Length() + 1; + + iOutgoingApName = ParseStringL( aData, offset ); + offset += iOutgoingApName->Length() + 1; + + iOutgoingUserName = ParseString8L( aData, offset ); + offset += iOutgoingUserName->Length() + 1; + + iOutgoingPassword = ParseString8L( aData, offset ); + offset += iOutgoingPassword->Length() + 1; + + // Check that it's safe to read next 3 bytes + if ( offset + 2 >= dataLength ) + { + User::Leave( KErrArgument ); + } + + iOutgoingSecurity = aData[offset]; + offset++; + HTI_LOG_FORMAT( "Outgoing security = %d", iOutgoingSecurity ); + + iOutgoingPort = aData[offset] + ( aData[offset+1] << 8 ); + offset += 2; + HTI_LOG_FORMAT( "Outgoing port = %d", iOutgoingPort ); + + iOwnMailAddress = ParseStringL( aData, offset ); + offset += iOwnMailAddress->Length() + 1; + + iOwnName = ParseStringL( aData, offset ); + offset += iOwnName->Length() + 1; + + // Check that it's safe to read next 2 bytes + if ( offset + 1 >= dataLength ) + { + User::Leave( KErrArgument ); + } + + iSendOption = aData[offset]; + offset++; + HTI_LOG_FORMAT( "Send option = %d", iSendOption ); + + iSendCopyToOwnAddress = aData[offset]; + offset++; + HTI_LOG_FORMAT( "Send copy = %d", iSendCopyToOwnAddress ); + + iSignatureText = ParseStringL( aData, offset, 2 ); + offset += iSignatureText->Length() + 2; + + // Check that it's safe to read next 6 bytes + if ( offset + 5 >= dataLength ) + { + User::Leave( KErrArgument ); + } + + iNewMailIndicators = (TBool) aData[offset]; + offset++; + HTI_LOG_FORMAT( "Indicators = %d", iNewMailIndicators ); + + iRetrievedParts = aData[offset]; + offset++; + HTI_LOG_FORMAT( "Retrieved parts = %d", iRetrievedParts ); + + iRetrieveSizeLimitKb = aData[offset] + ( aData[offset+1] << 8 ); + offset += 2; + HTI_LOG_FORMAT( "Size limit = %d", iRetrieveSizeLimitKb ); + + iEmailsToRetrieve = aData[offset] + ( aData[offset+1] << 8 ); + offset += 2; + HTI_LOG_FORMAT( "Emails to retrieve = %d", iEmailsToRetrieve ); + + iImapFolderPath = ParseString8L( aData, offset ); + offset += iImapFolderPath->Length() + 1; + + // Check that it's safe to read next 2 bytes + if ( offset + 1 >= dataLength ) + { + User::Leave( KErrArgument ); + } + + iAutomaticUpdate = aData[offset]; + offset++; + HTI_LOG_FORMAT( "Automatic update = %d", iAutomaticUpdate ); + + iSetAsDefault = (TBool) aData[offset]; + offset++; + HTI_LOG_FORMAT( "Set as default = %d", iSetAsDefault ); + + HTI_LOG_FORMAT( "Final offset= %d", offset ); + // Check that there's no extra bytes + if ( offset != dataLength ) + { + User::Leave( KErrArgument ); + } + + // Validate fields - limits based on S60 3.0 mailbox settings UI + if ( iMailboxName->Length() < 1 || + iMailboxName->Length() > 30 || + iIncomingServer->Length() < 3 || // a.b + iIncomingServer->Length() > 50 || + iOutgoingServer->Length() < 3 || // a.b + iOutgoingServer->Length() > 50 || + iOwnMailAddress->Length() < 5 || // a@b.c + iOwnMailAddress->Length() > 100 || + iIncomingUserName->Length() > 50 || + iIncomingPassword->Length() > 50 || + iOutgoingUserName->Length() > 50 || + iOutgoingPassword->Length() > 50 || + iOwnName->Length() > 100 || + iSignatureText->Length() > 500 || + iImapFolderPath->Length() > 100 || + iIncomingPort > 999 || + iOutgoingPort > 999 || + iRetrieveSizeLimitKb > 999 || + iEmailsToRetrieve > 999 || + iIncomingSecurity > 2 || + iOutgoingSecurity > 2 || + iSendOption > 2 || + iSendCopyToOwnAddress > 3 || + iRetrievedParts > 2 || + iAutomaticUpdate > 2 ) + { + User::Leave( KErrArgument ); + } + + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::ParseCreateMsgL" ); + } + + +// ---------------------------------------------------------------------------- +// CHtiMailboxHandler::ParseStringL +// Helper for parsing one string from the message. +// ---------------------------------------------------------------------------- +HBufC* CHtiMailboxHandler::ParseStringL( const TDesC8& aData, + TInt aStrLenOffset, + TInt aStrLenBytes ) + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::ParseStringL" ); + if ( aStrLenOffset >= aData.Length() || + aStrLenBytes > 2 || aStrLenBytes < 1 ) + { + User::Leave( KErrArgument ); + } + TInt strLen = 0; + if ( aStrLenBytes == 1 ) + { + strLen = aData[aStrLenOffset]; + } + else + { + strLen = aData[aStrLenOffset] + ( aData[aStrLenOffset +1 ] << 8 ); + } + + if ( aData.Length() <= aStrLenOffset + strLen ) + { + User::Leave( KErrArgument ); + } + HTI_LOG_FORMAT( "String length = %d", strLen ); + HBufC* result = HBufC::NewL( strLen ); + result->Des().Copy( aData.Mid( aStrLenOffset + aStrLenBytes, strLen ) ); + HTI_LOG_FORMAT( "Parsed: %S", result ); + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::ParseStringL" ); + return result; + } + + +// ---------------------------------------------------------------------------- +// CHtiMailboxHandler::ParseString8L +// Helper for parsing one string from the message. +// ---------------------------------------------------------------------------- +HBufC8* CHtiMailboxHandler::ParseString8L( const TDesC8& aData, + TInt aStrLenOffset, + TInt aStrLenBytes ) + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::ParseString8L" ); + if ( aStrLenOffset >= aData.Length() || + aStrLenBytes > 2 || aStrLenBytes < 1 ) + { + User::Leave( KErrArgument ); + } + TInt strLen = 0; + if ( aStrLenBytes == 1 ) + { + strLen = aData[aStrLenOffset]; + } + else + { + strLen = aData[aStrLenOffset] + ( aData[aStrLenOffset + 1] << 8 ); + } + if ( aData.Length() <= aStrLenOffset + strLen ) + { + User::Leave( KErrArgument ); + } + HTI_LOG_FORMAT( "String length = %d", strLen ); + HBufC8* result = aData.Mid( aStrLenOffset + aStrLenBytes, strLen ).AllocL(); + HTI_LOG_FORMAT( "Parsed: %S", result ); + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::ParseString8L" ); + return result; + } + + +// ---------------------------------------------------------------------------- +// CHtiMailboxHandler::AccessPointUIDL +// Gets the UID of Access Point named by aApName. +// Returns KErrNotFound if AP not found. +// ---------------------------------------------------------------------------- +TInt CHtiMailboxHandler::AccessPointUIDL( const TDesC& aApName ) + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::AccessPointUIDL" ); + TInt iapId = KErrNotFound; + + // Search from uncategorised first + RArray array = RArray(); + iCmManager.ConnectionMethodL( array ); + CleanupClosePushL( array ); + TInt i = 0; + while ( i < array.Count() && iapId == KErrNotFound ) + { + RCmConnectionMethod cm = iCmManager.ConnectionMethodL( array[i] ); + CleanupClosePushL( cm ); + HBufC* name = cm.GetStringAttributeL( CMManager::ECmName ); + HTI_LOG_FORMAT( "Found name: %S", name ); + CleanupStack::PushL( name ); + if ( aApName.Compare( *name ) == 0 ) + { + iapId = cm.GetIntAttributeL( CMManager::ECmId ); + HTI_LOG_FORMAT( "Match: UID = %d", iapId ); + } + CleanupStack::PopAndDestroy(); // name + CleanupStack::PopAndDestroy(); // cm + i++; + } + CleanupStack::PopAndDestroy(); // array + + // If not found from uncategorised, search from all destinations + if ( iapId == KErrNotFound ) + { + HTI_LOG_TEXT( "Not found from uncategorised" ); + RArray destIdArray = RArray(); + iCmManager.AllDestinationsL( destIdArray ); + CleanupClosePushL( destIdArray ); + i = 0; + while ( i < destIdArray.Count() && iapId == KErrNotFound ) + { + RCmDestination dest = iCmManager.DestinationL( destIdArray[i] ); + CleanupClosePushL( dest ); + TInt j = 0; + while ( j < dest.ConnectionMethodCount() && iapId == KErrNotFound ) + { + HBufC* name = dest.ConnectionMethodL( j ).GetStringAttributeL( + CMManager::ECmName ); + CleanupStack::PushL( name ); + HTI_LOG_FORMAT( "Found name: %S", name ); + if ( aApName.Compare( *name ) == 0 ) + { + iapId = dest.ConnectionMethodL( j ).GetIntAttributeL( + CMManager::ECmId ); + HTI_LOG_FORMAT( "Match: UID = %d", iapId ); + } + CleanupStack::PopAndDestroy(); // name + j++; + } + CleanupStack::PopAndDestroy(); // dest + i++; + } + CleanupStack::PopAndDestroy(); // destIdArray + } + + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::AccessPointUIDL" ); + return iapId; + } + + +// ---------------------------------------------------------------------------- +// CHtiMailboxHandler::FindSmtpAccount +// Searches for an SMTP account by name. +// Returns KErrNone if found, otherwise KErrNotFound or other error. +// ---------------------------------------------------------------------------- +TInt CHtiMailboxHandler::FindSmtpAccount( const TDesC& aAccountName, + TSmtpAccount& aAccount ) + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::FindSmtpAccount" ); + + TInt err = KErrNone; + TInt popCount = 0; + + RArray smtpAccounts; + CleanupClosePushL( smtpAccounts ); + popCount++; // smtpAccounts + + CEmailAccounts* accounts = NULL; + TRAP( err, accounts = CEmailAccounts::NewL() ); + + if ( err == KErrNone ) + { + CleanupStack::PushL( accounts ); + popCount++; // accounts + TRAP( err, accounts->GetSmtpAccountsL( smtpAccounts ) ); + } + + if ( err == KErrNone ) + { + TInt count = smtpAccounts.Count(); + HTI_LOG_FORMAT( "Found %d SMTP accounts", count ); + err = KErrNotFound; + for ( TInt i = 0; i < count; i++ ) + { + aAccount = smtpAccounts[i]; + HTI_LOG_FORMAT( "Account name: %S", &aAccount.iSmtpAccountName ); + if ( aAccount.iSmtpAccountName.Compare( aAccountName ) == 0 ) + { + HTI_LOG_FORMAT( "Match - MSV ID %d", aAccount.iSmtpService ); + err = KErrNone; + break; + } + } + } + + CleanupStack::PopAndDestroy( popCount ); + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::FindSmtpAccount" ); + return err; + } + + +// ---------------------------------------------------------------------------- +// CHtiMailboxHandler::GetDeviceImeiL() +// Gets the device IMEI code and stores it to aResult. +// ---------------------------------------------------------------------------- +// +void CHtiMailboxHandler::GetDeviceImeiL( TDes& aResult ) + { + if ( aResult.MaxLength() < KImeiLength ) + { + User::Leave( KErrBadDescriptor ); + } +#ifdef __WINS__ + aResult.Copy( KWinsImei ); +#else + RTelServer telServer; + User::LeaveIfError( telServer.Connect() ); + CleanupClosePushL( telServer ); + User::LeaveIfError( telServer.LoadPhoneModule( KTsyName ) ); + + TInt phoneCount = 0; + User::LeaveIfError( telServer.EnumeratePhones( phoneCount ) ); + if ( phoneCount < 1 ) + { + User::Leave( KErrNotFound ); + } + + RTelServer::TPhoneInfo phoneInfo; + User::LeaveIfError( telServer.GetPhoneInfo( 0, phoneInfo ) ); + RMobilePhone mobilePhone; + User::LeaveIfError( mobilePhone.Open( telServer, phoneInfo.iName ) ); + CleanupClosePushL( mobilePhone ); + + RMobilePhone::TMobilePhoneIdentityV1 identity; + TRequestStatus status; + mobilePhone.GetPhoneId( status, identity ); + User::WaitForRequest( status ); + User::LeaveIfError( status.Int() ); + + aResult.Copy( identity.iSerialNumber ); + CleanupStack::PopAndDestroy( 2 ); // mobilePhone, telServer +#endif + } + + +// ---------------------------------------------------------------------------- +// CHtiMailboxHandler::ResetVariables +// Clears the instance variables that store the create message parameters. +// ---------------------------------------------------------------------------- +void CHtiMailboxHandler::ResetVariables() + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::ResetVariables" ); + delete iMailboxName; + iMailboxName = NULL; + delete iIncomingServer; + iIncomingServer = NULL; + delete iIncomingApName; + iIncomingApName = NULL; + delete iIncomingUserName; + iIncomingUserName = NULL; + delete iIncomingPassword; + iIncomingPassword = NULL; + delete iOutgoingServer; + iOutgoingServer = NULL; + delete iOutgoingApName; + iOutgoingApName = NULL; + delete iOutgoingUserName; + iOutgoingUserName = NULL; + delete iOutgoingPassword; + iOutgoingPassword = NULL; + delete iOwnMailAddress; + iOwnMailAddress = NULL; + delete iOwnName; + iOwnName = NULL; + delete iSignatureText; + iSignatureText = NULL; + delete iImapFolderPath; + iImapFolderPath = NULL; + + iMailboxType = KErrUnknown; + iIncomingSecurity = KErrUnknown; + iIncomingPort = KErrUnknown; + iOutgoingSecurity = KErrUnknown; + iOutgoingPort = KErrUnknown; + iSendOption = KErrUnknown; + iSendCopyToOwnAddress = KErrUnknown; + iRetrievedParts = KErrUnknown; + iRetrieveSizeLimitKb = KErrUnknown; + iEmailsToRetrieve = KErrUnknown; + iAutomaticUpdate = KErrUnknown; + + iAPopSecureLogin = EFalse; + iNewMailIndicators = EFalse; + iSetAsDefault = EFalse; + + iCmManager.Close(); + + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::ResetVariables" ); + } + + +// ---------------------------------------------------------------------------- +// CHtiMailboxHandler::SendOkMsgL +// Helper function for sending response messages. +// ---------------------------------------------------------------------------- +void CHtiMailboxHandler::SendOkMsgL( const TDesC8& aData ) + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::SendOkMsgL" ); + User::LeaveIfNull( iDispatcher ); + HBufC8* temp = HBufC8::NewL( aData.Length() + 1 ); + TPtr8 response = temp->Des(); + response.Append( ( TChar ) CHtiMessagesServicePlugin::EResultOk ); + response.Append( aData ); + User::LeaveIfError( iDispatcher->DispatchOutgoingMessage( + temp, KHtiMessagesServiceUid ) ); + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::SendOkMsgL" ); + } + + +// ---------------------------------------------------------------------------- +// CHtiMailboxHandler::SendErrorMessageL +// Helper function for sending error response messages. +// ---------------------------------------------------------------------------- +void CHtiMailboxHandler::SendErrorMessageL( TInt aError, const TDesC8& aDescription ) + { + HTI_LOG_FUNC_IN( "CHtiMailboxHandler::SendErrorMessageL" ); + User::LeaveIfNull( iDispatcher ); + User::LeaveIfError( iDispatcher->DispatchOutgoingErrorMessage( + aError, aDescription, KHtiMessagesServiceUid ) ); + HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::SendErrorMessageL" ); + } + + +// ---------------------------------------------------------------------------- +// CHtiMailboxHandler::HandleSessionEventL +// From MMsvSessionObserver. +// ---------------------------------------------------------------------------- +void CHtiMailboxHandler::HandleSessionEventL( TMsvSessionEvent /*aEvent*/, + TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/ ) + { + // HTI_LOG_FUNC_IN( "CHtiMailboxHandler::HandleSessionEventL" ); + + // HTI_LOG_FUNC_OUT( "CHtiMailboxHandler::HandleSessionEventL" ); + } + +// End of file