/*
* Copyright (c) 2003 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:  C interface to url loader
*
*/


// INCLUDE FILES
#include <e32std.h>
#include <e32base.h>
#include "urlloader_urlloaderi.h"
#include "urlloader_CUrlLoader.h"
#include "urlloader_loaderutils.h"
#include "httploader_mlinkresolvercallbacks.h"
#include "nwx_defs.h"
#include "nwx_ctx.h"
#include <uri16.h>
#include "BrsrStatusCodes.h"

//R
//#include "httploadereventtouilistener.h"

//lint -save -e774 Boolean within 'if' always evaluates to True

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS
_LIT(KSchemeHttps, "https");
_LIT(KSchemeFile, "file");
_LIT(KSchemeHttp, "http");


// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS
#ifdef __cplusplus
extern "C" {
#endif


#ifdef __cplusplus
} // extern "C"
#endif

// ============================= LOCAL FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CKHttpLoader::UrlLoader_GetUrlLoader
// Get a pointer to the url loader.
// -----------------------------------------------------------------------------
//
static CKUrlLoader* UrlLoader_GetUrlLoader()
{
    return (CKUrlLoader*)NW_Ctx_Get(NW_CTX_URL_LOADER, 0);
}


// -----------------------------------------------------------------------------
// CKHttpLoader::UrlLoader_HttpRequestHeadersNewL
// Create a HttpHeaders structure with some or all of the following arguments.
// Each field can contain a value, or can be NULL
// -----------------------------------------------------------------------------
//
static HttpRequestHeaders* UrlLoader_HttpRequestHeadersNewL(const TUint8* aAccept,
                                                            const TUint8* aContentType,
                                                            const TUint16* aReferer,
                                                            const TUint8* aBoundary,
                                                            TUint aContentLength,
                                                            const TUint8* aExpectedContentType)
{
    TUint8* accept = NULL;
    TUint8* contentType = NULL;
    TUint8* referer = NULL;
    TUint8* boundary = NULL;
    TUint8* expectedContentType = NULL;
    TInt pushed = 0;
    HttpRequestHeaders* headers = NULL;
    // If accept header is set, allocate and copy it
    if (aAccept != NULL)
    {
        accept = new TUint8 [User::StringLength(aAccept) + 1];
        User::LeaveIfNull(accept);
        Mem::Copy(accept, aAccept, User::StringLength(aAccept) + 1);
        CleanupStack::PushL(accept);
        pushed++;
    }

    // If contentType header is set, allocate and copy it
    if (aContentType != NULL)
    {
        contentType = new TUint8 [User::StringLength(aContentType) + 1];
        User::LeaveIfNull(contentType);
        Mem::Copy(contentType, aContentType, User::StringLength(aContentType) + 1);
        CleanupStack::PushL(contentType);
        pushed++;
    }

    // If referer header is set, allocate and copy it
    if (aReferer != NULL)
    {
        TUint refererLength = User::StringLength(aReferer) + 1;
        TPtrC16 referer16(aReferer);
        TPtr8 referer8(NULL, 0);
        referer = new TUint8 [refererLength];
        User::LeaveIfNull(referer);
        CleanupStack::PushL(referer);
        pushed++;

        referer8.Set(referer, 0, refererLength);
        referer8.Copy(referer16);
        referer8.ZeroTerminate();
    }

    // If the boundary for multipart is set, allocate and copy it
    if (aBoundary != NULL)
    {
        boundary = new TUint8 [User::StringLength(aBoundary) + 1];
        User::LeaveIfNull(boundary);
        Mem::Copy(boundary, aBoundary, User::StringLength(aBoundary) + 1);
        CleanupStack::PushL(boundary);
        pushed++;
    }
        
    // If expectedContentType header is set, allocate and copy it
    if (aExpectedContentType != NULL)
    {
        expectedContentType = new TUint8 [User::StringLength(aExpectedContentType) + 1];
        User::LeaveIfNull(expectedContentType);
        Mem::Copy(expectedContentType, aExpectedContentType, User::StringLength(aExpectedContentType) + 1);
        CleanupStack::PushL(expectedContentType);
        pushed++;
    }
    headers = new(ELeave) HttpRequestHeaders;
    headers->accept = accept;
    headers->contentType = contentType;
    headers->referer = referer;
    headers->boundary = boundary;
    headers->contentLength = aContentLength;
    headers->expectedContentType = expectedContentType;
    CleanupStack::Pop(pushed);
    return headers;
}

