/*
* 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 <s32mem.h>
#include <s32file.h>
#include <sysutil.h>

#include <SenBaseFragment.h>
#include <SenXmlUtils.h>

#include "msenidentitymanager.h"
#include "msenidentity.h"
#include "senbaseidentitymanager.h"
#include "sensecuritymechanismobserver.h"
#include "senlogger.h"
#include "sensecuritymechanism.h"  // internal  Framework\inc - ECOM interface

#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 "sendebug.h" // internal Utils\inc - filelogging MACROs
#include "sennotplugindlg.h" // internal NotifierPlugin\inc, KSenNotifierPluginUID

#include "senserviceinvocationframework.h"  // internal Framework\inc (framework event codes)

#ifndef __WINS__ // only required in release builds
// For reading IMEI. NOTE: not found from Series 60 2.1 public SDK
//Since plpvariant.h is depricated in TB9.2 from wk48 2009 on words.
//provided alternative solution  
//#include <plpvariant.h>
#endif
#include<SenBaseAttribute.h>

namespace
    {
    //_LIT8(KSenBaseIdentityManagerPanic, "SenBaseIdentityManager");

#if !defined( EKA2 ) && !defined( RD_SECURE_PRIV_DATA )
    _LIT(KIdentityFile, "C:\\system\\data\\senidentities.xml");
#else
    _LIT(KIdentityFile, "senidentities.xml");
#endif

    _LIT8(KSpace, " ");
    _LIT8(KUserName, "User");
    _LIT8(KUsersStart, "<Users><User>");
    _LIT8(KUsersEnd, "</User></Users>");
    _LIT8(KIdentityProvider, "IdentityProvider");
    _LIT8(KTouch, "touch");

    const TInt KFLATBUF_SIZE = 128;
    }


EXPORT_C CSenBaseIdentityManager* CSenBaseIdentityManager::NewL(
                                            MSenCoreServiceManager& aManager)
    {
    CSenBaseIdentityManager* pNew = NewLC(aManager);
    CleanupStack::Pop();
    return(pNew) ;
    }

EXPORT_C CSenBaseIdentityManager* CSenBaseIdentityManager::NewLC(
                                            MSenCoreServiceManager& aManager)
    {
    CSenBaseIdentityManager* pNew =
                        new (ELeave) CSenBaseIdentityManager(aManager);
    CleanupStack::PushL(pNew);
    pNew->ConstructL();
    return pNew;
    }

CSenBaseIdentityManager::CSenBaseIdentityManager(
                                            MSenCoreServiceManager& aManager)
:   iIdentity(NULL),
    iProvider(NULL),
    iManager(aManager),
    iConfigReadonly(EFalse),
    iLog((RFileLogger*)aManager.Log()),
    iObserver(NULL),
    ipMechanicsNames(NULL),
    ipDeviceID(NULL),
    iShowPasswordDialog(EFalse)
    {
    }

EXPORT_C CSenBaseIdentityManager::~CSenBaseIdentityManager()
    {
    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenBaseIdentityManager::~CSenBaseIdentityManager");        
    iEcomInfoArray.ResetAndDestroy();
    iSechMechNames.ResetAndDestroy();
    iSechMechCues.ResetAndDestroy();
    delete ipMechanicsNames;
    delete iObserver;
    
    delete iProvider;
    delete ipDeviceID;
    }


void CSenBaseIdentityManager::ConstructL()
    {
    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenBaseIdentityManager::ConstructL - Version 2 [2006-05-09]");        
    BaseConstructL(KIdentityElementLocalName);


    delete ipDeviceID;
    ipDeviceID=NULL;

    #ifndef __WINS__
	//Since plpvariant.h is depricated in TB9.2 from wk48 2009 on words.
	//provided alternative solution  
    /*
    // This only works on target machine
    TPlpVariantMachineId imei;
    PlpVariant::GetMachineIdL(imei);


    ipDeviceID = SenXmlUtils::ToUtf8LC(imei);
    CleanupStack::Pop(); // ipDeviceID
	*/
	TPtrC8 imei ;
	imei.Set(iManager.IMEI());
	ipDeviceID = imei.AllocL();
		
    #else
    // Return a fake IMEI when working on emulator
    _LIT8(KEmulatorImei, "012345678901234");
    ipDeviceID = KEmulatorImei().AllocL();
    #endif

    // Device ID is now resolved, fake or not
    TPtr8 imeiTPtr = ipDeviceID->Des();
    iIdentity = CSenBaseIdentity::NewL(imeiTPtr);

    HBufC* file = KIdentityFile().AllocL();
    CleanupStack::PushL(file);
    LoadFromL(*file, *iManager.XMLReader());

    // ValidateDefaultIdentity()
    ReloadSenSecurityMechanismsL();
    iObserver = CSenSenSecurityMechanismObserver::NewL(*this);
    iObserver->Start();
    CleanupStack::PopAndDestroy(); // file
    }

