--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsidentitymanager/src/senbaseidentity.cpp Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,989 @@
+/*
+* 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 FILES
+#include <SenXmlElement.h>
+#include <SenBaseFragment.h>
+#include <SenXmlUtils.h>
+#include <SenServiceConnection.h> // WSF error codes
+
+#include "senbaseidentity.h"
+#include "senwiseidentityprovider.h"
+#include "sendebug.h" // internal Utils\inc - filelogging MACROs
+#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__
+
+EXPORT_C CSenBaseIdentity* CSenBaseIdentity::NewL(TPtrC8 aIMEI)
+ {
+ CSenBaseIdentity* pNew = NewLC(aIMEI);
+ CleanupStack::Pop();
+ return(pNew) ;
+ }
+EXPORT_C CSenBaseIdentity* CSenBaseIdentity::NewLC(TPtrC8 aIMEI)
+ {
+ CSenBaseIdentity* pNew = new (ELeave) CSenBaseIdentity(aIMEI);
+ CleanupStack::PushL(pNew);
+ pNew->ConstructL();
+ return pNew;
+ }
+CSenBaseIdentity::CSenBaseIdentity(TPtrC8 aIMEI)
+: iProvider(NULL),
+ iIMEI(aIMEI)
+ {
+ }
+
+void CSenBaseIdentity::ConstructL()
+ {
+ BaseConstructL( KIdentityElementLocalName() );
+ }
+
+
+CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL(MSenServiceDescription& aService )
+ {
+
+ TInt idpCount(iProviderList.Count());
+
+ CSenIdentityProvider* pIdp = NULL;
+ CSenIdentityProvider* pCandidate = NULL;
+
+ for (TInt i=0; i<idpCount; i++)
+ {
+ pCandidate = (CSenIdentityProvider*)iProviderList[i];
+ if(pCandidate->IsTrustedByL(aService))
+ {
+ pIdp = pCandidate;
+ pCandidate = NULL;
+ }
+ if(pIdp == NULL && pCandidate->IsDefault())
+ {
+ pIdp = pCandidate;
+ }
+
+ if(pIdp)
+ {
+ break;
+ }
+ }
+ return pIdp;
+ }
+
+CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL(const TDesC8& aURI )
+ {
+ TInt idpCount(iProviderList.Count());
+ CSenIdentityProvider* retVal = NULL;
+ for (TInt i=0; i<idpCount; i++)
+ {
+ retVal = (CSenIdentityProvider*)iProviderList[i];
+ if (retVal->Endpoint() == aURI)
+ {
+ break;
+ }
+ else
+ {
+ retVal = NULL;
+ }
+ }
+ return retVal;
+ }
+
+CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL(const CDesC8Array& aIdpIdList,
+ TBool aStrict )
+ {
+ TInt idpCount(iProviderList.Count());
+ TInt patternCount(aIdpIdList.Count());
+
+ if(patternCount==0)
+ {
+ if(aStrict)
+ {
+ return NULL;
+ }
+ else
+ {
+ return IdentityProviderL(); // return the default provider
+ }
+ }
+
+ // to optimize the search, store the default idp
+ CSenIdentityProvider* pDefault = NULL;
+
+ for (TInt i=0; i<idpCount; i++)
+ {
+ for(TInt j=0; j<patternCount; j++)
+ {
+ TPtrC8 providerID = ((CSenIdentityProvider*)iProviderList[i])->ProviderID();
+ if(providerID.Length()>0 && providerID == aIdpIdList[j])
+ {
+ return (CSenIdentityProvider*)iProviderList[i];
+ }
+ }
+ if(!aStrict)
+ {
+ // to optimize the search, store the default idp, if found
+ if(((CSenIdentityProvider*)iProviderList[i])->IsDefault())
+ {
+ pDefault = (CSenIdentityProvider*)iProviderList[i];
+ }
+ }
+ }
+ if(aStrict)
+ {
+ // default idp does not meet the search requirements
+ // (not in strict pattern list)
+ return NULL;
+ }
+ else
+ {
+ // if current item did not match with anything in the
+ // pattern list, check if it's ok in non-strict perspective
+ return pDefault;
+ }
+ }
+
+CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL(MSenServiceDescription& aService,
+ const CDesC8Array& aIdpIdList,
+ TBool aStrict)
+ {
+ TInt idpCount(iProviderList.Count());
+ TInt patternCount(aIdpIdList.Count());
+
+ if(patternCount==0)
+ {
+ if(aStrict)
+ {
+ return NULL;
+ }
+ else
+ {
+ return IdentityProviderL(); // return the default provider
+ }
+ }
+
+ // to optimize the search, store the default idp
+ CSenIdentityProvider* pDefault = NULL;
+ CSenIdentityProvider* pTrusted = NULL;
+
+ for (TInt i=0; i<idpCount; i++)
+ {
+ for(TInt j=0; j<patternCount; j++)
+ {
+ TPtrC8 providerID =
+ ((CSenIdentityProvider*)iProviderList[i])->ProviderID();
+ if(providerID.Length()>0 && providerID == aIdpIdList[j])
+ {
+ if (((CSenIdentityProvider*)iProviderList[i])->IsTrustedByL(aService))
+ {
+ return (CSenIdentityProvider*)iProviderList[i];
+ }
+ }
+ }
+
+ if(!aStrict)
+ {
+ if (!pTrusted)
+ {
+ if (((CSenIdentityProvider*)iProviderList[i])->IsTrustedByL(aService))
+ {
+ pTrusted = (CSenIdentityProvider*)iProviderList[i];
+ }
+ }
+
+ // to optimize the search, store the default IDP, if found
+ if(((CSenIdentityProvider*)iProviderList[i])->IsDefault())
+ {
+ pDefault = (CSenIdentityProvider*)iProviderList[i];
+ }
+ }
+ }
+
+
+ if(aStrict)
+ {
+ // default idp does not meet the search requirements
+ // (not in strict pattern list)
+ return NULL;
+ }
+ else
+ {
+ // if current item did not match with anything in the
+ // pattern list, check if it's ok in non-strict perspective
+ if (pTrusted)
+ {
+ return pTrusted;
+ }
+ else
+ {
+ return pDefault;
+ }
+ }
+ }
+
+CSenIdentityProvider* CSenBaseIdentity::IdentityProviderL()
+ {
+ TInt idpCount(iProviderList.Count());
+
+ CSenIdentityProvider* pDefaultIdp = NULL;
+
+ for (TInt i=0; i<idpCount && !pDefaultIdp; i++)
+ {
+ pDefaultIdp = (CSenIdentityProvider*)iProviderList[i];
+ if (!pDefaultIdp->IsDefault()) pDefaultIdp = NULL;
+ }
+
+ if (!pDefaultIdp && idpCount > 0)
+ {
+ // use the first IdentityProvider
+ pDefaultIdp = (CSenIdentityProvider*)iProviderList[0];
+ }
+
+ return pDefaultIdp;
+ }
+const RIdentityProviderList& CSenBaseIdentity::IdentityProvidersL() const
+ {
+ return iProviderList;
+ }
+
+// NOTE: takes ownership of the given apIdentityProvider
+TInt CSenBaseIdentity::RegisterIdentityProviderL(CSenIdentityProvider* apIdentityProvider )
+ {
+ //SENDEBUG_L("CSenBaseIdentity::RegisterIdentityProviderL(*)");
+
+ if(!apIdentityProvider)
+ {
+ SENDEBUG_L("RegisterIdentityProviderL(*) - Illegal argument: NULL");
+ return KErrArgument;
+ }
+
+ if (apIdentityProvider->Endpoint() == KNullDesC8)
+ {
+ SENDEBUG_L("RegisterIdentityProviderL(*) - Error: no Endpoint in IDP");
+ //Delete the object since ownership is with us
+ delete apIdentityProvider;
+ apIdentityProvider = NULL;
+ return KErrSenNoEndpoint;
+ }
+
+ TInt retVal(KErrNone);
+
+ // Now check for duplicates:
+ CSenIdentityProvider* pDuplicate = NULL;
+
+ retVal = FindMatchingIdentityProviderL(*apIdentityProvider, pDuplicate);
+ if(pDuplicate)
+ {
+ //SENDEBUG((_L(" Duplicate(s) found, updating the IdP!.")));
+ RPointerArray<CSenElement> newElements =
+ apIdentityProvider->AsElement().ElementsL();
+
+ TInt elemCount = newElements.Count();
+ TInt i(0);
+ // Checking the aIdp elements
+ while ( i < elemCount )
+ {
+ CSenElement* elem = newElements[i];
+ TPtrC8 localName = elem->LocalName();
+
+ RPointerArray<CSenElement> pDuplicateAsElems =
+ pDuplicate->AsElement().ElementsL();
+ TInt duplicateCount = pDuplicateAsElems.Count();
+ TBool found = EFalse;
+ TBool foundServiceID = EFalse;
+ TInt j(0);
+
+ // Checking if the duplicate has the element found from aIdp
+ // If found update it, if not found insert new element.
+ while ( j < duplicateCount )
+ {
+ CSenElement* dupElem = pDuplicateAsElems[j];
+ if ( localName == dupElem->LocalName() )
+ {
+ if ( localName == KServiceIDElementLocalName )
+ {
+ if ( elem->Content() == dupElem->Content() )
+ {
+ foundServiceID = ETrue;
+ }
+ }
+ else
+ {
+ // note, this create the element if it
+ // is not found
+ if (elem->Content() != KNullDesC8)
+ {
+ dupElem->SetContentL( elem->Content() );
+ }
+ RPointerArray<CSenElement> nestedElems = elem->ElementsL();
+ for (TInt k = 0; k < nestedElems.Count(); k++)
+ {
+ CSenElement* dupNestEl = dupElem->Element(nestedElems[k]->LocalName());
+ if (dupNestEl)
+ {
+ dupNestEl->SetContentL(nestedElems[k]->Content());
+ }
+ else
+ {
+ CSenElement* newEl = dupElem->CreateElementL(nestedElems[k]->NsPrefix(),
+ nestedElems[k]->LocalName());
+ CleanupStack::PushL(newEl);
+ dupElem->AddElementL(*newEl);
+ CleanupStack::Pop(newEl);
+ newEl->SetContentL(nestedElems[k]->Content());
+ }
+ }
+
+ //cleaning, if sth has been removed on backend
+ //nested duplicate - local
+ //nested - backend
+ RPointerArray<CSenElement> nestedDupElems = dupElem->ElementsL();
+ for (TInt k = 0; k < nestedDupElems.Count(); k++)
+ {
+ CSenElement* nestEl = elem->Element(nestedDupElems[k]->LocalName());
+ if (!nestEl)
+ {
+ nestedDupElems[k]->SetContentL(KNullDesC8);
+ }
+ }
+
+
+ found = ETrue;
+ break;
+ }
+ }
+ j++;
+ }
+
+ if ( !found && !foundServiceID && elem)
+ {
+ // this is new kind of element, and not in original
+ // idp, thus it needs to be copied because it is
+ // owned by idp being registered (which will be
+ // deleted inside this method)
+ CSenElement* pCopy =
+ CSenXmlElement::NewL( elem->LocalName() );
+ CleanupStack::PushL(pCopy);
+ // copy the contents of serviceid
+ pCopy->CopyFromL(*elem);
+ // append the copy into original idp
+ pDuplicate->AsElement().AddElementL( *pCopy );
+ CleanupStack::Pop(); // pCopy
+ }
+ i++;
+ }
+ // NOTE: ownership of the given argument apIdentityProvider
+ // will NOT be TRANSFERRED to anywhere.
+ // So: free the memory, contents copied and thus updated
+
+ delete apIdentityProvider;
+ apIdentityProvider = NULL;
+ if(retVal > 0)
+ retVal = KErrNone;
+ }
+ else if(retVal==KErrNotFound)
+ {
+ //SENDEBUG((_L(" No duplicate(s) found, will try to add..")));
+ // Append into both provider list and as child element
+ retVal = iProviderList.Append( apIdentityProvider );
+ if(retVal==KErrNone)
+ {
+ // OWNERSHIP of apIdentityProvider is now here
+ TInt leaveCode(KErrNone);
+ TRAP( leaveCode, AsElement().AddElementL(apIdentityProvider->AsElement() ) );
+ if(leaveCode!=KErrNone)
+ {
+ retVal = leaveCode;
+ // no need to free the apIdentityProvider, it will
+ // be destroyed in destructor as part of iProviderList
+ }
+ }
+ else
+ {
+ // free the orphan apIdentityProvider
+ delete apIdentityProvider;
+ apIdentityProvider = NULL;
+ }
+ }
+ else // some other error occurred: free the orphan argument
+ {
+ //SENDEBUG((_L("An error occured and no duplicate(s) were found.")));
+ delete apIdentityProvider;
+ apIdentityProvider = NULL;
+ }
+ return retVal;
+ }
+
+TInt CSenBaseIdentity::UpdateIdentityProviderL(CSenIdentityProvider& aIdentityProvider)
+ {
+ if (aIdentityProvider.Endpoint() == KNullDesC8)
+ {
+ SENDEBUG_L("RegisterIdentityProviderL(*) - Error: no Endpoint in IDP");
+ return KErrSenNoEndpoint;
+ }
+
+ TInt retVal(KErrNone);
+
+ // Now check for duplicates:
+ CSenIdentityProvider* pDuplicate = NULL;
+
+ retVal = FindMatchingIdentityProviderL(aIdentityProvider, pDuplicate);
+ if(pDuplicate)
+ {
+ //SENDEBUG((_L(" Duplicate(s) found, updating the IdP!.")));
+ RPointerArray<CSenElement> newElements =
+ aIdentityProvider.AsElement().ElementsL();
+
+ TInt elemCount = newElements.Count();
+ TInt i(0);
+ // Checking the aIdp elements
+ while ( i < elemCount )
+ {
+ CSenElement* elem = newElements[i];
+ TPtrC8 localName = elem->LocalName();
+
+ RPointerArray<CSenElement> pDuplicateAsElems =
+ pDuplicate->AsElement().ElementsL();
+ TInt duplicateCount = pDuplicateAsElems.Count();
+ TBool found = EFalse;
+ TBool foundServiceID = EFalse;
+ TInt j(0);
+
+ // Checking if the duplicate has the element found from aIdp
+ // If found update it, if not found insert new element.
+ while ( j < duplicateCount )
+ {
+ CSenElement* dupElem = pDuplicateAsElems[j];
+ if ( localName == dupElem->LocalName() )
+ {
+ if ( localName == KServiceIDElementLocalName )
+ {
+ if ( elem->Content() == dupElem->Content() )
+ {
+ foundServiceID = ETrue;
+ }
+ }
+ else
+ {
+ // note, this create the element if it
+ // is not found
+ dupElem->SetContentL( elem->Content() );
+ found = ETrue;
+ break;
+ }
+ }
+ j++;
+ }
+
+ if ( !found && !foundServiceID && elem)
+ {
+ // this is new kind of element, and not in original
+ // idp, thus it needs to be copied because it is
+ // owned by idp being registered (which will be
+ // deleted inside this method)
+ CSenElement* pCopy =
+ CSenXmlElement::NewL( elem->LocalName() );
+ CleanupStack::PushL(pCopy);
+ // copy the contents of serviceid
+ pCopy->CopyFromL(*elem);
+ // append the copy into original idp
+ pDuplicate->AsElement().AddElementL( *pCopy );
+ CleanupStack::Pop(); // pCopy
+ }
+ i++;
+ }
+ if(retVal > 0)
+ retVal = KErrNone;
+ }
+
+ return retVal;
+ }
+
+// Note: non-strict search is used when unregistering: it must be possible
+// to unregister a provider using only provider Id in cases where someone
+// is unable to update and IDP (because provider id was *already *in use).
+// This "someone", cannot figure out the endpoint -> so, only way to unregister
+// blocking IDP is to call unregister(ProviderID) and then register the IDP
+// using different ProviderID & endpoint pair.
+
+// more about this "non strict" search used by unregistering: to get a MATCH
+// usingof plain endpoint must be accepted ONLY if providerid was NOT in use
+// with basic web services.
+//
+
+// FOR ID-WSF framework, mainly
+TInt CSenBaseIdentity::FindMatchingIdentityProviderL(CSenIdentityProvider& aIdp,
+ CSenIdentityProvider*& apMatch)
+ {
+ //SENDEBUG((
+ // _L("CSenBaseIdentity::FindMatchingIdentityProviderL() - Started ")));
+
+ TInt retVal(KErrNotFound);
+
+ TInt idpCount(iProviderList.Count());
+ apMatch = NULL;
+
+ for (TInt i=0; i<idpCount; i++)
+ {
+ TPtrC8 databaseProvID =
+ ((CSenIdentityProvider*)iProviderList[i])->ProviderID();
+
+ TPtrC8 databaseEndpoint =
+ ((CSenIdentityProvider*)iProviderList[i])->Endpoint();
+
+
+
+ TPtrC8 addedProvID = aIdp.ProviderID();
+ TPtrC8 addedEndpoint = aIdp.Endpoint();
+
+ if(databaseProvID==KNullDesC8)
+ {
+ // This is Basic Web Services IDP and only endpoint matters
+ if( databaseEndpoint == addedEndpoint )
+ {
+ retVal = i; // match was found: return the index of found element
+ apMatch = iProviderList[i];
+ }
+ }
+ else if(databaseProvID == addedProvID)
+ {
+ // This is an ID-WSF IDP, where providerIDs match
+
+ // We might have a match for non-strict ("provider id only" -type search).
+ // Now we must check that there was
+ if( databaseEndpoint == addedEndpoint )
+ {
+ apMatch = (CSenIdentityProvider*)iProviderList[i];
+ retVal = i; // match was found: return the index of found IDP
+ }
+ else
+ {
+ // we need to return an error code indicating that provider id
+ // is already mapped to different endpoint(!)
+ retVal = KErrSenProviderIdInUseByAnotherEndpoint;
+ }
+ }
+ }
+ return retVal;
+ }
+
+
+TInt CSenBaseIdentity::UnregisterIdentityProviderL(CSenIdentityProvider& aIdp )
+ {
+ TInt retVal(KErrNotFound);
+
+ CSenIdentityProvider* pMatch = NULL;
+ TInt index = FindMatchingIdentityProviderL(aIdp, pMatch);
+
+ if ( index==KErrNotFound ||
+ (aIdp.Endpoint()==KNullDesC8 &&
+ index==KErrSenProviderIdInUseByAnotherEndpoint)
+ )
+ {
+ // we need to make it possible to unregister an IDP using
+ // plain provider ID
+ TPtrC8 providerId = aIdp.ProviderID();
+ index = IdentityProviderNamed( providerId, pMatch );
+ }
+
+ // index is either >= 0, OR: if nothing was removed,
+ // return KErrNotFound OR: provider id used by
+ // another endpoint (new error code)
+ if(index>=0 && pMatch)
+ {
+ // remove the match from database list, which allows us to
+ // delete the IdP from memory.
+ iProviderList.Remove(index);
+ TRAP( retVal, AsElement().RemoveElement(pMatch->AsElement()); )
+ delete pMatch;
+ retVal = KErrNone;
+ }
+
+ return retVal; // if nothing was removed, this will return KErrNotFound
+ }
+
+TBool CSenBaseIdentity::AssociateServiceL(const TDesC8& aServiceID,
+ const TDesC8& aProviderID)
+ {
+ TBool ret = EFalse;
+ CSenIdentityProvider* prov = IdentityProviderNamed( aProviderID );
+ if ( prov != NULL )
+ {
+ if ( !prov->IsTrustedByL( aServiceID ))
+ {
+ CSenElement& service =
+ prov->AsElement().AddElementL(KServiceIDElementLocalName);
+
+ service.SetContentL( aServiceID );
+ }
+ ret = ETrue;
+ }
+ return ret;
+ }
+
+TBool CSenBaseIdentity::DissociateServiceL(const TDesC8& aServiceID,
+ const TDesC8& aProviderID)
+ {
+ TBool ret = EFalse;
+ CSenIdentityProvider* prov = IdentityProviderNamed( aProviderID );
+ if ( prov != NULL )
+ {
+ if ( prov->IsTrustedByL( aServiceID ))
+ {
+ RPointerArray<CSenElement> services =
+ prov->AsElement().ElementsL();
+ TInt serviceCount = services.Count();
+ TInt i(0);
+ while (i < serviceCount)
+ {
+ if (services[i]->LocalName() == KServiceIDElementLocalName)
+ {
+ CSenElement* elem = services[i];
+ if ( elem->Content() == aServiceID)
+ {
+ TInt retVal;
+ TRAP(retVal, prov->AsElement().RemoveElement(*elem));
+ if (retVal == KErrNone )
+ {
+ if ( elem )
+ {
+ delete elem;
+ }
+ ret = ETrue;
+ }
+ else
+ {
+ ret = EFalse;
+ }
+ break;
+ }
+ }
+ i++;
+ }
+ }
+ }
+ return ret;
+ }
+
+void CSenBaseIdentity::StartElementL(const TDesC8& aNsUri,
+ const TDesC8& aLocalName,
+ const TDesC8& aQName,
+ const RAttributeArray& aAttributes)
+ {
+ if (aLocalName == KSenIdpLocalname)
+ {
+ // create CSenWiseIdentityProvider
+ iProvider =
+ CSenWiseIdentityProvider::NewL(iIMEI, KNullDesC8, KNullDesC8);
+
+ iProvider->SetOwner(*this);
+ iProvider->SetAttributesL(aAttributes);
+ iProvider->SetReader(*Reader());
+ DelegateParsingL(*iProvider);
+ }
+ else
+ {
+ DelegateParsingL(aNsUri, aLocalName, aQName, aAttributes);
+ }
+ }
+
+
+void CSenBaseIdentity::EndElementL(const TDesC8& aNsUri,
+ const TDesC8& aLocalName,
+ const TDesC8& aQName)
+ {
+ if(aLocalName == KSenIdpLocalname)
+ {
+ if(iProvider)
+ {
+#ifdef __CRYPTO_HW__
+ TBuf8<KEncrypedLen> decPwd;
+ TInt leaveCode(KErrNone);
+ TRAP(leaveCode, DecryptPasswordL(iProvider->Password(), decPwd));
+ if (leaveCode == KErrNone)
+ {
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("Identity ::DecryptPasswordL success")));
+ }
+ else
+ {
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("Identity ::DecryptPasswordL Failed")));
+ }
+ iProvider->SetUserInfoL(iProvider->UserName(),iProvider->UserName(), decPwd);
+
+#endif // __CRYPTO_HW__
+ RegisterIdentityProviderL(iProvider);
+ iProvider=NULL;
+ }
+ }
+ else
+ {
+ CSenBaseFragment::EndElementL(aNsUri,aLocalName,aQName);
+ }
+ }
+
+const TDesC8& CSenBaseIdentity::Type()
+ {
+ return KNullDesC8;
+ }
+
+const TDesC8& CSenBaseIdentity::Name()
+ {
+ return KNullDesC8;
+ }
+
+const TDesC8& CSenBaseIdentity::UserName()
+ {
+ return KNullDesC8;
+ }
+
+
+HBufC8* CSenBaseIdentity::AsXmlL()
+ {
+ return this->AsElement().AsXmlL();
+ }
+
+HBufC* CSenBaseIdentity::AsXmlUnicodeL()
+ {
+ return this->AsElement().AsXmlUnicodeL();
+ }
+
+void CSenBaseIdentity::WriteAsXMLToL(RWriteStream& aWriteStream)
+ {
+#ifdef __CRYPTO_HW__
+ TInt idpCount(iProviderList.Count());
+
+ RArray<RBuf8 *> password;
+ for(TInt i=0; i<idpCount; i++)
+ {
+ CSenIdentityProvider* idp = (CSenIdentityProvider*)iProviderList[i];
+
+ TBuf8<KEncrypedLen> encPwd;
+ TInt leaveCode(KErrNone);
+ //EncryptPasswordL(idp->Password(), encPwd);
+ TRAP(leaveCode, EncryptPasswordL(idp->Password(), encPwd));
+ if (leaveCode == KErrNone)
+ {
+
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("Identity ::EncryptPasswordL success")));
+ }
+ else
+ {
+
+ TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("Identity ::EncryptPasswordL Failed")));
+ }
+ RBuf8 *tempPass = new RBuf8;
+ tempPass->Create(idp->Password());
+ password.Append(tempPass);
+ idp->SetUserInfoL(idp->UserName(),idp->UserName(),encPwd);
+ }
+#endif // __CRYPTO_HW__
+ this->AsElement().WriteAsXMLToL(aWriteStream);
+#ifdef __CRYPTO_HW__
+ for(TInt i=0; i<idpCount; i++)
+ {
+ CSenIdentityProvider* idp = (CSenIdentityProvider*)iProviderList[i];
+ idp->SetUserInfoL(idp->UserName(),idp->UserName(),*password[i]);
+ password[i]->Close();
+ delete password[i];
+ }
+#endif // __CRYPTO_HW__
+ }
+
+EXPORT_C CSenBaseIdentity::~CSenBaseIdentity()
+ {
+ if(iProvider)
+ {
+ CSenElement* removed =
+ CSenBaseIdentity::AsElement().RemoveElement(iProvider->AsElement());
+ // prevend impossible "duplicate delete"
+ if(removed)
+ {
+ delete iProvider; // a leave occured between
+ // StartElementL and EndElementL...
+ }
+ iProvider = NULL; // to prevent accidental duplicate delete
+ }
+
+ TInt idpCount(iProviderList.Count());
+ for(TInt i=idpCount-1; i>=0; i--)
+ {
+ CSenElement* removed =
+ CSenBaseIdentity::AsElement().RemoveElement(
+ ((CSenIdentityProvider*)iProviderList[i])->AsElement());
+ // prevend impossible "duplicate delete"
+ if(removed)
+ {
+ delete iProviderList[i];
+ iProviderList.Remove(i); // 6.11.2004
+ }
+ }
+
+ iProviderList.ResetAndDestroy();
+ }
+
+CSenIdentityProvider* CSenBaseIdentity::IdentityProviderNamed(const TDesC8& aProviderId)
+ {
+ CSenIdentityProvider* pMatch = NULL;
+ IdentityProviderNamed( aProviderId, pMatch );
+ return pMatch;
+ }
+
+TInt CSenBaseIdentity::IdentityProviderNamed( const TDesC8& aProviderID,
+ CSenIdentityProvider*& apMatch)
+ {
+ TInt idpCount(iProviderList.Count());
+ TInt retVal(KErrNotFound); // index, or an error
+ apMatch = NULL;
+ for(TInt i=0; i<idpCount; i++)
+ {
+ TPtrC8 providerId =
+ ((CSenIdentityProvider*)iProviderList[i])->ProviderID();
+ if(providerId.Length()>0 && providerId == aProviderID)
+ {
+ retVal = i; // store the index
+ apMatch = (CSenIdentityProvider*)iProviderList[i]; // found a match
+ break;
+ }
+ }
+ return retVal;
+ }
+
+TInt CSenBaseIdentity::ContainsIdentityProviderL(TBool& aContains,
+ CSenIdentityProvider& aIDP)
+ {
+ aContains = EFalse;
+ TInt idpCount(iProviderList.Count());
+
+ for(TInt i=0; i<idpCount; i++)
+ {
+ if (iProviderList[i]->ConsistsOfL(aIDP)
+ )
+ {
+ aContains = ETrue;
+ break; // No need to loop the rest of the providers, we are
+ // happy with the first hit
+ }
+ }
+ return KErrNone;
+ }
+#ifdef __CRYPTO_HW__
+void CSenBaseIdentity::EncryptPasswordL(const TDesC8& aData, TDes8& aCipherText)
+ {
+#ifndef __WINSCW__
+ TUint cipherLen;
+ TBuf8<KEncrypedLen> temp;
+
+ // add padding if length is less than 16
+ if (aData.Length() < KCryptoPADataLen)
+ {
+ const TInt remainder = aData.Length() % KCryptoPADataLen;
+ temp.Copy(aData);
+ temp.AppendFill( KPadding, KCryptoPADataLen - remainder );
+ cipherLen = temp.Length() + KPaCryptAuthLen ;
+ aCipherText.SetLength(cipherLen);
+ }
+ else
+ {
+ temp.Copy(aData);
+ cipherLen = aData.Length() + KPaCryptAuthLen ;
+ aCipherText.SetLength(cipherLen);
+ }
+
+ TBuf8<20> paId;
+ paId.Copy(KCryptoPA);
+
+ CSecEnv* secEnv = CSecEnv::NewL();
+ TInt err = secEnv->ProtectedApplicationExecute(paId, (TAny*)temp.Ptr(), temp.Length(),
+ (TAny*)aCipherText.Ptr(), cipherLen, KEncryptNoSalt);
+ delete secEnv;
+
+ // Encode data into Base64 format
+ HBufC8 *b64encPwd = SenCryptoUtils::EncodeBase64L(aCipherText);
+ if(b64encPwd)
+ {
+ aCipherText = (*b64encPwd);
+ delete b64encPwd;
+ }
+
+
+#else
+
+aCipherText = aData;
+//return KErrNotSupported;
+#endif
+
+ }
+
+void CSenBaseIdentity::DecryptPasswordL(const TDesC8& aCipherText, TDes8& aData)
+ {
+#ifndef __WINSCW__
+ TUint dataLen = aCipherText.Length() - KPaCryptAuthLen ;
+ aData.SetLength(dataLen);
+ TBuf8<20> paId;
+ paId.Copy(KCryptoPA);
+ // Decode data from Base64 format
+ HBufC8 *b64decPwd = SenCryptoUtils::DecodeBase64L(aCipherText);
+ TDesC8 aTmpTxt= (*b64decPwd);
+ // Decrypt using PA
+ CSecEnv* secEnv = CSecEnv::NewL();
+ TInt err = secEnv->ProtectedApplicationExecute(paId, (TAny*)aTmpTxt.Ptr(), aTmpTxt.Length(),
+ (TAny*)aData.Ptr(), dataLen, KDecrypt);
+ // remove padding
+ if (aData.Length() == KCryptoPADataLen)
+ {
+ RBuf8 decPwd;
+ decPwd.Create(KCryptoPADataLen);
+ decPwd.Copy(aData);
+ TInt pos = decPwd.Locate(KPadding);
+ if(pos != KErrNotFound)
+ {
+ decPwd.SetLength(pos);
+ aData.SetLength(decPwd.Length());
+ aData = decPwd;
+ }
+ decPwd.Close();
+ }
+ delete secEnv;
+ if(b64decPwd)
+ {
+ delete b64decPwd;
+ }
+#else
+
+aData = aCipherText ;
+//return KErrNotSupported;
+#endif
+}
+#endif // __CRYPTO_HW__