// 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          : CSIPAuthHeaderBase.cpp
// Part of       : SIP Codec
// Version       : SIP/4.0 
//



#include "sipauthheaderbase.h"
#include "CSIPParamContainerBase.h"
#include "CSIPTokenizer.h"
#include "sipcodecerr.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "sipcodecutils.h"
#include "_sipcodecdefs.h"

// ----------------------------------------------------------------------------
// CSIPAuthHeaderBase::CSIPAuthHeaderBase
// ----------------------------------------------------------------------------
//
CSIPAuthHeaderBase::CSIPAuthHeaderBase()
:iSeparator(',')
	{
	}

// ----------------------------------------------------------------------------
// CSIPAuthHeaderBase::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPAuthHeaderBase::ConstructL(RStringF aAuthScheme)
	{
	SetAuthSchemeL(aAuthScheme.DesC());
	}

// ----------------------------------------------------------------------------
// CSIPAuthHeaderBase::~CSIPAuthHeaderBase
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPAuthHeaderBase::~CSIPAuthHeaderBase()
	{
	iAuthScheme.Close();
	}

// ----------------------------------------------------------------------------
// CSIPAuthHeaderBase::AuthScheme
// ----------------------------------------------------------------------------
//
EXPORT_C RStringF CSIPAuthHeaderBase::AuthScheme() const
	{
	return iAuthScheme;
	}

// ----------------------------------------------------------------------------
// CSIPAuthHeaderBase::SetParamAndAddQuotesL
// ----------------------------------------------------------------------------
//
EXPORT_C void CSIPAuthHeaderBase::SetParamAndAddQuotesL(RStringF aName,
                                                        const TDesC8& aValue)
	{
    const TInt KQuotesLength = 2;
	HBufC8* tmp = HBufC8::NewLC(aValue.Length()+KQuotesLength);
	TPtr8 tmpPtr(tmp->Des());
	tmpPtr.Append('"');
	tmpPtr.Append(aValue);
	tmpPtr.Append('"');	
	Params().SetParamL(aName,tmpPtr);
	CleanupStack::PopAndDestroy(tmp);
	}

// ----------------------------------------------------------------------------
// CSIPAuthHeaderBase::ExternalizeSupported
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
EXPORT_C TBool CSIPAuthHeaderBase::ExternalizeSupported() const
	{
	return EFalse;
	}

// ----------------------------------------------------------------------------
// CSIPAuthHeaderBase::EncodeMultipleToOneLine
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
TBool CSIPAuthHeaderBase::EncodeMultipleToOneLine() const
	{
	return EFalse;	
	}

// ----------------------------------------------------------------------------
// CSIPAuthHeaderBase::MoreThanOneAllowed
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//		
TBool CSIPAuthHeaderBase::MoreThanOneAllowed() const
	{
	return ETrue;	
	}

// ----------------------------------------------------------------------------
// CSIPAuthHeaderBase::PreferredPlaceInMessage
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
CSIPHeaderBase::TPreferredPlace
CSIPAuthHeaderBase::PreferredPlaceInMessage () const
	{
	return CSIPHeaderBase::EMiddleBottom;
	}

// -----------------------------------------------------------------------------
// CSIPAuthHeaderBase::ToTextValueL
// From CSIPHeaderBase:
// -----------------------------------------------------------------------------
//
HBufC8* CSIPAuthHeaderBase::ToTextValueL() const
	{
	TUint encodedLength = iAuthScheme.DesC().Length(); 

	HBufC8* encodedParams = Params().ToTextLC();
	if (Params().ParamCount() > 0)
		{
		encodedLength += 1; // separator		
		encodedLength += encodedParams->Length();
		}

	HBufC8* encodingResult = HBufC8::NewL (encodedLength);
	TPtr8 encodingResultPtr = encodingResult->Des();

	encodingResultPtr.Append(iAuthScheme.DesC());

	if (Params().ParamCount() > 0)
		{
		encodingResultPtr.Append(' '); // Separate Scheme from other values
		encodingResultPtr.Append(*encodedParams);
		}

	CleanupStack::PopAndDestroy(encodedParams);
	return encodingResult;
	}

// ----------------------------------------------------------------------------
// CSIPAuthHeaderBase::SetAuthSchemeL
// ----------------------------------------------------------------------------
//
void CSIPAuthHeaderBase::SetAuthSchemeL(const TDesC8& aAuthScheme)
	{		
    RStringF tmp = 
        SIPCodecUtils::CheckAndCreateTokenL(
            aAuthScheme,KErrSipCodecAuthScheme);
	iAuthScheme.Close();
    iAuthScheme = tmp;
	}

// -----------------------------------------------------------------------------
// CSIPAuthHeaderBase::ParseL
// -----------------------------------------------------------------------------
//
void CSIPAuthHeaderBase::ParseL(const TDesC8& aValue)
	{
	TLex8 lex(aValue);
	lex.SkipSpace();
	TPtrC8 mandatoryPart(lex.NextToken());
	if (mandatoryPart.Length() < 1) 
		{
		User::Leave (KErrSipCodecAuthScheme);
		}
    SetAuthSchemeL(mandatoryPart);
    lex.SkipSpace();
    Params().ParseL(lex.Remainder());
	}

// -----------------------------------------------------------------------------
// CSIPAuthHeaderBase::HasParam
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CSIPAuthHeaderBase::HasParam(RStringF aName) const
	{
	return Params().HasParam(aName);
	}

// -----------------------------------------------------------------------------
// CSIPAuthHeaderBase::ParamValue
// -----------------------------------------------------------------------------
//
EXPORT_C RStringF CSIPAuthHeaderBase::ParamValue(RStringF aName) const
	{
	return Params().ParamValue(aName);
	}

// -----------------------------------------------------------------------------
// CSIPAuthHeaderBase::DesParamValue
// -----------------------------------------------------------------------------
//	
EXPORT_C const TDesC8& CSIPAuthHeaderBase::DesParamValue(RStringF aName) const
    {
    return Params().DesParamValue(aName);
    }		

// -----------------------------------------------------------------------------
// CSIPAuthHeaderBase::SetParamL
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPAuthHeaderBase::SetParamL(
    RStringF aName,
    RStringF aValue)
	{
	Params().SetParamL(aName,aValue);
	}

// -----------------------------------------------------------------------------
// CSIPAuthHeaderBase::SetDesParamL
// -----------------------------------------------------------------------------
//	
EXPORT_C void CSIPAuthHeaderBase::SetDesParamL(
    RStringF aName,
    const TDesC8& aValue)
    {
    Params().SetDesParamL(aName,aValue);
    }

// -----------------------------------------------------------------------------
// CSIPAuthHeaderBase::DeleteParam
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPAuthHeaderBase::DeleteParam(RStringF aName)
	{
	Params().DeleteParam(aName);
	}