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 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    23 #include <logengdurations.h>

    24 #endif

    25 #include    <msventry.h>

    26 #include    <logcli.h>

    27 #include    <logview.h>

    28 // socket error when switching to offline mode

    29 #include    <es_sock.h>

    30 // Internet error when switching to offline mode

    31 #include    <inet6err.h>

    32 #include    <CoreApplicationUIsSDKCRKeys.h>

    33 #include    <e32property.h> // pubsub

    34 #include    <connect/sbdefs.h>

    35 #include    <apgcli.h>  // RApaLsSession

    36 #include    <fileprotectionresolver.h>

    37 #include    <mmsvattachmentmanager.h>

    38 

    39 #include    "mmsbaseoperation.h"

    40 #include    "mmsservercommon.h"

    41 #include    "mmserrors.h"

    42 #include    "mmssettings.h"

    43 #include    "mmsserverentry.h"

    44 #include    "mmssession.h"

    45 #include    "mmsheaders.h"

    46 #include    "mmsdecode.h"

    47 #include    "mmsencode.h"

    48 #include    "mmsscheduledentry.h"

    49 #include    "mmslog.h"

    50 #include    "mmsconninit.h"

    51 #include    "MmsServerDebugLogging.h"

    52 #include    "MmsPhoneClient.H"

    53 #include    "mmscodecdatasupplier.h"

    54 #include    "mmscodecdatasink.h"

    55 #include 	"mmsregisteredapplications.h"

    56 

    57 // EXTERNAL DATA STRUCTURES

    58 

    59 // EXTERNAL FUNCTION PROTOTYPES  

    60 

    61 // CONSTANTS

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

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

    64 

    65 // MACROS

    66 

    67 // LOCAL CONSTANTS AND MACROS

    68 

    69 // MODULE DATA STRUCTURES

    70 

    71 // LOCAL FUNCTION PROTOTYPES

    72 

    73 // FORWARD DECLARATIONS

    74 

    75 // ============================= LOCAL FUNCTIONS ===============================

    76 

    77 

    78 // ============================ MEMBER FUNCTIONS ===============================

    79 

    80 // -----------------------------------------------------------------------------

    81 // CMmsBaseOperation::CMmsBaseOperation

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

    83 // might leave.

    84 // -----------------------------------------------------------------------------

    85 //

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

    87 iFs( aFs )

    88     {

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

    90     }

    91 

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

    93 // CMmsBaseOperation::ConstructL

    94 // Symbian 2nd phase constructor can leave.

    95 // -----------------------------------------------------------------------------

    96 //

    97 void CMmsBaseOperation::ConstructL( CMmsSettings* aMmsSettings )

    98     {

    99     // Default critical state

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

   101     iCriticalState = EMmsOperationEncodingPDU;

   102     iMmsSettings = aMmsSettings;

   103 

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

   105     TInt error = KErrNone;

   106     error = iSocketServ.Connect();

   107 #ifndef _NO_MMSS_LOGGING_

   108     if ( error != KErrNone )

   109         {

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

   111         }

   112 #endif

   113     User::LeaveIfError( error );

   114     error = iConnection.Open( iSocketServ );

   115 #ifndef _NO_MMSS_LOGGING_

   116     if ( error != KErrNone )

   117         {

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

   119         }

   120 #endif

   121     User::LeaveIfError( error );

   122     iFailed = new( ELeave ) CMsvEntrySelection;

   123     iSuccessful = new( ELeave ) CMsvEntrySelection;

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

   125     iEncoder = CMmsEncode::NewL( iFs );

   126     iDecoder = CMmsDecode::NewL( iFs );

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

   128     // always allocate the amount we need

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

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

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

   132     // observe backup/restore event ends

   133     iBackupStart = EFalse;

   134     iBackupEnd = EFalse;

   135     }

   136 

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

   138 // CMmsBaseOperation::NewL

   139 // Two-phased constructor.

   140 // -----------------------------------------------------------------------------

   141 //

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

   143     {

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

   145     

   146     CleanupStack::PushL( self );

   147     self->ConstructL( aMmsSettings );

   148     CleanupStack::Pop( self );

   149 

   150     return self;

   151     }

   152 

   153     

   154 // Destructor

   155 CMmsBaseOperation::~CMmsBaseOperation()

   156     {

   157     // derived class must cancel.

   158 	Cancel();		// framework requirement

   159     // iSelection, iServerEntry, and iMmsSettings

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

   161 

   162 // start of ROAMING CHECK handling

   163     delete iPhone;

   164 // end ROAMING CHECK handling

   165     if ( iRemoteParties )

   166         {

   167         iRemoteParties->Reset();

   168         }

   169     delete iRemoteParties;

   170     delete iEncodeBuffer;

   171     delete iFailed;

   172     delete iSuccessful;

   173     delete iEntryWrapper;

   174     delete iUri;

   175     delete iResponse;

   176     delete iEncoder;

   177     delete iDecoder;

   178     delete iMmsLog;

   179     delete iLogEvent;

   180     delete iLogViewEvent;

   181     delete iLogClient;

   182     delete iMmsSession;

   183 

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

   185     delete iConnectionInitiator;

   186     delete iIAPArray;

   187     iConnection.Close();

   188     iSocketServ.Close();

   189 

   190     }

   191 

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

   193 // CMmsBaseOperation::NetworkOperationsAllowed()

   194 //

   195 // ---------------------------------------------------------

   196 //

   197 TBool CMmsBaseOperation::NetworkOperationsAllowed()

   198     {

   199     TBool networkAllowed = ETrue; // optimist

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

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

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

   203     

   204     CRepository* repository = NULL;

   205     TInt error = KErrNone;

   206     TInt value = ECoreAppUIsNetworkConnectionAllowed;

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

   208     if( error == KErrNone )

   209         {

   210         repository->Get( KCoreAppUIsNetworkConnectionAllowed, value );

   211         delete repository;

   212         repository = NULL;

   213         if ( value == ECoreAppUIsNetworkConnectionNotAllowed )

   214             {

   215             networkAllowed = EFalse;

   216             }

   217         }

   218 

   219     return networkAllowed;

   220     }

   221 

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

   223 // CMmsBaseOperation::AllocateTID

   224 //

   225 // ---------------------------------------------------------

   226 //

   227 TInt64 CMmsBaseOperation::AllocateTID()

   228     {

   229     TTime currentTime;

   230     currentTime.UniversalTime();

   231     return currentTime.Int64();

   232     }

   233 

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

   235 // CMmsBaseOperation::StartL

   236 //

   237 // ---------------------------------------------------------

   238 //

   239 void CMmsBaseOperation::StartL(

   240     CMsvEntrySelection& aSelection,

   241     CMsvServerEntry& aServerEntry,

   242     TMsvId aService,

   243     TRequestStatus& aStatus )

   244     {

   245 

   246 #ifndef _NO_MMSS_LOGGING_

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

   248 #endif

   249 

   250     InitializeL( aSelection, aServerEntry, aService );

   251 

   252     if ( iCurrentMessageNo < 1 )

   253         {

   254         // nothing to send. Give up immediately

   255         aStatus = KRequestPending;

   256         TRequestStatus* status = &aStatus;

   257         User::RequestComplete( status, KErrNotFound );

   258         return;

   259         }

   260 

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

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

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

   264     // the probability of the connection being broken.

   265 

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

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

   268 

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

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

   271     Queue( aStatus );

   272     FallThrough();

   273     }

   274     

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

   276 // CMmsBaseOperation::ContainsClosedContent

   277 //

   278 // ---------------------------------------------------------

   279 //

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

   281     {

   282     RApaLsSession apaLsSession;

   283     TInt err = apaLsSession.Connect();

   284     

   285     if ( err != KErrNone )

   286         {

   287         return err;

   288         }

   289     CleanupClosePushL( apaLsSession );

   290     

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

   292         

   293     TDataRecognitionResult* dataType = new( ELeave )TDataRecognitionResult;

   294     CleanupStack::PushL( dataType );

   295         

   296     CMsvStore* store = aServerEntry.ReadStoreL();

   297     CleanupStack::PushL( store );

   298         

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

   300     

   301     TInt attaCount = attachMan.AttachmentCount();

   302         

   303     TInt i = 0;

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

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

   306         {

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

   308         RFile file;

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

   310         delete attaInfo;

   311         attaInfo = NULL;

   312         

   313         if ( err == KErrNone )

   314             {

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

   316             CleanupClosePushL( file );

   317         

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

   319 #ifndef _NO_MMSS_LOGGING_

   320             if ( err != KErrNone )

   321                 {

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

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

   324                 // is not recognized

   325                 err = KErrNotSupported;

   326                 }

   327             else

   328                 {

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

   330                 TPtrC dummy;

   331                 TPtr ptr = buf16->Des();

   332                 file.Name( ptr );

   333                 // we cannot log indefinitely long strings.

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

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

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

   337                 CleanupStack::PopAndDestroy( buf16 );

   338 

   339                 TBuf<KMaxDataTypeLength> buffer;

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

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

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

   343                     {

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

   345                     }

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

   347                     {

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

   349                     }

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

   351                     {

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

   353                     }

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

   355                     {

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

   357                     }

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

   359                     {

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

   361                     }

   362                 else

   363                     {

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

   365                     }

   366                 }

   367 #endif

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

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

   370                 {

   371                 TInt pos = 0;

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

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

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

   375                     !( prot & EFileProtSuperDistributable ) )

   376                     {

   377                     err = KMmsErrorProtectedContent;

   378                     }

   379                 }

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

   381             }

   382 #ifndef _NO_MMSS_LOGGING_

   383         else

   384             {

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

   386             }

   387 #endif

   388         }

   389 

   390     CleanupStack::PopAndDestroy( store );

   391     CleanupStack::PopAndDestroy( dataType );

   392     CleanupStack::PopAndDestroy( fileProt );

   393         

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

   395     

   396     if ( err == KErrNotSupported )

   397         {

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

   399         err = KErrNone;

   400         }

   401     

   402     return err;

   403     }

   404 

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

   406 // CMmsBaseOperation::HandleBackupOperationEventL

   407 //

   408 // ---------------------------------------------------------

   409 //

   410 void CMmsBaseOperation::HandleBackupOperationEventL(

   411     const TBackupOperationAttributes& aBackupOperationAttributes )

   412     {

   413     switch ( aBackupOperationAttributes.iOperation )

   414         {

   415         case EStart:

   416             iBackupStart = ETrue;

   417             iBackupEnd = EFalse;

   418 #ifndef _NO_MMSS_LOGGING_

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

   420 #endif

   421             break;

   422         case EEnd:

   423         case EAbort:

   424             iBackupStart = EFalse;

   425             if ( iHaveTimer )

   426                 {

   427                 iTimer.Cancel();

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

   429                 iBackupEnd = ETrue;

   430                 // do not do it twice

   431                 iDoNotWaitForBackupEnd = ETrue;

   432                 iMustWait = ETrue;

   433                 }

   434 #ifndef _NO_MMSS_LOGGING_

   435             if ( aBackupOperationAttributes.iOperation == EEnd )

   436                 {

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

   438                 }

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

   440                 {

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

   442                 }

   443 #endif

   444             break;

   445         default:

   446             break;

   447         }

   448     }

   449 

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

   451 // CMmsBaseOperation::RunL

   452 //

   453 // ---------------------------------------------------------

   454 //

   455 void CMmsBaseOperation::RunL()

   456     {

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

   458     // asynch step as required.

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

   460     // without queuing another cycle.

   461 

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

   463     // completion to the client.

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

   465     // or the state cycle is complete

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

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

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

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

   470 

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

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

   473     // comes back to us in iStatus.

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

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

   476     // error value set by an asynchronous operation.

   477 #ifndef _NO_MMSS_LOGGING_

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

   479         iStatus.Int(), iError );

   480 #endif

   481     TInt status=iStatus.Int();

   482 

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

   484         {

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

   486         status = KErrNone;

   487         }

   488 

   489     // wait for 5 seconds after backup end

   490     if ( iMustWait )

   491         {

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

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

   494         // We must rely on iMustWait.

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

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

   497         iMustWait = EFalse;

   498         iTimer.After( iStatus, KMmsServerReadyWait );

   499         SetActive();

   500         return;

   501         }

   502 

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

   504     if ( iHaveTimer )

   505         {

   506         iTimer.Cancel();

   507         iTimer.Close();

   508         iHaveTimer = EFalse;

   509         iDoNotWaitForBackupEnd = ETrue;

   510         iBackupEnd = EFalse;

   511         }

   512 

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

   514         status >= (TInt) KMsvIndexRestore &&

   515         !iDoNotWaitForBackupEnd )

   516         {

   517 #ifndef _NO_MMSS_LOGGING_

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

   519 #endif

   520         iState = EMmsOperationWaitingForBackupEnd;

   521         // This will take us back to RunL

   522         WaitForBackupEnd();

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

   524         if ( iError == status )

   525             {

   526             iError = KErrNone;

   527             }

   528         return;

   529         }

   530         

   531     if ( iState == EMmsOperationCheckingRoaming )

   532         {

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

   534         iRegistrationStatus = status;

   535         delete iPhone;

   536         iPhone = NULL;

   537         if ( status > 0 )

   538             {

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

   540             // it must not be set into iError

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

   542             // be propagated.

   543             status = 0;

   544             }

   545         }

   546 

   547     // Don't override old error.

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

   549     // it must be handled separately.

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

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

   552     if ( iError == KErrNone &&

   553         iState != EMmsOperationConnectingToIAP &&

   554         iState != EMmsOperationLogging)

   555         {

   556         iError = status;

   557         }

   558 

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

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

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

   562     // what cleanup work must be done.

   563     // Only cancel can exit.

   564     if ( status != KErrCancel )

   565         {

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

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

   568         // in next step.

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

   570         // must not requeue in error situations

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

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

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

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

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

   576         // or the system has crashed)

   577 #ifndef _NO_MMSS_LOGGING_

   578         if ( error != KErrNone )

   579             {

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

   581                 error );

   582             if ( IsActive() )

   583                 {

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

   585                 }

   586             }

   587 #endif

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

   589         if ( IsActive() ) // requeued

   590             {

   591             return;

   592             }

   593         status=error;

   594         if ( error == KErrNone )

   595             {

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

   597             status = iError;

   598             }

   599         }

   600     

   601     Complete( status );

   602     }

   603 

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

   605 // CMmsBaseOperation::DoRunL

   606 //

   607 // ---------------------------------------------------------

   608 //

   609 void CMmsBaseOperation::DoRunL()

   610     {

   611 

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

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

   614 

   615     if ( iState != EMmsOperationFinalizing )

   616         {

   617         SelectNextState();

   618         // If appropriate, ChangeState makes us active again

   619         ChangeStateL();

   620         }

   621     else

   622         {

   623         iState = EMmsOperationIdle;

   624         iStatus = iError;

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

   626         // RunL completes.

   627         }

   628     }

   629 

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

   631 // CMmsBaseOperation::DoComplete

   632 //

   633 // ---------------------------------------------------------

   634 //

   635 void CMmsBaseOperation::DoComplete( TInt& aError )

   636     {

   637 

   638 #ifndef _NO_MMSS_LOGGING_

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

   640 #endif

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

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

   643 

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

   645 

   646     UnSetSendMask( *iFailed, aError );

   647 

   648     }

   649 

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

   651 // CMmsBaseOperation::DoCancel

   652 //

   653 // ---------------------------------------------------------

   654 //

   655 void CMmsBaseOperation::DoCancel()

   656     {

   657 #ifndef _NO_MMSS_LOGGING_

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

   659 #endif

   660     // cancel anything that is still active

   661 

   662     if ( iPhone )

   663         {

   664         iPhone->Cancel();

   665         }

   666     if ( iDecoder )

   667         {

   668         iDecoder->Cancel();

   669         }

   670     if ( iEncoder )

   671         {

   672         iEncoder->Cancel();

   673         }

   674     if ( iConnectionInitiator )

   675         {

   676         iConnectionInitiator->Cancel();

   677         }

   678     if ( iMmsSession )

   679         {

   680         iMmsSession->Cancel();

   681         }

   682     if ( iHaveTimer )

   683         {

   684         iTimer.Cancel();

   685         iTimer.Close();

   686         iHaveTimer = EFalse;

   687         }

   688 

   689     CMsgActive::DoCancel();

   690     if ( iError == KErrNone )

   691         {

   692         iError = KErrCancel;

   693         }

   694 

   695     }

   696 

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

   698 // CMmsBaseOperation::SelectNextState

   699 //

   700 // ---------------------------------------------------------

   701 //

   702 void CMmsBaseOperation::SelectNextState()

   703     {

   704 

   705     // If appropiate, the functions called within the switch statement

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

   707     // will complete

   708 

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

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

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

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

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

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

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

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

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

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

   719 

   720     switch ( iState )

   721         {

   722         case EMmsOperationIdle:

   723             iState = EMmsOperationCheckingRoaming;

   724             break;

   725         case EMmsOperationCheckingRoaming:

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

   727             // roaming state dependent modes needed by the operation

   728             GetRoamingState();

   729             iState = EMmsOperationEncodingPDU;

   730             break;

   731         case EMmsOperationEncodingPDU:

   732             if ( iConnected )

   733                 {

   734                 iState = EMmsOperationSubmittingTransaction;

   735                 }

   736             else

   737                 {

   738                 iState = EMmsOperationConnectingToIAP;

   739                 }

   740             iCriticalState = EMmsOperationCreatingEntry;

   741             break;

   742         case EMmsOperationConnectingToIAP:

   743             CheckConnectionState();

   744             if ( iConnected )

   745                 {

   746                 iState = EMmsOperationInitializingSession;

   747                 }

   748             else

   749                 {

   750                 // if could not connect, give up

   751                 iState = EMmsOperationUpdatingEntryStatus; 

   752                 }

   753             break;

   754         case EMmsOperationInitializingSession:

   755             iState = EMmsOperationSubmittingTransaction;

   756             break;

   757         case EMmsOperationSubmittingTransaction:

   758             iState = EMmsOperationCreatingEntry;

   759             iCriticalState = EMmsOperationCreatingEntry;

   760             break;

   761         case EMmsOperationCreatingEntry:

   762             iState = EMmsOperationDecodingResponse;

   763             break;

   764         case EMmsOperationDecodingResponse:

   765             iState = EMmsOperationStoringResponseData;

   766             iCriticalState = EMmsOperationStoringResponseData;

   767             break;

   768         case EMmsOperationStoringResponseData:

   769             iState = EMmsOperationEncodingAck;

   770             iCriticalState = EMmsOperationUpdatingEntryStatus;

   771             break;

   772         case EMmsOperationEncodingAck:

   773             iState = EMmsOperationSendingAck;

   774             break;

   775         case EMmsOperationSendingAck:

   776             iState = EMmsOperationUpdatingEntryStatus;

   777             break;

   778         case EMmsOperationUpdatingEntryStatus:

   779             iState = EMmsOperationLogging;

   780             iCriticalState = EMmsOperationMovingEntry;

   781             break;

   782         case EMmsOperationLogging:

   783             iState = EMmsOperationMovingEntry;

   784             break;

   785         case EMmsOperationMovingEntry:

   786             iCurrentMessageNo--;

   787             if ( iCurrentMessageNo > 0 )

   788                 {

   789                 iState = EMmsOperationEncodingPDU;

   790                 iCriticalState = EMmsOperationEncodingPDU;

   791                 }

   792             else

   793                 {

   794                 iState = EMmsOperationFinalizing;

   795                 iCriticalState = EMmsOperationFinalizing;

   796                 }

   797             break;

   798         case EMmsOperationFinalizing:

   799             // no more states

   800             break;

   801         case EMmsOperationWaitingForBackupEnd:

   802             // return to failure point

   803             iState = iCriticalState;

   804             break;

   805         default:

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

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

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

   809             // that there is nothing to be done

   810             // Change state will terminate the loop.

   811 #ifndef _NO_MMSS_LOGGING_

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

   813 #endif

   814             break;

   815         }

   816     }

   817 

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

   819 // CMmsBaseOperation::ChangeStateL

   820 //

   821 // ---------------------------------------------------------

   822 //

   823 void CMmsBaseOperation::ChangeStateL()

   824     {

   825     switch ( iState )

   826         {

   827         case EMmsOperationCheckingRoaming:

   828             RoamingCheck();

   829             break;

   830         case EMmsOperationEncodingPDU:

   831             EncodePDUL();

   832             break;

   833         case EMmsOperationConnectingToIAP:

   834             ConnectToIAPL();

   835             break;

   836         case EMmsOperationInitializingSession:

   837             InitializeSessionL();

   838             break;

   839         case EMmsOperationSubmittingTransaction:

   840             SubmitTransactionL();

   841             break;

   842         case EMmsOperationCreatingEntry:

   843             CreateEntryL();

   844             break;

   845         case EMmsOperationDecodingResponse:

   846             DecodeResponseL();

   847             break;

   848         case EMmsOperationStoringResponseData:

   849             StoreResponseL();

   850             break;

   851         case EMmsOperationEncodingAck:

   852             EncodeAckL();

   853             break;

   854         case EMmsOperationSendingAck:

   855             SendAckL();

   856             break;

   857         case EMmsOperationUpdatingEntryStatus:

   858             UpdateEntryStatusL();

   859             break;

   860         case EMmsOperationLogging:

   861             LogL();

   862             break;

   863         case EMmsOperationMovingEntry:

   864             MoveEntryL();

   865             break;

   866         case EMmsOperationFinalizing:

   867             FinalizeL();

   868             break;

   869         case EMmsOperationWaitingForBackupEnd:

   870             WaitForBackupEnd();

   871             break;

   872         case EMmsOperationIdle:

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

   874             break;

   875         default:

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

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

   878             // cycle completes.

   879 #ifndef _NO_MMSS_LOGGING_

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

   881 #endif

   882             iError = KErrUnknown;

   883             iStatus = iError;

   884             break;

   885         }

   886     }

   887 

   888 

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

   890 // CMmsBaseOperation::FallThrough

   891 //

   892 // ---------------------------------------------------------

   893 //

   894 void CMmsBaseOperation::FallThrough()

   895     {

   896     TRequestStatus* status = &iStatus;

   897     iStatus = KRequestPending;

   898     SetActive();

   899     User::RequestComplete( status, iError );

   900     }

   901 

   902 

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

   904 // CMmsBaseOperation::InitializeL

   905 //

   906 // ---------------------------------------------------------

   907 //

   908 void CMmsBaseOperation::InitializeL(

   909     CMsvEntrySelection& aSelection,

   910     CMsvServerEntry& aServerEntry,

   911     TMsvId aService )

   912     {

   913 

   914 #ifndef _NO_MMSS_LOGGING_

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

   916 #endif

   917 

   918     iSelection = &aSelection;

   919     iServerEntry = &aServerEntry;

   920     iService = aService;

   921 

   922     iDoNotWaitForBackupEnd = EFalse;

   923     iCriticalState = EMmsOperationEncodingPDU;

   924 

   925     delete iEntryWrapper;

   926     iEntryWrapper = NULL;

   927     iEntryWrapper = CMmsServerEntry::NewL(

   928         iFs,

   929         aServerEntry,

   930         iService );

   931 

   932     iFailed->Reset();

   933     iSuccessful->Reset();

   934     iResponse->Reset();

   935 

   936     iCurrentMessageNo = iSelection->Count();

   937     iError = KErrNone;

   938 

   939     // clean these in case the class is reused

   940     delete iUri;

   941     iUri = NULL;

   942     delete iIAPArray;

   943     iIAPArray = NULL;

   944     iConnectionIndex = 0;

   945     iRegistrationStatus = 0; // hope for the best

   946 

   947     // Initialize everything into the failed list.

   948     // Very pessimistic indeed.

   949 

   950     if ( iCurrentMessageNo > 0 )

   951         {

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

   953         iSuccessful->SetReserveL( iCurrentMessageNo );

   954         }

   955 

   956     SetSendMask( *iFailed );

   957     

   958     //

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

   960     //

   961     if ( iMmsSettings->LocalMode() )

   962         {

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

   964         }

   965     }

   966 

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

   968 // CMmsBaseOperation::EncodePDUL

   969 //

   970 // ---------------------------------------------------------

   971 //

   972 void CMmsBaseOperation::EncodePDUL()

   973     {

   974     // This state is quite variable.

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

   976     // no common implementation available.

   977 #ifndef _NO_MMSS_LOGGING_

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

   979 #endif

   980 

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

   982     FallThrough();

   983 

   984     }

   985 

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

   987 // CMmsBaseOperation::ConnectToIAPL

   988 //

   989 // ---------------------------------------------------------

   990 //

   991 void CMmsBaseOperation::ConnectToIAPL()

   992     {

   993 

   994 #ifndef _NO_MMSS_LOGGING_

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

   996 #endif

   997 

   998     if ( iError != KErrNone )

   999         {

  1000         FallThrough();

  1001         return;

  1002         }

  1003 

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

  1005     TRequestStatus* status = &iStatus;

  1006 

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

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

  1009     if ( !NetworkOperationsAllowed() )

  1010         {

  1011 #ifdef __WINS__

  1012         iStatus = KRequestPending;

  1013         SetActive();

  1014         User::RequestComplete( status, KMmsErrorOfflineMode );

  1015         return;

  1016 #else

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

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

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

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

  1021         if ( !iMmsSettings->LocalMode() )

  1022             {

  1023             iStatus = KRequestPending;

  1024             SetActive();

  1025             User::RequestComplete( status, KMmsErrorOfflineMode );

  1026             return;

  1027             }

  1028 #endif

  1029         }

  1030 

  1031     // Use WAP AP from Comms database table.

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

  1033     TInt count = iMmsSettings->AccessPointCount();

  1034     if( !iMmsSettings->LocalMode() )

  1035         {

  1036         if ( count < 1 )

  1037             {

  1038             User::Leave( KMmsErrorNoWAPAccessPoint );

  1039             }

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

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

  1042             {

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

  1044             }

  1045 

  1046         iConnectionInitiator = CMmsConnectionInitiator::NewL();

  1047         // CMmsConnInit sets our status to "KRequestPending"

  1048         iConnectionInitiator->ConnectL(

  1049             iConnection,

  1050 			*iIAPArray,	

  1051 			iStatus );

  1052 

  1053         SetActive();

  1054         }

  1055     else

  1056         {

  1057         // local mode has no real wap access point

  1058         iStatus = KRequestPending;

  1059         SetActive();

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

  1061         // preferred access point)

  1062         User::RequestComplete( status, 1 );

  1063         }

  1064     }

  1065 

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

  1067 // CMmsBaseOperation::InitializeSessionL

  1068 //

  1069 // ---------------------------------------------------------

  1070 //

  1071 void CMmsBaseOperation::InitializeSessionL()

  1072     {

  1073 

  1074 #ifndef _NO_MMSS_LOGGING_

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

  1076 #endif

  1077 

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

  1079         {

  1080         FallThrough();

  1081         return;

  1082         }

  1083 

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

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

  1086     delete iUri;

  1087     iUri = NULL;

  1088     TUint32 iap = 0;

  1089     TBool proxyUsed = EFalse;

  1090     HBufC8* proxyAddress = NULL;

  1091     HBufC* uri = NULL;

  1092 

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

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

  1095     CMmsConnectionInitiator::GetParametersL( 

  1096         iIAPArray->At( iConnectionIndex - 1 ),

  1097         iap,

  1098         uri, 

  1099         proxyUsed,

  1100         proxyAddress

  1101         );

  1102 

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

  1104     iUri = uri;

  1105     uri = NULL;

  1106 

  1107     CleanupStack::PushL( proxyAddress );

  1108     

  1109     iMmsSession->OpenL(

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

  1111         proxyUsed,

  1112         iMmsSettings->MaximumReceiveSize(),

  1113         iMmsSettings->MaximumSendSize(),

  1114         iStatus );

  1115 

  1116     CleanupStack::PopAndDestroy( proxyAddress );

  1117     SetActive();

  1118 

  1119     }

  1120 

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

  1122 // CMmsBaseOperation::SubmitTransactionL

  1123 //

  1124 // ---------------------------------------------------------

  1125 //

  1126 void CMmsBaseOperation::SubmitTransactionL()

  1127     {

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

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

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

  1131     // and not HTTP POST like other operations.

  1132 

  1133 #ifndef _NO_MMSS_LOGGING_

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