void MPanelItem::SetData(const BYTE* apData, DWORD anSize, BOOL bIsCopy /*= FALSE*/, BOOL bAddBom /*= FALSE*/)
{
if (!apData) {
this->printf(_T("\n<Can't access memory: %i bytes at 0x00000000>\n"), anSize);
return;
}
if (!bIsCopy) {
ULONGLONG nPos = (apData - g_pMappedFileBase);
if ((nPos+anSize) > g_FileSize.QuadPart) {
TCHAR szErrInfo[128];
if (nPos > g_FileSize.QuadPart) {
wsprintf(szErrInfo, _T("Can't access memory at 0x%08X"), (DWORD)(apData-g_pMappedFileBase));
this->AddText(szErrInfo, -1, TRUE);
Parent()->SetError(szErrInfo);
return;
} else {
wsprintf(szErrInfo, _T("Can't access %i bytes at 0x%08X"), anSize, (DWORD)(apData-g_pMappedFileBase));
Parent()->SetError(szErrInfo);
}
anSize = (DWORD)(g_FileSize.QuadPart - nPos);
}
}
if (!bIsCopy && !ValidateMemory(apData, anSize))
{
this->printf(_T("\n<Can't access memory: %i bytes at 0x%08X>\n"), anSize, (DWORD)(apData-g_pMappedFileBase));
}
else if (bIsCopy && IsBadReadPtr(apData, anSize))
{
this->printf(_T("\n<Can't access memory: %i bytes at 0x%08X>\n"), anSize, (DWORD)(apData-g_pMappedFileBase));
}
else
{
if (pBinaryData) {
_ASSERTE(pBinaryData==NULL);
free(pBinaryData); nBinarySize = 0;
}
int nShift = bAddBom ? 2 : 0;
pBinaryData = (LPBYTE)malloc(anSize+nShift);
nBinarySize = anSize+nShift;
if (!pBinaryData) {
this->printf(_T("\n<Can't allocate memory: %i bytes at 0x%08X>\n"), anSize, (DWORD)(apData-g_pMappedFileBase));
} else {
if (bAddBom) {
WORD nBOM = 0xFEFF; // CP-1200
memmove(pBinaryData, &nBOM, 2);
}
memmove(pBinaryData+nShift, apData, anSize);
}
item.nFileSizeLow = anSize; // реально может быть меньше
}
}
void
Tcl_ValidateAllMemory(
const char *file, /* File from which Tcl_ValidateAllMemory was
* called. */
int line) /* Line number of call to
* Tcl_ValidateAllMemory */
{
struct mem_header *memScanP;
if (!ckallocInit) {
TclInitDbCkalloc();
}
Tcl_MutexLock(ckallocMutexPtr);
for (memScanP = allocHead; memScanP != NULL; memScanP = memScanP->flink) {
ValidateMemory(memScanP, file, line, FALSE);
}
Tcl_MutexUnlock(ckallocMutexPtr);
}
void
Tcl_DbCkfree(
char *ptr,
const char *file,
int line)
{
struct mem_header *memp;
if (ptr == NULL) {
return;
}
/*
* The following cast is *very* tricky. Must convert the pointer to an
* integer before doing arithmetic on it, because otherwise the arithmetic
* will be done differently (and incorrectly) on word-addressed machines
* such as Crays (will subtract only bytes, even though BODY_OFFSET is in
* words on these machines).
*/
memp = (struct mem_header *) (((unsigned long) ptr) - BODY_OFFSET);
if (alloc_tracing) {
fprintf(stderr, "ckfree %lx %ld %s %d\n",
(long unsigned int) memp->body, memp->length, file, line);
}
if (validate_memory) {
Tcl_ValidateAllMemory(file, line);
}
Tcl_MutexLock(ckallocMutexPtr);
ValidateMemory(memp, file, line, TRUE);
if (init_malloced_bodies) {
memset(ptr, GUARD_VALUE, (size_t) memp->length);
}
total_frees++;
current_malloc_packets--;
current_bytes_malloced -= memp->length;
if (memp->tagPtr != NULL) {
memp->tagPtr->refCount--;
if ((memp->tagPtr->refCount == 0) && (curTagPtr != memp->tagPtr)) {
TclpFree((char *) memp->tagPtr);
}
}
/*
* Delink from allocated list
*/
if (memp->flink != NULL) {
memp->flink->blink = memp->blink;
}
if (memp->blink != NULL) {
memp->blink->flink = memp->flink;
}
if (allocHead == memp) {
allocHead = memp->flink;
}
TclpFree((char *) memp);
Tcl_MutexUnlock(ckallocMutexPtr);
}
void DumpNEResourceTable(MPanelItem *pRoot, PIMAGE_DOS_HEADER dosHeader, LPBYTE pResourceTable)
{
PBYTE pImageBase = (PBYTE)dosHeader;
MPanelItem* pChild = pRoot->AddFolder(_T("Resource Table"));
pChild->AddText(_T("<Resource Table>\n"));
// минимальный размер
size_t nReqSize = sizeof(OS2RC_TYPEINFO)+12;
if (!ValidateMemory(pResourceTable, nReqSize)) {
pChild->printf(_T("!!! Can't read memory at offset: 0x%08X\n"),
(DWORD)(pResourceTable - pImageBase));
return;
}
//
USHORT rscAlignShift = *(USHORT*)pResourceTable;
OS2RC_TYPEINFO* pTypeInfo = (OS2RC_TYPEINFO*)(pResourceTable+2);
char szTypeName[128], szResName[256];
UINT nResLength = 0, nResOffset = 0;
LPBYTE pNames;
// —начала нужно найти начало имен
pTypeInfo = (OS2RC_TYPEINFO*)(pResourceTable+2);
while (pTypeInfo->rtTypeID) {
OS2RC_TNAMEINFO* pResName = pTypeInfo->rtNameInfo;
// Next resource type
pTypeInfo = (OS2RC_TYPEINFO*)(pResName+pTypeInfo->rtResourceCount);
if (!ValidateMemory(pTypeInfo, 2)) {
pChild->printf(_T("!!! Can't read memory at offset: 0x%08X\n"),
(DWORD)(((LPBYTE)pTypeInfo) - pImageBase));
return;
}
}
pNames = ((LPBYTE)pTypeInfo)+2;
// “еперь, собственно ресурсы
pTypeInfo = (OS2RC_TYPEINFO*)(pResourceTable+2);
while (pTypeInfo->rtTypeID) {
szTypeName[0] = 0;
GetOS2ResourceTypeName(pTypeInfo->rtTypeID, szTypeName, sizeof(szTypeName));
MPanelItem* pType = pChild->AddFolder(szTypeName);
pType->printf(" <%s>:\n", szTypeName);
pType->printf(_T(" Resource count: %i\n"), pTypeInfo->rtResourceCount);
OS2RC_TNAMEINFO* pResName = pTypeInfo->rtNameInfo;
for (USHORT i = pTypeInfo->rtResourceCount; i--; pResName++) {
nResLength = pResName->rnLength * (1 << rscAlignShift);
nResOffset = pResName->rnOffset * (1 << rscAlignShift);
szResName[0] = 0;
if (pNames) {
if (!ValidateMemory(pNames, 1)) {
pChild->printf(_T("!!! Can't read memory at offset: 0x%08X\n"),
(DWORD)(pNames - pImageBase));
pNames = NULL;
} else if (!ValidateMemory(pNames, 1+(*pNames))) {
pChild->printf(_T("!!! Can't read memory at offset: 0x%08X\n"),
(DWORD)(pNames - pImageBase));
pNames = NULL;
} else if (*pNames) {
memmove(szResName, pNames+1, *pNames);
szResName[*pNames] = 0;
pNames += (*pNames)+1;
} else {
pNames++;
}
}
if (szResName[0]) {
sprintf(szResName+strlen(szResName), ".0x%08X", pResName->rnID);
} else {
sprintf(szResName, "ResID=0x%08X", pResName->rnID);
}
MPanelItem* pRes = NULL;
if (nResLength && nResOffset) {
pRes = CreateResource(pType, pTypeInfo->rtTypeID,
pImageBase+nResOffset, nResLength,
szResName, NULL, 0, 0);
} else {
pRes = pType->AddFile(szResName, nResOffset ? nResLength : 0);
}
pType->printf(" <%s>\n", szResName);
pType->printf(" Resource Name: %s\n", szResName);
pType->printf(" Resource ID: 0x%08X\n", pResName->rnID);
pType->printf(" Resource length: %u bytes\n", nResLength);
pType->printf(" Resource offset: 0x%08X\n", nResOffset);
pType->printf(" Handle(reserved): 0x%04X\n", (DWORD)pResName->rnHandle);
pType->printf(" Usage(reserved): 0x%04X\n", (DWORD)pResName->rnUsage);
//if (nResLength && nResOffset) {
// pRes->SetData(pImageBase+nResOffset, nResLength);
//}
}
// Next resource type
pTypeInfo = (OS2RC_TYPEINFO*)pResName;
}
}
