/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  

*

*/

#include <Uri8.h>

#include <EscapeUtils.h>

#include <http/rhttpheaders.h>

#include <http/mhttpdatasupplier.h>

#include <thttpfields.h>

#include "ResourceHandle.h"

#include "ResourceHandleInternal.h"

#include "ResourceRequest.h"

#include "HttpConnection.h"

#include "ResourceHandleManagerSymbian.h"

#include "StaticObjectsContainer.h"

#include "ResourceLoaderDelegate.h"

#include "HttpCacheSupply.h"

#include "HttpPostDataSupplier.h"

#include <HttpFilterCommonStringsExt.h>

#include <BrCtlDefs.h>

#include "BrCtl.h"

#include "BrCtlSpecialLoadObserver.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "DocumentLoader.h"

#include "HttpUiCallbacks.h"

#include "HttpRequestHeaderManager.h"

#include "HttpConnUtils.h"

#include "MultipartContentHandler.h"

#include "UnknownContentHandler.h"

#include <wtf/Vector.h>

_LIT8(KHttps, "https");

_LIT8( KAppUid, "Appuid" );

using namespace WebCore;

DefersData::DefersData(void* ctx, DefersDataCallback callback) : CActive(CActive::EPriorityStandard)

{

    m_ctx = ctx;

    m_callback = callback;

    CActiveScheduler::Add(this);

}

DefersData::~DefersData()

{

    Cancel();

    delete m_response;

    Vector<HBufC8*>::const_iterator it = m_bodyParts.begin();

    Vector<HBufC8*>::const_iterator end = m_bodyParts.end();

    while (it != end) {

        HBufC8* buf = m_bodyParts.first();

        m_bodyParts.remove(0);

        delete buf;

        it = m_bodyParts.begin();

        end = m_bodyParts.end();

    }

}

void DefersData::RunL()

{

    m_callback(m_ctx);

}

TInt DefersData::RunError(TInt aError)

{

    return KErrNone;

}

void DefersData::Activate()

{

    SetActive();

    iStatus = KRequestPending;

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

}

ReceivedFinished::ReceivedFinished(void* ctx, ReceivedFinishedCallback callback) : CActive(CActive::EPriorityStandard)

{

    m_ctx = ctx;

    m_callback = callback;

    m_done = true;

    m_error = KErrNone;

    CActiveScheduler::Add(this);

}

ReceivedFinished::~ReceivedFinished()

{

    Cancel();

}

void ReceivedFinished::RunL()

{

    m_callback(m_ctx, m_error);

    m_done = true;

}

TInt ReceivedFinished::RunError(TInt aError)

{

    return KErrNone;

}

void ReceivedFinished::Activate(TInt errorCode)

{

    m_done = false;

    m_error = errorCode;

    SetActive();

    iStatus = KRequestPending;

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

}

void ReceivedFinished::done(bool status)

{

    m_done = status;

}

HttpConnection::HttpConnection(ResourceHandle* _handle, Frame* _frame) : MUrlConnection(_handle)

{

    HttpSessionManager* httpSessionMgr = StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager();

    httpSessionMgr->addRequest(this, m_handle);

    m_frag = NULL;

    m_transaction = NULL;

    m_urlResponse = NULL;

    m_contentType = NULL;

    m_encoding = NULL;

    m_cacheSupply = NULL;

    m_postDataSupplier = NULL;

    m_maxSize = 0;

    m_frame = _frame;

    m_IsMultipart = false;

    m_isDone = false;

    m_certInfo = NULL;

    m_accumulatedSize = 0;

    m_defersData = NULL; // requests will not be propagated if loading is blocked

    m_receivedFinished = NULL;

    m_unknownContentHandler = NULL;

}

HttpConnection::~HttpConnection()

{

    HttpSessionManager* httpSessionMgr = StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager();

    if (m_transaction) {

        RHTTPSession& session = httpSessionMgr->httpSession();

        // remove own address from transaction properties

        m_transaction->PropertySet().RemoveProperty( session.StringPool().StringF(HttpFilterCommonStringsExt::ESelfPtr,

            HttpFilterCommonStringsExt::GetTable()));

    }

    httpSessionMgr->removeRequest(this);

    delete m_frag;

    delete m_urlResponse;

    delete m_contentType;

    delete m_encoding;

    delete m_defersData;

    delete m_receivedFinished;

    delete m_unknownContentHandler;

    delete m_cacheSupply;

    delete m_postDataSupplier;

    delete m_transaction;

}

HttpConnection* HttpConnection::connectionFromTransaction(RHTTPTransaction& transaction)

