/*

* 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> // check if this include is needed(?)

#include <SenXmlUtils.h>

#include "idwsfsaslmessage.h"

#include "sendebug.h"

#include "senlogger.h"

#include "senpasswordtransform.h"

namespace

    {

    _LIT8(KContinue, "continue");

    _LIT8(KAbort, "abort");

    _LIT8(KPasswordTransformsName, "PasswordTransforms");

    _LIT8(KTransformName, "Transform");

    _LIT8(KParameterName, "Parameter");

    _LIT8(KDataName, "Data");

    _LIT8(KNameAttr, "name");

    _LIT8(KAuthzIdName, "authzID");

    _LIT8(KAdvisoryAuthnIdName, "advisoryAuthnID");

    _LIT8(KServerMechanismName, "serverMechanism");

    _LIT8(KMechanismName, "mechanism");

    }

CIdWsfSaslMessage* CIdWsfSaslMessage::NewL(

                                    MSenCoreServiceManager& aServiceManager)

    {

    CIdWsfSaslMessage* pNew = new (ELeave) CIdWsfSaslMessage(aServiceManager);

    CleanupStack::PushL(pNew);

    pNew->ConstructL();

    CleanupStack::Pop();

    return pNew;

    }

CIdWsfSaslMessage* CIdWsfSaslMessage::NewL(

    MSenCoreServiceManager& aServiceManager,

    const TDesC8& aXmlns,

    const TDesC8& aLocalName,

    const TDesC8& aQName

    )

    {

    CIdWsfSaslMessage* pNew = new (ELeave) CIdWsfSaslMessage(aServiceManager);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aXmlns, aLocalName, aQName);

    CleanupStack::Pop();

    return pNew;

    }

CIdWsfSaslMessage::CIdWsfSaslMessage(MSenCoreServiceManager& aServiceManager)

:   iServiceManager(aServiceManager),

    ipMechanism(NULL),

    ipParameterName(NULL)

    {

    }

void CIdWsfSaslMessage::ConstructL()

    {

    BaseConstructL(KSaslXmlns, KSaslResponseName, KSaslResponseQName);

    }

void CIdWsfSaslMessage::ConstructL(

    const TDesC8& aXmlns,

    const TDesC8& aLocalName,

    const TDesC8& aQName

    )

    {

    BaseConstructL(aXmlns, aLocalName, aQName);

    }

CIdWsfSaslMessage::~CIdWsfSaslMessage()

    {

    delete ipMechanism;

    delete ipParameterName;

    }

TInt CIdWsfSaslMessage::ConstructInitRequestFromL(

                                              const TDesC8& aAllMechanismNames,

                                              CSenIdentityProvider& aAccount)

    {

    // fresh start

    delete ipMechanism;

    ipMechanism=NULL;

    delete ipParameterName;

    ipParameterName=NULL;

    MSenElement& element = AsElement();

    element.AddAttrL(KMechanismName, aAllMechanismNames);

    TPtrC8 authzId = aAccount.AuthzID();

    if (authzId.Length() > 0)

        {

        element.AddAttrL(KAuthzIdName, authzId);

        }

    TPtrC8 advisoryAuthnId = aAccount.AdvisoryAuthnID();

    if (advisoryAuthnId.Length() > 0)

        {

        element.AddAttrL(KAdvisoryAuthnIdName, advisoryAuthnId);

        }

    return KErrNone;

    }

TInt CIdWsfSaslMessage::ConstructRequestFromL(

    const TDesC8& aMech)

    {

    // fresh start

    delete ipMechanism;

    ipMechanism=NULL;

    delete ipParameterName;

    ipParameterName=NULL;

    AsElement().AddAttrL(KMechanismName, aMech);

    return KErrNone;

    }

TInt CIdWsfSaslMessage::ConstructRequestFromL(

    const TDesC8& aMech,

    const TDesC8& aData

    )

    {

    // fresh start

    delete ipMechanism;

    ipMechanism=NULL;

    delete ipParameterName;

    ipParameterName=NULL;

    TInt retVal = ConstructRequestFromL(aMech);

    HBufC8* pDataBase64 = iServiceManager.EncodeToBase64LC(aData);

    AsElement().AddElementL(

        AsElement().NamespaceURI(), KDataName).SetContentL(*pDataBase64);

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

    return retVal;

    }

TBool CIdWsfSaslMessage::IsContinue()

    {

    if(!ipStatus)

        {

        return EFalse;

        }

    else

        {

        return SenXmlUtils::EndsWith(*ipStatus, KContinue);

        }

    }

TBool CIdWsfSaslMessage::IsAbort()

    {

    if (ipStatus == NULL)

        {

        return EFalse;

        }

    else

        {

        return SenXmlUtils::EndsWith(*ipStatus, KAbort);

        }

    }

TPtrC8 CIdWsfSaslMessage::Mechanism()

    {

    if (!ipMechanism)

        {

        return KNullDesC8();

        }

    else

        {

        return *ipMechanism;

        }

    }

TPtrC8 CIdWsfSaslMessage::ParameterName()

    {

    if (!ipParameterName)

        {

        return KNullDesC8();

        }

    else

        {

        return *ipParameterName;

        }

    }

TPtrC8 CIdWsfSaslMessage::Data()

    {

    MSenElement* pDataElement = AsElement().Element(KDataName);

    if(pDataElement)

        {

        return pDataElement->Content();

        }

    return KNullDesC8();

    }

// @return NULL if list is empty

CSenPasswordTransform* CIdWsfSaslMessage::LastParsedPasswordTransform()

    {

    TInt count(iTransforms.Count());

    if(count>0)

        {

        return iTransforms[count-1];

        }

    else

        {

        return NULL;

        }

    }

void CIdWsfSaslMessage::StartElementL(

    const TDesC8& aNsUri,

    const TDesC8& aLocalName,

    const TDesC8& aQName,

    const RAttributeArray& aAttributes )

    {

    if (IsOk())

        {

        CIdWsfDsQueryResponse::StartElementL(aNsUri, aLocalName, aQName,

                                                aAttributes);

        }

    else

        {

        switch (iState)

            {

            case KStateIgnore:

                {

                if (aLocalName == KSaslResponseName)

                    {

                    HBufC8* pNew = SenXmlUtils::AllocAttrValueL(

                        aAttributes,

                        KServerMechanismName

                        );

                    delete ipMechanism;

                    ipMechanism = pNew;

                    }

                else if (aLocalName == KStatusName)

                    {

                    HBufC8* pNew = SenXmlUtils::AllocAttrValueL(

                        aAttributes,

                        KStatusCodeName

                        );

                    delete ipStatus;

                    ipStatus = pNew;

                    }

                else if (aLocalName == KDataName)

                    {

                    DelegateParsingL(aNsUri, aLocalName, aQName, aAttributes);

                    }

                else if (aLocalName == KPasswordTransformsName)

                    {

                    iTransforms.Reset(); // NOT owned..

                    iState = KStateParsingPwTransforms;

                    }

                break;

                }

            case KStateParsingPwTransforms:

                {

                if (aLocalName == KTransformName)

                    {

                    TPtrC8 name = SenXmlUtils::AttrValue(aAttributes, 

                                                            KNameAttr);

                    CSenPasswordTransform* pTransform =

                        CSenPasswordTransform::NewL(name, iServiceManager);

                    if(pTransform)

                        {

                        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase   , KMinLogLevel  ,

                            _L8("CIdWsfSaslMessage::StartElementL - \

                            appending password transform: '%S'"), &name));

                        iTransforms.Append(pTransform);

                        }

                    }

                else if (aLocalName == KParameterName)

                    {

                    HBufC8* pNew = SenXmlUtils::AllocAttrValueL(

                        aAttributes,

                        KNameAttr

                        );

                    delete ipParameterName; // free memory

                    ipParameterName = pNew;

                    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase   , KMinLogLevel  ,

                        _L("CIdWsfSaslMessage::StartElementL - \

                        parsing PasswordTransform parameter: '%S'"),

                            ipParameterName));

                    ResetContentL();

                    }

                break;

                }

            }

        }

    }

void CIdWsfSaslMessage::EndElementL(

    const TDesC8& aNsUri,

    const TDesC8& aLocalName,

    const TDesC8& aQName

    )

    {

    if (IsOk())

        {

        CIdWsfDsQueryResponse::EndElementL(aNsUri, aLocalName, aQName);

        }

    else

        {

        switch (iState)

            {

            case KStateParsingPwTransforms:

                {

                if (aLocalName == KParameterName)

                    {

                    CSenPasswordTransform* pLast =

                            LastParsedPasswordTransform();

                    if(pLast)

                        {

                        pLast->SetParameterL(*ipParameterName, Content());

                        }

                    }

                else if (aLocalName == KPasswordTransformsName)

                    {

                    ResetContentL();

                    iState = KStateIgnore;

                    }

                break;

                }

            default:

                break;

            }

        }

    }

RPointerArray<CSenPasswordTransform> CIdWsfSaslMessage::Transforms()

    {

    return iTransforms;

    }

RFileLogger* CIdWsfSaslMessage::Log() const

    {

    return iServiceManager.Log();

    }

// End of File