/*

* Copyright (c) 2009-2010 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:

* MSRP Implementation

*

*/

// INCLUDES

// CLASS HEADER

#include "CMSRPMsgParser.h"

#include "MSRPCommon.h"

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

// CMSRPMsgParser::NewL

// Static constructor

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

//

/*static*/CMSRPMsgParser* CMSRPMsgParser::NewL(MMSRPParserObserver& aConnection)

    {

    MSRPLOG( "CMSRPMsgParser::NewL enter" )

    CMSRPMsgParser* self = new (ELeave) CMSRPMsgParser(aConnection );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    MSRPLOG( "CMSRPMsgParser::NewL exit" )

    return self;

    }

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

// CMSRPMsgParser::CMSRPMsgParser

// Constructor

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

//

CMSRPMsgParser::CMSRPMsgParser(MMSRPParserObserver& aConnection)        

    : iConnection( aConnection )

    {  

    }

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

// CMSRPMsgParser::~CMSRPMsgParser

// Destructor

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

//

CMSRPMsgParser::~CMSRPMsgParser()

    {

    MSRPLOG( "CMSRPMsgParser::~CMSRPMsgParser enter" )

    delete iLocalBuf;

    delete iEndToken;

    delete iMessage;

    iParseBuffers.ResetAndDestroy();

    iParseBuffers.Close();    

    MSRPLOG( "CMSRPMsgParser::~CMSRPMsgParser exit" )

    }

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

// CMSRPMsgParser::ConstructL

// 2nd phase constructor

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

//

void CMSRPMsgParser::ConstructL()

    {

    iState = ETitleLine;

    //to avoid leak on newl leave

    RMsrpBuf buf(iBufPool.ProvideBufferL());

    iLocalBuf = new (ELeave) RMsrpBuf(buf);

    //iLocalBuf = new (ELeave) RMsrpBuf(iBufPool.ProvideBufferL());

    iEndToken = HBufC8::NewL(KMSRPEndTokenMax);   

    }

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

// CMSRPMsgParser::ParseL

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

//

TBool CMSRPMsgParser::ParseL()

    {

    TMatchType match = EFullMatch;

    TBool ret = TRUE;

    /*parse until a parse element spans buffers. 

      if parse element completes exactly at buffer boundaries,

      might end up parsing greater than bufsize+1_element in one runl. 

      to avoid, use transitioned flag (set in handle full match)*/

    while (match == EFullMatch) 

    //while (ret == TRUE)/*parse all parseable data*/

        {    

        MSRPLOG( "CMSRPMsgParser::ParseL enter" )    

        if(!iParseBuffers.Count())

		{

			MSRPLOG( "CMSRPMsgParser::ParseL exit" ) 

            return FALSE;

		}

        TPtrC8 token(KCRAndLF());        

        if (iState == EBody)

            {

            token.Set(iEndToken->Des());                

            }   

        TInt matchPos;

        match = FindToken(iParseBuffers[0]->Ptr(),token,matchPos);    

        if(match == EFullMatch)

            {

            ret = HandleFullMatchL(token, matchPos);

            }

        else if (match == EPartialMatch)

            {

            ret = HandlePartialMatchL(token, matchPos);    

            }

        else //if (match == ENoMatch)        

            {              

            ret = HandleNoMatchL(token, matchPos);

            }

        }

    MSRPLOG( "CMSRPMsgParser::ParseL exit" )

    return ret;

    }

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

// CMSRPMsgParser::HandleFullMatchL

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

//

TBool CMSRPMsgParser::HandleFullMatchL(TPtrC8& aToken, TInt aMatchPos, TBool aCopyToLocal)

    {

    MSRPLOG( "CMSRPMsgParser::HandleFullMatchL enter" )

    TPtrC8 buf = iParseBuffers[0]->Ptr().Left(aMatchPos + aToken.Length());

    if(aCopyToLocal)

        {        

        iLocalBuf->Append(buf);

        }

    else

        {

        HandleStateL(buf, aMatchPos);

        }

    if((aMatchPos + aToken.Length()) != iParseBuffers[0]->Ptr().Length())

        {

        iParseBuffers[0]->MsrpMidTPtr(aMatchPos + aToken.Length());

        }

    else

        {

        //transitioned

        RMsrpBuf* headBuf = iParseBuffers[0];

        iParseBuffers.Remove(0);

        delete headBuf;

        if(!iParseBuffers.Count())

            return FALSE;

        }

    MSRPLOG( "CMSRPMsgParser::HandleFullMatchL exit" )

    return TRUE;

    }

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