// ========================== OTHER EXPORTED FUNCTIONS =========================
#ifdef __cplusplus
extern "C" {
#endif



// -----------------------------------------------------------------------------
// UrlLoader_Shutdown
// Free the loaders and close the session to the http stack.
// -----------------------------------------------------------------------------
//
void UrlLoader_Shutdown()
{
    CKUrlLoader* urlLoader = UrlLoader_GetUrlLoader();

    if (urlLoader != NULL)
    {
        delete urlLoader;
        NW_Ctx_Set(NW_CTX_URL_LOADER, 0, NULL);
    }
}


// -----------------------------------------------------------------------------
// UrlLoader_Request
// Make a load request to the loaders.
// -----------------------------------------------------------------------------
//
TBrowserStatusCode UrlLoader_Request(const NW_Ucs2* aUrl, void* aHeader,
                                     NW_Uint8* aData, NW_Uint32 aDataLen,
                                     NW_Uint8 aMethod, NW_Uint16* aTransId,
                                     void* aLoadContext,
                                     NW_Url_RespCallback_t* aLoadCallback,
                                     NW_Cache_Mode_t aCacheMode,
                                     NW_Uint32 aDefaultHeadersMask,
                                     NW_Uint8 loadType,
                                     NW_Bool aIsTopLevel,
                                     NW_Bool aIsScript,
                                     NW_Uint8 aReason,
                                     void* aLoadData)
    {
    CKUrlLoader* urlLoader = UrlLoader_GetUrlLoader();
    TBrowserStatusCode status = KBrsrFailure;
    __ASSERT_DEBUG(urlLoader != NULL, LoaderUtils::PanicLoader());
    
    
    if (urlLoader != NULL)
        {
        status = urlLoader->LoadRequest(aUrl, aHeader, aData, aDataLen,
                                        aMethod, aTransId, aLoadContext,
                                        aLoadCallback, aCacheMode,
                                        aDefaultHeadersMask,
                                        loadType, aIsTopLevel, aIsScript,
                                        aReason, aLoadData);
        if (status != KBrsrSuccess)
            {
            if ((aDataLen > 0) && (aData != NULL))
                {
                delete [] aData;
                }
            UrlLoader_HeadersFree(aHeader);
            }
        }

    return status;
    }


// -----------------------------------------------------------------------------
// UrlLoader_HeadersNew
// Create a HttpHeaders structure with some or all of the following arguments.
// Each field can contain a value, or can be NULL
// -----------------------------------------------------------------------------
//
void* UrlLoader_HeadersNew(const NW_Uint8* aAccept,
                           const NW_Uint8* aContentType,
                           const NW_Ucs2* aReferer,
                           const NW_Uint8* aBoundary,
                           NW_Uint32 aContentLength,
                           const NW_Uint8* aExpectedContentType)
{
    TInt ret = KErrNone;
    HttpRequestHeaders* headers = NULL;
    TRAP(ret, headers = UrlLoader_HttpRequestHeadersNewL(aAccept,
														 aContentType,
														 aReferer,
														 aBoundary,
														 aContentLength,
                                                         aExpectedContentType));
    if (ret == KErrNone)
	{
        return headers;
	}

    return NULL;
}


// -----------------------------------------------------------------------------
// UrlLoader_HeadersFree
// Free the headers structure.
// -----------------------------------------------------------------------------
//
void UrlLoader_HeadersFree(void* aHeaders)
{
    if (aHeaders != NULL)
    {
        HttpRequestHeaders* headers = (HttpRequestHeaders*)aHeaders;
        delete [] headers->accept;
        delete [] headers->contentType;
        delete [] headers->referer;
        delete [] headers->boundary;
        delete headers;
    }
}


// -----------------------------------------------------------------------------
// UrlLoader_HeadersCopy
// Copy the headers structure.
// -----------------------------------------------------------------------------
//
void* UrlLoader_HeadersCopy(const void* aHeaders)
{
    if (aHeaders == NULL)
	{
        return NULL;
    }
	
	HttpRequestHeaders* newHeaders = NULL;

    HttpRequestHeaders* headers = (HttpRequestHeaders*)aHeaders;

    newHeaders = (HttpRequestHeaders*)UrlLoader_HeadersNew(headers->accept,
														   headers->contentType,
														   NULL,
														   headers->boundary,
														   headers->contentLength,
                                                           headers->expectedContentType);
    if (headers->referer != NULL)
    {
        newHeaders->referer =
				new TUint8 [User::StringLength(headers->referer) + 1];
        
		if (newHeaders->referer != NULL)
        {
            Mem::Copy(newHeaders->referer, headers->referer,
					  User::StringLength(headers->referer) +1);
        }
        else
        {
            UrlLoader_HeadersFree(newHeaders);
            newHeaders = NULL;
        }
    }
    return newHeaders;
}



// -----------------------------------------------------------------------------
// GetFlags
// Local helper function for UrlLoader_UpdateSecurityStatus.
// Gets the flags on urlLoader->iSecureFlag.
// Finds if a security note is needed and displays it
// -----------------------------------------------------------------------------
//
void GetFlags(TUint   aSecurityFlag,
			  TUint8* aIsPrevTopLevelSecure,
              TUint8* aIsCurrentTopLevelSecure,
			  TUint8* aWasNoteDisplayedForThisTopLevel,
              TUint8* aWasNoteAcceptedForThisTopLevel)
    {
    __ASSERT_DEBUG(aIsPrevTopLevelSecure != NULL, LoaderUtils::PanicLoader());
    __ASSERT_DEBUG(aIsCurrentTopLevelSecure != NULL, LoaderUtils::PanicLoader());
    __ASSERT_DEBUG(aWasNoteDisplayedForThisTopLevel != NULL,
                   LoaderUtils::PanicLoader());
    __ASSERT_DEBUG(aWasNoteAcceptedForThisTopLevel != NULL,
                   LoaderUtils::PanicLoader());
    
    *aIsPrevTopLevelSecure = (TUint8)(aSecurityFlag & 0xFF);
    *aIsCurrentTopLevelSecure = (TUint8)((aSecurityFlag >> 8) & 0xFF);
    *aWasNoteDisplayedForThisTopLevel = (TUint8)((aSecurityFlag >> 16) & 0xFF);
    *aWasNoteAcceptedForThisTopLevel = (TUint8)((aSecurityFlag >> 24) & 0xFF);
    }




// -----------------------------------------------------------------------------
// UrlLoader_InitializeL
// Header: urlloader_urloaderi.h
// Initialize the loaders
// -----------------------------------------------------------------------------
//
void UrlLoader_InitializeL(MBrCtlSpecialLoadObserver* aSpecialLoadObserver,
						   MHttpLoader_LinkResolverCallbacks* aLinkCallbacks,
						   MWmlInterface* aWKWmlInterface)
    {
    CKUrlLoader* urlLoader = NULL;
    urlLoader = CKUrlLoader::NewL(aSpecialLoadObserver, aLinkCallbacks,aWKWmlInterface);
    NW_Ctx_Set(NW_CTX_URL_LOADER, 0, urlLoader);
    }


// -----------------------------------------------------------------------------
// IsSubmit
// Description: Determines if the load is a result of sumbit or not.
//				Local helper function for HandleTopLevelSecurityStateChange.
//                
// Parameters:   *aUrl                 - pointer to the url to load
//               aMethod               - post or get
//               aIsTopLevel           - is top level request or not
//               aHasHeaders           - a flag is the request contains hedears
//
// Return Value: EFalse 
//               ETrue 
// -----------------------------------------------------------------------------
//
NW_Bool IsSubmit(const NW_Ucs2 *aUrl, NW_Uint8 aMethod,
				 NW_Bool aIsTopLevel, NW_Bool aHasHeaders)
{
    __ASSERT_DEBUG(aUrl != NULL, LoaderUtils::PanicLoader());
	if (aUrl == NULL)
	{
		return EFalse;
	}

	TPtrC urlPtr(aUrl);
	if (aIsTopLevel)
	{
		if (aMethod == NW_URL_METHOD_POST || (aHasHeaders && urlPtr.Locate('?')))
		{
			return ETrue;
		}
	}

	return EFalse;
}



// -----------------------------------------------------------------------------
// UrlLoader_FindUrlScheme
// Determine the scheme of the url.
// -----------------------------------------------------------------------------
//
TUrlLoaderScheme UrlLoader_FindUrlScheme(const NW_Ucs2* aUrl)
    {
    if (aUrl == NULL)
        {
        return ESchemeInvalid;
        }
    
    TUriParser parser;
    TPtrC uriPtr(aUrl);
    if (parser.Parse(uriPtr) != KErrNone)
        {
        return ESchemeInvalid;
        }
    
    if (!parser.IsSchemeValid())
        {
        return ESchemeInvalid;
        }
    
    TPtrC schemePtr(parser.Extract(EUriScheme));
    TInt schemeLength = schemePtr.Length();
    
    // HTTP scheme is the default
    if (schemeLength == 0)
        {
        return ESchemeHttp;
        }
    
    // Identify the scheme
    if (schemeLength == KSchemeHttp().Length() &&
        uriPtr.FindF(KSchemeHttp) == 0)
        {
        return ESchemeHttp;
        }

    if (schemeLength == KSchemeHttps().Length() &&
        uriPtr.FindF(KSchemeHttps) == 0)
        {
        return ESchemeHttps;
        }
    
    if (schemeLength == KSchemeFile().Length() &&
        uriPtr.FindF(KSchemeFile) == 0)
        {
        return ESchemeFile;
        }
    
    return ESchemeUnknown;
    }


// -----------------------------------------------------------------------------
// UrlLoader_IsBrowserScheme
// Determine if the url is handled by the browser.
// -----------------------------------------------------------------------------
//
NW_Bool UrlLoader_IsBrowserScheme(const NW_Ucs2* aUrl)
    {
    TUrlLoaderScheme urlScheme = UrlLoader_FindUrlScheme(aUrl);
    
    return (urlScheme != ESchemeUnknown);
    }

// -----------------------------------------------------------------------------
// UrlLoader_IsUrlInCache
// Check if a specific url is in cache.
// -----------------------------------------------------------------------------
//
NW_Bool UrlLoader_IsUrlInCache(NW_Ucs2* aUrl)
    {
    NW_Bool ret = NW_FALSE;
    CKUrlLoader* urlLoader = UrlLoader_GetUrlLoader();
    
    if (urlLoader )
        {
        ret = (NW_Bool)urlLoader->IsUrlInCache(aUrl);
        }
    
    return ret;
    }

#ifdef __cplusplus
} /* extern "C" */
#endif

//lint -restore

//  End of File
