/*

* Copyright (c) 2005 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:   CXcapHttpOperation

*

*/

#include <XdmErrors.h>

#include <escapeutils.h>

#include "XcapDocument.h"

#include "XcapProtocol.h"

#include "XcapAppUsage.h"

#include "XcapUriParser.h"

#include "XdmXmlParser.h"

#include "XcapHttpRequest.h"

#include "XdmNodeAttribute.h"

#include "XcapEngineDefines.h"

#include "XcapHttpOperation.h"

#include "XcapHttpContSupplier.h"

#include "XcapOperationFactory.h"

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

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

// might leave.

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

//

CXcapHttpOperation::CXcapHttpOperation( const CXdmDocument& aTargetDoc,

                                        CXcapDocumentNode* aDocumentSubset,

                                        CXcapOperationFactory& aOperationFactory ) :

                                        CActive( EPriorityStandard ),

                                        iDocumentSubset( aDocumentSubset ),

                                        iTargetDoc( ( CXcapDocument& )aTargetDoc ),

                                        iOperationFactory( aOperationFactory ) 

    {

    }

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

// CXcapHttpOperation::BaseConstructL

//

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

//

void CXcapHttpOperation::BaseConstructL()

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "-> CXcapHttpOperation::BaseConstructL" ) ); 

    #endif

    iXmlParser = &iTargetDoc.Protocol().Parser();

    iUriParser = CXcapUriParser::NewL( iTargetDoc, iOperationFactory );

    #ifdef _DEBUG

        TPtrC8 contType( iTargetDoc.ApplicationUsage().ContentType() );

        iOperationFactory.WriteToLog( _L8( " Content-Type: %S" ), &contType ); 

    #endif

    CActiveScheduler::Add( this );

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "<- CXcapHttpOperation::BaseConstructL" ) ); 

    #endif

    }

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

// Destructor

//

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

//

CXcapHttpOperation::~CXcapHttpOperation()

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapHttpOperation::~CXcapHttpOperation()" ) );  

    #endif

    delete iUriParser;

    iRequestQueue.ResetAndDestroy();

    }

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

// CXcapOperationBase::IsCompleted

//

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

//

TBool CXcapHttpOperation::IsCompleted() const

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapOperationBase::IsCompleted()" ) );  

    #endif

    return iCompleted;

    }

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

// CXcapOperationBase::CompletionData

//

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

//

const TXdmCompletionData& CXcapHttpOperation::CompletionData() const

    {

    return *iRequestData;

    }

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

// CXcapOperationBase::CompletionData

//

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

//

CXdmDocumentNode* CXcapHttpOperation::TargetNode() const

    {

    return iDocumentSubset;

    }

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

// CXcapOperationBase::CompletionData

//

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

//

void CXcapHttpOperation::Destroy()

    {

    delete this;

    }

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

// CXcapHttpOperation::Result

//

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

//

TInt CXcapHttpOperation::Result() const

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapHttpOperation::Result()" ) );  

    #endif

    return iRequestData != NULL ? iRequestData->iHttpStatus : KErrUnknown;

    }

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

// CXcapHttpOperation::ExecuteL

//

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

//

void CXcapHttpOperation::ExecuteL( TRequestStatus& aStatus, TUint aOptions )

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapHttpOperation::ExecuteL( &status )" ) );  

    #endif

    iOptionFlags = aOptions;

    iClientStatus = &aStatus;

    aStatus = KRequestPending;

    if( !IsActive() )

        {

        iActiveRequest = iRequestQueue[iCurrentIndex];

        TRAPD( error, ExecuteL() );

        if( error == KErrNone )

            {

            if( StartOperationL() )

                SetActive();

            else

                {

                iFailureData.iCompletion = KXcapErrorNetworkNotAvailabe;

                User::RequestComplete( iClientStatus, KXcapErrorNetworkNotAvailabe );

                iRequestData = &iFailureData;

                }      

            }

        else

            {

            #ifdef _DEBUG

                iOperationFactory.WriteToLog( _L8( " Execution failed with %d" ), error );  

            #endif

            iFailureData.iCompletion = error;

            User::RequestComplete( iClientStatus, error );

            iRequestData = &iFailureData;

            }

        }

    else  //This is a re-run of a previously failed request

        {

        if( !StartOperationL() )

            {

            #ifdef _DEBUG

                iOperationFactory.WriteToLog( _L8( " Execution succeeded, network not ready" ) );  

            #endif

            User::RequestComplete( iClientStatus, KXcapErrorNetworkNotAvailabe );

            }

        }  

    }

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

