// Copyright (c) 2007-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          : sipsecdigestcontext.cpp
// Part of       : SIPSec/DigestPlugin
// Version       : SIP/6.0
//



#include "sipresponse.h"
#include "siprequest.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "sipauthorizationheaderbase.h"
#include "sipsecurityverifyheader.h"
#include "sipsecdigestcontext.h"
#include "sipsecdigestcache.h"
#include "sipsecrequestdata.h"
#include "CSIPSecDigest.h"
#include "CSIPSecCredentials.h"
#include "CSIPSecUserRecord.h"
#include "SipSecUtils.h"
#include "CSIPSecDigestObserver.h"

// ============================ MEMBER FUNCTIONS ===============================


// -----------------------------------------------------------------------------
// TSIPSecDigestContext::TSIPSecDigestContext
// -----------------------------------------------------------------------------
//
TSIPSecDigestContext::TSIPSecDigestContext( CSIPSecCredentials& aCredentials,
                                            TSIPSecPluginContext* aParent ) :
    iCredentials( aCredentials ),
    iParent( aParent )
    {
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::Mechanism
// -----------------------------------------------------------------------------
//
CSIPSecDigest& TSIPSecDigestContext::Mechanism() const
    {
    return iCredentials.Mechanism();
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::Parent
// -----------------------------------------------------------------------------
//
TSIPSecPluginContext& TSIPSecDigestContext::Parent()
    {
    __ASSERT_ALWAYS( iParent,
    	User::Panic( _L( "SIPSecDigestCtx:Parent" ), KErrNotFound ) );

    return *iParent;
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::UserData
// -----------------------------------------------------------------------------
//
CSIPSecUserRecord& TSIPSecDigestContext::UserData()
	{
	return iCredentials.UserData();
	}

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::SetUserData
// -----------------------------------------------------------------------------
//
void TSIPSecDigestContext::SetUserData( CSIPSecUserRecord& aUserData )
	{
	iCredentials.SetUserData( aUserData );
	}

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::GetParam
// -----------------------------------------------------------------------------
//
const TDesC8& TSIPSecDigestContext::GetParam( const CSIPAuthHeaderBase& aHeader,
											  TInt aParam )
    {
    return aHeader.ParamValue( SIPStrings::StringF( aParam ) ).DesC();
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::GetDesParam
// -----------------------------------------------------------------------------
//
const TDesC8&
TSIPSecDigestContext::GetDesParam( const CSIPAuthHeaderBase& aHeader,
								   TInt aParam )
    {
    return aHeader.DesParamValue( SIPStrings::StringF( aParam ) );
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::SetParamValueL
// -----------------------------------------------------------------------------
//
void TSIPSecDigestContext::SetParamValueL( CSIPAuthHeaderBase& aHeader,
										   TInt aParam,
										   const TDesC8& aValue )
    {
    if ( aValue.Length() > 0 )
        {
		RStringF value = SIPStrings::Pool().OpenFStringL( aValue );
		CleanupClosePushL( value );
		aHeader.SetParamL( SIPStrings::StringF( aParam ), value );
		CleanupStack::PopAndDestroy(); //value
        }
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::SetDesParamValueL
// -----------------------------------------------------------------------------
//
void TSIPSecDigestContext::SetDesParamValueL( CSIPAuthHeaderBase& aHeader,
										   	  TInt aParam,
										      const TDesC8& aValue )
    {
    if ( aValue.Length() > 0 )
        {
		aHeader.SetDesParamL( SIPStrings::StringF( aParam ), aValue );			
        }
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::SetParamWithEmptyValueL
// -----------------------------------------------------------------------------
//
void TSIPSecDigestContext::SetParamWithEmptyValueL( TInt aParam )
	{
	iCredentials.Content().SetParamAndAddQuotesL( SIPStrings::StringF( aParam ),
												  KNullDesC8 );
	}

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::GetParam
// -----------------------------------------------------------------------------
//
const TDesC8& TSIPSecDigestContext::GetParam( TInt aParam ) const
    {
    return GetParam( iCredentials.Content(), aParam );
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::GetDesParam
// -----------------------------------------------------------------------------
//
const TDesC8& TSIPSecDigestContext::GetDesParam( TInt aParam ) const
    {
    return GetDesParam( iCredentials.Content(), aParam );
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::SetParamValueL
// -----------------------------------------------------------------------------
//
void TSIPSecDigestContext::SetParamValueL( TInt aParam, const TDesC8& aValue )
    {
    SetParamValueL( iCredentials.Content(), aParam, aValue );
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::SetDesParamValueL
// -----------------------------------------------------------------------------
//
void
TSIPSecDigestContext::SetDesParamValueL( TInt aParam, const TDesC8& aValue )
    {
    SetDesParamValueL( iCredentials.Content(), aParam, aValue );
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::Nonce
// -----------------------------------------------------------------------------
//
const TDesC8& TSIPSecDigestContext::Nonce() const
    {
    return GetDesParam( SipStrConsts::ENonce );
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::NonceCount
// -----------------------------------------------------------------------------
//
const TDesC8& TSIPSecDigestContext::NonceCount() const
	{
	return GetParam( SipStrConsts::ENonceCount );
	}

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::CNonce
// -----------------------------------------------------------------------------
//
const TDesC8& TSIPSecDigestContext::CNonce() const
	{
    return GetDesParam( SipStrConsts::ECNonce );
	}

// -----------------------------------------------------------------------------
// TSIPSecDigestContext::DigestURI
// -----------------------------------------------------------------------------
//
const TDesC8& TSIPSecDigestContext::DigestURI() const
    {
    return GetParam( SipStrConsts::EUri );
    }



// ============================ MEMBER FUNCTIONS ===============================
	
	
// ----------------------------------------------------------------------------
// TSIPSecDigestCtxSetup::TSIPSecDigestCtxSetup
// ----------------------------------------------------------------------------
//
TSIPSecDigestCtxSetup::TSIPSecDigestCtxSetup(
	CSIPSecCredentials& aCredentials,
	TTransactionId aTransactionId,
	TSIPSecPluginCtxResponse* aParent ) :
	TSIPSecDigestContext( aCredentials, aParent ),
	iTransactionId( aTransactionId )
	{
	}
	  
// -----------------------------------------------------------------------------
// TSIPSecDigestCtxSetup::RequestUserCredentialsL
// -----------------------------------------------------------------------------
//
TBool TSIPSecDigestCtxSetup::RequestUserCredentialsL()
	{
    TSIPSecPluginCtxResponse& parent =
    	static_cast<TSIPSecPluginCtxResponse&>( Parent() );
    CSIPSecDigestObserver* observer =
    	parent.Cache().RegisterObserverL( parent.Observer(), UserData() );
	return UserData().RequestL( *this, *observer );
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestCtxSetup::SetCNonceL
// -----------------------------------------------------------------------------
//
void TSIPSecDigestCtxSetup::SetCNonceL( const TDesC8& aCnonce )
	{
    SetDesParamValueL( SipStrConsts::ECNonce, aCnonce );
	}

// ----------------------------------------------------------------------------
// TSIPSecDigestCtxSetup::TransactionId
// ----------------------------------------------------------------------------
//
TTransactionId TSIPSecDigestCtxSetup::TransactionId() const
	{
	return iTransactionId;
	}


// ============================ MEMBER FUNCTIONS ===============================
	
	
// ----------------------------------------------------------------------------
// TSIPSecDigestCtxProcess::TSIPSecDigestCtxProcess
// ----------------------------------------------------------------------------
//
TSIPSecDigestCtxProcess::TSIPSecDigestCtxProcess(
									CSIPSecCredentials& aCredentials,
                                    TSIPSecPluginContext* aParent ) :
    TSIPSecDigestContext( aCredentials, aParent )
	{	
	}

// -----------------------------------------------------------------------------
// TSIPSecDigestCtxProcess::Method
// -----------------------------------------------------------------------------
//
const TDesC8& TSIPSecDigestCtxProcess::Method()
	{	
	return static_cast<TSIPSecPluginCtxRequest&>( Parent() ).
		SIPRequest().Method().DesC();
	}

// -----------------------------------------------------------------------------
// TSIPSecDigestCtxProcess::Message
// -----------------------------------------------------------------------------
//
const TDesC8& TSIPSecDigestCtxProcess::Message()
	{
	return static_cast<TSIPSecPluginCtxRequest&>( Parent() ).
		SIPRequest().Content();
	}

// -----------------------------------------------------------------------------
// TSIPSecDigestCtxProcess::SetResponseL
// -----------------------------------------------------------------------------
//
void TSIPSecDigestCtxProcess::SetResponseL( const TDesC8& aResponse )
	{
    SetDesParamValueL( SipStrConsts::EResponse, aResponse );
	}

// -----------------------------------------------------------------------------
// TSIPSecDigestCtxProcess::RequestDataL
// -----------------------------------------------------------------------------
//
CSIPSecRequestData*
TSIPSecDigestCtxProcess::RequestDataL( CSIPSecRequestData::TQop aQop )
    {
    return CSIPSecRequestData::NewL( *this, aQop );
    }

    
// ============================ MEMBER FUNCTIONS ===============================


// -----------------------------------------------------------------------------
// TSIPSecDigestVerifyContext::RequestData
// -----------------------------------------------------------------------------
//
TSIPSecDigestVerifyContext::TSIPSecDigestVerifyContext(
	CSIPSecCredentials& aCredentials,
	const TDesC8& aUri,
	TSIPSecPluginCtxVerify* aParent ) :
    TSIPSecDigestCtxProcess( aCredentials, aParent ),
    iUri( aUri )
    {
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestVerifyContext::DigestURI
// -----------------------------------------------------------------------------
//
const TDesC8& TSIPSecDigestVerifyContext::DigestURI() const
	{
    return iUri;
	}

// -----------------------------------------------------------------------------
// TSIPSecDigestVerifyContext::SetResponseL
// -----------------------------------------------------------------------------
//
void TSIPSecDigestVerifyContext::SetResponseL( const TDesC8& aResponse )
	{
    RStringF value = SIPStrings::Pool().OpenFStringL( aResponse );
    CleanupClosePushL( value );
    static_cast< TSIPSecPluginCtxVerify& >( Parent() ).
    	SecurityVerifyHeader().SetParamL( SIPStrings::StringF(
    		SipStrConsts::EDigestVerify ), value );
    CleanupStack::PopAndDestroy(); // value
	}

// -----------------------------------------------------------------------------
// TSIPSecDigestVerifyContext::RequestDataL
// -----------------------------------------------------------------------------
//
CSIPSecRequestData*
TSIPSecDigestVerifyContext::RequestDataL( CSIPSecRequestData::TQop aQop )
    {
    return CSIPSecDigestVerifyData::NewL( *this, aQop );
    }



// ----------------------------------------------------------------------------
// TSIPSecDigestVerifyContext::SecurityServerHeaderL
// Example
// 	Security-Server: ipsec-ike;q=0.1
// 	Security-Server: tls;q=0.2
// Result
// 	Security-Server:ipsec-ike;q=0.1,tls;q=0.2
// ----------------------------------------------------------------------------
//	
HBufC8* TSIPSecDigestVerifyContext::SecurityServerHeaderL()
    {
    HBufC8* serverHeader( NULL );

    TSglQueIter<CSIPHeaderBase> headers(
    	static_cast< TSIPSecPluginCtxVerify& >( Parent() ).
    		SecurityServerHeaders() );

    if ( headers )
        {
        CBufBase* encoded = SipSecUtils::EncodeHeadersL( headers );
        CleanupStack::PushL( encoded );
        TPtr8 encodedPtr( encoded->Ptr( 0 ) );
        serverHeader = encodedPtr.AllocL();
        CleanupStack::PopAndDestroy( encoded );
        }
        
    return serverHeader;    
    }


// ============================ MEMBER FUNCTIONS ===============================


// -----------------------------------------------------------------------------
// TSIPSecDigestAuthInfoContext::TSIPSecDigestAuthInfoContext
// -----------------------------------------------------------------------------
//
TSIPSecDigestAuthInfoContext::TSIPSecDigestAuthInfoContext(
										CSIPSecCredentials& aCredentials,
                      	                TDes8& aResponse,
                      	                TSIPSecPluginCtxResponse* aParent ) :
    TSIPSecDigestCtxProcess( aCredentials, aParent ),
    iResponse( aResponse )
    {    
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestAuthInfoContext::SetResponseL
// -----------------------------------------------------------------------------
//
void TSIPSecDigestAuthInfoContext::SetResponseL( const TDesC8& aResponse )
    {
	__ASSERT_ALWAYS( iResponse.MaxLength() >= aResponse.Length(),
	 				 User::Leave( KErrArgument ) );
    iResponse.Copy( aResponse );
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestAuthInfoContext::Method
// -----------------------------------------------------------------------------
//
const TDesC8& TSIPSecDigestAuthInfoContext::Method()
    {
    return KNullDesC8;
    }

// -----------------------------------------------------------------------------
// TSIPSecDigestAuthInfoContext::Message
// -----------------------------------------------------------------------------
//
const TDesC8& TSIPSecDigestAuthInfoContext::Message()
    {
	return static_cast< TSIPSecPluginCtxResponse& >( Parent() ).
		SIPResponse().Content();
    }

// End of File