/*

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:

*

*

*/

/*

*/

#include <e32debug.h>

#include "EapTraceSymbian.h"

#include "eap_am_export.h"

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT EapCertificateEntry::EapCertificateEntry()

: iCertType(ENone)

, iSubjectNamePresent(EFalse)

, iIssuerNamePresent(EFalse)

, iSerialNumberPresent(EFalse)

, iThumbprintPresent(EFalse)

, iLabelPresent(EFalse)

, iPrimaryNamePresent(EFalse)

, iSecondaryNamePresent(EFalse)

, iIsEnabledPresent(EFalse)

, iSubjectKeyIdPresent(EFalse)

, iIsValid(EFalse)

{

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT EapCertificateEntry::~EapCertificateEntry()

{

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT void EapCertificateEntry::trace() const

{

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapCertificateEntry::trace(): iCertType=%d"),

		iCertType));

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapCertificateEntry::trace(): iSubjectNamePresent=%d"),

		iSubjectNamePresent));

	if (iSubjectNamePresent)

	{

		EAP_TRACE_DATA_DEBUG_SYMBIAN(("EapCertificateEntry::trace(): iSubjectName",

			iSubjectName.Ptr(),

			iSubjectName.Size()));

	}

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapCertificateEntry::trace(): iIssuerNamePresent=%d"),

		iIssuerNamePresent));

	if (iIssuerNamePresent)

	{

		EAP_TRACE_DATA_DEBUG_SYMBIAN(("EapCertificateEntry::trace(): iIssuerName",

			iIssuerName.Ptr(),

			iIssuerName.Size()));

	}

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapCertificateEntry::trace(): iSerialNumberPresent=%d"),

		iSerialNumberPresent));

	if (iSerialNumberPresent)

	{

		EAP_TRACE_DATA_DEBUG_SYMBIAN(("EapCertificateEntry::trace(): iSerialNumber",

			iSerialNumber.Ptr(),

			iSerialNumber.Size()));

	}

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapCertificateEntry::trace(): iThumbprintPresent=%d"),

		iThumbprintPresent));

	if (iThumbprintPresent)

	{

		EAP_TRACE_DATA_DEBUG_SYMBIAN(("EapCertificateEntry::trace(): iThumbprint",

			iThumbprint.Ptr(),

			iThumbprint.Size()));

	}

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapCertificateEntry::trace(): iLabelPresent=%d"),

		iLabelPresent));

	if (iLabelPresent)

	{

		EAP_TRACE_DATA_DEBUG_SYMBIAN(("EapCertificateEntry::trace(): iLabel",

			iLabel.Ptr(),

			iLabel.Size()));

	}

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapCertificateEntry::trace(): iPrimaryNamePresent=%d"),

		iPrimaryNamePresent));

	if (iPrimaryNamePresent)

	{

		EAP_TRACE_DATA_DEBUG_SYMBIAN(("EapCertificateEntry::trace(): iPrimaryName",

			iPrimaryName.Ptr(),

			iPrimaryName.Size()));

	}

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapCertificateEntry::trace(): iSecondaryNamePresent=%d"),

		iSecondaryNamePresent));

	if (iSecondaryNamePresent)

	{

		EAP_TRACE_DATA_DEBUG_SYMBIAN(("EapCertificateEntry::trace(): iSecondaryName",

			iSecondaryName.Ptr(),

			iSecondaryName.Size()));

	}

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapCertificateEntry::trace(): iIsEnabledPresent=%d"),

		iIsEnabledPresent));

	if (iIsEnabledPresent)

	{

		EAP_TRACE_DEBUG_SYMBIAN((_L("EapCertificateEntry::trace(): iIsEnabled=%d"),

			iIsEnabled));

	}

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapCertificateEntry::trace(): iSubjectKeyIdPresent=%d"),

		iSubjectKeyIdPresent));

	if (iSubjectKeyIdPresent)

	{

		EAP_TRACE_DATA_DEBUG_SYMBIAN(("EapCertificateEntry::trace(): iSubjectKeyId",

			iSubjectKeyId.Ptr(),

			iSubjectKeyId.Size()));

	}

	EAP_TRACE_DEBUG_SYMBIAN((_L("EapCertificateEntry::trace(): iIsValid=%d"),

		iIsValid));

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT EapCertificateEntry * EapCertificateEntry::Copy()

