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

// implementation of UDP and TCP tranlation

// 

//

/**

 @file

 @internalTechnology 

*/

#include "hookdefs.h"

#include <e32std.h>

#include <in6_opt.h>

#include <udp_hdr.h>

#include <icmp6_hdr.h>

#include <udp_hdr.h>

#include <in_pkt.h>

#include <ext_hdr.h>

#include <in_chk.h>

#include <tcp_hdr.h>

#include <icmp6_hdr.h>

#include "naptlog.h"

#include "panic.h"

#include "napt_ini.h"

#include "naptconfigtable.h"

#include <posthook.h>

#ifdef SYMBIAN_NETWORKING_ADDRESS_PROVISION

#include "naptutil.h"

#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION

#include <es_prot_internal.h>

const TInt KIapUnDefined = 0;

void Panic(TNAPTPanic aPanic)

	{

	User::Panic(_L("NAPTHook panic"), aPanic);

	}

_LIT(KProtocolNaptName, "napt");

//Timer class  Functions..

CNaptTimer* CNaptTimer::NewL(CProtocolNapt* aNaptProtocol)

	/**

	*

    * Create an instance of the timer

   	*

    */

     {

     CNaptTimer* timer = new(ELeave)CNaptTimer();

     CleanupStack::PushL(timer);

     timer->ConstructL();

     timer->iNaptProtocol = aNaptProtocol;

     timer->iMapMgrPtr = 	&(aNaptProtocol->iNaptMapMgr);

     CleanupStack::Pop(timer);

     return timer;

     }

void CNaptTimer::StartTimer()

	/**

	*

    * Start Timer & Add it Active Scheduler

    *

    **/

	{

	ASSERT(!IsAdded());

	CActiveScheduler::Add(this);

	//it should be in Micro Seconds..

	CTimer::After(iNaptTableScanInterval*1000000);

	}

void CNaptTimer::RunL()

	/**

	*	Timer is complete...

	*	Delete the TimedOut Entries from the TranslationTable.

	*	Check Any Packets are there in TranslationTable to be converted.

	*	Restart Timer if they are present by taking iIndexedCount

	*	Else Stop the timer

	*

	*	@internalTechnology

	**/

	{

	//delete timeout transactions..

	iMapMgrPtr->TimerComplete();

	//reset timer

	if (iNaptProtocol->iNaptMapMgr.GetIndexedPortCount())

		{

		CTimer::After(iNaptTableScanInterval*1000000);

		}

	else

		{

		Cancel();

		}

	}

void CNaptTimer::Cancel()

	/**

	*

	* Remove Timer from Active Scheduler

	*

	**/

	{

	CTimer::DoCancel();

	if (IsAdded())

		{

        Deque();

        }

	}

CNaptTimer::~CNaptTimer()

	/**

    *

    * Timer destructor

    *

    */

     {

     Cancel();

     }

/**

---------------------------------------------------------------------------------------

								CSapNapt

---------------------------------------------------------------------------------------

This class is derived from CServProviderBase.CSapNapt is the service class for sockets

loading NAPT.But here only one socket will be able to load protocol.If protocol once

loaded other socket cannot service protocol by opening socket.

 */

CSapNapt::CSapNapt()

	{

	iConfigInfo = NULL;

	}

TNaptConfigInfo* CSapNapt::GetConfigInfo()

/** 

 * This method is used to get the NAPT related configuration for this Service provider

 * access point.

 * @param None

 * return - TNaptConfigInfo*

**/

	{

	return iConfigInfo;

	}

void CSapNapt::SetConfigInfo(TNaptConfigInfo *aConfigInfo)	

/** 

 * This method is used to set the NAPT related configuration for this Service provider

 * access point.

 * @param None

 * return - TNaptConfigInfo*

**/

	{

	iConfigInfo = aConfigInfo;

	}

TInt CSapNapt::SetOption(TUint aLevel ,TUint aName ,const TDesC8& anOption)

