Read physical memory information from registry

/////////////////////////////////////////////////////////////////////////
//
// Module:
// Read physical memory information from registry
// HKLM/HARDWARE/RESOURCEMAP/System Resources/Physical Memory
//
// Author:
// CDrea (CDrea_at_SafeChina[dot]ORG
//
// Version:
// 2007-12-24 v0.1
//
/////////////////////////////////////////////////////////////////////////
#include <windows.h>
#include <stdio.h>

struct _mi {
LARGE_INTEGER Address;
DWORD Length;
DWORD Reserved;
};

#define MI_LEN sizeof(struct _mi)

typedef struct _phy_mem_info {
DWORD BusCount;
DWORD MemoryRangeCount;
struct _mi* MemInfoPtr;
}PHY_MEM_INFO;

BOOL
GetPhyMemoryInfo(
OUT PHY_MEM_INFO* PhyMemInfo
);

void logo();

int main()
{
PHY_MEM_INFO PhyMemInfo = {0};
LARGE_INTEGER TotalSize = {0};

logo();

if(!GetPhyMemoryInfo(&PhyMemInfo)) return -1;

for(DWORD i = 0; i < PhyMemInfo.MemoryRangeCount; i++)
{
TotalSize.QuadPart += (PhyMemInfo.MemInfoPtr + i)->Length;
}

printf("Total memory: %d MB/n", TotalSize.QuadPart / 1024 / 1024);
printf("Bus count: %d/n", PhyMemInfo.BusCount);
printf("Memory ranges:/n");
for(DWORD i = 0; i < PhyMemInfo.MemoryRangeCount; i++)
{
printf(" 0x%-016I64X Length: 0x%X (%dK)/n",
(PhyMemInfo.MemInfoPtr + i)->Address.QuadPart,
(PhyMemInfo.MemInfoPtr + i)->Length,
(PhyMemInfo.MemInfoPtr + i)->Length / 1024);
}

if(PhyMemInfo.MemInfoPtr != NULL)
free(PhyMemInfo.MemInfoPtr);
return 0;
}

BOOL
GetPhyMemoryInfo(
OUT PHY_MEM_INFO* PhyMemInfo
)
{
HKEY hKey;
int nRet = 0;

nRet = RegOpenKey(HKEY_LOCAL_MACHINE, "Hardware//ResourceMap//System Resources//Physical Memory", &hKey);
if(nRet != ERROR_SUCCESS)
{
fprintf(stderr, "RegOpenKey() failed. --err: %d/n", GetLastError());
return FALSE;
}

DWORD Type = 0;
DWORD cbData = 0;
LPBYTE lpData = NULL;
LPBYTE pmrc = NULL;

RegQueryValueEx(hKey, ".Translated", 0, &Type, NULL, &cbData);
lpData = (LPBYTE)malloc(cbData);
RegQueryValueEx(hKey, ".Translated", 0, &Type, lpData, &cbData);
if(nRet != ERROR_SUCCESS)
{
fprintf(stderr, "RegQueryValueEx() failed. --err: %d/n", GetLastError());
return FALSE;
}

DWORD BusCount = *(DWORD*)lpData;
if(BusCount <= 0)
{
fprintf(stderr, "Cannot get valid memory information./n");
return FALSE;
}

LPBYTE p = lpData + 0x10;
DWORD MemoryRangesCount = 0;
for(DWORD i = 1; i <= BusCount; i++)
{
MemoryRangesCount += *(DWORD*)p;
p = p + 0x8 + i * (*(DWORD*)p) * 0x10;
}
p = lpData + 0x10;

PhyMemInfo->MemInfoPtr = (struct _mi*)malloc(MI_LEN * MemoryRangesCount);
if(PhyMemInfo->MemInfoPtr == NULL)
{
fprintf(stderr, "Not enough memory./n");
return FALSE;
}

LPBYTE pmi = NULL;
struct _mi* ptr = PhyMemInfo->MemInfoPtr;
for(DWORD i = 1; i <= BusCount; i++)
{
pmi = p + 0x8;
for(DWORD j = 0; j < *(DWORD*)p; j++)
{
ptr->Address.LowPart = *(DWORD*)pmi;
ptr->Address.HighPart = *(long*)(pmi + 0x4);
ptr->Length = *(DWORD*)(pmi + 0x8);
ptr++;
pmi += MI_LEN;
}

p = p + 0x8 + i * (*(DWORD*)p) * 0x10;
}

PhyMemInfo->BusCount = BusCount;
PhyMemInfo->MemoryRangeCount = MemoryRangesCount;

RegCloseKey(hKey);
free(lpData);
return TRUE;
}

void logo()
{
printf("+------------------------------------+/n");
printf("| Physical Memory Information v0.1 |/n");
printf("| Write by CDrea |/n");
printf("| CDrea_at_SafeChina[dot]ORG |/n");
printf("| 2007-12-24 |/n");
printf("| http://www.safechina.org |/n");
printf("+------------------------------------+/n/n");
}