RFileLogger* CSenBaseIdentityManager::Log()
    {
    return iLog;
    }

void CSenBaseIdentityManager::LoadFromL(TDesC& aFile,
                                                 CSenXmlReader& aReader)
    {
    RFs fss;
    User::LeaveIfError(fss.Connect());
    CleanupClosePushL(fss);
    
    aReader.SetContentHandler(*this);
    SetReader(aReader);

    TInt leaveCode(KErrNone);

#if defined( EKA2 ) || defined( RD_SECURE_PRIV_DATA )
    TBuf<KMaxPath> file;
    fss.CreatePrivatePath(EDriveC);
    fss.PrivatePath(file);
    file.Append(aFile);
    TRAP(leaveCode, aReader.ParseL(fss, file));
#else
    TRAP(leaveCode, aReader.ParseL(fss, aFile));
#endif

#ifdef _SENDEBUG
    if(leaveCode == KErrNotFound)
        {
        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- The senidentities.xml does not exist!");
        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- New file will be generated.");
        }
    else if(leaveCode != KErrNone)
        {
        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("- Parsing of senidentities.xml leaved: %d"), leaveCode));
        }   
    else
        {
        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"- Identity database (senidentities.xml) successfully read.");
        }
#else
    leaveCode=0; // this is a decision: we are not interested 
                 // of invalid input in read/parse phase
#endif

    WriteDatabase(); // Always validate by saving

    CleanupStack::PopAndDestroy(); // fss
    }

EXPORT_C TInt CSenBaseIdentityManager::WriteDatabase()
    {
    TInt retVal(KErrNone);
    TRAP(retVal, WriteConfigurationToL(KIdentityFile));

    return retVal;
    }

void CSenBaseIdentityManager::StartElementL(
                                          const TDesC8& aNsUri,
                                          const TDesC8& aLocalName,
                                          const TDesC8& aQName,
                                          const RAttributeArray& aAttributes
                                                  )
    {
    if (aLocalName ==  KIdentityElementLocalName)
        {
        delete iIdentity;   // there can be only one at the moment
        iIdentity = NULL;
        TPtr8 imei = ipDeviceID->Des();
        iIdentity = CSenBaseIdentity::NewL(imei);
        iIdentity->SetAttributesL(aAttributes);
        iIdentity->SetReader(*Reader());
        DelegateParsingL(*iIdentity);
        }
//  else if (aLocalName == KUsers)
//      {
//      }
    else
        {
        CSenBaseFragment::StartElementL(aNsUri, 
                                    aLocalName, aQName, aAttributes);
        }
    }

MSenIdentity& CSenBaseIdentityManager::IdentityL()
    {
    return (MSenIdentity&)*iIdentity;
    }

TInt CSenBaseIdentityManager::UserNameL(HBufC8*& aUserName)
    {
    delete aUserName;
    aUserName = NULL;
    aUserName = KUserName().AllocL();
    return KErrNone;
    }

CSenIdentityProvider* CSenBaseIdentityManager::IdentityProviderL()
    {
    return IdentityL().IdentityProviderL();
    }
const RPointerArray<CSenIdentityProvider>& CSenBaseIdentityManager::IdentityProvidersL()
    {
    return IdentityL().IdentityProvidersL();
    }

CSenIdentityProvider* CSenBaseIdentityManager::IdentityProviderL(
                            MSenServiceDescription& aServiceDescription )
    {
    return IdentityL().IdentityProviderL( aServiceDescription );
    }

CSenIdentityProvider* CSenBaseIdentityManager::IdentityProviderL(
                                                        const TDesC8& aURI )
    {
    return IdentityL().IdentityProviderL(aURI);
    }

