/*

* Copyright (c) 2002-2005 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 FILES

#include <SenXmlElement.h>

#include <SenBaseFragment.h>

#include <SenXmlUtils.h>

#include <SenServiceConnection.h> // WSF error codes

#include "senbaseidentity.h"

#include "senwiseidentityprovider.h"

#include "sendebug.h" // internal Utils\inc - filelogging MACROs

#ifdef __CRYPTO_HW__

#include "sencryptoutils.h"

#include <SecEnv.h>

#include <SecEnvDevice.h>

#include <SecEnvType.h>

#include <SecEnvMgr.h>

const TInt KCryptoPADataLen     = 16;

const TInt KCryptoPACipherLen   = 48;

const TInt KPaCryptAuthLen     = 32;

const TInt KEncryptNoSalt = 3;

const TInt KDecrypt       = 2;

const TUint KPadding = 0;

const TUint KEncrypedLen = 128;

_LIT8(KCryptoPA, "PA_CRYPT");

#endif // __CRYPTO_HW__

EXPORT_C CSenBaseIdentity* CSenBaseIdentity::NewL(TPtrC8 aIMEI)

    {

    CSenBaseIdentity* pNew = NewLC(aIMEI);

    CleanupStack::Pop();

    return(pNew) ;

    }

EXPORT_C CSenBaseIdentity* CSenBaseIdentity::NewLC(TPtrC8 aIMEI)

    {

    CSenBaseIdentity* pNew = new (ELeave) CSenBaseIdentity(aIMEI);

    CleanupStack::PushL(pNew);

    pNew->ConstructL();

    return pNew;

    }

CSenBaseIdentity::CSenBaseIdentity(TPtrC8 aIMEI)

:   iProvider(NULL),

    iIMEI(aIMEI)

    {

    }

void CSenBaseIdentity::ConstructL()

    {

    BaseConstructL( KIdentityElementLocalName() );

    }

CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL(MSenServiceDescription& aService )

    {

    TInt idpCount(iProviderList.Count());

    CSenIdentityProvider* pIdp = NULL;

    CSenIdentityProvider* pCandidate = NULL;

    for (TInt i=0; i<idpCount; i++)

        {

        pCandidate = (CSenIdentityProvider*)iProviderList[i];

        if(pCandidate->IsTrustedByL(aService))

            {

            pIdp = pCandidate;

            pCandidate = NULL;

            }

        if(pIdp == NULL && pCandidate->IsDefault()) 

            {

            pIdp = pCandidate;

            }

        if(pIdp)

            {

            break;

            }

        }

    return pIdp;

    }

CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL(const TDesC8& aURI )

    {

    TInt idpCount(iProviderList.Count());

    CSenIdentityProvider* retVal = NULL;

    for (TInt i=0; i<idpCount; i++)

        {

            retVal = (CSenIdentityProvider*)iProviderList[i];

            if (retVal->Endpoint() == aURI)

                {

                break;

                }

            else

                {

                retVal = NULL;

                }

        }

    return retVal;

    }

CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL(const CDesC8Array& aIdpIdList,

                                                          TBool aStrict )

    {

    TInt idpCount(iProviderList.Count());

    TInt patternCount(aIdpIdList.Count());

    if(patternCount==0)

        {

        if(aStrict)

            {

            return NULL;

            }

        else

            {

            return IdentityProviderL(); // return the default provider

            }

        }

    // to optimize the search, store the default idp

    CSenIdentityProvider* pDefault = NULL;

    for (TInt i=0; i<idpCount; i++)

        {

        for(TInt j=0; j<patternCount; j++)

            {

            TPtrC8 providerID = ((CSenIdentityProvider*)iProviderList[i])->ProviderID();

            if(providerID.Length()>0 && providerID == aIdpIdList[j])

                {

                return (CSenIdentityProvider*)iProviderList[i];

                }

            }

        if(!aStrict)

            {

            // to optimize the search, store the default idp, if found

            if(((CSenIdentityProvider*)iProviderList[i])->IsDefault())

                {

                pDefault = (CSenIdentityProvider*)iProviderList[i];

                }

            }

        }

    if(aStrict)

        {

        // default idp does not meet the search requirements

        // (not in strict pattern list)

        return NULL;

        }

    else

        {

        // if current item did not match with anything in the

        // pattern list, check if it's ok in non-strict perspective

        return pDefault;

        }

    }

CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL(MSenServiceDescription& aService,

                                                          const CDesC8Array& aIdpIdList,

                                                          TBool aStrict)

    {

    TInt idpCount(iProviderList.Count());

    TInt patternCount(aIdpIdList.Count());

    if(patternCount==0)

        {

        if(aStrict)

            {

            return NULL;

            }

        else

            {

            return IdentityProviderL(); // return the default provider

            }

        }

    // to optimize the search, store the default idp

    CSenIdentityProvider* pDefault = NULL;

    CSenIdentityProvider* pTrusted = NULL;

    for (TInt i=0; i<idpCount; i++)

        {

        for(TInt j=0; j<patternCount; j++)

            {

            TPtrC8 providerID = 

                ((CSenIdentityProvider*)iProviderList[i])->ProviderID();

            if(providerID.Length()>0 && providerID == aIdpIdList[j])

                {

                if (((CSenIdentityProvider*)iProviderList[i])->IsTrustedByL(aService))

                    {

                    return (CSenIdentityProvider*)iProviderList[i];

                    }

                }

            }

        if(!aStrict)

            {

            if (!pTrusted)

                {

                if (((CSenIdentityProvider*)iProviderList[i])->IsTrustedByL(aService))

                    {

                    pTrusted = (CSenIdentityProvider*)iProviderList[i];

                    }

                }

            // to optimize the search, store the default IDP, if found

            if(((CSenIdentityProvider*)iProviderList[i])->IsDefault())

                {

                pDefault = (CSenIdentityProvider*)iProviderList[i];

                }

            }

        }

    if(aStrict)

        {

        // default idp does not meet the search requirements

        // (not in strict pattern list)

        return NULL;

        }

    else

        {

        // if current item did not match with anything in the

        // pattern list, check if it's ok in non-strict perspective

        if (pTrusted)

            {

            return pTrusted;

            }

        else

            {

            return pDefault;

            }

        }

    }

CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL()

    {

    TInt idpCount(iProviderList.Count());

    CSenIdentityProvider* pDefaultIdp = NULL;

    for (TInt i=0; i<idpCount && !pDefaultIdp; i++)

        {

        pDefaultIdp = (CSenIdentityProvider*)iProviderList[i];

        if (!pDefaultIdp->IsDefault()) pDefaultIdp = NULL;

        }

    if (!pDefaultIdp && idpCount > 0)

        {

        // use the first IdentityProvider

        pDefaultIdp = (CSenIdentityProvider*)iProviderList[0];

        }

    return pDefaultIdp;

    }

const RIdentityProviderList& CSenBaseIdentity::IdentityProvidersL() const

    {

    return iProviderList;

    }

// NOTE: takes ownership of the given apIdentityProvider

TInt CSenBaseIdentity::RegisterIdentityProviderL(CSenIdentityProvider* apIdentityProvider )

    {

    //SENDEBUG_L("CSenBaseIdentity::RegisterIdentityProviderL(*)");

    if(!apIdentityProvider)

        {

        SENDEBUG_L("RegisterIdentityProviderL(*) - Illegal argument: NULL");

        return KErrArgument;

        }

    if (apIdentityProvider->Endpoint() == KNullDesC8)

        {

        SENDEBUG_L("RegisterIdentityProviderL(*) - Error: no Endpoint in IDP");

        //Delete the object since ownership is with us

        delete apIdentityProvider;		

        apIdentityProvider = NULL;        

        return KErrSenNoEndpoint;

        }

    TInt retVal(KErrNone);

    // Now check for duplicates:

    CSenIdentityProvider* pDuplicate = NULL;

    retVal = FindMatchingIdentityProviderL(*apIdentityProvider, pDuplicate);

    if(pDuplicate)

        {

        //SENDEBUG((_L("  Duplicate(s) found, updating the IdP!.")));

        RPointerArray<CSenElement> newElements =

                            apIdentityProvider->AsElement().ElementsL();

        TInt elemCount = newElements.Count();

        TInt i(0);

        // Checking the aIdp elements

        while ( i < elemCount )

            {

            CSenElement* elem = newElements[i];

            TPtrC8 localName = elem->LocalName();

            RPointerArray<CSenElement> pDuplicateAsElems =

                                    pDuplicate->AsElement().ElementsL();

            TInt duplicateCount = pDuplicateAsElems.Count();

            TBool found = EFalse;

            TBool foundServiceID = EFalse;

            TInt j(0);

            // Checking if the duplicate has the element found from aIdp

            // If found update it, if not found insert new element.

            while ( j < duplicateCount )

                {

                CSenElement* dupElem = pDuplicateAsElems[j];

                if ( localName == dupElem->LocalName() )

                    {

                    if ( localName == KServiceIDElementLocalName )

                        {

                        if ( elem->Content() == dupElem->Content() )

                            {

                            foundServiceID = ETrue;

                            }

                        }

                    else

                        {

                        // note, this create the element if it

                        // is not found

                        if (elem->Content() != KNullDesC8)

                            {

                            dupElem->SetContentL( elem->Content() );

                            }

                        RPointerArray<CSenElement> nestedElems = elem->ElementsL();

                        for (TInt k = 0; k < nestedElems.Count(); k++)

                            {

                            CSenElement* dupNestEl = dupElem->Element(nestedElems[k]->LocalName());

                            if (dupNestEl)

                                {

                                dupNestEl->SetContentL(nestedElems[k]->Content());

                                }

                            else

                                {

                                CSenElement* newEl = dupElem->CreateElementL(nestedElems[k]->NsPrefix(),

                                                        nestedElems[k]->LocalName());

                                CleanupStack::PushL(newEl);

                                dupElem->AddElementL(*newEl);

                                CleanupStack::Pop(newEl);

                                newEl->SetContentL(nestedElems[k]->Content());

                                }

                            }

                        //cleaning, if sth has been removed on backend

                        //nested duplicate - local

                        //nested - backend

                        RPointerArray<CSenElement> nestedDupElems = dupElem->ElementsL();

                        for (TInt k = 0; k < nestedDupElems.Count(); k++)

                            {

                            CSenElement* nestEl = elem->Element(nestedDupElems[k]->LocalName());

                            if (!nestEl)

                                {

                                nestedDupElems[k]->SetContentL(KNullDesC8);

                                }

                            }

                        found = ETrue;

                        break;

                        }

                    }

                j++;

                }

            if ( !found && !foundServiceID && elem)

                {

                // this is new kind of element, and not in original

                // idp, thus it needs to be copied because it is 

                // owned by idp being registered (which will be

                // deleted inside this method)

                CSenElement* pCopy = 

                    CSenXmlElement::NewL( elem->LocalName() ); 

                CleanupStack::PushL(pCopy);

                // copy the contents of serviceid 

                pCopy->CopyFromL(*elem);

                // append the copy into original idp

                pDuplicate->AsElement().AddElementL( *pCopy );

                CleanupStack::Pop(); // pCopy

                }

            i++;

            }

        // NOTE: ownership of the given argument apIdentityProvider

        // will NOT be TRANSFERRED to anywhere.

        // So: free the memory, contents copied and thus updated

        delete apIdentityProvider;

        apIdentityProvider = NULL;

        if(retVal > 0)

            retVal = KErrNone;

        }

    else if(retVal==KErrNotFound)

        {

        //SENDEBUG((_L("  No duplicate(s) found, will try to add..")));

        // Append into both provider list and as child element

        retVal = iProviderList.Append( apIdentityProvider );

        if(retVal==KErrNone)

            {

            // OWNERSHIP of apIdentityProvider is now here

            TInt leaveCode(KErrNone);

            TRAP( leaveCode, AsElement().AddElementL(apIdentityProvider->AsElement() ) );

            if(leaveCode!=KErrNone)

                {

                retVal = leaveCode;

                // no need to free the apIdentityProvider, it will

                // be destroyed in destructor as part of iProviderList

                }                                    

            }

        else

            {

            // free the orphan apIdentityProvider

            delete apIdentityProvider;

            apIdentityProvider = NULL;

            }

        }

    else // some other error occurred: free the orphan argument

        {

        //SENDEBUG((_L("An error occured  and no duplicate(s) were found.")));

        delete apIdentityProvider;

        apIdentityProvider = NULL;

        }

    return retVal;

    }

TInt CSenBaseIdentity::UpdateIdentityProviderL(CSenIdentityProvider& aIdentityProvider)

    {

    if (aIdentityProvider.Endpoint() == KNullDesC8)

        {

        SENDEBUG_L("RegisterIdentityProviderL(*) - Error: no Endpoint in IDP");

        return KErrSenNoEndpoint;

        }

    TInt retVal(KErrNone);

    // Now check for duplicates:

    CSenIdentityProvider* pDuplicate = NULL;

    retVal = FindMatchingIdentityProviderL(aIdentityProvider, pDuplicate);

    if(pDuplicate)

        {

        //SENDEBUG((_L("  Duplicate(s) found, updating the IdP!.")));

        RPointerArray<CSenElement> newElements =

                            aIdentityProvider.AsElement().ElementsL();

        TInt elemCount = newElements.Count();

        TInt i(0);

        // Checking the aIdp elements

        while ( i < elemCount )

            {

            CSenElement* elem = newElements[i];

            TPtrC8 localName = elem->LocalName();

            RPointerArray<CSenElement> pDuplicateAsElems =

                                    pDuplicate->AsElement().ElementsL();

            TInt duplicateCount = pDuplicateAsElems.Count();

            TBool found = EFalse;

            TBool foundServiceID = EFalse;

            TInt j(0);

            // Checking if the duplicate has the element found from aIdp

            // If found update it, if not found insert new element.

            while ( j < duplicateCount )

                {

                CSenElement* dupElem = pDuplicateAsElems[j];

                if ( localName == dupElem->LocalName() )

                    {

                    if ( localName == KServiceIDElementLocalName )

                        {

                        if ( elem->Content() == dupElem->Content() )

                            {

                            foundServiceID = ETrue;

                            }

                        }

                    else

                        {

                        // note, this create the element if it

                        // is not found

                        dupElem->SetContentL( elem->Content() );

                        found = ETrue;

                        break;

                        }

                    }

                j++;

                }

            if ( !found && !foundServiceID && elem)

                {

                // this is new kind of element, and not in original

                // idp, thus it needs to be copied because it is 

                // owned by idp being registered (which will be

                // deleted inside this method)

                CSenElement* pCopy = 

                    CSenXmlElement::NewL( elem->LocalName() ); 

                CleanupStack::PushL(pCopy);

                // copy the contents of serviceid 

                pCopy->CopyFromL(*elem);

                // append the copy into original idp

                pDuplicate->AsElement().AddElementL( *pCopy );

                CleanupStack::Pop(); // pCopy

                }

            i++;

            }

        if(retVal > 0)

            retVal = KErrNone;

        }