/** 

 * This class is used to set interface index information to be used by NAPT.

 * level will contain Downlink information and name will contain private interface

 * index. This method will also bind the protocol to the TCP/IP stack if it has not been

 * done yet.

 * @param aDownlink-- Downlink Interface Index.

 * @param aPrivateInterface - Private interface Index.

 * return - KErrNone if no value is assigned else KErrPermissionDenied

**/

	{

	TInt err = KErrNone;

#ifndef SYMBIAN_NETWORKING_ADDRESS_PROVISION

	const TInterfaceLockInfo* info= reinterpret_cast<const TInterfaceLockInfo* >(anOption.Ptr());

	if(aLevel==KSolNapt &&  aName == KSoNaptSetup)

		{

		if(anOption.Length()!=sizeof(TInterfaceLockInfo))

			{

			//this means that Block is not filled properly

			return KErrArgument;

			}

		err = iConfigMgr->UpdateConfigL(info, this);

		}//check if option and size

	else

		{

		//options level or Name wrong

		return KErrArgument; 

		}

#else //SYMBIAN_NETWORKING_ADDRESS_PROVISION

		if(aLevel==KSolNapt)

		{

		switch(aName)

			{

			case KSoNaptSetup:

			case KSoNaptProvision:

				{

				LOG(Log::Printf(_L("CSapNapt::SetOption(): KSoNaptSetup ")));

				const TInterfaceLockInfo* info = reinterpret_cast<const TInterfaceLockInfo* >(anOption.Ptr());

				if(anOption.Length()!= sizeof(TInterfaceLockInfo))

					{

					//this means that Block is not filled properly

					return KErrArgument;

					}

				err = iConfigMgr->UpdateConfigL(info, this) ;

				}

				break;

			default:

				{

				LOG(Log::Printf(_L("//options level or Name wrong")));

				//options level or Name wrong

				return KErrArgument;

				}

			}//switch ends here

		}

	else

		{

		//options level or Name wrong

		return KErrArgument; 

		}

#endif //SYMBIAN_NETWORKING_ADDRESS_PROVISION

    // Bind the protocol to TCP/IP stack and this will result in actually attach of the hook

    DoBindToL(err);

    return err;

	}//end main function

void CSapNapt::DoBindToL(TInt aStatus)

/* This method is used to bind the protocol to TCP/IP stack once the client

 * configures NAPT hook. It checks if the protocol is not already bound in case it is

 * already bound the method does nothing and simply returns. Until and unless Napt is 

 * configured it's not actually bound to TCP/IP stack.

 * @param aStatus -- Status.

 * return - None

 *

 */

	{

	if ((aStatus == KErrNone) && (iProtocol->iBoundFlag == EFalse))

		{

		iProtocol->iBoundFlag = ETrue;

		iProtocol->BindToL(iProtocol->iProtBase);

		}

	}

TInt CSapNapt::SecurityCheck(MProvdSecurityChecker* aChecker)

	/**

	* Capability check for the NAPT sockets.

	*

	* NAPT sockets require the NetworkControl capability.

	*

	* @param aChecker The policy checker.

	* @return The result of the policy check.

	*/

	{

	//	This method is called when a SAP is created and when a socket is transferred between sessions.  The SAP is

	//required to check whether the originating client process has enough privileges to request services from the SAP.

	//The MProvdSecurityChecker class instance is used to perform security policy checks.  The SAP may choose

	//to perform a security policy check in its SecurityCheck(...) method, or it may choose to store the

	//MProvdSecurityChecker class instance argument and perform checking later (i.e. when subsequent

	//SAP methods are called). 

	_LIT_SECURITY_POLICY_C1(KPolicyNetworkControl, ECapabilityNetworkControl);

	return aChecker->CheckPolicy(KPolicyNetworkControl, "NAPT policy failed.");

	}

/*

-------------------------------------------------------------------------------------------------

									CProtocolNapt

-------------------------------------------------------------------------------------------------

				Protocol loading

				----------------

		ESOCK 			

 			\

 		      \ 	

 	       load \

                  \           load

 				CProtocolNapt-------->CProtocolNaptIn

CProtocolNapt will load CProtocolNaptIn in its constructor. CProtocolNapt will bind itself as forward hook and

will bind CProtocolNaptIn as an InboundHook using NetworkServices.

 */

