/*

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

#include "seninternalcredential.h"

#include <s32mem.h>

#include <s32file.h>

#include <sysutil.h>

#include <SenXmlProperties.h>

#include <SenXmlConstants.h>

#include "sendebug.h"               // internal \Utils\inc - filelogging MACROs

#include "senlogger.h"

#include "msencoreservicemanager.h" // internal \Framework\inc

#include "senservicemanagerdefines.h" // KMaxTicks (1209600000)

                                      // 1 tick = 1 millisec

                                      // 86400 sec = 1 day

                                      // 86400*1000 millisec = 1 day

                                      // 86400*14*1000 = 1209600000 millisec = 2 weeks

#include "SenParser.h"

#include "SenDateUtils.h"

#include "senwsdescription.h"

#include "senwebservicesession.h"

#include <SenServiceConnection.h> // KErrSenNoPermission ( -30315 )

#include <SenCredential.h>

#include <SenXmlUtils.h>

#ifdef __CRYPTO_HW__

#include "sencryptoutils.h"

#include <SecEnv.h>

#include <SecEnvDevice.h>

#include <SecEnvType.h>

#include <SecEnvMgr.h>

const TInt KCryptoPADataLen     = 16;

const TInt KCryptoPACipherLen   = 48;

const TInt KPaCryptAuthLen     = 32;

const TInt KEncryptNoSalt = 3;

const TInt KDecrypt       = 2;

const TUint KPadding = 0;

const TUint KEncrypedLen = 128;

_LIT8(KCryptoPA, "PA_CRYPT");

#endif // __CRYPTO_HW__

namespace

    {

#if !defined( EKA2 ) && !defined( RD_SECURE_PRIV_DATA )

    _LIT(KCredentialFile,           "C:\\system\\data\\sencredentials.xml");

#else

    _LIT(KCredentialFile,           "sencredentials.xml");

#endif

    _LIT8(KCredentials,             "Credentials");

    _LIT8(KCredentialsMaxID,        "CredentialsMaxID");

    _LIT8(KCredentialContainer,     "CredentialContainer");

    _LIT8(KCredentialIdentifier,    "Identifier");

    _LIT8(KCredentialProperties,    "Properties");

    _LIT8(KTouch,    "touch");

    _LIT8(KCredentialId, "CredentialId");

    const TInt KStateParsingCredentialContainer   = 99;

    const TInt KStateParsingCredentialIdentifier  = 100;

    const TInt KStateParsingCredentialProperties  = 102;

    const TInt KStateParsingCredential            = 104;

    const TInt KFlatBufSize                       = 128;

    /* microseconds before actual notOnOrAfter (or validUntil) time

     * when credentials are treated as expired.

     */

    const TInt KClockSlipMicroSeconds = 3*60*1000*1000;

    }

EXPORT_C CSenCredentialManager* CSenCredentialManager::NewL(MSenCoreServiceManager& aManager)

    {

    CSenCredentialManager* pNew = NewLC(aManager);

    CleanupStack::Pop(pNew);

    return(pNew);

    }

EXPORT_C CSenCredentialManager* CSenCredentialManager::NewLC(MSenCoreServiceManager& aManager)

    {

    CSenCredentialManager* pNew = new (ELeave) CSenCredentialManager(aManager);

    CleanupStack::PushL(pNew);

    pNew->ConstructL();

    return pNew;

    }

CSenCredentialManager::CSenCredentialManager(MSenCoreServiceManager& aManager)

: iManager(aManager),

  iLog((RFileLogger*)aManager.Log()),

  iMaxCredentialID(0)

    {

    }

EXPORT_C CSenCredentialManager::~CSenCredentialManager()

    {

    SaveCredentialDB();

    TInt count = iCredentialArray.Count();

    for (TInt i=0; i < count; i++)

        {

        iCredentialArray[i].Close();

        }

    iCredentialArray.Close();

    delete ipParser;

    // Sanity check for Delegates (which are not handled correctly

    //                             during parsing)

    delete ipCredentialContainer;

    delete ipCredentialIdentifier;

    delete ipCredentialProperties;

    delete ipCredential;

    }

