/** @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:  HTTP header

*

*/

// INCLUDES

#include <e32math.h>

#include <f32file.h>

#include <e32std.h>

#include <e32property.h>

#include "upnplist.h"

#include "upnphttpmessage.h"

#include "upnpcommonupnplits.h"

#include "upnpcons.h"

#include "upnpstring.h"

#include "upnpcustomlog.h"

#include "upnpmessageobserver.h"

const TInt KHeadersMaxSixe = 8192;

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

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

// CUpnpHttpMessage::NewL

// Two-phased constructor.

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

//

EXPORT_C CUpnpHttpMessage* CUpnpHttpMessage::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CCHttpMessage::NewL

// Two-phased constructor.

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

//

EXPORT_C CUpnpHttpMessage* CUpnpHttpMessage::NewL(const TInetAddr& aAddr)

    {

    return NewL(aAddr, NewSessionIdL());

    }

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

// CCHttpMessage::NewL

// Two-phased constructor.

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

//

EXPORT_C CUpnpHttpMessage* CUpnpHttpMessage::NewL(TInetAddr aAddr, TInt aSessionId)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL(aAddr, aSessionId);

    CleanupStack::Pop(self);

    return self;

    }

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

// CCHttpMessage::NewL

// Two-phased constructor.

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

//

EXPORT_C CUpnpHttpMessage* CUpnpHttpMessage::NewL(TDesC8& aMessageBuffer, TInetAddr aSender)

    {

    return NewL(aMessageBuffer, aSender, NewSessionIdL());

    }

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

// CCHttpMessage::NewL

// Two-phased constructor.

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

//

EXPORT_C CUpnpHttpMessage* CUpnpHttpMessage::NewL(TDesC8& aMessageBuffer, const TInetAddr& aSender, TInt aSessionId)

    {

    CUpnpHttpMessage* self = NewL(aSender, aSessionId);

    CleanupStack::PushL(self);

    self->ParseL(aMessageBuffer);

    CleanupStack::Pop();

    return self;

    }

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

// CUpnpHttpMessage::~CUpnpHttpMessage

// Destructor.

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

//

EXPORT_C CUpnpHttpMessage::~CUpnpHttpMessage()

    {

    if (iHeaderList)

        {

        iHeaderList->DeleteObjects();

        delete iHeaderList;

        }

    if( iTimer )

        {

        iTimer->Cancel();

        delete iTimer;

        }

    if ( iOutUri )

        {

        delete iOutUri;

        }

    delete iDestinationPath;

    delete iSenderPath;

    delete iTextBody;

    delete iOutFilename;

    delete iInFilename;

    }

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

// CUpnpHttpMessage::CUpnpHttpMessage

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

// might leave.

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

//

EXPORT_C CUpnpHttpMessage::CUpnpHttpMessage()

    {

    iSessionPriority = EPriorityNormal;

    iOverwriteExisting = EFalse;

    // Parameters connected with downloading range of requested content.

    // This mechanism if disabled by default an the whole file is requested.

    iOffset = 0;

    iLength = 0; 

    iSaveAtOffset = EFalse;

    }

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

// CUpnpHttpMessage::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CUpnpHttpMessage::ConstructL()

    {

    iHeaderList = new (ELeave) CUpnpHttpHeaderList;

    iTextBody = HBufC8::NewL(0);

    iDestinationPath = HBufC8::NewL(0);

    iSenderPath = HBufC8::NewL(0);

    iInFilename = HBufC8::NewL(0);

    iOutFilename = HBufC8::NewL(0);

    //by default EFalse, meaning ignored

    iClientRequest = EFalse;

    //TCP-session's 0 means the value will be ignored unless changed later on!

    iTcpTimeout = 0;

    iInternalError = KErrNone;

    }

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

// CUpnpHttpMessage::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CUpnpHttpMessage::ConstructL( TInetAddr& aSender, TInt aSessionId)

    {

    iDestinationPath = HBufC8::NewL(0);

    iSenderPath = HBufC8::NewL(0);

    iInFilename = HBufC8::NewL(0);

    iOutFilename = HBufC8::NewL(0);

    iHeaderList = new (ELeave) CUpnpHttpHeaderList;

    iTextBody = HBufC8::NewL(0);

    iRemoteHost = aSender;

    iSessionId = aSessionId;

    //by default EFalse, meaning ignored

    iClientRequest = EFalse;

    }

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

// CUpnpHttpMessage::ParseL

// Parses one row of headers.

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

//

