void CPosSession::GetModuleInfoByIndexL(const RMessage2& aMessage) { DEBUG_TRACE("EPositionServerGetModuleInfoByIndex in", __LINE__) // module index TInt modIndex = aMessage.Int0(); CPosModuleIdList* moduleIdList = iModuleSettings.ModuleIdListL(); CleanupStack::PushL( moduleIdList ); if (modIndex >= moduleIdList->Count() || modIndex < 0) { User::Leave(KErrNotFound); } TPositionModuleId moduleId = (*moduleIdList)[modIndex]; // module info HBufC8* buffer = Global::CopyClientBuffer8LC(aMessage, KParamModuleInfo); TPositionModuleInfoBase* moduleInfoBase = reinterpret_cast<TPositionModuleInfoBase*>( const_cast<TUint8*>(buffer->Ptr())); Global::ValidatePositionClassBufferL(*moduleInfoBase, buffer->Des()); // TPositionModuleInfo is the only class supported by CPosModules Global::ValidatePositionClassTypeL(*moduleInfoBase, EPositionModuleInfoClass); DEBUG_TRACE("Buffer validation done", __LINE__) CleanupStack::PopAndDestroy(2, moduleIdList); // TPositionModuleInfo contains descriptor. If it is corrupt // (malicious client) then writing to this will panic server // Local instance of TPositionModuleInfo is created to be sure // that module name descriptor is not corrupt TPositionModuleInfo modInfo; iModuleSettings.GetModuleInfoL(moduleId, modInfo); TPckg<TPositionModuleInfo> modInfoPack(modInfo); User::LeaveIfError(Global::Write(aMessage, KParamModuleInfo, modInfoPack)); RequestComplete(aMessage, KErrNone); DEBUG_TRACE("EPositionServerGetModuleInfoByIndex out", __LINE__) }
CPolicyServer::TCustomResult CMsmmServer::CustomSecurityCheckL( const RMessage2& aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/) { CPolicyServer::TCustomResult returnValue = CPolicyServer::EFail; TSecureId ClientSID = aMsg.SecureId(); if (KFDFWSecureId == ClientSID) { returnValue = CPolicyServer::EPass; } else if ((KSidHbDeviceDialogAppServer == ClientSID) && SessionNumber() > 0) { returnValue = CPolicyServer::EPass; } return returnValue; }
void CConfigSession::Cancel( const RMessage2& aMessage) /** * Asynchronous request to cancel an existing asynchronous operation. * * @internalComponent * * @param aMessage Message containing the request status. */ { __FLOG_STATIC(KConfigLoggingTag1(), KConfigLoggingTag2(), _L("CConfigSession::Cancel Start")); if (iConfigIf) iConfigIf->CancelRequest(); aMessage.Complete(KErrNone); __FLOG_STATIC(KConfigLoggingTag1(), KConfigLoggingTag2(), _L("CConfigSession::Cancel End")); }
/** Called when a message is received for this session. @param aMessage The message from the client. */ void CSuplProxyPrivacySession::ServiceL(const RMessage2& aMessage) { LBSLOG(ELogP1, "CSuplProxyPrivacySession::ServiceL() Begin\n"); switch (aMessage.Function()) { case ELbsPrivacyServerNotifyLocation: NotifyLocationRequest(aMessage); break; case ELbsPrivacyServerVerifyLocation: VerifyLocationRequest(aMessage); break; case ELbsPrivacyServerNotifyVerificationTimeout: NotifyVerificationTimeout(aMessage); break; case ELbsPrivacyServerCancelVerifyLocationRequest: CancelVerifyLocationRequest(aMessage); break; case ELbsPrivacyServerNewPrivacyRequestLocal: case ELbsPrivacyServerNewPrivacyRequestNetwork: NewPrivacyRequest(aMessage); break; case ELbsPrivacyServerRepeatPrivacyRequestLocal: case ELbsPrivacyServerRepeatPrivacyRequestNetwork: RepeatPrivacyRequest(aMessage); break; case ELbsPrivacyServerCompleteRequest: CompleteRequest(aMessage); break; default: User::Leave(KErrNotSupported); } LBSLOG(ELogP1, "CSuplProxyPrivacySession::ServiceL() End\n"); }
// --------------------------------------------------------- // HandleOrderNotifications // --------------------------------------------------------- // void CHotSpotSession::HandleOrderNotifications( const RMessage2& aMessage ) { iPendingNotificationRequest = aMessage; iIsNotificationRequestPending = ETrue; if( !iNotificationHandle ) // == NULL i.e. is not activated { TRAPD( err, iNotificationHandle = CSessionNotification::NewL( *this ) ); if ( err == KErrNone ) { iServer.NotifyAdd( *iNotificationHandle ); } else { iIsNotificationRequestPending = EFalse; aMessage.Complete( err ); return; } } HandleNotification(); // check is there any unsent notifications }
// -------------------------------------------------------------------------- // // -------------------------------------------------------------------------- void CAknCompaSrvSession::DispatchMessageL(const RMessage2& aMessage) { switch(aMessage.Function()) { case ECompaSrvSimulateKeyEvent: SimulateKeyEventServiceL(aMessage); break; case ECompaSrvDisaTransEffects: Server().DisaTransEffectsL(aMessage); break; case ECompaSrvRestoreTransEffects: Server().RestoreTransEffectsL(aMessage); break; // Requests that we don't understand at all are a different matter. // This is considered a client programming error, so we panic the // client - this also completes the message. default: CAknCompaServer::PanicClient(aMessage, EBadRequest); } }
void CCntItemMsgHandler::SetAsyncActivityL(const RMessage2& aMessage) { CheckForManagerL(); TBool asyncActivity = TBool(aMessage.Int0()); // Create and then process appropriate request using state machine. CCntRequest* request = NULL; if (asyncActivity) { request = CReqAsyncActivity::NewLC(iSessionId, aMessage, iTimeOut); } else { request = CReqNoAsyncActivity::NewLC(iSessionId, aMessage, iTimeOut); } iManager->StateMachineL().ProcessRequestL(request); // ownership transferred // ProcessRequestL received ownership of the request, the request only need // to be popped from CleanupStack. CleanupStack::Pop(request); }
void CConfigSession::IoctlL( const RMessage2& aMessage) /** * Asynchronous request to start an action. * * @internalComponent * * @param aMessage Message containing the type parameter and the request status. * @leave Leaves from CConfigControl::IoctlL. */ { __FLOG_STATIC(KConfigLoggingTag1(), KConfigLoggingTag2(), _L("CConfigSession::IoctlL Start")); if (!iConfigIf) User::Leave(KErrNotReady); iConfigIf->IoctlL(aMessage.Int1(), aMessage); __FLOG_STATIC(KConfigLoggingTag1(), KConfigLoggingTag2(), _L("CConfigSession::IoctlL End")); }
void CConfigSession::DeregisterL( const RMessage2& aMessage) /** * Asynchronous deregistration request. * * @internalComponent * * @param aMessage * @leave KErrNotReady If ConfigureL was not called previously. Leaves from CConfigControl::DeregisterL. */ { __FLOG_STATIC(KConfigLoggingTag1(), KConfigLoggingTag2(), _L("CConfigSession::DeregisterL Start")); if (!iConfigIf) User::Leave(KErrNotReady); iConfigIf->DeregisterL(aMessage.Int0(), aMessage); __FLOG_STATIC(KConfigLoggingTag1(), KConfigLoggingTag2(), _L("CConfigSession::DeregisterL End")); }
/** Submit a notification timeout request. @param aMessage The message from the client. */ void CSuplProxyPrivacySession::NotifyVerificationTimeout(const RMessage2& aMessage) { LBSLOG(ELogP1, "CSuplProxyPrivacySession::NotifyVerificationTimeout() Begin\n"); // NOTE: requestInfo does not complete the message in this case CSuplProxyPrivacyRequestInfo* requestInfo = NULL; TRAPD(err, requestInfo = CSuplProxyPrivacyRequestInfo::NewL(aMessage)); if (err != KErrNone) { // Error creating request info object, complete with the error and return aMessage.Complete(err); return; } TLbsExternalRequestInfo2 extRequestInfo; TPckg<TLbsExternalRequestInfo2> extRequestInfoPkg(extRequestInfo); aMessage.Read(0,extRequestInfoPkg); requestInfo->SetRequestInfo(extRequestInfo); requestInfo->SetRequestId(aMessage.Int1()); TLbsNetPosRequestPrivacy netPosRequestPrivacy; TPckg<TLbsNetPosRequestPrivacy> netPosRequestPrivacyPkg(netPosRequestPrivacy); aMessage.Read(2,netPosRequestPrivacyPkg); requestInfo->SetRequestPrivacy(netPosRequestPrivacy); requestInfo->SetIsResponseRequired(EFalse); if (!IsRequestInfoValid(*requestInfo)) { aMessage.Panic(KPosPrivacyPanicCategory, EPosPrivSrvPanicInvalidArguments); delete requestInfo; return; } // temporary. Since NRH state machine can't deal with receiving a second privacy request while waiting for a location request, complete the first session so we start a new one. iPrivacyProtocol.EndPrivacySession(aMessage.Int1(), KErrNone); iPrivacyProtocol.NotifyVerificationTimeout(requestInfo); aMessage.Complete(KErrNone); LBSLOG(ELogP1, "CSuplProxyPrivacySession::NotifyVerificationTimeout() End\n"); }
// --------------------------------------------------------------------------- // --------------------------------------------------------------------------- // TInt CPolicyClientRequestHandler::InsertClient(const RMessage2& aMessage) { TInt err = KErrNone; CPolicyEventReq* req = new CPolicyEventReq(); if (!req) { return KErrNoMemory; } // Getting the client ID and storing it. RThread client; err = aMessage.Client(client); if( err != KErrNone ) { delete req; return err; } req->iClientId = client.Id(); client.Close(); err = iControlPolicyClients.Append(req); if( err == KErrNone ) { // Requesting all policies from the policy handler. err = iParent->GetAllControlPolicies( req->iOriginalControlPolicies ); if( err == KErrNotFound ) { // If no polices found, store message for later. req->iMessage = aMessage; return err; } err = req->TotalPolicyCount(); } else { delete req; } return err; }
TBool CAppInfoViewSubsession::DoServiceL(TInt aFunction, const RMessage2& aMessage) /** Implement CFileListSubsession by handling the supplied message. @param aFunction Function identifier without SCS code. @param aMessage Standard server-side handle to message. @return ETrue means complete client request now. EFalse for asynchronous tasks. */ { TScrSessionFunction f = static_cast<TScrSessionFunction>(aFunction); switch (f) { case EOpenAppInfoView: { DeleteObjectZ(iAppInfoFilter); iAppInfoFilter = iServer->RequestImpL()->ReadAppInfoFilterL(aMessage); DeleteObjectZ(iStatement); iSubsessionContext->iLocale = TLanguage(aMessage.Int1()); if(iSubsessionContext->iLocale == KUnspecifiedLocale) { iSubsessionContext->iLocale = User::Language(); } iSubsessionContext->iAppInfoIndex = 0; iServer->RequestImpL()->OpenAppInfoViewL(*iAppInfoFilter, this->iSubsessionContext); break; } case EGetNextAppInfoSize: iServer->RequestImpL()->NextAppInfoSizeL(aMessage, iApaAppInfo, this->iSubsessionContext); break; case EGetNextAppInfoData: iServer->RequestImpL()->NextAppInfoDataL(aMessage, iApaAppInfo); break; default: User::Leave(KErrNotSupported); break; } return ETrue; }
void CNrhPrivacyServerSubsession::DispatchL(const RMessage2& aMessage) { switch(aMessage.Function()) { case ENrhPrivacyControllerRegister: SetClientReady(aMessage); break; case ENrhPrivacyControllerCancelRegister: CancelClientReady(aMessage); break; case ENrhPrivacyControllerResponse: HandlePrivacyResponse(aMessage); break; case ENrhPrivacyControllerCancel: HandlePrivacyCancel(aMessage); break; } }
// --------------------------------------------------------------------------- // Returns the index of a given preset observer. // --------------------------------------------------------------------------- // TInt CPSServer::PresetObserverIndex( const RMessage2& aMessage ) const { TInt idx = KErrNotFound; CSession2* currentSession = aMessage.Session(); for ( TInt i = 0; i < iPresetObservers.Count(); i++ ) { const RMessage2& message = iPresetObservers[i]; if ( !message.IsNull() && message.Session() == currentSession && message.Int0() == aMessage.Int0() ) { idx = i; /*lint -save -e960 (Note -- Violates MISRA Required Rule 58, non-switch break used)*/ break; /*lint -restore*/ } } return idx; }
// --------------------------------------------------------------------------- // Called when a session is disconnected. // --------------------------------------------------------------------------- // void CPSServer::SessionDisconnected( const RMessage2& aMessage ) { PSDEBUG( "CPSServer::SessionDisconnected( RMessage2& ) [enter]" ); for ( TInt i = 0; i < iPresetObservers.Count(); i++ ) { const RMessage2& message = iPresetObservers[i]; if ( message.Session() == aMessage.Session() ) { if ( !message.IsNull() ) { message.Complete( KErrDied ); } iPresetObservers.Remove( i ); i--; } } PSDEBUG( "CPSServer::SessionDisconnected( RMessage2& ) [exit]" ); }
// ============================================================================ // CCwrtRegistryServerSession::ServiceL() // Handles messages from client // // ============================================================================ // void CCwrtRegistryServerSession::ServiceL( const RMessage2& aMessage ) { TBool retBool( EFalse ); bool ret( false ); TInt len = 0; TInt uid = 0; TInt count = 0; TInt policyId = 0; const TInt function = aMessage.Function(); // TBD seems like we should trap leaves and return error codes so // as not to exit the server switch ( function ) { case EOpCodeRegisterWidget: ret = OpRegisterWidgetL( aMessage ); aMessage.Complete( ret ); break; case EOpCodeDeRegisterWidget: ret = OpDeRegisterWidgetL( aMessage ); aMessage.Complete( ret ); break; case EOpCodeGetWebAttribute: OpGetWebAttributeL( aMessage ); aMessage.Complete( KErrNone ); break; case EOpCodeSetWebAttribute: ret = OpSetWebAttributeL( aMessage ); aMessage.Complete( ret ); break; case EOpCodeNativeIdToAppId: OpNativeIdToAppIdL( aMessage ); aMessage.Complete( KErrNone ); break; case EOpCodeWidgetRegistryDisconnect: OpDisconnect( aMessage ); aMessage.Complete( KErrNone ); break; default: User::Leave( KErrNotSupported ); break; } }
/** * Takes a buffer from the client and sends to the driver. * * @param aMessage RMessage2 client request. */ void CShBufTestServerSession::FromTPtr8ProcessAndReleaseL(const RMessage2& aMessage) { // // Read the client buffer... // TPtr8 bufPtr(iSessionTempBuffer, sizeof(iSessionTempBuffer)); aMessage.ReadL(0, bufPtr); // // Pass to the server to pass to the driver and back... // TInt result; result = Server().FromTPtr8ProcessAndRelease(bufPtr); // // Complete the request... // CompleteRequest(aMessage, result); } // CShBufTestServerSession::FromTPtr8ProcessAndReleaseL
/** Services messages directed to a device. Messages associated with a single Logical Unit contained by the device are forwarded to the Logical Unit Handler. @param aMessage */ void TDeviceHandler::HandleMessageL(const RMessage2& aMessage) { __MSFNLOG TLun lun = iDevice.GetAndSetLunL(aMessage); switch (aMessage.Function()) { case EUsbHostMsSuspendLun: iDevice.SuspendLunL(lun); break; case EUsbHostMsUnRegisterLun: iDevice.RemoveLunL(lun); break; default: // Try Logical Unit Handler CUsbHostMsLogicalUnit& lu = iDevice.GetLuL(lun); TLogicalUnitHandler luHandler(lu); luHandler.HandleMessageL(aMessage); break; } }
// --------------------------------------------------------------------------- // Process a client message related to notifiers. // --------------------------------------------------------------------------- // void CBTNotifGenInfoNotifier::HandleNotifierRequestL( const RMessage2& aMessage ) { BOstraceFunctionEntryExt ( DUMMY_LIST, this, aMessage.Function() ); TInt opcode = aMessage.Function(); TInt uid = aMessage.Int0(); TInt err = KErrNone; switch ( opcode ) { case EBTNotifCancelNotifier: { aMessage.Complete( err ); break; } case EBTNotifUpdateNotifier: { aMessage.Complete( err ); break; } case EBTNotifStartSyncNotifier: { TRAP(err,ShowNotificationL(aMessage)); aMessage.Complete( err ); break; } case EBTNotifStartAsyncNotifier: { TRAP(err,ShowNotificationL(aMessage)); aMessage.Complete( err ); break; } default: { aMessage.Complete( KErrNotSupported ); } } BOstraceFunctionExit1( DUMMY_DEVLIST, this ); }
// ----------------------------------------------------------------------------- // CWimCertHandler::GetCertificateInfo // Fetches certificate info. Wrapper for WIMI call. // ----------------------------------------------------------------------------- // TBool CWimCertHandler::CheckReadCapsForUsage( const RMessage2& aMsg, TUint8 aUsage ) { TBool result = EFalse; switch ( aUsage ) { case WIMI_CU_CA: { // CA certificate reading doesn't require any capability. _WIMTRACE(_L("CWimCertHandler::CheckReadCapsForUsage: CA cert read req, OK.")); result = ETrue; break; } case WIMI_CU_Client: { // User certificate reading requires ReadUserData capability. if ( aMsg.HasCapability( ECapabilityReadUserData )) { result = ETrue; _WIMTRACE(_L("CWimCertHandler::CheckReadCapsForUsage: User cert read capa PASS")); } else { result = EFalse; _WIMTRACE(_L("CWimCertHandler::CheckReadCapsForUsage: User cert read capa FAIL")); } break; } default: { _WIMTRACE(_L("CWimCertHandler::CheckReadCapsAccordingToUsage: FAIL:Unknown usage.")); result = EFalse; break; } } _WIMTRACE(_L("CWimCertHandler::CheckReadCapsForUsage | End")); return result; }
/** Called by ServiceL() It tests the function code and then delegates to the appropriate function. */ void CCountServSession::DispatchMessageL(const RMessage2& aMessage) { switch (aMessage.Function()) { case ECountServSetFromString: SetFromStringL(aMessage); return; case ECountServIncrease: Increase(); return; case ECountServIncreaseBy: IncreaseBy(aMessage); return; case ECountServDecrease: Decrease(); return; case ECountServDecreaseBy: DecreaseBy(aMessage); return; case ECountServReset: Reset(); return; case ECountServValue: CounterValueL(aMessage); return; // This is an example of a request that we know about, but don't support. // We cause KErrNotSupported to be returned to the client. case ECountServUnsupportedRequest: User::Leave(KErrNotSupported); // Requests that we don't understand at all are a different matter. // This is considered a client programming error, so we panic the // client - this also completes the message. default: PanicClient(aMessage,EBadRequest); return; } }
TInt CEchoDaemonSession::DispatchMessageL(const RMessage2& aMessage) { TInt ret = KErrNotSupported; switch(aMessage.Function()) { case EStartEchoDaemon: ret = Start(aMessage); break; case EStopEchoDaemon: ret = Stop(aMessage); break; case EStopAllEchoDaemons: ret = StopAll(aMessage); break; default: // Unknown function number - panic the client PanicClient(aMessage, EBadRequest); } return ret; }
// --------------------------------------------------------------------------- // CSecurityDialogNotifierSession::DispatchMessageL() // --------------------------------------------------------------------------- // void CSecurityDialogNotifierSession::DispatchMessageL( const RMessage2& aMessage ) { TRACE( "CSecurityDialogNotifierSession::DispatchMessageL, begin" ); if( !IsOperationCancelled( aMessage ) ) { TSecurityDialogOperation operation = static_cast< TSecurityDialogOperation >( aMessage.Function() ); TRACE( "CSecurityDialogNotifierSession::DispatchMessageL, operation=%d", operation ); switch( operation ) { case ESecureConnection: case ESignText: // TODO: implement User::Leave( KErrNotSupported ); break; case EEnterPIN: case EEnablePIN: case EDisablePIN: case EChangePIN: BasicPinOperationL( aMessage ); break; case EUnblockPIN: case EPINBlocked: case ETotalBlocked: case EUnblockPINInClear: // TODO: implement User::Leave( KErrNotSupported ); break; case EServerAuthenticationFailure: ServerAuthenticationFailureL( aMessage ); break; default: User::Leave( KErrNotSupported ); break; } } TRACE( "CSecurityDialogNotifierSession::DispatchMessageL, end" ); }
void CStsServerSession::ServiceL(const RMessage2& aMessage) { switch (aMessage.Function()) { case StsMsg_RegisterMsgQueue: DoRegisterMsgQueueL(aMessage); break; case StsMsg_PlayTone: DoPlayToneL(aMessage); break; case StsMsg_PlayAlarm: DoPlayAlarmL(aMessage); break; case StsMsg_PlayToneAlarm: DoPlayToneAlarmL(aMessage); break; case StsMsg_StopAlarm: DoStopAlarmL(aMessage); break; default: break; } }
void CMsmmSession::ServiceError(const RMessage2 &aMessage, TInt aError) { OstTraceFunctionEntry0( CMSMMSESSION_SERVICEERROR_ENTRY ); CMsmmPolicyPluginBase* plugin = iServer.PolicyPlugin(); TUSBMSDeviceDescription& device = iDevicePkg(); switch (aError) { case KErrNoMemory: iErrData->iError = EHostMsErrOutOfMemory; break; case KErrArgument: iErrData->iError = EHostMsErrInvalidParameter; break; case KErrNotFound: iErrData->iError = EHostMsErrInvalidParameter; break; default: iErrData->iError = EHostMsErrGeneral; } iErrData->iE32Error = aError; iErrData->iManufacturerString = device.iManufacturerString; iErrData->iProductString = device.iProductString; iErrData->iDriveName = 0x0; OstTrace1( TRACE_DUMP, CMSMMSESSION_SERVICEERROR, "iErrData->iE32Error = %d", aError ); OstTraceExt1( TRACE_DUMP, CMSMMSESSION_SERVICEERROR_DUP1, "iErrData->iManufacturerString=\"%S\"", device.iManufacturerString ); OstTraceExt1( TRACE_DUMP, CMSMMSESSION_SERVICEERROR_DUP2, "iErrData->iProductString=\"%S\"", device.iProductString ); TInt err(KErrNone); TRAP(err, plugin->SendErrorNotificationL(*iErrData)); aMessage.Complete(aError); OstTraceFunctionExit0( CMSMMSESSION_SERVICEERROR_EXIT ); }
/** Handles the connect request from the client. We trap Leaves, to ensure that existing sessions aren't affected by failure to create a new one. @param aMessage The Connect message sent by the client requesting the connection. aMessage.Ptr0() is the required Version. */ EXPORT_C void CServer2::DoConnect(const RMessage2& aMessage) { ASSERT(aMessage.Function() == RMessage2::EConnect); ASSERT(aMessage.Session() == NULL); ASSERT(!aMessage.IsNull()); CSession2* newSession = NULL; TRAPD(err, DoConnectL(aMessage, newSession)); if (err != KErrNone) { // Connect failed delete newSession; aMessage.Complete(err); } else { ASSERT(newSession != NULL); CServer2* sessionServer = const_cast<CServer2*>(newSession->Server()); ASSERT(sessionServer != NULL); // The return value of Server() will be 'this', unless it was // changed by a call to SetServer(). if (sessionServer == this) { // no SetServer() call, so just complete the Connect message aMessage.Complete(err); } else { // Transfer the new Csession to the specified slave Cserver newSession->iLink.Deque(); sessionServer->iSessionQ.AddLast(*newSession); // Ask the kernel to transfer the DSession to the slave DServer. // Note: this Exec call also completes the Connect message. TInt msgHandle = aMessage.iHandle; const_cast<TInt&>(aMessage.iHandle) = 0; ASSERT(msgHandle); Exec::TransferSession(msgHandle, sessionServer->Server().Handle()); } } ASSERT(aMessage.IsNull()); }
void CRtaContentHandler::GetEmbeddedObjects2L(const RMessage2& aMessage) { RStreamablePtrArray<CEmbeddedObject> array; CleanupClosePushL(array); TEmbeddedType type; TPckg<TEmbeddedType> typePckg(type); aMessage.Read(1, typePckg); iArchive->DrmFilesL().CurrentContainer().GetEmbeddedObjectsL(array, type); // Write the object out to a buffer, send to client CBufFlat* buf = CBufFlat::NewL(50); CleanupStack::PushL(buf); // create write stream RBufWriteStream writeStream(*buf); // write the directory to the stream array.ExternalizeL(writeStream); TPtr8 bufPtr = buf->Ptr(0); WriteL(aMessage, 0, bufPtr); CleanupStack::PopAndDestroy(2, &array); // buf, array }
void CConfigSession::ConfigureL( const RMessage2& aMessage) /** * This function is used to start the configuration for * the connection specified in the RMessage. * * @internalComponent * * @param aMessage * @leave KErrInUse if previously called. Leaves from CConfigControl::ConfigureL. */ { __FLOG_STATIC(KConfigLoggingTag1(), KConfigLoggingTag2(), _L("CConfigSession::ConfigureL Start")); if (iConfigIf) User::Leave(KErrInUse); TConnectionInfoBuf configInfo; aMessage.Read(0, configInfo); iConfigIf = CreateControlL(); iConfigIf->ConfigureL(configInfo(), aMessage); __FLOG_STATIC(KConfigLoggingTag1(), KConfigLoggingTag2(), _L("CConfigSession::ConfigureL End")); }
// this is custom security check implemented just for example purposes // check that client process has secure UID of our UI client application CPolicyServer::TCustomResult CExPolicy_Server::CustomSecurityCheckL(const RMessage2& aMsg, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/) { if(iFile.SubSessionHandle()) { iFile.Write(_L8("Security test\n,")); } CPolicyServer::TCustomResult test; test=EFail;// by default we will fail the test RThread ClientThread; aMsg.Client(ClientThread);// get client thread if(ClientThread.Handle())// has handle --> is valid { RProcess ClientProcess; ClientThread.Process(ClientProcess);// then get the process TSecureId ProsID = ClientProcess.SecureId();// and check secure UID if(ProsID.iId == (TUint32)KMAINYTasksUid31.iUid || ProsID.iId == (TUint32)KMAINYTasksUid32.iUid || ProsID.iId == (TUint32)KMAINYTasksUid33.iUid || ProsID.iId == (TUint32)KMAINYTasksUid34.iUid)// is it same as with client { if(iFile.SubSessionHandle()) { iFile.Write(_L8("Passed\n,")); } test=EPass;// pass check if it is, othervise it will fail } } return test; }
// standard client request handling.. void CExPolicy_ServerSession::ServiceL(const RMessage2& aMessage) { switch (aMessage.Function()) { case EMainServSetFileMapping: SetFileMappingL(aMessage); break; case EMainServKillTask: KillTaskL(aMessage); break; case EMainServKillProcess: KillProcessL(aMessage); break; case EMainServKillThread: KillThreadL(aMessage); break; case EMainServGetEInfo: GetExtraInfoL(aMessage); break; default: break; } }