// Copyright (c) 2005-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          : CIpSecPolicyHandler.cpp
// Part of       : SIPSec
// Version       : SIP/4.0 
//



#include <utf.h>
#include <convutils.h>
#include <lib_pfkey.h>

#include "CIpSecPolicyHandler.h"
#include "MSipSecPolicyObserver.h"
#include "SipSecIpsecParams.h"

#ifndef CPPUNIT_TEST
// Comment this definition off, if ipsec is wanted to be used for real
//#define DISABLE_IPSEC_POLICY_USAGE
#endif

// ----------------------------------------------------------------------------
// CIpSecPolicyHandler::NewL
// ----------------------------------------------------------------------------
//
CIpSecPolicyHandler* CIpSecPolicyHandler::NewL(
    MSipSecPolicyObserver& aObserver,
	RIpsecPolicyServ& aPolicyServ )
	{
	CIpSecPolicyHandler* 
		self = CIpSecPolicyHandler::NewLC( aObserver, aPolicyServ );
	CleanupStack::Pop( self );
	return self;
	}
	
// ----------------------------------------------------------------------------
// CIpSecPolicyHandler::NewLC
// ----------------------------------------------------------------------------
//
CIpSecPolicyHandler* CIpSecPolicyHandler::NewLC(
    MSipSecPolicyObserver& aObserver,
	RIpsecPolicyServ& aPolicyServ )
	{
	CIpSecPolicyHandler* 
		self = new ( ELeave ) CIpSecPolicyHandler( aObserver, aPolicyServ );
	CleanupStack::PushL( self );
	return self;
	}

	
// ----------------------------------------------------------------------------
// CIpSecPolicyHandler::~CIpSecPolicyHandler
// ----------------------------------------------------------------------------
//
CIpSecPolicyHandler::~CIpSecPolicyHandler()
	{
	Cancel();
	delete iPolicyData;
	}
	
// ----------------------------------------------------------------------------
// CIpSecPolicyHandler::CreatePolicyL
// ----------------------------------------------------------------------------
//
void CIpSecPolicyHandler::CreatePolicyL( 
    const TInetAddr& aLocalAddress,
	const TInetAddr& aRemoteAddress,
	const TSipSecSaParams& aSaParams )
    {
    if ( IsActive() && iHandlerState != EIdle )
        {
        User::Leave( KErrInUse );
        }
        
    HBufC8* localAddr = GetAddrAsTextLC( aLocalAddress );
    TPtr8 plocalAddr( localAddr->Des() );
    HBufC8* remoteAddr = GetAddrAsTextLC( aRemoteAddress );
    TPtr8 premoteAddr( remoteAddr->Des() );
    
    HBufC8* mask = 0;
    if ( !(aLocalAddress.Address()))
        {
        _LIT8( KV6Mask, "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" ); 
        mask = KV6Mask().AllocLC();
        }
    else
        {
        _LIT8( KV4Mask, "255.255.255.255" );
        mask = KV4Mask().AllocLC();
        }
    TPtr8 pmask( mask->Des() );
        
    RemovePolicyData();
    
    const TInt KMAxTUint32AsDescLen = 10;

    _LIT8( KPolicyFormat, 
"SECURITY_FILE_VERSION: 3\r\n\
[INFO]\r\n\
SIP IPSec policies\r\n\
[POLICY]\r\n\
sa sip_sas = {\r\n\
esp\r\n\
encrypt_alg 11\r\n\
auth_alg %u\r\n\
src_specific\r\n\
local_port_specific\r\n\
remote_port_specific\r\n\
}\r\n\
local %S %S local_port %u remote %S %S remote_port %u = { sip_sas() }\r\n\
local %S %S local_port %u remote %S %S remote_port %u = { sip_sas() }\r\n\
local %S %S local_port %u = drop\r\n\
inbound = {}\r\n\
outbound = {}\r\n" );

    iPolicyData = HBufC8::NewL( KPolicyFormat().Length() +
                                6 * KMAxTUint32AsDescLen +
                                2 * premoteAddr.Length() +
                                5 * pmask.Length() + 
                                3 * plocalAddr.Length() );
                                
    TPtr8 pdata( iPolicyData->Des() );
    
    // Form policy data. Drop policy for the port_us cannot be created
    // since it will affect to other SAs using the same protected server port.
    // Instead, dropping of packets coming to port_us from incorrect remote
    // addresses is handled in ConnectionMgr level.
    pdata.AppendFormat( KPolicyFormat, 
                        aSaParams.iAuthAlg,
                        &plocalAddr,
                        &pmask,
                        aSaParams.iPort_us,
                        &premoteAddr,
                        &pmask,
                        aSaParams.iPort_pc,
                        &plocalAddr,
                        &pmask,
                        aSaParams.iPort_uc,
                        &premoteAddr,
                        &pmask,
                        aSaParams.iPort_ps,
                        &plocalAddr,
                        &pmask,
                        aSaParams.iPort_uc );
                        
    CleanupStack::PopAndDestroy( mask );
    CleanupStack::PopAndDestroy( remoteAddr );                  
    CleanupStack::PopAndDestroy( localAddr );
    
#ifdef DISABLE_IPSEC_POLICY_USAGE
    // Dummy completion of the loading request
	iStatus = KRequestPending;
	SetActive();
	iHandlerState = ELoading;
	TRequestStatus* status = &iStatus;
	User::RequestComplete( status, KErrNone );
#else
    // Start loading the policy                    
    iPolicyServ.LoadPolicy( *iPolicyData, iPolicyHandle, iStatus );
    iHandlerState = ELoading;
    SetActive();
#endif                        
    }