{

    RHTTPTransactionPropertySet propSet = transaction.PropertySet();

    THTTPHdrVal propRetVal;

    // Get the name of the property

    HttpSessionManager* httpSessionMgr = StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager();

    RHTTPSession& session = httpSessionMgr->httpSession();

    RStringF propName = session.StringPool().StringF( HttpFilterCommonStringsExt::ESelfPtr, HttpFilterCommonStringsExt::GetTable() );

    // if it is set . .

    if( propSet.Property( propName, propRetVal ) ){

        return (HttpConnection*)(TInt(propRetVal));

    }

    return NULL;

}

int HttpConnection::submit()

{

    TRAPD(error, submitL());

    return error;

}

void HttpConnection::submitL()

{

    __ASSERT_DEBUG( !m_transaction, THttpConnUtils::PanicLoader( KErrArgument ) );

    HttpSessionManager* httpSessionMgr = StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager();

    User::LeaveIfNull(httpSessionMgr);

    httpSessionMgr->openHttpSessionIfNeededL();

    TPtrC8 urlPtr( m_handle->request().url().des() );

    m_transaction = new (ELeave) RHTTPTransaction;

    RHTTPSession& session = httpSessionMgr->httpSession();

    RStringPool stringPool = session.StringPool();

    const TStringTable& stringTable = RHTTPSession::GetTable();

    TUriParser8 uriParser;

    uriParser.Parse(urlPtr);

    // fragment

    if(uriParser.IsPresent(EUriFragment)) {

        m_frag = uriParser.Extract(EUriFragment).AllocL();

        // url without frag

        uriParser.UriWithoutFragment(urlPtr);

        // and reparse url

        uriParser.Parse(urlPtr);

        }

    // open transaction

    RStringF method;

    if (m_handle->request().httpMethod() == "GET") {

        method = stringPool.StringF( HTTP::EGET, stringTable );

    }

    else if (m_handle->request().httpMethod() == "POST") {

        method = stringPool.StringF( HTTP::EPOST, stringTable );

    }

    else if (m_handle->request().httpMethod() == "PUT") {

        method = stringPool.StringF( HTTP::EPUT, stringTable );

    }

    else if (m_handle->request().httpMethod() == "DELETE") {

        method = stringPool.StringF( HTTP::EDELETE, stringTable );

    }

    else {

        User::Leave(KErrArgument);

    }

    *m_transaction = session.OpenTransactionL( uriParser, *(httpSessionMgr->transactionCallback()), method );

    // add transaction attributes such as default headers, cache properties

    addRequestHeadersL();

    RHTTPTransactionPropertySet propSet = m_transaction->PropertySet();

    RStringF appuid = stringPool.OpenFStringL( KAppUid );

    TUint appuidValue = control(m_frame)->webView()->getWidgetId();

    if(appuidValue){

        propSet.SetPropertyL(appuid,THTTPHdrVal(appuidValue));

    }

    appuid.Close();

    // Add IMEI Notify property to the transaction

    // It is not needed, as it is done in UA-Prof filter

    // addIMEINotifyPropertiesL();

    // add http request headers

    RHTTPHeaders httpHeaders = m_transaction->Request().GetHeaderCollection();

    httpSessionMgr->requestHeaderManager()->AddAllHeadersL(httpHeaders, m_handle->request());

    // Create a dataSupplier object to supply the request body to http stack.

    if ((m_handle->request().httpMethod() == "POST" ||

        m_handle->request().httpMethod() == "PUT") && m_handle->request().httpBody()){

        // 2 steps constructor

        m_postDataSupplier = new(ELeave)HttpPostDataSupplier( m_transaction, control(m_frame));

        m_postDataSupplier->initL(m_handle->request().httpBody());

        m_transaction->Request().SetBody( *m_postDataSupplier);

    }

    // create cache supplier

    m_cacheSupply = CHttpCacheSupply::NewL( this );

    TBrCtlDefs::TBrCtlCacheMode cacheMode;

    switch (m_handle->request().cachePolicy())

    {

    default:

    case UseProtocolCachePolicy:

        cacheMode = TBrCtlDefs::ECacheModeNormal;

        break;

    case ReloadIgnoringCacheData:

        cacheMode = TBrCtlDefs::ECacheModeNoCache;

        break;

    case ReturnCacheDataElseLoad:

        cacheMode = TBrCtlDefs::ECacheModeHistory;

        break;

    case ReturnCacheDataDontLoad:

        cacheMode = TBrCtlDefs::ECacheModeOnlyCache;

        break;

    };

	IsUrlInCacheL(m_transaction->Request().URI().UriDes() );

    if( m_cacheSupply->StartRequestL( cacheMode ) != KErrNone ) {

        // check if the response must come from the cache

        if( cacheMode != TBrCtlDefs::ECacheModeOnlyCache ) {

            m_transaction->SubmitL();

        }

        else {

            // cache failed

            complete( KErrGeneral );

        }

    }

}