void CSenCredentialManager::ConstructL()

    {

    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenCredentialManager::ConstructL");

    BaseConstructL(KCredentials);

    LoadDB();

    }

RFileLogger* CSenCredentialManager::Log()

    {

    return iLog;

    }

void CSenCredentialManager::OnStartElementL(const RTagInfo& aElement,

                                            const RAttributeArray& aAttributes,

                                            TInt aErrorCode)

    {

    const TPtrC8 localName   = aElement.LocalName().DesC();

    switch (iState)

        {

        case KSenStateSave:

            {

            const TPtrC8 saxLocalName   = aElement.LocalName().DesC();

            if (saxLocalName == KCredentialContainer)

                {

                if ( ipCredentialContainer )

                    {

                    TXmlEngElement element  = ipCredentialContainer->AsElementL();

                    element.Remove(); // Deletes Container from Dom tree

                    delete ipCredentialContainer;

                    ipCredentialContainer = NULL;

                    }

                const TPtrC8 saxNsUri       = aElement.Uri().DesC();

                const TPtrC8 saxPrefix      = aElement.Prefix().DesC();

                TXmlEngElement element = AsElementL();

                RSenDocument   document = AsDocumentL();

				ipCredentialContainer = CSenFragmentBase::NewL(

					                         saxNsUri, saxLocalName,

					                         saxPrefix, aAttributes,

					                         element, document 

					                         );

                iState = KStateParsingCredentialContainer;

                }

            break;

            }

        case KStateParsingCredentialContainer: // KStateParsingCredentialContainer 

                                               // is also Save state

            {

            const TPtrC8 saxLocalName   = aElement.LocalName().DesC();

            if (saxLocalName == KCredentialIdentifier)

                {

                if ( ipCredentialIdentifier )

                    {

                    TXmlEngElement element  = ipCredentialIdentifier->AsElementL();

                    element.Remove(); // Deletes Identifier from Dom tree

                    delete ipCredentialIdentifier;

                    ipCredentialIdentifier = NULL;

                    }

                const TPtrC8 saxNsUri       = aElement.Uri().DesC();

                const TPtrC8 saxPrefix      = aElement.Prefix().DesC();

                TXmlEngElement element  = ipCredentialContainer->AsElementL();

                RSenDocument   document = AsDocumentL();

				ipCredentialIdentifier = CSenCredentialIdentifier::NewL(

					                         saxNsUri, saxLocalName,

					                         saxPrefix, aAttributes,

					                         element, document 

					                         );

                iState = KStateParsingCredentialIdentifier;

                OnDelegateParsingL(*ipCredentialIdentifier);

                }

            else if (saxLocalName == KCredentialProperties)

                {

                if ( ipCredentialProperties )

                    {

                    TXmlEngElement element  = ipCredentialProperties->AsElementL();

                    element.Remove(); // Deletes Properties from Dom tree

                    delete ipCredentialProperties;

                    ipCredentialProperties = NULL;

                    }

                const TPtrC8 saxNsUri       = aElement.Uri().DesC();

                const TPtrC8 saxPrefix      = aElement.Prefix().DesC();

                TXmlEngElement element  = ipCredentialContainer->AsElementL();

                RSenDocument   document = AsDocumentL();

				ipCredentialProperties = CSenCredentialProperties::NewL(

					                         saxNsUri, saxLocalName,

					                         saxPrefix, aAttributes,

					                         element, document 

					                         );

                iState = KStateParsingCredentialProperties;

                OnDelegateParsingL(*ipCredentialProperties);

                }

            else 

                {

                // Parsing Credential

                // 

                // <=> Container can have only three elements:

                //     1) CredentialIdentifier,

                //     2) CredentialProperties and

                //     3) Credential (which LocalName we do not know)

                //

                //     If we see that LocalName was not CredentialIdentifier

                //                                      or CredentialProperties

                //     we know that we are handling Credential.

                if ( ipCredential )

                    {

                    TXmlEngElement element  = ipCredential->AsElementL();

                    element.Remove(); // Deletes Credential from Dom tree

                    delete ipCredential;

                    ipCredential = NULL;

                    }

                const TPtrC8 saxNsUri       = aElement.Uri().DesC();

                const TPtrC8 saxPrefix      = aElement.Prefix().DesC();

                TXmlEngElement element  = ipCredentialContainer->AsElementL();

                RSenDocument   document = AsDocumentL();

				ipCredential = CSenInternalCredential::NewL(

					                         saxNsUri, saxLocalName,

					                         saxPrefix, aAttributes,

					                         element, document 

					                         );

		        ipCredential->SetIdentifier(ipCredentialIdentifier);

		        ipCredentialIdentifier = NULL;

		        ipCredential->SetProperties(ipCredentialProperties);

		        ipCredentialProperties = NULL;

                iState = KStateParsingCredential;

                OnDelegateParsingL(*ipCredential);

                }

            break;

            }

        default:

            {

            const TPtrC8 saxLocalName   = aElement.LocalName().DesC();

            if (saxLocalName == KCredentials)

                {

                TInt count(aAttributes.Count());

                for (TInt i=0; i<count; i++)

                    {

                    TPtrC8 localName = aAttributes[i].Attribute().LocalName().DesC();

                    TPtrC8 value = aAttributes[i].Value().DesC();

                    if ( localName == KCredentialsMaxID )

                        {

                        TLex8 lex;

                        lex.Assign(value);

                        lex.Val( iMaxCredentialID );                        

                        break;

                        }

                    }

                }

            CSenFragmentBase::OnStartElementL( aElement, aAttributes, aErrorCode );

            break;

            }

        }

    }

