// 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:
// eui_addr.cpp - EUI-xx address structure
//

#include "eui_addr.h"	// This
#include <e32std.h>		// Mem::*, User::*, TTime
#include <e32math.h>	// Math::*

static void EuiPanic(TEuiPanic aReason);
static void EuiPanic(TEuiPanic aReason)
{
	User::Panic(_L("EUI"), aReason);
}

EXPORT_C TE64Addr::TE64Addr()
{
	SetAddrZero();
}

EXPORT_C TE64Addr::TE64Addr(const TE64Addr& aAddr)
{
	SetAddr(aAddr);
}

EXPORT_C TE64Addr::TE64Addr(const TInt64& aAddr)
{
	SetAddr(aAddr);
}

EXPORT_C TE64Addr::TE64Addr(const TUint8* aPtr, TUint aLength)
{
	SetAddr(aPtr, aLength);
}

EXPORT_C void TE64Addr::SetAddr(const TE64Addr& aAddr)
{
	u = aAddr.u;
}

EXPORT_C void TE64Addr::SetAddr(const TInt64& aAddr)
{
#ifdef I64HIGH
	u.iAddr32[0] = I64HIGH(aAddr);
	u.iAddr32[1] = I64LOW(aAddr);
#else
	u.iAddr32[0] = aAddr.High();
	u.iAddr32[1] = aAddr.Low();
#endif
}

EXPORT_C void TE64Addr::SetAddr(const TUint8* aPtr, TUint aLength)
{
	__ASSERT_DEBUG(aLength <= AddrLen(), EuiPanic(EEuiPanicSourceTooLong));
	Mem::Copy(AddrPtr(), aPtr, aLength);
}

EXPORT_C void TE64Addr::SetGroupBit(TBool aBit)
{
	__ASSERT_DEBUG(aBit == 0 || aBit == 1, EuiPanic(EEuiPanicBitIsNotBit));

	//   0       0 0       1 1       2 ..
	//  |0       7 8       5 6       3|..
	//  +----+----+----+----+----+----+
	//  |cccc|ccug|cccc|cccc|cccc|cccc|..
	//  +----+----+----+----+----+----+

	if (aBit)
	{
		u.iAddr8[0] |= 0x1;
	}
	else
	{
		u.iAddr8[0] &= 0xFE;
	}
}

EXPORT_C void TE64Addr::SetUniversalBit(TBool aBit)
{
	__ASSERT_DEBUG(aBit == 0 || aBit == 1, EuiPanic(EEuiPanicBitIsNotBit));

	//   0       0 0       1 1       2 ..
	//  |0       7 8       5 6       3|..
	//  +----+----+----+----+----+----+
	//  |cccc|ccug|cccc|cccc|cccc|cccc|..
	//  +----+----+----+----+----+----+

	if (aBit)
	{
		u.iAddr8[0] |= 0x2;
	}
	else
	{
		u.iAddr8[0] &= 0xFD;
	}
}

EXPORT_C void TE64Addr::SetAddrZero()
{
	Mem::FillZ(AddrPtr(), AddrLen());
}

EXPORT_C void TE64Addr::SetAddrRandom()
{
	TTime now;

#ifndef EUI_PSEUDORANDOM
	now.UniversalTime();
#endif

	TInt64 seed = now.Int64();
	u.iAddr32[0] = Math::Rand(seed);
	u.iAddr32[1] = Math::Rand(seed);
	SetUniversalBit(0);
	SetGroupBit(0);
}

EXPORT_C void TE64Addr::SetAddrRandomNZ()
{
	do {
		SetAddrRandom();
	}
	while (IsZero());
}

EXPORT_C void TE64Addr::SetAddrRandomNZButNot(const TE64Addr& aAddr)
{
	do {
		SetAddrRandomNZ();
	}
	while (Match(aAddr));
}

// Really should define TE48Addr for this... -tom