// CXcapHttpOperation::ExecuteL

//       

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

//

void CXcapHttpOperation::ExecuteL( CXcapHttpRequest* aHttpRequest,

                                   CXdmDocumentNode* aDocumentNode )

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapAddition::ExecuteL()" ) );  

    #endif

    CXdmDocumentNode* node = aDocumentNode == NULL ?

                             iTargetDoc.DocumentRoot() : aDocumentNode;

    __ASSERT_ALWAYS( node != NULL, User::Panic( _L( "CXcapAddition" ), 1 ) );

    User::LeaveIfError( FormatModRequestL( node ) );

    TRAPD( error, iUriParser->ParseL( aHttpRequest->RequestUriL() ) );

    if( error == KErrNone )

        {

        TPtrC8 uri = iUriParser->DesC8();

        HBufC8* escape = CXcapHttpOperation::EscapeLC( uri );

        aHttpRequest->UpdateRequestUriL( escape->Des() );

        CleanupStack::PopAndDestroy();  //escape

        }

    }

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

// CXcapHttpOperation::StartOperationL

//

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

//

TBool CXcapHttpOperation::StartOperationL()

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapHttpOperation::StartOperationL()" ) );  

    #endif

    if( iTargetDoc.Protocol().IsNetworkAvailable() )

        {

        #ifdef _DEBUG

            iOperationFactory.WriteToLog( _L8( " All set, dispatch request to transport" ) );  

        #endif

        if( iOptionFlags & KUseIntendedIdentity )

            {

            TPtrC8 identity( iTargetDoc.Protocol().PublicID() );

            #ifdef _DEBUG

                iOperationFactory.WriteToLog( _L8( " Early-IMS set, add X-3GPP-Intended-Identity header" ) );

                iOperationFactory.WriteToLog( _L8( "  Public ID: %S" ), &identity );  

            #endif

            iActiveRequest->SetHeaderL( KHttpHeaderIntIdentity, identity );

            }

        iActiveRequest->DispatchRequestL( iStatus );

        return ETrue;

        }

    else return EFalse;

    }

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

// CXcapHttpOperation::RunL

//

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

//

void CXcapHttpOperation::RunL()

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( 

        "CXcapHttpOperation::RunL() - Status: %d" ), iStatus.Int() );  

    #endif

    TInt count = iRequestQueue.Count();

    iRequestData = iActiveRequest->ResponseData();

    __ASSERT_DEBUG( iRequestData != NULL, User::Panic( _L( "CXcapHttpOperation" ), 1 ) );

    TRAPD( error, iStatus != KErrNone ? OperationFailedL() : OperationCompleteL() );

    if( error == KErrNone && !iCompleted )

        SetActive();

    else

        {

        #ifdef _DEBUG

            iOperationFactory.WriteToLog( _L8( 

                "  ** Operation completed - Result: %d  Error: %d **" ), iResult, error );  

        #endif

        iCurrentIndex = 0;

        iResult = error < KErrNone ? error : iResult;

        iRequestData->iCompletion = iResult;

        User::RequestComplete( iClientStatus, iResult );

        }

    }

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

// CXcapRetrieval::CancelOperation

//

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

//

