/*

* Copyright (c) 2008 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:  CHttpTransactionClient

*

*/

#include <http/rhttpresponse.h>

#include <http/rhttpheaders.h>

#include <httpstringconstants.h>

#include <http/thttphdrval.h>

#include <http/mhttpauthenticationcallback.h>

#include <httperr.h>

#include <stringpool.h>

#include <e32svr.h>

#include <x509cert.h>

#include <ssl.h>

#include "logger.h"

#include "chttptransactionclient.h"

#include "httpsessionclient.h"

#include "chttpscertinfo.h"

#include "mrefhttpclientobserver.h"

_LIT8(KSeperator , ";;");

_LIT8(KComma , ",");

_LIT8(KDot , ".");

_LIT8(KCommaSpace , ", ");

_LIT8(KSemiColonSpace , "; ");

_LIT8(KEquals , "=");

_LIT8(KDRMHeader1,"application/vnd.oma.drm.content");

_LIT8(KDRMHeader2,"application/vnd.oma.drm.message");

// A maximum length of the cipher suite description strings,

// see CipherSuiteDescription().

const TUint8 KMaxCipherSuiteDescriptionLength = 40;

const TInt KCookieBufferAllocLength = 4096;

CHttpTransactionClient::CHttpTransactionClient(HttpSessionClient& aSession, MRefHttpClientObserver* aObserver)

        :iHttpSession(aSession) , iObserver(aObserver), iReleasedData(ETrue),iClosing(EFalse)

{}

CHttpTransactionClient* CHttpTransactionClient::NewL(HttpSessionClient& aSession,

        MRefHttpClientObserver* aObserver,

        const TDesC* aUri,

        const TDesC* aRequestMethod)

{

    CHttpTransactionClient* self =  new(ELeave) CHttpTransactionClient(aSession,aObserver);

    CleanupStack::PushL(self);

    self->ConstructL(aUri, aRequestMethod);

    CleanupStack::Pop(self);

    return self;

}

void CHttpTransactionClient::ConstructL(const TDesC* aUri, const TDesC* aRequestMethod)

{

    //open the transaction

    LOG(ESOCKET,EInfo, "CHttpTransactionClient::ConstructL ");

    iFlag = 0;

    iDrmBuf = HBufC8::NewL(256);

    OpenTransactionL(aUri , aRequestMethod);

}

void CHttpTransactionClient::OpenTransactionL(const TDesC* aUri, const TDesC* aRequestMethod)

{

    LOG(ESOCKET,EInfo,"CHttpTransactionClient::OpenTransactionL + ");

    TUriParser8 uri;

    HBufC8* uriBuf= HBufC8::NewLC(aUri->Length());

    TPtr8 uriPtr = uriBuf->Des();

    uriPtr.Copy(*aUri);

    uri.Parse(*uriBuf);

    //Get Request Method String

    TBuf8<32> reqestType; //GET //POST // HEAD // Only options available in Midp 2.0 Http

    LOG(ESOCKET,EInfo,"Open TransactionL : Transaction Uri  ");

    reqestType.Copy(*aRequestMethod);

    LOG(ESOCKET,EInfo,"Open TransactionL : ReqestType ");

    RStringF requestMethoStr = iHttpSession.Session().StringPool().OpenFStringL(reqestType);

    CleanupClosePushL(requestMethoStr);

    iTransaction = iHttpSession.Session().OpenTransactionL(uri,*this,requestMethoStr);

    CleanupStack::PopAndDestroy(2);//requestMethoStr// uriBuf

    LOG(ESOCKET,EInfo,"CHttpTransactionClient::OpenTransactionL - ");

}

void CHttpTransactionClient::SubmitL(RPointerArray<HBufC8>* aRawHeaders , TDesC8* aPostData, int aResponseTimeout)