CProtocolNapt* CProtocolNapt::NewL()

	{

	CProtocolNapt* self = new(ELeave) CProtocolNapt();

	CleanupStack::PushL(self);

	self->CreateL();

	CleanupStack::Pop();

	return self;

	}

void CProtocolNapt::CreateL()

/*

 *ConstructL part of two phase construction. Allocating memory to Inbound class aand passing 

 * reference to this.

*/

	{

    iNaptMapMgr.iLastPort = KNaptPort_HIGH;

    iConfigMgr = CNaptClientConfigMgr::NewL(*this);

    //Allocating memory for Inbound Hook. No need for cleanup stack here its

    //a leaving function, so everything should be traped above.

    iProtInbound = new(ELeave) CProtocolNaptIn(this);

   	//Create Timer Instance

   	if (!iTimer) 

		{

		iTimer = CNaptTimer::NewL(this);

		iNaptMapMgr.iTimerPtr = iTimer;

		}

    iBoundFlag = EFalse;

    }

CProtocolNapt::~CProtocolNapt()

/** 

 * Destructor.This is called when NAPT is destroyed. Protocol should unbind it self

 * from the Network Layer.

**/

	{

	CNaptIPPortMap *table=NULL;

	if (iTimer )

		{

		//running timer will be stopped in destructor

		delete iTimer;	

		}

	for (TInt index=0;index<KTranslationHashTableSize;index++)

		{

		TNaptTableIter naptTableIter(iNaptMapMgr.iIPPortMap[index]);

		naptTableIter.SetToFirst();

		while((table=naptTableIter++)!=NULL)

			{

			iNaptMapMgr.iIPPortMap[index].Remove(*table);

			delete table;

			}

		}

	// Protocol is being unloaded and hence clear all SAP references

	// We are not really needed to delete the objects as esock will take care of

	// deleting all the SAPs.	

    iSapList.Reset();		

    //Delete the client config manager.

    //This in turn destroys all the configurations stored in the list		

	delete iConfigMgr;

	if(iBoundFlag != EFalse)

		{

		//Unbind Hooks.iProtInbound is the inbound hook which should be unbind from

		//stack before unbinding main protocol.Should unbind using network service

		//which quite important.If unable to unbind then check for network Services.

		NetworkService()->Protocol()->Unbind((CProtocolBase*)iProtInbound,0);

		NetworkService()->Protocol()->Unbind(this,0);

		}

	if(iProtInbound!=NULL)

  		{

		delete iProtInbound;

		iProtInbound=NULL; //just safe step

		}

#ifdef __DEBUG

//UnMarking heap which is marked when protocol is loaded in Family.cpp

__UHEAP_MARKEND;

#endif

	}

void CProtocolNapt::Identify(TServerProtocolDesc* aProtocolDesc)const 

	{

	Describe(*aProtocolDesc);

	}

void CProtocolNapt::BindL(CProtocolBase* /*protocol*/, TUint /*id*/)

	{

	// We should not overwrite the existing esk files

	}

void CProtocolNapt::BindToL(CProtocolBase* aProtocol)

	/**

	* The protocol binds itself to TCP/IP stack. The bind has been delibrately deferred

	* here to facilitate opening of multiple sockets without actually loading the hook.

	* The hook will be actually loaded when someone configured the setup information in NAPT

	* 

	**/

	{

	if(iBoundFlag != EFalse)

	{

		const TUint id = (TUint)DoBindToL(aProtocol);

	}

	else

		iProtBase = aProtocol;

	}

