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

//

#include <es_sock.h>

#include <utf.h>

#include "pbapappheader.h"

#include "btaccesshostlog.h"

/*static*/ CPbapAppHeader* CPbapAppHeader::NewL()

	{

	LOG_STATIC_FUNC

	return new(ELeave) CPbapAppHeader;

	}

CPbapAppHeader::CPbapAppHeader()

	{

	LOG_FUNC

	Reset();

	}	

CPbapAppHeader::~CPbapAppHeader()

	{

	LOG_FUNC

	iSearchValue.Close();

	}	

/**

Set values to defaults defined in the PBAP specification

*/

void CPbapAppHeader::Reset()

	{

	LOG_FUNC

	iTagsPresent.Reset();

	iMaxListCount = KMaxTUint16;

	iListStartOffset = 0;

	iAttributeMask = SymbianPBAP::KPbapAttributeAll;

	iVCardVersion = EPBAPVCard21;

	iOrder = SymbianPBAP::EIndexed;

	iSearchValue.Close();

	iSearchAttribute = SymbianPBAP::EName;

	iOperation = EUnknownOperation;

	iIsAbsolutePathOp = EFalse;

	}

/**

Parse the application parameters header for the underlying "PBAP PDU"

this PBAP "PDU" is composed of the TLVs in the App Params Header

*/

void CPbapAppHeader::ParseL(const TDesC8& aObexApplicationHeader)

	{

	LOG_FUNC

	if (aObexApplicationHeader!=KNullDesC8)

		{

		TUint8 parseIndex = 0;		

		TUint8 appHeaderLength = aObexApplicationHeader.Length();

		while (parseIndex < appHeaderLength)

			{

			// get 'tag' from the header

			TApplicationHeaderTagId tag = static_cast<TApplicationHeaderTagId>(aObexApplicationHeader[parseIndex]);

			// check weather  'length' is present, then get 'length'

			if(++parseIndex == appHeaderLength)

				{

				User::Leave(KErrArgument);

				}

			TUint8 length = static_cast<TUint8>(aObexApplicationHeader[parseIndex]);

			// check weather 'length' is longer than the remaining header

			if (appHeaderLength-parseIndex <= length)

				{

				User::Leave(KErrArgument);

				}

			TPtrC8 nextValue = aObexApplicationHeader.Mid(++parseIndex,length);

			if (nextValue.Length() != length)

				{

				User::Leave(KErrArgument);

				}

			switch (tag)

				{

				case EOrder:

					{	

					LOG(_L("Order tag present"));

					// check whether the parameters header is valid

					if (length!=1)

						{

						User::Leave(KErrArgument);

						}

					iOrder = ConvertToOrder(nextValue[0]);

					LOG1(_L("Order = %d"), iOrder);

					if (iOrder == SymbianPBAP::EUnknownOrder)

						{

						User::Leave(KErrArgument);

						}

					}

					break;

				case ESearchValue:

					{

					LOG(_L("SearchValue tag present"));			

					// the search string may have a null terminator, if so remove it

					TPtrC8 searchValue(nextValue);

					if (length && searchValue[length-1]=='\0')

						{

						LOG(_L("Removing null terminator from search value"));	

						searchValue.Set(searchValue.Left(length-1));

						}

					// convert the search string from UTF-8 to unicode

					iSearchValue.Assign(CnvUtfConverter::ConvertToUnicodeFromUtf8L(searchValue)); // ownership transferred

					LOG1(_L("SearchValue = %S"), &iSearchValue);

					}

					break;

				case ESearchAttribute:

					{

					LOG(_L("SearchAttribute tag present"));

					if (length!=1)

						{

						User::Leave(KErrArgument);

						}

					iSearchAttribute = ConvertToSearchAttribute(nextValue[0]);

					LOG1(_L("SearchAttribute = %d"), iSearchAttribute);	

					if (iSearchAttribute == SymbianPBAP::EUnknownSearchAttribute)

						{

						User::Leave(KErrArgument);

						}

					}

					break;

				case EMaxListCount:

					{

					LOG(_L("MaxListCount tag present"));

					if (length!=2)

						{

						User::Leave(KErrArgument);

						}

					iMaxListCount = BigEndian::Get16(nextValue.Ptr());

					LOG1(_L("MaxListCount=%d"), iMaxListCount);

					}

					break;

				case EListStartOffset:

					{

					LOG(_L("ListStartOffset tag present"));

					if (length!=2)

						{

						User::Leave(KErrArgument);

						}

					iListStartOffset = BigEndian::Get16(nextValue.Ptr());

					LOG1(_L("ListStartOffset = %d"), iListStartOffset);

					}

					break;

				case EFilter:

					{

					LOG(_L("Filter tag present"));

					if (length!=8)

						{

						User::Leave(KErrArgument);

						}					

					iAttributeMask = ConvertToFilter(nextValue.Ptr());

					LOG1(_L("Filter tag = %d"), iAttributeMask);

					}

					break;

				case EFormat:

					{

					LOG(_L("Format tag present"));

					if (length!=1)

						{

						User::Leave(KErrArgument);

						}

					iVCardVersion = ConvertToVCardVersionL(nextValue[0]);

					LOG1(_L("vCard version = %d"), iVCardVersion);			

					}

					break;

				default:

					// ignore unknown tag

					break;

				}

			// completely ignore any unspecified tags

			if (tag < EBeginningOfUnspecifiedTags && tag > 0)

				{

				iTagsPresent[tag] = ETrue;

				}

			parseIndex+=length;

			}

		}

	}