CSenIdentityProvider* CSenBaseIdentityManager::IdentityProviderL(
                                                const CDesC8Array& aIdpList,
                                                TBool aStrict)
    {
    return IdentityL().IdentityProviderL(aIdpList,aStrict);
    }

CSenIdentityProvider* CSenBaseIdentityManager::IdentityProviderL(
                                MSenServiceDescription& aServiceDescription,
                                const CDesC8Array& aIdpList,
                                TBool aStrict)
    {
    return IdentityL().IdentityProviderL(aServiceDescription,aIdpList,aStrict);
    }



// Takes ownership of given IdentityProvider(!)
TInt CSenBaseIdentityManager::RegisterIdentityProviderL( CSenIdentityProvider* apIdp )
    {
    if(!apIdp)
        {
        return KErrArgument; // NULL given!
        }

    CleanupStack::PushL(apIdp);

    // try to register into default identity
    // null check done, above
    TInt retVal = IdentityL().RegisterIdentityProviderL(apIdp);
    CleanupStack::Pop(); // apIdp, ownership elsewhere

    // check success:
    if ( retVal == KErrNone)
        {
        // ownership taken, pop from stack:
        // try to serialize owned object
        TInt notifyLeaveCode(KErrNone);
        TRAP(notifyLeaveCode, iManager.NotifyFrameworksL(KSenEventRegisterIdentityProvider, apIdp));
        if ( WriteDatabase() != KErrNone)
            {
            retVal = KErrWrite;
            }
        }
    return retVal;
    }

TInt CSenBaseIdentityManager::UnregisterIdentityProviderL( CSenIdentityProvider& aIdp )
    {
    TInt retVal = IdentityL().UnregisterIdentityProviderL( aIdp );

    if ( retVal == KErrNone )
        {
        TInt notifyLeaveCode(KErrNone);
        TRAP(notifyLeaveCode, iManager.NotifyFrameworksL(KSenEventUnregisterIdentityProvider, &aIdp));
        
        
//      if (KErrNone != WriteDatabase() )
//          {
//          retVal = EFalse;
//          }

        retVal = WriteDatabase();
        }
    return retVal;
    }

TBool CSenBaseIdentityManager::AssociateServiceL( const TDesC8& aServiceID,
                                                  const TDesC8& aProviderID )
    {
    TBool retVal = IdentityL().AssociateServiceL(aServiceID, aProviderID);
    if (retVal)
        {
        if (KErrNone != WriteDatabase())
            {
            retVal = EFalse;
            }
        }
    return retVal;
    }

TBool CSenBaseIdentityManager::DissociateServiceL(
                                                   const TDesC8& aServiceID,
                                                   const TDesC8& aProviderID )
    {
    TBool retVal = IdentityL().DissociateServiceL(aServiceID, aProviderID);
    if (retVal)
        {
        if (KErrNone != WriteDatabase())
            {
            retVal = EFalse;
            }
        }
    return retVal;
    }

TInt CSenBaseIdentityManager::IdentitiesL(
                                            CDesC8Array& /* aIdentitiesList */)
    {
    return KErrNotSupported; // not yet supported.
    }


// NOTE! This code does not do as documentation states.
// Only second line text is shown and
// "Ok" button on the left side.
// return the value of button pressed (OK or CANCEL)
TInt CSenBaseIdentityManager::YesNoQueryL(const TDesC& aLine1,
                                          const TDesC& aLine2,
                                          const TDesC& aButton1,
                                          const TDesC& aButton2)
    {
    RNotifier notifier;
    User::LeaveIfError(notifier.Connect());
    CleanupClosePushL(notifier);

    TRequestStatus status;
    TInt buttonVal = -1;


    // NOTE! This code does not do as documentation states.
    // Only second line text is shown and
    // "Ok" button on the left side.

//    notifier.Notify(_L("Line 1 text"), _L("Line2 text"),
//        _L("B1Txt"), _L("B2Txt"), buttonVal, status);

    notifier.Notify(aLine1,
                    aLine2,
                    aButton1,
                    aButton2,
                    buttonVal,
                    status);


    User::WaitForRequest(status);
    CleanupStack::PopAndDestroy(); // Close notifier

#ifdef _SENDEBUG
    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("User pressed button (%d)"), buttonVal));
#endif

    return buttonVal;
    }