void CProtocolNapt::NetworkAttachedL()

	/**

	* The TCP/IP stack has been attached to this plugin.

	*

	* The CProtocolPosthook impelements the basic BindL/BindToL and Unbind

	* processing. The NetworkAttached is called when the TCP/IP

	* is connected with this protocol module.

	*

	* This function installs a hook for forwarded packets. The function

	* ApplyL will be called for each received packet that enters the

	* forward path (before actual forwarding decision).

	*

	* Could also install any other hooks to pull packets.

	*/

	{

	//Read Timer Configuration Parameters

	ReadConfigurationFile();

	NetworkService()->BindL(this, BindForwardHook());

	//Binding Inbound hook as hook all. This will take packets from all the interfaces

	//and translate only thise which are required.This seperate class optimise RAM usage. 

	//and implemented to avoid usage of heavy calls like IsForMeAddress.

	NetworkService()->BindL((CProtocolBase*)iProtInbound, BindHookAll());

	iManager = NetworkService()->Interfacer();

	}

void CProtocolNapt::ReadConfigurationFile()

	/*

	* Timer values are stored in Timer Class.	

	* iNaptTableScanInterval value should be less than 2147 seconds, as it is an argument

	* to CTimer::After(TTimeIntervalMicroSeconds32).	

	*/

	{

	iTimer->iNaptTableScanInterval	= GetIniValue(NAPT_INI_TIMER,NAPT_INI_TABLESCANINTERVAL,KTableScanIntervalDefault,1,KTimerMaxSeconds);

	iTimer->iNaptTcpIdleTimeout		= GetIniValue(NAPT_INI_TIMER,NAPT_INI_TCPIDLETIMEOUT,KTcpIdleTimeOutDefault,1,KMaxTInt);

	iTimer->iNaptUdpIdleTimeout		= GetIniValue(NAPT_INI_TIMER,NAPT_INI_UDPIDLETIMEOUT,KUdpIdleTimeoutDefault,1,KMaxTInt);

	iTimer->iNaptIcmpIdleTimeout	= GetIniValue(NAPT_INI_TIMER,NAPT_INI_ICMPIDLETIMEOUT,KIcmpIdleTimeoutDefault,1,KMaxTInt);

	iTimer->iNaptTcpCloseTimeout	= GetIniValue(NAPT_INI_TIMER,NAPT_INI_TCPCLOSETIMEOUT,KTcpCloseTimeoutDefault,1,KMaxTInt);

	iTimer->iNaptTcpOpenTimeout		= GetIniValue(NAPT_INI_TIMER,NAPT_INI_TCPOPENTIMEOUT,KTcpOpenTimeoutDefault,1,KMaxTInt);

	}

TInt CProtocolNapt::GetIniValue(const TDesC& aSection, const TDesC& aName, TInt aDefault, TInt aMin, TInt aMax)

	/*

	* Timer values are read from the configuration file-napt.ini

	* If the configuration values are not present default values are stored

	*/

	{

	TInt value;

	CESockIniData* config = NULL;

	TRAP_IGNORE(config = CESockIniData::NewL(NAPT_INI_DATA));

    if (config==NULL || !config->FindVar(aSection, aName, value))

    	{

        value = aDefault;

    	}

     else if (value < aMin || value > aMax)

         {

         value = aDefault;

         }

    delete config;

    return value;	

	}

TInt CProtocolNapt::ApplyL(RMBufHookPacket& aPacket, RMBufRecvInfo& aInfo)

/*

 * This function is called for all the packets coming from interfce. This instance of 

 * ApplyL will be called for forwarding hook as well as inbound hook. Packets are 

 * translated for both inbound and forwarding packets. Scope is being set for packet 

 * destined to private interface.

 * @param aPacket

 * @param aInfo

*/

	{

	const TInetAddr& dest = aInfo.iDstAddr;

	const TInetAddr& src= aInfo.iSrcAddr;

	const TUint32 ifindex = aInfo.iInterfaceIndex;

	TInetAddr addr(aInfo.iSrcAddr);

	LOG(Log::Printf(_L("packet received from interface index=[%d] and source ip address is:%x"),ifindex,addr.Address()));

	iCurConfigInfo = iConfigMgr->FindConfig(ifindex);

	if(!iCurConfigInfo)

		{

		LOG(Log::Printf(_L("No configuration information for interface index=[%d]"),ifindex));

		return KIp6Hook_PASS;

		}