/**

 convert sort order parameter values defined in PBAP specification to internal enum

*/

SymbianPBAP::TOrder CPbapAppHeader::ConvertToOrder(TUint8 aValue) const

	{

	LOG_FUNC

	SymbianPBAP::TOrder order;

	switch (aValue)

		{

		case 0x00:

			order = SymbianPBAP::EIndexed;

			break;

		case 0x01:

			order = SymbianPBAP::EAlphabetical;

			break;

		case 0x02:

			order = SymbianPBAP::EPhonetical;

			break;

		default:

			order = SymbianPBAP::EUnknownOrder;

			break;	

		}

	return order;

	}

/**

 convert search attribute parameter values defined in PBAP specification to internal enum

*/

SymbianPBAP::TSearchAttribute CPbapAppHeader::ConvertToSearchAttribute(TUint8 aValue) const

	{

	LOG_FUNC

	SymbianPBAP::TSearchAttribute searchAttrib;

	switch (aValue)

		{

		case 0x00:

			searchAttrib = SymbianPBAP::EName;

			break;

		case 0x01:

			searchAttrib = SymbianPBAP::ENumber;

			break;

		case 0x02:

			searchAttrib = SymbianPBAP::ESound;

			break;

		default:

			searchAttrib = SymbianPBAP::EUnknownSearchAttribute;

			break;	

		}

	return searchAttrib;

	}

/**

 convert format parameter values defined in PBAP specification to internal enum

*/	

TVCardVersion CPbapAppHeader::ConvertToVCardVersionL(TUint8 aValue) const

	{

	LOG_FUNC

	TVCardVersion version = EPBAPVCard21;

	switch (aValue)

		{

		case 0x00:

			version = EPBAPVCard21;

			break;

		case 0x01:

			version = EPBAPVCard30;

			break;

		default:

			User::Leave(KErrArgument);

			break;	

		}

	return version;

	}

/** 

 Converts big-endian formatted descriptor to 64-bit filter mask

*/

TUint64 CPbapAppHeader::ConvertToFilter(const TUint8* aPtr) const

	{

	LOG_FUNC

	return ((static_cast<TUint64>(aPtr[0])<<56) |

			(static_cast<TUint64>(aPtr[1])<<48) |

			(static_cast<TUint64>(aPtr[2])<<40) |

			(static_cast<TUint64>(aPtr[3])<<32) |

			(static_cast<TUint64>(aPtr[4])<<24) |

			(static_cast<TUint64>(aPtr[5])<<16) |

			(static_cast<TUint64>(aPtr[6])<<8)  |

			(static_cast<TUint64>(aPtr[7]))); 	

	}

/**

Determine the actual PBAP operation from the type header and the parsed

application parameter header 

*/		

TPbapOperation CPbapAppHeader::DeterminePBAPOperationL(const TDesC8& aTypeHeader)

	{

	LOG_FUNC

#ifdef __FLOG_ACTIVE

	RBuf buf;

	buf.CreateL(aTypeHeader.Length());

	buf.Copy(aTypeHeader);

	LOG1(_L("Type header: %S"), &buf);

	buf.Close();

#endif

	TPtrC8 typeHeader(aTypeHeader);

	TInt length = aTypeHeader.Length();

	// obex may append null terminator to type header, if so remove it

	if (length && aTypeHeader[length-1]=='\0')

		{	

		typeHeader.Set(aTypeHeader.Left(length-1));

		}

	if (typeHeader.CompareF(KObexTypeBTvCardPhoneBook)==0)

		{

		if (!iTagsPresent[EMaxListCount])

			{

			LOG(_L("Missing mandatory MaxListCount tag in App Header"));

			// mandatory to have the tag present in this operation

			User::Leave(KErrArgument);

			}		

		if (iMaxListCount==0)

			{

			iOperation = ERequestPhoneBookSize;

			LOG(_L("PBAP operation is PullPhoneBook - MaxListCount = 0"));

			}

		else

			{

			iOperation = EPullPhoneBook;

			LOG(_L("PBAP operation is PullPhoneBook"));

			}

		// this type of request operates on absolute paths	

		iIsAbsolutePathOp = ETrue;

		}

	else if (typeHeader.CompareF(KObexTypeBTvCardListing)==0)

		{

		if (!iTagsPresent[EMaxListCount])

			{

			LOG(_L("Missing MaxListCount tag in App Header, continuing due to spec (v1.0) inconsistency"));

			}		

		if (iMaxListCount==0)

			{

			iOperation = ERequestPhoneBookSize;

			LOG(_L("PBAP operation is PullvCardListing - MaxListCount = 0"));

			}

		else

			{

			iOperation = EPullVCardListing;

			LOG(_L("PBAP operation is PullvCardListing"));

			}

		}

	else if (typeHeader.CompareF(KObexTypeBTvCard)==0)

		{

		// leave to folderparser to determine if handle is ok

		iOperation = EPullVCard;

		LOG(_L("PBAP operation is PullvCard"));		

		}		

	else

		{

		// incorrect or nonexistent Type header. Bad.

		LOG(_L("Cannot determine PBAP operation"));

		User::Leave(KErrCorrupt);

		}

	return iOperation;

	}