{

	EapCertificateEntry * const entry = new EapCertificateEntry;

	if (entry == 0)

	{

		EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: EapCertificateEntry::Copy(): No memory.\n")));

		return 0;

	}

	*entry = *this;

	if (entry->iIsValid == EFalse)

	{

		delete entry;

		EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: EapCertificateEntry::Copy(): No memory.\n")));

		return 0;

	}

	return entry;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT EapCertificateEntry &EapCertificateEntry::operator = (const EapCertificateEntry &right_type_value)

{

	if (this == &right_type_value)

	{

		return *this;

	}

	iIsValid = EFalse;

	SetCertType(right_type_value.GetCertType());

	if (right_type_value.GetSubjectNamePresent())

	{

		if (SetSubjectName(*right_type_value.GetSubjectName()) != KErrNone)

		{

			EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: EapCertificateEntry::operator = (): SetSubjectName(): No memory.\n")));

			return *this;

		}

	}

	if (right_type_value.GetIssuerNamePresent())

	{

		if (SetIssuerName(*right_type_value.GetIssuerName()) != KErrNone)

		{

			EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: EapCertificateEntry::operator = (): SetIssuerName(): No memory.\n")));

			return *this;

		}

	}

	if (right_type_value.GetSerialNumberPresent())

	{

		if (SetSerialNumber(*right_type_value.GetSerialNumber()) != KErrNone)

		{

			EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: EapCertificateEntry::operator = (): SetSerialNumber(): No memory.\n")));

			return *this;

		}

	}

	if (right_type_value.GetThumbprintPresent())

	{

		if (SetThumbprint(*right_type_value.GetThumbprint()) != KErrNone)

		{

			EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: EapCertificateEntry::operator = (): SetThumbprint(): No memory.\n")));

			return *this;

		}

	}

	if (right_type_value.GetLabelPresent())

	{

		if (SetLabel(*right_type_value.GetLabel()) != KErrNone)

		{

			EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: EapCertificateEntry::operator = (): SetLabel(): No memory.\n")));

			return *this;

		}

	}

	if (right_type_value.GetPrimaryNamePresent())

	{

		if (SetPrimaryName(*right_type_value.GetPrimaryName()) != KErrNone)

		{

			EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: EapCertificateEntry::operator = (): SetPrimaryName(): No memory.\n")));

			return *this;

		}

	}

	if (right_type_value.GetSecondaryNamePresent())

	{

		if (SetSecondaryName(*right_type_value.GetSecondaryName()) != KErrNone)

		{

			EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: EapCertificateEntry::operator = (): SetSecondaryName(): No memory.\n")));

			return *this;

		}

	}

	if (right_type_value.GetIsEnabledPresent())

	{

		if (SetIsEnabled(right_type_value.GetIsEnabled()) != KErrNone)

		{

			EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: EapCertificateEntry::operator = (): SetIsEnabled(): No memory.\n")));

			return *this;

		}

	}

	if (right_type_value.GetSubjectKeyIdPresent())

	{

		if (SetSubjectKeyId(right_type_value.GetSubjectKeyId()) != KErrNone)

		{

			EAP_TRACE_DEBUG_SYMBIAN((_L("ERROR: EapCertificateEntry::operator = (): SetSubjectKeyId(): No memory.\n")));

			return *this;

		}

	}

	iIsValid = ETrue;

	return *this;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT TBool EapCertificateEntry::GetSubjectNamePresent() const

{

	return iSubjectNamePresent;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT TBool EapCertificateEntry::GetIssuerNamePresent() const

{

	return iIssuerNamePresent;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT TBool EapCertificateEntry::GetSerialNumberPresent() const

{

	return iSerialNumberPresent;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT TBool EapCertificateEntry::GetThumbprintPresent() const

{

	return iThumbprintPresent;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT TBool EapCertificateEntry::GetLabelPresent() const

{

	return iLabelPresent;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT TBool EapCertificateEntry::GetPrimaryNamePresent() const

{

	return iPrimaryNamePresent;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT TBool EapCertificateEntry::GetSecondaryNamePresent() const

{

	return iSecondaryNamePresent;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT TBool EapCertificateEntry::GetIsEnabledPresent() const

{

	return iIsEnabledPresent;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT TBool EapCertificateEntry::GetSubjectKeyIdPresent() const

{

	return iSubjectKeyIdPresent;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT void EapCertificateEntry::SetSubjectNamePresent()

{

	iSubjectNamePresent = ETrue;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT void EapCertificateEntry::SetIssuerNamePresent()

{

	iIssuerNamePresent = ETrue;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT void EapCertificateEntry::SetSerialNumberPresent()

{

	iSerialNumberPresent = ETrue;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT void EapCertificateEntry::SetThumbprintPresent()

{

	iThumbprintPresent = ETrue;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT void EapCertificateEntry::SetLabelPresent()

{

	iLabelPresent = ETrue;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT void EapCertificateEntry::SetPrimaryNamePresent()

{

	iPrimaryNamePresent = ETrue;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT void EapCertificateEntry::SetSecondaryNamePresent()

{

	iSecondaryNamePresent = ETrue;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT void EapCertificateEntry::SetIsEnabledPresent()

{

	iIsEnabledPresent = ETrue;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT void EapCertificateEntry::SetSubjectKeyIdPresent()

{

	iSubjectKeyIdPresent = ETrue;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT EapCertificateEntry::TCertType EapCertificateEntry::GetCertType() const

{

	return iCertType;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT const TDes * EapCertificateEntry::GetSubjectName() const

{

	return &iSubjectName;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT const TDes * EapCertificateEntry::GetIssuerName() const

{

	return &iIssuerName;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT const TDes * EapCertificateEntry::GetSerialNumber() const

{

	return &iSerialNumber;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT const TDes * EapCertificateEntry::GetThumbprint() const

{

	return &iThumbprint;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT TInt EapCertificateEntry::SetCertType(const TCertType & aType)

{

	iCertType = aType;

	return KErrNone;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT TInt EapCertificateEntry::SetSubjectName(const TBuf<KGeneralStringMaxLength> & aSubjectName)

{

	iSubjectName.Copy(aSubjectName);

	if (iSubjectName.Length() != aSubjectName.Length())

	{

		return KErrNoMemory;

	}

	iSubjectNamePresent = ETrue;

	return KErrNone;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT TInt EapCertificateEntry::SetIssuerName(const TBuf<KGeneralStringMaxLength> & aIssuerName)

{

	iIssuerName.Copy(aIssuerName);

	if (iIssuerName.Length() != aIssuerName.Length())

	{

		return KErrNoMemory;

	}

	iIssuerNamePresent = ETrue;

	return KErrNone;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT TInt EapCertificateEntry::SetSerialNumber(const TBuf<KGeneralStringMaxLength> & aSerialNumber)

{

	iSerialNumber.Copy(aSerialNumber);

	if (iSerialNumber.Length() != aSerialNumber.Length())

	{

		return KErrNoMemory;

	}

	iSerialNumberPresent = ETrue;

	return KErrNone;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT TInt EapCertificateEntry::SetThumbprint(const TBuf<KThumbprintMaxLength> & aThumbprint)

{

	iThumbprint.Copy(aThumbprint);

	if (iThumbprint.Length() != aThumbprint.Length())

	{

		return KErrNoMemory;

	}

	iThumbprintPresent = ETrue;

	return KErrNone;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT const TDes * EapCertificateEntry::GetLabel() const

{

	return &iLabel;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT const TKeyIdentifier & EapCertificateEntry::GetSubjectKeyId() const

{

	return iSubjectKeyId;

}

//-------------------------------------------------------------------------------------

EAP_FUNC_EXPORT const TDes * EapCertificateEntry::GetPrimaryName() const

{

	return &iPrimaryName;