// 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:
//

#include <bluetooth/logger.h>
#include "pannapiphook.h"
#include "RBnepFrame.h"			// For the DHCP / Forwarding RMBufPacket header flags

#include <in_sock.h>
#include <in_chk.h>
#include <udp_hdr.h>
#include <es_prot_internal.h>

_LIT(KProtocolPanNapIpHookName, "pannapiphook");

#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_PAN_NAPIPHOOK);
#endif

#ifdef __FLOG_ACTIVE
// Define strings for logging.
_LIT(KStringTrue, "True");
_LIT(KStringFalse,  "False");
_LIT(KStringDropped, "Dropped");
_LIT(KStringPassed,  "Passed");
#endif


static const TUint KDhcpDstPort = 67;

// Returning a negative number from the ApplyL() method in an IP hook will make the IP
// stack drop the packet. No constant is defined in networking so define it here to
// help readability of the code.
static const TInt KIp6Hook_DROP = -1;

//
// CPanNapIpHook
//
CPanNapIpHook* CPanNapIpHook::NewL()
	{
	CPanNapIpHook* self = new(ELeave) CPanNapIpHook();
	return self;
	}

CPanNapIpHook::~CPanNapIpHook()
	{
	Unbind(this,BindHookAll());
	CProtocolPosthook::NetworkDetached();
	}

void CPanNapIpHook::NetworkAttachedL()
	{
	// This hook is dual purpose and checks both that incoming packets destined for the
	// DHCP server and any packets to be forwarded to the uplink have access to do so.
	// This is why the hook gets bound in 2 places, once for forwarding packets and once
	// for all incoming packets. The logic in ApplyL() determines where the hook has 
	// been called from.
	NetworkService()->BindL(this, BindForwardHook());
	NetworkService()->BindL(this, BindHookAll());
	iManager = NetworkService()->Interfacer();
	}

TInt CPanNapIpHook::ApplyL(RMBufHookPacket &aPacket, RMBufRecvInfo &aInfo)
	{
	TInt rCode = KIp6Hook_PASS;
	
	// This hook is for packets coming from BNEP only and performs two purposes depending
	// on whether or not the packet is destined for the local host or not.
	if(aInfo.iFlags & KBnep)
		{
		LOG1(_L("Remote device granted access to uplink: %S"), (aInfo.iFlags & KBnepForwardingAllowed) ? &KStringTrue() : &KStringFalse());
		
		if (iManager->IsForMeAddress(TInetAddr::Cast(aInfo.iDstAddr).Ip6Address(), aInfo.iInterfaceIndex))
			{
			LOG(_L("Packet destined for local host"));

			// Make sure that any packets from BNEP destined for the DHCP Server are processed
			// only if it has come from a remote device granted access to the uplink
			if(aInfo.iProtocol == KProtocolInetUdp)
				{
				TInet6Checksum<TInet6HeaderIP4> ipHeader(aPacket);
				TInet6Packet<TInet6HeaderUDP> udpHeader(aPacket, ipHeader.iHdr->HeaderLength());
				
				if(udpHeader.iHdr->DstPort() == KDhcpDstPort)
					{
					LOG(_L("DHCP packet detected"));
					
					// DHCP packet. Drop if forwarding flag not set.
					if(!(aInfo.iFlags & KBnepForwardingAllowed))
						{
						aPacket.Free();
						rCode = KIp6Hook_DROP;  // Drop packet
						}
					}
				}			
			}
		else
			{
			LOG(_L("Packet destined to be forwarded"));

			// Before forwarding packets from BNEP ensure that they have come from a remote
			// device granted access to the uplink
			if(!(aInfo.iFlags & KBnepForwardingAllowed))
				{
				aPacket.Free();
				rCode = KIp6Hook_DROP;  // Drop packet
				}
			}
		}
		
	// Finished with the flags
	aInfo.iFlags &= ~KBnep;
	aInfo.iFlags &= ~KBnepForwardingAllowed;

	LOG1(_L("Packet %S"), (rCode < 0) ? &KStringDropped() : &KStringPassed());

	return rCode;
	}

void CPanNapIpHook::Identify(TServerProtocolDesc* aProtocolDesc) const 
	{
	Describe(*aProtocolDesc);
	}

void CPanNapIpHook::Describe(TServerProtocolDesc& aEntry)
	{
	aEntry.iName = KProtocolPanNapIpHookName;
	aEntry.iAddrFamily = KAfInet;
	aEntry.iSockType = KSockDatagram;
	aEntry.iProtocol = KProtocolPanNapIpHook;
	aEntry.iVersion = TVersion(1, 0, 0);
	aEntry.iByteOrder = EBigEndian;
	aEntry.iServiceInfo = KSIDatagram | KSIConnectionLess;
	aEntry.iNamingServices = 0;
	aEntry.iSecurity = KSocketNoSecurity;
	aEntry.iMessageSize = 0xffff;
	aEntry.iServiceTypeInfo = 0;
	aEntry.iNumSockets = KUnlimitedSockets;
	aEntry.iServiceTypeInfo = ESocketSupport | EInterface;
	}

//
// CPanNapIpHookFamily
//	
CPanNapIpHookFamily::CPanNapIpHookFamily()
	{
	__DECLARE_NAME(_S("CPanNapIpHookFamily"));
	}

CPanNapIpHookFamily::~CPanNapIpHookFamily()
	{
	}

TInt CPanNapIpHookFamily::Install()
	{
	return KErrNone;
	}

TInt CPanNapIpHookFamily::Remove()
	{
	return KErrNone;
	}

TUint CPanNapIpHookFamily::ProtocolList(TServerProtocolDesc *& aProtocolList)
	{
	aProtocolList = new TServerProtocolDesc[1];
	
	if (!aProtocolList)
		{
		return 0;
		}
		
	CPanNapIpHook::Describe(aProtocolList[0]);
	return 1;
	}

CProtocolBase* CPanNapIpHookFamily::NewProtocolL(TUint /*aSockType*/, TUint aProtocol)
	{
	if (aProtocol != KProtocolPanNapIpHook)
		{
		User::Leave(KErrNotSupported);
		}
	return CPanNapIpHook::NewL();
	}

EXPORT_C CProtocolFamilyBase* Install(void)
	{
	CPanNapIpHookFamily* protocol = new CPanNapIpHookFamily();
	return protocol;
	}