void CXcapHttpOperation::CancelOperation()

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapHttpOperation::CancelOperation()" ) );  

    #endif

    if( IsActive() )

        {

        #ifdef _DEBUG

            iOperationFactory.WriteToLog( _L8( "Active, cancel HTTP request" ) );  

        #endif

        Cancel();

        iRequestData = &iFailureData;

        iFailureData.iCompletion = KErrCancel;

        User::RequestComplete( iClientStatus, KErrCancel );

        }

    }

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

// CXcapHttpOperation::CancelOperation

//

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

//

void CXcapHttpOperation::DoCancel()

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapHttpOperation::DoCancel()" ) );  

    #endif

    iRequestQueue[iCurrentIndex]->CancelRequest();   

    }

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

// CXcapHttpOperation::Descriptor

//

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

//

TPtrC8 CXcapHttpOperation::Descriptor( HBufC8* aBuffer )

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapHttpOperation::Descriptor()" ) );  

    #endif

    if( aBuffer != NULL )

        {

        TPtrC8 descriptor( aBuffer->Des() );

        return descriptor.Length() > 0 ? descriptor : TPtrC8();

        }

    else

        {

        #ifdef _DEBUG

            iOperationFactory.WriteToLog( _L8( " Buffer is NULL, return empty descriptor" ) );  

        #endif

        return TPtrC8();

        }

    }

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

// CXcapHttpOperation::Transport

//

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

//

CXcapHttpTransport& CXcapHttpOperation::Transport() const

    {

    return iTargetDoc.Protocol().Transport();

    }

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

// CXcapHttpOperation::FormatModRequestL

//

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

//

TInt CXcapHttpOperation::FormatModRequestL( const CXdmDocumentNode* aDocumentNode )

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapHttpOperation::FormatModRequestL()" ) );  

    #endif

    HBufC8* body = NULL;

    TInt error = KErrNone;

    CXcapAppUsage& usage = iTargetDoc.ApplicationUsage();

    CXcapHttpContSupplier* request = ( CXcapHttpContSupplier* )iActiveRequest;

    switch( iUriParser->NodeType() )

        {

        case EXdmElementAttribute:

            {

            CXdmNodeAttribute* attribute = ( CXdmNodeAttribute* )aDocumentNode;

            body = attribute->EightBitValueLC();

            request->SetRequestBodyL( body->Des() );

            CleanupStack::PopAndDestroy();  //body

            request->SetHeaderL( KHttpHeaderAccept, _L8( "application/xcap-diff+xml" ) );

            request->SetHeaderL( KHttpHeaderContentType, _L8( "application/xcap-att+xml" ) );

            }

            break;

        case EXdmElementNode:

            {

            #ifndef __OVERRIDE_VALIDATION__

                error = usage.Validate( CONST_CAST( CXdmDocumentNode&, *aDocumentNode ), iUriParser, EFalse );

            #endif

            if( error == KErrNone )

                {

                #ifdef _DEBUG

                    iOperationFactory.WriteToLog( _L8( " Validation of a partial document OK" ) );  

                #endif

                body = iXmlParser->FormatToXmlLC( EFalse, &iTargetDoc, aDocumentNode );

                request->SetRequestBodyL( body->Des() );

                CleanupStack::PopAndDestroy();  //body

                request->SetHeaderL( KHttpHeaderAccept, _L8( "application/xcap-diff+xml" ) );

                request->SetHeaderL( KHttpHeaderContentType, _L8( "application/xcap-el+xml" ) );

                }

            else

                {

                #ifdef _DEBUG

                    iOperationFactory.WriteToLog( _L8( " Validation failed: %d" ), error );  

                #endif

                }

            }

            break;

        default:

        #ifndef __OVERRIDE_VALIDATION__

            error = usage.Validate( iTargetDoc, ETrue );

        #endif

            if( error == KErrNone )

                {

                #ifdef _DEBUG

                    iOperationFactory.WriteToLog( _L8( " Validation OK" ) );  

                #endif

                body = iXmlParser->FormatToXmlLC( ETrue, &iTargetDoc, aDocumentNode );

                request->SetRequestBodyL( body->Des() );

                CleanupStack::PopAndDestroy();  //body

                }

            else

                {

                #ifdef _DEBUG

                    iOperationFactory.WriteToLog( _L8( " Validation failed: %d" ), error );  

                #endif

                }

            break;

        }

    return error;

    }

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

