/*

* Copyright (c) 2006-2006 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 "wsstarpassporthandler.h"

#include "SenXmlUtils.h"

#include "wsstarmessageutils.h"

#include "wsstartrustclient.h"

#include "SenSoapFault.h"

#include "senlogger.h"

#include "sensaxutils.h"

#ifdef RD_SEN_VTCP_SUPPORT

#include "wsstarpassportheaderinbound.h"

#endif//RD_SEN_VTCP_SUPPORT

using namespace WSPassport32;

// Create instance of concrete ECOM interface implementation

CWSStarPassportHandler* CWSStarPassportHandler::NewL(TAny* aHandlerCtx)

    {

    MSenHandlerContext* ctx =

        reinterpret_cast<MSenHandlerContext*>( aHandlerCtx);

    CWSStarPassportHandler* self = new (ELeave) CWSStarPassportHandler(*ctx);

    CleanupStack::PushL (self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

TInt CWSStarPassportHandler::InvokeL(MSenMessageContext& aCtx)

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarPassportHandler::InvokeL(MSenMessageContext& aCtx)")));

    CSenSoapEnvelope* message = 

        const_cast<CSenSoapEnvelope*>(aCtx.GetSenSoapEnvelopeL(

                                                SenContext::KSenCurrentSoapMessageCtxKey));

    const TBool* boolValue = NULL;

    if (message)

        {

        _LIT8(KId,"Id");

        boolValue = aCtx.GetIntL(WSStarContextKeys::KPassportEnabled);

        if ((boolValue && *boolValue == (TBool)ETrue))

            {

            if (aCtx.Direction() == SenContext::EOutgoing)

                {//------------------OUTGOING

                CSenElement& header = message->HeaderL();

                CSenElement& authInfo = header.AddElementL(KPassportXmlns,

                                                           KAuthInfoTag,

                                                           KAuthInfoQTag);

                SenXmlUtils::AddAttributeL(authInfo, KId ,KPPAuthInfoAttrValue);

                authInfo.AddElementL(KPassportXmlns, 

                                        KHostingAppTag, 

                                        KHostingAppQTag).SetContentL(KHostingAppTagValue);

                authInfo.AddElementL(KPassportXmlns, 

                                        KBinaryVersionTag, 

                                        KBinaryVersionQTag).SetContentL(KBinaryVersionTagValue);

                authInfo.AddElementL(KPassportXmlns, 

                                        KUIVersionTag, 

                                        KUIVersionQTag).SetContentL(KUIVersionTagValue);

                authInfo.AddElementL(KPassportXmlns, 

                                        KCookiesTag, 

                                        KCookiesQTag).SetContentL(KCookiesTagValue);

                authInfo.AddElementL(KPassportXmlns, 

                                        KRequestParamsTag, 

                                        KRequestParamsQTag).SetContentL(KRequestParamsTagValue);

                CSenElement& body = message->BodyL();

                CSenElement* multiEl = 

                    CWSStarMessageUtils::GetMarkedElementL(body, WSStarContextKeys::KMultiReqTagMark, 

                                                            EFalse);

                if (multiEl)

                    {

                    multiEl->Set(KPassportXmlns, KRequestMultipleSecurityTokensTag, 

                                    KRequestMultipleSecurityTokensQTag);

                    }

                }

            else if(aCtx.Direction() == SenContext::EIncoming)

                {//------------------INCOMING

                TPtrC8 problem(KNullDesC8);

                if (message->IsFault())

                    {

                    CSenSoapFault* faultElement = message->FaultL();

                    if (faultElement)

                        {

                        if (message->NsUri() == KSenSoap12EnvelopeXmlns)

                            {

    //----------------SOAP1.2

                            TPtrC8 code = faultElement->FaultCode();

                            const CSenNamespace* nmSpaceCode = faultElement->Namespace(SenXmlUtils::NsPrefix(code), ETrue);

                            code.Set(SenXmlUtils::LocalName(code));

                            if ((

                                (nmSpaceCode && 

                                nmSpaceCode->URI() == KSenSoap12EnvelopeXmlns) 

                                ||

                                !nmSpaceCode)

                                &&

                                code == KSender)

                                {

                                TPtrC8 subcode = faultElement->FaultSubcode();

                                const CSenNamespace* nmSpace = faultElement->Namespace(SenXmlUtils::NsPrefix(subcode), ETrue);

                                subcode.Set(SenXmlUtils::LocalName(subcode));

                                if (nmSpace && 

                                    nmSpace->URI() == WSTrust::KTrustNamespace200502())

                                    {

                                    problem.Set(subcode);

                                    }    

                                }

                            else if (nmSpaceCode && nmSpaceCode->URI() == KSecurityXmlNs)

                                {

                                problem.Set(code);

                                }

                            }

                        else if (message->NsUri() == KSenSoapEnvelopeXmlns)

                            {

    //----------------SOAP1.1

                            TPtrC8 code = faultElement->FaultCode();

                            const CSenNamespace* nmSpace = faultElement->Namespace(SenXmlUtils::NsPrefix(code), ETrue);

                            code.Set(SenXmlUtils::LocalName(code));

                            if ((nmSpace && 

                                nmSpace->URI() == WSTrust::KTrustNamespace200502()))

                                {

                                problem.Set(code);

                                }    

                            }

    //------------------real logic                        

                        if (problem.Length()>0 && problem == WSTrust::KFailedAuthentication)

                            {

                            CSenElement* elem = NULL;

                            CSenElement& env = message->AsElement();

                            elem = CWSStarMessageUtils::FindElementL(KRedirectUrlTag, env);

                            if (elem)

                                {

                                const CSenNamespace* ns = elem->Namespace();

                                if (ns && ns->URI() == KPassportFaultNamespaceXmlns)

                                    {

                                    ((MSenContext&)aCtx).Update(WSStarSession::KErrorLayer, WSStarSession::ETrust);

                                    ((MSenContext&)aCtx).Update(WSStarContextKeys::KReAuthNeeded, EFalse);

                                    ((MSenContext&)aCtx).Update(WSStarContextKeys::KRedirect, elem->Content());        

                                    }

                                }

                            }

                        }

                    }

		#ifdef RD_SEN_VTCP_SUPPORT					

                else

                    {

                        TPtrC8 txtMessage = aCtx.GetMessageL();

                        if(message)

                        {

                            return HandleInboundL(aCtx, message);

                        }

                        else if(txtMessage.Length())

                        {

                            TInt ret(KErrNone);

                            TInt endTagStart;

                            TInt endTagEnd;

                            TInt startTagStart;

                            TInt startTagEnd;

                            TPtrC8 prefix;

                            ret = SenSaxUtils::SearchEndTagL(txtMessage,KSenSoapEnvelopeBodyName,

                                                             endTagStart, endTagEnd, prefix);

                            if ( ret != KErrNotFound )

                                {

                                ret = SenSaxUtils::SearchStartTagL(txtMessage,prefix,KSenSoapEnvelopeBodyName,

                                                                   startTagStart, startTagEnd);

                                }

                            if ( ret != KErrNotFound )

                                {

                                    TPtrC8 startPart(txtMessage.Ptr(),startTagEnd+1);

                                    TPtrC8 endPart(txtMessage.Ptr()+endTagStart,txtMessage.Size()-endTagStart);

                                    HBufC8* pXmlWithoutBody = HBufC8::NewLC(startPart.Length()+endPart.Length());

                                    pXmlWithoutBody->Des().Append(startPart);

                                    pXmlWithoutBody->Des().Append(endPart);

                                    CWSStarPassportHeaderInbound* inbound =

                                            CWSStarPassportHeaderInbound::NewLC();

                                    inbound->SetMessageContext(aCtx);

                                    CSenXmlReader& reader = const_cast<CSenXmlReader&>(*aCtx.GetParser());

                                    inbound->SetReader(reader);

                                    inbound->BuildFrom(*pXmlWithoutBody);

                                    CleanupStack::PopAndDestroy(inbound);

                                    CleanupStack::PopAndDestroy(pXmlWithoutBody);

                                }

                            else//case with empty body - <S:Body/>, so we can parse all

                                {

                                CWSStarPassportHeaderInbound* inbound =

                                        CWSStarPassportHeaderInbound::NewLC();

                                inbound->SetMessageContext(aCtx);

                                CSenXmlReader& reader = const_cast<CSenXmlReader&>(*aCtx.GetParser());

                                inbound->SetReader(reader);

                                inbound->BuildFrom(txtMessage);

                                CleanupStack::PopAndDestroy(inbound);                        

                                }

                        }

					}                        

		#endif//RD_SEN_VTCP_SUPPORT

                }

            }

        }

    else

        {

        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarPassportHandler::InvokeL(MSenMessageContext& aCtx) - \

                        Soap message in message context not exists")));

        return KErrNotFound;

        }

    return KErrNone;    

    }    

TInt CWSStarPassportHandler::HandleInboundL(MSenMessageContext& aCtx, CSenSoapEnvelope* aMessage)

    {

    CSenElement& header = aMessage->HeaderL();

    CWSStarMessageUtils::RArraySenElements elements;

    CWSStarMessageUtils::FindElementL(KCredProperty, header,elements);

    CSenElement* elem = NULL;

    TInt count(elements.Count());

    TInt i=0;

    while (i<count)

        {

        elem = elements[i];

        if (elem->LocalName() == WSPassport32::KCredProperty)

            {

            const TDesC8& nsUri = elem->NamespaceURI();

            if ((nsUri == WSPassport32::KPassportFaultNamespaceXmlns))

                {

                    const TDesC8* ptr= elem->AttrValue(WSPassport32::KName);

                    if(*ptr == WSPassport32::KMainBrandID)

                    {

                        ((MSenContext&)aCtx).Update(WSStarContextKeys::KMainBrandID, elem->Content());

                    }

                 }

            }

        i++;

        }

    elements.Reset();

    CWSStarMessageUtils::RArraySenElements credProperties;

    CWSStarMessageUtils::FindElementL(KCredProperties, header,credProperties);

    elem = NULL;

    count = 0;

    count = credProperties.Count();

	if(count == 1)

	{

		elem = credProperties[0];	

		HBufC8* xmlSnippet = elem->AsXmlL();

		CleanupStack::PushL(xmlSnippet);

		((MSenContext&)aCtx).Update(WSStarContextKeys::KBrandIDList,xmlSnippet->Des() );		

 		CleanupStack::PopAndDestroy(xmlSnippet);

	}

    credProperties.Reset();

    return KErrNone;

    }

SenHandler::THandlerDirection CWSStarPassportHandler::Direction() const

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarPassportHandler::Direction()")));

    return SenHandler::EOutgoing;

    }

SenHandler::THandlerPhase CWSStarPassportHandler::Phase()

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarPassportHandler::Phase()")));

    return SenHandler::EMessage;

    }

// Constructor

CWSStarPassportHandler::CWSStarPassportHandler(MSenHandlerContext& aCtx)

:CSenMessageHandler(aCtx)

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarPassportHandler::CWSStarPassportHandler(MSenHandlerContext& aCtx)")));

    }

// Destructor

CWSStarPassportHandler::~CWSStarPassportHandler()

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarPassportHandler::~CWSStarPassportHandler()")));

    }

// Second phase construction.

void CWSStarPassportHandler::ConstructL()

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarPassportHandler::ConstructL()")));

    }

TInt CWSStarPassportHandler::InitL(MSenHandlerContext& aCtx)

    {

    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarPassportHandler::InitL(MSenHandlerContext& aCtx)")));

    iHandlerContext = aCtx;

    return KErrNone;

    }

RFileLogger* CWSStarPassportHandler::Log() const

    {

    RFileLogger* pLog = NULL;

    TRAP_IGNORE( pLog = (RFileLogger*)iHandlerContext.GetAnyL(HandlerContextKey::KLogger); )

    return pLog;

    }

// END OF FILE