TBool CSenBaseIdentityManager::AllowSavePasswordL()
    {
    TBool retVal = EFalse;

    RNotifier notifier;
    User::LeaveIfError(notifier.Connect());
    CleanupClosePushL(notifier);

    TPckgBuf<TAskSaveDlgRequest>* request = new(ELeave)TPckgBuf<TAskSaveDlgRequest>();
    CleanupStack::PushL(request);

    TPckgBuf<TAskSaveDlgResponse>* response = new(ELeave)TPckgBuf<TAskSaveDlgResponse>();
    CleanupStack::PushL(response);

    TRequestStatus reqStatus;
    notifier.StartNotifierAndGetResponse(reqStatus, KSenNotifierPluginUID, *request, *response);

    User::WaitForRequest(reqStatus);
    notifier.Close();

    if(reqStatus.Int() == KErrNone)
        {
        if((*response)().OkButtonPressed())
            {
            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("User pressed OK Button to allow password saving")));
            retVal = ETrue;
            }
#ifdef _SENDEBUG
        else
            {
            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("User pressed Cancel Button to deny password saving")));
            }
#endif
        }
#ifdef _SENDEBUG
    else if(reqStatus.Int() == KErrNotFound)
        {
        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("Notifier plug-in for 'Save WS data?' -dialog was not found")));
        }
    else
        {
        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("'Save WS data?' -dialog returned an error: %d"), 
                                                        reqStatus.Int()));
        }
#endif

    CleanupStack::PopAndDestroy(2); // request, response;
    //CleanupStack::PopAndDestroy(); // close the notifier
    CleanupStack::Pop(); // notifier
    return retVal;
    }

TInt CSenBaseIdentityManager::AuthenticationForL(
                            CSenIdentityProvider& aProvider, 
                            TPckgBuf<TSenAuthentication>& aResponse)
    {
    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenBaseIdentityManager::AuthenticationForL");

    TPtrC8 user = aProvider.AuthzID();
    if (user == KNullDesC8)
        {
        user.Set(aProvider.AdvisoryAuthnID());
        }


    if (!iShowPasswordDialog)
        {
        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"Not allowed to show password dialog");
        HBufC8* pDecodedPassword = SenXmlUtils::DecodeHttpCharactersLC(aProvider.Password());
        TPtrC8 decodedPassword = pDecodedPassword->Des();

        aResponse().iUsername.Append((const TUint8*)user.Ptr(), user.Size());
        aResponse().iPassword.Append((const TUint8*)decodedPassword.Ptr(), 
                                        decodedPassword.Size());
        CleanupStack::PopAndDestroy(); // delete pDecodedPassword
        return KErrNone;
        }


    RNotifier notifier;
    User::LeaveIfError(notifier.Connect());
    CleanupClosePushL(notifier);

    TPckgBuf<TAuthenticationDlgRequest>* request = 
                            new(ELeave)TPckgBuf<TAuthenticationDlgRequest>();
    CleanupStack::PushL(request);

    // convert username to unicode
    HBufC* pUserAsUnicode = SenXmlUtils::ToUnicodeLC(user); // push
    TPtrC username = pUserAsUnicode->Des();

    // decode password
    HBufC8* pDecodedPassword = SenXmlUtils::DecodeHttpCharactersLC(aProvider.Password());
    TPtrC8 decodedPassword = pDecodedPassword->Des();
    // convert decoded password to unicode
    HBufC* pPasswordAsUnicode = 
                SenXmlUtils::ToUnicodeLC(decodedPassword); // push
    TPtrC password = pPasswordAsUnicode->Des();

    // set data to request
    (*request)().SetData(username, password);

    CleanupStack::PopAndDestroy(3); // delete pPasswordAsUnicode, pDecodedPassword, pUserAsUnicode


    TPckgBuf<TAuthenticationDlgResponse>* response = 
                        new(ELeave)TPckgBuf<TAuthenticationDlgResponse>();
    CleanupStack::PushL(response);

    TRequestStatus reqStatus;
    notifier.StartNotifierAndGetResponse(reqStatus, 
                            KSenNotifierPluginUID, *request, *response);

    TBool illegalUsername = EFalse;

    HBufC8* pUsernameUtf8 = NULL;
    HBufC8* pPasswordUtf8 = NULL;
    User::WaitForRequest(reqStatus);

    notifier.Close();

    if(reqStatus.Int() == KErrNone)
        {
        if((*response)().OkButtonPressed())
            {
            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("User pressed OK Button in Password dialog")));
            pUsernameUtf8 = SenXmlUtils::ToUtf8LC((*response)().Username());
            pPasswordUtf8 = SenXmlUtils::ToUtf8LC((*response)().Password());
            TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("Username: %S"), pUsernameUtf8));
            TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("Password: %S"), pPasswordUtf8 ));
            HBufC8* pEncodedUsername = NULL;
            illegalUsername = 
                SenXmlUtils::EncodeHttpCharactersL(*pUsernameUtf8,
                                                    pEncodedUsername);
            if (illegalUsername) 
                {
                TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("Username included illegal characters.")));
                delete pEncodedUsername;
                pEncodedUsername = NULL;
                }