{

    //ELOG(ESOCKET,"CHttpTransactionClient::SubmitL + ");

    //retrieve the headers

    TInt respTimeOut = aResponseTimeout;

    delete iBuf;

    iBuf=NULL;

    if (aPostData!=NULL && aPostData->Length()>0)

    {

        HBufC8* buf = aPostData->AllocL();

        iBuf=buf;

        LOG(ESOCKET,EInfo,"SubmitL : Posting Data ");

    }

    // Disable pipelining on this transaction

    RStringPool stringPool = iHttpSession.Session().StringPool();

    RStringF property = stringPool.StringF(HTTP::EHttpPipelining, RHTTPSession::GetTable());

    THTTPHdrVal disablePipelining = stringPool.StringF(HTTP::EDisablePipelining, RHTTPSession::GetTable());

    iTransaction.PropertySet().SetPropertyL(property, disablePipelining);

    if (respTimeOut != -1)

    {

        LOG1(ESOCKET,EInfo,"Setting response timeout to http stack with value = %d ",aResponseTimeout);

        property = stringPool.StringF(HTTP::EReceiveTimeOutValue, RHTTPSession::GetTable());

        THTTPHdrVal responseTimeout(respTimeOut);

        iTransaction.PropertySet().SetPropertyL(property, responseTimeout);

    }

    //Submit the transaction

    RHTTPHeaders hdr = iTransaction.Request().GetHeaderCollection();

    TInt headerCount = aRawHeaders->Count();

    for (TInt ii=0; ii < headerCount; ++ii)

    {

        SetHeaderL(hdr, (*aRawHeaders)[ii]);

    }

    //iHttpSession.CustomiseHeadersL(hdr);

    //Set Data

    if (iBuf && iBuf->Length() > KErrNone)

        iTransaction.Request().SetBody(*this);

    /* The data will be requested from MHttpDataSupplier*/

    iJavaWaitingOnCallBack=ETrue;

    iJavaWaitingOnReadCallBack=ETrue; // Assume somebody opened an input Stream

    LOG1(ESOCKET,EInfo,"CHttpTransactionClient::SubmitL :iTransaction.Id %d ",iTransaction.Id());

    TRAP_IGNORE(iTransaction.SubmitL());

    LOG(ESOCKET,EInfo,"CHttpTransactionClient::SubmitL - ");

}

void CHttpTransactionClient::SetHeaderL(RHTTPHeaders& aHeaders, const TDesC8* aRawField)

{

    /*Raw Headers are passed in from java of the format

    * ValueKey ;; property

    * HTTP requires all request properties which can legally have

    * multiple instances with the same key to use a comma-separated list

    * syntax which enables multiple properties to be appended into a

    * single property.

    */

    //Find the value field

    //Seperated from values in Java by KSeperator

    TInt valueIndex = aRawField->Find(KSeperator);

    User::LeaveIfError(valueIndex);

    TPtrC8 value =aRawField->Left(valueIndex);

    RStringF valueF = iHttpSession.Session().StringPool().OpenFStringL(value);

    CleanupClosePushL(valueF);

    TPtrC8 propertyRaw= aRawField->Mid(valueIndex+2);

    LOG(ESOCKET,EInfo,"CHttpTransactionClient Add header value ");

    aHeaders.SetRawFieldL(valueF, propertyRaw , KComma);

    CleanupStack::PopAndDestroy();//valueF

}

void CHttpTransactionClient::GetResponseL(RPointerArray<HBufC8>* aRawHeaders)

