1 /*

     2 * Copyright (c) 2004-2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   base class for mms operations

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 #include    <msventry.h>

    23 #include    <logcli.h>

    24 #include    <logview.h>

    25 // socket error when switching to offline mode

    26 #include    <es_sock.h>

    27 // Internet error when switching to offline mode

    28 #include    <inet6err.h>

    29 #include    <CoreApplicationUIsSDKCRKeys.h>

    30 #include    <e32property.h> // PubSub

    31 #include    <connect/sbdefs.h>

    32 #include    <apgcli.h>  // RApaLsSession

    33 #include    <fileprotectionresolver.h>

    34 #include    <mmsvattachmentmanager.h>

    35 

    36 #include    "mmsbaseoperation.h"

    37 #include    "mmsservercommon.h"

    38 #include    "mmserrors.h"

    39 #include    "mmssettings.h"

    40 #include    "mmsserverentry.h"

    41 #include    "mmssession.h"

    42 #include    "mmsheaders.h"

    43 #include    "mmsdecode.h"

    44 #include    "mmsencode.h"

    45 #include    "mmsscheduledentry.h"

    46 #include    "mmslog.h"

    47 #include    "mmsconninit.h"

    48 #include    "MmsServerDebugLogging.h"

    49 #include    "MmsPhoneClient.H"

    50 #include    "mmscodecdatasupplier.h"

    51 #include    "mmscodecdatasink.h"

    52 #include 	"mmsregisteredapplications.h"

    53 

    54 // EXTERNAL DATA STRUCTURES

    55 

    56 // EXTERNAL FUNCTION PROTOTYPES  

    57 

    58 // CONSTANTS

    59 const TInt KMmsBackupWait = 300000000; // wait for 5min, no more

    60 const TInt KMmsServerReadyWait = 5000000; // wait for 5 sec for server ready after backup end

    61 

    62 // MACROS

    63 

    64 // LOCAL CONSTANTS AND MACROS

    65 

    66 // MODULE DATA STRUCTURES

    67 

    68 // LOCAL FUNCTION PROTOTYPES

    69 

    70 // FORWARD DECLARATIONS

    71 

    72 // ============================= LOCAL FUNCTIONS ===============================

    73 

    74 

    75 // ============================ MEMBER FUNCTIONS ===============================

    76 

    77 // -----------------------------------------------------------------------------

    78 // CMmsBaseOperation::CMmsBaseOperation

    79 // C++ default constructor can NOT contain any code, that

    80 // might leave.

    81 // -----------------------------------------------------------------------------

    82 //

    83 CMmsBaseOperation::CMmsBaseOperation( RFs& aFs ):CMsgActive( KMmsActiveObjectPriority ),

    84 iFs( aFs )

    85     {

    86     // As this class is derived from CBase, all uninitialized variables are set to 0.

    87     }

    88 

    89 // -----------------------------------------------------------------------------

    90 // CMmsBaseOperation::ConstructL

    91 // Symbian 2nd phase constructor can leave.

    92 // -----------------------------------------------------------------------------

    93 //

    94 void CMmsBaseOperation::ConstructL( CMmsSettings* aMmsSettings )

    95     {

    96     // Default critical state

    97     // If nothing is stored, operations just fall through, and there is no error

    98     iCriticalState = EMmsOperationEncodingPDU;

    99     iMmsSettings = aMmsSettings;

   100 

   101     // connect to socket to keep connection open as long as we need it

   102     TInt error = KErrNone;

   103     error = iSocketServ.Connect();

   104 #ifndef _NO_MMSS_LOGGING_

   105     if ( error != KErrNone )

   106         {

   107         TMmsLogger::Log( _L("BaseOperation: Connect Socket server returned error %d"), error );

   108         }

   109 #endif

   110     User::LeaveIfError( error );

   111     error = iConnection.Open( iSocketServ );

   112 #ifndef _NO_MMSS_LOGGING_

   113     if ( error != KErrNone )

   114         {

   115         TMmsLogger::Log( _L("BaseOperation: RConnection::Open returned error %d"), error );

   116         }

   117 #endif

   118     User::LeaveIfError( error );

   119     iFailed = new( ELeave ) CMsvEntrySelection;

   120     iSuccessful = new( ELeave ) CMsvEntrySelection;

   121     iResponse = CMmsHeaders::NewL( iMmsSettings->MmsVersion() );

   122     iEncoder = CMmsEncode::NewL( iFs );

   123     iDecoder = CMmsDecode::NewL( iFs );

   124     // expand size is arbitrary. It is not used, we

   125     // always allocate the amount we need

   126     iEncodeBuffer = CBufFlat::NewL( 0x100 );

   127     iMmsSession = CMmsSession::NewL( KMmsActiveObjectPriority, iSocketServ, iConnection );

   128     iRemoteParties = new ( ELeave )CDesCArrayFlat( KMmsArrayAllocationNumber );

   129     // observe backup/restore event ends

   130     iBackupStart = EFalse;

   131     iBackupEnd = EFalse;

   132     }

   133 

   134 // -----------------------------------------------------------------------------

   135 // CMmsBaseOperation::NewL

   136 // Two-phased constructor.

   137 // -----------------------------------------------------------------------------

   138 //

   139 CMmsBaseOperation* CMmsBaseOperation::NewL( RFs& aFs, CMmsSettings* aMmsSettings )

   140     {

   141     CMmsBaseOperation* self = new( ELeave ) CMmsBaseOperation( aFs );

   142     

   143     CleanupStack::PushL( self );

   144     self->ConstructL( aMmsSettings );

   145     CleanupStack::Pop( self );

   146 

   147     return self;

   148     }

   149 

   150     

   151 // Destructor

   152 CMmsBaseOperation::~CMmsBaseOperation()

   153     {

   154     // derived class must cancel.

   155 	Cancel();		// framework requirement

   156     // iSelection, iServerEntry, and iMmsSettings

   157     // are not deleted, because they belong to caller

   158 

   159 // start of ROAMING CHECK handling

   160     delete iPhone;

   161 // end ROAMING CHECK handling

   162     if ( iRemoteParties )

   163         {

   164         iRemoteParties->Reset();

   165         }

   166     delete iRemoteParties;

   167     delete iEncodeBuffer;

   168     delete iFailed;

   169     delete iSuccessful;

   170     delete iEntryWrapper;

   171     delete iUri;

   172     delete iResponse;

   173     delete iEncoder;

   174     delete iDecoder;

   175     delete iMmsLog;

   176     delete iLogEvent;

   177     delete iLogViewEvent;

   178     delete iLogClient;

   179     delete iMmsSession;

   180 

   181     // connection initiator should be NULL already...

   182     delete iConnectionInitiator;

   183     delete iIAPArray;

   184     iConnection.Close();

   185     iSocketServ.Close();

   186 

   187     }

   188 

   189 // ---------------------------------------------------------

   190 // CMmsBaseOperation::NetworkOperationsAllowed()

   191 //

   192 // ---------------------------------------------------------

   193 //

   194 TBool CMmsBaseOperation::NetworkOperationsAllowed()

   195     {

   196     TBool networkAllowed = ETrue; // optimist

   197     // If there is no such key, we will continue normally.

   198     // This means that in a system where online/offline mode switching

   199     // is not supported, we behave as we were always online

   200     

   201     CRepository* repository = NULL;

   202     TInt error = KErrNone;

   203     TInt value = ECoreAppUIsNetworkConnectionAllowed;

   204     TRAP( error, repository = CRepository::NewL( KCRUidCoreApplicationUIs ) );

   205     if( error == KErrNone )

   206         {

   207         repository->Get( KCoreAppUIsNetworkConnectionAllowed, value );

   208         delete repository;

   209         repository = NULL;

   210         if ( value == ECoreAppUIsNetworkConnectionNotAllowed )

   211             {

   212             networkAllowed = EFalse;

   213             }

   214         }

   215 

   216     return networkAllowed;

   217     }

   218 

   219 // ---------------------------------------------------------

   220 // CMmsBaseOperation::AllocateTID

   221 //

   222 // ---------------------------------------------------------

   223 //

   224 TInt64 CMmsBaseOperation::AllocateTID()

   225     {

   226     TTime currentTime;

   227     currentTime.UniversalTime();

   228     return currentTime.Int64();

   229     }

   230 

   231 // ---------------------------------------------------------

   232 // CMmsBaseOperation::StartL

   233 //

   234 // ---------------------------------------------------------

   235 //

   236 void CMmsBaseOperation::StartL(

   237     CMsvEntrySelection& aSelection,

   238     CMsvServerEntry& aServerEntry,

   239     TMsvId aService,

   240     TRequestStatus& aStatus )

   241     {

   242 

   243 #ifndef _NO_MMSS_LOGGING_

   244     TMmsLogger::Log( _L("BaseOperation starting"));

   245 #endif

   246 

   247     InitializeL( aSelection, aServerEntry, aService );

   248 

   249     if ( iCurrentMessageNo < 1 )

   250         {

   251         // nothing to send. Give up immediately

   252         aStatus = KRequestPending;

   253         TRequestStatus* status = &aStatus;

   254         User::RequestComplete( status, KErrNotFound );

   255         return;

   256         }

   257 

   258     // The first thing to do is to encode the first message.

   259     // We don't start connecting before we have something to send

   260     // We want to minimize the connection time in order to minimize

   261     // the probability of the connection being broken.

   262 

   263     // In the connect routine we must check that the connection

   264     // exists, and open it if it doesn't

   265 

   266     // the last call in derived class StartL before SetActive() must be Queue.

   267     // This will store the caller's status and set it to "request pending" state

   268     Queue( aStatus );

   269     FallThrough();

   270     }

   271     

   272 // ---------------------------------------------------------

   273 // CMmsBaseOperation::ContainsClosedContent

   274 //

   275 // ---------------------------------------------------------

   276 //

   277 TInt CMmsBaseOperation::CheckClosedContentL( CMsvServerEntry& aServerEntry, RFs& aFs )

   278     {

   279     RApaLsSession apaLsSession;

   280     TInt err = apaLsSession.Connect();

   281     

   282     if ( err != KErrNone )

   283         {

   284         return err;

   285         }

   286     CleanupClosePushL( apaLsSession );

   287     

   288     CFileProtectionResolver* fileProt = CFileProtectionResolver::NewLC( aFs );

   289         

   290     TDataRecognitionResult* dataType = new( ELeave )TDataRecognitionResult;

   291     CleanupStack::PushL( dataType );

   292         

   293     CMsvStore* store = aServerEntry.ReadStoreL();

   294     CleanupStack::PushL( store );

   295         

   296     MMsvAttachmentManager& attachMan = store->AttachmentManagerL();

   297     

   298     TInt attaCount = attachMan.AttachmentCount();

   299         

   300     TInt i = 0;

   301     // we check all attachments, but if we find even one forbidden type, we give up.

   302     for ( i = 0; i < attaCount && err == KErrNone; i++ )

   303         {

   304        	CMsvAttachment* attaInfo =  attachMan.GetAttachmentInfoL( i );

   305         RFile file;

   306         err = file.Open( aFs, attaInfo->FilePath(), EFileRead|EFileShareReadersOnly );

   307         delete attaInfo;

   308         attaInfo = NULL;

   309         

   310         if ( err == KErrNone )

   311             {

   312             // We continue only if we managed to open the file successfully    

   313             CleanupClosePushL( file );

   314         

   315             err = apaLsSession.RecognizeData( file, *dataType );

   316 #ifndef _NO_MMSS_LOGGING_

   317             if ( err != KErrNone )

   318                 {

   319                 TMmsLogger::Log(_L("- Error in recognization of data type"), err );

   320                 // We assume that the file cannot be closed content, if its type

   321                 // is not recognized

   322                 err = KErrNotSupported;

   323                 }

   324             else

   325                 {

   326                 HBufC16* buf16 = HBufC16::NewLC( KMaxFileName );

   327                 TPtrC dummy;

   328                 TPtr ptr = buf16->Des();

   329                 file.Name( ptr );

   330                 // we cannot log indefinitely long strings.

   331                 // We get this long strings only if the message is corrupted.

   332                 dummy.Set( ptr.Left( KMmsMaxLogStringLength ) );

   333                 TMmsLogger::Log( _L("- filename: %S"), &dummy );

   334                 CleanupStack::PopAndDestroy( buf16 );

   335 

   336                 TBuf<KMaxDataTypeLength> buffer;

   337                 buffer.Copy( dataType->iDataType.Des8() );

   338                 TMmsLogger::Log(_L("- Data type recognizer result: %S"), &buffer );

   339                 if ( dataType->iConfidence == CApaDataRecognizerType::ECertain )

   340                     {

   341                     TMmsLogger::Log(_L("- Confidence level: Certain"));

   342                     }

   343                 else if ( dataType->iConfidence == CApaDataRecognizerType::EProbable )

   344                     {

   345                     TMmsLogger::Log(_L("- Confidence level: Probable"));

   346                     }

   347                 else if ( dataType->iConfidence == CApaDataRecognizerType::EPossible )

   348                     {

   349                     TMmsLogger::Log(_L("- Confidence level: Possible"));

   350                     }

   351                 else if ( dataType->iConfidence == CApaDataRecognizerType::EUnlikely )

   352                     {

   353                     TMmsLogger::Log(_L("- Confidence level: Unlikely"));

   354                     }

   355                 else if ( dataType->iConfidence == CApaDataRecognizerType::ENotRecognized )

   356                     {

   357                     TMmsLogger::Log(_L("- Confidence level: Not recognized"));

   358                     }

   359                 else

   360                     {

   361                     TMmsLogger::Log(_L("- Unknown confidence level"));

   362                     }

   363                 }

   364 #endif

   365             // We Must set limit to "possible". The recognition is rather uncertain

   366             if ( err == KErrNone && dataType->iConfidence >= CApaDataRecognizerType::EPossible )

   367                 {

   368                 TInt pos = 0;

   369                 file.Seek( ESeekStart, pos ); // rewind just in case

   370                 TInt prot = fileProt->ProtectionStatusL( file, dataType->iDataType );

   371                 if ( ( prot & ( EFileProtForwardLocked | EFileProtClosedContent ) ) &&

   372                     !( prot & EFileProtSuperDistributable ) )

   373                     {

   374                     err = KMmsErrorProtectedContent;

   375                     }

   376                 }

   377             CleanupStack::PopAndDestroy( &file ); //close file    

   378             }

   379 #ifndef _NO_MMSS_LOGGING_

   380         else

   381             {

   382             TMmsLogger::Log(_L("- Error in opening file for recognization of data type"), err );

   383             }

   384 #endif

   385         }

   386 

   387     CleanupStack::PopAndDestroy( store );

   388     CleanupStack::PopAndDestroy( dataType );

   389     CleanupStack::PopAndDestroy( fileProt );

   390         

   391     CleanupStack::PopAndDestroy( &apaLsSession ); // close apaSession

   392     

   393     if ( err == KErrNotSupported )

   394         {

   395         // the content type was not recognized, we must assume it is not closed content

   396         err = KErrNone;

   397         }

   398     

   399     return err;

   400     }

   401 

   402 // ---------------------------------------------------------

   403 // CMmsBaseOperation::HandleBackupOperationEventL

   404 //

   405 // ---------------------------------------------------------

   406 //

   407 void CMmsBaseOperation::HandleBackupOperationEventL(

   408     const TBackupOperationAttributes& aBackupOperationAttributes )

   409     {

   410     switch ( aBackupOperationAttributes.iOperation )

   411         {

   412         case EStart:

   413             iBackupStart = ETrue;

   414             iBackupEnd = EFalse;

   415 #ifndef _NO_MMSS_LOGGING_

   416             TMmsLogger::Log(_L("Backup/Restore Start"));

   417 #endif

   418             break;

   419         case EEnd:

   420         case EAbort:

   421             iBackupStart = EFalse;

   422             if ( iHaveTimer )

   423                 {

   424                 iTimer.Cancel();

   425                 // Set this to true only if we cancel timer because of backup end

   426                 iBackupEnd = ETrue;

   427                 // do not do it twice

   428                 iDoNotWaitForBackupEnd = ETrue;

   429                 iMustWait = ETrue;

   430                 }

   431 #ifndef _NO_MMSS_LOGGING_

   432             if ( aBackupOperationAttributes.iOperation == EEnd )

   433                 {

   434                 TMmsLogger::Log(_L("Backup/Restore End"));

   435                 }

   436             else // if not end, then it was abort

   437                 {

   438                 TMmsLogger::Log(_L("Backup/Restore Abort"));

   439                 }

   440 #endif

   441             break;

   442         default:

   443             break;

   444         }

   445     }

   446 

   447 // ---------------------------------------------------------

   448 // CMmsBaseOperation::RunL

   449 //

   450 // ---------------------------------------------------------

   451 //

   452 void CMmsBaseOperation::RunL()

   453     {

   454     // DoRunL() takes the AO through the states, queuing another

   455     // asynch step as required.

   456     // if DoRunL() detects the end of the cycle it returns

   457     // without queuing another cycle.

   458 

   459     // If Run() would exit without queuing another cycle it reports

   460     // completion to the client.

   461     // In CMsgActive this is true if the asynch step or DoRunL fails,

   462     // or the state cycle is complete

   463     // However, we must keep our cycle going in spite of error.

   464     // If any step reports an error, we must cleanup the current

   465     // operation, and continue to the next entry in the selection.

   466     // Only if we lose the connection, we complete the whole loop.

   467 

   468     // If we have completed ourselves, the error is already in iError.

   469     // However, if an asynchronous operation completed us, the error

   470     // comes back to us in iStatus.

   471     // As we always complete ourselves by returning iError as the

   472     // status, we get back either our original iError, or a new

   473     // error value set by an asynchronous operation.

   474 #ifndef _NO_MMSS_LOGGING_

   475     TMmsLogger::Log( _L("BaseOperation RunL status %d, error %d"),

   476         iStatus.Int(), iError );

   477 #endif

   478     TInt status=iStatus.Int();

   479 

   480     if ( iBackupEnd && ( status == KErrCancel || status == KErrTimedOut ) )

   481         {

   482         // timer cancelled because of backup end - continue as if no error

   483         status = KErrNone;

   484         }

   485 

   486     // wait for 5 seconds after backup end

   487     if ( iMustWait )

   488         {

   489         // Timer is never active if iMustWait == ETrue,

   490         // Actually it is not possible to check if iTimer is active.

   491         // We must rely on iMustWait.

   492         // iMustWait is set true only when the timer was just cancelled

   493         // because of backup end, and we must wait a few seconds before continuing.

   494         iMustWait = EFalse;

   495         iTimer.After( iStatus, KMmsServerReadyWait );

   496         SetActive();

   497         return;

   498         }

   499 

   500     // when we come here after wait, the timer can go.

   501     if ( iHaveTimer )

   502         {

   503         iTimer.Cancel();

   504         iTimer.Close();

   505         iHaveTimer = EFalse;

   506         iDoNotWaitForBackupEnd = ETrue;

   507         iBackupEnd = EFalse;

   508         }

   509 

   510     if ( status <= (TInt) KMsvMediaUnavailable &&

   511         status >= (TInt) KMsvIndexRestore &&

   512         !iDoNotWaitForBackupEnd )

   513         {

   514 #ifndef _NO_MMSS_LOGGING_

   515         TMmsLogger::Log( _L("- must wait for backup end ") );

   516 #endif

   517         iState = EMmsOperationWaitingForBackupEnd;

   518         // This will take us back to RunL

   519         WaitForBackupEnd();

   520         // iError has been set when the media unavailable error has occurred.

   521         if ( iError == status )

   522             {

   523             iError = KErrNone;

   524             }

   525         return;

   526         }

   527         

   528     if ( iState == EMmsOperationCheckingRoaming )

   529         {

   530         // the status is the result of the roaming query

   531         iRegistrationStatus = status;

   532         delete iPhone;

   533         iPhone = NULL;

   534         if ( status > 0 )

   535             {

   536             // If the status is a successful registration state result,

   537             // it must not be set into iError

   538             // However, if something has gone wrong, the error should

   539             // be propagated.

   540             status = 0;

   541             }

   542         }

   543 

   544     // Don't override old error.

   545     // Connection state returns index of successful connection in status,

   546     // it must be handled separately.

   547     // And if logging fails, the error is not stored.

   548     // Logging is done on "best effort" basis

   549     if ( iError == KErrNone &&

   550         iState != EMmsOperationConnectingToIAP &&

   551         iState != EMmsOperationLogging)

   552         {

   553         iError = status;

   554         }

   555 

   556     // The connection may go wrong, which means there's no use continuing now.

   557     // On the other hand, if one operation fails, the next one may be all right.

   558     // We don't exit in the middle of the loop without deciding

   559     // what cleanup work must be done.

   560     // Only cancel can exit.

   561     if ( status != KErrCancel )

   562         {

   563         // iError contains the possible error from previous step.

   564         // It may be needed to decide what to do with current message

   565         // in next step.

   566         TRAPD( error,DoRunL() );    // continue operations, may re-queue

   567         // must not requeue in error situations

   568         // If we want to continue the loop in spite of error,

   569         // we must not leave, but return the error in iError.

   570         // Symbian code may leave, so we must trap the leaves here,

   571         // as we want to keep the loop going unless something

   572         // is really fatally wrong (we are completely out of memory,

   573         // or the system has crashed)

   574 #ifndef _NO_MMSS_LOGGING_

   575         if ( error != KErrNone )

   576             {

   577             TMmsLogger::Log(_L("BaseOperatin DoRunL left with error %d"),

   578                 error );

   579             if ( IsActive() )

   580                 {

   581                 TMmsLogger::Log(_L("- still active!"));

   582                 }

   583             }

   584 #endif

   585         __ASSERT_DEBUG( error==KErrNone || !IsActive(), User::Invariant() );

   586         if ( IsActive() ) // requeued

   587             {

   588             return;

   589             }

   590         status=error;

   591         if ( error == KErrNone )

   592             {

   593             // If DoRunL did not leave, possible error is in iError

   594             status = iError;

   595             }

   596         }

   597     

   598     Complete( status );

   599     }

   600 

   601 // ---------------------------------------------------------

   602 // CMmsBaseOperation::DoRunL

   603 //

   604 // ---------------------------------------------------------

   605 //

   606 void CMmsBaseOperation::DoRunL()

   607     {

   608 

   609     // This routine takes the state machine through the states

   610     // until an error is encountered or the cycle completes.

   611 

   612     if ( iState != EMmsOperationFinalizing )

   613         {

   614         SelectNextState();

   615         // If appropriate, ChangeState makes us active again

   616         ChangeStateL();

   617         }

   618     else

   619         {

   620         iState = EMmsOperationIdle;

   621         iStatus = iError;

   622         // If we return from DoRunL without becoming active again,

   623         // RunL completes.

   624         }

   625     }

   626 

   627 // ---------------------------------------------------------

   628 // CMmsBaseOperation::DoComplete

   629 //

   630 // ---------------------------------------------------------

   631 //

   632 void CMmsBaseOperation::DoComplete( TInt& aError )

   633     {

   634 

   635 #ifndef _NO_MMSS_LOGGING_

   636     TMmsLogger::Log( _L("BaseOperation DoComplete"));

   637 #endif

   638     // We should get here if we are cancelled, or if

   639     // the cycle has completed (with or without error)

   640 

   641     // Only final cleanup can be done here, nothing asychronous is allowed

   642 

   643     UnSetSendMask( *iFailed, aError );

   644 

   645     }

   646 

   647 // ---------------------------------------------------------

   648 // CMmsBaseOperation::DoCancel

   649 //

   650 // ---------------------------------------------------------

   651 //

   652 void CMmsBaseOperation::DoCancel()

   653     {

   654 #ifndef _NO_MMSS_LOGGING_

   655     TMmsLogger::Log( _L("BaseOperation DoCancel"));

   656 #endif

   657     // cancel anything that is still active

   658 

   659     if ( iPhone )

   660         {

   661         iPhone->Cancel();

   662         }

   663     if ( iDecoder )

   664         {

   665         iDecoder->Cancel();

   666         }

   667     if ( iEncoder )

   668         {

   669         iEncoder->Cancel();

   670         }

   671     if ( iConnectionInitiator )

   672         {

   673         iConnectionInitiator->Cancel();

   674         }

   675     if ( iMmsSession )

   676         {

   677         iMmsSession->Cancel();

   678         }

   679     if ( iHaveTimer )

   680         {

   681         iTimer.Cancel();

   682         iTimer.Close();

   683         iHaveTimer = EFalse;

   684         }

   685 

   686     CMsgActive::DoCancel();

   687     if ( iError == KErrNone )

   688         {

   689         iError = KErrCancel;

   690         }

   691 

   692     }

   693 

   694 // ---------------------------------------------------------

   695 // CMmsBaseOperation::SelectNextState

   696 //

   697 // ---------------------------------------------------------

   698 //

   699 void CMmsBaseOperation::SelectNextState()

   700     {

   701 

   702     // If appropriate, the functions called within the switch statement

   703     // will make us active again. If all is done, the asynchronous request

   704     // will complete

   705 

   706     // iCritical state determines the state where the operation must be

   707     // continued if progress is interrupted by an error caused by backup/restore.

   708     // The critical state changes when enough information has been saved so

   709     // that backtracking is no longer needed. The critical state is always a 

   710     // stat where information is read from disk or stored to disk, because

   711     // disk operations may fail because of backup/restore.

   712     // Continuation is usually possible only after backup, not after restore,

   713     // but because available events do not specify which operation is in progress,

   714     // every situation must be handled as if it would be possible to continue

   715     // as soon as disk files can be accessed again.

   716 

   717     switch ( iState )

   718         {

   719         case EMmsOperationIdle:

   720             iState = EMmsOperationCheckingRoaming;

   721             break;

   722         case EMmsOperationCheckingRoaming:

   723             // check what we got from the roaming query and adjust any 

   724             // roaming state dependent modes needed by the operation

   725             GetRoamingState();

   726             iState = EMmsOperationEncodingPDU;

   727             break;

   728         case EMmsOperationEncodingPDU:

   729             if ( iConnected )

   730                 {

   731                 iState = EMmsOperationSubmittingTransaction;

   732                 }

   733             else

   734                 {

   735                 iState = EMmsOperationConnectingToIAP;

   736                 }

   737             iCriticalState = EMmsOperationCreatingEntry;

   738             break;

   739         case EMmsOperationConnectingToIAP:

   740             CheckConnectionState();

   741             if ( iConnected )

   742                 {

   743                 iState = EMmsOperationInitializingSession;

   744                 }

   745             else

   746                 {

   747                 // if could not connect, give up

   748                 iState = EMmsOperationUpdatingEntryStatus; 

   749                 }

   750             break;

   751         case EMmsOperationInitializingSession:

   752             iState = EMmsOperationSubmittingTransaction;

   753             break;

   754         case EMmsOperationSubmittingTransaction:

   755             iState = EMmsOperationCreatingEntry;

   756             iCriticalState = EMmsOperationCreatingEntry;

   757             break;

   758         case EMmsOperationCreatingEntry:

   759             iState = EMmsOperationDecodingResponse;

   760             break;

   761         case EMmsOperationDecodingResponse:

   762             iState = EMmsOperationStoringResponseData;

   763             iCriticalState = EMmsOperationStoringResponseData;

   764             break;

   765         case EMmsOperationStoringResponseData:

   766             iState = EMmsOperationEncodingAck;

   767             iCriticalState = EMmsOperationUpdatingEntryStatus;

   768             break;

   769         case EMmsOperationEncodingAck:

   770             iState = EMmsOperationSendingAck;

   771             break;

   772         case EMmsOperationSendingAck:

   773             iState = EMmsOperationUpdatingEntryStatus;

   774             break;

   775         case EMmsOperationUpdatingEntryStatus:

   776             iState = EMmsOperationLogging;

   777             iCriticalState = EMmsOperationMovingEntry;

   778             break;

   779         case EMmsOperationLogging:

   780             iState = EMmsOperationMovingEntry;

   781             break;

   782         case EMmsOperationMovingEntry:

   783             iCurrentMessageNo--;

   784             if ( iCurrentMessageNo > 0 )

   785                 {

   786                 iState = EMmsOperationEncodingPDU;

   787                 iCriticalState = EMmsOperationEncodingPDU;

   788                 }

   789             else

   790                 {

   791                 iState = EMmsOperationFinalizing;

   792                 iCriticalState = EMmsOperationFinalizing;

   793                 }

   794             break;

   795         case EMmsOperationFinalizing:

   796             // no more states

   797             break;

   798         case EMmsOperationWaitingForBackupEnd:

   799             // return to failure point

   800             iState = iCriticalState;

   801             break;

   802         default:

   803             // If we are in an illegal state, we don't change it.

   804             // The only way we can end here is if someone overwrites

   805             // our stack, and in that case things are so terribly wrong

   806             // that there is nothing to be done

   807             // Change state will terminate the loop.

   808 #ifndef _NO_MMSS_LOGGING_

   809             TMmsLogger::Log( _L("BaseOperation in illegal state %d "), iState );

   810 #endif

   811             break;

   812         }

   813     }

   814 

   815 // ---------------------------------------------------------

   816 // CMmsBaseOperation::ChangeStateL

   817 //

   818 // ---------------------------------------------------------

   819 //

   820 void CMmsBaseOperation::ChangeStateL()

   821     {

   822     switch ( iState )

   823         {

   824         case EMmsOperationCheckingRoaming:

   825             RoamingCheck();

   826             break;

   827         case EMmsOperationEncodingPDU:

   828             EncodePDUL();

   829             break;

   830         case EMmsOperationConnectingToIAP:

   831             ConnectToIAPL();

   832             break;

   833         case EMmsOperationInitializingSession:

   834             InitializeSessionL();

   835             break;

   836         case EMmsOperationSubmittingTransaction:

   837             SubmitTransactionL();

   838             break;

   839         case EMmsOperationCreatingEntry:

   840             CreateEntryL();

   841             break;

   842         case EMmsOperationDecodingResponse:

   843             DecodeResponseL();

   844             break;

   845         case EMmsOperationStoringResponseData:

   846             StoreResponseL();

   847             break;

   848         case EMmsOperationEncodingAck:

   849             EncodeAckL();

   850             break;

   851         case EMmsOperationSendingAck:

   852             SendAckL();

   853             break;

   854         case EMmsOperationUpdatingEntryStatus:

   855             UpdateEntryStatusL();

   856             break;

   857         case EMmsOperationLogging:

   858             LogL();

   859             break;

   860         case EMmsOperationMovingEntry:

   861             MoveEntryL();

   862             break;

   863         case EMmsOperationFinalizing:

   864             FinalizeL();

   865             break;

   866         case EMmsOperationWaitingForBackupEnd:

   867             WaitForBackupEnd();

   868             break;

   869         case EMmsOperationIdle:

   870             // We should not become idle again. This is startup state

   871             break;

   872         default:

   873             // Totally messed up. Someone overwrote the stack.

   874             // If we return without becoming active again, the 

   875             // cycle completes.

   876 #ifndef _NO_MMSS_LOGGING_

   877             TMmsLogger::Log( _L("BaseOperation in illegal state %d "), iState );

   878 #endif

   879             iError = KErrUnknown;

   880             iStatus = iError;

   881             break;

   882         }

   883     }

   884 

   885 

   886 // ---------------------------------------------------------

   887 // CMmsBaseOperation::FallThrough

   888 //

   889 // ---------------------------------------------------------

   890 //

   891 void CMmsBaseOperation::FallThrough()

   892     {

   893     TRequestStatus* status = &iStatus;

   894     iStatus = KRequestPending;

   895     SetActive();

   896     User::RequestComplete( status, iError );

   897     }

   898 

   899 

   900 // ---------------------------------------------------------

   901 // CMmsBaseOperation::InitializeL

   902 //

   903 // ---------------------------------------------------------

   904 //

   905 void CMmsBaseOperation::InitializeL(

   906     CMsvEntrySelection& aSelection,

   907     CMsvServerEntry& aServerEntry,

   908     TMsvId aService )

   909     {

   910 

   911 #ifndef _NO_MMSS_LOGGING_

   912     TMmsLogger::Log( _L("BaseOperation Initialize"));

   913 #endif

   914 

   915     iSelection = &aSelection;

   916     iServerEntry = &aServerEntry;

   917     iService = aService;

   918 

   919     iDoNotWaitForBackupEnd = EFalse;

   920     iCriticalState = EMmsOperationEncodingPDU;

   921 

   922     delete iEntryWrapper;

   923     iEntryWrapper = NULL;

   924     iEntryWrapper = CMmsServerEntry::NewL(

   925         iFs,

   926         aServerEntry,

   927         iService );

   928 

   929     iFailed->Reset();

   930     iSuccessful->Reset();

   931     iResponse->Reset();

   932 

   933     iCurrentMessageNo = iSelection->Count();

   934     iError = KErrNone;

   935 

   936     // clean these in case the class is reused

   937     delete iUri;

   938     iUri = NULL;

   939     delete iIAPArray;

   940     iIAPArray = NULL;

   941     iConnectionIndex = 0;

   942     iRegistrationStatus = 0; // hope for the best

   943 

   944     // Initialize everything into the failed list.

   945     // Very pessimistic indeed.

   946 

   947     if ( iCurrentMessageNo > 0 )

   948         {

   949         iFailed->AppendL( iSelection->Back( 0 ), iCurrentMessageNo );

   950         iSuccessful->SetReserveL( iCurrentMessageNo );

   951         }

   952 

   953     SetSendMask( *iFailed );

   954     

   955     //

   956     // NOTE: receive operation must override this setting to 'iLocalModeIn'

   957     //

   958     if ( iMmsSettings->LocalMode() )

   959         {

   960         iFs.SetSessionPath( iMmsSettings->LocalModeOut() );

   961         }

   962     }

   963 

   964 // ---------------------------------------------------------

   965 // CMmsBaseOperation::EncodePDUL

   966 //

   967 // ---------------------------------------------------------

   968 //

   969 void CMmsBaseOperation::EncodePDUL()

   970     {

   971     // This state is quite variable.

   972     // Each operation will need to know what to encode,

   973     // no common implementation available.

   974 #ifndef _NO_MMSS_LOGGING_

   975     TMmsLogger::Log( _L("BaseOperation EncodePDUL - FallThrough"));

   976 #endif

   977 

   978     // this always starts a new round. iError should be cleared.

   979     FallThrough();

   980 

   981     }

   982 

   983 // ---------------------------------------------------------

   984 // CMmsBaseOperation::ConnectToIAPL

   985 //

   986 // ---------------------------------------------------------

   987 //

   988 void CMmsBaseOperation::ConnectToIAPL()

   989     {

   990 

   991 #ifndef _NO_MMSS_LOGGING_

   992     TMmsLogger::Log( _L("BaseOperation Connect to IAP"));

   993 #endif

   994 

   995     if ( iError != KErrNone )

   996         {

   997         FallThrough();

   998         return;

   999         }

  1000 

  1001     // This operation should be identical for all derived classes.

  1002     TRequestStatus* status = &iStatus;

  1003 

  1004     // clean URI in case the class is used more than once

  1005     // Just at the last minute we check if network operations are allowed

  1006     if ( !NetworkOperationsAllowed() )

  1007         {

  1008 #ifdef __WINS__

  1009         iStatus = KRequestPending;

  1010         SetActive();

  1011         User::RequestComplete( status, KMmsErrorOfflineMode );

  1012         return;

  1013 #else

  1014         // if offline is on and global mode is on in HW, normal offline behaviour.

  1015         // if offline is on and local mode is on in HW, continue.

  1016         // The purpose of this is to allow fetching precreated messages even if

  1017         // network operations were not allowed during the first boot.

  1018         if ( !iMmsSettings->LocalMode() )

  1019             {

  1020             iStatus = KRequestPending;

  1021             SetActive();

  1022             User::RequestComplete( status, KMmsErrorOfflineMode );

  1023             return;

  1024             }

  1025 #endif

  1026         }

  1027 

  1028     // Use WAP AP from Comms database table.

  1029     // This contains the home page URI, and is linked to the actual IAP.

  1030     TInt count = iMmsSettings->AccessPointCount();

  1031     if( !iMmsSettings->LocalMode() )

  1032         {

  1033         if ( count < 1 )

  1034             {

  1035             User::Leave( KMmsErrorNoWAPAccessPoint );

  1036             }

  1037         iIAPArray = new (ELeave) CArrayFixFlat<TUint32>( count );

  1038         for( TInt index = 0; index < count; index++ )

  1039             {

  1040             iIAPArray->AppendL( iMmsSettings->AccessPoint( index ) );

  1041             }

  1042 

  1043         iConnectionInitiator = CMmsConnectionInitiator::NewL();

  1044         // CMmsConnInit sets our status to "KRequestPending"

  1045         iConnectionInitiator->ConnectL(

  1046             iConnection,

  1047 			*iIAPArray,	

  1048 			iStatus );

  1049 

  1050         SetActive();

  1051         }

  1052     else

  1053         {

  1054         // local mode has no real wap access point

  1055         iStatus = KRequestPending;

  1056         SetActive();

  1057         // we return status 1 (as if we got connection to most

  1058         // preferred access point)

  1059         User::RequestComplete( status, 1 );

  1060         }

  1061     }

  1062 

  1063 // ---------------------------------------------------------

  1064 // CMmsBaseOperation::InitializeSessionL

  1065 //

  1066 // ---------------------------------------------------------

  1067 //

  1068 void CMmsBaseOperation::InitializeSessionL()

  1069     {

  1070 

  1071 #ifndef _NO_MMSS_LOGGING_

  1072     TMmsLogger::Log( _L("BaseOperation InitializeSession"));

  1073 #endif

  1074 

  1075     if ( iError != KErrNone || iMmsSettings->LocalMode() )

  1076         {

  1077         FallThrough();

  1078         return;

  1079         }

  1080 

  1081 // When we are supporting only HTTP, there is no separate session connection stage.

  1082 // Session initialization only sets necessary headers. (User agent and UAProf)

  1083     delete iUri;

  1084     iUri = NULL;

  1085     TUint32 iap = 0;

  1086     TBool proxyUsed = EFalse;

  1087     HBufC8* proxyAddress = NULL;

  1088     HBufC* uri = NULL;

  1089 

  1090     // We are not supposed to be here, if we haven't succeeded

  1091     // in making connection to one of specified access points

  1092     CMmsConnectionInitiator::GetParametersL( 

  1093         iIAPArray->At( iConnectionIndex - 1 ),

  1094         iap,

  1095         uri, 

  1096         proxyUsed,

  1097         proxyAddress

  1098         );

  1099 

  1100     // We must remember the uri, it will be used later.

  1101     iUri = uri;

  1102     uri = NULL;

  1103 

  1104     CleanupStack::PushL( proxyAddress );

  1105     

  1106     iMmsSession->OpenL(

  1107         ( !proxyAddress )?TPtrC8():proxyAddress->Des(),

  1108         proxyUsed,

  1109         iMmsSettings->MaximumReceiveSize(),

  1110         iMmsSettings->MaximumSendSize(),

  1111         iStatus );

  1112 

  1113     CleanupStack::PopAndDestroy( proxyAddress );

  1114     SetActive();

  1115 

  1116     }

  1117 

  1118 // ---------------------------------------------------------

  1119 // CMmsBaseOperation::SubmitTransactionL

  1120 //

  1121 // ---------------------------------------------------------

  1122 //

  1123 void CMmsBaseOperation::SubmitTransactionL()

  1124     {

  1125     // Standard transaction is sending a PDU to MMSC in global mode

  1126     // Local mode will need an override if supported (send and fetch only)

  1127     // Fetch will need an override, because it uses HTTP GET

  1128     // and not HTTP POST like other operations.

  1129 

  1130 #ifndef _NO_MMSS_LOGGING_

  1131     TMmsLogger::Log( _L("BaseOperation SubmitTransaction"));

  1132 #endif

  1133 

  1134     if ( !iConnected )