/*

* Copyright (c) 2002-2006 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:  

*     Class implementing transaction within WAP session

*

*/

// INCLUDE FILES

#include    <uriutils.h>

#include    <httpstringconstants.h>

#include    <uaproffilter_interface.h>

#include    "mmstransaction.h"

#include    "mmsservercommon.h"

#include    "mmsconst.h"

#include    "mmssession.h"

#include    "mmserrors.h"

#include    "MmsServerDebugLogging.h"

#include    "mmscodecdatasupplier.h"

#include    "mmscodecdatasink.h"

// EXTERNAL FUNCTION PROTOTYPES  

extern void gPanic(TMmsPanic aPanic);

// CONSTANTS

const TInt KMmsMaxRetryCount = 4;

// HTTP error ranges

const TInt KMmsHTTP100 = 100; // 1xx informative

const TInt KMmsHTTP200 = 200; //

const TInt KMmsHTTP300 = 300; //

const TInt KMmsHTTP400 = 400; //

const TInt KMmsHTTP500 = 500; //

const TInt KMmsHTTP404 = 404; // Not Found

const TInt KMmsHTTP413 = 413; // Request entity too large

const TInt KMmsReserve = 10000; // extra for buffer

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

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

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

// ---------------------------------------------------------

// CMmsTransaction

// ---------------------------------------------------------

//

CMmsTransaction::CMmsTransaction()

    : CMsgActive ( KMmsActiveObjectPriority ),

    iState ( EMmsIdle ),

    iUri ( NULL ),

    iHTTPSession( NULL ),

    iTimer( NULL ),

    iTransferControl( NULL ),

    iTransactionOpened( EFalse )

    {

    }

// ---------------------------------------------------------

// ConstructL

// ---------------------------------------------------------

//

void CMmsTransaction::ConstructL()

    {

    iTimer = CMmsOperationTimer::NewL();

    CActiveScheduler::Add( this );    

    }

// ---------------------------------------------------------

// NewL

// ---------------------------------------------------------

//