// CMSRPMsgParser::HandlePartialMatchL

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

//

TBool CMSRPMsgParser::HandlePartialMatchL(TPtrC8& aToken, TInt aCurBufMatchPos)

    {

    MSRPLOG( "CMSRPMsgParser::HandlePartialMatchL enter" )

    TBool ret = TRUE;

    TInt matchTokenLen = iParseBuffers[0]->Ptr().Length()- aCurBufMatchPos;

    TPtrC8 matchToken = aToken.Left(matchTokenLen);

    TPtrC8 remainingToken = aToken.Mid(matchTokenLen);

    TPtrC8 emptyToken;

    if(iParseBuffers.Count() < 2)

        {

        if (iState == EBody && aCurBufMatchPos)

            //if some bytes to return in body, return now (xcluding token part) rather than parse again 

            {            

            ret = HandleFullMatchL(emptyToken, aCurBufMatchPos);//parse true return nxt parse false

            }

        return FALSE;//buffer count greater than 0 but content size smaller than complete lexical element  

        }

    //Look to complete token

    TInt nxtBufMatchPos;

    TMatchType match;                      

    TPtrC8 headOfNxtBuf = iParseBuffers[1]->Ptr().Left(remainingToken.Length());                    

    match = FindToken(headOfNxtBuf, remainingToken, nxtBufMatchPos);                       

    if(nxtBufMatchPos!=0) //nxt buf does not complete token

        {

        if (iState != EBody)

            {

            User::LeaveIfError(KErrCorrupt);

            }

        //false partial alarm for body, dont retain token part

        //need to update curbuf as false tokenpart also needs to be returned

        aCurBufMatchPos += matchToken.Length();

        //ret = HandleFullMatchL(matchToken, aCurBufMatchPos);//parse true return true

        ret = HandleFullMatchL(emptyToken, aCurBufMatchPos);

        }

    else

        {

        if(match == EPartialMatch) //completes part token but bytes insufficient

            {

            if (iState == EBody && aCurBufMatchPos)

                {

                ret = HandleFullMatchL(emptyToken, aCurBufMatchPos);//parse true ret false                                   

                }            

            return FALSE;

            }

        else //complete token

            {  

            TBool addToLocal = FALSE;

            if(iState != EBody)

                {

                addToLocal = TRUE;                

                }

            ret = HandleFullMatchL(matchToken, aCurBufMatchPos, addToLocal);

            ret = HandleFullMatchL(remainingToken, nxtBufMatchPos, addToLocal);//if token.length() and matches state token upto length, transition state

            //ret cud be false, if nxtbuf exactly completes token

            if(addToLocal == TRUE)

                {

                HandleStateL(*iLocalBuf, aCurBufMatchPos+nxtBufMatchPos);//nxtBuf==0, just token

                iLocalBuf->Zero();

                }            

            }

        }

    MSRPLOG( "CMSRPMsgParser::HandlePartialMatchL exit" )

    return ret;

    }

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

// CMSRPMsgParser::HandleNoMatchL

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

//

TBool CMSRPMsgParser::HandleNoMatchL(TPtrC8& aToken, TInt aCurBufMatchPos)

    {

    MSRPLOG( "CMSRPMsgParser::HandleNoMatchL enter" )

    TPtrC8 emptyToken;    

    TBool ret = FALSE;

    aCurBufMatchPos = iParseBuffers[0]->Ptr().Length();

    if (iState == EBody /*&& aCurBufMatchPos*/)

        {        

        ret = HandleFullMatchL(emptyToken, aCurBufMatchPos);        

        }        

    else if(iParseBuffers.Count() >= 2)

        {

        //if header find token in nxt buf

        TInt nxtBufMatchPos;

        TMatchType match;                      

        match = FindToken(iParseBuffers[1]->Ptr(),aToken,nxtBufMatchPos);

        if(match == EFullMatch)

            {       

            ret = HandleFullMatchL(emptyToken, aCurBufMatchPos, TRUE);

            ret = HandleFullMatchL(aToken, nxtBufMatchPos, TRUE);

            HandleStateL(*iLocalBuf, aCurBufMatchPos+nxtBufMatchPos);

            iLocalBuf->Zero();

            }

        else if (iParseBuffers.Count()>2)

            {

            User::LeaveIfError(KErrCorrupt);        

            }

        //else count==2, bytes insufficient in nxt buf, return false        

        }

    MSRPLOG( "CMSRPMsgParser::HandleNoMatchL exit" )

    return ret;

    }

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

