--- /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