void HttpConnection::cancel()

{

    complete( KErrCancel );

}

void HttpConnection::download(WebCore::ResourceHandle* handle,

                              const WebCore::ResourceRequest& request,

                              const WebCore::ResourceResponse& response)

{

    StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager()->download(handle,

        request, response, this);

}

void HttpConnection::setDefersLoading(bool defers)

{

    if (m_receivedFinished && !m_receivedFinished->isDone()) {

        // Don't set defer loading when in ReceivedFinished process

        return;

    }

    if (defers) {

        if (m_defersData) {

            m_defersData ->Cancel(); // This would happen if we did not finish sending the accumulated content, and a second JavaScript dialog is displayed.

        } else {

            m_defersData = new DefersData(this, processDefersData);

        }

        if (m_cacheSupply) {

            m_cacheSupply->PauseSupply();

        }

    }

    else {

        if (m_defersData) {

            m_defersData->Activate();

        }

        if (m_cacheSupply) {

            m_cacheSupply->ResumeSupply();

        }

    }

}

void HttpConnection::handleError(int error)

{

    complete(error);

}

void HttpConnection::MHFRunL(const THTTPEvent &aEvent)

    {

    if (m_cancelled) {

        return;

        }

    __ASSERT_DEBUG( m_transaction, THttpConnUtils::PanicLoader( KErrArgument ) );

    // Using this flag to prevent caching of secure items

    TBool nonsecure = ETrue;

    TUriParser8 requestedParser;

    if(requestedParser.Parse(m_transaction->Request().URI().UriDes()) == KErrNone) {

        if( requestedParser.Extract( EUriScheme ).Compare(KHttps) == 0 ) {

            nonsecure = EFalse;

            }

        }

    switch( aEvent.iStatus )

        {

        case THTTPEvent::EGotResponseHeaders:

            {

            if ( nonsecure ) {

                // pass headers to the cache first

                TRAP_IGNORE(m_cacheSupply->HeadersReceivedL());

                }

            int httpStatus( m_transaction->Response().StatusCode() );

            if (httpStatus == KErrCompletion) {

                return;

            }

            // Add certificate only if https, and top level request

            if( m_handle->request().mainLoad() ) {

                if ( m_transaction->Request().URI().Extract( EUriScheme ).FindF( KHttps ) == 0 && !m_isInCache ) {

                    m_certInfo = new(ELeave)TCertInfo;

                    m_transaction->ServerCert( *m_certInfo );

                    }

                // certinfo will be set/overwritten only if top load request

                control(m_frame)->setCertInfo( m_certInfo );

            }

            // authentication

            bool handled( EFalse );

            //in case of bad Auth Header(aError = -7276), transaction is cancelled already in the filter,

            //should be passed to Error Handler, otherwise handle Auth request normally.

            if( ( httpStatus == 401 /*EHttpUnauthorized*/ ) ||

                ( httpStatus == 407 /*EHttpProxyAuthenticationRequired*/ ) )

                {

                // Move the transaction to the Auth queue,

                // and wait for Authentication callback

                // This is proventing the transaction from being deleted

                // in case the network dropped automatically for example

                // during the data call connection.

                m_transaction->Cancel();

                HttpSessionManager* httpSessionMgr = StaticObjectsContainer::instance()->resourceLoaderDelegate()->httpSessionManager();

                httpSessionMgr->removeRequest(this);

                httpSessionMgr->addAuthRequest(this, m_handle);

                TInt authRet = handleAuthRequestL( httpStatus );

                handled = (authRet == KErrNone);

                // trans is cancelled at this point. if

                // authentication is failed (not handled) then

                // just complete this transaction

                if( !handled )

                    {

                    //

                    complete( authRet );

                    return;

                    }

                }

            if ( !handled )

                {

                // url

                m_urlResponse = NULL;

                if(m_frag) {

                    m_urlResponse = HBufC8::NewL(m_transaction->Request().URI().UriDes().Length() + m_frag->Length() + 1);

                    TPtr8 responsePtr(m_urlResponse->Des());

                    responsePtr.Copy(m_transaction->Request().URI().UriDes());

                    responsePtr.Append(_L("#"));

                    responsePtr.Append(*m_frag);

                }

                else {

                    m_urlResponse = HBufC8::NewL(m_transaction->Request().URI().UriDes().Length());

                    m_urlResponse->Des().Copy(m_transaction->Request().URI().UriDes());

                }

                // content type

                THTTPHdrVal hdrVal;

                RHTTPHeaders httpHeaders = m_transaction->Response().GetHeaderCollection();

                RStringPool stringPool = m_transaction->Session().StringPool();

                const TStringTable& stringTable = RHTTPSession::GetTable();

                if( httpHeaders.GetField( stringPool.StringF( HTTP::EContentType, stringTable ), 0,

                    hdrVal) == KErrNone ) {

                    m_contentType = hdrVal.StrF().DesC().AllocL();

                }

                else {

                    m_contentType = KNullDesC8().AllocL();

                }

                // content encoding

                if( httpHeaders.GetParam( stringPool.StringF( HTTP::EContentType, stringTable ),

                    stringPool.StringF( HTTP::ECharset, stringTable ), hdrVal ) == KErrNone ) {

                    m_encoding = hdrVal.StrF().DesC().AllocL();

                }

                else {

                    m_encoding = KNullDesC8().AllocL();

                }

                // content length

                if( httpHeaders.GetField( stringPool.StringF( HTTP::EContentLength,

                    stringTable ), 0, hdrVal ) == KErrNone ) {

                    m_maxSize = hdrVal.Int();

                }

                String encoding;

                if (m_encoding && m_encoding->Length()) {

                    encoding = m_encoding->Des();

                }

                ResourceResponse response(m_urlResponse->Des(), m_contentType->Des(), m_maxSize, encoding, String() );

                response.setHTTPStatusCode(m_transaction->Response().StatusCode());

                //HTTP status text

                response.setHTTPStatusText(((m_transaction->Response()).StatusText().DesC()));

                if (m_contentType && m_contentType->Length()) {

                    response.setHTTPHeaderField("Content-Type", *m_contentType);

                }

				TPtrC8 result;

                if( httpHeaders.GetRawField( stringPool.StringF( HTTP::EContentDisposition, stringTable ), result) == KErrNone )

                	response.setHTTPHeaderField("Content-Disposition", result);

                if (m_handle->request().mainLoad()) {

                    if(m_handle->request().url() != response.url()) {

                        // Relative URLs are resolved based on the request URL, not response URL.

                        // If a redirect happens, the request URL must be updated.

                        m_handle->getInternal()->m_request.setURL(response.url());

                        m_frame->loader()->activeDocumentLoader()->request().setURL(response.url());

                    }

                    if(MultipartContentHandler::IsSupported(response)) {

                        m_IsMultipart = true;

                        m_MultipartContentHandler = MultipartContentHandler::NewL();

                        m_MultipartContentHandler->HandleResponseHeadersL(response, *m_transaction);

                        return;

                    }

                    if (UnknownContentHandler::isUnknownContent(response)) {

                        m_unknownContentHandler = UnknownContentHandler::NewL(this, response);

                        return;

                    }

                }

                // If loading is defered, don't send the headers now

                if (m_defersData) {

                    ResourceResponse* resp = new ResourceResponse(m_urlResponse->Des(), m_contentType->Des(), m_maxSize, encoding, String());

                    if (resp == NULL) {

                        complete(KErrNoMemory);

                    }

                    else {

                        m_defersData->m_response = resp;

                    }

                }

                else {

                    CResourceHandleManager::self()->receivedResponse(m_handle, response, this);

                }

                // transaction is complete (must have been cancelled in receivedResponse call

                if (m_isDone)

                    return;

                // transaction is taken, we need to cleanup this resource.

                if (!m_transaction) {

                    derefHandle();

                    // this object might be invalid at this point

                    return;

                    }

                }

            break;

        }

        case THTTPEvent::EGotResponseBodyData:

            {

            if ( nonsecure ) {

                // pass chunk to the cache first

                TRAP_IGNORE( m_cacheSupply->BodyReceivedL() );

                }

            MHTTPDataSupplier* body = m_transaction->Response().Body();

            // get it from the transaction

            TPtrC8 chunkPtr;

            body->GetNextDataPart( chunkPtr );

            m_accumulatedSize += chunkPtr.Length();

            if (chunkPtr.Length()) {

                if(m_IsMultipart) {

                    m_MultipartContentHandler->HandleResponseBodyL(chunkPtr);

                } else {

                    if (m_unknownContentHandler) {

                        m_unknownContentHandler->updateContentTypeL(chunkPtr);