// CXcapHttpOperation::ReinterpretStatus

// 

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

//

TInt CXcapHttpOperation::ReinterpretStatus( const TInt aHttpStatus ) const

    {

    #ifdef _DEBUG

        iOperationFactory.WriteToLog( _L8( "CXcapHttpOperation::ReinterpretStatus()" ) );  

    #endif

    switch( aHttpStatus )

        {

        case 500:  //Internal Server Error

        case 501:  //Not Implemented

        case 502:  //Bad Gateway

        case 503:  //Service Unavailable

        case 504:  //Gateway Timeout

        case 505:  //HTTP Version Not Supported

        case 405:  //Method Not Allowed

		case 408:  //Request Timeout

		case 410:  //Gone

		case 411:  //Length Required

		case 413:  //Request Entity Too Large

		case 414:  //Request-URI Too Long

		case 415:  //Unsupported Media Type

		case 416:  //Requested Range Not Satisfiable

		case 417:  //Expectation Failed

            return KXcapErrorHttpServer;

        case 400:

            return KXcapErrorHttpBadRequest;

        case 401:

            return KXcapErrorHttpUnauthorised;

        case 403:

            return KXcapErrorHttpForbidden;

        case 404:

            return KXcapErrorHttpNotFound;

        case 409:

            return KXcapErrorHttpConflict;

        case 412:

            return KXcapErrorHttpPrecondFailed;

        default:

            return KErrNone;

        }

    }

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

// CXcapHttpOperation::Escape2LC

// 

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

//

HBufC8* CXcapHttpOperation::Escape2LC( const TDesC& aDescriptor )

    {

    HBufC8* eight = EscapeUtils::ConvertFromUnicodeToUtf8L( aDescriptor );

    CleanupStack::PushL( eight );

    HBufC8* buf = EscapeUtils::EscapeEncodeL( eight->Des(), EscapeUtils::EEscapeNormal );

    CleanupStack::PopAndDestroy();  //eight

    CleanupStack::PushL( buf );

    return buf;

    }

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

// CXcapHttpOperation::EscapeLC

// 

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

//

HBufC8* CXcapHttpOperation::EscapeLC( const TDesC8& aDescriptor )

    {

    CBufFlat* buffer = CBufFlat::NewL( 50 );

    CleanupStack::PushL( buffer );

    TInt bufPos = 0;

    TBuf8<10> format;

    for( TInt i = 0;i < aDescriptor.Length();i++ )

        {

        TUint8 byte = aDescriptor[i];

        if( byte < 0x7F )                 //US-ASCII

            {

            switch( byte )

                {

                case 0x20:                // ' '

                case 0x22:                // '"'

                case 0x3B:                // ';'                 

                case 0x26:                // '&'                  

                case 0x3C:                // '<'                  

                case 0x3E:                // '>'

                case 0x5B:                // '['

                case 0x5D:                // ']'                              

                    format.Append( _L8( "%" ) );

                    format.AppendFormat( _L8( "%x" ), byte );

                    break;               

                default:

                    format.Append( byte );

                    break;

                }

            }

        else

            {

            format.Append( _L8( "%" ) );  //UNICODE

            format.AppendFormat( _L8( "%x" ), byte );

            }

        buffer->InsertL( bufPos, format );

        bufPos = bufPos + format.Length();

        format.Zero();

        }

    HBufC8* ret = HBufC8::NewL( buffer->Size() );

    TPtr8 pointer( ret->Des() );

    buffer->Read( 0, pointer, buffer->Size() );

    CleanupStack::PopAndDestroy();  //buffer

    CleanupStack::PushL( ret );

    return ret;