EXPORT_C void TE64Addr::SetAddrFromEUI48(const TUint8* aPtr)
{
	u.iAddr8[0] = aPtr[0];
	u.iAddr8[1] = aPtr[1];
	u.iAddr8[2] = aPtr[2];
	u.iAddr8[3] = 0xff;
	u.iAddr8[4] = 0xfe;
	u.iAddr8[5] = aPtr[3];
	u.iAddr8[6] = aPtr[4];
	u.iAddr8[7] = aPtr[5];

	// The following is really not part of EUI-64 standard
	// but required for IPv6 when forming an IPv6 interface
	// identifier from an EUI-64 adderss. See RFC-2464,
	// RFC-2373. Probably the stack should do this instead. -tom

	// > It is required that the "u" bit (universal/local bit
	// > in IEEE EUI-64 terminology) be inverted when forming
	// > the interface identifier from the EUI-64.  The "u" bit
	// > is set to one (1) to indicate global scope, and it is
	// > set to zero (0) to indicate local scope.

	// So at this moment the address complies EUI-64

	SetUniversalBit(!IsUniversal());

	// Now it doesn't, but complies to IPv6 an interface identifier
}

EXPORT_C TBool TE64Addr::Match(const TE64Addr& aAddr) const
{
	return Mem::Compare(AddrPtrC(), AddrLen(), aAddr.AddrPtrC(), AddrLen()) ? 0 : 1;
}

EXPORT_C TBool TE64Addr::IsZero() const
{
	return (u.iAddr32[0] == 0) && (u.iAddr32[1] == 0);
}

EXPORT_C TBool TE64Addr::IsGroup() const
{
	return (u.iAddr8[0] & 0x1);
}

EXPORT_C TBool TE64Addr::IsUniversal() const
{
	return (u.iAddr8[0] & 0x2);
}

EXPORT_C void TE64Addr::Output(TDes& aBuf) const
{
	TPtrC8 e64Addr(AddrPtrC(), AddrLen());
	TUint i;

	for (i = 0; i < AddrLen(); i++)
	{
		if (i) {
			aBuf.Append(':');
		}

		aBuf.AppendNum(TUint(e64Addr[i]), EHex);
	}
}

EXPORT_C TUint TE64Addr::AddrLen()
{
	return sizeof(TE64Addr);
}

EXPORT_C TUint8* TE64Addr::AddrPtr()
{
	return &u.iAddr8[0];
}

EXPORT_C const TUint8* TE64Addr::AddrPtrC() const
{
	return &u.iAddr8[0];
}

EXPORT_C TEui64Addr::TEui64Addr() : TSockAddr()
{
	Init();
	Address().SetAddrZero();
}

EXPORT_C TEui64Addr::TEui64Addr(const TSockAddr& aAddr) : TSockAddr()
{
	__ASSERT_ALWAYS(aAddr.Family() == KAfEui64 || aAddr.Family() == 0, EuiPanic(EEuiPanicFamilyMismatch));
	Init();
	SetAddress(TEui64Addr::Cast(aAddr).Address());
}

EXPORT_C void TEui64Addr::Init()
{
	SetFamily(KAfEui64);
	SetPort(0);
	SetUserLen(AddrLen());
}

EXPORT_C void TEui64Addr::SetAddress(const TE64Addr& aAddr)
{
	Address().SetAddr(aAddr);
}

EXPORT_C TE64Addr& TEui64Addr::Address() const
{
	return AddrPtr()->iAddr;
}

EXPORT_C TBool TEui64Addr::Match(const TEui64Addr& aAddr) const
{
	return Address().Match(aAddr.Address());
}

EXPORT_C TBool TEui64Addr::IsZero() const
{
	return Address().IsZero();
}

EXPORT_C TEui64Addr& TEui64Addr::Cast(const TSockAddr& aAddr)
{
	return *((TEui64Addr*)&aAddr); //lint !e1773 // standard way to implement Cast
}

EXPORT_C TEui64Addr& TEui64Addr::Cast(const TSockAddr* aAddr)
{
       return *((TEui64Addr*)aAddr); //lint !e1773 // standard way to implement Cast
}

EXPORT_C SE64Addr* TEui64Addr::AddrPtr() const
{
	return (SE64Addr*)UserPtr();
}

EXPORT_C TUint TEui64Addr::AddrLen()
{
	return TE64Addr::AddrLen();
}