Fixed lots of issues with installing a low-caps version of fshell from SIS file.
* Fixed issue in CCommandFactory whereby some APIs like GetCommandInfoL could trigger allocations on the wrong heap or signals to the wrong thread. The symptoms were often seen as a crash in the which_00 thread when running ciftest.
* Lots of build fixes for when FSHELL_PROTECTED_UIDS isn't defined and when all capabilities aren't available.
* Added new platform.mmh macro FSHELL_OPEN_SIGNED.
* Open signing of fshell SIS files is now supported for production S60 handsets. Build fshell with the FSHELL_OPEN_SIGNED macro defined (and without defining FSHELL_CAP_ALL or FSHELL_PROTECTED_UIDS) in your platform.mmh and submit \epoc32\fshell\fshell.unsigned.sis to https://www.symbiansigned.com/app/page/public/openSignedOnline.do . The following commands are not available when using Open Signing due to Platform Security restrictions: fdb; kerninfo; chunkinfo; svrinfo; objinfo; sudo; fsck; localdrive; ramdefrag; readmem; reboot; setcritical; setpriority. Others such as chkdeps, e32header, ps, and fshell itself will run but in a restricted capacity (for example, fshell will no longer allow you to modify files in the \sys\bin directory).
* Removed commands objinfo, svrinfo, chunkinfo, readmem, fsck completely when memory access isn't present - previously they would still appear in the help but would give an error if you tried to run them.
// proxyallocatorhelper.cpp
//
// Copyright (c) 2010 Accenture. All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Accenture - Initial contribution
//
#include <fshell/heaputils.h>
#include <fshell/common.mmh>
#include <fshell/ltkutils.h>
__ASSERT_COMPILE(sizeof(LtkUtils::RProxyAllocatorHelper) == 11*4);
#ifdef FSHELL_MEMORY_ACCESS_SUPPORT
#include <fshell/memoryaccess.h>
#endif
EXPORT_C LtkUtils::RProxyAllocatorHelper::RProxyAllocatorHelper()
: RAllocatorHelper()
{
}
EXPORT_C TInt LtkUtils::RProxyAllocatorHelper::Open(RMemoryAccess& aMem, TUint aThreadId)
{
iMemoryAccess = &aMem;
iThreadId = aThreadId;
#ifdef FSHELL_MEMORY_ACCESS_SUPPORT
TUint8* allocatorAddress;
TInt err = iMemoryAccess->GetAllocatorAddress(iThreadId, allocatorAddress);
if (err == KErrNone)
{
if (allocatorAddress == NULL)
{
// If the thread has not yet been resumed it's valid for it not to have an allocator yet
err = KErrNotReady;
}
else
{
iAllocatorAddress = (TLinAddr)allocatorAddress;
TInt udeb = EuserIsUdeb();
if (udeb < 0) return udeb; // error
err = IdentifyAllocatorType(udeb);
}
}
return err;
#else
return KErrNotSupported;
#endif
}
EXPORT_C TInt LtkUtils::RProxyAllocatorHelper::OpenChunkHeap(RMemoryAccess& aMem, TAny* aDChunkPtr)
{
#ifdef FSHELL_MEMORY_ACCESS_SUPPORT
iMemoryAccess = &aMem;
TChunkKernelInfo chunkInfo;
TPckg<TChunkKernelInfo> chunkInfoPckg(chunkInfo);
TInt err = iMemoryAccess->GetObjectInfo(EChunk, (TUint8*)aDChunkPtr, chunkInfoPckg);
if (err) return err;
RProcess process;
err = process.Open(chunkInfo.iControllingOwnerProcessId);
if (err == KErrNone)
{
TPckgBuf<TProcessKernelInfo> processInfo;
err = iMemoryAccess->GetObjectInfoByHandle(EProcess, RThread().Id(), process.Handle(), processInfo);
process.Close();
if (err == KErrNone)
{
iThreadId = processInfo().iFirstThreadId;
return RAllocatorHelper::OpenChunkHeap((TLinAddr)chunkInfo.iBase, chunkInfo.iMaxSize);
}
}
return err;
#else
(void)aMem;
(void)aDChunkPtr;
return KErrNotSupported;
#endif
}
TInt LtkUtils::RProxyAllocatorHelper::ReadData(TLinAddr aLocation, TAny* aResult, TInt aSize) const
{
#ifdef FSHELL_MEMORY_ACCESS_SUPPORT
TThreadMemoryAccessParams params;
params.iId = iThreadId;
params.iAddr = (TUint8*)aLocation;
params.iSize = aSize;
TPtr8 ptr((TUint8*)aResult, aSize, aSize);
return iMemoryAccess->GetThreadMem(params, ptr);
#else
return KErrNotSupported;
#endif
}
TInt LtkUtils::RProxyAllocatorHelper::WriteData(TLinAddr aLocation, const TAny* aData, TInt aSize)
{
#ifdef FSHELL_MEMORY_ACCESS_SUPPORT
const TPtrC8 ptr((const TUint8*)aData, aSize);
return iMemoryAccess->WriteMem(iThreadId, ptr, (TAny*)aLocation);
#else
return KErrNotSupported;
#endif
}
TInt LtkUtils::RProxyAllocatorHelper::TryLock()
{
return KErrNotSupported;
}
void LtkUtils::RProxyAllocatorHelper::TryUnlock()
{
// Not supported
}
EXPORT_C void LtkUtils::RProxyAllocatorHelper::Close()
{
iMemoryAccess = NULL;
iThreadId = 0;
RAllocatorHelper::Close();
}