/*

* 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 "seninternalcredential.h"

#include "SenFacet.h"

#include <SenXmlElement.h> // check if this include is needed(?)

#include "senwsdescription.h"

#include "SenDateUtils.h"

#include <SenIdentityProvider.h>

#include "senlogger.h"

#ifdef SYMBIAN_SECURE_ECOM

    // for S60 FP3 (2.8) platform or newer (3.0 and above)

    #include <xml/attribute.h> // needed for RAttributeArray

//#else  // for S60 FP2 platform (2.6) or older

    //#include "Attribute.h"

#endif

using namespace Xml;

namespace

    {

    _LIT8(KProviderIdLocalName,  "ProviderID");

    _LIT8(KUserName,             "AuthzID");

    _LIT8(KPassword,             "Password");

    const TInt KCredIdBufSize    = 128;    

    }

EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL()

    {

    CSenInternalCredential* pNew = NewLC();

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC()

    {

    CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential;

    CleanupStack::PushL(pNew);

    pNew->ConstructL(KNullDesC8);

    return pNew;

    }

EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL(

                                           	const TDesC8& aNsUri,

                                            const TDesC8& aLocalName,

                                            const TDesC8& aQName,

                                            const RAttributeArray& aAttributes)

    {

    CSenInternalCredential* pNew = NewLC(aNsUri, aLocalName, aQName, aAttributes);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC(

                                            const TDesC8& aNsUri,

                                            const TDesC8& aLocalName,

                                            const TDesC8& aQName,

                                            const RAttributeArray& aAttributes)

    {

    CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential;

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aNsUri, aLocalName, aQName, aAttributes);

    return pNew;

    }

EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL(

                                            const TDesC8& aNsUri,

                                            const TDesC8& aLocalName,

                                            const TDesC8& aQName,

                                            const RAttributeArray& aAttributes,

                                            TXmlEngElement& aParent)

    {

    CSenInternalCredential* pNew = NewLC(aNsUri, aLocalName,

                                         aQName, aAttributes, aParent);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC(

                                            const TDesC8& aNsUri,

                                            const TDesC8& aLocalName,

                                            const TDesC8& aQName,

                                            const RAttributeArray& aAttributes,

                                            TXmlEngElement& aParent)

    {

    CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential;

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent);

    return pNew;

    }

EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL(

                                            const TDesC8& aNsUri,

                                            const TDesC8& aLocalName,

                                            const TDesC8& aQName,

                                            const RAttributeArray& aAttributes,

                                            TXmlEngElement& aParent,

                                            RSenDocument& aOwnerDocument)

    {

    CSenInternalCredential* pNew = NewLC(aNsUri, aLocalName,

                                         aQName, aAttributes,

                                         aParent, aOwnerDocument);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC(

                                            const TDesC8& aNsUri,

                                            const TDesC8& aLocalName,

                                            const TDesC8& aQName,

                                            const RAttributeArray& aAttributes,

                                            TXmlEngElement& aParent,

                                            RSenDocument& aOwnerDocument)

    {

    CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential;

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent,

                     aOwnerDocument);

    return pNew;

    }

EXPORT_C CSenInternalCredential* CSenInternalCredential::NewL(

                                             const CSenInternalCredential& aCredential)

    {

    CSenInternalCredential* pNew = NewLC(aCredential);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenInternalCredential* CSenInternalCredential::NewLC(

                                             const CSenInternalCredential& aCredential)

    {

    CSenInternalCredential* pNew = new (ELeave) CSenInternalCredential;

    CleanupStack::PushL(pNew);

    pNew->ConstructL((CSenInternalCredential&)aCredential);

    return pNew;

    }

EXPORT_C void CSenInternalCredential::ConstructL(CSenInternalCredential& aCredential)

    {

    CSenCredential2::BaseConstructL(aCredential);

    }

EXPORT_C void CSenInternalCredential::ConstructL(const TDesC8&  aNsUri,

                                          const TDesC8&  aLocalName,

                                          const TDesC8&  aQName,

                                          const RAttributeArray& aAttributes,

                                          TXmlEngElement& aParent)

    {

    CSenCredential2::BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent);

    }

EXPORT_C void CSenInternalCredential::ConstructL(const TDesC8&  aNsUri,

                                          const TDesC8&  aLocalName,

                                          const TDesC8&  aQName,

                                          const RAttributeArray& aAttributes,

                                          TXmlEngElement& aParent,

                                          RSenDocument& aOwnerDocument)

    {

    CSenCredential2::BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent, aOwnerDocument);

    }

EXPORT_C void CSenInternalCredential::ConstructL(const TDesC8&  aNsUri,

                                          const TDesC8&  aLocalName,

                                          const TDesC8&  aQName,

                                          const RAttributeArray& aAttributes)

    {

    CSenCredential2::BaseConstructL(aNsUri, aLocalName, aQName, aAttributes);

    }

EXPORT_C void CSenInternalCredential::ConstructL(const TDesC8& aLocalName)

    {

    CSenFragmentBase::BaseConstructL(aLocalName);

    }

EXPORT_C CSenInternalCredential::CSenInternalCredential()

    {

    }

EXPORT_C CSenInternalCredential::~CSenInternalCredential()

    {

    delete ipIdentifier;

    delete ipProperties;

    }

EXPORT_C TBool CSenInternalCredential::IsApplicableL(const CSenWSDescription& aPattern)	//codescannerwarings

    {

    TPtrC8 value;

    CSenElement* valueElement;

    CSenElement& patternElement = ((CSenWSDescription&)aPattern).AsElement();

    CSenCredentialIdentifier& identifier = IdentifierL();	//codescannerwarings

    RXmlEngNodeList<TXmlEngAttr> attrList;

    RXmlEngNodeList<TXmlEngElement> list;

    CleanupClosePushL(list);

    TXmlEngElement element = identifier.AsElementL();

    element.GetChildElements(list);

    while ( list.HasNext() )

        {

        TXmlEngElement element = list.Next();

        if ( (element.Name() != KSenCredentialId) &&

             (element.Name() != KProviderIdLocalName)  &&

             (element.Name() != KSenIdpAuthzIDLocalname) &&

             (element.Name() != KSenIdpPasswordLocalname) )

            {

            HBufC8* pTag = element.Name().AllocLC();

            CleanupStack::PopAndDestroy(pTag);

            valueElement = patternElement.Element(element.Name());

            if ( valueElement )

                {

                HBufC8* pElement1 = valueElement->Content().AllocLC();

                HBufC8* pElement2 = element.Text().AllocLC();

                CleanupStack::PopAndDestroy(pElement2);

                CleanupStack::PopAndDestroy(pElement1);

                if ( valueElement->Content() != element.Text() )

                    {

                    CleanupStack::PopAndDestroy(&list); // Close()

                    return EFalse;

                    }

                else

                    {

                    element.GetAttributes(attrList);

                    CleanupClosePushL(attrList);

                    while ( attrList.HasNext() )

                        {

                        TXmlEngAttr attr = attrList.Next();

                        if ( *valueElement->AttrValue(attr.Name()) != attr.Value() )

                            {

                            CleanupStack::PopAndDestroy(&attrList); // Close()

                            CleanupStack::PopAndDestroy(&list); // Close()

                            return EFalse;

                            }

                        }

                    CleanupStack::PopAndDestroy(&attrList); // Close()

                    }

                }

            else

                {

                CleanupStack::PopAndDestroy(&list); // Close()

                return EFalse;

                }

            }

        }

    CleanupStack::PopAndDestroy(&list); // Close()

    return ETrue;

    }

EXPORT_C void CSenInternalCredential::SetIdentifier(CSenCredentialIdentifier* aIdentifier)

    {

    if ( ipIdentifier )

        {

        delete ipIdentifier;

        }

    ipIdentifier = aIdentifier;

    }

EXPORT_C CSenCredentialIdentifier& CSenInternalCredential::IdentifierL()	//codescannerwarings

    {

    if ( !ipIdentifier )

        {

        ipIdentifier = CSenCredentialIdentifier::NewL();

        }

    return *ipIdentifier;

    }

EXPORT_C void CSenInternalCredential::SetProperties(CSenCredentialProperties* aProperties)

    {

    if ( ipProperties )

        {

        delete ipProperties;

        }

    ipProperties = aProperties;

    }

EXPORT_C CSenCredentialProperties& CSenInternalCredential::PropertiesL()	//codescannerwarings

    {

    if ( !ipProperties )

        {

        ipProperties = CSenCredentialProperties::NewL();

        }

    return *ipProperties;

    }

EXPORT_C TBool CSenInternalCredential::HasProperties()

    {

    if ( !ipProperties )

        {

        return EFalse;

        }

    else 

        {

        return ETrue;

        }

    }

EXPORT_C void CSenInternalCredential::SetIdentityProviderIdL(TDesC8& aIdentityProviderId)

    {

    IdentifierL().SetPropertyL(KProviderIdLocalName, aIdentityProviderId);	//codescannerwarings

    }

EXPORT_C void CSenInternalCredential::SetAuthInfo(TDesC8& aUserId, TDesC8& aPassword)

    {

		TInt retVal(KErrNone);

    TRAP(retVal,

    		IdentifierL().SetPropertyL(KUserName, aUserId);

    		IdentifierL().SetPropertyL(KPassword, aPassword);

    		);

    }

EXPORT_C TInt CSenInternalCredential::IdentityProviderIdL(TPtrC8& aIdTo)

    {

    return IdentifierL().PropertyL(KProviderIdLocalName, aIdTo);	//codescannerwarings

    }

EXPORT_C void CSenInternalCredential::SetSession(CSenServiceSession& aSession)

    {

    ipSession = &aSession;

    }

EXPORT_C CSenServiceSession* CSenInternalCredential::Session()

    {

    return ipSession;

    }

EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewL()

    {

    CSenCredentialProperties* pNew = NewLC();

    CleanupStack::Pop(pNew);

    return pNew;

    }

EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewLC()

    {

    CSenCredentialProperties* pNew = new (ELeave) CSenCredentialProperties;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(KSenCredentialProperteisLocalname);

    return pNew;

    }

EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewL(

                                            const TDesC8& aNsUri,

                                            const TDesC8& aLocalName,

                                            const TDesC8& aQName,

                                            const RAttributeArray& aAttributes)

    {

    CSenCredentialProperties* pNew = NewLC(aNsUri, aLocalName, aQName, aAttributes);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewLC(

                                            const TDesC8& aNsUri,

                                            const TDesC8& aLocalName,

                                            const TDesC8& aQName,

                                            const RAttributeArray& aAttributes)

    {

    CSenCredentialProperties* pNew = new (ELeave) CSenCredentialProperties;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes);

    return pNew;

    }

EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewL(

                                            const TDesC8& aNsUri,

                                            const TDesC8& aLocalName,

                                            const TDesC8& aQName,

                                            const RAttributeArray& aAttributes,

                                            TXmlEngElement& aParent)

    {

    CSenCredentialProperties* pNew = NewLC(aNsUri, aLocalName,

                                           aQName, aAttributes, aParent);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewLC(

                                            const TDesC8& aNsUri,

                                            const TDesC8& aLocalName,

                                            const TDesC8& aQName,

                                            const RAttributeArray& aAttributes,

                                            TXmlEngElement& aParent)

    {

    CSenCredentialProperties* pNew = new (ELeave) CSenCredentialProperties;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent);

    return pNew;

    }

EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewL(

                                            const TDesC8& aNsUri,

                                            const TDesC8& aLocalName,

                                            const TDesC8& aQName,

                                            const RAttributeArray& aAttributes,

                                            TXmlEngElement& aParent,

                                            RSenDocument& aOwnerDocument)

    {

    CSenCredentialProperties* pNew = NewLC(aNsUri, aLocalName,

                                           aQName, aAttributes,

                                           aParent, aOwnerDocument);

    CleanupStack::Pop(); // pNew;

    return pNew;

    }

EXPORT_C CSenCredentialProperties* CSenCredentialProperties::NewLC(

                                            const TDesC8& aNsUri,

                                            const TDesC8& aLocalName,

                                            const TDesC8& aQName,

                                            const RAttributeArray& aAttributes,

                                            TXmlEngElement& aParent,

                                            RSenDocument& aOwnerDocument)

    {

    CSenCredentialProperties* pNew = new (ELeave) CSenCredentialProperties;

    CleanupStack::PushL(pNew);

    pNew->BaseConstructL(aNsUri, aLocalName, aQName, aAttributes, aParent,

                         aOwnerDocument);

    return pNew;

    }

EXPORT_C CSenCredentialProperties::~CSenCredentialProperties()

    {

    }

CSenCredentialProperties::CSenCredentialProperties()

    {

    }

EXPORT_C TInt CSenCredentialProperties::SetPropertyL(const TDesC8& aName,

                                                         const TDesC8& aValue)

    {

    TXmlEngElement element = AsElementL();

    RXmlEngNodeList<TXmlEngElement> list;

    CleanupClosePushL(list);

    element.GetElementsByTagNameL(list, aName);

    if ( list.Count() > 0 )

        {

        TXmlEngElement firstElement = list.Next();

        firstElement.SetTextNoEncL(aValue);

        CleanupStack::PopAndDestroy(&list); // Close();

        return KErrNone;

        }

    CleanupStack::PopAndDestroy(&list);

    TXmlEngElement newElement = element.AddNewElementL(aName);

    newElement.SetTextNoEncL(aValue);

    return KErrNone;

    }

EXPORT_C TInt CSenCredentialProperties::PropertyL(const TDesC8& aName, TPtrC8& aValue)

    {

    TInt retVal(KErrNone);

    TXmlEngElement element = AsElementL();

    RXmlEngNodeList<TXmlEngElement> list;

    CleanupClosePushL(list);

    element.GetElementsByTagNameL(list, aName);

    if ( list.Count() > 0 )

        {

        TXmlEngElement firstElement = list.Next();

        aValue.Set(firstElement.Text());

        }

    else

        {

        retVal = KErrNotFound;

        }

    CleanupStack::PopAndDestroy(&list);

    return retVal;

    }

EXPORT_C TInt CSenCredentialProperties::FacetValueL(TDesC8& aURI,

                                                        HBufC8*& aValueTo)

    {

    TInt retVal(KErrNotFound);

    TXmlEngElement element = AsElementL();

    RXmlEngNodeList<TXmlEngElement> list;

    CleanupClosePushL(list);

    element.GetElementsByTagNameL(list, KSenFacet);

    if ( list.Count() > 0 )

        {

        TXmlEngElement element;