/** @file

* Copyright (c) 2005-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:  Declares chunk parsing class.

*

*/

// INCLUDE FILES

#include "upnphttpchunkparser.h"

#include "upnpcons.h"

// CONSTANTS

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

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

// CUpnpHttpChunkParser::NewL

// Two-phased constructor

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

//

CUpnpHttpChunkParser* CUpnpHttpChunkParser::NewL()

	{

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

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

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

// CUpnpHttpChunkParser::~CUpnpHttpChunkParser

// C++ default destructor

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

//

CUpnpHttpChunkParser::~CUpnpHttpChunkParser()

	{

	}

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

// CUpnpHttpChunkParser::CUpnpHttpChunkParser

// C++ default constructor

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

//

CUpnpHttpChunkParser::CUpnpHttpChunkParser()

:iContext(EUnknown),

 iChunkSize(KErrNotFound),

 iError (KErrNone)

	{

	}

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

// CUpnpHttpChunkParser::ConstructL

// Two-phased constructor

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

//

void CUpnpHttpChunkParser::ConstructL()

	{

	}

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

// CUpnpHttpChunkParser::Reset

// Checks if decoding ended

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

//

void CUpnpHttpChunkParser::Reset()

    {

    iContext = EUnknown;

    iError = KErrNone;

    iChunkSize = KErrNotFound;	

    }

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

// CUpnpHttpChunkParser::SetErrorState

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

//

void CUpnpHttpChunkParser::SetErrorState()

    {

    iError = EHttpRequestTimeout;

    iContext = EError;

    }				    

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

// CUpnpHttpChunkParser::Parse

// Decoding the chunked-encoded buffer

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

//

TInt CUpnpHttpChunkParser::Parse(TDes8& aBuffer, TInt& aPos)

    {		

    TBool interrupt = EFalse;

    while(!interrupt)

        {

        switch(iContext)

            {

            case EUnknown:

                iContext = EHeader;

            case EHeader:

                interrupt = ParseHeader(aBuffer,aPos);

                break;

            case ELastChunk:

                interrupt = ParseLastChunk(aBuffer,aPos);

                break;	

            case EBody:

                interrupt = ParseBody(aBuffer,aPos);

                break;

            case EEndChunkBody:

                iContext = EHeader;

                break;

            case EExtension:

                interrupt = ParseExtension(aBuffer,aPos);

                break;

            case ETrailer:

                interrupt = ParseTrailer(aBuffer,aPos);

                break;

            case EError:			

                return iError;

            case EFinish:

                return KErrNone;

            default:

                return KErrUnknown;

            }

        }

    return KErrNone;

    }

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

// CUpnpHttpChunkParser::ParseL

// Decoding the chunked-encoded buffer

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

//

TBool CUpnpHttpChunkParser::ParseBody( TDes8& aBuffer, TInt& aPos )

	{	

    if ( IsEmpty( aBuffer, aPos ) )

        {	    

        return ETrue;

        }

    TPtrC8 pointer( aBuffer.Right( aBuffer.Length() - aPos ) );	

    if ( iBytesAppended + pointer.Length() >= iChunkSize )

        {	

        aPos += ( iChunkSize - iBytesAppended );		

        pointer.Set( aBuffer.Right( aBuffer.Length() - aPos ) );

        TInt lineFeed = pointer.FindF(UpnpString::KLineFeed());		

        //linefeed found

        if ( !lineFeed )

            {			

            aBuffer.Delete( aPos, UpnpString::KLineFeed().Length() );

            iContext = EEndChunkBody;	

            return ( aPos == aBuffer.Length() );

            }

        //linefeed not found, end of buffer	

        else if ( lineFeed == KErrNotFound && 

                ( ( aPos + UpnpString::KLineFeed().Length() ) > aBuffer.Length() )

                )

            {			

            iBytesAppended = iChunkSize; 				

            return ETrue;

            }

        //size doesn't comply with the header value

        iError = KErrGeneral;	

        iContext = EError;	

        return EFalse;	

        }

    else

        {

        iBytesAppended += pointer.Length();

        aPos = aBuffer.Length();

        return ETrue;

        }		

    }

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

// CUpnpHttpChunkParser::ParseL

// Decoding the chunked-encoded buffer

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

//

TBool CUpnpHttpChunkParser::ParseHeader( TDes8& aBuffer, TInt& aPos )

	{

    if ( IsEmpty( aBuffer, aPos ) )

        {	    

        return ETrue;

        }

    iChunkSize = KErrNotFound;

    iBytesAppended = 0;

    TPtrC8 pointer(NULL,0);

    //if '\r\n' exists

    TInt lineFeed = aBuffer.Right( aBuffer.Length() - aPos ).FindF( UpnpString::KLineFeed );

    //if ';' exists

    TInt semiColon = aBuffer.Right( aBuffer.Length() - aPos ).FindF( UpnpString::KSemiColon );

    //semicolon ignored if occurs after the linefeed

    if ( semiColon !=KErrNotFound && lineFeed !=KErrNotFound && lineFeed<semiColon )

        {

        semiColon = KErrNotFound;

        }

    if ( semiColon !=KErrNotFound )

        {		

        pointer.Set(aBuffer.Right( aBuffer.Length() - aPos ).Mid( 0,semiColon ) );		

        }

    else if ( lineFeed !=KErrNotFound )

        {

        pointer.Set( aBuffer.Right( aBuffer.Length() - aPos ).Mid( 0,lineFeed ) );		

        }

    else

        {

        pointer.Set( aBuffer.Right( aBuffer.Length() - aPos ) );		

        }

    TLex8 lex( pointer );	

    //skip white spaces	

    lex.SkipSpace();

    TUint size;

    //neither semicolon nor linefeed found

    if ( lineFeed == KErrNotFound && semiColon == KErrNotFound )

        {

        //remember the num of cut spaces

        TInt len = lex.Offset();

        if ( !lex.Eos() )

            {

            //check the chunk header size for the limit

            TInt error = lex.Val( size, EHex );			

            if ( error!= KErrNone || size > KMaxTInt )	

                {

                //size too big

                iError = ( error ) ? error: EHttpInsufficientStorage;

                iContext = EError;

                return EFalse;

                }			

            }

        aBuffer.Delete( aPos,len );

        return ETrue;

        }

    //get size	

    TInt error = lex.Val( size, EHex );

    if ( error!= KErrNone || size > KMaxTInt )

        {

        //unexpected characters or size too big

        iError = ( error ) ? error: EHttpInsufficientStorage ;

        iContext = EError;

        return EFalse;

        }	

    iChunkSize = size;	

    //skip white spaces	

    lex.SkipSpace();	

    if ( !lex.Eos() )

        {

        //unexpected characters

        iError = KErrGeneral;

        iContext = EError;

        return EFalse;

        }

    if ( lineFeed != KErrNotFound )

        {

        //the whole chunk header is parsed

        aBuffer.Delete( aPos, lineFeed + UpnpString::KLineFeed().Length() );

        //chunk size == 0

        if ( !iChunkSize )

            {        

            iContext = ELastChunk;

            }

        else

            {        

            iContext = EBody;

            }

        return ( aPos == aBuffer.Length() );

        }

    else if ( semiColon != KErrNotFound )

        {

        //extension found, 

        //one character left - possible linefeed

        if ( aPos<aBuffer.Length() )

            {            

            aBuffer.Delete( aPos, aBuffer.Length() - aPos - 1 );		

            }

        iContext = EExtension;

        return ETrue;	

        }

    iError = KErrUnknown;	

    iContext = EError;	

    return EFalse;		    	

    }

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

// CUpnpHttpChunkParser::ParseL

// Decoding the chunked-encoded buffer

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

//

TBool CUpnpHttpChunkParser::ParseExtension( TDes8& aBuffer, TInt& aPos )

    {	

    if ( IsEmpty( aBuffer, aPos ) )

        {	    

        return ETrue;	

        }

    //if '\r\n' exists

    TInt lineFeed = aBuffer.Right( aBuffer.Length() - aPos ).FindF( UpnpString::KLineFeed );

    if ( lineFeed != KErrNotFound )

        {

        aBuffer.Delete( aPos, lineFeed + UpnpString::KLineFeed().Length() );		

        if ( !iChunkSize )

            {

            iContext = ETrailer;

            return EFalse;		

            }

        else

            {

            iContext = EBody;

            return EFalse;

            }		

        }

    else

        {

        //one character left - possible linefeed

        if ( aPos + 1 < aBuffer.Length() )

            {            

            aBuffer.Delete( aPos, aBuffer.Length() - aPos - 1 );

            }

        return ETrue;

        }

    }

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

// CUpnpHttpChunkParser::ParseL

// Decoding the chunked-encoded buffer

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

//

TBool CUpnpHttpChunkParser::ParseLastChunk( TDes8& aBuffer, TInt& aPos )

    {		

    //if empty or only one character present

    if ( (aBuffer.Length() - aPos) < UpnpString::KLineFeedLength )

        {	    

        return ETrue;

        }

    //if '\r\n' exists

    TInt lineFeed = aBuffer.Right( aBuffer.Length() - aPos ).FindF( UpnpString::KLineFeed );

    if ( !lineFeed )

        {

        aBuffer.Delete( aPos, lineFeed + UpnpString::KLineFeed().Length() );		

        iContext = EFinish;

        return ETrue;		

        }

    else

        {

        iContext = ETrailer;

        return EFalse;		

        }		

    }	

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

// CUpnpHttpChunkParser::ParseL

// Decoding the chunked-encoded buffer

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

//

TBool CUpnpHttpChunkParser::ParseTrailer( TDes8& aBuffer, TInt& aPos )

	{		

    if ( IsEmpty( aBuffer, aPos ) )

        {	    

        return ETrue;

        }

    //if double '\r\n' exists

    TInt doublelineFeed = aBuffer.Right( aBuffer.Length() - aPos ).FindF( UpnpString::KDoubleLineFeed );

    if (doublelineFeed != KErrNotFound ) 

        {

        aBuffer.Delete( aPos, doublelineFeed + UpnpString::KDoubleLineFeed().Length() );		

        iContext = EFinish;

        return ETrue;	

        }

    else

        {

        //waiting,3 characters reserved for double linefeed

        if ( aPos + UpnpString::KCRLFCRLength < aBuffer.Length() )

            {            

            aBuffer.Delete( aPos, aBuffer.Length() - aPos - UpnpString::KCRLFCRLength );

            }

        return ETrue;	

        }

    }

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

// CUpnpHttpChunkParser::IsEmpty

// Decoding the chunked-encoded buffer

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

//

TBool CUpnpHttpChunkParser::IsEmpty( TDes8& aBuffer, TInt aPos )

    {

    return ( aPos >= aBuffer.Length() );

    }   

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

// CUpnpHttpChunkParser::IsFinished

// Checks if decoding ended

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

//

TBool CUpnpHttpChunkParser::IsFinished()

    {

    return ( iContext==EFinish );

    }   

// End Of File