#ifdef _SENDEBUG
            else
                {
                TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"Username did NOT include illegal characters.");
                }
#endif
       		
       		//Check if iilegal chars are there then return
            if (!illegalUsername)
                {
                
                if(user != *pUsernameUtf8)
                {
                	
	                // User modified the username in the dialog prompt(!)
	                // We have to save it right away, because there is
	                // no in-memory/session based member variables in
	                // components calling identity manager (sec mechs and
	                // in ID-WSF AS client!
	                TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"Username changed. Saving new username.");

	                // Use Advisory only if AuthzID is not available
	                if (aProvider.AuthzID() == KNullDesC8 
	                    && aProvider.AdvisoryAuthnID() != KNullDesC8)
	                    {
	                    aProvider.SetUserInfoL(aProvider.AuthzID(),
	                                            *pUsernameUtf8, 
	                                            aProvider.Password());
	                    }
	                else 
	                    {
	                    // There was at least AuthzID available, and possibly
	                    // also advisory value. Any way, if 

	                    
	                    // We have to NULL advisory value (set it to KNullDesC8), 
	                    // because if both were available, then user was
	                    // prompted to allow modification of AuthzID AND 
	                    // if advisory was changed in service (is no longer
	                    // valid), there would NOT be any way for end-user
	                    // to change (remove) it(!)

	                    CSenElement& element = aProvider.AsElement();
	                    delete element.RemoveElement(KSenIdpAdvisoryAuthnIdLocalname);

	                    aProvider.SetUserInfoL(*pUsernameUtf8, 
	                                            KNullDesC8,
	                                            aProvider.Password());
	                    }
	                // serialize changed username into sensessions.xml database immediately
	                WriteDatabase();
                }
                
	            if (AllowSavePasswordL())
	                {
	                HBufC8* pEncodedPassword = SenXmlUtils::EncodeHttpCharactersLC(*pPasswordUtf8);
#ifdef _SENDEBUG
                if(pEncodedPassword)
                    {
                    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8("Encoded password: %S"), pEncodedPassword));
                    }
#endif
					if(pEncodedPassword)
						{
							aProvider.SetUserInfoL(aProvider.AuthzID(),
	                                        aProvider.AdvisoryAuthnID(),
	                                        *pEncodedPassword);
						}
	                WriteDatabase();
	                CleanupStack::PopAndDestroy(1); // pEncodedPassword
	                }
                
                }

            aResponse().iUsername.Zero();
            aResponse().iPassword.Zero();
            if (!illegalUsername) 
            {
	            aResponse().iUsername.Copy(pUsernameUtf8->Des());
	            aResponse().iPassword.Copy(pPasswordUtf8->Des());
            }

            CleanupStack::PopAndDestroy(2); // pPasswordUtf8, pUsernameUtf8
            }
        else
            {
            TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("User pressed Cancel Button in Password dialog")));
            }
        }
    else if(reqStatus.Int() == KErrNotFound)
        {
        TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("Password dialog plugin notifier impl. was not found")));
        }
    else
        {
        TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KMinLogLevel, _L8(" Notifier plugin for 'Password' dialog returned an error: %d"), 
                                                        reqStatus.Int()));
        }

    CleanupStack::PopAndDestroy(2); // request, response;
    CleanupStack::Pop(); // notifier

    if (illegalUsername) return KErrArgument;
    return reqStatus.Int();
    }


