/** @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 CUpnpRangeHeaderParser class.

*

*/

#include "upnphttpservertransactioncreator.h"

#include "upnphttpmessage.h"

#include "upnprangeheaderparser.h"

#include "upnphttpservertransaction.h"

#include "upnphttpservertransaction.h"

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

// CUpnpRangeHeaderParser::NewL

// Factory method.

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

//

CUpnpRangeHeaderParser* CUpnpRangeHeaderParser::NewL(

    CUpnpHttpServerTransaction &aTransaction, TInt& aStartPos, TInt& aEndPos )

    {

    CUpnpRangeHeaderParser* self = 

        CUpnpRangeHeaderParser::NewLC( aTransaction, aStartPos, aEndPos );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpRangeHeaderParser::NewLC

// Factory method.

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

//

CUpnpRangeHeaderParser* CUpnpRangeHeaderParser::NewLC(

    CUpnpHttpServerTransaction &aTransaction, TInt& aStartPos, TInt& aEndPos )

    {

    CUpnpRangeHeaderParser* self = 

        new( ELeave ) CUpnpRangeHeaderParser( aTransaction, aStartPos, aEndPos );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CUpnpRangeHeaderParser::CUpnpRangeHeaderParser

// C++ constructor.

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

//

CUpnpRangeHeaderParser::CUpnpRangeHeaderParser(

    CUpnpHttpServerTransaction &aTransaction, TInt& aStartPos, TInt& aEndPos )

    :iTransaction(aTransaction), iStartPos( aStartPos ), iEndPos( aEndPos )

    {

    }

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

// CUpnpRangeHeaderParser::ConstructL

// Two-phased constructor

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

//    

void CUpnpRangeHeaderParser::ConstructL()

    {

    }

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

// CUpnpRangeHeaderParser::~CUpnpRangeHeaderParser

// Destructor.

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

//

CUpnpRangeHeaderParser::~CUpnpRangeHeaderParser()

    {

    }

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

// CUpnpRangeHeaderParser::ParseRangeL

// Function returns parsinfg status.

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

//

TInt CUpnpRangeHeaderParser::ParseRangeL( CUpnpHttpMessage* aMsg, TInt aFileSize )

    {

    //checks if Range header exist and is correct

    TInt rangeStatus = CheckRangeHeaderSyntax( aMsg );

    if ( rangeStatus != EHttpPartialContent )

        {

        return rangeStatus;

        }

    //checks Range values    

    rangeStatus = CheckRangeValues( aFileSize );

    if ( rangeStatus < 0 )

    {

        return rangeStatus;

    }

    // creates response if Range header occurs

    if ( rangeStatus==EHttpPartialContent )

        {

        //HTTP/1.1 206 Partial Content

        CreatePartialContentResponseL( aFileSize, rangeStatus ); 

        }

    else if ( rangeStatus==EHttpNoContent )

        {

        //HTTP/1.1 204 No Content

        CreateNoContentResponseL( aFileSize, rangeStatus ); //HTTP/1.1 204 No Content

        }

    return rangeStatus;

    }

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

// CUpnpRangeHeaderParser::CheckRangeHeaderSyntax

// Checks range header syntax.

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

//

TInt CUpnpRangeHeaderParser::CheckRangeHeaderSyntax( CUpnpHttpMessage* aMsg )

    {

    // checks if range header exist

    TBool rangeHeaderExist = EFalse;

    aMsg->IsHeader( (TDesC8&) UpnpHTTP::KHdrRange, rangeHeaderExist );

    if( !rangeHeaderExist )

        {

        return EHttpOk; //Range header doesn't exist

        }

    // checks if Range value exist    

    if( !(aMsg->GetHeaderValue( (TDesC8&) UpnpHTTP::KHdrRange ).Length() > 0 ) )

        {

        return -EHttpBadRequest; //Range value doesn't exist

        }

    // checks syntax of Range header

    if( !CUpnpRangeHeaderParser::ParseRangeHeader( aMsg->GetHeaderValue(

        (TDesC8&) UpnpHTTP::KHdrRange ), iStartPos, iEndPos ) )

        {

        return -EHttpBadRequest; //error in syntax

        }            

     return EHttpPartialContent; //Range header is proper

    }

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

// CUpnpRangeHeaderParser::CheckRangeValue

// Checks range values.

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

//    

TInt CUpnpRangeHeaderParser::CheckRangeValues( TInt aFileSize )

    { 

    // empty file

    if ( aFileSize == 0 )

        {

        if ( ( iStartPos == 0 ) || ( iStartPos == iEndPos ) 

             || ( iStartPos > 0 && iEndPos == KErrNotFound ) 

             || ( iStartPos == KErrNotFound && iEndPos > 0 ) )

            {

            return EHttpNoContent;

            }

        else

            {

            return -EHttpBadRequest;

            }

        }

     else

        {

        // final bytes request

        // e.g. Range: bytes=-70 

        if ( ( iStartPos == KErrNotFound && iEndPos > 0 && iEndPos <= aFileSize ) )

            {

            iStartPos = aFileSize - iEndPos; 

            iEndPos = aFileSize-1;

            return EHttpPartialContent;

            }

        // bad posision dependece

        // e.g. Range: bytes=70-20 

        // e.g requested final bytes bigger than file size

        else if ( ( iStartPos == KErrNotFound && iEndPos == 0 ) 

                  || ( iStartPos == KErrNotFound && iEndPos > 0  && iEndPos > aFileSize )

                  || ( iStartPos > iEndPos && iEndPos != KErrNotFound ) )   

            {

            return -EHttpBadRequest;

            }

        // start position larger than file size     

        else if ( ( iStartPos >= aFileSize 

                  && ( iStartPos <= iEndPos || iEndPos == KErrNotFound ) ) )

            {

            return -EHttpRequestedRangeNotSatisfiable;

            }

        }

        // updates end position if it is out of file size

        if ( iEndPos == KErrNotFound || iEndPos > aFileSize-1 )

            {

            iEndPos = aFileSize-1;

            }

        return EHttpPartialContent; 

    }

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

// CUpnpRangeHeaderParser::AppendContentLengthToResponseL

// Appends Content-Length header to response.

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

//            

void CUpnpRangeHeaderParser::AppendContentLengthToResponseL( 

    TInt aFileSize, TInt rangeStatus )

    {

    TInt size( 0 );

    if ( rangeStatus == EHttpPartialContent )

        {

        size = iEndPos - iStartPos + 1;    

        }

    else

        {

        size = aFileSize;

        }

    iSizeBuffer.Num( size ); 

    iTransaction.AddResponseHeaderL( UpnpHTTP::KHdrContentLength(), iSizeBuffer );

    }

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

// CUpnpRangeHeaderParser::AppendBytesToResponseL

// Appends Bytes header to response.

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

//         

void CUpnpRangeHeaderParser::AppendBytesToResponseL( TInt aFileSize )

    {

    HBufC8* buffer = HBufC8::NewLC( sizeof(UpnpHTTP::KBytes) +

                         KIntegerOccurance*KMaxIntegerLength + KSlashSpaceAndMinusSize );

    //bytes

    buffer->Des().Append( UpnpHTTP::KBytes() );

    buffer->Des().Append( UpnpString::KSpace );

    //x

    iSizeBuffer.Num( iStartPos );

    buffer->Des().Append( iSizeBuffer ); 

    buffer->Des().Append( UpnpString::KMinus );

    //y

    iSizeBuffer.Num( iEndPos ); 

    buffer->Des().Append( iSizeBuffer ); 

    buffer->Des().Append( UpnpString::KSlash );

    //total

    iSizeBuffer.Num( aFileSize );

    buffer->Des().Append( iSizeBuffer );

    iTransaction.AddResponseHeaderL( UpnpHTTP::KHdrContentRange(), *buffer );

    CleanupStack::PopAndDestroy( buffer );

    }

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

// CUpnpRangeHeaderParser::CreatePartialContentResponseL

// Creates response 206 Partial Content.

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

//     

void CUpnpRangeHeaderParser::CreatePartialContentResponseL( 

    TInt aFileSize, TInt aHttpCode )

    {

    // append Partial Content To Response - "206 Partial Content"    

    iTransaction.AddResponseHeaderL( KNullDesC8(), UpnpHTTP::KHTTPPartialContent() );

    AppendContentLengthToResponseL( aFileSize, aHttpCode );

    AppendBytesToResponseL( aFileSize );

    }

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

// CUpnpRangeHeaderParser::CreateNoContentResponseL

// Creates response for 204 No Content.

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

//     

void CUpnpRangeHeaderParser::CreateNoContentResponseL( 

    TInt aFileSize, TInt aHttpCode )

    {

    // append No Content To Response - "204 No Content"

    iTransaction.AddResponseHeaderL( KNullDesC8(), UpnpHTTP::KHTTPNoContent() );    

    AppendContentLengthToResponseL( aFileSize, aHttpCode );

    // Append No Content Fields To Response;

    iTransaction.AddResponseHeaderL( UpnpHTTP::KHdrPragma(), UpnpHTTP::KNoCache() );

    iTransaction.AddResponseHeaderL( UpnpHTTP::KHdrCacheControl(), UpnpHTTP::KNoCache() );

    }

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

//  CUpnpHttpSession::ParseRangeHeader

//  Parse range values

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

//    

TBool CUpnpRangeHeaderParser::ParseRangeHeader( TDesC8& aRangeHeader, TInt& aStartPos,

                                                TInt& aEndPos )

    {

    // Check header's syntax: "bytes=x-y" where y i optional

    TInt pos( KErrNotFound );

    // 1 string has to contain "="

    pos = aRangeHeader.FindC( UpnpString::KEqual() );

    if( pos == KErrNotFound ) 

        return EFalse;

    // 2 "bytes" has to be at the beginnig

    pos = aRangeHeader.FindC( UpnpHTTP::KBytes() );

    if( pos == KErrNotFound || pos != 0 ) 

        return EFalse;

    // 3 Sets position to after bytes

    pos = UpnpHTTP::KBytes().Length();

    // 4 If there any space or tab after "bytes" - move pos after it

    CUpnpRangeHeaderParser::MovePosition( aRangeHeader, pos );

    // 5 "=" - has to be at this position (after "bytes" + spaces or tabs)

    if( aRangeHeader[ pos ] != UpnpString::KEqual()[0] )

        return EFalse;

    // 6 Sets position to after "="

    pos++;

    // 7 If there any space or tab after "=" - move pos after it

    CUpnpRangeHeaderParser::MovePosition( aRangeHeader, pos );

    // 8 extract x-y. -1 stands for '=' length

    TPtrC8 byteRange = aRangeHeader.Right( aRangeHeader.Length() - pos );

    // 9 There can't be any comas because multi-range is not allowed

    if( byteRange.Find( UpnpString::KComa() ) != KErrNotFound ) 

        return EFalse;

    // 10 "-" delimiter must occure and it cant't be first char, because notation as follows: "-y"  is not allowed

    pos = byteRange.Find( UpnpString::KMinus() );

    if( pos == KErrNotFound ) 

        return EFalse;

    // 11 Checks if it is a final bytes request

    // e.g. Range: bytes= -20

    if( pos == 0 )

        {

        // If there any space or tab after "-" - move pos after it

        CUpnpRangeHeaderParser::MovePosition( byteRange.Right( byteRange.Length()-1 ), pos );

        // if pos equal 0 should be 1 to avoid "-" in getting number from string operation

        pos = pos == 0 ? 1 : pos;

        TLex8 endMinus( byteRange.Right( byteRange.Length() - pos  ) );

        endMinus.SkipSpace();

        TInt error = endMinus.Val( aEndPos );

        if ( !CUpnpRangeHeaderParser::HandleConversionException( endMinus, aEndPos, error ) )

            {

            return EFalse;

            }

        // We have to check if something else than space or tab leaves after conversion - unless for example 11a will be correct but it is not

        if ( CUpnpRangeHeaderParser::HasImproperChars( endMinus ) )

            return EFalse;

        aStartPos = KErrNotFound;

        return ETrue;

        }

    // 12 All looks fine, so now parse it and get x and y

    TLex8 start( byteRange.Left( pos ) );

    start.SkipSpace();

    // 13 If conversion fails - return error

    TInt error = start.Val( aStartPos );

    if ( !CUpnpRangeHeaderParser::HandleConversionException( start, aStartPos, error ) )

        {

        return EFalse;

        }

    // 14 We have to check if something else than space or tab leaves after conversion - unless for example 11a will be correct but it is not

    if ( CUpnpRangeHeaderParser::HasImproperChars( start ) )

            return EFalse;

    // y is optional

    if( ( byteRange.Length() - pos - 1 ) > 0 )

        {

        TLex8 end( byteRange.Right( byteRange.Length() - pos - 1 ) );

        end.SkipSpace();

        error = end.Val( aEndPos );

        if ( !CUpnpRangeHeaderParser::HandleConversionException( end, aEndPos, error ) )

            {

            return EFalse;

            }

        // We have to check if something else than space or tab leaves after conversion - unless for example 11a will be correct but it is not

        if ( CUpnpRangeHeaderParser::HasImproperChars( end ) )

            return EFalse;

        } 

    else

        {

        aEndPos = KErrNotFound; 

        } 

    return ETrue;

    } 

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

//  CUpnpRangeHeaderParser::HasImproperChars

//  Checks number format

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

//  

TBool CUpnpRangeHeaderParser::HasImproperChars( const TLex8& aNumber )

    {

    TPtrC8 rem_ptr = aNumber.Remainder();

    for( TInt index = 0; index < rem_ptr.Length(); index++ )

        {

        if( rem_ptr[ index ] != UpnpString::KSpace()[0] &&

            rem_ptr[ index ] != UpnpString::KTab()[0] )

            return ETrue;

        }

    return EFalse;    

    }

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

//  CUpnpRangeHeaderParser::MovePosition

//  Moves parser position to first not white space

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

//  

void CUpnpRangeHeaderParser::MovePosition( const TDesC8& aString, TInt& aPos )

    {

    while ( aPos < aString.Length() && 

            ( aString[ aPos ] == UpnpString::KSpace()[0] || aString[ aPos ] ==

                                                            UpnpString::KTab()[0] ) 

          ) 

        {

        aPos++;

        }  

    }    

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

//  CUpnpRangeHeaderParser::HandleConversionException

//  Handles conversion exceptions

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

// 

TBool CUpnpRangeHeaderParser::HandleConversionException( TLex8& aNumber, TInt& aRangePos,

                                                         TInt aError )

    {

    if( aError == KErrOverflow )

    {

        aRangePos = KMaxTInt;

        while ( aNumber.Peek().IsDigit() )

            {

            aNumber.Inc();

            }        

    }        

    else if ( aError != KErrNone )

        {

        return EFalse;

        }

    return ETrue;

    }

// End Of File