/*
* 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: Header declaration
*
*/
#ifndef SEN_CORE_SERVICE_MANAGER_H
#define SEN_CORE_SERVICE_MANAGER_H
// INCLUDES
#include <e32base.h>
#include <badesca.h>
#include <f32file.h>
#include <imcvcodc.h> // for base64 codec
#include <flogger.h>
#include <etelmm.h>
#include <SenXmlReader.h>
#include "senservicemanagerdefines.h"
#include "msencoreservicemanager.h"
#include "senxmldao.h"
#include "msentransport.h"
// CONSTANTS
#ifdef EKA2
// Server's policy here
// Total number of ranges
const TUint KCoreServiceManagerRangeCount = 11; //CodeScannerWarnings
// Definition of the ranges of IPC numbers
// NOTE: ranges MUST start from request number 0 (!)
const TInt coreServiceManagerRanges[KCoreServiceManagerRangeCount] =
{
0, // ESenServInitialize,
1, // ESenServTransaction,
2, // ESenServInstallFramework,
3, // ESenServAssociateService,
// ESenServDissociateService,
// ESenServRegisterIdentityProvider,
// ESenServUnregisterIdentityProvider,
// ESenServRegisterServiceDescription,
// ESenServUnregisterServiceDescription,
9, // ESenServGetServiceDescriptionsByPattern,
// ESenServGetServiceDescriptionsByUri,
11, // ESenServIsReady,
// ESenServHasFacet,
// ESenServServerMessagesOnOff,
14, // ESenServGetLengthOfServiceDescriptionByUri,
// ESenServGetLengthOfServiceDescriptionByPattern,
16, // ESenServRequestServiceDescription,
// ESenServReceiveServiceDescription,
18, // ESenServSendMsgAndGetTxnId,
// ESenServSendSoapMsgAndGetTxnId,
20, // ESenServStartTransaction,
// ESenServTransactionCompleted,
// ESenServCancelSession,
// ESenServSetTransportProperties,
// ESenServTransportProperties
// ESenServCreateHostletConnection,
// ESenServWaitForHostletRequest
// ESenServProvideHostletResponse
// ESenServMoveChunk
// ESenServMoveFile
// ESenServSendFileHandle
// ESenServGetGredentials
// ESenServAddCredential
// ESenServRemoveCredential
// ESenServCancelRequest
// ESenServConnectionID
// ESenServConnectionIdentityProvider
// ESenObserveTransfer
// ESenObserveAuthCallback
// ESenTransferProgress
// ESenServSearchIdentityProvider
// ESenServTrafficDetails
// ESenObserveCoBranding
// ESenServGetIdentityProviders
#ifdef __ENABLE_ALR__
// ESenServRegisterMobiltyObserver
//ESenServMigrateToPreffredCarrier
//ESenServNewCarrierAccepted
47
#else
44
#endif
};
// Policy to implement for each of the above ranges
const TUint8 coreServiceManagerElementsIndex[KCoreServiceManagerRangeCount] =
{
2, //applies to 1st range <=> 0
CPolicyServer::EAlwaysPass, //applies to 2nd range <=> 1
1, //applies to 3rd range <=> 2
3, //applies to 4th range <=> 3 - 8
0, //applies to 5th range <=> 9 - 10
CPolicyServer::EAlwaysPass, //applies to 6th range <=> 11 - 13
0, //applies to 7th range <=> 14 - 15
CPolicyServer::EAlwaysPass, //applies to 8th range <=> 16 - 17
2, //applies to 9th range <=> 18 - 19
CPolicyServer::EAlwaysPass, //applies to 10th range <=> 20 - 35
CPolicyServer::ENotSupported //applies to 11th range (out of range IPC; >35)
};
// Specific capability checks
const CPolicyServer::TPolicyElement coreServiceManagerElements[] =
{
//policy "0"; fail call if ReadUserData not present
{_INIT_SECURITY_POLICY_C1(ECapabilityReadUserData), CPolicyServer::EFailClient},
//policy "1"; fail call if WriteUserData not present
{_INIT_SECURITY_POLICY_C1(ECapabilityWriteUserData), CPolicyServer::EFailClient},
//policy "2"; fail call if NetworkServices not present
{_INIT_SECURITY_POLICY_C1(ECapabilityNetworkServices), CPolicyServer::EFailClient},
//policy "3"; fail call if ReadUserData, WriteUserData not present
{_INIT_SECURITY_POLICY_C2(ECapabilityReadUserData, ECapabilityWriteUserData), CPolicyServer::EFailClient}
};
// Package all the above together into a policy
const CPolicyServer::TPolicy coreServiceManagerPolicy =
{
CPolicyServer::EAlwaysPass, // specifies all connect attempts should pass
KCoreServiceManagerRangeCount, // number of ranges
coreServiceManagerRanges, // ranges array
coreServiceManagerElementsIndex, // elements<->ranges index
coreServiceManagerElements, // array of elements
};
#endif //EKA2
// FORWARD DECLARATIONS
class CSenGuidGen;
class CSenBaseIdentityManager;
class CSenCredentialManager;
class CSenServerContext;
class CSenCoreShutdownTimer;
// CLASS DECLARATION
#ifdef EKA2
class CSenCoreServiceManager : public CPolicyServer,
public MSenCoreServiceManager
#else
class CSenCoreServiceManager : public CServer2,
public MSenCoreServiceManager
#endif
{
public:
// Constructors
static CSenCoreServiceManager* NewL();
static CSenCoreServiceManager* NewLC();
// C++ destructor
virtual ~CSenCoreServiceManager();
// From MSenIdentityManager:
virtual MSenIdentity& IdentityL();
virtual TInt UserNameL(HBufC8*& aUserName);
virtual CSenIdentityProvider* IdentityProviderL();
virtual CSenIdentityProvider* IdentityProviderL(const TDesC8& aURI);
virtual CSenIdentityProvider* IdentityProviderL(const CDesC8Array& aIdpList,
TBool aStrict);
virtual CSenIdentityProvider* IdentityProviderL(MSenServiceDescription& aSD);
virtual CSenIdentityProvider* IdentityProviderL(MSenServiceDescription& aSD,
const CDesC8Array& aIdpList,
TBool aStrict);
virtual const RPointerArray<CSenIdentityProvider>& IdentityProvidersL();
virtual TInt RegisterIdentityProviderL(CSenIdentityProvider* apIdp);
virtual TInt UnregisterIdentityProviderL(CSenIdentityProvider& aIdp);
virtual TBool AssociateServiceL(const TDesC8& aServiceID, const TDesC8& aProviderID);
virtual TBool DissociateServiceL(const TDesC8& aServiceID, const TDesC8& aProviderID);
virtual TInt IdentitiesL(CDesC8Array& aIdentitiesList);
virtual TInt AuthenticationForL(CSenIdentityProvider& aAccount, TPckgBuf<TSenAuthentication>& aResponse);
virtual TPtrC8 SenSecurityMechanismNames8L();
virtual void SetShowPasswordDialog(const TBool aState);
virtual CSenSecurityMechanism* MechanismNamedL(const TDesC8& aName);
// From MSenServiceManager
virtual TInt InitServiceConnectionL(MSenRemoteServiceConsumer& aServiceConsumer,
CSenWSDescription& aPattern,
HBufC8*& aErrorMsg);
virtual TInt ServiceDescriptionsL(RWSDescriptionArray& aMatches,
const TDesC8& aContract);
virtual TInt ServiceDescriptionsL(RWSDescriptionArray& aMatches,
MSenServiceDescription& aPattern);
virtual TInt RegisterServiceDescriptionL(CSenWSDescription* apSD);
virtual TInt UnregisterServiceDescriptionL(MSenServiceDescription& aSD);
virtual CSenBaseFragment* InstallFrameworkL(const TDesC8& aFrameworkId);
virtual TPtrC8 IMSI();
virtual TPtrC8 IMEI();
virtual CSenXmlReader* XMLReader();
virtual HBufC8* RandomGuidL();
virtual RFileLogger* Log() const;
virtual void IncrementConnections();
virtual void DecrementConnections();
virtual TInt ContainsServiceDescriptionL(TBool& aContains,
CSenWSDescription& aPattern);
virtual TInt ContainsIdentityProviderL(TBool& aContains,
CSenIdentityProvider& aIDP);
virtual TInt FindMatchingIdentityProviderL(CSenIdentityProvider &aIdp,
CSenIdentityProvider*& apMatch);
virtual TInt UpdateIdentityProviderL(CSenIdentityProvider& aIdp);
virtual TInt NextTransactionId();
/**
* Notifies *ALL* framework plug-ins about certain event
* @return some system-wide error code, if an error occurred
*/
virtual TInt NotifyFrameworksL(const TInt aEvent);
/**
* Notifies *ALL* framework plug-ins about certain event,
* an additional object pointer may be passed
* NULL is also accepted
* @return some system-wide error code, if an error occurred
*/
virtual TInt NotifyFrameworksL(const TInt aEvent, TAny* aArgument);
/**
* Notifies only those frameworks plug-ins, which match
* with given framework ID (aFrameworkID)
* If aFrameworkID == KNullDesC8 (zero-length),
* then *all* known framework plug-ins are notified about the event.
* @return some system-wide error code, if an error occurred
*/
virtual TInt NotifyFrameworksL(const TDesC8& aFrameworkID,
const TInt aEvent);
/**
* Notifies only those frameworks plug-ins, which match
* with given framework ID (aFrameworkID)
* If aFrameworkID == KNullDesC8 (zero-length),
* then *all* known framework plug-ins are notified about the event,
* an additional object pointer may be passed
* NULL is also accepted
* @return some system-wide error code, if an error occurred
*/
virtual TInt NotifyFrameworksL(const TDesC8& aFrameworkID,
const TInt aEvent,
TAny* aArgument);
virtual TInt SizeOfServiceDescriptionsL(RWSDescriptionArray& aArray);
virtual TInt SizeOfCredentialsL(RSenCredentialArray& aArray);
virtual TInt SizeOfIdentityProvidersL(const RPointerArray<CSenIdentityProvider>& aArray);
// From MSenCoreServiceManager
/**
* Takes the ownership of apServiceDescription
* @return KErrNone on success
* KErrArgument, if aServiceDescription is NULL
* KErrSenNoContractNoEndPoint, if both endpoint and
* contract are of zero-lenght, making SD invalid
* KErrGeneral if duplicate (blocking), service description
* with equal primary keys could not be removed.
*/
virtual TInt AddServiceDescriptionL(CSenWSDescription* apServiceDescription);
virtual TInt RemoveServiceDescriptionL(CSenWSDescription& aServiceDescription);
virtual TInt SaveL(const CSenServiceSession& aServiceSession);
virtual TInt SaveL(const CSIF& aServiceInvocationFramework);
virtual CDesC8Array& SupportedFrameworksL();
virtual MSenProvider& LookupHostletForL(const TDesC8& aHostletEndpoint,
const TDesC& aReqThreadId,
const TDesC8& aReqConsumerId);
virtual TInt ReleaseHostletL(const MSenProvider* aHostlet,
const TDesC& aReqThreadId,
const TDesC8& aReqConsumerId);
// From MSenTransportFactory:
virtual CSenTransportBase* CreateL(CSenWSDescription& aInitializer,
CSenServiceSession* apSession);
// from CServer
CSession2* NewSessionL(const TVersion &aVersion,
const RMessage2& aMessage) const;
static TInt ThreadFunction(TAny* sStarted);
virtual HBufC8* EncodeToBase64LC(const TDesC8& aSource);
virtual HBufC8* DecodeFromBase64LC(const TDesC8& aSource);
// New functions
virtual RStringPool& StringPool();
/*
// New functions
virtual TInt AddActiveHostletConnectionEndpointL(const TDesC8& aEndpoint);
virtual TInt RemoveActiveHostletConnectionEndpoint(const TDesC8& aEndpoint);
*/
// From MSenCredentialManager
virtual TInt SaveCredentialDB();
virtual TInt CredentialsL(const CSenWSDescription& aPattern,
RSenCredentialArray& aCredentials);
virtual TInt CredentialsL(const CSenWSDescription& aPattern,
const CSenIdentityProvider& aIdP,
RSenCredentialArray& aCredentials);
virtual TInt CredentialsL(const CSenWSDescription& aPattern,
RSenCredentialPtrArray& aCredentials);
virtual TInt CredentialsL(const CSenWSDescription& aPattern,
const CSenIdentityProvider& aIdP,
RSenCredentialPtrArray& aCredentials);
virtual RSenCredentialPtr AddCredentialL(CSenInternalCredential* apCredential,
TInt& aErrorTo);
virtual RSenCredentialPtr AddCredentialL(CSenIdentityProvider* apIdP,
CSenInternalCredential* apCredential,
TInt& aErrorTo);
virtual RSenCredentialPtr AddCredentialL(const TDesC8& aCredential,
TInt& aErrorTo);
virtual RSenCredentialPtr AddCredentialL(CSenIdentityProvider* apIdP,
const TDesC8& aCredential,
TInt& aErrorTo);
virtual TInt RemoveCredentialsL(const CSenWSDescription& aPattern);
virtual TInt RemoveCredentialsL(const CSenWSDescription& aPattern,
const CSenIdentityProvider& aIdP);
virtual TInt RemoveCredentialsL(const TDesC8& aProviderId);
virtual TInt RemoveCredentialL(TInt aInternalCredentialId); //codescannerwarnings
virtual RSenCredentialPtr CredentialL(TInt aInternalCredentialId,
TInt& aErrorTo);
virtual RSenCredentialPtr UpdateCredentialL(TInt aInternalCredentialId,
CSenInternalCredential* apCredential,
TInt& aErrorTo);
virtual RSenCredentialPtr UpdateCredentialL(TInt aInternalCredentialId,
const TDesC8& aCredential,
TInt& aErrorTo);
virtual TInt NextConnectionID();
protected:
// From CActive
TInt RunError(TInt aError);
private:
/**
* C++ default constructor.
*/
CSenCoreServiceManager(TInt aPriority);
/**
* By default Symbian 2nd phase constructor is private.
*/
void ConstructL();
// New functions
MSIF* Framework(const TDesC8& aFrameworkID);
TImCodecB64& Base64Codec();
// RPointerArray<HBufC8>& ActiveHostletEndpointsL();
private:
// CS framework:
static void PanicClient(const RMessage2& aMessage,
TWsfServPanic aReason);
static void PanicServer(TWsfServPanic aPanic);
static void ThreadFunctionL();
void UpdateTouchL(CSenServiceSession* aSession);
void GetImsiImeiL();
private: // Data
CSenXMLDAO* iDAO; // owned
CSenBaseIdentityManager* iIdentityManager; // owned
RFileLogger iLog; // owned
TInt iConnectionCount;
CSenGuidGen* iGuidGenerator; // owned
CSenXmlReader* iReader; // owned
TImCodecB64 iBase64Codec;
RStringPool iStringPool; // owned
// RPointerArray<HBufC8>* ipActiveHostletEndpoints; // owned
TInt iNextTransactionId;
CSenCredentialManager* iCredentialManager; // owned
CSenTransportBase* ipVtcpTransport; // not owned
// HBufC8* ipVtcpEndpoint; // owned
TInt iConnectionID;
CSenServerContext* ipServerContext; // owned
CSenCoreShutdownTimer* iShutdownTimer;
TBuf8<15> iIMSI;
TBuf8<50> iIMEI;
};
#endif // SEN_CORE_SERVICE_MANAGER_H
// End of File