EXPORT_C void RMobileCall::SetDynamicHscsdParams(TRequestStatus& aReqStatus, TMobileCallAiur aAiur, TInt aRxTimeslots) const
/**
* This method sets new values for the dynamic parameters of a mobile HSCSD call
* It will complete after the phone has requested the new parameters
*
* \param aAiur Wanted air interface user rate
* \param aRxTimeslots Wanted number of receive (downlink) timeslots
*/
{
__ASSERT_ALWAYS(iMmPtrHolder!=NULL,PanicClient(EEtelPanicNullHandle));
iMmPtrHolder->iAiur = aAiur;
TPtrC8& ptr1=iMmPtrHolder->SetC(CMobileCallPtrHolder::ESlot1SetDynamicHscsdParams, iMmPtrHolder->iAiur);
iMmPtrHolder->iRxTimeslots = aRxTimeslots;
TPtrC8& ptr2=iMmPtrHolder->SetC(CMobileCallPtrHolder::ESlot2SetDynamicHscsdParams, iMmPtrHolder->iRxTimeslots);
Set(EMobileCallSetDynamicHscsdParams,aReqStatus,ptr1,ptr2);
}
/**
Returns the character that corresponds to the value of its parameter
(base 17!).
@param aDigit an integer between 0 and 16.
@return A TChar representing one of '0' to '9' or 'A' to 'G'.
@internalComponent
@released
*/
TChar RMobileSmartCardEap::SeptChar(TInt aDigit)
{
TChar ret(0);
if ((aDigit < 0) || (aDigit > 16))
{
PanicClient(EEtelPanicHandleNotOpen);
}
else
{
if (aDigit < 10)
{
ret = aDigit + (TUint)'0';
}
else
{
ret = aDigit - 10 + (TUint)'A';
}
}
return ret;
}
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;
}
TInt CMdSServer::RunError( TInt aError )
{
__LOG1( ELogAlways, "Server::RunError %d", aError );
if ( aError == KErrBadDescriptor )
{
// A bad descriptor error implies a badly programmed client,
// so panic it; otherwise report the error to the client
PanicClient( Message(), KErrBadDescriptor );
}
else
{
Message().Complete( aError );
}
// The leave will result in an early return from CServer::RunL(), skipping
// the call to request another message. So do that now in order to keep the
// server running.
ReStart();
return KErrNone; // Handled the error fully
}
/**
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;
}
}
void CVwsSession::AddViewL(const RMessage2& aMessage)
{
TVwsViewId viewId(ViewIdFromMessageL(aMessage));
if (iAppUid.iUid==0)
{
iAppUid.iUid=viewId.iAppUid.iUid;
#ifdef __DO_LOGGING__
TBuf<64> queueName;
queueName.Format(_L("Session Queue for \"%x\""),iAppUid.iUid);
iEventQueue->SetName(queueName);
#endif
}
else if (iAppUid!=viewId.iAppUid)
{
// All views added by the same client should have the same app uid.
PanicClient(aMessage,EVwsInvalidViewUid);
}
LOG4(CVwsLog::ENormal,_L("Adding view \"%x,%x\""),viewId.iAppUid.iUid,viewId.iViewUid.iUid);
AddViewL(viewId);
}
/**
The authentication status is obtained from the EAP supporting UICC
application's EF_EAPSTATUS. It specifies the current state of
authentication in the DF_EAP.
@param aReqStatus Returns the result code after the asynchronous call
completes.
@param aAuthStatus On request completion, will store the current
authentication status of the DF_EAP.
@capability ReadDeviceData
@publishedPartner
@released
*/
EXPORT_C void RMobileSmartCardEap::GetAuthenticationStatus(TRequestStatus& aReqStatus, TEapAuthStatus& aAuthStatus)
{
__ASSERT_ALWAYS(iMmPtrHolder != NULL, PanicClient(EEtelPanicNullHandle));
if (iSemaphore.Handle() == 0)
{
TRequestStatus* status1 = &aReqStatus;
User::RequestComplete(status1, KErrBadHandle);
return;
}
if (!iOwnsEapMethodLock)
{
TRequestStatus* status2 = &aReqStatus;
User::RequestComplete(status2, KErrInUse);
return;
}
TPtr8& ptr1 = iMmPtrHolder->Set(CMobileSmartCardEapPtrHolder::ESlot1GetAuthStatus, aAuthStatus);
Get(EMobileSmartCardEapGetAuthenticationStatus, aReqStatus, ptr1);
}
/**
Retrieves the generated key stored in EF_EAPKEYS of the DF_EAP (see
section 7.1 of ETSI TS 102.310 v6.2.0).
@param aReqStatus Returns the result code after the asynchronous call
completes.
@param aRequestedKey Used to specify which of the keys the client is
requesting.
@param aKey Populated with the requested key on request completion.
@capability ReadDeviceData
@publishedPartner
@released
*/
EXPORT_C void RMobileSmartCardEap::GetEapKey(TRequestStatus& aReqStatus, const TEapKeyTag aRequestedKey, TDes8& aKey)
{
__ASSERT_ALWAYS(iMmPtrHolder != NULL, PanicClient(EEtelPanicNullHandle));
if (iSemaphore.Handle() == 0)
{
TRequestStatus* status1 = &aReqStatus;
User::RequestComplete(status1, KErrBadHandle);
return;
}
if (!iOwnsEapMethodLock)
{
TRequestStatus* status2 = &aReqStatus;
User::RequestComplete(status2, KErrInUse);
return;
}
iMmPtrHolder->iReqEapKeyTag = aRequestedKey;
TPtrC8& ptr1 = iMmPtrHolder->SetC(CMobileSmartCardEapPtrHolder::ESlot1GetEapKey, iMmPtrHolder->iReqEapKeyTag);
SetAndGet(EMobileSmartCardEapGetEapKey, aReqStatus, ptr1, aKey);
}
/**
Auxiliary function for TestCaseID TAppLangFrenchSTARTER-doTestStepL
This method services the client requests to the message server.
The opcode is checked and does approprate servicing by invoking methods
SetFromStringL() and SetErrorFromStringL().
*/
void CMessageServSession3::DispatchMessageL(const RMessage2 &aMessage)
{
switch (aMessage.Function())
{
case EMessageServSetFromString3:
SetFromStringL(aMessage);
return;
case EMessageServSetErrorFromString3:
SetErrorFromStringL(aMessage);
return;
case EMessageServStop3:
{
CActiveScheduler::Stop();
iMsgSvr->iStep->iMessage->RequestForTheMessageOutput(STOP_SERVER_CODE);
return;
}
// requests we don't understand at all are a different thing,
// so panic the client here, this function also completes the message
default:
PanicClient(EBadRequest3);
return;
}
}
void CVwsSession::ServiceL(const RMessage2& aMessage)
{
TBool completeMessage=ETrue;
switch (aMessage.Function())
{
case EVwsAsynchronousMessageForServerToPanicClientWith:
iPanicMessage=aMessage;
completeMessage=EFalse;
break;
case EVwsClose:
CActiveScheduler::Stop();
break;
case EVwsAddView:
AddViewL(aMessage);
break;
case EVwsSetSystemDefaultView:
SetSystemDefaultViewL(aMessage);
break;
case EVwsGetSystemDefaultView:
GetSystemDefaultViewL(aMessage);
break;
case EVwsRemoveView:
RemoveViewL(aMessage);
break;
case EVwsRequestViewEvent:
RequestViewEventL(aMessage);
completeMessage=EFalse;
break;
case EVwsRequestViewEventCancel:
CancelRequestViewEvent();
break;
case EVwsActivateView:
ActivateViewL(aMessage,ECompleteRequest);
completeMessage=EFalse;
break;
case EVwsCreateActivateViewEvent:
ActivateViewL(aMessage,EDoNotCompleteRequest);
break;
case EVwsRequestCustomMessage:
RequestCustomMessageL(aMessage);
break;
case EVwsStartApp:
StartAppL(aMessage);
completeMessage=EFalse;
break;
case EVwsDeactivateActiveView:
DeactivateActiveViewL(aMessage,ECompleteRequest);
completeMessage=EFalse;
break;
case EVwsDeactivateActiveViewIfOwnerMatch:
DeactivateActiveViewIfOwnerMatchL(aMessage,ECompleteRequest);
completeMessage=EFalse;
break;
case EVwsCreateDeactivateViewEvent:
DeactivateActiveViewL(aMessage,EDoNotCompleteRequest);
break;
case EVwsNotifyNextDeactivation:
NotifyNextDeactivationL(aMessage);
break;
case EVwsNotifyNextActivation:
NotifyNextActivationL(aMessage);
break;
case EVwsSetClientRequestTimeOut:
SetClientRequestTimeOut(aMessage);
break;
case EVwsSetServerEventTimeOut:
SetServerEventTimeOut(aMessage);
break;
case EVwsEnableServerEventTimeOut:
EnableServerEventTimeOut(aMessage);
break;
case EVwsCheckSourceOfViewSwitch:
CheckSourceOfViewSwitchL(aMessage);
break;
case EVwsPriority:
GetPriorityForActiveObjectL(aMessage);
break;
case EVwsEnableServerBlankScreen:
EnableServerBlankScreen(aMessage);
break;
case EVwsSetProtected:
SetProtectedL(aMessage);
break;
case EVwsSetCrossCheckUid:
iServer.SetCrossCheckUid(aMessage);
break;
case EVwsSetWindowBackgroundColor:
iServer.SetWindowBackgroundColor(aMessage);
break;
case EVwsCurrentActiveViewId:
GetCurrentActiveViewIdL(aMessage);
break;
default:
PanicClient(aMessage,EVwsBadRequest);
}
if (completeMessage && !aMessage.IsNull())
{
LOG3(CVwsLog::ENormal,_L("Auto completing with %d"),KErrNone);
aMessage.Complete(KErrNone);
}
}
// void CBrdSession::ServiceL(const RMessage& aMessage)
void CBrdSession::ServiceL(const RMessage2& aMessage)
{
CBrdServer *server = (CBrdServer*)Server();
switch (aMessage.Function())
{
case EAnvlPrintInt:
server->iControl->WriteText(_L("int=%d\n"), aMessage.Int0());
aMessage.Complete(KErrNone);
break;
case EAnvlPrintStr:
{
TInt desLen = aMessage.GetDesLength(0);
HBufC8* buf=HBufC8::NewL(desLen);
TPtr8 bufPtr = buf->Des();
// Message().ReadL(desPtr,bufPtr);
aMessage.ReadL(0,bufPtr);
PrintStr(bufPtr);
aMessage.Complete(KErrNone);
delete buf;
buf = NULL;
}
break;
case EAnvlPrintfStr:
{
TInt desLen = aMessage.GetDesLength(0);
HBufC8* buf=HBufC8::NewL(desLen);
CleanupStack::PushL(buf);
TPtr8 bufPtr = buf->Des();
// Message().ReadL(desPtr,bufPtr);
aMessage.ReadL(0,bufPtr);
desLen = aMessage.GetDesLength(1);
HBufC8* buf2=HBufC8::NewL(desLen);
CleanupStack::PushL(buf2);
TPtr8 bufPtr2 = buf2->Des();
// Message().ReadL(desPtr,bufPtr2);
aMessage.ReadL(0,bufPtr2);
PrintfStr(bufPtr, bufPtr2);
aMessage.Complete(KErrNone);
CleanupStack::Pop();
CleanupStack::Pop();
delete buf;
buf = NULL;
delete buf2;
buf2 = NULL;
}
break;
case EAnvlPrintfInt:
{
TInt desLen = aMessage.GetDesLength(0);
HBufC8* buf=HBufC8::NewL(desLen);
TPtr8 bufPtr = buf->Des();
// Message().ReadL(desPtr,bufPtr);
aMessage.ReadL(0,bufPtr);
PrintfInt(bufPtr, aMessage.Int1());
aMessage.Complete(KErrNone);
delete buf;
buf = NULL;
}
break;
case EAnvlNumberOfSessions:
aMessage.Complete(server->NumberOfSessions());
break;
default:
PanicClient(EPanicUnknownFunction);
break;
}
}
void CVwsSession::PanicClient(TInt aPanic)
{
__ASSERT_DEBUG(aPanic!=0,User::Invariant());
PanicClient(iPanicMessage,aPanic);
}
void CSessionWriterSession::ServiceL(const RMessage2 &aMessage)
{
TInt res = KErrNone;
TBool handled = ETrue;
switch (aMessage.Function())
{
case ERegisterForLogMessages:
{
if (iSessionWriter)
{
// We're already registered
res = KErrAlreadyExists;
break;
}
CSessionWriter* writer = Server().CloggerServer().RegisterSessionWithSessionWriter(this);
if (!writer)
{
// Only one session can be registered at once, and some other session is
res = KErrInUse;
break;
}
iSessionWriter = writer;
RChunk& bufChunk = Server().CloggerServer().GetBufChunk();
aMessage.Complete(bufChunk);
return; // As we've handled it ourself
}
case EGetNextLog:
{
if (!iSessionWriterMessage.IsNull())
{
res = KErrAlreadyExists;
break;
}
if (!iSessionWriter)
{
PanicClient(aMessage, ENotRegisteredForLogs);
return;
}
iClientSharedChunkBase = (TAny*)aMessage.Ptr1();
iSessionWriter->SetEnabled(ETrue);
iSessionWriterMessage = aMessage;
if (iWaitingForClient)
{
iWaitingForClient = EFalse;
iSessionWriter->Completed();
}
return; // Don't want to complete this yet!
}
case ECancelGetNextLog:
if (iSessionWriter)
{
iSessionWriter->SetEnabled(EFalse);
}
if (!iSessionWriterMessage.IsNull())
{
iSessionWriterMessage.Complete(KErrCancel);
}
break;
default:
handled = EFalse;
}
if (handled)
{
aMessage.Complete(res);
}
else
{
PanicClient(aMessage, EPanicIllegalFunction);
}
}
void CTestUtilSessionSwi::ServiceL(const RMessage2& aMessage)
{
switch (aMessage.Function())
{
case ECopy:
{
HBufC* source = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
HBufC* destination = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,1);
TInt err = Server().FileMan().Copy(*source, *destination, CFileMan::ERecurse | CFileMan::EOverWrite);
if (err == KErrNone)
{
// Turn off the read only attributes
TTime time(0); // must specify 0, or a valid time, otherwise sets time to a random value and causes -6/-21 errors
err = Server().FileMan().Attribs(*destination, 0, KEntryAttReadOnly, time, CFileMan::ERecurse);
}
CleanupStack::PopAndDestroy(destination);
CleanupStack::PopAndDestroy(source);
aMessage.Complete(err);
break;
}
case EMove:
{
HBufC* source = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
HBufC* destination = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,1);
TInt err = Server().FS().Rename(*source,*destination);
if (err == KErrNone)
{
// Turn off the read only attributes
TTime time(0); // must specify 0, or a valid time, otherwise sets time to a random value and causes -6/-21 errors
err = Server().FileMan().Attribs(*destination, 0, KEntryAttReadOnly, time, CFileMan::ERecurse);
}
CleanupStack::PopAndDestroy(destination);
CleanupStack::PopAndDestroy(source);
aMessage.Complete(err);
break;
}
case EDelete:
{
HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
TEntry entry;
TInt err = Server().FS().Entry(*fileName, entry);
if (err == KErrNone)
{
if (entry.IsDir())
{
TPath pathName(*fileName);
if (pathName[pathName.Length() - 1] != KPathDelimiter)
{
pathName.Append(KPathDelimiter);
}
err = Server().FileMan().RmDir(pathName);
}
else
{
err = Server().FS().Delete(*fileName);
}
}
CleanupStack::PopAndDestroy(fileName);
aMessage.Complete(err);
break;
}
case ERmDir:
{
HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
TParsePtrC parsePtr(*fileName);
if(parsePtr.IsRoot())
{
User::Leave(KErrAccessDenied);
}
TInt err = Server().FileMan().RmDir(*fileName);
CleanupStack::PopAndDestroy(fileName);
aMessage.Complete(err);
break;
}
case EMkDirAll:
{
HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
TInt err = Server().FS().MkDirAll(*fileName);
CleanupStack::PopAndDestroy(fileName);
aMessage.Complete(err);
break;
}
case EFileExists:
{
delete iDetector;
iDetector=CTestFileDetector::NewL(aMessage,
Server().FS());
iDetector->DetectFile();
break;
}
case ELock:
{
HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
RFile lockFile;
TInt err = lockFile.Open(Server().FS(), *fileName, EFileWrite);
if (err == KErrNone)
iLockedFileHandles.Append(lockFile);
CleanupStack::PopAndDestroy(fileName);
aMessage.Complete(err);
break;
}
case EUnlock:
{
HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
TInt err = KErrNotFound;
TFileName lockedFileName;
for (TInt i = 0; i < iLockedFileHandles.Count() && err;i++)
{
TInt err2 = iLockedFileHandles[i].FullName(lockedFileName);
User::LeaveIfError(err2);
if (lockedFileName.MatchF(*fileName) != KErrNotFound)
{
iLockedFileHandles[i].Close();
iLockedFileHandles.Remove(i);
err = KErrNone;
}
}
CleanupStack::PopAndDestroy(fileName);
aMessage.Complete(err);
break;
}
case EFormat:
{
TInt drive = aMessage.Int0();
TBool formatFatOnly = aMessage.Int1();
TChar aDriveChar;
User::LeaveIfError(Server().FS().DriveToChar(drive, aDriveChar));
TBuf<3> bfDrv;
bfDrv.Append(aDriveChar);
bfDrv.Append(KBP);
RFormat format;
TInt count;
User::LeaveIfError(format.Open(Server().FS(), bfDrv, EHighDensity, count));
CleanupClosePushL(format);
if (formatFatOnly)
{
User::LeaveIfError(format.Next(count));
}
else
{
while (count > 0)
{
User::LeaveIfError(format.Next(count));
}
}
CleanupStack::PopAndDestroy(&format);
aMessage.Complete(KErrNone);
break;
}
case EMount:
{
TInt drive = aMessage.Int0();
User::LeaveIfError(Server().FS().Connect());
//Mount the drive synchronizely to make sure the drive is ready for the next operation
User::LeaveIfError(Server().FS().MountFileSystem(KFAT, drive, ETrue));
aMessage.Complete(KErrNone);
break;
}
case EUnMount:
{
TInt drive = aMessage.Int0();
TFileName fsName;
User::LeaveIfError(Server().FS().FileSystemName(fsName, drive));
User::LeaveIfError(Server().FS().DismountFileSystem(fsName, drive));
aMessage.Complete(KErrNone);
break;
}
case ESetReadOnly:
{
HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
TInt setReadOnly = aMessage.Int1();
TUint setmask;
TUint clearmask;
if (setReadOnly)
{
// Setting read only attribute
setmask = KEntryAttReadOnly;
clearmask = 0;
}
else
{
// Clearing read only attribute
setmask = 0;
clearmask = KEntryAttReadOnly;
}
// Turn off the read only attributes
TTime time(0);
TInt err = Server().FileMan().Attribs(*fileName, setmask, clearmask, time);
CleanupStack::PopAndDestroy(fileName);
aMessage.Complete(err);
break;
}
case EGetFileHandle:
{
HBufC* fileName = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
RFile file;
CleanupClosePushL(file);
User::LeaveIfError(file.Open(Server().FS(), *fileName, EFileRead | EFileShareReadersOnly));
User::LeaveIfError(file.TransferToClient(aMessage, 1));
CleanupStack::PopAndDestroy(2, fileName); // file
break;
}
case EWatchFile:
{
if (iFileWatcher)
{
if (iFileWatcher->IsActive())
{
aMessage.Complete(KErrServerBusy);
break;
}
else
{
delete iFileWatcher;
iFileWatcher = NULL;
}
}
// Create a new file watcher for this session
iFileWatcher = CFileWatcher::NewL(Server().FS(), aMessage);
break;
}
case EWatchFileCancel:
{
if (iFileWatcher)
{
iFileWatcher->Cancel();
aMessage.Complete(KErrNone);
}
else
{
// No file watch request to cancel!
aMessage.Complete(KErrNotReady);
}
break;
}
case EGetNumFiles:
{
HBufC* dirPath = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
CDir* dirContents = NULL;
User::LeaveIfError(Server().FS().GetDir(*dirPath, KEntryAttNormal, ESortNone, dirContents));
TPckg<TInt> numFiles(dirContents->Count());
delete dirContents;
aMessage.WriteL(1, numFiles);
aMessage.Complete(KErrNone);
CleanupStack::PopAndDestroy(dirPath);
break;
}
case ERegenerateCache:
{
#ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
Swi::RSisRegistryWritableSession session;
User::LeaveIfError(session.Connect());
CleanupClosePushL(session);
session.RegenerateCacheL();
CleanupStack::PopAndDestroy(&session);
aMessage.Complete(KErrNone);
#else
aMessage.Complete(KErrNotSupported);
#endif
break;
}
case EGetFileHash:
{
HBufC* fileNameA = CTestUtilSessionCommon::AllocateInputBufferLC(aMessage,0);
CMessageDigest* digest = CalculateFileHashLC(*fileNameA);
aMessage.WriteL(1, digest->Final());
aMessage.Complete(KErrNone);
CleanupStack::PopAndDestroy(2, fileNameA);
break;
}
default:
{
PanicClient(aMessage,EPanicIllegalFunction);
break;
}
}
}
void CTestUtilSessionSwi::ServiceError(const RMessage2& aMessage,TInt aError)
{
if (aError==KErrBadDescriptor)
PanicClient(aMessage,EPanicBadDescriptor);
CSession2::ServiceError(aMessage,aError);
}
void CCommSession::ServiceL(const RMessage2& aMessage)
/**
* Handle messages for this session.
*
* @param aMessage handle to the IPC message from the client
*/
{
C32LOG5(KC32Detail,_L8("CCommSession::ServiceL(), Session : 0x%x, IPC: %d (%S). Message: %08x"), this, aMessage.Function(), &TC32Log::C32RequestStr(aMessage.Function()),aMessage.Handle());
iComplete = ETrue;
const CC32WorkerThread& owner=C32WorkerThread();
CC32Dealer& c32Dealer = owner.DealerByRef();
if (c32Dealer.StartupFailed())
{
SafeComplete(aMessage, KErrNotReady);
return;
}
// TestImmediateShutdownPresent is only set when EImmediate shutdown is present, which is
// used only in testing phase.
if(c32Dealer.TestImmediateShutdownPresent())
{
User::Leave(KErrServerTerminated);
}
if((aMessage.Function()==ECommOpen)
||
(aMessage.Function()==ECommOpenWhenAvailable))
{
NewPortL(aMessage);
return;
}
#if defined (_DEBUG)
switch (aMessage.Function())
{
case ECommDbgMarkHeap:
__UHEAP_MARK;
SafeComplete(aMessage, KErrNone);
return;
case ECommDbgCheckHeap:
__UHEAP_CHECK(aMessage.Int0());
SafeComplete(aMessage, KErrNone);
return;
case ECommDbgMarkEnd:
__UHEAP_MARKENDC(aMessage.Int0());
SafeComplete(aMessage, KErrNone);
return;
case ECommDbgFailNext:
// We set the fail point for all heaps, rather than just the current Dealer. This could lead to a failure not related
// directly to whatever the client test code is trying to exercise but it all helps find bugs
c32Dealer.SetFailNextForAllHeaps(aMessage.Int0());
SafeComplete(aMessage, KErrNone);
return;
}
#endif
switch ((aMessage.Function()))
{
case ECommLoadCommModule:
{
TFileName fullCSYFilename;
TInt ret = Read(0,aMessage,fullCSYFilename);
if (ret != KErrNone)
{
C32LOG2(KC32Warning, _L8("ServiceL: LoadCommModule Read returned %d instead of KErrNone, cannot proceed"), ret);
PanicClient(EBadDescriptor,aMessage);
return;
}
ret = AddCSYExtension(fullCSYFilename,aMessage);
if(ret != KErrNone)
{
C32LOG2(KC32Warning, _L8("ServiceL: LoadCommModule AddCSYExtension returned %d instead of KErrNone, cannot proceed"), ret);
return;
}
CommsFW::TWorkerId worker;
TBuf8<KMaxFileName> fileName8;
fileName8.Copy(fullCSYFilename);
TBool found = iThreadManager->FindThreadByFileName(fileName8, worker);
if(!found)
{
worker = iThreadManager->iDefaultThreadIndex;
}
if(c32Dealer.WorkerExists(worker))
{
LoadCommModuleL(aMessage,worker,!found,fullCSYFilename);
}
else
{
C32LOG2(KC32Dealer,_L8("ServiceL: LoadCommModule requires worker %d. This worker does not exist so starting"),worker);
ret = c32Dealer.LoadCPMOnLoadCommModule(worker);
if ((ret!=KErrNone) && (ret!=KErrInUse))
{
// only likely return codes here are KErrNoMemory or KErrNotFound if
// the RS server could not be found - which means system is probably in pretty bad state (ie, no memory)
// luckily at this point there isn't anything to clean up!
SafeComplete(aMessage,ret);
}
else
{
ret = c32Dealer.ParkRequest(this, aMessage);
if(ret != KErrNone)
{
SafeComplete(aMessage, ret);
}
}
}
return;
}
case ECommCloseCommModule:
CloseCommModuleL(aMessage);
return;
case ECommPortInfoByName:
{
TPortName name;
TInt ret = Read(1,aMessage,name);
if (ret != KErrNone)
{
C32LOG2(KC32Warning, _L8("ServiceL: LoadCommModule Read returned %d instead of KErrNone, cannot proceed"), ret);
PanicClient(EBadDescriptor,aMessage);
return;
}
PortInfoL(aMessage,name);
return;
}
case ECommPortInfoByNumber: // original msg is not forwarded as global as aMessage.Int2() is not valid in player, instead CSerial* is wrapped in TC32PlayerGetPortInfoMsg
PortInfo(aMessage,aMessage.Int2());
return;
case ECommNumPorts: // get information from ThreadManager in dealer
NumPorts(aMessage);
return;
case ECommStartServerThread: // KErrNotSupported
C32LOG2(KC32Dealer, _L8("WARNING: deprecated function ECommStartServerThread called, CCommSession(%08x)"), this);
SafeComplete(aMessage, KErrNotSupported);
return;
}
// obtain subsession* from aMessage.Int3()
CCommSubSession *p = SubSessionFromHandle(aMessage.Int3(), CCommSubSession::ECPort);
if (aMessage.Function()==ECommClose)
{
if (p==NULL) // not a valid aMessage.Int3()
{
SafeComplete(aMessage, KErrBadHandle);
return;
}
else
{
CloseSubSessionL(aMessage, CCommSubSession::ECPort);
return;
}
}
if (p==NULL) // not a valid aMessage.Int3()
{
PanicClient(EBadCommHandle, aMessage);
return;
}
// Its OK to proceed with the dispatch of other requests
switch (aMessage.Function())
{
case ECommRead:
case ECommReadCancel:
case ECommQueryReceiveBuffer:
case ECommResetBuffers:
case ECommWrite:
case ECommWriteCancel:
case ECommBreak:
case ECommBreakCancel:
case ECommCancel:
case ECommConfig:
case ECommSetConfig:
case ECommCaps:
case ECommSetMode:
case ECommGetMode:
case ECommSignals:
case ECommSetSignalsToMark:
case ECommSetSignalsToSpace:
case ECommReceiveBufferLength:
case ECommSetReceiveBufferLength:
case ECommSetAccess:
case ECommOpenWhenAvailableCancel:
#ifdef _DEBUG
case ECommDebugState:
#endif
// Extensions to the CCommSession starts from here
case ECommNotifySignals:
case ECommNotifyFlowControl:
case ECommNotifySignalsCancel:
case ECommNotifyFlowControlCancel:
case ECommGetFlowControl:
case ECommNotifyConfigChange:
case ECommNotifyConfigChangeCancel:
case ECommNotifyBreak:
case ECommNotifyBreakCancel:
case ECommGetRole:
case ECommNotifyDataAvailable:
case ECommNotifyDataAvailableCancel:
case ECommNotifyOutputEmpty:
case ECommNotifyOutputEmptyCancel:
ForwardMessageL(aMessage, *p);
break;
// Extensions to the CCommSession ends to here
default:
SafeComplete(aMessage, KErrNotSupported);
break;
}
C32LOG(KC32Detail,_L8("CCommSession::ServiceL() end"));
}
// ---------------------------------------------------------
// CDownloadMgrSession::DispatchMessageL
// ---------------------------------------------------------
//
void CDownloadMgrSession::DispatchMessageL( const RMessage2& aMessage )
{
CLOG_ENTERFN( "CDownloadMgrSession::DispatchMessageL" )
CLOG_WRITE_FORMAT( "Message function: %d", aMessage.Function() )
// Set this false in case of the asyncron requests!!!
iComplete = ETrue;
SetCurrentMessage( aMessage );
// Fixed for Bug id - JJUN-78WCJ3 (DownloadMgrServer crashes under IPC attack)
//This check will make sure that before start of any download, InitializeL() should
// be called so that all the member variables will be initialized.
if(aMessage.Function() != EHttpDownloadMgrInitialize && iClientAppInstance == NULL)
{
User::Leave(KErrGeneral);
}
// check for session-relative requests
switch( aMessage.Function() )
{
case EHttpDownloadMgrInitialize:
{
InitializeL();
return;
}
case EHttpDownloadMgrCreateDownload:
{
NewDownloadL();
return;
}
case EHttpDownloadMgrAttach:
{
DownloadMgrAttachL();
return;
}
case EHttpDownloadAttach:
{
DownloadAttachL();
return;
}
case EHttpDownloadAttachToDownload:
{
AttachToDownloadL();
return;
}
case EHttpDownloadMgrPauseAll:
{
PauseAllL();
return;
}
case EHttpDownloadMgrStartAllL:
{
StartAllL();
return;
}
case EHttpDownloadMgrResetAll:
{
ResetAll();
return;
}
case EHttpDownloadMgrDeleteAll:
{
DeleteAll();
return;
}
case EHttpDownloadMgrDisconnect:
{
Disconnect();
return;
}
case EHttpDownloadMgrGetIntAttribute:
{
GetIntAttributeL();
return;
}
case EHttpDownloadMgrGetBoolAttribute:
{
GetBoolAttributeL();
return;
}
case EHttpDownloadMgrGetStringAttribute:
{
GetStringAttributeL();
return;
}
case EHttpDownloadMgrGetString8Attribute:
{
GetString8AttributeL();
return;
}
case EHttpDownloadMgrSetIntAttribute:
{
SetIntAttributeL();
return;
}
case EHttpDownloadMgrSetBoolAttribute:
{
SetBoolAttributeL();
return;
}
case EHttpDownloadMgrSetStringAttribute:
{
SetStringAttributeL();
return;
}
case EHttpDownloadMgrSetString8Attribute:
{
SetString8AttributeL();
return;
}
case EHttpDownloadMgrSessionEventSubscription:
{
InitSessionEvent( aMessage );
// Send event from the queue
TUint dummy( 0 );
Event( NULL, (THttpDownloadState)dummy, (THttpProgressState)dummy, dummy );
// This is an asyncron request will be completed later!
SetComplete( EFalse );
return;
}
case EHttpDownloadMgrSessionEventCancel:
{
CancelMovedEvent();
return;
}
}
// ok, it must be subsession relative
CDownloadSubSession* download = DownloadFromHandle( aMessage.Int3() );
__ASSERT_DEBUG( download, PanicClient( EBadSubsessionHandle ) );
TRAPD( err, download->DispatchMessageL( aMessage ) );
if( err )
{
download->OnError( err );
User::Leave( err );
}
}
EXPORT_C void RMobileCall::ConstructL()
{
RCall::ConstructL();
__ASSERT_ALWAYS(iMmPtrHolder==NULL,PanicClient(EEtelPanicHandleNotClosed));
iMmPtrHolder = CMobileCallPtrHolder::NewL(CMobileCallPtrHolder::EMaxNumberCallPtrSlots,CMobileCallPtrHolder::EMaxNumberCallPtrCSlots);
}
TInt ParseMixedBinaryAsciiDataL(TDes8& aTextToConvert)
/**
Parses aTextToConvert based on the following rules:
'\\' (double backslash) is used to denote a single '\'
(single backslash)
'\xnn' denote a byte of binary data where nn is in hex-decimal.
The '\xnn' in aTextToConvert is replaced by the binary byte
that it represents.
For example: If aTextToConvert contains "abc\\def\xFF",
after parsing, it will contain "abc\def?" where ? = 0xFF.
@param aTextToConvert Modifiable buffer which will be parsed.
@return KErrNone if aTextToConvert is in valid
EAdditionalParamDataFormatMixedBinaryAndAscii format.
KErrArgument if aTextToConvert is in an incorrect format.
@panic KErrNoMemory if there is not enough memory to do the parsing.
*/
{
// Pointer to unparsed portion of additionalParamDataBuffer
HBufC8* resultBuffer = HBufC8::NewLC(aTextToConvert.Length());
__ASSERT_ALWAYS(resultBuffer, PanicClient(KErrNoMemory));
TPtr8 result(resultBuffer->Des());
// Position of backslash
TInt pos = 0;
while ((pos = aTextToConvert.Locate('\\')) != KErrNotFound)
{
// Check that the backslash is followed by at least one more character
if ((pos+1) >= aTextToConvert.Length())
{
return KErrArgument;
}
TUint8 modifier = aTextToConvert[pos+1];
// Parse depending on character after the backslash
switch (modifier)
{
case '\\':
// Next character after the '\' is another '\'.
// Replace it with a single '\' and move
// on.
result.Append(aTextToConvert.Left(pos+1));
aTextToConvert.Delete(0, pos+2);
break;
case 'x':
// Next character is an 'x' so check that there are three
// characters after the backslash (one for the x and two
// characters of HEX.
if ((pos+3) >= aTextToConvert.Length())
{
return KErrArgument;
}
// Convert those to HEX and replace '\xNN' with this.
result.Append(aTextToConvert.Left(pos));
TUint8 hexAsInt;
if (AsciiHexToNum(aTextToConvert.MidTPtr(pos+2,2), hexAsInt) != KErrNone)
{
return KErrArgument;
}
// Append the raw byte to the result
result.SetLength(result.Length()+1);
result[result.Length()-1] = hexAsInt;
aTextToConvert.Delete(0, pos+4);
break;
}
} // End while
aTextToConvert.Insert(0, result);
CleanupStack::PopAndDestroy(resultBuffer);
return KErrNone;
}
/**
Handle an error from CEglContentSession::ServiceL()
*/
void CEglContentSession::ServiceError(const RMessage2& aMessage, TInt aError)
{
if(aError == KErrBadDescriptor)
PanicClient(aMessage, EPanicBadDescriptor);
CSession2::ServiceError(aMessage, aError);
}
void CBTControllerServerSession::ServiceL( const RMessage2& aMessage )
{
RDebug::Print(_L("CBTControllerServerSession::ServiceL: %d"), aMessage.Function());
if(aMessage.Function() != ECancelAll)
iLastFunction = (TServerMessage)aMessage.Function();
switch(aMessage.Function())
{
case EStartServer:
{
iMessage = aMessage;
ControllerStart();
}break;
case EStopServer:
{
iMessage = aMessage;
ControllerStop();
}break;
case EFindAndConnect:
{
iMessage = aMessage;
ControllerDiscover(TControllerDataTypes::ERemoteTypeWii);
}break;
case EDisconnect:
{
iMessage = aMessage;
iController.DisconnectDevice();
iMessage.Complete(KErrNone);
}break;
case ESwitchPowerOn:
{
iMessage = aMessage;
SwitchOnPower();
}break;
case ELoadKeyConfig:
{
iMessage = aMessage;
iKeyConfigName.Zero();
iMessage.ReadL(0,iKeyConfigName);
LoadKeyConfig(iKeyConfigName);
}break;
case EGetCurrentConfig:
{
iMessage = aMessage;
GetCurrentConfigName();
}break;
case EControllerType:
{
iMessage = aMessage;
GetControllerType();
}break;
case EBatteryStatus:
{
iMessage = aMessage;
GetBatteryStatus();
}break;
case EWiiSpeakerEnabled:
{
iMessage = aMessage;
GetWiiSpeakerStatus();
}break;
case ESetWiiSpeakerEnabled:
{
iMessage = aMessage;
TControllerDataTypes::TWiiSpeaker spk;
TPtr8 desc(reinterpret_cast<TUint8*>(&spk),sizeof(spk),sizeof(spk));
iMessage.ReadL(0,desc);
SetWiiSpeakerStatus(spk);
}break;
case ESetAccelerometerState:
{
iMessage = aMessage;
TBool state;
TPtr8 desc(reinterpret_cast<TUint8*>(&state),sizeof(state),sizeof(state));
iMessage.ReadL(0,desc);
EnableWiiAcc(state);
}break;
case ECancelAll:
{
switch(iLastFunction)
{
case EDiscoverController:
{
iController.CancelDiscovery();
}break;
default:
break;
}
if(!iMessage.IsNull())
{
iMessage.Complete(KErrCancel);
}
if(!aMessage.IsNull())
{
if(aMessage != iMessage)
aMessage.Complete(KErrCancel);
}
iLastFunction = ECancelAll;
}break;
case ELoadConfigByUid:
{
iMessage = aMessage;
TBool load;
TPtr8 desc(reinterpret_cast<TUint8*>(&load),sizeof(load),sizeof(load));
iMessage.ReadL(0,desc);
SetLoadByUid(load);
}break;
default:
{
iMessage = aMessage;
PanicClient(iMessage,KErrNotSupported);
}break;
}
}
// ---------------------------------------------------------------------------
// CCmMdhSession::ServiceL
// Implements CSession2 -derived ServiceL -method.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CCmMdhSession::ServiceL(const RMessage2& aMessage)
{
LOG(_L("[CmMdh Server]\t CCmMdhSession::ServiceL"));
switch ( aMessage.Function() )
{
case ECmMdhSearchMediaservers:
{
LOG(_L("[CmMdh Server]\t ECmMdhSearchMediaServers request"));
if ( !CompleteIfBusy(aMessage) )
{
iServer.SetCurrentAsyncMsg( aMessage );
iServer.CreateMediaserverContainerL();
iServer.MediaserverContainer().SearchMediaserversL();
}
break;
}
case ECmMdhHarvest:
{
LOG(_L("[CmMdh Server]\t ECmMdhHarvest request"));
iServer.SetCurrentAsyncMsg( aMessage );
iServer.CreateMediaserverContainerL();
iServer.MediaserverContainer().HarvestMediaserversL();
break;
}
case ECmMdhCancel:
{
LOG(_L("[CmMdh Server]\t ECmMdhCancel request"));
switch ( iServer.ServerState() )
{
case ECmMdhServerStateSearching:
{
iServer.MediaserverContainer().CancelSearchL();
iServer.DestroyMediaserverContainer();
aMessage.Complete( KErrNone );
break;
}
case ECmMdhServerStateHarvesting:
{
iServer.MediaserverContainer().CancelHarvestL();
iServer.DestroyMediaserverContainer();
aMessage.Complete( KErrNone );
break;
}
default:
{
aMessage.Complete( KErrNotReady );
break;
}
}
break;
}
default:
{
// Unknown opcode --> panic client
PanicClient( aMessage, ECmMdhClientBadRequest );
break;
}
}
}
/**
Delayed construction of heap stored data members.
@leave KErrNoMemory Heap memory allocation failure for
CMobileSmartCardEapPtrHolder object.
@publishedPartner
@released
*/
EXPORT_C void RMobileSmartCardEap::ConstructL()
{
__ASSERT_ALWAYS(iMmPtrHolder == NULL, PanicClient(EEtelPanicHandleNotClosed));
iMmPtrHolder = CMobileSmartCardEapPtrHolder::NewL(CMobileSmartCardEapPtrHolder::EMaxNumberSmartCardEapPtrSlots,
CMobileSmartCardEapPtrHolder::EMaxNumberSmartCardEapPtrCSlots);
}
/**
Handles the servicing of a client request that has been passed
to the server.
*/
void CMockSYSession::ServiceL(const RMessage2& aMessage)
{
switch(aMessage.Function())
{
case RMockSY::KExpect:
{
HBufC8* data = HBufC8::NewLC(aMessage.GetDesLengthL(3));
TPtr8 dataPtr = data->Des();
aMessage.ReadL(3,dataPtr);
CleanupStack::Pop(data);
iEngine.QueueEpectedCallL(aMessage.Int0(),aMessage.Int1(),aMessage.Int2(),data);
aMessage.Complete(KErrNone);
}
break;
case RMockSY::KComplete:
{
HBufC8* data = HBufC8::NewLC(aMessage.GetDesLengthL(3));
TPtr8 dataPtr = data->Des();
aMessage.ReadL(3,dataPtr);
CleanupStack::Pop(data);
iEngine.QueueReturnCallL(aMessage.Int0(),aMessage.Int1(), aMessage.Int2(),data);
aMessage.Complete(KErrNone);
}
break;
case RMockSY::KNotifyTerminated:
{
if (!iNotifyDoneMsg.IsNull())
{
PanicClient(aMessage,EPanicAlreadyReceiving);
}
else
{
iNotifyDoneMsg = aMessage;
}
}
break;
case RMockSY::KGetNextLogLine:
{
HBufC* line = iEngine.GetNextLogLine();
TInt ret;
if (line!=NULL)
{
ret=aMessage.Write(0,line->Des());
delete line;
}
else
{
ret=aMessage.Write(0,KNullDesC);
}
aMessage.Complete(ret);
}
break;
case RMockSY::KGetStatus:
{
TBool retVal;
TPckg<TBool> retValPckg(retVal);
retVal = iEngine.HasWaitingEvents();
aMessage.Write(0,retValPckg);
retVal = iEngine.HasPendingEvents();
aMessage.Write(1,retValPckg);
retVal = iEngine.HasFailure();
aMessage.Write(2,retValPckg);
aMessage.Complete(KErrNone);
}
break;
default:
PanicClient(aMessage,EPanicIllegalFunction);
}
}
/*
-------------------------------------------------------------------------------
Class: CTestModule
Method: DispatchMessageL
Description: Dispatch message, calls corresponding function to do it.
Parameters: const RMessage& aMessage :inout: Message to be handled
Return Values: TInt Error code
Errors/Exceptions: Leaves if operation handling function leaves
Status: Proposal
-------------------------------------------------------------------------------
*/
TInt CTestModule::DispatchMessageL( const RMessage2& aMessage )
{
__TRACE( KMessage,( _L( "CTestModule::DispatchMessageL %d" ),
aMessage.Function() ) );
switch( aMessage.Function() )
{
// Session specific
case ETestServerCloseSession: // Close whole session
{
__TRACE( KError ,( _L( "Closing test module session" ) ) );
return CloseSession( aMessage );
}
case ETestServerGetServerThreadId: // Get Server ThreadId
{
__TRACE( KError ,( _L( "Return server thread id" ) ) );
return GetServerThreadIdL( aMessage );
}
case ETestModuleCreateSubSession : // Create new test module subsession
{
__TRACE( KError,( _L( "Creating test module session" ) ) );
return CreateModuleSessionL( aMessage );
}
case ETestModuleCloseSubSession: // Close module subsession
{
// Nothing to do.
aMessage.Complete( KErrNone );
return KErrNone;
}
case ETestExecutionCreateSubSession: // Create new test execution subsession
{
return NewTestExecutionL( aMessage );
}
case ETestModuleEnumerateTestCases: // Enumerate test cases
{
__TRACE( KError,( _L( "Enumerating test cases" ) ) );
return EnumerateTestCasesL( aMessage );
}
case ETestModuleGetTestCases: // Get test cases
{
return GetTestCasesL( aMessage );
}
case ETestModuleErrorNotification: // Request error notification
{
return HandleErrorNotificationL( aMessage );
}
case ETestModuleCancelAsyncRequest:
{
return CancelAsyncRequestL( aMessage );
}
// Subsession specific
case ETestExecutionRunTestCase: // Run test case
{
__TRACE( KInit,( _L( "Running test case" ) ) );
CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage );
return testCase->RunTestCase( aMessage );
}
case ETestExecutionNotifyProgress: // Test case prints
{
CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage );
return testCase->NotifyPrint( aMessage );
}
case ETestExecutionNotifyEvent: // Event notifications
{
CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage );
return testCase->NotifyEvent( aMessage );
}
case ETestExecutionNotifyRemoteCmd: // RemoteCmd notifications
{
CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage );
return testCase->NotifyRemoteCmd( aMessage );
}
case ETestExecutionReadRemoteCmdInfo: // RemoteCmd reading
{
//CTestExecution* testCase=CaseFromHandle( aMessage.Int3() );
//return testCase->NotifyRemoteCmd( aMessage );
CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage );
return testCase->ReadRemoteCmdInfo( aMessage );
}
case ETestExecutionResume: // Resume case execution
{
__TRACE( KVerbose,( _L( "Resuming test execution" ) ) );
CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage );
return testCase->Resume( aMessage );
}
case ETestExecutionPause: // Pause case execution
{
__TRACE( KVerbose,( _L( "Pausing test execution" ) ) );
CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage );
return testCase->Pause( aMessage );
}
case ETestExecutionCloseSubSession: // Close execution subsession
{
CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage );
return testCase->CloseTestExecution( aMessage );
}
case ETestExecutionCancelAsyncRequest: // Cancel async request
{
CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage );
return testCase->CancelRequestL( aMessage );
}
case ETestExecutionNotifyCommand: // Command notifications
{
CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage );
return testCase->NotifyCommand( aMessage );
}
default: // Invalid request
{
PanicClient( EBadRequest, aMessage );
return KErrNotSupported;
}
}
}
void CMemoryMonitorSession::ServiceL(const RMessage2& aMessage)
{
FUNC_LOG;
#ifndef CLIENT_REQUEST_QUEUE
iFunction = aMessage.Function();
#endif
switch (aMessage.Function())
{
case EOomMonitorRequestFreeMemory:
if (!iRequestFreeRam.IsNull())
PanicClient(aMessage, EPanicRequestActive);
// message will be completed when CloseAppsFinished() is called.
#ifdef CLIENT_REQUEST_QUEUE
ClientRequestQueue().RequestFreeMemoryL(aMessage);
#else
iRequestFreeRam = aMessage;
Monitor().RequestFreeMemoryL(aMessage.Int0(), IsDataPaged(aMessage));
#endif
break;
case EOomMonitorCancelRequestFreeMemory:
if (!iRequestFreeRam.IsNull())
iRequestFreeRam.Complete(KErrCancel);
aMessage.Complete(KErrNone);
break;
case EOomMonitorThisAppIsNotExiting:
Monitor().AppNotExiting(aMessage.Int0());
aMessage.Complete(KErrNone);
break;
case EOomMonitorRequestOptionalRam:
if (!iRequestFreeRam.IsNull())
PanicClient(aMessage, EPanicRequestActive);
// message will be completed when CloseAppsFinished() is called.
#ifdef CLIENT_REQUEST_QUEUE
ClientRequestQueue().RequestOptionalRamL(aMessage);
#else
iRequestFreeRam = aMessage;
iMinimumMemoryRequested = aMessage.Int1();
Monitor().FreeOptionalRamL(aMessage.Int0(), aMessage.Int2(), IsDataPaged(aMessage));
#endif
break;
case EOomMonitorSetPriorityBusy:
Monitor().SetPriorityBusy(aMessage.Int0());
aMessage.Complete(KErrNone);
break;
case EOomMonitorSetPriorityNormal:
Monitor().SetPriorityNormal(aMessage.Int0());
aMessage.Complete(KErrNone);
break;
case EOomMonitorSetPriorityHigh:
Monitor().SetPriorityHigh(aMessage.Int0());
aMessage.Complete(KErrNone);
break;
default:
PanicClient(aMessage, EPanicIllegalFunction);
break;
}
}
void CPicoServSession::loadROM()
{
TInt res;
const TAny* pD=Message().Ptr0();
// TInt desLen=Message().Client().GetDesLength(pD);
if(rom_data) {
// save SRAM for previous ROM
if(currentConfig.iFlags & 1)
saveLoadGame(0, 1);
}
RomFileName = 0;
if(rom_data) {
free(rom_data);
rom_data = 0;
}
// read the contents of the client pointer into a TPtr.
static TBuf8<KMaxFileName> writeBuf;
TRAP(res,Message().ReadL(pD,writeBuf));
if (res!=KErrNone) {
PanicClient(EBadDescriptor);
return;
}
// detect wrong extensions (.srm and .mds)
TBuf8<5> ext;
ext.Copy(writeBuf.Right(4));
ext.LowerCase();
if(!strcmp((char *)ext.PtrZ(), ".srm") || !strcmp((char *)ext.PtrZ(), "s.gz") || // .mds.gz
!strcmp((char *)ext.PtrZ(), ".mds")) {
User::Leave(3);
return;
}
FILE *rom = fopen((char *) writeBuf.PtrZ(), "rb");
if(!rom) {
DEBUGPRINT(_L("failed to open rom."));
User::Leave(1);
return;
}
unsigned int rom_size = 0;
// zipfile support
if(!strcmp((char *)ext.PtrZ(), ".zip")) {
fclose(rom);
res = CartLoadZip((const char *) writeBuf.PtrZ(), &rom_data, &rom_size);
if(res) {
User::Leave(res);
return;
}
} else {
if( (res = PicoCartLoad(rom, &rom_data, &rom_size)) ) {
DEBUGPRINT(_L("PicoCartLoad() failed."));
fclose(rom);
User::Leave(2);
return;
}
fclose(rom);
}
// detect wrong files (Pico crashes on very small files), also see if ROM EP is good
if(rom_size <= 0x200 || strncmp((char *)rom_data, "Pico", 4) == 0 ||
((*(TUint16 *)(rom_data+4)<<16)|(*(TUint16 *)(rom_data+6))) >= (int)rom_size) {
free(rom_data);
rom_data = 0;
User::Leave(3); // not a ROM
}
DEBUGPRINT(_L("PicoCartInsert(0x%08X, %d);"), rom_data, rom_size);
if(PicoCartInsert(rom_data, rom_size)) {
User::Leave(2);
return;
}
pico_was_reset = 1;
// global ROM file name for later use
RomFileName = (const char *) writeBuf.PtrZ();
// load SRAM for this ROM
if(currentConfig.iFlags & 1)
saveLoadGame(1, 1);
// debug
#ifdef __DEBUG_PRINT
TInt cells = User::CountAllocCells();
TInt mem;
User::AllocSize(mem);
DEBUGPRINT(_L("comm: cels=%d, size=%d KB"), cells, mem/1024);
gamestate = PGS_DebugHeap;
gamestate_prev = PGS_Running;
#else
gamestate = PGS_Running;
#endif
}
// ----------------------------------------------------------------------------
// Message dispatcher
// ----------------------------------------------------------------------------
//
void CMPXPlaybackSession::DispatchMessageL( const RMessage2& aMessage, TInt& aMsgHandleResult )
{
aMsgHandleResult = KErrNone;
//
// All methods apart from the player creation methods, require a player
//
TInt op=aMessage.Function();
if (op != EPbsSetMode)
{
CheckPlayerL();
}
MPX_DEBUG3("-->CMPXPlaybackSession::DispatchMessageL %d, this 0x%08x",
op, this);
switch(op)
{
case EPbsSetMode:
{
SetModeL(aMessage);
break;
}
case EPbsGetClients:
{
RArray<TProcessId> procArray;
::CopyArrayL<TProcessId>(
iPlayer->ClientList()->ClientProcessList(),
procArray );
TProcessId lastPid = static_cast<CMPXPlaybackServer*>(
const_cast<CServer2*>(Server()))->LastActiveProcessId();
TInt index( procArray.Find( lastPid ));
if ( KErrNotFound != index && index )
{
procArray.Remove( index );
procArray.Insert( lastPid, 0 );
}
::CreateBufferL<TProcessId>(
procArray.Array(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
procArray.Close();
break;
}
case EPbsGetSyncBuffer:
{
aMessage.WriteL(0,iSyncBuffer->Ptr(0));
delete iSyncBuffer;
iSyncBuffer = NULL;
break;
}
case EPbsGetAsyncBuffer:
{
//In case of other application leaving, causing us to leave
//we could have a task that does not get removed from the top of the queue
//but the data for that task has been deleted.
//When the task runs again, there will be no data causing a panic - leave if this occurs
User::LeaveIfNull(iAsyncBuffer);
aMessage.WriteL(0,iAsyncBuffer->Ptr(0));
delete iAsyncBuffer;
iAsyncBuffer = NULL;
break;
}
case EPbsInitFromCollection:
{
MPXUser::CreateBufferL(aMessage, 0, iSyncBuffer);
CMPXCollectionPlaylist* p = NULL;
::NewFromBufferL(*iSyncBuffer, p);
delete iSyncBuffer;
iSyncBuffer = NULL;
CleanupStack::PushL(p);
iPlayer->InitL(*p,aMessage.Int1());
CleanupStack::PopAndDestroy(p);
}
break;
case EPbsInitFromUri:
{
CBufBase* buf0(NULL);
MPXUser::CreateBufferL(aMessage,0,buf0);
CleanupStack::PushL(buf0);
// Type parameter is optional
if ( aMessage.GetDesLength( 1 ) > 0 )
{
CBufBase* buf1(NULL);
MPXUser::CreateBufferL(aMessage,1,buf1);
CleanupStack::PushL(buf1);
iPlayer->InitL(MPXUser::Ptr(buf0->Ptr(0)), buf1->Ptr(0));
CleanupStack::PopAndDestroy(buf1);
}
else
{
MPX_DEBUG2("CMPXPlaybackSession::DispatchMessageL %d: Type is empty", op);
iPlayer->InitL( MPXUser::Ptr( buf0->Ptr(0) ), KNullDesC8 );
}
CleanupStack::PopAndDestroy(buf0);
}
break;
case EPbsInitFromFile:
{
InitFromFileL(aMessage);
break;
}
case EPbsInitStreamingFromUri:
{
CBufBase* buf0(NULL);
MPXUser::CreateBufferL(aMessage,0,buf0);
CleanupStack::PushL(buf0);
// Type parameter is optional
if ( aMessage.GetDesLength( 1 ) > 0 )
{
CBufBase* buf1(NULL);
MPXUser::CreateBufferL(aMessage,1,buf1);
CleanupStack::PushL(buf1);
iPlayer->InitStreamingL(MPXUser::Ptr(buf0->Ptr(0)), buf1->Ptr(0), aMessage.Int2());
CleanupStack::PopAndDestroy(buf1);
}
else
{
MPX_DEBUG2("CMPXPlaybackSession::DispatchMessageL %d: Type is empty", op);
iPlayer->InitStreamingL( MPXUser::Ptr( buf0->Ptr(0) ), KNullDesC8, aMessage.Int2() );
}
CleanupStack::PopAndDestroy(buf0);
break;
}
case EPbsInitStreamingFromFile:
{
RFile file;
User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));
iPlayer->InitStreamingL(file, aMessage.Int2());
file.Close();
break;
}
case EPbsCancelRequest:
{
CancelRequests();
break;
}
case EPbsGetState:
{
aMsgHandleResult = iPlayer->State();
break;
}
case EPbsSetProperty:
{
iPlayer->SetL(static_cast<TMPXPlaybackProperty>(aMessage.Int0()),
aMessage.Int1());
break;
}
case EPbsGetProperty:
{
SetAsync(aMessage);
iPlayer->PropertyL(
static_cast<TMPXPlaybackProperty>(aMessage.Int0()),*this);
break;
}
case EPbsGetPlayerTypes:
{
RArray<TMPXPlaybackPlayerType> pluginTypes;
CleanupClosePushL(pluginTypes);
RArray<TInt> types;
CleanupClosePushL(types);
iPlayer->PluginHandler()->GetPluginTypes(types);
for (TInt i=0; i< types.Count(); ++i)
{
pluginTypes.AppendL(
static_cast<TMPXPlaybackPlayerType>(types[i]));
}
CleanupStack::PopAndDestroy(&types);
::CreateBufferL<TMPXPlaybackPlayerType>(
pluginTypes.Array(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(&pluginTypes);
break;
}
case EPbsGetPlayerTypeDisplayName:
{
const TDesC& playerName = iPlayer->PluginHandler()->PlayerName(
static_cast<TMPXPlaybackPlayerType>(aMessage.Int0()));
aMsgHandleResult = 0;
if (playerName.Length()>0)
{
MPXUser::CreateBufferL(playerName, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
}
break;
}
case EPbsGetAllPlayersUids:
{
RArray<TUid> uids;
CleanupClosePushL(uids);
iPlayer->PluginHandler()->GetPluginUids(uids);
::CreateBufferL<TUid>(
uids.Array(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(&uids);
break;
}
case EPbsGetPlayersUidsForType:
{
aMsgHandleResult = CreatePlayerUidsBufferL(aMessage);
break;
}
case EPbsGetSubPlayerNamesByUid:
{
SetAsync(aMessage);
iPlayer->SubPlayerNamesL(TUid::Uid(aMessage.Int0()),*this);
break;
}
case EPbsSelectPlayerByType:
{
iPlayer->PluginHandler()->SelectPlayersL(
static_cast<TMPXPlaybackPlayerType>(aMessage.Int0()));
break;
}
case EPbsSelectPlayerByUid:
{
iPlayer->PluginHandler()->SelectPlayerL(TUid::Uid(aMessage.Int0()));
break;
}
case EPbsSelectSubPlayer:
{
iPlayer->PluginHandler()->SelectSubPlayerL(
TUid::Uid(aMessage.Int0()),aMessage.Int1());
break;
}
case EPbsClearPlayerSelection:
{
iPlayer->PluginHandler()->ClearSelectPlayersL();
break;
}
case EPbsGetSelection:
{
GetSelectionL(aMessage);
break;
}
case EPbsPlayerFound:
{
aMsgHandleResult = iPlayer->PluginHandler()->PlayerFound();
break;
}
case EPbsGetPlayerType:
{
aMsgHandleResult = iPlayer->PluginHandler()->PluginType();
break;
}
case EPbsGetTypeName:
{
MPXUser::CreateBufferL(iPlayer->PluginHandler()->PlayerName(),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
break;
}
case EPbsGetSubPlayerIndex:
{
aMsgHandleResult = iPlayer->PluginHandler()->SubPlayer();
break;
}
case EPbsGetPlayerUid:
{
TPckgC<TInt> uidPkg((iPlayer->PluginHandler()->PluginUid()).iUid);
aMessage.Write(0,uidPkg);
break;
}
case EPbsGetCollectionPlaylist:
{
aMsgHandleResult = 0;
if (iPlayer->Playlist())
{
::CreateBufferL<CMPXCollectionPlaylist>(*(iPlayer->Playlist()),
iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
}
break;
}
case EPbsGetFile:
{
const RFile& file = iPlayer->File();
if (file.SubSessionHandle())
{
aMsgHandleResult = file.TransferToClient(aMessage,0); //message completed
}
else
{
TPckgC<TInt> handle(KErrNotFound);
aMessage.Write(0, handle);
}
break;
}
case EPbsGetUri:
{
aMsgHandleResult=0;
if (iPlayer->Uri().Length()>0)
{
MPXUser::CreateBufferL(iPlayer->Uri(),iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
}
break;
}
case EPbsGetMedia:
{
SetAsync( aMessage );
CMPXCommand* cmd( CMPXCommand::NewL( aMessage.Int1() ) );
CleanupStack::PushL( cmd );
iPlayer->MediaL( *this, *cmd );
CleanupStack::PopAndDestroy( cmd );
break;
}
case EPbsGetSupportedMimeTypes:
{
CDesCArray* mimeTypes =
iPlayer->PluginHandler()->SupportedMimeTypesL();
CleanupStack::PushL(mimeTypes);
MPXUser::CreateBufferL((const MDesCArray*)mimeTypes, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(mimeTypes);
}
break;
case EPbsGetSupportedExtensions:
{
CDesCArray* exts =
iPlayer->PluginHandler()->SupportedExtensionsL();
CleanupStack::PushL(exts);
MPXUser::CreateBufferL((const MDesCArray*)exts, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(exts);
}
break;
case EPbsGetSupportedSchemas:
{
CDesCArray* schemas =
iPlayer->PluginHandler()->SupportedSchemasL();
CleanupStack::PushL(schemas);
MPXUser::CreateBufferL((const MDesCArray*)schemas, iSyncBuffer);
aMsgHandleResult = iSyncBuffer->Size();
CleanupStack::PopAndDestroy(schemas);
}
break;
case EPbsGetNextMessage:
{
ASSERT(iMessageQueue);
iMessageQueue->SendNext(aMessage);
iCompleteRequest=EFalse;
break;
}
case EPbsCancelGetMessage:
{
ASSERT(iMessageQueue);
iMessageQueue->Reset();
break;
}
case EPbsCommand:
{
CMPXCommand* cmd( NULL );
::NewFromMessageL<CMPXMedia>(aMessage, 1, cmd);
CleanupStack::PushL(cmd);
iPlayer->CommandL(*cmd, *iMessageQueue);
CleanupStack::PopAndDestroy(cmd);
break;
}
#ifdef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
case EPbsInitFromFile64:
{
RFile64 file;
User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));
iPlayer->Init64L(file);
file.Close();
break;
}
case EPbsInitStreamingFromFile64:
{
RFile64 file;
User::LeaveIfError(file.AdoptFromClient(aMessage,0,1));
iPlayer->InitStreaming64L(file, aMessage.Int2());
file.Close();
break;
}
case EPbsGetFile64:
{
const RFile64& file = iPlayer->File64();
if (file.SubSessionHandle())
{
aMsgHandleResult = file.TransferToClient(aMessage,0); //message completed
}
else
{
TPckgC<TInt> handle(KErrNotFound);
aMessage.Write(0, handle);
}
break;
}
#endif // SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API
case EPbsSetPrimaryClient:
{
aMsgHandleResult = iPlayer->ClientList()->SetPrimaryClient(*iMessageQueue);
break;
}
default:
{
PanicClient(aMessage,KErrNotSupported);
break;
}
}
MPX_DEBUG1("<---CMPXPlaybackSession::DispatchMessageL");
}
/*
-------------------------------------------------------------------------------
Class: CTestModule
Method: EnumerateTestCases
Description: Enumerates test cases and returns test case count by writing
result to client side package.
Function obtains a TestModule and calls EnumerateTestCases from it.
Test module will be released when calling GetTestCases function.
Parameters: const RMessage& aMessage :inout: Message to be handled
Return Values: TInt Operation result
Errors/Exceptions: None
Status: Proposal
-------------------------------------------------------------------------------
*/
TInt CTestModule::EnumerateTestCasesL( const RMessage2& aMessage )
{
__TRACE( KMessage,( _L( "CTestModule::EnumerateTestCasesL in" ) ) );
// Get data from message
TFileName config;
TRAPD( res, aMessage.ReadL( 0, config ) );
if(res == KErrDied)
{
RDebug::Print(_L("CTestModule::EnumerateTestCasesL() Reading from RMessage ended with KErrDied. Client is not alive anymore and this request will be ignored"));
return res;
}
else if( res != KErrNone )
{
RDebug::Print(_L("CTestModule::EnumerateTestCasesL() #1 Panic client with [%d], res=[%d]"), EBadDescriptor, res);
PanicClient( EBadDescriptor, aMessage );
return res;
}
// Free old case data
User::LeaveIfError( FreeCaseData() );
// Get test cases from the test module
User::LeaveIfError( GetTestModule( iEnumerateModule, config ) );
// Enumerate test cases
iEnumerateModule->EnumerateTestCases( config );
// Something fatal?
TInt r = iEnumerateModule->OperationErrorResult();
if( r != KErrNone )
{
// Enumeration module have crashed.
delete iEnumerateModule;
iEnumerateModule = NULL;
return r;
}
// Error from module?
if( iEnumerateModule->ModuleResult() != KErrNone )
{
return iEnumerateModule->ModuleResult();
}
// Write count to Ptr1()
const RPointerArray<TTestCaseInfo>* testCases = iEnumerateModule->TestCases();
if( testCases == NULL )
{
User::Leave( KErrGeneral );
}
CTestCasesList* testCasesList = NULL;
for ( TInt i = 0; i < iTestCaseTitlesMap.Count(); i++ )
{
if ( iTestCaseTitlesMap[ i ]->GetConfigFileName() == config )
{
testCasesList = iTestCaseTitlesMap[ i ];
break;
}
}
if ( testCasesList == NULL )
{
testCasesList = CTestCasesList::NewL( config );
CleanupStack::PushL( testCasesList );
iTestCaseTitlesMap.AppendL( testCasesList );
CleanupStack::Pop( testCasesList );
}
// Store titles (for further use, i.e. when asked for title from the interface via CTestModuleIf->CTestThreadContainer->CTestModuleContainer)
testCasesList->ResetAndDestroy();
TInt i;
for(i = 0; i < testCases->Count(); i++)
{
//Handle situation when test cases are enumerated not as 0-based (testscripter, ...)
if(i == 0 && (*testCases)[i]->iCaseNumber > 0)
{
testCasesList->AppendTestCaseL( KNullDesC );
}
testCasesList->AppendTestCaseL( (*testCases)[i]->iTitle );
}
TPckgBuf<TInt> countPckg( testCases->Count() );
TRAP( res, aMessage.WriteL( 1, countPckg ) );
if(res == KErrDied)
{
RDebug::Print(_L("CTestModule::EnumerateTestCasesL() Writing to RMessage ended with KErrDied. Client is not alive anymore and this request will be ignored"));
return res;
}
else if( res != KErrNone )
{
RDebug::Print(_L("CTestModule::EnumerateTestCasesL() #2 Panic client with [%d], res=[%d], config=[%S]"), EBadDescriptor, res, &config);
PanicClient( EBadDescriptor, aMessage );
return res;
}
// All ok, complete message
aMessage.Complete( KErrNone );
__TRACE( KMessage,( _L( "CTestModule::EnumerateTestCasesL out" ) ) );
return KErrNone;
}
// service a client request; test the opcode and then do appropriate servicing
void CPicoServSession::DispatchMessageL(const RMessage &aMessage)
{
switch (aMessage.Function()) {
case PicoMsgLoadState:
if(!rom_data) User::Leave(-1); // no ROM
User::LeaveIfError(saveLoadGame(1));
gamestate = PGS_Running;
return;
case PicoMsgSaveState:
if(!rom_data) User::Leave(-1);
User::LeaveIfError(saveLoadGame(0));
gamestate = PGS_Running;
return;
case PicoMsgLoadROM:
loadROM();
return;
case PicoMsgResume:
if(rom_data) gamestate = PGS_Running;
return;
case PicoMsgReset:
if(rom_data) {
PicoReset(0);
pico_was_reset = 1;
gamestate = PGS_Running;
}
return;
case PicoMsgKeys:
gamestate = PGS_KeyConfig;
return;
case PicoMsgPause:
gamestate = PGS_Paused;
return;
case PicoMsgQuit:
DEBUGPRINT(_L("got quit msg."));
gamestate = PGS_Quit;
return;
// config change
case PicoMsgConfigChange: // launcher -> emu
changeConfig();
return;
case PicoMsgRetrieveConfig: // emu -> launcher
sendConfig();
return;
case PicoMsgRetrieveDebugStr: // emu -> launcher
sendDebug();
return;
// requests we don't understand at all are a different thing,
// so panic the client here, this function also completes the message
default:
PanicClient(EBadRequest);
return;
}
}