// CMSRPMsgParser::HandleStateL

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

//

void CMSRPMsgParser::HandleStateL(const TDesC8& aString, TInt aMatchPos)

    {

    MSRPLOG( "CMSRPMsgParser::HandleStateL enter" )

    switch(iState)

         {

         case ETitleLine:

             HandleTitleLineL(aString, aMatchPos);             

             break;

         case EToPath:

         case EFromPath:    

         //case EMandatoryHeader:

             HandleHeaderL(aString, aMatchPos);            

             break;

         case EOptionalHeaders:

             HandleOptionalHeaderL(aString, aMatchPos);

             break;

         case EExtraCRLF:

             HandleXtraCrlfL(aString, aMatchPos);

             break;

         case EBody:

             HandleBodyL(aString, aMatchPos);

             break;             

         case EEndofEndLine:

             HandleEndofEndLineL(aString, aMatchPos);

             break;

         default:

             User::LeaveIfError(KErrUnknown);

             break;        

         }   

    MSRPLOG( "CMSRPMsgParser::HandleStateL exit" )

    }

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

// CMSRPMsgParser::HandleTitleLineL

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

//

void CMSRPMsgParser::HandleTitleLineL(const TDesC8& aString, TInt /*aMatchPos*/)

    {

    MSRPLOG( "CMSRPMsgParser::HandleTitleLineL enter" )

    TPtrC8 msrp(aString.Left(KMSRP().Length()));

    if(msrp.Compare(KMSRP()))

        User::LeaveIfError(KErrCorrupt);

    if(aString[KMSRP().Length()] != ' ')

        User::LeaveIfError(KErrCorrupt);

    TPtrC8 trans_id = aString.Mid(KMSRP().Length()+1);    

    TInt pos = trans_id.Locate(MSRP_SPACE);

    /*if(pos == KErrNotFound)

        User::LeaveIfError(KErrCorrupt);*/    

    if (pos < KMSRPIDLenMin || pos > KMSRPIDLenMax)

        User::LeaveIfError(KErrCorrupt);           

    trans_id.Set(trans_id.Left(pos));

    TPtr8 ptr = iEndToken->Des();

    ptr.Zero();

    ptr.Append(KCRAndLF);

    ptr.Append(KDashLine());

    ptr.Append(trans_id);

    TPtrC8 method = aString.Mid(KMSRP().Length()+1+trans_id.Length()+1);

    pos = method.Locate(MSRP_SPACE);

    if(pos == KErrNotFound)

        {

        pos = method.Locate(MSRP_CARRIAGE);        

        if(pos == KErrNotFound)

            User::LeaveIfError(KErrCorrupt);

        method.Set(method.Left(pos));

         if (!method.Compare(KMSRPSend()))

             {

             iMessage = CMSRPMessageHandler::NewL(MMSRPIncomingMessage::EMSRPMessage);

             }

         else if (!method.Compare(KMSRPReport()))

             {

             iMessage = CMSRPMessageHandler::NewL(MMSRPIncomingMessage::EMSRPReport);

             }

         else //extn

             {

             iMessage = CMSRPMessageHandler::NewL(MMSRPIncomingMessage::EMSRPNotDefined);

             }        

        }

    else //response

        {

        TPtrC8 null;

        method.Set(method.Left(pos));

        iMessage = CMSRPMessageHandler::NewL(MMSRPIncomingMessage::EMSRPResponse);

        iMessage->SetStatusOfResponseL(method, null);

        }    

    iMessage->SetTransactionId(trans_id);

    iState = EToPath;    

    MSRPLOG( "CMSRPMsgParser::HandleTitleLineL exit" )

    }

