/*

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

#include "wspolicy.h"

#include "wssecuritypolicyconstants.h"

using namespace WsSecurityPolicy;

CWsSecurityPolicy* CWsSecurityPolicy::NewL()

{

    CWsSecurityPolicy* pSelf =

        CWsSecurityPolicy::NewLC();

    CleanupStack::Pop(pSelf);

    return pSelf;

}

CWsSecurityPolicy* CWsSecurityPolicy::NewLC()

{

    CWsSecurityPolicy* pSelf = new (ELeave) CWsSecurityPolicy();

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL();

    return pSelf;  

}

void CWsSecurityPolicy::ConstructL()

{

}

CWsSecurityPolicy::~CWsSecurityPolicy()

{

}

CWsSecurityPolicy::CWsSecurityPolicy()

{

}

CSenElement* CWsSecurityPolicy::IntersectL(TDesC8& aKey, CSenElement* aFirst, CSenElement* aSecond)

    {

    TBool reply(EFalse);

    if(aKey.Compare(KAsymmetricBinding) == 0)

        {

        CAsymmetricBinding* firstBinding = CAsymmetricBinding::NewL(aFirst);

        CleanupStack::PushL( firstBinding );

        CAsymmetricBinding* secondBinding = CAsymmetricBinding::NewL(aSecond);

        CleanupStack::PushL( secondBinding );

        reply = firstBinding->IsEqualAsymmtericAssertion( secondBinding );        

        CleanupStack::PopAndDestroy( secondBinding ); // delete secondBinding;

        CleanupStack::PopAndDestroy( firstBinding ); // delete firstBinding;

        }

    else if(aKey.Compare(KSymmetricBinding) == 0)

        {

        CSymmetricBinding* firstBinding = CSymmetricBinding::NewL(aFirst);

        CleanupStack::PushL( firstBinding );

        CSymmetricBinding* secondBinding = CSymmetricBinding::NewL(aSecond);

        CleanupStack::PushL( secondBinding );

        reply = firstBinding->IsEqualSymmtericAssertion(secondBinding);

        CleanupStack::PopAndDestroy( secondBinding ); // delete secondBinding;

        CleanupStack::PopAndDestroy( firstBinding ); // delete firstBinding;

        }

    else if(aKey.Compare(KWss10) == 0)

        {

        CWss10* pFirstAssertion = CWss10::NewL(aFirst);

        CleanupStack::PushL( pFirstAssertion );

        CWss10* pSecondAssertion = CWss10::NewL(aSecond);

        CleanupStack::PushL( pSecondAssertion );

        reply = pFirstAssertion->IsEqualWss10Assertion(pSecondAssertion);

        CleanupStack::PopAndDestroy( pSecondAssertion ); // delete pSecondAssertion;

        CleanupStack::PopAndDestroy( pFirstAssertion ); // delete pFirstAssertion;

        }

    else if(aKey.Compare(KWss11) == 0)

        {

        CWss11* pFirstAssertion = CWss11::NewL(aFirst);

        CleanupStack::PushL( pFirstAssertion );

        CWss11* pSecondAssertion = CWss11::NewL(aSecond);

        CleanupStack::PushL( pSecondAssertion );

        reply = pFirstAssertion->IsEqualWss11Assertion(pSecondAssertion);

        CleanupStack::PopAndDestroy( pSecondAssertion ); // delete pSecondAssertion;

        CleanupStack::PopAndDestroy( pFirstAssertion ); // delete pFirstAssertion;

        }

    else if(aKey.Compare(KTrust10) == 0)

        {

        CWsTrust10* pFirstAssertion = CWsTrust10::NewL(aFirst);

        CleanupStack::PushL( pFirstAssertion );

        CWsTrust10* pSecondAssertion = CWsTrust10::NewL(aSecond);

        CleanupStack::PushL( pSecondAssertion );

        reply = pFirstAssertion->IsEqualWsTrust10Assertion(pSecondAssertion);

        CleanupStack::PopAndDestroy( pSecondAssertion ); // delete pSecondAssertion;

        CleanupStack::PopAndDestroy( pFirstAssertion ); // delete pFirstAssertion;

        }

    else if(aKey.Compare(KSignedParts) == 0 || aKey.Compare(KEncryptedParts) == 0 )

        {

        CEncryptedSignedParts* pFirstAssertion = CEncryptedSignedParts::NewL(aFirst);

        CleanupStack::PushL( pFirstAssertion );

        CEncryptedSignedParts* pSecondAssertion = CEncryptedSignedParts::NewL(aSecond);        

        CleanupStack::PushL( pSecondAssertion );

        reply = pFirstAssertion->IsEqualEncryptedSignedParts(pSecondAssertion);

        CleanupStack::PopAndDestroy( pSecondAssertion ); // delete pSecondAssertion;

        CleanupStack::PopAndDestroy( pFirstAssertion ); // delete pFirstAssertion;

        }   

    else if(aKey.Compare(KSignedElements) == 0 || aKey.Compare(KEncryptedElements) == 0 )

        {

        CEncryptedSignedElements* pFirstAssertion = CEncryptedSignedElements::NewL(aFirst);

        CleanupStack::PushL( pFirstAssertion );

        CEncryptedSignedElements* pSecondAssertion = CEncryptedSignedElements::NewL(aSecond);

        CleanupStack::PushL( pSecondAssertion );

        reply = pFirstAssertion->IsEqualEncryptedSignedElements(pSecondAssertion);

        CleanupStack::PopAndDestroy( pSecondAssertion ); // delete pSecondAssertion;

        CleanupStack::PopAndDestroy( pFirstAssertion ); // delete pFirstAssertion;

        }   

    // return the first, if comparison equals

    if (reply)

        {

        return aFirst;

        }

    else

        {

        return NULL;

        }

    }

CSenElement* CWsSecurityPolicy::MergeL(TDesC8& aKey, CSenElement* aFirst, CSenElement* aSecond)

    {

    TBool reply(EFalse);

    if(aKey.Compare(KAsymmetricBinding) == 0)

    {

        CAsymmetricBinding* firstBinding = CAsymmetricBinding::NewL(aFirst);

        CleanupStack::PushL( firstBinding );

        CAsymmetricBinding* secondBinding = CAsymmetricBinding::NewL(aSecond);

        CleanupStack::PushL( secondBinding );

        reply = firstBinding->IsEqualAsymmtericAssertion(secondBinding);

        CleanupStack::PopAndDestroy( secondBinding ); // delete secondBinding;

        CleanupStack::PopAndDestroy( firstBinding ); // delete firstBinding;

        }

    else if(aKey.Compare(KSymmetricBinding) == 0)

        {

        CSymmetricBinding* firstBinding = CSymmetricBinding::NewL(aFirst);

        CleanupStack::PushL( firstBinding );

        CSymmetricBinding* secondBinding = CSymmetricBinding::NewL(aSecond);

        CleanupStack::PushL( secondBinding );

        reply = firstBinding->IsEqualSymmtericAssertion(secondBinding);

        CleanupStack::PopAndDestroy( secondBinding ); // delete secondBinding;

        CleanupStack::PopAndDestroy( firstBinding ); // delete firstBinding;

        }

    else if(aKey.Compare(KWss10) == 0)

        {

        CWss10* pFirstAssertion = CWss10::NewL(aFirst);

        CleanupStack::PushL( pFirstAssertion );

        CWss10* pSecondAssertion = CWss10::NewL(aSecond);

        CleanupStack::PushL( pSecondAssertion );

        reply = pFirstAssertion->IsEqualWss10Assertion(pFirstAssertion);

        CleanupStack::PopAndDestroy( pSecondAssertion ); // delete pSecondAssertion;

        CleanupStack::PopAndDestroy( pFirstAssertion ); // delete pFirstAssertion;

        }

    else if(aKey.Compare(KWss11) == 0)

        {

        CWss11* pFirstAssertion = CWss11::NewL(aFirst);

        CleanupStack::PushL( pFirstAssertion );

        CWss11* pSecondAssertion = CWss11::NewL(aSecond);

        CleanupStack::PushL( pSecondAssertion );

        reply = pFirstAssertion->IsEqualWss11Assertion(pSecondAssertion);

        CleanupStack::PopAndDestroy( pSecondAssertion ); // delete pSecondAssertion;

        CleanupStack::PopAndDestroy( pFirstAssertion ); // delete pFirstAssertion;

        }

     else if(aKey.Compare(KTrust10) == 0)

        {

        CWsTrust10* pFirstAssertion = CWsTrust10::NewL(aFirst);

        CleanupStack::PushL( pFirstAssertion );

        CWsTrust10* pSecondAssertion = CWsTrust10::NewL(aSecond);

        CleanupStack::PushL( pSecondAssertion );

        reply = pFirstAssertion->IsEqualWsTrust10Assertion(pSecondAssertion);

        CleanupStack::PopAndDestroy( pSecondAssertion ); // delete pSecondAssertion;

        CleanupStack::PopAndDestroy( pFirstAssertion ); // delete pFirstAssertion;

        }   

    else if(aKey.Compare(KSignedParts) == 0 || aKey.Compare(KEncryptedParts) == 0 )

        {

        CEncryptedSignedParts* pFirstAssertion = CEncryptedSignedParts::NewL(aFirst);

        CleanupStack::PushL( pFirstAssertion );

        CEncryptedSignedParts* pSecondAssertion = CEncryptedSignedParts::NewL(aSecond);        

        CleanupStack::PushL( pSecondAssertion );

        reply = pFirstAssertion->IsEqualEncryptedSignedParts(pSecondAssertion);

        CleanupStack::PopAndDestroy( pSecondAssertion ); // delete pSecondAssertion;

        CleanupStack::PopAndDestroy( pFirstAssertion ); // delete pFirstAssertion;

        }   

    else if(aKey.Compare(KSignedElements) == 0 || aKey.Compare(KEncryptedElements) == 0 )

        {

        CEncryptedSignedElements* pFirstAssertion = CEncryptedSignedElements::NewL(aFirst);

        CleanupStack::PushL( pFirstAssertion );

        CEncryptedSignedElements* pSecondAssertion = CEncryptedSignedElements::NewL(aSecond);

        CleanupStack::PushL( pSecondAssertion );

        reply = pFirstAssertion->IsEqualEncryptedSignedElements(pSecondAssertion);

        CleanupStack::PopAndDestroy( pSecondAssertion ); // delete pSecondAssertion;

        CleanupStack::PopAndDestroy( pFirstAssertion ); // delete pFirstAssertion;

//        RArray<TPtrC8> result;

//        TBool signAll = firstAssertion->MergedElements(SecondAssertion, result);

//        CSenElement* mergedEelement = aFirst.CopyL();

//        mergedEelement.RemoveChildren();

//        

//        if(!signAll)

//        {

//

//            //reply value depends on it

//            if(//reply && 

//            result.Count() > 0)

//            {

////                TString argument;

////                argument.SetL(KXPath);

//                for(TInt i = 0; i< result.Count(); i++)

//                {//Copy original element, delete all children and add new children

//                    

//                    TPtrC8 te= result[i];

////                    TString content;

////                    content.SetL(te);

//                    CSenElement* xpath = mergedEelement.AddNewElementSameNsL(KXPath);

//                    xpath.AddTextL(te);

////                    content.Close();

//                }

////                argument.Close();

//

//              }

//        

//        }

//

        }   

    if (reply)

        {

        return aFirst;

        }

    else

        {

        return NULL;

        }

    }

///////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////

CToken::~CToken()

    {

    }

CToken::CToken():

iTokenInclusion(KIncludeAlways),

iDerivedKeys(EFalse)

    {

    }

void CToken::ConstructL(CSenElement* aToken)

    {

    const TDesC8* attr = aToken->AttrValue(KIncludeToken);

    if(attr)

        {

        HBufC8* attrib = attr->AllocL();

        TPtrC8 includeToken = attrib->Des();

        if(includeToken.Compare(KIncludeNever) == 0)

            iTokenInclusion.Set(KIncludeNever);

        else if(includeToken.Compare(KIncludeOnce) == 0)

            iTokenInclusion.Set(KIncludeOnce);

        else if(includeToken.Compare(KIncludeAlwaysToReceipent) == 0)

            iTokenInclusion.Set(KIncludeAlwaysToReceipent);

        else if(includeToken.Compare(KIncludeAlways) == 0)

            iTokenInclusion.Set(KIncludeAlways);

        delete attrib;

        }

   }

void CToken::BaseConstructL(CSenElement* aToken)

    {

    ConstructL(aToken);

    }

CHttpsToken* CHttpsToken::NewL(CSenElement* aToken)

    {

    CHttpsToken* pSelf = CHttpsToken::NewLC(aToken);

    CleanupStack::Pop(pSelf);

    return pSelf;

    }

CHttpsToken* CHttpsToken::NewLC(CSenElement* aToken)

    {

    CHttpsToken* pSelf = new (ELeave) CHttpsToken();

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL(aToken);

    return pSelf;  

    }

CHttpsToken::~CHttpsToken()

    {

    }

CHttpsToken::CHttpsToken():

iRequireClientCertificate(ETrue)

{

}

void CHttpsToken::ConstructL(CSenElement* aToken)

    {

    const TDesC8* attr = aToken->AttrValue(KRequireClientCertificate); 

    if(attr)

        {

        HBufC8* attrib = attr->AllocL();

        TPtrC8 requireCertificateToken = attrib->Des();

        if(requireCertificateToken.Compare(KTrue) == 0)

            iRequireClientCertificate = ETrue;

        else if(requireCertificateToken.Compare(KFalse) == 0)

            iRequireClientCertificate = EFalse;

        }

    RPointerArray<CSenElement>& tokenChildren = aToken->ElementsL();

    CSenElement* child = NULL;

    for (TInt i = 0; i < tokenChildren.Count(); i++)

        { 

        //There should be only one element here the TokenType

        child = tokenChildren[i];

        TPtrC8 localName = child->LocalName();

        if(localName.Compare(WSPolicy::KWsPolicy) == 0)

            {

            iPolicy = child;

            }

        }

    }

CSamlToken* CSamlToken::NewL(CSenElement* aToken)

{

    CSamlToken* pSelf = CSamlToken::NewLC(aToken);

    CleanupStack::Pop(pSelf);

    return pSelf;

}

CSamlToken* CSamlToken::NewLC(CSenElement* aToken)

{

    CSamlToken* pSelf = new (ELeave) CSamlToken();

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL(aToken);

    return pSelf; 

}

CSamlToken::~CSamlToken()

{

}

CSamlToken::CSamlToken()

{

}

void CSamlToken::ConstructL(CSenElement* aToken)

{

    BaseConstructL(aToken);

    CSenElement* AND = CXmlHelper::RipPolicyXORElementL(aToken);

    RPointerArray<CSenElement>& tokenChildren =   AND->ElementsL();

    CSenElement* child;

    for (TInt i = 0; i < tokenChildren.Count(); i++)

    { //There should be only one element here the TokenType

        child = tokenChildren[i];

        TPtrC8 localName = child->LocalName();

        if(localName.Compare(KRequireKeyIdentifierReference) == 0)

        {

            iRequireKeyIdentifierReference = ETrue;

        }

        else if(localName.Compare(KWssSamlV10Token10) == 0)

        {

            iSamlTokenProfile.Set(KWssSamlV10Token10);

        }

        else if(localName.Compare(KWssSamlV11Token10) == 0)

        {

            iSamlTokenProfile.Set(KWssSamlV11Token10);

        }

        else if(localName.Compare(KWssSamlV10Token11) == 0)

        {

            iSamlTokenProfile.Set(KWssSamlV10Token11);

        }

        else if(localName.Compare(KWssSamlV11Token11) == 0)

        {

            iSamlTokenProfile.Set(KWssSamlV11Token11);

        }

        else if(localName.Compare(KWssSamlV20Token11) == 0)

        {

            iSamlTokenProfile.Set(KWssSamlV20Token11);

        }

    }

}

CUsernameToken* CUsernameToken::NewL(CSenElement* aToken)

{

    CUsernameToken* pSelf = CUsernameToken::NewLC(aToken);

    CleanupStack::Pop(pSelf);

    return pSelf;

}

CUsernameToken* CUsernameToken::NewLC(CSenElement* aToken)

{

    CUsernameToken* pSelf = new (ELeave) CUsernameToken();

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL(aToken);

    return pSelf; 

}

CUsernameToken::~CUsernameToken()

{

}

CUsernameToken::CUsernameToken()

:iUsernameTokenProfile(KWssUsernameToken10)

{

}

void CUsernameToken::ConstructL(CSenElement* aToken)

{

    BaseConstructL(aToken);

    CSenElement* AND = CXmlHelper::RipPolicyXORElementL(aToken);

    RPointerArray<CSenElement>& tokenChildren =  AND->ElementsL();

    CSenElement* child;

    for (TInt i = 0; i < tokenChildren.Count(); i++)

    { //There should be only one element here the TokenType

        child = tokenChildren[i];

        TPtrC8 localName = child->LocalName();

        if(localName.Compare(KWssUsernameToken10) == 0)

        {

            iUsernameTokenProfile.Set(KWssUsernameToken10);

        }

        else if(localName.Compare(KWssUsernameToken11) == 0)

        {

            iUsernameTokenProfile.Set(KWssUsernameToken11);

        }

    }

}

CRequestSecurityTokenTemplate* CRequestSecurityTokenTemplate::NewL(CSenElement* aToken)

{

    CRequestSecurityTokenTemplate* pSelf = CRequestSecurityTokenTemplate::NewLC(aToken);

    CleanupStack::Pop(pSelf);

    return pSelf;

}

CRequestSecurityTokenTemplate* CRequestSecurityTokenTemplate::NewLC(CSenElement* aToken)

{

    CRequestSecurityTokenTemplate* pSelf = new (ELeave) CRequestSecurityTokenTemplate();

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL(aToken);

    return pSelf; 

}

CRequestSecurityTokenTemplate::~CRequestSecurityTokenTemplate()

{

  delete iToken;

  delete iTrustVersion;  

}

CRequestSecurityTokenTemplate::CRequestSecurityTokenTemplate()

:iToken(KNullDesC8().AllocL()),

iTrustVersion(KNullDesC8().AllocL())

{

}

void CRequestSecurityTokenTemplate::ConstructL(CSenElement* aToken)

{ //parse the token and then save it as HBufC8 

    const TDesC8* attr = aToken->AttrValue(KTrustVersion);    

    if(attr)

    {

        iTrustVersion = attr->AllocL();

    }

    RPointerArray<CSenElement>& tokenChildren =   aToken->ElementsL();

    CSenElement* child = NULL;

    RBuf8 buffer;

    CleanupClosePushL(buffer);

    RBuf8 request;

    CleanupClosePushL(request);

    for (TInt i = 0; i < tokenChildren.Count(); i++)  

    { 

        child = tokenChildren[i];

        TPtrC8 localName = child->LocalName();

//        child.OuterXmlL(buffer);

        request.Append(buffer);

    }

    iToken = request.AllocL();

    CleanupStack::PopAndDestroy(&request);

    CleanupStack::PopAndDestroy(&buffer);

}

CIssuedToken* CIssuedToken::NewL(CSenElement* aToken)