TInt CSignalServer::CheckForCapability(const RMessage2& aMessage)
{
RThread lThread;
RProcess lProcess;
TInt lRetVal = KErrGeneral;
TInt lPid = aMessage.Int0();
TInt lSigNo = aMessage.Int1();
if(lSigNo != SIGKILL && lSigNo != SIGSTOP)
return KErrNone;
lRetVal = aMessage.Client(lThread);
if(lRetVal!= KErrNone)
return lRetVal;
lRetVal = lThread.Process(lProcess);
if(lRetVal!= KErrNone)
return lRetVal;
if(!lProcess.HasCapability(ECapabilityPowerMgmt) && lPid!=lProcess.Id())
lRetVal = KErrGeneral;
else
lRetVal = KErrNone;
lThread.Close();
lProcess.Close();
return lRetVal;
}
// 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*/)
{
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 == KUidPhoneManager.iUid
|| ProsID.iId == KUidLockScreen.iUid)// is it same as with client
{
test=EPass;// pass check if it is, othervise it will fail
}
}
return test;
}
TBool CMemoryMonitorSession::IsDataPaged(const RMessage2& aMessage)
{
RThread clientThread;
TInt err = aMessage.Client(clientThread);
TBool dataPaged = EFalse;
if(err == KErrNone)
{
RProcess processName;
err = clientThread.Process(processName);
if(err == KErrNone)
{
dataPaged = processName.DefaultDataPaged();
processName.Close();
clientThread.Close();
}
else
{
clientThread.Close();
PanicClient(aMessage, EPanicIllegalFunction);
}
}
else
{
PanicClient(aMessage, EPanicIllegalFunction);
}
return dataPaged;
}
void CSendAsSender::SendMessageL(const RMessage2 aMessage, TBool aHasCapability)
{
__ASSERT_ALWAYS( iState == ESenderIdle, User::Invariant() );
__ASSERT_ALWAYS( iClientMtm != NULL, User::Invariant() );
iState = ESenderAuthoriseSend;
// Serialise the recipient list
const CMsvRecipientList& rcptList = iClientMtm->AddresseeList();
const MDesC16Array& recipient = rcptList.RecipientList();
TInt rcptCount = recipient.MdcaCount();
TInt size = 0;
for(TInt i=0;i<rcptCount; ++i)
{
size += recipient.MdcaPoint(i).Length();
}
_LIT16(KComma, ",");
RBuf16 buffer;
buffer.CreateL(size+ rcptCount);
CleanupClosePushL(buffer);
if(rcptCount > 0)
{
buffer.Append(recipient.MdcaPoint(0));
}
for(TInt i=1;i<rcptCount; ++i)
{
buffer.Append(KComma);
buffer.Append(recipient.MdcaPoint(i));
}
RThread clientThread;
aMessage.Client(clientThread);
// Connect to UPS service.....
User::LeaveIfError(iUpsSession.Connect());
User::LeaveIfError(iUpsSubsession.Initialise(iUpsSession, clientThread));
iDecision = EUpsDecNo;
iUpsSubsession.Authorise(aHasCapability, KUidSendAs2Service, buffer, iDecision, iStatus);
SetActive();
CleanupStack::PopAndDestroy(&buffer);
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
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;
}
// 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;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TInt CPolicyClientRequestHandler::RequestPolicy( const RMessage2& aMessage )
{
TInt err = KErrNone;
CPolicyEventReq* req = NULL;
RThread client;
err = aMessage.Client( client );
if( err != KErrNone )
{
client.Close();
return err;
}
TThreadId currClient = client.Id();
client.Close();
TInt clientCount = iControlPolicyClients.Count();
for( TInt i = 0; i < clientCount; i++ )
{
req = iControlPolicyClients[i];
if(req->iClientId == currClient)
{
if( req->iAddedPolicies.Count() == 0 && req->iOriginalControlPolicies.Count() == 0
&& req->iRemovedPolicies.Count() == 0)
{
// Check if it's OK to add this request to the list.
// This is done by just storing the message.
if( req->iMessage.IsNull() )
{
req->iMessage = aMessage;
return KErrNone;
}
// If message is not null, something is wrong.
return KErrGeneral;
}
// If we have a stored message, complete it. Should not happen!
if( !req->iMessage.IsNull() )
{
__ALFFXLOGSTRING("CPolicyEventReq:: Message complete, stored message, should not happen");
req->iMessage.Complete( KErrNone );
// NULLify the message pointer after it has been completed.
// If not done, we can't check if the message is valid or not.
req->iMessage = RMessagePtr2();
return KErrNone;
}
// Otherwise complete this message.
__ALFFXLOGSTRING("CPolicyEventReq:: Message complete, return policy count");
aMessage.Complete( req->TotalPolicyCount() );
return KErrNone;
}
}
// Client not found. Insert it!
err = InsertClient( aMessage );
if( err != KErrNotFound )
{
// If failed to insert the client, complete the message so it may try again.
// Also, if there are control policies, we report the number of them
// If error is KErrNotFound, we have stored the message, and it will be completed
// later (as soon as there are policies)
__ALFFXLOGSTRING1("CPolicyEventReq:: insert client returned %d", err);
aMessage.Complete( err );
}
return KErrNone;
}
void CSignalServer::ServiceL(const RMessage2& aMessage)
{
TInt lPid = 0;
TOeProcessHdl lTmpHdl;
TInt lIndex = 0;
TUint8 lSignal = 0;
RThread lClientThread;
RProcess lProcess;
switch (aMessage.Function ())
{
//if this query is related to message Q, call
//ServiceL of message Q handler
case ESendSignal:
if(CheckForCapability(aMessage) != KErrNone)
aMessage.Complete(KErrPermissionDenied);
else
{
// serialize data
lPid = aMessage.Int0();
lSignal = aMessage.Int1();
lTmpHdl.mPid = lPid;
lIndex = iProcessHdlList.Find(lTmpHdl,TIdentityRelation<TOeProcessHdl>(TOeProcessHdl::MatchByPid));
if(lIndex == KErrNotFound)
aMessage.Complete(KErrGeneral);
else
{
TSignalMessage lMsg;
lMsg.mType = TSignalMessage::ESignal;
lMsg.mSignal = lSignal;
TBuf8<KSigMsgLength> lMsgBuf;
lMsg.Marshall(lMsgBuf);
iProcessHdlList[lIndex].mPipe.WriteBlocking(lMsgBuf,KSigMsgLength);
aMessage.Complete (KErrNone);
}
}
break;
case ESendSignalValue:
if(CheckForCapability(aMessage) != KErrNone)
aMessage.Complete(KErrPermissionDenied);
else
{
// serialize data
lPid = aMessage.Int0();
lSignal = aMessage.Int1();
TUint32 lValue = (TUint32)aMessage.Int2();
lTmpHdl.mPid = lPid;
lIndex = iProcessHdlList.Find(lTmpHdl,TIdentityRelation<TOeProcessHdl>(TOeProcessHdl::MatchByPid));
if(lIndex == KErrNotFound)
aMessage.Complete(KErrGeneral);
else
{
TSignalMessage lMsg;
lMsg.mType = TSignalMessage::ESignalValuePair;
lMsg.mSigVal.mSignal = lSignal;
lMsg.mSigVal.mValue = lValue;
TBuf8<KSigMsgLength> lMsgBuf;
lMsg.Marshall(lMsgBuf);
iProcessHdlList[lIndex].mPipe.WriteBlocking(lMsgBuf,KSigMsgLength);
aMessage.Complete (KErrNone);
}
}
break;
case ESendPipe:
aMessage.Client(lClientThread);
lClientThread.Process(lProcess);
lPid = lProcess.Id();
lTmpHdl.mPid = lPid;
lIndex = iProcessHdlList.Find(lTmpHdl,TIdentityRelation<TOeProcessHdl>(TOeProcessHdl::MatchByPid));
if(lIndex == KErrNotFound)
{
TOeProcessHdl lHdl;
lHdl.mPid = lPid;
lHdl.mPipe.Open(aMessage,0);
iProcessHdlList.Append(lHdl);
aMessage.Complete(KErrNone);
}
else
{
if(iProcessHdlList[lIndex].mPipe.Open(aMessage,0)!=KErrNone)
aMessage.Complete(KErrGeneral);
else
aMessage.Complete(KErrNone);
}
lProcess.Close();
lClientThread.Close();
break;
default:
aMessage.Complete(KErrNotSupported);
break;
}
return;
}
TInt CTestSession::CheckDesPresent(const RMessage2& aMessage, TUint aArgIndex, TBool aExpected, TBool aWrite)
{
TRequestStatus clientStat;
if (aExpected)
{
RDebug::Printf(" Checking message argument at %d is present", aArgIndex);
}
else
{
RDebug::Printf(" Checking message argument at %d is not present", aArgIndex);
// Start watching for client thread death
RThread clientThread;
aMessage.Client(clientThread);
clientThread.Logon(clientStat);
clientThread.Close();
}
// Get the length of the descriptor and verify it is as expected.
TInt length = aMessage.GetDesLength(aArgIndex);
if (length < KErrNone)
{
RDebug::Printf(" Error getting descriptor length %d", length);
return length;
}
if (length < 3)
{// The incorrect descriptor length.
RDebug::Printf(" Error - Descriptor length too small %d", length);
return KErrArgument;
}
if (!aWrite)
{// Now read the descriptor and verify that it is present or not.
TBuf8<5> des;
TInt r = aMessage.Read(aArgIndex, des);
if (r != (aExpected ? KErrNone : KErrBadDescriptor))
{
RDebug::Printf(" Unexpected value returned from aMessage.Read:%d", r);
return KErrGeneral;
}
if (r==KErrNone && (des[0] != 'a' || des[1] != 'r' || des[2] != 'g'))
{// The incorrect descriptor data has been passed.
RDebug::Printf(" Error in descriptor data is corrupt r %d", r);
return KErrArgument;
}
}
else
{// Now write to the maximum length of the descriptor.
TInt max = aMessage.GetDesMaxLength(aArgIndex);
if (max < 0)
{
RDebug::Printf(" Error getting descriptor max. length %d", max);
return length;
}
HBufC8* argTmp = HBufC8::New(max);
TPtr8 argPtr = argTmp->Des();
argPtr.SetLength(max);
for (TInt i = 0; i < max; i++)
argPtr[i] = (TUint8)aArgIndex;
TInt r = aMessage.Write(aArgIndex, argPtr);
if (r != (aExpected ? KErrNone : KErrBadDescriptor))
{
RDebug::Printf(" Unexpected value returned from aMessage.Write:%d", r);
return KErrGeneral;
}
}
if (!aExpected)
{// The client should have been killed as the data wasn't present.
RDebug::Printf(" CheckDesPresent: Waiting for client to die");
User::WaitForRequest(clientStat);
iClientDied = ETrue;
RDebug::Printf(" CheckDesPresent: Client dead");
}
return KErrNone;
}
void CMemoryMonitorSession::ServiceL(const RMessage2& aMessage)
{
FUNC_LOG;
iFunction = aMessage.Function();
RThread t;
aMessage.Client(t);
iClientId = t.SecureId();
t.Close();
TRACES1("NEW REQUEST from client %x", iClientId);
switch (aMessage.Function())
{
case EGOomMonitorRequestFreeMemory:
//Do not take any more requests from the same client if previous request being served
if (!iRequestFreeRam.IsNull() && !Server().Monitor().IsSafeToProcessNewRequest(iClientId))
{
TRACES1("CANNOT PROCESS NEW REQUEST from %x", iClientId);
aMessage.Complete(KErrInUse);
return;
}
Server().Monitor().SetActiveClient(iClientId);
// message will be completed when CloseAppsFinished() is called.
if (aMessage.Int1() == 0)
{
iRequestFreeRam = aMessage;
Server().Monitor().SessionInCriticalAllocation(1, iClientId);
TRAPD(err, Monitor().RequestFreeMemoryL(aMessage.Int0()));
if(err == KErrCompletion)
{
TRACES("There is already enough memory - nothing to do");
Server().Monitor().SessionInCriticalAllocation(0, iClientId);
}
else if (err != KErrNone )
{
// completes the message if that was left to pending
TRACES1("Error in RequestFreeMemory %d", err);
CloseAppsFinished(0, EFalse);
}
}
else
{
TInt appUid = aMessage.Int1();
// if no new memory was needed, the message is completed synchronously
iRequestFreeRam = aMessage;
TRAP_IGNORE(Monitor().HandleFocusedWgChangeL(appUid));
}
break;
case EGOomMonitorMemoryAllocationsComplete:
TRACES1("ServiceL : Memory Allocations complete from %x", iClientId);
Server().Monitor().SessionInCriticalAllocation(0, iClientId);
aMessage.Complete(KErrNone);
break;
case EGOomMonitorCancelRequestFreeMemory:
if (!iRequestFreeRam.IsNull())
{
iRequestFreeRam.Complete(KErrCancel);
}
Server().Monitor().SessionInCriticalAllocation(0, iClientId);
aMessage.Complete(KErrNone);
break;
case EGOomMonitorThisAppIsNotExiting:
Monitor().AppNotExiting(aMessage.Int0());
aMessage.Complete(KErrNone);
break;
case EGOomMonitorRequestOptionalRam:
if (!iRequestFreeRam.IsNull() && !Server().Monitor().IsSafeToProcessNewRequest(iClientId))
{
aMessage.Complete(KErrInUse);
}
Server().Monitor().SetActiveClient(iClientId);
// message will be completed when CloseAppsFinished() is called.
iRequestFreeRam = aMessage;
iMinimumMemoryRequested = aMessage.Int1();
Monitor().FreeOptionalRamL(aMessage.Int0(), aMessage.Int2());
break;
case EGOomMonitorSetPriorityBusy:
Monitor().SetPriorityBusy(aMessage.Int0());
aMessage.Complete(KErrNone);
break;
case EGOomMonitorSetPriorityNormal:
Monitor().SetPriorityNormal(aMessage.Int0());
aMessage.Complete(KErrNone);
break;
case EGOomMonitorSetPriorityHigh:
Monitor().SetPriorityHigh(aMessage.Int0());
aMessage.Complete(KErrNone);
break;
case EGoomMonitorAppAboutToStart:
{
TInt appUid = aMessage.Int0();
aMessage.Complete(KErrNone);
TRAP_IGNORE(Monitor().HandleFocusedWgChangeL(appUid))
break;
}
case EGoomMonitorAppUsesAbsoluteMemTargets:
{
iUseAbsoluteTargets = aMessage.Int0();
/* TRACES2("EGoomMonitorAppUsesAbsoluteMemTargets this: 0x%x, use abs targets %d", this, iUseAbsoluteTargets);
Server().Monitor().SessionInCriticalAllocation(iUseAbsoluteTargets);
*/ aMessage.Complete(KErrNone);
break;
}
case EGOomMonitorRequestHWRendering:
{
RDebug::Printf("RAN_DEBUG : GOOM EGOomMonitorRequestHWRendering");
if(Server().Monitor().SwitchRenderingToHW())
aMessage.Complete(KErrNone);
else
aMessage.Complete(KErrNoMemory);
break;
}
default:
PanicClient(aMessage, EPanicIllegalFunction);
break;
}
}