void CSenCredentialManager::OnEndElementL( const RTagInfo& aElement, TInt aErrorCode )

    {

    const TPtrC8 localName   = aElement.LocalName().DesC();

    switch(iState)

        {

        case KStateParsingCredentialIdentifier:

            {

#ifdef __CRYPTO_HW__

            TInt leaveCode(KErrNone);  

 			TPtrC8 pass;

            TBuf8<KEncrypedLen> decPwd;

            ipCredentialIdentifier->PropertyL(KSenIdpPasswordLocalname, pass);

            TRAP(leaveCode, DecryptPasswordL(pass, decPwd));

            if (leaveCode == KErrNone)

                {

                TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("SenCredentialManager::DecryptPasswordL success")));

                }

            else

                {

                TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("SenCredentialManager::DecryptPasswordL Failed"))); 

                }

			ipCredentialIdentifier->SetPropertyL(KSenIdpPasswordLocalname, decPwd);       			

#endif // __CRYPTO_HW__			

            iState = KStateParsingCredentialContainer;

            break;

            }

        case KStateParsingCredentialProperties:

            {

            iState = KStateParsingCredentialContainer;

            break;

            }

        case KStateParsingCredential:

            {

            TTime now;

            now.UniversalTime();

            TPtrC8 value;

            TTimeIntervalMicroSeconds clientServerInterval = 0;

            TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"Checking 'ServiceInterval' property.");

            _LIT8(KServiceInterval,"ServiceInterval");	//CodeScannerWarnings

            TInt ret = ipCredential->PropertiesL().PropertyL(KServiceInterval, value);

            TBool propertiesExist(ETrue);

            if ( ret == KErrNone )

                {

                TLex8 lex(value);

                TInt64 val;

                ret = lex.Val(val);

                TTimeIntervalMicroSeconds clientServerInterval = val;

                if ( ret == KErrNone )

                    {

#ifdef _SENDEBUG

                    TInt leaveCode(KErrNone);

                    TBuf8<SenDateUtils::KXmlDateTimeMaxLength> ts;

                    TRAP(leaveCode, SenDateUtils::ToXmlDateTimeUtf82L(ts, now);)

                    if (leaveCode == KErrNone)

                        {

                        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("Client time : %S"), &ts));

                        }

#endif // _SENDEBUG

                    now += clientServerInterval;

#ifdef _SENDEBUG

                    TBuf8<64> buf;

                    buf.AppendNum(clientServerInterval.Int64());

                    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("Client-Server Interval in microseconds: %S"),&buf));

                    TRAP(leaveCode, SenDateUtils::ToXmlDateTimeUtf82L(ts, now);)

                    if (leaveCode == KErrNone)

                        {

                        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("Fixed client time : %S"), &ts));

                        }

                    leaveCode = 0; // not used

