// Copyright (c) 1998-2009 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:

// Purpose:  This file provides the definition of the CHTTPResponse class.

// The HTTP Response class encodes HTTP response headers only. It

// contains the methods used to transcode from WSP->HTTP fields

//

// System includes

//

#include <wspdecoder.h>

#include <chttpresponse.h>

// Wap Logging

//

#include <waplog.h>

#include <logdef.h>

const TUint8 KWapQuote = 0x7F;

const TUint8 KTop3BitSet = 0x70;

const TUint8 KCarryBitMask = 0x80;

// Default MIME type is text/plain if we can't identify any other

//

static const TText8* const defaultType = _S8("application/octet-stream");

// Implementation of CHTTPResponse class

//

// Factory method to construct this class.

//

// Rtn: a new CHTTPResponse object, by ptr. Ownership is transferred to the

//      caller.

//

EXPORT_C CHTTPResponse* CHTTPResponse::NewL()

	{

	CHTTPResponse* me = new(ELeave)CHTTPResponse();

	CleanupStack::PushL(me);

	me->ConstructL();

	CleanupStack::Pop();

	return me;

	}

// Destructor for this class. Removes this object and releases memory held

// by it

//

EXPORT_C CHTTPResponse::~CHTTPResponse()

    {

    Reset();

	__CLOSE_LOG;

    }

// Clean out the fields buffer

//

EXPORT_C void CHTTPResponse::Reset()

    {

	__LOG_ENTER(_L("CHTTPResponse::Reset"));

    delete iResponse;

    iResponse = NULL;

	__LOG_RETURN;

    }

// Set the fields buffer with the response received from the WAP Stack

//

// In:

//  aResponse - an 8-bit descriptor field containing the origin server's

//				WSP-encoded response header. Ownership is transferred to

//				this class.

//

EXPORT_C void CHTTPResponse::AddResponse(HBufC8* aResponse)

    {

	__LOG_ENTER(_L("CHTTPResponse::AddResponse"));

    delete iResponse;

    iResponse = aResponse;

#ifdef _DEBUG

	DumpToLog(*aResponse);

#endif

	__LOG_RETURN;

    }

// Accessor to the HTTP response fields buffer

//

// Rtn: a reference to the response. Ownership is _NOT_ transferred

//

// NOTE THIS SHOULD RETURN CONST - BUT CAN'T BE CHANGED SINCE IT WOULD

// BREAK BC.

EXPORT_C HBufC8& CHTTPResponse::Response() const

    {

	__LOG_ENTER(_L("CHTTPResponse::Response"));

	__LOG_RETURN;

    return *iResponse;

    }

// Accessor to the HTTP status code (e.g. 400, 300, 200, 500)

//

// Rtn: the status code - series number only.

//

EXPORT_C THttpStatusCode CHTTPResponse::StatusCode() const

    {

	__LOG_ENTER(_L("CHTTPResponse::StatusCode"));

	__LOG_RETURN;

    return iStatusCode;

    }

// Accessor to the HTTP detailed status code (e.g. 404, 304, 200, 501)

//

// Rtn: the status code - series and specific code value

//

EXPORT_C THttpStatusCode CHTTPResponse::DetailedStatusCode() const

    {

	__LOG_ENTER(_L("CHTTPResponse::DetailedStatusCode"));

	__LOG_RETURN;

    return iDetailedStatusCode;

    }

// Accessor to set the HTTP response status.

//

// In:

//  aCode - the WSP-encoded status code

//