{

    LOG(ESOCKET,EInfo,"CHttpTransactionClient::GetResponseL(RPointerArray<HBufC8>* aRawHeaders)");

    RStringPool strP = iTransaction.Session().StringPool();

    //First element in response array is the status line of the form

    //HTTP-Version (major.minor) ;; Status-Code ;; Reason-Phrase

    LOG1(ESOCKET,EInfo,"CHttpTransactionClient::GetResponseL :iTransaction.Id %d ",iTransaction.Id());

    RHTTPResponse response = iTransaction.Response();

    TInt statusLineLength=0;

    //HTTP-Version

    TVersion serverVersion = response.Version();

    TBuf<16> major;

    major.Num(serverVersion.iMajor);

    TBuf<16> minor;

    minor.Num(serverVersion.iMinor);

    statusLineLength+=major.Length();

    statusLineLength+=1;//KDot

    statusLineLength+=minor.Length();

    //Status code

    TBuf<16> stausCode;

    TInt serverStatusCode = response.StatusCode();

    stausCode.Num(serverStatusCode);

    statusLineLength+=stausCode.Length();

    //Status Text

    RStringF serverResponseTextF = response.StatusText();

    statusLineLength+= serverResponseTextF.DesC().Length();

    //Sepearators KSeperator *2

    statusLineLength+=4;//

    HBufC8* responseText = HBufC8::NewLC(statusLineLength);

    //Create Status Line

    //Version

    responseText->Des().Append(major);

    responseText->Des().Append(KDot);

    responseText->Des().Append(minor);

    //Status Code

    responseText->Des().Append(KSeperator);

    responseText->Des().Append(stausCode);

    //Status Text

    responseText->Des().Append(KSeperator);

    responseText->Des().Append(serverResponseTextF.DesC());

    aRawHeaders->Append(responseText);

    CleanupStack::Pop(responseText);

    //Package up all the transaction headers in to an array of java strings

    RHTTPHeaders headers =response.GetHeaderCollection();

    THTTPHdrFieldIter it = headers.Fields();

    RStringTokenF token;

    RStringF fieldNameStr;

    TPtrC8 rawFldPtr;

    HBufC8* rawHeader = NULL; // field name  and values

    TInt rawFieldLength=0;

    do

    {

        token = it();

        fieldNameStr=strP.StringF(token);

        //Get the field data assume we get comma seperated values and

        //don't have to use aPartIdx

        RStringF setCookie = strP.StringF(HTTP::ESetCookie,RHTTPSession::GetTable());

        if (fieldNameStr == setCookie)

        {

            // Buffer for storing a single cookie

            HBufC8* cookieBuf = HBufC8::NewLC(KCookieBufferAllocLength);

            cookieBuf->Des().Append(fieldNameStr.DesC());

            cookieBuf->Des().Append(KSeperator);

            iMinLength = cookieBuf->Des().Length();

            TInt totalCookiesLength = 0;

            TInt cookieCount = headers.FieldPartsL(setCookie);

            if (cookieCount != 0)

            {

                for (TInt ii = 0; ii < cookieCount; ii++)

                {

                    iDiscardCookie = false;

                    StoreOneCookieL(cookieBuf, headers, ii, setCookie);

                    if (ii < cookieCount-1)

                    {

                        // Replace last semicolon with comma

                        if (iDiscardCookie!=true)

                        {

                            cookieBuf->Des().SetLength(cookieBuf->Des().Length() - KSemiColonSpace().Length());

                            cookieBuf->Des().Append(KCommaSpace);

                        }

                        else

                        {

                            cookieBuf->Des().Append(KCommaSpace);

                        }

                    }

                    if (ii > 0)

                    {

                        totalCookiesLength += cookieBuf->Des().Length();

                        rawHeader = rawHeader->ReAllocL(totalCookiesLength);

                        rawHeader->Des().Append(*cookieBuf);

                    }

                    else

                    {

                        rawHeader = cookieBuf->AllocL();

                        totalCookiesLength = rawHeader->Length();

                    }

                    cookieBuf->Des().Zero();

                }

            }

            else

            {

                LOG(ESOCKET,EInfo,"CHttpTransactionClient::GetResponseL 'Set-Cookie:' header field is empty");

                rawHeader = cookieBuf->AllocL();

            }

            CleanupStack::PopAndDestroy(cookieBuf);

            aRawHeaders->Append(rawHeader);

        }

        else

        {

            TInt err = headers.GetRawField(fieldNameStr,rawFldPtr);

            // Work around for DRM download

//          RStringF contentType = strP.StringF(HTTP::EContentType,RHTTPSession::GetTable());

//          if (fieldNameStr == contentType)

//          {

//                  LOG(ESOCKET,EInfo,"content type header is  present");

//                  TInt index = rawFldPtr.Match(KDRMHeader1);

//                  //  LOG1(ESOCKET,EInfo,"rawFldPtr = %s ",rawFldPtr.str());

//                      LOG1(ESOCKET,EInfo,"index of drm header is = %d",index);

//              if(index == 0)

//              {

//                      iDrmDownload = true;

//              }

//              else

//              {

//                      index = rawFldPtr.Match(KDRMHeader2);

//                      if(index == 0)

//                              iDrmDownload = true;

//              }

//          }

            if (err==KErrNone)

            {

                rawFieldLength += fieldNameStr.DesC().Length();

                rawFieldLength += 2;//KSeperator Length;

                rawFieldLength += rawFldPtr.Length();

                rawHeader = HBufC8::NewL(rawFieldLength);

                rawHeader->Des().Append(fieldNameStr.DesC());

                rawHeader->Des().Append(KSeperator);

                rawHeader->Des().Append(rawFldPtr);

                aRawHeaders->Append(rawHeader);

                rawFieldLength=0;

            }

        }

        ++it;

    }

    while (!it.AtEnd());

}