EXPORT_C void CUpnpHttpMessage::ParseL(TDesC8& aBuffer)

    {

    // position where the header ends

    TInt endOfHeader=0;

    // position of first \r\n

    TInt posOfNextLine = 0;

    // position of first space

    TInt posOfFirstSpace = 0;

    // position of second space

    TInt posOfSecondSpace = 0;

    // Boolean value that is used to check if message is

    // request or response. If message is response, protocol

    // version information is at the beginning of first row

    // (HTTP/1.1 200 OK)

    // In request, protocol version is at the end.

    // (GET / HTTP/1.1)

    TBool isResponse = EFalse;

// Handling of header part

    // trying to find Head/body separator

    endOfHeader = aBuffer.Find(UpnpString::KDoubleLineFeed);

    if( endOfHeader == KErrNotFound)

        {

        User::Leave(KErrAbort);

        }

    posOfNextLine = aBuffer.Find(UpnpString::KLineFeed); 

    if( posOfNextLine != KErrNotFound )

        {

        TPtrC8 spacePtr;

        spacePtr.Set( aBuffer );

        // finding first space

        posOfFirstSpace = spacePtr.Find(UpnpString::KSpace);

        if ( posOfFirstSpace != KErrNotFound )

            {

            spacePtr.Set( spacePtr.Left( posOfFirstSpace ) );

            // if first word of message is HTTP/1.1 or HTTP/1.0

            // message is response

            if( ( spacePtr.Find( KHttp11WithoutSpace() ) == 0 && 

                  posOfFirstSpace == KHttp11WithoutSpace().Length() ) 

                ||

                ( spacePtr.Find( KHttp10() ) == 0 && 

                  posOfFirstSpace == KHttp10().Length() ) )

                {

                isResponse = ETrue;

                }

            else

                {

                isResponse = EFalse;            

                }

            }

        else

            {

            isResponse = EFalse;            

            }

        // back to basic handling

        spacePtr.Set( aBuffer );

        if( posOfFirstSpace < posOfNextLine && posOfFirstSpace != KErrNotFound )

            {

            // if first space is found, it has to be before linefeed

            // +1 comes from going over the first space, we are interested

            // in what comes after it.

            spacePtr.Set( spacePtr.Mid( posOfFirstSpace  + 1 ) );

            posOfSecondSpace = spacePtr.Find(UpnpString::KSpace);

            if( posOfSecondSpace < posOfNextLine && posOfSecondSpace != KErrNotFound )

                {

                // check that length of path is longer than zero.

                if( posOfSecondSpace > 0 )

                    {

                    // Now check that Protocol version is HTTP/1.0 

                    // or HTTP/1.1. 

                    // If message is response, version is defined in first 

                    // parameter of the message. This has been checked before,

                    // so if response, no check needed.

                    spacePtr.Set( spacePtr.Mid( posOfSecondSpace+1 ) );

                    posOfNextLine = spacePtr.FindC( UpnpString::KLineFeed() );

                    spacePtr.Set( spacePtr.Left( posOfNextLine ) );

                    if( !isResponse )

                        {

                        //Check protocol's version                        

                        if (spacePtr.Match( KHttpVersionPattern() ) == 0 )

                            {    

                            //get only version numbers    

                            TPtrC8 version = spacePtr.Mid(5);

                            TLex8 lex(version);

                            TUint major;                            

                            if(lex.Val(major)!= KErrNone || lex.Peek()!='.')

                                {

                                {

                                // (protocol NOT HTTP/1.0 or HTTP/1.1. Invalid message)

                                User::Leave(KErrAbort);        

                                }

                                }

                            lex.Inc();                                                        

                            TUint minor;

                            if (lex.Val(minor) !=KErrNone)

                                {

                                // (protocol NOT HTTP/1.x. Invalid message)

                                User::Leave(KErrAbort);    

                                }                                

                            lex.SkipSpace();

                            if (!lex.Eos())

                                {

                                // (protocol NOT HTTP/1.x. Invalid message)

                                User::Leave(KErrAbort);    

                                }

                            //only 1.1 and 1.0 supported

                            if(major != 1 || (minor>1))

                                {

                                // (HTTP Version not supported)

                                User::Leave(-EHttpVersionNotSupported);    

                                }

                            }

                        else

                            {

                            // (protocol NOT HTTP/1.0 or HTTP/1.1. Invalid message)

                            User::Leave(KErrAbort);                                

                            }

                        }

                    }

                else

                    {

                    // header too short. Invalid message

                    User::Leave(KErrAbort);

                    }

                }

            else

                {

                // no second space found. Invalid message.

                User::Leave(KErrAbort);

                }

            }

        else

            {

            // no space found before linefeed. Invalid message

            User::Leave(KErrAbort);

            }

        }

    else

        {

        // no linefeed found. Invalid message

        User::Leave(KErrAbort);

        }

    if ( endOfHeader != KErrNotFound )

        {

        TPtrC8 tempHeaderPointer;

        TPtrC8 finderIndexPointer;

        tempHeaderPointer.Set(aBuffer.Left(endOfHeader));

        // if header lenght is longer that 8k,cut headers after one that cross the line

        if (endOfHeader > KHeadersMaxSixe)

            {

            TInt afterLimit = tempHeaderPointer.Mid(KHeadersMaxSixe).Find(UpnpString::KLineFeed);

            if (afterLimit != KErrNotFound)

                {

                tempHeaderPointer.Set(tempHeaderPointer.Left(KHeadersMaxSixe + afterLimit));

                }

            }    

        TInt index=0, indexLWS=0, indexCRLF=0;

        TBool FirstLine=ETrue;

        while (index != KErrNotFound)

            {

            // locate end-of-line, parse each line separately

            //RFC822 3.2 field-name  =  1*<any CHAR, excluding CTLs, SPACE, and ":">

            index = tempHeaderPointer.Find(UpnpString::KLineFeed);

            indexLWS = FindLWS(tempHeaderPointer);

            finderIndexPointer.Set(tempHeaderPointer);

            indexCRLF = index;

            //the length of the string for the end-line marker CRLF

            TInt headerCRLF = 2;

            while (indexCRLF == indexLWS && indexCRLF != KErrNotFound)

            {

                //3 below =the length of the LWS string

                finderIndexPointer.Set(finderIndexPointer.Right(finderIndexPointer.Length()-(indexCRLF+3)));

                indexCRLF = finderIndexPointer.Find(UpnpString::KLineFeed);

                if (indexCRLF == KErrNotFound)

                {

                    //3 below =the length of the LWS string

                    index += finderIndexPointer.Length() + 3; 

                    indexLWS = finderIndexPointer.Length();

                    headerCRLF = 0;

                }

                else

                {

                    index += indexCRLF+3;    

                    indexLWS = FindLWS(finderIndexPointer);

                }

            }

            if(index != KErrNotFound)

                {

                TPtrC8 oneHeaderRow;

                oneHeaderRow.Set(tempHeaderPointer.Left(index));

                // To check if is the first line of message (e.g. GET / HTTP 1.1 etc.)

                if (FirstLine)

                    {

                    ParseHeaderRowL( (TDesC8&) oneHeaderRow, ETrue);

                    FirstLine=EFalse;

                    }

                else 

                    {

                    ParseHeaderRowL(oneHeaderRow, EFalse);

                    }

                // To delete one header row + "\r\n" = length+2 to prepare for next row.

                if (headerCRLF)

                    {

                    tempHeaderPointer.Set(tempHeaderPointer.Right(tempHeaderPointer.Length()-(index+headerCRLF)));    

                    }

                    else

                    {

                        index = KErrNotFound;

                    }

                }

            }

        if (FirstLine)

            {

            ParseHeaderRowL(tempHeaderPointer, ETrue);

            }

        else

            {

            ParseHeaderRowL(tempHeaderPointer, EFalse);

            }

        }

    // check if all HTTP/1 requests have HOST header

    if(!isResponse && RequestHTTPVersion() == KHttp11WithoutSpace() )

        {

        TBool exists;

        IsHeader(UpnpSSDP::KHdrHost(), exists);

        if (!exists) 

            User::Leave(KErrAbort);    

        }

    // Handle body:

    if(iTextBody)

        {

        delete iTextBody;

        iTextBody=NULL;

        }

    iTextBody=HBufC8::NewL(aBuffer.Length() - endOfHeader);

    iTextBody->Des().Zero();

    // Append rest of message to iTextBody. Leave out string "\r\n\r\n".

    iTextBody->Des().Append(aBuffer.Right(aBuffer.Length() - (endOfHeader + 4)));

    }

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

// CUpnpHttpMessage::ParseHeaderRowL

// Parses one row of headers.

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

//

EXPORT_C TInt CUpnpHttpMessage::FindLWS(const TDesC8& aText)

{

    TInt indexSP = aText.Find(UpnpString::KCRLFSP);

    TInt indexHT = aText.Find(UpnpString::KCRLFHT);

    if (indexSP == KErrNotFound) 

        return indexHT;

    else if    (indexHT == KErrNotFound) 

        return indexSP;

    else if(indexSP < indexHT) 

        return indexSP;

    else

        return indexHT;

}

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

// CUpnpHttpMessage::ParseHeaderRowL

// Parses one row of headers.

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

//

EXPORT_C void CUpnpHttpMessage::ParseHeaderRowL(const TDesC8& aBuffer, TBool aFirstLine)

    {

    TInt FirstColonPosition=0;

    // locate first colon. This separates header's name and value.

    FirstColonPosition = aBuffer.Find(UpnpString::KColon());

    if(aFirstLine)

        {

        AddPairL(aBuffer, KSpace8());

        }

    else

        {

        if (FirstColonPosition == KErrNotFound )

            {