/*
* 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 <e32std.h>
#include <xmlsecwinit.h>
#include <xmlsecwsign.h>
#include "sencryptoutils.h"
#include "sendebug.h"
#include "SenSoapMessage.h"
#include "SenParser.h"
#include "wsstarsecurityhandler.h"
#include "wsstarcons.h"
#include "wsstarhandlercontext.h"
#include "wsstarmessagehandlerscons.h"
#include "senlogger.h" // private Utils\inc
#include "wsstarmessageutils.h"
using namespace WSStarSecurityFault;

//_LIT8(KSecurityIdPrefix, "SEC_");
_LIT8(KSecurityPrefix, "ds");

// Create instance of concrete ECOM interface implementation
CWSStarSecurityHandler* CWSStarSecurityHandler::NewL(
        MSenHandlerContext* aHandlerCtx)
    {
    
    CWSStarSecurityHandler* self =
            new (ELeave) CWSStarSecurityHandler(*aHandlerCtx);
    return self;
    }

// Constructor
CWSStarSecurityHandler::CWSStarSecurityHandler(MSenHandlerContext& aCtx):
        CSenMessageHandler(aCtx)
    {
    }

// Destructor
CWSStarSecurityHandler::~CWSStarSecurityHandler()
    {
        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarSecurityHandler::~CWSStarSecurityHandler()")));
    }

TInt CWSStarSecurityHandler::InvokeL(MSenMessageContext& aCtx)
    {
    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarSecurityHandler::InvokeL(MSenMessageContext& aCtx)")));

    if (aCtx.Direction() == SenContext::EOutgoing)
        {
        const TDesC8* keyB64 = aCtx.GetDesC8L(WSStarContextKeys::KPOPBase64);        
        const TDesC8* keyType = aCtx.GetDesC8L(WSStarContextKeys::KBinaryType);
        if (!keyB64)
            {
            return KErrNone;
            }
        HBufC8* key = SenCryptoUtils::DecodeBase64L(*keyB64);
        if (!key)
            {
            return KErrArgument;
            }
        CleanupStack::PushL(key);

        RArrayElements elements;
        CleanupClosePushL(elements);
        
        CSenDomFragmentBase* base = GetElementsToSignL(aCtx, &elements);
        if (!base)
            {
            CleanupStack::PopAndDestroy(2, key);
            return KErrNone;
            }
        CleanupStack::PushL(base);
        
        base->AsDocumentL().RegisterXmlIdL(KSecurityUtilityId, KSecurityUtilityXmlNs);
        
        if (elements.Count())
            {
            XmlSecPushL();
            //TUint id = 0;
            for (TInt i = 0; i < elements.Count(); i++)
                {
                TXmlEngElement& el = elements[i];
                TXmlEngNamespace ns = el.LookupNamespaceByPrefixL(KSecurityUtilityXmlNsPrefix);
                if (ns.IsUndefined())
                    {
                        ns = el.AddNamespaceDeclarationL(KSecurityUtilityXmlNs, 
                                                            KSecurityUtilityXmlNsPrefix);    
                    }
                else if (ns.Uri() != KSecurityUtilityXmlNs)
                    {
                    User::Leave(KErrCorrupt);
                    }
                    
                 //!!!atention, current id value is absed upn tag name. Below commented code 
                 //generate more uniq name (similar to sequencer)
                //while (!el.HasAttributeL(KSecurityUtilityId, KSecurityUtilityXmlNs))
                    {
                    //TBuf8<12> idStr = KSecurityIdPrefix();
                    //idStr.AppendNumFixedWidth(++id, EHex, 8);
                    //el.AddXmlIdL(KSecurityUtilityId, idStr, ns);
                    el.AddXmlIdL(KSecurityUtilityId, elements[i].Name(), ns);
                    }
                }
            
            CXmlSecSign* sign = CXmlSecSign::NewLC();
            TXmlEngElement signature;
            if (!keyType || //only 4 possible case null, nonce, asymmetric, symmetric.
                (keyType && 
                *keyType == WSStarContextValues::KPOPTypeAsimmetric))
                {
                TLSLOG(KSenFaultsLogChannel, KSenFaultsLogLevel, KUnsupportedAlgorithm);  
                CleanupStack::PopAndDestroy(sign); 
                XmlSecPopAndDestroy();
                CleanupStack::PopAndDestroy(base); 
                CleanupStack::PopAndDestroy(); //elements, it is R class
                CleanupStack::PopAndDestroy(key); 
                return KErrNone;
                }
            else //if nonce , then key is computed and also is simettric
                {
                sign->CreateTemplateL(CXmlSecSign::EHMAC, 
                                        elements, 
                                        KSecurityUtilityWsuId,
                                        EFalse,
                                        CXmlSecSign::KExclusiveC14N,
                                        KSecurityPrefix,
                                        EFalse
                                        );
                sign->SetKeyFromBufferL(*key, KNullDesC8, CXmlSecSign::EHMAC);
                //const TDesC8* str = aCtx.GetDesC8L(WSStarContextKeys::KSTR);
                _LIT8(KSTRstr,"<wsse:SecurityTokenReference \
xmlns:wsse=\"http://docs.oasis-open.org/wss/2004/01/\
oasis-200401-wss-wssecurity-secext-1.0.xsd\">\
<wsse:Reference wsse:URI=\"token\" />\
</wsse:SecurityTokenReference>");
                const TDesC8* str = &KSTRstr();
                if (str)
                    {
                    CSenDomFragmentBase* strFr = CSenDomFragmentBase::NewL();
                    CleanupStack::PushL(strFr);
                    CSenParser* parser = CSenParser::NewLC();
                    parser->ParseL(*str, *strFr); 
                    sign->SetKeyInfoL(strFr->AsElementL().CopyL());
                    CleanupStack::PopAndDestroy(2, strFr);
                    }
                signature = sign->SignXmlNodesL(elements);
                }
        
            HBufC8* messageXml = base->AsXmlL();
            CleanupStack::PushL(messageXml);
            
            CSenSoapMessage* message=NULL;
            CSenSoapMessage* msg = 
                (CSenSoapMessage*)aCtx.GetSenSoapEnvelopeL(
                                            SenContext::KSenCurrentSoapMessageCtxKey);
            if(msg->SoapVersion() == ESOAP12)
            {
                message = CSenSoapMessage::NewL( ESOAP12, KSecurityXmlNs);
            }
            else
            {
                message = CSenSoapMessage::NewL(ESOAP11, KSecuritySchemeXmlNs );
            }
            CleanupStack::PushL(message);
            CSenXmlReader& reader =   const_cast<CSenXmlReader&>(*aCtx.GetParser());

            message->ParseWithL( reader );
            message->ParseL(*messageXml);
            aCtx.Update(SenContext::KSenCurrentSoapMessageCtxKey, message);
            CleanupStack::Pop(message);
            AttachElementL(aCtx, signature);
            CleanupStack::PopAndDestroy(2, sign);//messagexml, sign
            
            
            XmlSecPopAndDestroy();
            }

        CleanupStack::PopAndDestroy(3, key);//base, elements, key
        }
       return KErrNone;
    }

    
SenHandler::THandlerDirection CWSStarSecurityHandler::Direction() const
    {
        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarSecurityHandler::Direction()")));
        return SenHandler::EBoth;
    };
SenHandler::THandlerPhase CWSStarSecurityHandler::Phase()
    {
        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("CWSStarSecurityHandler::Phase()")));
        return SenHandler::EMessage;
    };    
TInt CWSStarSecurityHandler::InitL(MSenHandlerContext& /*aCtx*/)
    {
    return KErrNone;
    }
    
    
