// Copyright (c) 2004-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:
// Name          : CSIPPreParser.cpp
// Part of       : SIP Codec
// Version       : SIP/4.0 
//




#include "CSIPPreParser.h"
#include "CSIPHeaderNameValue.h"
#include "sipcodecerr.h"

_LIT8 (KCRLFCRLF, "\r\n\r\n");
_LIT8 (KCRCRLF, "\r\r\n");
_LIT8 (KLFCRLF, "\n\r\n");

// -----------------------------------------------------------------------------
// CSIPPreParser::NewL
// -----------------------------------------------------------------------------
//
CSIPPreParser* CSIPPreParser::NewL (HBufC8* aSipMessageBuf)
	{
	CSIPPreParser* self= CSIPPreParser::NewLC (aSipMessageBuf);
	CleanupStack::Pop(self);
	return self;
	} 

// -----------------------------------------------------------------------------
// CSIPPreParser::NewLC
// -----------------------------------------------------------------------------
//
CSIPPreParser* CSIPPreParser::NewLC (HBufC8* aSipMessageBuf)
	{
	__ASSERT_ALWAYS (aSipMessageBuf!=0, User::Leave(KErrSipCodecPreParser));
	__ASSERT_ALWAYS (aSipMessageBuf->Length()>0, User::Leave(KErrSipCodecPreParser));

	CSIPPreParser* self= new(ELeave)CSIPPreParser (*aSipMessageBuf);
	CleanupStack::PushL(self);
	self->ConstructL(aSipMessageBuf);
	return self;
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::CSIPPreParser
// -----------------------------------------------------------------------------
//
CSIPPreParser::CSIPPreParser (const TDesC8& aSipMessageDes)
 : iLexBuf(aSipMessageDes)
	{
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPPreParser::ConstructL (HBufC8* aSipMessageBuf)
	{
	CreateHeaderBufL (*aSipMessageBuf);
	ParseL ();
	// aSipMessageBuf ownership taken only after the pre-parsing has succeeded.
	iSipMessageBuf = aSipMessageBuf;
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::~CSIPPreParser
// -----------------------------------------------------------------------------
//
CSIPPreParser::~CSIPPreParser ()
	{
    iHeaderStartArray.Close();
	delete iHeaderBuf;
	delete iSipMessageBuf;
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::ParseL
// -----------------------------------------------------------------------------
//
void CSIPPreParser::ParseL ()
	{
	TChar chr = GetCharL();
	while (chr == ' ' || chr == '\t' || chr == '\r' || chr == '\n')
		{
		chr = GetCharL();
		}

	TBool headerPartEnds = EFalse;
	while (!headerPartEnds)
		{
		switch (chr)
			{
			case '\n': headerPartEnds = HandleLfL(); break;
			case '\r': headerPartEnds = HandleCrL(); break;
			default: iHeaderBuf->Des().Append(chr); break;
			}
		if (!headerPartEnds)
		    {
		    chr = GetChar();
		    }
		}
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::FirstLineL
// -----------------------------------------------------------------------------
//
TPtrC8 CSIPPreParser::FirstLineL ()
	{
	// The first line of any SIP message is a request line or a status line.
	TPtrC8 firstLine(GetLineL(0));
	return firstLine;
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::ContentL
// -----------------------------------------------------------------------------
//
HBufC8* CSIPPreParser::ContentL ()
	{
	// The ownership of the content is given to the caller.
	// The function is not re-entrant. Content can be only asked once.
	// The purpose of this is to avoid unnecessary copying.
	__ASSERT_ALWAYS (iSipMessageBuf != 0, User::Leave (KErrSipCodecPreParser));

	// Delete the header part from the original SIP message. "Delete" does not
	// free any memory. It just changes the starting position of the descriptor
	// in the original buffer.
	TInt originalLength = iSipMessageBuf->Length();
	iSipMessageBuf->Des().Delete (0, iOriginalHeaderPartLength);
	TInt contentLength = originalLength - iOriginalHeaderPartLength;

	// With relatively big content parts try to avoid unnecessary copying. 
	HBufC8* content = NULL;
	if (contentLength < iOriginalHeaderPartLength)
		{
		// Relatively small content part. Make a copy. See HBufC8::ReAllocL.
		content = iSipMessageBuf->ReAllocL (contentLength);
		}
	else
		{
		// Relatively big content part. Do not copy into smaller buffer.
		content = iSipMessageBuf;
		}
	iSipMessageBuf = 0;
	return content;
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::HeaderCount
// -----------------------------------------------------------------------------
//
TUint CSIPPreParser::HeaderCount ()
	{
	return iHeaderStartArray.Count();
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::ParseNameValueL
// -----------------------------------------------------------------------------
//
CSIPHeaderNameValue* CSIPPreParser::ParseNameValueL (TInt aIndex)
	{
	__ASSERT_ALWAYS (aIndex < iHeaderStartArray.Count(), 
					User::Leave(KErrSipCodecPreParser));

	TUint lineStartPos = iHeaderStartArray[aIndex];
    TPtrC8 line (GetLineL(lineStartPos));
	TInt colonPos = line.Locate (':'); // find the first colon

	__ASSERT_ALWAYS (colonPos > 0, User::Leave(KErrSipCodecPreParser));

	TPtrC8 name(line.Left(colonPos));
	TPtrC8 value(line.Mid(colonPos+1));

	return CSIPHeaderNameValue::NewL(name, value);
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::GetLineL
// -----------------------------------------------------------------------------
//
TPtrC8 CSIPPreParser::GetLineL (TInt aLineStartPosition)
	{
    __ASSERT_ALWAYS (aLineStartPosition < iHeaderBuf->Length(),
					User::Leave(KErrSipCodecPreParser));

	TPtrC8 lineStartBuf (iHeaderBuf->Des().Mid (aLineStartPosition));

	// All the line ends (CR,LF or CRLF) have been replaced by LF.
	TInt lineEndPosition = lineStartBuf.Locate('\n');
	
    __ASSERT_ALWAYS (lineEndPosition > 0, User::Leave (KErrSipCodecPreParser));

	return lineStartBuf.Left(lineEndPosition);
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::CreateHeaderBufL
// -----------------------------------------------------------------------------
//
void CSIPPreParser::CreateHeaderBufL (const TDesC8& aSipMessageDes)
	{
	TLex8 lex(aSipMessageDes);
	lex.SkipSpace();
    TInt headerPartEndPosition = 0;
    FindHeaderPartEndPositionL (lex.Remainder(),headerPartEndPosition);
	if (headerPartEndPosition <= 0) 
		{
		User::Leave (KErrSipCodecPreParser);
		}
	iHeaderBuf = HBufC8::NewL(headerPartEndPosition+1);
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::FindHeaderPartEndPositionL
// -----------------------------------------------------------------------------
//
void CSIPPreParser::FindHeaderPartEndPositionL (
    const TDesC8& aSipMessageDes,
    TInt& aPosition)
	{
	// The header part may end only with CRLFCRLF, CRCRLF or LFCRLF
	RArray<TInt> positions;
	CleanupClosePushL(positions);

	// CRLFCRLF
	TInt CrLfCrLfPos = aSipMessageDes.Find(KCRLFCRLF);
    if (CrLfCrLfPos >= 0) 
        {
        User::LeaveIfError(positions.Append(CrLfCrLfPos));
        }
	
	// CRCRLF
	TInt CrCrLfPos = aSipMessageDes.Find(KCRCRLF);
	if (CrCrLfPos >= 0) 
        {
        User::LeaveIfError(positions.InsertInOrder(CrCrLfPos));
        }
	
	// LFCRLF
	TInt LfCrLfPos = aSipMessageDes.Find(KLFCRLF);
	if (LfCrLfPos >= 0) 
        {
        User::LeaveIfError(positions.InsertInOrder(LfCrLfPos));
        }

	if (positions.Count() == 0)
		{
		User::Leave(KErrNotFound);
		}

	aPosition = positions[0];
	CleanupStack::PopAndDestroy(); // positions
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::HandleLfL
// -----------------------------------------------------------------------------
//
TBool CSIPPreParser::HandleLfL ()
	{
	TChar chr = GetCharL ();
	switch (chr)
		{
		case ' ' : // LFSP 
		case '\t': // LFHTAB
			// The header continues on the next line.
			SkipSpacesAndTabsL ();
			iHeaderBuf->Des().Append(' '); // replace by one space
			break;

		case '\r': // LFCR
			chr = GetCharL ();
			if (chr == '\n') // LFCRLF
				{
				// Header part ends according to the old SIP specs.
				// Replace LFCRLF with LF to simplify name-value parsing.
				iHeaderBuf->Des().Append('\n');
				return ETrue; 
				}
			else // LFCR"AnyText" not allowed.
				{
				User::Leave (KErrSipCodecPreParser);
				}

		case '\n': // LFLF not allowed.
			User::Leave (KErrSipCodecPreParser);

		default: // LF"AnyText"
			MoveToNextLineL ();
			break;
		}
	return EFalse;
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::HandleCrL
// -----------------------------------------------------------------------------
//
TBool CSIPPreParser::HandleCrL ()
	{
	TChar chr = GetCharL ();
	switch (chr)
		{
		case ' ' : // CRSP
		case '\t': // CRHTAB
			// The header continues on the next line.
			SkipSpacesAndTabsL ();
			iHeaderBuf->Des().Append(' '); // replace by one space
			break;

		case '\r': // CRCR
			chr = GetCharL ();
			if (chr == '\n') // CRCRLF
				{
				// Header part ends according to the old SIP specs.
				// Replace CRCRLF with LF to simplify name-value parsing.
				iHeaderBuf->Des().Append('\n');
				return ETrue;
				}
			else // CRCR"AnyText" not allowed.
				{
				User::Leave (KErrSipCodecPreParser); 
				}

		case '\n': // CRLF
			chr = GetCharL ();
			switch (chr)
				{
				case '\n': // CRLFLF not allowed.
					User::Leave (KErrSipCodecPreParser);

				case ' ' : case '\t': // CRLFSP or CRLFHTAB
					// The header continues on the next line.
					SkipSpacesAndTabsL ();
					iHeaderBuf->Des().Append(' '); // replace by one space
					break;

				case '\r': // CRLFCR
					chr = GetCharL ();
					if (chr == '\n') // CRLFCRLF. Header part ends.
						{
						// Replace with LF to simplify name-value parsing.
						iHeaderBuf->Des().Append('\n');
						return ETrue;
						}
					else // CRLFCR"AnyText" not allowed.
						{
						User::Leave (KErrSipCodecPreParser); 
						}

				default: // CRLF"AnyText"
					MoveToNextLineL ();
					break;
				}
			break;
	
		default: // CR"AnyText"
			MoveToNextLineL ();
			break;
		}
	return EFalse;
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::SkipSpacesAndTabsL
// -----------------------------------------------------------------------------
//
void CSIPPreParser::SkipSpacesAndTabsL ()
	{
	TChar chr = GetCharL ();
	while (chr == ' ' || chr == '\t')
		{
		chr = GetCharL();
		}
	UnGetChar(); // Put back the last one that was not a space or a tab
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::MoveToNextLineL
// -----------------------------------------------------------------------------
//
void CSIPPreParser::MoveToNextLineL ()
	{
	UnGetChar();
	// Replace the line end (CR, LF or CRLF) with LF
	iHeaderBuf->Des().Append('\n');
	TUint nextLineStartPosition = iHeaderBuf->Length();
	User::LeaveIfError (iHeaderStartArray.Append(nextLineStartPosition));
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::GetCharL
// -----------------------------------------------------------------------------
//
inline TChar CSIPPreParser::GetCharL()
	{
    TChar chr = GetChar();
	if (chr == 0) 
        {
        User::Leave (KErrSipCodecPreParser);
        }
    return chr;
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::GetChar
// -----------------------------------------------------------------------------
//
inline TChar CSIPPreParser::GetChar()
	{
	TChar chr = iLexBuf.Get();
	if (chr != 0) iOriginalHeaderPartLength++;
    return chr;
	}

// -----------------------------------------------------------------------------
// CSIPPreParser::UnGetChar
// -----------------------------------------------------------------------------
//
inline void CSIPPreParser::UnGetChar()
	{
	iLexBuf.UnGet();
	iOriginalHeaderPartLength--;
	}