EXPORT_C void CHTTPResponse::SetStatusCode(TInt aCode)

    {

//	__LOG_ENTER(_L("CHTTPResponse::SetStatusCode"));

//	__LOG1(_L("CHTTPResponse::SetStatusCode : 'aCode' = %d"), aCode);

	// Set iDetailedStatusCode to a default

    iDetailedStatusCode = EHttpUnknown;

    // Magic no.s come from the WAP WSP specification, Appendix A, Table 36

    switch (aCode)

        {

    case 0x10:

        iStatusCode = EHttpContinue;

        break;

    case 0x11:

        iDetailedStatusCode = EHttpSwitchingProtocols;

        iStatusCode = EHttpContinue;

        break;

    case 0x20:

        iStatusCode = EHttpOK;

        break;

    case 0x21:

        iDetailedStatusCode = EHttpCreated;

        iStatusCode = EHttpOK;

        break;

    case 0x22:

        iDetailedStatusCode = EHttpAccepted;

        iStatusCode = EHttpOK;

        break;

    case 0x23:

        iDetailedStatusCode = EHttpNonAuthorativeInformation;

        iStatusCode = EHttpOK;

        break;

    case 0x24:

        iDetailedStatusCode = EHttpNoContent;

        iStatusCode = EHttpOK;

        break;

    case 0x25:

        iDetailedStatusCode = EHttpResetContent;

        iStatusCode = EHttpOK;

        break;

    case 0x26:

        iDetailedStatusCode = EHttpPartialContent;

        iStatusCode = EHttpOK;

        break;

    case 0x30:

        iStatusCode = EHttpMultipleChoices;

        break;

    case 0x31:

        iDetailedStatusCode = EHttpMovedPermanently;

        iStatusCode = EHttpMultipleChoices;

        break;

    case 0x32:

        iDetailedStatusCode = EHttpMovedTemporarily;

        iStatusCode = EHttpMultipleChoices;

        break;

    case 0x33:

        iDetailedStatusCode = EHttpSeeOther;

        iStatusCode = EHttpMultipleChoices;

        break;

    case 0x34:

        iDetailedStatusCode = EHttpNotModified;

        iStatusCode = EHttpMultipleChoices;

        break;

    case 0x35:

        iDetailedStatusCode = EHttpUseProxy;

        iStatusCode = EHttpMultipleChoices;

        break;

    case 0x40:

        iStatusCode = EHttpBadRequest;

        break;

    case 0x41:

        iDetailedStatusCode = EHttpUnauthorized;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x42:

        iDetailedStatusCode = EHttpPaymentRequired;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x43:

        iDetailedStatusCode = EHttpForbidden;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x44:

        iDetailedStatusCode = EHttpNotFound;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x45:

        iDetailedStatusCode = EHttpMethodNotAllowed;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x46:

        iDetailedStatusCode = EHttpNotAcceptable;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x47:

        iDetailedStatusCode = EHttpProxyAuthenticationRequired;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x48:

        iDetailedStatusCode = EHttpRequestTimeout;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x49:

        iDetailedStatusCode = EHttpConflict;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x4a:

        iDetailedStatusCode = EHttpGone;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x4b:

        iDetailedStatusCode = EHttpLengthRequired;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x4c:

        iDetailedStatusCode = EHttpPreconditionFailed;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x4d:

        iDetailedStatusCode = EHttpRequestEntityTooLarge;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x4e:

        iDetailedStatusCode = EHttpRequestURITooLong;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x4f:

        iDetailedStatusCode = EHttpUnsupportedMediaType;

        iStatusCode = EHttpBadRequest;

        break;

    case 0x60:

        iStatusCode = EHttpInternalServerError;

        break;

    case 0x61:

        iDetailedStatusCode = EHttpNotImplemented;

        iStatusCode = EHttpInternalServerError;

        break;

    case 0x62:

        iDetailedStatusCode = EHttpBadGateway;

        iStatusCode = EHttpInternalServerError;

        break;

    case 0x63:

        iDetailedStatusCode = EHttpServiceUnavailable;

        iStatusCode = EHttpInternalServerError;

        break;

    case 0x64:

        iDetailedStatusCode = EHttpGatewayTimeout;

        iStatusCode = EHttpInternalServerError;

        break;

    case 0x65:

        iDetailedStatusCode = EHttpHTTPVersionNotSupported;

        iStatusCode = EHttpInternalServerError;

        break;

    default:

        iStatusCode = EHttpUnknown;

        break;

        }

    if (iDetailedStatusCode == EHttpUnknown)

        iDetailedStatusCode = iStatusCode;

//	__LOG1(_L("CHTTPResponse::SetStatusCode : status code = %d"), iStatusCode);

//	__LOG1(_L("CHTTPResponse::SetStatusCode : detailed status code = %d"), iDetailedStatusCode);

//	__LOG_RETURN;

    }

// Method to find a named field, that returns null terminated 

// WSP text strings. Note that there is no checking that it is a text string

// which follows.

//

// In:

//  aField		- the field type

//  aStartIndex	- the index to search from (defaults to the buffer start)

//

// Out:

//  aDesc - a pointer-type descriptor into the response buffer at the

//			position where the field was located. The caller must NOT

//			modify the descriptor contents

//

// Rtn: TBool - set to ETrue if the field was found, EFalse otherwise

//

EXPORT_C TBool CHTTPResponse::FindField(THttpHeaderField aField,

							   TPtrC8& aDesc,

							   TInt aStartIndex) const

    {

//	__LOG_ENTER(_L("CHTTPResponse::FindField (string)"));

//	__LOG1(_L("CHTTPResponse::FindField : searching for field type = %d"), aField);

    TInt index = LocateField(aField, aStartIndex);

    if (index >0)

        {

        TInt count = 0;

        for (count = index; (count < iResponse->Length()) &&

			(iResponse->Des()[count] != 0); count++) {};

        if (count <= iResponse->Length())

            {

            aDesc.Set(&(iResponse->Des()[index]), count-index);

//			__LOG(_L("CHTTPResponse::FindField : found string:"));

#ifdef _DEBUG

			DumpToLog(aDesc);

#endif

//			__LOG_RETURN;

            return ETrue;

            }

        }

//	__LOG(_L("CHTTPResponse::FindField : nothing found"));

//	__LOG_RETURN;

    return EFalse;

    }

// Method to find a named field, that returns 8-bit octet data (binary

// or strings - not stipulated which).

//

// In:

//  aField		- the field type