// RHTTPResponse CHttpTransactionClient::GetResponseL()

//  {

//  LOG(ESOCKET,EInfo,"CHttpTransactionClient::GetResponseL");

//  return iTransaction.Response();

//  }

/*

* Returns the total number of bytes read into the buffer,

* or -1 if there is no more data because the end of the stream

* has been reached.

*/

TInt CHttpTransactionClient::ReadBytes(TDes8& aBytesPtr)

{

    LOG(ESOCKET,EInfo,"CHttpTransactionClient:: ReadBytes");

    TInt maxBufLength = aBytesPtr.MaxLength();

    TInt bodyDataPartLength = 0;

    if (iDrmDownload == false)

    {

        bodyDataPartLength = iBuf->Length();

    }

    else

    {

        bodyDataPartLength = iDrmBuf->Length();

    }

    LOG1(ESOCKET,EInfo,"CHttpTransactionClient::ReadBytes: maxRead: %d," , maxBufLength);

    LOG1(ESOCKET,EInfo,"CHttpTransactionClient::ReadBytes: bodyDataPartLength:: %d " ,bodyDataPartLength);

    TInt bytesRead = (maxBufLength+iJavaReadOffset > bodyDataPartLength) ? (bodyDataPartLength - iJavaReadOffset) : maxBufLength;

    if (bytesRead>0)

    {

        LOG1(ESOCKET,EInfo,"Bytes read : %d " ,bytesRead);

        if (iDrmDownload == false)

        {

            TPtrC8 bufPtr = iBuf->Mid(iJavaReadOffset,bytesRead);

            aBytesPtr.Copy(bufPtr);

        }

        else

        {

            TPtrC8 bufPtr = iDrmBuf->Mid(iJavaReadOffset,bytesRead);

            aBytesPtr.Copy(bufPtr);

        }

        LOG1(ESOCKET,EInfo,"CHttpTransactionClient::ReadBytes: iJavaReadOffset:: %d " ,iJavaReadOffset);

        if (iDrmDownload == false)

        {

            if ((iJavaReadOffset+bytesRead) == bodyDataPartLength && iLastChunk)

            {

                //All body data from the http transaction has been read

                LOG(ESOCKET,EInfo,"CHttpTransactionClient::ReadBytes: EOF iLastChunk");

                iRead = ETrue;

                iJavaWaitingOnReadCallBack=EFalse;

                TRAP_IGNORE(iObserver->DataReadyForRead(-1));

            }

        }

        else

        {

            if ((iJavaReadOffset+bytesRead) == iDrmBuf->Length() && iLastChunk)

            {

                //All DRM body data from the http transaction has been read

                LOG(ESOCKET,EInfo,"CHttpTransactionClient::ReadBytes: EOF iLastChunk");

                iRead = ETrue;

                iJavaWaitingOnReadCallBack=EFalse;

                TRAP_IGNORE(iObserver->DataReadyForRead(-1));

            }

        }

    } // if(bytesread > 0)

    if ((iJavaReadOffset+bytesRead)<=bodyDataPartLength)

    {

        if (iJavaReadOffset+bytesRead < bodyDataPartLength)

        {

            //Java hasn't read all the current body data buffer, inform java

            //amount of bytes left to read in buffer.

            iJavaReadOffset+=bytesRead;

            TInt  bytesLeftInBuffer = bodyDataPartLength-iJavaReadOffset;

            LOG1(ESOCKET,EInfo," CHttpTransactionClient::ReadBytes: bytesLeftInBuffer: %d",bytesLeftInBuffer);

            //Unblock java so it can read the remaining buffered data

            iJavaWaitingOnReadCallBack=ETrue;

            TRAP_IGNORE(iObserver->DataReadyForRead(bytesLeftInBuffer));

        }

        else

        {

            // in this call, the iBuf data was completely read, so call release data to get the next chunk(part) of body from

            // the native stack

            if (iDrmDownload == false)

            {

                // Non-Drm case, offset is reset to 0, starting reading newly from iBuf from the next call

                iJavaReadOffset=0;

                LOG(ESOCKET,EInfo,"CHttpTransactionClient:: ReadBytes ReleaseData!");

                iReleasedData=ETrue;

                if (iBuf)

                {

                    delete iBuf;

                    iBuf = NULL;

                }

                iRespBody->ReleaseData();   // tell the stack to send the next response body data, stack will call mhfrunl after this

            }

            else

            {

                // DRM file download, index is never reset to 0 , continue reading from drm buffer

                iJavaReadOffset+=bytesRead;

            }

        }

    }

    LOG1(ESOCKET,EInfo,"CHttpTransactionClient::ReadBytes: return bytesRead %d " , bytesRead);

    return bytesRead;

}

