diff -r 000000000000 -r 62f9d29f7211 webservices/wsidentitymanager/src/senbaseidentitymanager.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsidentitymanager/src/senbaseidentitymanager.cpp	Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,945 @@
+/*
+* 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