diff -r 000000000000 -r 62f9d29f7211 webservices/wsmanager/src/senservicemanagerimpl.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webservices/wsmanager/src/senservicemanagerimpl.cpp	Thu Jan 07 16:19:19 2010 +0200
@@ -0,0 +1,1293 @@
+/*
+* 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 "senservicemanagerimpl.h"
+
+#include <SenIdentityProvider.h>
+#include <SenXmlUtils.h>
+#include <SenServiceConnection.h>  // WSF error codes
+
+#include "senservicemanagerdefines.h" // IPC enumerations
+#include "sendebug.h" // filelogging MACROs
+#include "senlogger.h"
+#include "senguidgen.h"
+#include "senchunk.h"
+#include <SenCredential2.h>
+#include "senxmldebug.h"
+
+namespace
+    {
+    const TInt KMaxChunkNumDecimals = 64;
+    _LIT8(KIdentityProviderName, "IdentityProvider");
+    }
+
+
+CSenServiceManagerImpl* CSenServiceManagerImpl::NewL()
+    {
+    CSenServiceManagerImpl* pNew = NewLC();
+    CleanupStack::Pop();
+    return(pNew) ;
+    }
+
+CSenServiceManagerImpl* CSenServiceManagerImpl::NewLC()
+    {
+    CSenServiceManagerImpl* pNew = new (ELeave) CSenServiceManagerImpl(NULL);
+    CleanupStack::PushL(pNew);
+    pNew->ConstructL();
+    return pNew;
+    }
+
+CSenServiceManagerImpl* CSenServiceManagerImpl::NewL(MSenAuthenticationProvider& aAuthProvider)
+    {
+    CSenServiceManagerImpl* pNew = NewLC(aAuthProvider);
+    CleanupStack::Pop();
+    return(pNew) ;
+    }
+
+CSenServiceManagerImpl* CSenServiceManagerImpl::NewLC(MSenAuthenticationProvider& aAuthProvider)
+    {
+    CSenServiceManagerImpl* pNew = new (ELeave) CSenServiceManagerImpl(&aAuthProvider);
+    CleanupStack::PushL(pNew);
+    pNew->ConstructL();
+    return pNew;
+    }
+
+void CSenServiceManagerImpl::ConstructL()
+    {
+    TInt connAttemp = 0;
+    TInt connErr = KErrGeneral;
+
+    ipGenerator = CSenGuidGen::NewL();
+    ipChunkName = HBufC::NewL(KSenUuidMaxLength+KMaxChunkNumDecimals);
+
+    TLSLOG_OPEN(KSenServiceManagerLogChannel, KSenServiceManagerLogLevel, KSenServiceManagerLogDir, KSenServiceManagerLogFile);
+    connErr = iConnection.Connect();
+
+    while ( (connErr == KErrServerBusy || connErr == KErrServerTerminated) 
+                     & connAttemp < KSenMaxClientConnectionOpeningAttempts )
+        {
+        User::After(1000000); // wait for a second if server has been shut down
+        connErr = iConnection.Connect();
+        connAttemp++;
+        }
+    if ( connErr != KErrNone )
+        {
+        User::Leave( connErr );
+        }
+
+    iConnectionID = iConnection.ConnectionID();
+    iConnection.SetChannel(KSenServiceManagerLogChannelBase+iConnectionID);   
+    //iTlsLogChannel = KSenServiceManagerLogChannelBase + iConnectionID;
+
+
+#ifdef _SENDEBUG
+    RThread thread;
+    RProcess process;
+    TFileName logFile;
+    logFile.Append( KSenServiceManagerLogFile().Left(KSenServiceManagerLogFile().Length()-4) ); // exclude ".log" file extension
+    logFile.AppendNum( iConnectionID );
+    logFile.Append( KSenUnderline );
+    logFile.Append( process.Name().Left(32));
+    logFile.Append( KSenUnderline );
+    logFile.Append( thread.Name().Left(20));
+    logFile.Append( KSenServiceManagerLogFile().Right(4) ); // postfix with ".log" file extension
+
+    // Open connection to the file logger server
+    TLSLOG_OPEN(KSenServiceManagerLogChannelBase+iConnectionID, KSenServiceManagerLogLevel, KSenServiceManagerLogDir, logFile);
+    TLSLOG_L(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,"CSenServiceManager::ConstructL - Log file opened");
+    TLSLOG_FORMAT((KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel , _L8("- Connection ID: (%d)"), iConnectionID));
+    TLSLOG_L(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,"- Service Manager client ready.");
+#endif
+
+    iReader = CSenXmlReader::NewL(KXmlParserMimeType); // use libxml2 sax parser
+    }
+
+CSenServiceManagerImpl::CSenServiceManagerImpl(MSenAuthenticationProvider* apAuthProvider)
+:   iConnection(),//&iLog),
+    iReader(NULL),
+    iInBuffer(NULL,0),
+    iOutBuffer(NULL,0),
+    iInitialized(EFalse),
+    ipGenerator(NULL),
+    ipChunkName(NULL),
+    iChunkNameNumber(0),
+    ipAuthProvider(apAuthProvider),
+    iConnectionID(KErrNotReady) //,
+//    iTlsLogChannel(KSenServiceManagerLogChannelBase)
+    {
+    CActiveScheduler::Add(this);
+    }
+
+CSenServiceManagerImpl::~CSenServiceManagerImpl()
+    {
+    TLSLOG_L(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,"CSenServiceManagerImpl::~CSenServiceManagerImpl");
+    Cancel(); // Causes call to DoCancel()
+    iConnection.Close();
+
+    delete iReader;
+    delete iOutBuf;
+    delete ipGenerator;
+    delete ipChunkName;
+
+    // Close the log file and the connection to the server.
+    TLSLOG(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,(_L("Log file closed.")));
+    TLSLOG_CLOSE (KSenServiceManagerLogChannelBase+iConnectionID);
+    TLSLOG_CLOSE (KSenServiceManagerLogChannel);
+    }
+
+void CSenServiceManagerImpl::RunL()
+    {
+
+    }
+
+void CSenServiceManagerImpl::DoCancel()
+    {
+    TLSLOG(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceManagerImpl::DoCancel")));
+    }
+
+TInt CSenServiceManagerImpl::Identifier()
+    {
+    return iConnectionID;    
+    }
+
+/*
+RFileLogger* CSenServiceManagerImpl::Log() const
+    {
+    return (RFileLogger*) &iLog;
+    }
+*/
+TPtrC CSenServiceManagerImpl::NextChunkNameL()	//Codescannerwarnings
+    {
+    if(ipChunkName)
+        {
+        iChunkNameNumber++;
+        TPtr chunkname = ipChunkName->Des();
+        chunkname.Zero();
+
+        HBufC* pRandomGuid = ipGenerator->GetRandomGuidLC();
+        TPtr idBuffer = pRandomGuid->Des();
+        if(idBuffer.Length()>KSenUuidPrefixLength)
+            {
+            chunkname.Append(idBuffer.Right(idBuffer.Length()-KSenUuidPrefixLength));
+            }
+        CleanupStack::PopAndDestroy(); // pRandomGuid
+        chunkname.AppendNum(iChunkNameNumber);
+
+        // Remove dashes
+         _LIT(KDash, "-");
+        TInt pos = chunkname.Find(KDash);
+        while (pos != KErrNotFound)
+            {
+            chunkname.Replace(pos, KDash().Length(), KNullDesC);
+            pos = chunkname.Find(KDash);
+            }
+        TLSLOG_FORMAT((KSenServiceManagerLogChannelBase+iConnectionID, KNormalLogLevel , _L("CSenServiceManagerImpl::NextChunkNameL(): %S"), &chunkname));
+
+        return chunkname;
+        }
+    else
+        {
+        return KNullDesC();
+        }  
+    }
+
+
+
+// Parameter aUri is contract of the service
+TInt CSenServiceManagerImpl::ServiceDescriptionsL(const TDesC8& aUri, 
+                                                  RServiceDescriptionArray& aList)
+    {
+    TInt retVal(KErrNone);
+    TPtrC8 descriptions;
+
+    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkNameL());	//Codescannerwarnings
+    //pSenChunk->SetLogger(Log());
+    retVal = pSenChunk->CreateChunk();
+    if (retVal == KErrNone)
+        {
+        retVal = pSenChunk->DescToChunk(aUri);
+        if (retVal == KErrNone)
+            {
+            retVal = iConnection.ServiceDescriptionsByUriL(*pSenChunk);
+            if (retVal == KErrNone)
+                {
+                retVal = pSenChunk->DescFromChunk(descriptions);
+                if(retVal == KErrNone)
+                    {
+                    retVal = ExtractServiceDescriptionsL(descriptions, aList);
+                    }
+                }
+            }
+        }
+    CleanupStack::PopAndDestroy(pSenChunk); // Close chunk
+    return retVal;
+    }
+
+TInt CSenServiceManagerImpl::ServiceDescriptionsL(MSenServiceDescription& aSD,
+                                                  RServiceDescriptionArray& aList)
+    {
+    TInt retVal(KErrNone);
+    
+    HBufC8* pPattern = aSD.AsXmlL();
+    CleanupStack::PushL(pPattern);
+    
+    TPtrC8 descriptions;
+
+    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkNameL());	//Codescannerwarnings
+    //pSenChunk->SetLogger(Log());
+    retVal = pSenChunk->CreateChunk();
+    if (retVal == KErrNone)
+        {
+        retVal = pSenChunk->DescToChunk(*pPattern);
+        if (retVal == KErrNone)
+            {
+            retVal = iConnection.ServiceDescriptionsByPatternL(*pSenChunk);
+            if(retVal == KErrNone)
+                {
+                retVal = pSenChunk->DescFromChunk(descriptions);
+                if(retVal == KErrNone)
+                    {
+                    retVal = ExtractServiceDescriptionsL(descriptions, aList);
+                    }
+                }
+            }
+        }
+    CleanupStack::PopAndDestroy(pSenChunk); // Close chunk
+
+    // In any case, destroy the pattern as XML buffer:
+    CleanupStack::PopAndDestroy(); // pPattern
+
+    return retVal;
+    }
+
+TInt CSenServiceManagerImpl::RegisterServiceDescriptionL(MSenServiceDescription& aSD)
+    {
+    // do not register if both endpoint and contract are 
+    // missing
+    if(aSD.Endpoint().Length()==0 && aSD.Contract().Length()==0)
+        {
+        return KErrSenNoContractNoEndPoint;
+        }
+    
+    else 
+        {
+        _LIT8(KProviderID,"ProviderID");
+        HBufC8* pAsXml = NULL;
+        if ( aSD.DescriptionClassType() ==
+                MSenServiceDescription::EIdentityProvider )
+            {
+            TLSLOG(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,(_L("RegisterServiceDescriptionL with EIdentityProvider ")));
+        
+            CSenIdentityProvider* pIdP = (CSenIdentityProvider*)&aSD;
+        
+            CSenXmlServiceDescription* pSD = CSenXmlServiceDescription::NewLC(
+                    pIdP->Endpoint(),
+                    pIdP->Contract()  );
+        
+            pSD->SetFrameworkIdL( pIdP->FrameworkId() );
+            pSD->AsElement().AddElementL(KProviderID).SetContentL(
+                                                            pIdP->ProviderID() );	//CodeScannerWarnings
+        
+            pAsXml = pSD->AsXmlL(); // leaves if no memory available
+            CleanupStack::PopAndDestroy(); // pSD
+            }
+        else    // ServiceDescription
+            {
+            pAsXml = aSD.AsXmlL(); // leaves if no memory available
+            }
+        
+        CleanupStack::PushL(pAsXml); // must be the first line after if-clause
+        TPtr8 ptr = pAsXml->Des();
+        // now register the XML string (descriptor) to WSF Symbian server:
+        TInt retVal(iConnection.RegisterServiceDescription(ptr));
+        CleanupStack::PopAndDestroy(); // pAsXml
+        
+        return retVal;
+        }
+    }
+
+TInt CSenServiceManagerImpl::UnregisterServiceDescriptionL(
+                                                MSenServiceDescription& aSD)
+    {
+    // do not unregister if both endpoint and contract are 
+    // missing
+    if(aSD.Endpoint().Length()==0 && aSD.Contract().Length()==0)
+        {
+        return KErrSenNoContractNoEndPoint;
+        }
+    else 
+        {
+        HBufC8* pAsXml = NULL;
+        if ( aSD.DescriptionClassType() ==
+            MSenServiceDescription::EIdentityProvider )
+            {
+            TLSLOG(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,(_L("UnregisterServiceDescriptionL with EIdentityProvider ")));
+            
+            CSenIdentityProvider* pIdP = (CSenIdentityProvider*)&aSD;
+            
+            CSenXmlServiceDescription* pSD = 
+                CSenXmlServiceDescription::NewLC(pIdP->Endpoint(),
+                                                 pIdP->Contract());
+            
+            pSD->SetFrameworkIdL( pIdP->FrameworkId() );
+            if(pIdP->ProviderID().Length()>0)
+                {
+		        _LIT8(KProviderID,"ProviderID");
+                CSenElement& providerIdElement = 
+                    pSD->AsElement().AddElementL(KProviderID);	//CodeScannerWarnings
+                providerIdElement.SetContentL(pIdP->ProviderID());
+                }
+            pAsXml = pSD->AsXmlL(); // leaves if no memory available
+            CleanupStack::PopAndDestroy(); // pSD
+            }
+        else    // ServiceDescription
+            {
+            pAsXml = aSD.AsXmlL(); // leaves if no memory available
+            }
+        
+        CleanupStack::PushL(pAsXml); // must be the first line after if-clause
+        TPtr8 ptr = pAsXml->Des();
+        TInt retVal(iConnection.UnregisterServiceDescription(ptr));
+        CleanupStack::PopAndDestroy(); // pAsXml
+        return retVal;
+        }
+    }
+// comment: remote developer interface to identity manager
+TInt CSenServiceManagerImpl::RegisterIdentityProviderL(
+                                            CSenIdentityProvider& aProvider)
+    {
+    HBufC8* provider = aProvider.AsXmlL();
+    TPtr8 ptr = provider->Des();
+    TInt retVal = iConnection.RegisterIdentityProvider(ptr);
+    delete provider;
+    return retVal;
+    }
+
+TInt CSenServiceManagerImpl::UnregisterIdentityProviderL(
+                                            CSenIdentityProvider& aProvider)
+    {
+    HBufC8* provider = aProvider.AsXmlL();
+    TPtr8 ptr = provider->Des();
+    TInt retVal(iConnection.UnregisterIdentityProvider(ptr));
+    delete provider;
+    return retVal;
+    }
+
+TInt CSenServiceManagerImpl::AssociateServiceL(const TDesC8& aServiceID,
+                                               const TDesC8& aProviderID)
+    {
+    if (aServiceID.Length() <= 0 || aProviderID.Length() <= 0)
+        {
+        return KErrArgument;
+        }
+    TInt retVal( iConnection.AssociateService(  (TDesC8&)aServiceID,
+                                                (TDesC8&)aProviderID) );
+    return retVal;
+    }
+
+
+TInt CSenServiceManagerImpl::DissociateServiceL(const TDesC8& aServiceID,
+                                                const TDesC8& aProviderID)
+    {
+    if (aServiceID.Length() <= 0 || aProviderID.Length() <= 0)
+        {
+        return KErrArgument;
+        }
+    TInt retVal( iConnection.DissociateService( (TDesC8&)aServiceID,
+                                                (TDesC8&)aProviderID) );
+    return retVal;
+    }
+
+TInt CSenServiceManagerImpl::InstallFrameworkL(const TDesC8& aFrameworkId)
+    {
+    TLSLOG(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceManager::InstallFrameworkL")));
+    TLSLOG(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,(aFrameworkId));
+    if (aFrameworkId.Length() <= 0)
+        {
+        return KErrArgument;
+        }
+    TInt retVal( iConnection.InstallFramework((TDesC8&)aFrameworkId) );
+
+    return retVal;
+    }
+
+TInt CSenServiceManagerImpl::ExtractServiceDescriptionsL(TPtrC8& aSDs, 
+                                                          RServiceDescriptionArray& aList)
+    {
+    TLSLOG_L(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,"CSenServiceManagerImpl::ExtractServiceDescriptionsL");
+    TInt retVal(KErrNotFound);
+
+    
+    if (aSDs.Length() > 0)
+        {
+        TPtrC8 single;
+        TPtrC8 rest;
+        _LIT8(KTab, "\t");
+        TBool loop(ETrue);
+        TInt pos(-1);
+        CSenXmlServiceDescription* desc = NULL;
+        rest.Set(aSDs);
+
+        while (loop)
+            {
+            pos = rest.Find(KTab());
+            if (pos > 0)
+                {
+                desc = CSenXmlServiceDescription::NewLC();
+                iReader->SetContentHandler(*desc);
+                desc->SetReader(*iReader);
+                single.Set(rest.Left(pos));
+
+                TInt leaveCode(KErrNone);
+                TRAP(leaveCode, desc->ParseL(single));
+                if(leaveCode!=KErrNone)
+                    {
+                    TInt count(aList.Count());
+                    TLSLOG_FORMAT((KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel , _L8("-desc->ParseL(#%d): parsing failed: %d"), count+1, leaveCode));
+                        
+                    CleanupStack::PopAndDestroy(); // desc
+                    if(count == 0)
+                        {
+                        retVal = KErrNotFound; // could not parse single service description
+                        }
+
+                    break;
+                    }
+
+                rest.Set(rest.Mid(pos+1));  // Check
+                retVal = aList.Append(desc);
+                if(retVal == KErrNone)
+                    {
+                    CleanupStack::Pop(); // desc
+                    }
+                else
+                    {
+                    CleanupStack::PopAndDestroy();
+                    }
+                desc = NULL;
+                }
+            else
+                {
+                desc = CSenXmlServiceDescription::NewLC();
+                iReader->SetContentHandler(*desc);
+                desc->SetReader(*iReader);
+
+                TInt leaveCode(KErrNone);
+                TRAP(leaveCode, desc->ParseL(rest));
+                if(leaveCode!=KErrNone)
+                    {
+                    TInt count(aList.Count());
+                    TLSLOG_FORMAT((KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel , _L8("-desc->ParseL(#%d): parsing failed: %d"), count+1, leaveCode));
+                        
+                    CleanupStack::PopAndDestroy(); // desc
+                    if(count == 0)
+                        {
+                        retVal = KErrNotFound; // could not parse single service description
+                        }
+
+                    break;
+                    }
+                retVal = aList.Append(desc);
+                if(retVal == KErrNone)
+                    {
+                    CleanupStack::Pop(); // desc
+                    }
+                else
+                    {
+                    CleanupStack::PopAndDestroy();
+                    }
+                desc = NULL;
+                break;
+                }
+
+            if (rest.Length() == 0 )
+                {
+                break;
+                }
+
+            }
+        } //  END OF: if aSD.Length() > 0
+    return retVal;
+    }
+
+TInt CSenServiceManagerImpl::ExtractCredentialsL(TPtrC8& aCredentials, 
+                                                 RCredentialArray& aList,
+                                                 RCredentialPropertiesArray& aCredentialPropertiesList)
+    {
+    TLSLOG_L(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,"CSenServiceManagerImpl::ExtractCredentialsL");
+    TInt retVal(KErrNotFound);
+    
+    if ( aCredentials.Length() > 0 )
+        {
+        TPtrC8 single;
+        TPtrC8 rest;
+        _LIT8(KTab, "\t");
+        _LIT8(KNewline, "\n");
+        _LIT8(KNoProperties, "-");
+
+        TInt pos(KErrNone);
+        CSenCredential2* pCredential = NULL;
+        rest.Set(aCredentials);
+        CSenParser* pParser = CSenParser::NewLC();
+
+        while ( pos != KErrNotFound && rest.Length() > 0 )
+            {
+            pos = rest.Find(KTab());
+            if (pos > 0)
+                {
+                single.Set(rest.Left(pos));
+                }
+            else
+                {
+                single.Set(rest);
+                }
+
+            if ( single.Length() > 0 )
+                {
+                pCredential = CSenCredential2::NewLC();
+
+                TInt leaveCode(KErrNone);
+                TRAP(leaveCode, pParser->ParseL(single, *pCredential));
+                if ( leaveCode != KErrNone )
+                    {
+                    TInt count(aList.Count());
+                    TLSLOG_FORMAT((KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel , _L8("- Credential(#%d): parsing failed: %d"), count+1, leaveCode));
+                       
+                    CleanupStack::PopAndDestroy(); // desc
+                    if ( count == 0 )
+                        {
+                        retVal = KErrNotFound; // could not parse single credential
+                        }
+
+                    break;
+                    }
+
+                retVal = aList.Append(pCredential);
+                if(retVal == KErrNone)
+                    {
+                    CleanupStack::Pop(); // desc
+                    }
+                else
+                    {
+                    CleanupStack::PopAndDestroy();
+                    }
+
+                rest.Set(rest.Mid(pos+1));  // Check
+
+                pos = rest.Find(KNewline());
+                if (pos > 0)
+                    {
+                    single.Set(rest.Left(pos));
+                    }
+                else
+                    {
+                    single.Set(rest);
+                    }
+                    
+                if ( single == KNoProperties )
+                    {
+                    aCredentialPropertiesList.Append(NULL);
+                    }
+                else
+                    {
+                    if ( single.Length() > 0 )
+                        {
+                        CSenXmlProperties* pCredentialProperties = CSenXmlProperties::NewLC();
+                        pCredentialProperties->SetReader(*iReader);
+                        leaveCode = KErrNone;
+                        TRAP(leaveCode, pCredentialProperties->ReadFromL(single));
+                        if ( leaveCode != KErrNone )
+                            {
+                            TInt count(aList.Count());
+                            TLSLOG_FORMAT((KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel , _L8("- CredentialProperties(#%d): parsing failed: %d"), count+1, leaveCode));
+                                
+                            CleanupStack::PopAndDestroy(pCredentialProperties);
+                            if ( count == 0 )
+                                {
+                                retVal = KErrNotFound; // could not parse single credential
+                                }
+                                
+                            retVal = aCredentialPropertiesList.Append(NULL);
+                            break;
+                            }
+                        
+                        retVal = aCredentialPropertiesList.Append(pCredentialProperties);
+                        if(retVal == KErrNone)
+                            {
+                            CleanupStack::Pop(pCredentialProperties);
+                            }
+                        else
+                            {
+                            CleanupStack::PopAndDestroy(pCredentialProperties);
+                            }
+                        }
+                    else
+                        {
+                        aCredentialPropertiesList.Append(NULL);
+                        }
+                    }
+                    
+                rest.Set(rest.Mid(pos+1));  // Check
+
+                pCredential = NULL;
+                }
+            else
+                {
+                pos = KErrNotFound;
+                }
+            }
+
+        CleanupStack::PopAndDestroy(pParser);
+        } //  END OF: if aCredentials.Length() > 0
+    return retVal;
+    }
+
+TInt CSenServiceManagerImpl::CredentialsL(const TDesC8& aEndpoint,
+                                          RCredentialArray& aCredentials,
+                                          RCredentialPropertiesArray& aCredentialProperties)
+    {
+    TInt retVal(KErrNone);
+    
+    CSenXmlServiceDescription* pServDesc = CSenXmlServiceDescription::NewLC();
+    pServDesc->SetEndPointL(aEndpoint);
+    
+    retVal = CredentialsL(*pServDesc, aCredentials, aCredentialProperties);
+    
+    CleanupStack::PopAndDestroy(pServDesc);
+    
+    return retVal;
+    }
+
+TInt CSenServiceManagerImpl::CredentialsL(const TDesC8& aEndpoint,
+                                          const CSenIdentityProvider& aIdP,
+                                          RCredentialArray& aCredentials,
+                                          RCredentialPropertiesArray& aCredentialProperties)
+    {
+    TInt retVal(KErrNone);
+    TPtrC8 credentials;
+    
+    CSenXmlServiceDescription* pServDesc = CSenXmlServiceDescription::NewLC();
+    pServDesc->SetEndPointL(aEndpoint);
+    HBufC8* pPatternAsXml = pServDesc->AsXmlL();
+    CleanupStack::PopAndDestroy(pServDesc);
+    CleanupStack::PushL(pPatternAsXml);
+    if( &aIdP == NULL )
+    {
+      return KErrArgument;  
+    }
+
+    HBufC8* pIdPAsXml = ((CSenIdentityProvider&)aIdP).AsXmlL();
+    CleanupStack::PushL(pIdPAsXml);
+
+    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkNameL());	//Codescannerwarnings
+    //pSenChunk->SetLogger(Log());
+    retVal = pSenChunk->CreateChunk();
+    if (retVal == KErrNone)
+        {
+        retVal = pSenChunk->DescsToChunk(*pPatternAsXml, *pIdPAsXml);
+        if (retVal == KErrNone)
+            {
+            retVal = iConnection.CredentialsL(*pSenChunk);
+            if (retVal == KErrNone)
+                {
+                retVal = pSenChunk->DescFromChunk(credentials);
+                if(retVal == KErrNone)
+                    {
+                    retVal = ExtractCredentialsL(credentials, aCredentials, aCredentialProperties);
+                    }
+                }
+            }
+        }
+    CleanupStack::PopAndDestroy(pSenChunk);
+    
+    CleanupStack::PopAndDestroy(pIdPAsXml);
+    CleanupStack::PopAndDestroy(pPatternAsXml);
+    
+    return retVal;    
+    }
+
+TInt CSenServiceManagerImpl::CredentialsL(const TDesC8& aEndpoint,
+                                          const TDesC8& aUserName,
+                                          const TDesC8& aPassword,
+                                          RCredentialArray& aCredentials,
+                                          RCredentialPropertiesArray& aCredentialProperties)
+    {
+    TInt retVal(KErrNone);
+    TPtrC8 credentials;
+    
+    CSenXmlServiceDescription* pServDesc = CSenXmlServiceDescription::NewLC();
+    pServDesc->SetEndPointL(aEndpoint);
+    HBufC8* pPatternAsXml = pServDesc->AsXmlL();
+    CleanupStack::PopAndDestroy(pServDesc);
+    CleanupStack::PushL(pPatternAsXml);
+
+    CSenIdentityProvider* pIdP = CSenIdentityProvider::NewLC(KIdentityProviderName);
+    pIdP->SetUserInfoL(aUserName, aUserName, aPassword);
+    HBufC8* pIdPAsXml = pIdP->AsXmlL();
+    CleanupStack::PopAndDestroy(pIdP);
+    CleanupStack::PushL(pIdPAsXml);
+
+    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkNameL());	//Codescannerwarnings
+    //pSenChunk->SetLogger(Log());
+    retVal = pSenChunk->CreateChunk();
+    if (retVal == KErrNone)
+        {
+        retVal = pSenChunk->DescsToChunk(*pPatternAsXml, *pIdPAsXml);
+        if (retVal == KErrNone)
+            {
+            retVal = iConnection.CredentialsL(*pSenChunk);
+            if (retVal == KErrNone)
+                {
+                retVal = pSenChunk->DescFromChunk(credentials);
+                if(retVal == KErrNone)
+                    {
+                    retVal = ExtractCredentialsL(credentials, aCredentials, aCredentialProperties);
+                    }
+                }
+            }
+        }
+    CleanupStack::PopAndDestroy(pSenChunk);
+    
+    CleanupStack::PopAndDestroy(pIdPAsXml);
+    CleanupStack::PopAndDestroy(pPatternAsXml);
+    
+    return retVal;    
+    }
+
+TInt CSenServiceManagerImpl::CredentialsL(const MSenServiceDescription& aPattern,
+                                          RCredentialArray& aCredentials,
+                                          RCredentialPropertiesArray& aCredentialProperties)
+    {
+    TInt retVal(KErrNone);
+    TPtrC8 credentials;
+    
+    if(&aPattern == NULL)
+    {
+      return KErrArgument;  
+    }
+    HBufC8* pPatternAsXml = ((MSenServiceDescription&)aPattern).AsXmlL();
+    CleanupStack::PushL(pPatternAsXml);
+
+    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkNameL());	//Codescannerwarnings
+    //pSenChunk->SetLogger(Log());
+    retVal = pSenChunk->CreateChunk();
+    if (retVal == KErrNone)
+        {
+        retVal = pSenChunk->DescsToChunk(*pPatternAsXml, KNullDesC8);
+        if (retVal == KErrNone)
+            {
+            retVal = iConnection.CredentialsL(*pSenChunk);
+            if (retVal == KErrNone)
+                {
+                retVal = pSenChunk->DescFromChunk(credentials);
+                if(retVal == KErrNone)
+                    {
+                    retVal = ExtractCredentialsL(credentials, aCredentials, aCredentialProperties);
+                    }
+                }
+            else if ( retVal == KErrSenNoPermission )
+                {
+                if ( ipAuthProvider )
+                    {
+                    TBool identityProviderCreated = EFalse;
+                    CSenIdentityProvider* pIdP = NULL;
+                    pIdP = (CSenIdentityProvider*)ipAuthProvider->IdentityProviderL();
+                    if ( !pIdP )
+                        {
+                        const TPtrC8 userName = ipAuthProvider->UsernameL();
+                        const TPtrC8 password = ipAuthProvider->PasswordL();
+                        if ( userName != KNullDesC8 &&
+                        	 password != KNullDesC8 )
+                            {
+                            pIdP = CSenIdentityProvider::NewLC(KIdentityProviderName);
+                            pIdP->SetUserInfoL( userName ,
+                            					userName ,
+                            					password );
+                            identityProviderCreated = ETrue;
+                            }
+                        }
+                    
+                    if ( pIdP )
+                        {
+                        HBufC8* pIdPAsXml = pIdP->AsXmlL();
+                        CleanupStack::PushL(pIdPAsXml);
+
+                        retVal = pSenChunk->DescsToChunk(*pPatternAsXml, *pIdPAsXml);
+                        if (retVal == KErrNone)
+                            {
+                            retVal = iConnection.CredentialsL(*pSenChunk);
+                            if (retVal == KErrNone)
+                                {
+                                retVal = pSenChunk->DescFromChunk(credentials);
+                                if(retVal == KErrNone)
+                                    {
+                                    retVal = ExtractCredentialsL(credentials, aCredentials, aCredentialProperties);
+                                    }
+                                }
+                            }
+                        CleanupStack::PopAndDestroy(pIdPAsXml);
+                        if ( identityProviderCreated )
+                            {
+                            CleanupStack::PopAndDestroy(pIdP);
+                            }
+                        //CleanupStack::PopAndDestroy(pIdPAsXml);
+                        }
+                    }
+                }
+            }
+        }
+    CleanupStack::PopAndDestroy(pSenChunk);
+    
+    CleanupStack::PopAndDestroy(pPatternAsXml);
+    
+    return retVal;
+    }
+
+TInt CSenServiceManagerImpl::CredentialsL(const MSenServiceDescription& aPattern,
+                                          const CSenIdentityProvider& aIdP,
+                                          RCredentialArray& aCredentials,
+                                          RCredentialPropertiesArray& aCredentialProperties)
+    {
+    TInt retVal(KErrNone);
+    TPtrC8 credentials;
+    
+    if(&aPattern == NULL || &aIdP == NULL)
+    {
+     return KErrArgument;
+    }
+    HBufC8* pPatternAsXml = ((MSenServiceDescription&)aPattern).AsXmlL();
+    CleanupStack::PushL(pPatternAsXml);
+
+    HBufC8* pIdPAsXml = ((CSenIdentityProvider&)aIdP).AsXmlL();
+    CleanupStack::PushL(pIdPAsXml);
+
+    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkNameL());	//Codescannerwarnings
+    //pSenChunk->SetLogger(Log());
+    retVal = pSenChunk->CreateChunk();
+    if (retVal == KErrNone)
+        {
+        retVal = pSenChunk->DescsToChunk(*pPatternAsXml, *pIdPAsXml);
+        if (retVal == KErrNone)
+            {
+            retVal = iConnection.CredentialsL(*pSenChunk);
+            if (retVal == KErrNone)
+                {
+                retVal = pSenChunk->DescFromChunk(credentials);
+                if(retVal == KErrNone)
+                    {
+                    retVal = ExtractCredentialsL(credentials, aCredentials, aCredentialProperties);
+                    }
+                }
+            }
+        }
+    CleanupStack::PopAndDestroy(pSenChunk);
+    
+    CleanupStack::PopAndDestroy(pIdPAsXml);
+    CleanupStack::PopAndDestroy(pPatternAsXml);
+    
+    return retVal;
+    }
+                                  
+TInt CSenServiceManagerImpl::CredentialsL(const MSenServiceDescription& aPattern,
+                                          const TDesC8& aUserName,
+                                          const TDesC8& aPassword,
+                                          RCredentialArray& aCredentials,
+                                          RCredentialPropertiesArray& aCredentialProperties)
+    {
+    TInt retVal(KErrNone);
+    TPtrC8 credentials;
+
+    if(&aPattern == NULL) 
+    {
+     return KErrArgument;   
+    }
+    HBufC8* pPatternAsXml = ((MSenServiceDescription&)aPattern).AsXmlL();
+    CleanupStack::PushL(pPatternAsXml);
+
+    CSenIdentityProvider* pIdP = CSenIdentityProvider::NewLC(KIdentityProviderName);
+    pIdP->SetUserInfoL(aUserName, aUserName, aPassword);
+    HBufC8* pIdPAsXml = pIdP->AsXmlL();
+    CleanupStack::PopAndDestroy(pIdP);
+    CleanupStack::PushL(pIdPAsXml);
+
+    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkNameL());	//Codescannerwarnings
+    //pSenChunk->SetLogger(Log());
+    retVal = pSenChunk->CreateChunk();
+    if (retVal == KErrNone)
+        {
+        retVal = pSenChunk->DescsToChunk(*pPatternAsXml, *pIdPAsXml);
+        if (retVal == KErrNone)
+            {
+            retVal = iConnection.CredentialsL(*pSenChunk);
+            if (retVal == KErrNone)
+                {
+                retVal = pSenChunk->DescFromChunk(credentials);
+                if(retVal == KErrNone)
+                    {
+                    retVal = ExtractCredentialsL(credentials, aCredentials, aCredentialProperties);
+                    }
+                }
+            }
+        }
+    CleanupStack::PopAndDestroy(pSenChunk);
+    
+    CleanupStack::PopAndDestroy(pIdPAsXml);
+    CleanupStack::PopAndDestroy(pPatternAsXml);
+    
+    return retVal;
+    }
+
+TInt CSenServiceManagerImpl::AddCredentialL(const MSenServiceDescription& aPattern,
+                                            const CSenIdentityProvider& aIdP,
+                                            const CSenCredential2& aCredential)
+    {
+    TInt retVal(KErrNone);
+    
+    if(&aPattern == NULL || &aIdP == NULL || &aCredential== NULL)
+    {
+      return KErrArgument;  
+    }
+    HBufC8* pPatternAsXml = ((MSenServiceDescription&)aPattern).AsXmlL();
+    CleanupStack::PushL(pPatternAsXml);
+
+    HBufC8* pIdPAsXml = ((CSenIdentityProvider&)aIdP).AsXmlL();
+    CleanupStack::PushL(pIdPAsXml);
+
+    HBufC8* pCredentialAsXml = ((CSenCredential2&)aCredential).AsXmlL();
+    CleanupStack::PushL(pCredentialAsXml);
+    
+    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkNameL());	//Codescannerwarnings
+    //pSenChunk->SetLogger(Log());
+    retVal = pSenChunk->CreateChunk();
+    
+    if (retVal == KErrNone)
+        {
+        retVal = pSenChunk->DescsToChunk(*pPatternAsXml, *pIdPAsXml);
+        retVal = pSenChunk->DescToChunk(*pCredentialAsXml,  2);
+        if (retVal == KErrNone)
+            {
+            retVal = iConnection.AddCredentialL(*pSenChunk);
+            }
+        }
+    CleanupStack::PopAndDestroy(pSenChunk);
+
+    CleanupStack::PopAndDestroy(pCredentialAsXml);
+    CleanupStack::PopAndDestroy(pIdPAsXml);
+    CleanupStack::PopAndDestroy(pPatternAsXml);
+
+    return retVal;
+    }
+
+TInt CSenServiceManagerImpl::AddCredentialL(const TDesC8& aEndpoint,
+                                            const CSenIdentityProvider& aIdP,
+                                            const CSenCredential2& aCredential)
+    {
+    CSenXmlServiceDescription* pServDesc = CSenXmlServiceDescription::NewLC();
+    pServDesc->SetEndPointL(aEndpoint);
+    
+    TInt retVal = AddCredentialL(*pServDesc, aIdP, aCredential);
+    
+    CleanupStack::PopAndDestroy(pServDesc);
+
+    return retVal;   
+    }
+
+TInt CSenServiceManagerImpl::AddCredentialL(const MSenServiceDescription& aPattern,
+                                            const CSenIdentityProvider& aIdP,
+                                            const CSenCredential2& aCredential,
+                                            const CSenXmlProperties& aCredentialProperties)
+    {
+    TInt retVal(KErrNone);
+    
+    if(&aPattern == NULL || &aIdP == NULL || &aCredential== NULL || &aCredentialProperties == NULL )
+    {
+      return KErrArgument;  
+    }
+    HBufC8* pPatternAsXml = ((MSenServiceDescription&)aPattern).AsXmlL();
+    CleanupStack::PushL(pPatternAsXml);
+
+    HBufC8* pIdPAsXml = ((CSenIdentityProvider&)aIdP).AsXmlL();
+    CleanupStack::PushL(pIdPAsXml);
+
+    HBufC8* pCredentialAsXml = ((CSenCredential2&)aCredential).AsXmlL();
+    CleanupStack::PushL(pCredentialAsXml);
+
+    HBufC8* pCredentialPropertiesAsXml = ((CSenXmlProperties&)aCredentialProperties).AsUtf8L();
+    CleanupStack::PushL(pCredentialPropertiesAsXml);
+    
+    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkNameL());	//Codescannerwarnings
+    //pSenChunk->SetLogger(Log());
+    retVal = pSenChunk->CreateChunk();
+    
+    if (retVal == KErrNone)
+        {
+        retVal = pSenChunk->DescsToChunk(*pPatternAsXml, *pIdPAsXml);
+        retVal = pSenChunk->DescToChunk(*pCredentialAsXml,  2);
+        retVal = pSenChunk->DescToChunk(*pCredentialPropertiesAsXml,  3);
+        if (retVal == KErrNone)
+            {
+            retVal = iConnection.AddCredentialL(*pSenChunk);
+            }
+        }
+    CleanupStack::PopAndDestroy(pSenChunk);
+
+
+    CleanupStack::PopAndDestroy(pCredentialPropertiesAsXml);
+    CleanupStack::PopAndDestroy(pCredentialAsXml);
+    CleanupStack::PopAndDestroy(pIdPAsXml);
+    CleanupStack::PopAndDestroy(pPatternAsXml);
+
+    return retVal;
+    }
+
+TInt CSenServiceManagerImpl::AddCredentialL(const TDesC8& aEndpoint,
+                                            const CSenIdentityProvider& aIdP,
+                                            const CSenCredential2& aCredential,
+                                            const CSenXmlProperties& aCredentialProperties)
+    {
+    CSenXmlServiceDescription* pServDesc = CSenXmlServiceDescription::NewLC();
+    pServDesc->SetEndPointL(aEndpoint);
+    
+    TInt retVal = AddCredentialL(*pServDesc, aIdP, aCredential, aCredentialProperties);
+    
+    CleanupStack::PopAndDestroy(pServDesc);
+
+    return retVal;   
+    }
+
+TInt CSenServiceManagerImpl::RemoveCredentialsL(const CSenIdentityProvider& aIdP)
+    {
+    TInt retVal(KErrNone);
+        
+    if(&aIdP == NULL)
+        {
+        return  KErrArgument; 
+        }
+    
+    HBufC8* pIdPAsXml = ((CSenIdentityProvider&)aIdP).AsXmlL();
+    CleanupStack::PushL(pIdPAsXml);
+
+    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkNameL());  //Codescannerwarnings
+    retVal = pSenChunk->CreateChunk();
+    
+    if (retVal == KErrNone)
+        {
+        retVal = pSenChunk->DescsToChunk(KNullDesC8(), *pIdPAsXml);
+        if (retVal == KErrNone)
+            {
+            retVal = iConnection.RemoveCredentialsL(*pSenChunk);
+            }
+        }
+    CleanupStack::PopAndDestroy(pSenChunk);
+
+    CleanupStack::PopAndDestroy(pIdPAsXml);
+    
+    return retVal;
+
+    }
+TInt CSenServiceManagerImpl::RemoveCredentialsL(const MSenServiceDescription& aPattern,
+                                                const CSenIdentityProvider& aIdP)
+    {
+    TInt retVal(KErrNone);
+    
+    if(&aPattern == NULL || &aIdP == NULL)
+    {
+      return  KErrArgument; 
+    }
+    HBufC8* pPatternAsXml = ((MSenServiceDescription&)aPattern).AsXmlL();
+    CleanupStack::PushL(pPatternAsXml);
+
+    HBufC8* pIdPAsXml = ((CSenIdentityProvider&)aIdP).AsXmlL();
+    CleanupStack::PushL(pIdPAsXml);
+
+    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkNameL());	//Codescannerwarnings
+    //pSenChunk->SetLogger(Log());
+    retVal = pSenChunk->CreateChunk();
+    
+    if (retVal == KErrNone)
+        {
+        retVal = pSenChunk->DescsToChunk(*pPatternAsXml, *pIdPAsXml);
+        if (retVal == KErrNone)
+            {
+            retVal = iConnection.RemoveCredentialsL(*pSenChunk);
+            }
+        }
+    CleanupStack::PopAndDestroy(pSenChunk);
+
+    CleanupStack::PopAndDestroy(pIdPAsXml);
+    CleanupStack::PopAndDestroy(pPatternAsXml);
+
+    return retVal;
+    }
+
+TInt CSenServiceManagerImpl::RemoveCredentialsL(const MSenServiceDescription& aPattern,
+                                                const TDesC8& aUserName,
+                                                const TDesC8& aPassword)
+    {
+    CSenIdentityProvider* pIdP = CSenIdentityProvider::NewLC(KIdentityProviderName);
+    pIdP->SetUserInfoL(aUserName, aUserName, aPassword);
+    
+    TInt retVal = RemoveCredentialsL(aPattern, *pIdP);
+    
+    CleanupStack::PopAndDestroy(pIdP);
+
+    return retVal;
+    }
+
+
+TInt CSenServiceManagerImpl::IdentityProvidersL( RIdentityProviderArray& aList )
+    {
+    TInt retVal(KErrNone);
+    TPtrC8 descriptions;
+
+    CSenChunk* pSenChunk = CSenChunk::NewLC(NextChunkNameL());
+    retVal = pSenChunk->CreateChunk();
+    if (retVal == KErrNone)
+        {
+        retVal = iConnection.IdentityProvidersL(*pSenChunk);
+        if (retVal == KErrNone)
+            {
+            retVal = pSenChunk->DescFromChunk(descriptions);
+            if(retVal == KErrNone)
+                {
+                retVal = ExtractIdentiyProvidersL(descriptions, aList);
+                }
+            }
+        }
+    CleanupStack::PopAndDestroy(pSenChunk); // Close chunk
+    return retVal;
+    }
+TInt CSenServiceManagerImpl::ExtractIdentiyProvidersL(TPtrC8& aIdPs, 
+                                                      RIdentityProviderArray& aList)
+    {
+    TLSLOG_L(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel,"CSenServiceManagerImpl::ExtractIdentiyProvidersL");
+    TInt retVal(KErrNotFound);
+
+    
+    if (aIdPs.Length() > 0)
+        {
+        TPtrC8 single;
+        TPtrC8 rest;
+        _LIT8(KTab, "\t");
+        TBool loop(ETrue);
+        TInt pos(-1);
+        CSenIdentityProvider* idp = NULL;
+        rest.Set(aIdPs);
+
+        while (loop)
+            {
+            pos = rest.Find(KTab());
+            if (pos > 0)
+                {
+                idp = CSenIdentityProvider::NewLC(KNullDesC8);
+                iReader->SetContentHandler(*idp);
+                idp->SetReader(*iReader);
+                single.Set(rest.Left(pos));
+
+                TInt leaveCode(KErrNone);
+                TLSLOG_ALL(KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel, single);
+                TRAP(leaveCode, idp->ParseL(single));
+                if(leaveCode!=KErrNone)
+                    {
+                    TInt count(aList.Count());
+                    TLSLOG_FORMAT((KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel , _L8("-idp->ParseL(#%d): parsing failed: %d"), count+1, leaveCode));
+                        
+                    CleanupStack::PopAndDestroy(); // desc
+                    if(count == 0)
+                        {
+                        retVal = KErrNotFound; // could not parse single service description
+                        }
+
+                    break;
+                    }
+
+                rest.Set(rest.Mid(pos+1));  // Check
+                retVal = aList.Append(idp);
+                if(retVal == KErrNone)
+                    {
+                    CleanupStack::Pop(); // desc
+                    }
+                else
+                    {
+                    CleanupStack::PopAndDestroy();
+                    }
+                idp = NULL;
+                }
+            else
+                {
+                idp = CSenIdentityProvider::NewLC(KNullDesC8);
+                iReader->SetContentHandler(*idp);
+                idp->SetReader(*iReader);
+
+                TInt leaveCode(KErrNone);
+                TRAP(leaveCode, idp->ParseL(rest));
+                if(leaveCode!=KErrNone)
+                    {
+                    TInt count(aList.Count());
+                    TLSLOG_FORMAT((KSenServiceManagerLogChannelBase+iConnectionID, KMinLogLevel , _L8("-idp->ParseL(#%d): parsing failed: %d"), count+1, leaveCode));
+                        
+                    CleanupStack::PopAndDestroy(); // desc
+                    if(count == 0)
+                        {
+                        retVal = KErrNotFound; // could not parse single service description
+                        }
+
+                    break;
+                    }
+                retVal = aList.Append(idp);
+                if(retVal == KErrNone)
+                    {
+                    CleanupStack::Pop(); // desc
+                    }
+                else
+                    {
+                    CleanupStack::PopAndDestroy();
+                    }
+                idp = NULL;
+                break;
+                }
+
+            if (rest.Length() == 0 )
+                {
+                break;
+                }
+
+            }
+        } //  END OF: if idp.Length() > 0
+    return retVal;
+    }
+TAny* CSenServiceManagerImpl::InterfaceByUid( TUid aUID )
+    {
+    if ( aUID == KSenInterfaceUidInternalServiceManager )
+		{
+		TLSLOG_FORMAT(( KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L8("CSenServiceConnectionImpl::InterfaceByUid(%d) == KSenInterfaceUidInternalServiceManager" ), aUID.iUid ));
+		// Must be cast to M-class  (as the same C-class implements multiple M-classes):
+		MSenInternalServiceManager* manager = (MSenInternalServiceManager*) this;
+		return manager; 
+		}
+    return NULL;
+    }
+
+// END OF FILE