// ----------------------------------------------------------------------------
// CIpSecPolicyHandler::RemovePolicy
// ----------------------------------------------------------------------------
//
void CIpSecPolicyHandler::RemovePolicy()
    {
    // Cancel first outstanding operations
    Cancel();
   
#ifdef DISABLE_IPSEC_POLICY_USAGE
    // Dummy completion of the unloading request
	iStatus = KRequestPending;
	SetActive();
	iHandlerState = EUnloading;
	TRequestStatus* status = &iStatus;
	User::RequestComplete( status, KErrNone );
#else 
    // Start unloading
    iPolicyServ.UnloadPolicy( iPolicyHandle(), iStatus );
    iHandlerState = EUnloading;
    SetActive();
#endif
    }

// ----------------------------------------------------------------------------
// CIpSecPolicyHandler::RunL
// ----------------------------------------------------------------------------
//
void CIpSecPolicyHandler::RunL()
	{
	TInt err( iStatus.Int() );
	
	if (  err != KErrNone )
	    {
	    RemovePolicyData();
	    NotifyError( err );
	    return;
	    }
	    
	switch ( iHandlerState )
	    {
	    case ELoading:
	        {
	        // Policy data is not needed anymore
	        RemovePolicyData();
	        
#ifdef DISABLE_IPSEC_POLICY_USAGE
            // Dummy completion of the activating request
			iStatus = KRequestPending;
			SetActive();
			iHandlerState = EActivating;
			TRequestStatus* status = &iStatus;
			User::RequestComplete( status, KErrNone );
#else
	        // Start activating the policy
	        iPolicyServ.ActivatePolicy( iPolicyHandle(), iStatus );
	        iHandlerState = EActivating;
	        SetActive();
#endif
	        break;
	        }
	    case EActivating:
	        {
	        // Inform observer, all done
	        iHandlerState = EActive;
	        NotifyActiveL();
	        break;
	        }
	    case EUnloading:
	        {
	        // Inform observer
	        iHandlerState = EIdle;
	        NotifyUnload();
	        break;
	        }
	    default:
	        {
	        break;
	        }
	    }
	}
	
// -----------------------------------------------------------------------------
// CIpSecPolicyHandler::RunError
// -----------------------------------------------------------------------------
//
TInt CIpSecPolicyHandler::RunError( TInt aError )
	{
	if ( aError != KErrNoMemory )
		{
		return KErrNone;
		}
	return aError;
	}

// ----------------------------------------------------------------------------
// CIpSecPolicyHandler::DoCancel
// ----------------------------------------------------------------------------
//
void CIpSecPolicyHandler::DoCancel()
	{
	switch ( iHandlerState )
	    {
	    case ELoading:
	        {
            iPolicyServ.CancelLoad();
            break;
	        }
	    case EActivating:
	        {
	        iPolicyServ.CancelActivate();
	        break;
	        }
	    case EUnloading:
	        {
	        iPolicyServ.CancelUnload();
	        break;
	        }
	    default:
	        {
	        break;
	        }
	    }
	}
	
// ----------------------------------------------------------------------------
// CIpSecPolicyHandler::CIpSecPolicyHandler
// ----------------------------------------------------------------------------
//
CIpSecPolicyHandler::CIpSecPolicyHandler( 
    MSipSecPolicyObserver& aObserver,
    RIpsecPolicyServ& aPolicyServ ) :
	CActive( EPriorityStandard ),
	iObserver( aObserver ),
	iPolicyServ( aPolicyServ ),
	iHandlerState( EIdle )
	{
	CActiveScheduler::Add( this );
	}

// ----------------------------------------------------------------------------
// CIpSecPolicyHandler::GetAddrAsTextLC
// ----------------------------------------------------------------------------
//	
HBufC8* CIpSecPolicyHandler::GetAddrAsTextLC( const TInetAddr& aAddr )
    {
    const TInt KMaxInetAddrLen = 256;
    TBuf<KMaxInetAddrLen> tempAddr;
    aAddr.Output( tempAddr );
    
    HBufC8* address = HBufC8::NewLC( tempAddr.Length() );
    TPtr8 paddress( address->Des() );  
    TInt ret = 
        CnvUtfConverter::ConvertFromUnicodeToUtf8( paddress, tempAddr );
    
    if ( ret > 0 || ret == CCnvCharacterSetConverter::EErrorIllFormedInput )
        {
        User::Leave( KErrGeneral );
        }
    
    return address;
    }

// ----------------------------------------------------------------------------
// CIpSecPolicyHandler::RemovePolicyData
// ----------------------------------------------------------------------------
//		
void CIpSecPolicyHandler::RemovePolicyData()
    {
    delete iPolicyData;
    iPolicyData = 0;
    }

// ----------------------------------------------------------------------------
// CIpSecPolicyHandler::NotifyActiveL
// ----------------------------------------------------------------------------
//    
void CIpSecPolicyHandler::NotifyActiveL()
    {
	iObserver.PolicyActivatedL();
    }

// ----------------------------------------------------------------------------
// CIpSecPolicyHandler::NotifyUnload
// ----------------------------------------------------------------------------
//    
void CIpSecPolicyHandler::NotifyUnload()
    {
	iObserver.PolicyUnloaded();
    }

// ----------------------------------------------------------------------------
// CIpSecPolicyHandler::NotifyError
// ----------------------------------------------------------------------------
//
void CIpSecPolicyHandler::NotifyError( TInt aError )
    {
    TPolicyHandlerState oldState = iHandlerState;
	iHandlerState = EIdle;
	iObserver.PolicyError( oldState, aError );
    }
    
// End of File