TInt CSenBaseIdentityManager::WriteConfigurationToL( const TDesC& aFile )
    {
    // First, collect everything into MEMORY
    CBufFlat *pBuf = CBufFlat::NewL(KFLATBUF_SIZE);
    CleanupStack::PushL(pBuf);

    RBufWriteStream bufWs(*pBuf);
    CleanupClosePushL(bufWs);

    bufWs.WriteL(KUsersStart);

    if(iIdentity)
        {
        iIdentity->WriteAsXMLToL(bufWs);
        }

    bufWs.WriteL(KUsersEnd);

    TPtrC8 p8 = pBuf->Ptr(0);

    CleanupStack::PopAndDestroy(1); // bufWs

    // Everything in MEMORY ok, prepare to write into file
    RFs fss;
    User::LeaveIfError(fss.Connect());
    CleanupClosePushL(fss);

    RFileWriteStream fileOutStream;
    CleanupClosePushL(fileOutStream);


    if(!SysUtil::FFSSpaceBelowCriticalLevelL(&fss, p8.Length()) )
        {
        // note, this will zero-length the file(!)
        // it is better to require that 2xfilesize is available and not to
        // dangerously zero the old file and find out
        // that there is no space left..

        //Data caging 2 implementation
#if defined( EKA2 ) || defined( RD_SECURE_PRIV_DATA )
        TBuf<KMaxPath> file;
        fss.CreatePrivatePath(EDriveC);
        fss.PrivatePath(file);
        file.Append(aFile);
        fileOutStream.Replace(fss, file, EFileWrite);
#else
        fileOutStream.Replace(fss, aFile, EFileWrite);
#endif
        // finally write the UTF-8 into the file. 
        fileOutStream.WriteL(p8);
        }

    CleanupStack::PopAndDestroy(3); // fileOutStream, fss, pBuf

    return KErrNone;
    }


void CSenBaseIdentityManager::ReloadSenSecurityMechanismsL()
    {
    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("Entering CSenXMLDAO::ReloadSenSecurityMechanismsL()..")));

    delete ipMechanicsNames;
    ipMechanicsNames = NULL;
    ipMechanicsNames = CBufFlat::NewL(KFLATBUF_SIZE);
    RBufWriteStream bufWs(*ipMechanicsNames);
    CleanupClosePushL(bufWs);

    iSechMechNames.ResetAndDestroy();
    iSechMechCues.ResetAndDestroy();

    REComSession::ListImplementationsL(KUidSechMech, iEcomInfoArray);


    TInt infoCount(iEcomInfoArray.Count());
    TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase  , KNormalLogLevel, _L8("%d Security Mechanism ECOM implementations found."),
                        infoCount));

    for (TInt i=0; i<infoCount; i++)
        {
        CImplementationInformation* pImplImfo = iEcomInfoArray[i];
        CSenSecurityMechanism* pSechMech =
            CSenSecurityMechanism::NewL(pImplImfo->DataType(),
                                        iManager);
        CleanupStack::PushL(pSechMech);
        iSechMechNames.Append(pSechMech->Name().AllocL());
        iSechMechCues.Append(pImplImfo->DataType().AllocL());
        bufWs.WriteL(pSechMech->Name());
        CleanupStack::PopAndDestroy(); // pSechMech
        if (i < (infoCount-1))
            {
            bufWs.WriteL(KSpace);
            }
        }
    iEcomInfoArray.ResetAndDestroy();
    CleanupStack::PopAndDestroy(1); // bufWs
    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(_L("Leaving CSenXMLDAO::ReloadSenSecurityMechanismsL().. ")));

    }


TPtrC8 CSenBaseIdentityManager::SenSecurityMechanismNames8L()
    {
    TPtrC8 p8 = ipMechanicsNames->Ptr(0);
    return p8;
    }

CSenSecurityMechanism* CSenBaseIdentityManager::MechanismNamedL(
                                                        const TDesC8& aName)
    {
    CSenSecurityMechanism* pSaslMechanism = NULL;
    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenIdWsfPlugin::MechanismNamedL");
    TLSLOG(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,(aName));

    for (TInt i=0; i<iSechMechNames.Count(); i++)
        {
        if (*iSechMechNames[i] == aName)
            {
            pSaslMechanism = CSenSecurityMechanism::NewL(*iSechMechCues[i], 
                                                                iManager);
            TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenBaseIdentityManager::MechanismNamedL - successful");
            break;
            }
        }
    if(!pSaslMechanism)
        {
        TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenBaseIdentityManager::MechanismNamedL - lookup failed!");
        }

    return pSaslMechanism;
    }