void CHttpTransactionClient::MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent)

{

    LOG(ESOCKET,EInfo,"CHttpTransactionClient::MHFRunL +");

    if (iTransaction== aTransaction)

    {

        LOG1(ESOCKET,EInfo,"before switch aEvent.iStatus = %d ",aEvent.iStatus);

        switch (aEvent.iStatus)

        {

        case THTTPEvent::ESubmit:

            LOG1(ESOCKET,EInfo,"MHFRunL::ESubmit : aEvent.iStatus = %d",aEvent.iStatus);

            iStatus= CHttpTransactionClient::ESubmitted;

            //Only send an event to Java when we've got a response

            break;

        case THTTPEvent::ECancel:

            LOG(ESOCKET,EInfo,"MHFRunL::ECancel");

            iStatus =CHttpTransactionClient:: ECancelled;

            if (iJavaWaitingOnCallBack)

            {

                iObserver->SubmitComplete(iStatus);

                LOG(ESOCKET,EInfo,"CHttpTransactionClient::MHFRunL ECancel ");

                iJavaWaitingOnCallBack=EFalse;

            }

            if (iJavaWaitingOnReadCallBack)

            {

                LOG(ESOCKET,EInfo,"Notifiy Read EOF / Cancel");

                iJavaWaitingOnCallBack=EFalse;

                iObserver->DataReadyForRead(-1);

            }

            break;

        case THTTPEvent::EClosed:

            LOG(ESOCKET,EInfo,"MHFRunL::EClosed");

            iStatus = CHttpTransactionClient::EClosed;

            if (iJavaWaitingOnCallBack)

            {

                iJavaWaitingOnCallBack=EFalse;

                LOG(ESOCKET,EInfo,"CHttpTransactionClient::MHFRunL EClosed");

                iObserver->SubmitComplete(iStatus);

            }

            if (iJavaWaitingOnReadCallBack)

            {

                LOG(ESOCKET,EInfo,"Notifiy Read EOF / Cancel");

                iJavaWaitingOnCallBack=EFalse;

                iObserver->DataReadyForRead(-1);

            }

            break;

            /*Receiving transaction events*/

        case THTTPEvent::EGotResponseTrailerHeaders:

        {

            LOG(ESOCKET,EInfo,"MHFRunL  EGotResponseTrailerHeaders");

            iStatus= CHttpTransactionClient::EGotResponse;

            break;

        }

        case THTTPEvent::ESucceeded:

        {

            LOG(ESOCKET,EInfo,"MHFRunL ESucceeded");

            break;

        }

        case THTTPEvent::EGotResponseHeaders:

        {

            LOG(ESOCKET,EInfo,"MHFRunL EGotResponseHeaders");

            iStatus = CHttpTransactionClient::EGotResponse;

            //If  we are secure attempt to get the security information.

            //At the moment the native HTTP stack only allows us to retrieve

            //Server cert info after and a submission and before the transaction is

            //complete, ignore any warnings as we may not be in sercure mode

            RStringPool strP = iTransaction.Session().StringPool();

            RHTTPResponse response = iTransaction.Response();

            RHTTPHeaders headers =response.GetHeaderCollection();

            THTTPHdrFieldIter it = headers.Fields();

            RStringTokenF token;

            RStringF fieldNameStr;

            TPtrC8 rawFldPtr;