RFileLogger* CWSStarSecurityHandler::Log() const
    {
    RFileLogger* pLog = NULL;
    TRAP_IGNORE( pLog = (RFileLogger*)iHandlerContext.GetAnyL(HandlerContextKey::KLogger); )
    return pLog;
    }
    
//------------------------------------------------------------------------------
// Add signature element to security header
//------------------------------------------------------------------------------
//
void CWSStarSecurityHandler::AttachElementL(MSenMessageContext& aCtx,
        TXmlEngElement& aSignature)
    {
    CSenSoapMessage* message = (CSenSoapMessage*)
            (aCtx.GetSenSoapEnvelopeL(
            SenContext::KSenCurrentSoapMessageCtxKey));
    RBuf8 buffer;
    aSignature.OuterXmlL(buffer);
    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel,(_L("Siganture from buffer")));
    TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel,(buffer));
    message->AddSecurityTokenL(buffer);
    buffer.Close();
    }
    
//------------------------------------------------------------------------------
// Returns collection of elements which has to be signed. Depenend on policy 
// which determine what to sign
//------------------------------------------------------------------------------
//

CSenDomFragmentBase* CWSStarSecurityHandler::GetElementsToSignL( MSenMessageContext& aCtx, RArrayElements* aElements )
    {
    CSenSoapMessage* msg = (CSenSoapMessage*)aCtx.GetSenSoapEnvelopeL(
            SenContext::KSenCurrentSoapMessageCtxKey);
    if (!msg)
        {
        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("There is no message in message context")));
        return NULL;
        }
    
    CSenDomFragmentBase* base = CSenDomFragmentBase::NewL();
    CleanupStack::PushL(base);

    HBufC8* xmlMsg = msg->AsXmlL();
    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel,(_L("____parse message in order to find elements____")));
    TLSLOG_ALL(KSenCoreServiceManagerLogChannelBase  , KMaxLogLevel,(*xmlMsg));
    
    CleanupStack::PushL(xmlMsg);
    
    
    CSenParser* parser = CSenParser::NewLC();
    parser->ParseL(*xmlMsg, *base); 
    CleanupStack::PopAndDestroy(2, xmlMsg);//parser, xmlMsg
    
    TXmlEngElement parent = base->AsElementL();
    
       
    TPtrC8 verDes = KSenSoapEnvelopeXmlns();
    const TInt* ver = aCtx.GetIntL(WSStarContextKeys::KSoapVersion);
    if (!ver || (*ver != ESOAP11))
        {
        verDes.Set(KSenSoap12EnvelopeXmlns());
        }
        
    //determine using global policy        
    RPointerArray<HBufC8>* pTags = (RPointerArray<HBufC8>*)aCtx.GetAnyL(WSStarContextKeys::KSignedPartsArray);
    
    if( pTags )
        {
        TInt count(pTags->Count());
        for (TInt i = 0; i<count; i+=2 )
            {
            TLSLOG_L( KSenCoreServiceManagerLogChannelBase, KMaxLogLevel, "____looking for elements____" );
            HBufC8* tagg = (*pTags)[i];
            HBufC8* taggNs = (*pTags)[i+1];
            TPtrC8 name = tagg->Des();
            TPtrC8 pNs = taggNs->Des();
            TLSLOG( KSenCoreServiceManagerLogChannelBase, KMaxLogLevel, ( *((*pTags)[i]) ) );
            TLSLOG( KSenCoreServiceManagerLogChannelBase, KMaxLogLevel, ( *((*pTags)[i+1]) ) );
            if ( pNs == KNullDesC8() ) // assumption is that this is some soap namespace (like Body)
                {
                pNs.Set( verDes );
                }
            CWSStarMessageUtils::FindElementL( name, pNs, parent, aElements );    
            }
        }
#ifdef _SENDEBUG        
    else // pTags == NULL
        {
        TLSLOG_L( KSenCoreServiceManagerLogChannelBase, KMinLogLevel, "CWSStarSecurityHandler::GetElementsToSignL(MSenMessageContext):" );
        TLSLOG_L( KSenCoreServiceManagerLogChannelBase, KMinLogLevel, "- aCtx.GetAnyL(WSStarContextKeys::KSignedPartsArray) returned NULL(!)" );
        }
#endif // _SENDEBUG        
    CleanupStack::Pop( base );
    return base;
    }


// END OF FILE