#if 0

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

// CMSRPMsgParser::HandleTitleLineL

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

//

void CMSRPMsgParser::HandleTitleLineL(const TDesC8& aString, TInt /*aMatchPos*/)

    {

    MSRPLOG( "CMSRPMsgParser::HandleTitleLineL enter" )

    TLex8 lex(aString);

    //MSRP

    lex.Mark();

    lex.SkipCharacters();

    if(lex.TokenLength() != 4)

        {   

        User::LeaveIfError(KErrCorrupt);

        }    

    TPtrC8 first_token = lex.MarkedToken();        

    if (first_token.Compare(KMSRP()))

        {

        User::LeaveIfError(KErrCorrupt);

        }

    //SP

    if(lex.Peek() != MSRP_SPACE)

    {

    User::LeaveIfError(KErrCorrupt);

    }

    lex.Inc();

    //trans-id

    lex.Mark();

    lex.SkipCharacters();    

    if (lex.TokenLength() < KMSRPIDLenMin || lex.TokenLength() > KMSRPIDLenMax)

        {

        User::LeaveIfError(KErrCorrupt);

        }

    //SP

    if(lex.Peek() != MSRP_SPACE)

    {

    User::LeaveIfError(KErrCorrupt);

    }

    lex.Inc();

    TPtrC8 trans_id = lex.MarkedToken();

    TPtr8 ptr = iEndToken->Des();

    ptr.Zero();

    ptr.Append(kEndMarker());

    ptr.Append(trans_id);

    //method

    lex.Mark();

    lex.SkipCharacters();

    if(lex.TokenLength() != 0)

        {   

        User::LeaveIfError(KErrCorrupt);

        }      

    TPtrC8 method = lex.MarkedToken();      

    //create msg

    //set trans_id

    if (!method.Compare(KMSRPSend()))

        {

        //type = ESend        

        //set type

        }

    else if (!method.Compare(KMSRPReport()))

        {

        //type = EReport        

        //set type

        }

    else //if 3 digit string

        { 

        //type = EResponse

        //set type

        //set status code

        //remaining SP comment\r\n

        /*ignore comment*/

        }

    //else extn method

    //remaining \r\n

    //TODO: comment, extn method and check remaining bytes is as xpected

    iState = EToPath;

    MSRPLOG( "CMSRPMsgParser::HandleTitleLineL exit" )

    }

#endif

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

// CMSRPMsgParser::HandleHeaderL

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

//

void CMSRPMsgParser::HandleHeaderL(const TDesC8& aString, TInt /*aMatchPos*/)

    {

    MSRPLOG( "CMSRPMsgParser::HandleHeaderL enter" )

    TInt pos = aString.Locate(MSRP_COLON);

    if(pos == KErrNotFound)

        User::LeaveIfError(KErrCorrupt);

    TPtrC8 header_name = aString.Left(pos);

    TUint8 nxtChar = aString[pos+1];

    if(nxtChar != MSRP_SPACE)

        User::LeaveIfError(KErrCorrupt);

    TPtrC8 header_val = aString.Mid(pos+2); 

    header_val.Set(header_val.Left(header_val.Length()-2));

    if(!header_val.Length())

        User::LeaveIfError(KErrCorrupt);

    MMSRPMessageHandler::TMsrpHeaderType headerType = MMSRPMessageHandler::EHeaderUnknown;

    if(iState == EToPath)

        {        

        if(header_name.Compare(KMSRPToPath()))

            User::LeaveIfError(KErrCorrupt);

        headerType = MMSRPMessageHandler::EToPath;

        iState = EFromPath;

        }

    else if(iState == EFromPath)

        {

        headerType = MMSRPMessageHandler::EFromPath;

        if(header_name.Compare(KMSRPFromPath()))

            User::LeaveIfError(KErrCorrupt);  

        iState = EOptionalHeaders;

        }

    else //find header id

        {

        if(!header_name.Compare(KMSRPMessageID()))

            {            

            headerType = MMSRPMessageHandler::EMessageId;

            }

        else if(!header_name.Compare(KMSRPByteRange()))

            {