//  aStartIndex	- the index to search from (defaults to the buffer start)

//

// Out:

//  aDesc - a pointer-type descriptor into the response buffer at the

//			position where the field was located. The caller must NOT

//			modify the descriptor contents

//

// Rtn: TBool - set to ETrue if the field was found, EFalse otherwise

//

EXPORT_C TBool CHTTPResponse::FindBinaryDescField(THttpHeaderField aField,

										 TPtrC8& aDesc,

										 TInt aStartIndex) const

    {

    TInt index = LocateField(aField, aStartIndex);

    if (index >= 0)

        {

		TInt offset = 0;

		TInt fieldLength = iResponse->Des()[index];	// assume the length is in

													// a short integer

		if(fieldLength == 31)

			{

			// Nope : Code 31 indicates that the following bytes make a

			// UIntVar,  which indicates the number of data octets after it. 

			// The UIntVar itself could be composed of upto 5 bytes

			// Copy a full 5 bytes from the header

			// Note that actually fewer might have been used; 

			// the UIntVar to Int converter function returns the exact number 

			// that were used.

			TInt consumed = ParseUIntVar(iResponse->Des().Mid(index + 1), fieldLength);

			__ASSERT_DEBUG( consumed >= KErrNone, User::Invariant() );

			offset += consumed;			

			}

        else if (fieldLength > 127)

			{

 			// Oops be sneaky and reuse this single byte

 			// Because this is a special code

 			fieldLength = 1;		

 			offset = -1;

 			}

		if(fieldLength)

            {

            aDesc.Set(&(iResponse->Des()[index + offset + 1]), fieldLength);

#ifdef _DEBUG

			DumpToLog(aDesc);

#endif

            return ETrue;

            }

        }

    return EFalse;

    }

// Method to find a named field, that returns an EPOC date/time structure.

//

// In:

//  aField		- the field type

//  aStartIndex	- the index to search from (defaults to the buffer start)

//

// Out:

//  aTime - a structure containing the time (and date) found in the header

//

// Rtn: TBool - set to ETrue if the field was found, EFalse otherwise

//

EXPORT_C TBool CHTTPResponse::FindField(THttpHeaderField aField,

							   TTime& aTime,

							   TInt aStartIndex) const

    {

	__LOG_ENTER(_L("CHTTPResponse::FindField (time)"));

	TBool result = EFalse;

    TInt index = LocateField(aField, aStartIndex);

    if (index > 0)

        {

 		TPtr8 respChars  = iResponse->Des();

   		ExtractFieldDateValue(respChars,index,aTime);

		result = ETrue;

        }

	__LOG_RETURN;

    return result;

    }

// Method to find a named field within the Cache Control header

//

// In:

//  aField		- the field type

//

// Out:

//

// Rtn: TBool - set to ETrue if the field was found, EFalse otherwise

//

EXPORT_C TBool CHTTPResponse::FindCacheControlFieldValue(TCacheControlFieldValue aField) const

	{

	TPtrC8 cacheControl;

	return FindCacheControlFieldValue(aField,cacheControl) != KErrNotFound;

	}

// Method to find a named field within the Cache Control header, 

// that returns an EPOC date/time structure.

//

// In:

//  aField		- the field type

//

// Out:

//  aTime - a structure containing the time (and date) found in the header

//			field

//

// Rtn: TBool - set to ETrue if the field was found, EFalse otherwise

//

EXPORT_C TBool CHTTPResponse::ExtractCacheControlTime(TCacheControlFieldValue aField,

											 TTime& aTime) const

	{

	__LOG_ENTER(_L("CHTTPResponse::ExtractCacheControlTime"));

	__ASSERT_DEBUG(aField == ECacheCtrlMaxAge || aField == ECacheCtrlMaxStale

						|| aField == ECacheCtrlMinFresh, User::Invariant());

	TBool result = EFalse;

	TPtrC8 cacheControl;

	aTime = 0;

	TInt index = FindCacheControlFieldValue(aField, cacheControl);

	if(index != KErrNotFound)

		{

		// Have the cache control and the field position

		// Now we need to extract the field's delta-secs value

		index++;

		TInt time = 0;

		TPtrC8 integerSource = cacheControl.Mid(index);

		if(integerSource[0] >= 0x80)			// Short integer value

			time = integerSource[0] & 0x7F;

		else								// Otherwise its multi octet

			ExtractMultiOctetInteger(time, integerSource);

		TTimeIntervalSeconds timeSeconds(time);

		aTime += timeSeconds;			// Store the seconds in the time field

		result = ETrue;

		}

	__LOG_RETURN;

	return result;

	}

// Method to search for the content type encoded in the response header

//

// Out:

//  aDesc - a pointer-type descriptor into the appropriate element of an

//			array prefilled with all the content types that have WSP

//			encodings. e.g. "text/vnd.wap.wml".  The contents of the

//			descriptor must NOT be modified.

//

EXPORT_C void CHTTPResponse::ContentType(TPtrC8& aDesc) const

    {