HBufC8* CSenBaseIdentityManager::EncodeToBase64LC(const TDesC8& aSource)
    {
    return iManager.EncodeToBase64LC(aSource);
    }

HBufC8* CSenBaseIdentityManager::DecodeFromBase64LC(const TDesC8& aSource)
    {
    return iManager.DecodeFromBase64LC(aSource);
    }

void CSenBaseIdentityManager::SetShowPasswordDialog(const TBool aState)
    {
    TLSLOG_L(KSenCoreServiceManagerLogChannelBase  , KMinLogLevel,"CSenBaseIdentityManager::SetShowPasswordDialog");
    iShowPasswordDialog = aState;
    }

TInt CSenBaseIdentityManager::ContainsIdentityProviderL(
                                                   TBool& aContains,
                                                   CSenIdentityProvider& aIDP)
    {
    return IdentityL().ContainsIdentityProviderL(aContains, aIDP);
    }
    
TInt CSenBaseIdentityManager::FindMatchingIdentityProviderL(CSenIdentityProvider &aIdp,
                                                            CSenIdentityProvider*& apMatch)
    {
    return IdentityL().FindMatchingIdentityProviderL(aIdp, apMatch);
    }
        
TInt CSenBaseIdentityManager::UpdateIdentityProviderL(CSenIdentityProvider& aIdp)
    {
    TInt retVal = IdentityL().UpdateIdentityProviderL(aIdp);

    // check success:
    if ( retVal == KErrNone)
        {
        // ownership taken, pop from stack:
        // try to serialize owned object
        if ( WriteDatabase() != KErrNone)
            {
            retVal = KErrWrite;
            }
        }

    return retVal;
    }
    

EXPORT_C void CSenBaseIdentityManager::UpdateTouchIdentityDBL(MSenServiceDescription& asd)
	{
	CSenIdentityProvider* Idp = NULL;
	
	Idp = iIdentity->IdentityProviderL(asd);
	if(Idp != NULL)
		{
		TUint32 current_tick(0);
		TBuf8<32> tickBuf;
				
		CSenElement& IdpElem = Idp->AsElement();
		current_tick = User::NTickCount();
		tickBuf.Num(current_tick);
		IdpElem.AddAttrL(KTouch(), tickBuf);
		}
//	CleanupUnusedIdentityDBL();   
                                  // (don't de-serialize old items). Serialized 
	                              // objects cannot be de-allocated on the fly.
	}
	
void CSenBaseIdentityManager::CleanupUnusedIdentityDBL()
	{
	TInt count(0);
	
	RPointerArray<CSenElement> elemList;
	CleanupClosePushL(elemList);
	
	CSenElement& element = iIdentity->AsElement();
	element.ElementsL(elemList, KIdentityProvider);
	count = elemList.Count(); 
	// There can be many Identity Provider elements within Identity element
	for(TInt i = 0; i < count; i++)
		{
		CSenElement* elem = elemList[i];
		
		const TDesC8* attrValue = elem->AttrValue(KTouch());
		if(attrValue != NULL)
			{
			TUint32 current_tick(0);
			TUint32 db_ticks(0);
			TUint32 diff_ticks(0);
					
			TLex8 lex;
            lex.Assign(*attrValue);
            lex.Val(db_ticks, EDecimal);
            
            current_tick = User::NTickCount();
            diff_ticks = current_tick - db_ticks;
            if(KMaxTicks <= diff_ticks || current_tick < db_ticks)
				{
				TInt endpointCount(0);
				_LIT8(KEndpoint, "Endpoint");
												
				RPointerArray<CSenElement> endpointElemList;
				CleanupClosePushL(endpointElemList);
				
				elem->ElementsL(endpointElemList, KEndpoint);
				endpointCount = endpointElemList.Count();
				
				if(endpointCount > 0)
					{
					CSenIdentityProvider* pMatch = NULL;
					
					CSenElement* endpointElem = endpointElemList[0];
					TPtrC8 endpoint = endpointElem->Content();
					pMatch = IdentityProviderL(endpoint);
					if(pMatch != NULL)
						{
						// Ownership ?
						UnregisterIdentityProviderL(*pMatch);
						}
					}
				CleanupStack::PopAndDestroy(&endpointElemList);
				}
			}
		}
	CleanupStack::PopAndDestroy(&elemList);
	}
			
// End of file