#endif // _SENDEBUG

                    }

                }

            else if ( ret == KErrNotFound )

                {

                TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- 'ServiceInterval' not found.");

                TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"Checking 'ValidUntil' property.");

                TInt ret2 = ipCredential->PropertiesL().PropertyL(_L8("ValidUntil"), value);

                if ( ret2 == KErrNotFound )

                    {

                    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- 'ValidUntil' not found.");

                    propertiesExist = EFalse;

                    }

                }                

            if ( !propertiesExist ||

                ( ( ipCredential->PropertiesL().ValidUntilL() != Time::NullTTime() ) &&

                 ( now > (ipCredential->PropertiesL().ValidUntilL()-TTimeIntervalMicroSeconds(KClockSlipMicroSeconds)) ) )

               )

                {

#ifdef _SENDEBUG

                if ( propertiesExist )

                    {

                    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("- Loaded credential is expired:")));

                    TInt leaveCode(KErrNone);

                    TBuf8<SenDateUtils::KXmlDateTimeMaxLength> ts2;

                    TRAP(leaveCode, SenDateUtils::ToXmlDateTimeUtf82L(ts2, ipCredential->PropertiesL().ValidUntilL());)//codescannerwarnings

                    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("- Credential time : %S, clockslip: %d micros"), &ts2, KClockSlipMicroSeconds));

                    leaveCode = 0; // not used

                    }

                else

                    {

                    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- Neither 'ValidUntil' or 'ServiceInterval' exist: credential should be discarded(!)");

                    }

#endif // _SENDEBUG

                TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("-- Invalid credential will be removed from CredentialManager.")));

                delete ipCredential;            

                ipCredential = NULL;         

                }

            else

                {

                if ( ipCredential->PropertiesL().ValidUntilL() != Time::NullTTime() )

                    {

                    TTime validUntil = ipCredential->PropertiesL().ValidUntilL();

                    ipCredential->SetValidUntil(validUntil);

                    }

                RSenCredentialPtr credentialPtr;

                credentialPtr.OpenL(ipCredential);

                CleanupClosePushL(credentialPtr);

                iCredentialArray.Append(credentialPtr);

                CleanupStack::Pop(&credentialPtr);

                }

            ipCredential = NULL;

            iState = KStateParsingCredentialContainer;

            break;

            }

        case KStateParsingCredentialContainer:

            {

            if(localName == KCredentialContainer)

            	{

            if ( ipCredentialContainer )

                {

                TXmlEngElement element  = ipCredentialContainer->AsElementL();

                RXmlEngNodeList<TXmlEngElement> children;

                CleanupClosePushL(children);

                element.GetChildElements(children);

                // Element should always have 3 child elements:

                //         1) CredentialIdentifier and

                //         2) Credential

                //         3) CredentialProperties

                if ( children.Count() < 2 )

                    {

                    if ( ipCredentialIdentifier )

                        {

                        TXmlEngElement element  = ipCredentialIdentifier->AsElementL();

                        element.Remove(); // Deletes Identifier from Dom tree

                        delete ipCredentialIdentifier;

                        ipCredentialIdentifier = NULL;

                        }

                    if ( ipCredentialProperties )

                        {

                        TXmlEngElement element  = ipCredentialProperties->AsElementL();

                        element.Remove(); // Deletes Identifier from Dom tree

                        delete ipCredentialProperties;

                        ipCredentialProperties = NULL;

                        }

                    if ( ipCredential )

                        {

                        TXmlEngElement element  = ipCredential->AsElementL();

                        element.Remove(); // Deletes Credential from Dom tree

                        delete ipCredential;

                        ipCredential = NULL;

                        }

                    element.Remove();

                    }

                CleanupStack::PopAndDestroy(&children);

                delete ipCredentialContainer;

                ipCredentialContainer = NULL;

                if ( ipContentBuf )

    				{

    		    	delete ipContentBuf;

        			ipContentBuf = NULL;

        			delete ipContentWriteStream;

        			ipContentWriteStream = NULL;

        			}

                }

            iState = KSenStateSave;

            break;

            	}

            	else

            	{

            		return;

            	}

            }

        default:

            {

            CSenFragmentBase::OnEndElementL(aElement, aErrorCode);

            break;