CMmsTransaction* CMmsTransaction::NewL()

    {

    CMmsTransaction* self = new (ELeave) CMmsTransaction();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------

// ~CMmsTransaction

// ---------------------------------------------------------

//

CMmsTransaction::~CMmsTransaction()

    {

    Cancel();

    if ( iTransactionOpened )

        {

        RHTTPHeaders hdr = iTransaction.Request().GetHeaderCollection();

        hdr.RemoveAllFields(); // clean up

        iTransaction.Close();

        }

    delete iUri;

    delete iTimer; 

    }

// ---------------------------------------------------------

// ExecuteL

// ---------------------------------------------------------

//

void CMmsTransaction::ExecuteL( 

    RHTTPSession& aSession,    

    CMmsBearerStatus& aTransferControl,

    const TDesC& aUri,

    const TInt aMethod,

    CBufFlat& aMessageBuffer,

    const TInt aTransactionTimer,

    TInt32 aMaxReceiveSize,

    TInt32 aExpectedReceiveSize,

    MMmsCodecDataSupplier& aDataSupplier,

    MMmsCodecDataSink& aDataSink,

    TRequestStatus& aStatus )

    {

    LOG( _L("CMmsTransaction::ExecuteL") );

    __ASSERT_DEBUG( iState == EMmsIdle, gPanic( EMmsAlreadyBusy ) );

    iError = KErrNone;

    iHTTPSession = &aSession;

    iDataSupplier = &aDataSupplier;

    iDataSink = &aDataSink;

    iMaxReceiveSize = aMaxReceiveSize;

    if( aMethod == HTTP::EGET )

        {

        //

        // Setting adequate receivebuffer size for receive transactions

        //

        TInt32 reserve = KMmsReserve; // fixed reserve for unexpected surplus data

        if ( aExpectedReceiveSize == KMmsChunkedBufferSize )

            {

            // we don't need extra when receiving in chunked mode

            reserve = 0;

            }

        if( ( aExpectedReceiveSize + reserve ) > aMaxReceiveSize )

            {

            iExpectedReceiveSize = aMaxReceiveSize;

            }

        else

            {

            iExpectedReceiveSize = aExpectedReceiveSize + reserve;

            }

        }

    iTransactionOpened = EFalse;

    delete iUri;

    iUri = NULL;

    HBufC* newUri = aUri.AllocL();

    iUri = newUri;    

    iBuffer = &aMessageBuffer;

    iMethod = aMethod;

    iTransactionTimeout = aTransactionTimer;

    iTransferControl = &aTransferControl;

    // clear the flags, because we are reusing the class,

    // we don't create a new instance every time

    iRetryCount = 0;

    iRequestOngoing = EFalse;

    iSuspendOccurred = EFalse;

    iGotBodyData = EFalse;

    iDataChunkNumber = 0; // no data obtained yet

    iCumulativeSize = 0; // received size or sent size, cumulative

    iChunkSize = 0;

    iEvent = THTTPEvent::ESubmit;

    Queue( aStatus );   // aStatus = iStatus = KRequestPending

    //

    // Start transaction timer

    //

    if ( iTimer->IsActive() )

        {

        iTimer->Cancel();

        }

    iTimer->Start( (MMmsTransportObserver*) this, iTransactionTimeout );

    //

    // If bearer is already blocked when starting, execution enters a wait

    //

    if( iTransferControl->IsSuspended() )

        {

        LOG( _L(" - GPRS is Suspended -> waiting for resume before sending") );

        // Transfer cancellation

        iTransferControl->SubscribeNotification( (MMmsTransportObserver*) this );

        // Start needed operations in suspend

        GprsSuspended();

        // someone must set our status to KRequestPending

        iStatus = KRequestPending;

#ifndef _NO_MMSS_LOGGING_

        if ( IsActive() )

            {

            LOG( _L(" - already active") );

            }

#endif  //_NO_MMSS_LOGGING_

        SetActive();

        }

    else // Bearer not blocked, continuing directly

        {

        iStatus = KRequestPending;

        SetActive();    

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        }

    }

// ---------------------------------------------------------

// RunL

// ---------------------------------------------------------

//

void CMmsTransaction::RunL()

    {

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

    // asynch step as required.

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

    // without queuing another cycle.

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

    // completion to the client.

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

    // or the state cycle is complete

    // However, we must keep our cycle going in spite of error(s).

    // The CMmsOperationTimer reports the exceed situation with error

    // This must be handled in CMmsTransaction's DoRunL before returning to

    // client

    // Also the bearer suspend/resume status is informed via error

    // Also handled in CMmsTransaction. 

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

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

    // comes back to us in iStatus.

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

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

    // error value set by an asynchronous operation.

    TInt status = iStatus.Int();

    if ( iError == KErrNone )

        {

        iError = status;

        }

    // Only cancel can exit.

    if ( status != KErrCancel || iError != KErrNone )

        {

        // iError contains the possible error from previous step.

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

        // must not requeue in error situations

        // If we want to continue the loop in spite of error (yes, sir),

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

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

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

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

        // or the system has crashed)

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

        // active means AO has been requeued, just return

        if ( IsActive() )             

            {

            return;

            }

        status = error;

        if ( error == KErrNone )

            {

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

            status = iError;

            }

        }

    LOG2( _L("CMmsTransaction::RunL: Complete with %d"), status );

    Complete( status );

    }

// ---------------------------------------------------------

// DoRunL

// ---------------------------------------------------------

//

void CMmsTransaction::DoRunL()

    {

    //

    // This routine takes the state machine through the states

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

    //

    LOG3( _L("CMmsTransaction::DoRunL status %d, iError %d"), iStatus.Int(), iError );

    // If we got last chunk already, do not cancel, let HTTP complete

    if ( iError != KErrNone && iError != KMmsErrorBearerSuspended )

        {

        if ( iRequestOngoing )

            {

            iTransaction.Cancel();

            iRequestOngoing = EFalse;

            }

        // Error code copied to status code

        iStatus = iError;

        }

    // We continue to next state to finish properly

    SelectNextState();

    // If appropriate, ChangeState makes us active again

    ChangeStateL();

    }

// ---------------------------------------------------------

// SelectNextState

// ---------------------------------------------------------

//

void CMmsTransaction::SelectNextState()

    {

    //

    // The purpose of the switch statements is to cycle through

    // states. These states handle certain task(s) and after

    // completed CMmsTransaction is finished.

    //

    switch ( iState )

        {

        case EMmsIdle:

            // start the loop

            iState = EMmsSendingTransactionRequest;

            break;

        case EMmsSendingTransactionRequest:

            iState = EMmsFinished;            

            break;

        case EMmsFinished:

            // No more states

            iError = KErrUnknown;           

            break;

        default:

            // Illegal state, we should never get here

            iError = KErrUnknown;

            break;

        }  

    }

// ---------------------------------------------------------

// ChangeStateL

// ---------------------------------------------------------

//

void CMmsTransaction::ChangeStateL()

    {

    switch ( iState )

        {

        case EMmsSendingTransactionRequest:

            MakeTransactionL();

            break;

        case EMmsFinished:

            FinishL();

            break;

        default:

            // All other states are illegal

            LOG( _L("CMmsTransaction::ChangeStateL(): ERROR: Illegal state") );

            iError = KErrUnknown;

            break;

        }    

    }

// ---------------------------------------------------------

// MakeTransactionL

// ---------------------------------------------------------

//

void CMmsTransaction::MakeTransactionL()

    {

    LOG( _L("CMmsTransaction::MakeTransactionL") );

    // Useragent has been added to session headers:

    // It should always be present

    HBufC8* uri = HBufC8::NewL( iUri->Length() );

    CleanupStack::PushL( uri );

    uri->Des().Copy( iUri->Des() );

    TUriParser8 uri2;

    uri2.Parse( uri->Des() );

    RStringPool stringPool = iHTTPSession->StringPool();

    iTransaction = iHTTPSession->OpenTransactionL( uri2,

        *this,

        stringPool.StringF( iMethod, RHTTPSession::GetTable() ) );

    iTransactionOpened = ETrue;

    CleanupStack::PopAndDestroy( uri );

    // Set headers. If GET, no content type needed as no content present

    // common accept headers are set as session headers

    // these are done only on the first time. In retry cases, they already exist.

    RHTTPHeaders hdr = iTransaction.Request().GetHeaderCollection();

    // Adding accept headers has been moved to transaction,

    // as automatic filters seemed to override session headers

    // (session headers are not added if transaction headers already exist)

    // NOTE: Currently Accept header contains the following line on purpose:

    // "Accept: */*, application/vnd.wap.mms-message, application/vnd.wap.sic"

    // in order to be compliant with some server vendors.

    // Accept: "*/*"

    SetHeaderL( hdr, HTTP::EAccept, KMmsAny );

    // Accept: "application/vnd.wap.mms-message"

    SetHeaderL( hdr, HTTP::EAccept, KMmsMessageContentType );

    // Accept: "application/vnd.wap.sic"

    SetHeaderL( hdr, HTTP::EAccept, KMmsWapSicContentType );

    // Accept-Language: en

    SetHeaderL( hdr, HTTP::EAcceptLanguage, KHTTPEnglish );

    // Accept-Charset: utf-8

    SetHeaderL( hdr, HTTP::EAcceptCharset, KHTTPUtf8 );

    // end of headers moved from session to transaction

    if( iMethod == HTTP::EPOST )

        {

        // Add contenttype header 

        SetHeaderL( hdr, HTTP::EContentType, KMmsMessageContentType );

        // Give payload supplier for stack in case of http post

        iTransaction.Request().SetBody( *this );

        }

    // Set the 'Host:' header

    SetHostHeaderL( hdr );

    // Set UA headers

    RStringF uaClient = iHTTPSession->StringPool().OpenFStringL( KUserAgentClientId );

    CleanupClosePushL<RStringF>( uaClient );

    iTransaction.PropertySet().SetPropertyL( uaClient, THTTPHdrVal( KUserAgentCliMMS ) );

    CleanupStack::PopAndDestroy( &uaClient );

    // no response headers yet

    iGotResponseHeaders = EFalse; 

    // Perform the actual sending

    iTransaction.SubmitL();

    // Start observer to monitor notifications

    iTransferControl->SubscribeNotification( (MMmsTransportObserver*) this );

    iRequestOngoing = ETrue;

    iStatus = KRequestPending;

    SetActive();

    }

// ---------------------------------------------------------

// FinishL

// ---------------------------------------------------------

//

void CMmsTransaction::FinishL()

    {

    LOG( _L("CMmsTransaction::FinishL") );

    //

    // Cancel timer and observer

    //

    iTransferControl->Cancel();

    //

    // Completion came from own timers

    //

    if( iStatus == KMmsErrorTimeout || iStatus == KMmsErrorSuspendTimeout )

        {

        LOG( _L(" - MmsEngine's timer expired") );

        if( iRequestOngoing )

            {

            iTransaction.Cancel();

            }

        if( iGotBodyData && iLastChunk )

            {

            LOG( _L(" - Data has been received, returning OK") );

            iError = KErrNone;

            }

        else // no body data, emptying 

            {

            iBuffer->Reset();

            }

        return;

        }

    //

    // Pause the timer (later it will be put back on, or cancelled)

    //

    iTimer->Pause();

    //

    // Completion came from HTTP stack

    // go through switch based on event status

    //

    switch ( iEvent.iStatus )

        {

        // Successful case

        case THTTPEvent::ESucceeded:

            {

            iRetryCount = 0;

            iSuspendOccurred = EFalse;

            iError = KErrNone; // successful.

            LOG( _L(" - HTTP status OK") );

            // If there was response data, we've already got it

            break;

            }

        // Failure cases

        case THTTPEvent::EFailed:

            {