windows-nt/Source/XPSP1/NT/net/tcpip/snmp/load.c

775 lines
20 KiB
C
Raw Normal View History

2020-09-26 03:20:57 -05:00
#include "allinc.h"
DWORD
LoadSystem()
{
DWORD dwResult;
TraceEnter("LoadSystem");
if(g_Cache.pRpcSysInfo)
{
if(g_Cache.pRpcSysInfo->aaSysObjectID.asnValue.object.ids)
{
SnmpUtilOidFree(&g_Cache.pRpcSysInfo->aaSysObjectID.asnValue.object);
}
HeapFree(g_hPrivateHeap,
0,
g_Cache.pRpcSysInfo);
g_Cache.pRpcSysInfo = NULL;
}
dwResult = GetSysInfo(&(g_Cache.pRpcSysInfo),
g_hPrivateHeap,
0);
if(dwResult isnot NO_ERROR)
{
TRACE1("GetSysInfo failed with error %x",dwResult);
TraceLeave("LoadSysInfo");
return dwResult;
}
TraceLeave("LoadSysInfo");
return NO_ERROR;
}
DWORD
LoadIfTable()
{
DWORD dwResult;
TraceEnter("LoadIfTable");
if(g_Cache.pRpcIfTable)
{
HeapFree(g_hPrivateHeap,
0,
g_Cache.pRpcIfTable);
g_Cache.pRpcIfTable = NULL;
}
dwResult = InternalGetIfTable(&(g_Cache.pRpcIfTable),
g_hPrivateHeap,
0);
if(dwResult isnot NO_ERROR)
{
TRACE1("GetIfTable failed with error %x",
dwResult);
TraceLeave("LoadIfTable");
return dwResult;
}
TraceLeave("LoadIfTable");
return NO_ERROR;
}
DWORD
LoadIpAddrTable()
{
DWORD dwResult;
TraceEnter("LoadIpAddrTable");
if(g_Cache.pRpcIpAddrTable)
{
HeapFree(g_hPrivateHeap,
0,
g_Cache.pRpcIpAddrTable);
g_Cache.pRpcIpAddrTable = NULL;
}
dwResult = InternalGetIpAddrTable(&(g_Cache.pRpcIpAddrTable),
g_hPrivateHeap,
0);
if(dwResult isnot NO_ERROR)
{
TRACE1("GetIpAddrTable failed with error %x",
dwResult);
TraceLeave("LoadIpAddrTable");
return dwResult;
}
TraceLeave("LoadIpAddrTable");
return NO_ERROR;
}
DWORD
LoadIpNetTable()
{
DWORD dwResult;
TraceEnter("LoadIpNetTable");
if(g_Cache.pRpcIpNetTable)
{
HeapFree(g_hPrivateHeap,
0,
g_Cache.pRpcIpNetTable);
g_Cache.pRpcIpNetTable = NULL;
}
dwResult = InternalGetIpNetTable(&(g_Cache.pRpcIpNetTable),
g_hPrivateHeap,
0);
if(dwResult isnot NO_ERROR)
{
TRACE1("GetIpNetTable failed with error %x",
dwResult);
TraceLeave("LoadIpNetTable");
return dwResult;
}
TraceLeave("LoadIpNetTable");
return NO_ERROR;
}
DWORD
LoadIpForwardTable()
{
DWORD dwResult;
TraceEnter("LoadIpForwardTable");
if(g_Cache.pRpcIpForwardTable)
{
HeapFree(g_hPrivateHeap,
0,
g_Cache.pRpcIpForwardTable);
g_Cache.pRpcIpForwardTable = NULL;
}
dwResult = InternalGetIpForwardTable(&(g_Cache.pRpcIpForwardTable),
g_hPrivateHeap,
0);
if(dwResult isnot NO_ERROR)
{
TRACE1("GetIpForwardTable failed with error %x",
dwResult);
TraceLeave("LoadIpForwardTable");
return dwResult;
}
TraceLeave("LoadIpForwardTable");
return NO_ERROR;
}
DWORD
LoadTcpTable()
{
DWORD dwResult, i;
TraceEnter("LoadTcpTable");
if(g_Cache.pRpcTcpTable)
{
HeapFree(g_hPrivateHeap,
0,
g_Cache.pRpcTcpTable);
g_Cache.pRpcTcpTable = NULL;
}
dwResult = InternalGetTcpTable(&(g_Cache.pRpcTcpTable),
g_hPrivateHeap,
0);
if(dwResult isnot NO_ERROR)
{
TRACE1("GetTcpTable failed with error %x",
dwResult);
TraceLeave("LoadTcpTable");
return dwResult;
}
//
// modify port numbers to be in host byte order
//
for (i = 0; i < g_Cache.pRpcTcpTable->dwNumEntries; i++)
{
g_Cache.pRpcTcpTable->table[i].dwLocalPort =
(DWORD)ntohs((WORD)g_Cache.pRpcTcpTable->table[i].dwLocalPort);
g_Cache.pRpcTcpTable->table[i].dwRemotePort =
(DWORD)ntohs((WORD)g_Cache.pRpcTcpTable->table[i].dwRemotePort);
}
TraceLeave("LoadTcpTable");
return NO_ERROR;
}
DWORD
LoadTcp6Table()
{
DWORD dwResult, i;
TraceEnter("LoadTcp6Table");
if(g_Cache.pRpcTcp6Table)
{
HeapFree(g_hPrivateHeap,
0,
g_Cache.pRpcTcp6Table);
g_Cache.pRpcTcp6Table = NULL;
}
dwResult = AllocateAndGetTcpExTableFromStack(
(TCP_EX_TABLE **)&(g_Cache.pRpcTcp6Table),
TRUE, g_hPrivateHeap, 0, AF_INET6);
if(dwResult isnot NO_ERROR)
{
TRACE1("GetTcp6Table failed with error %x",
dwResult);
TraceLeave("LoadTcp6Table");
return dwResult;
}
//
// modify port numbers to be in host byte order
// and scope ids to be in network byte order
//
for (i = 0; i < g_Cache.pRpcTcp6Table->dwNumEntries; i++)
{
g_Cache.pRpcTcp6Table->table[i].tct_localport =
(DWORD)ntohs((WORD)g_Cache.pRpcTcp6Table->table[i].tct_localport);
g_Cache.pRpcTcp6Table->table[i].tct_remoteport =
(DWORD)ntohs((WORD)g_Cache.pRpcTcp6Table->table[i].tct_remoteport);
g_Cache.pRpcTcp6Table->table[i].tct_localscopeid =
htonl(g_Cache.pRpcTcp6Table->table[i].tct_localscopeid);
g_Cache.pRpcTcp6Table->table[i].tct_remotescopeid =
htonl(g_Cache.pRpcTcp6Table->table[i].tct_remotescopeid);
}
TraceLeave("LoadTcp6Table");
return NO_ERROR;
}
DWORD
LoadUdpTable()
{
DWORD dwResult, i;
TraceEnter("LoadUdpTable");
if(g_Cache.pRpcUdpTable)
{
HeapFree(g_hPrivateHeap,
0,
g_Cache.pRpcUdpTable);
g_Cache.pRpcUdpTable = NULL;
}
dwResult = InternalGetUdpTable(&(g_Cache.pRpcUdpTable),
g_hPrivateHeap,
0);
if(dwResult isnot NO_ERROR)
{
TRACE1("GetUdpTable failed with error %x",
dwResult);
TraceLeave("LoadUdpTable");
return dwResult;
}
//
// modify port numbers to be in host byte order
//
for (i = 0; i < g_Cache.pRpcUdpTable->dwNumEntries; i++)
{
g_Cache.pRpcUdpTable->table[i].dwLocalPort =
(DWORD)ntohs((WORD)g_Cache.pRpcUdpTable->table[i].dwLocalPort);
}
TraceLeave("LoadUdpTable");
return NO_ERROR;
}
DWORD
LoadUdp6ListenerTable()
{
DWORD dwResult, i;
TraceEnter("LoadUdp6ListenerTable");
if(g_Cache.pRpcUdp6ListenerTable)
{
HeapFree(g_hPrivateHeap,
0,
g_Cache.pRpcUdp6ListenerTable);
g_Cache.pRpcUdp6ListenerTable = NULL;
}
dwResult = AllocateAndGetUdpExTableFromStack(
(UDP_EX_TABLE **)&(g_Cache.pRpcUdp6ListenerTable),
TRUE, g_hPrivateHeap, 0, AF_INET6);
if(dwResult isnot NO_ERROR)
{
TRACE1("GetUdp6ListenerTable failed with error %x",
dwResult);
TraceLeave("LoadUdp6ListenerTable");
return dwResult;
}
//
// modify port numbers to be in host byte order
// and scope ids to be in network byte order
//
for (i = 0; i < g_Cache.pRpcUdp6ListenerTable->dwNumEntries; i++)
{
g_Cache.pRpcUdp6ListenerTable->table[i].ule_localport =
(DWORD)ntohs((WORD)g_Cache.pRpcUdp6ListenerTable->table[i].ule_localport);
g_Cache.pRpcUdp6ListenerTable->table[i].ule_localscopeid =
htonl(g_Cache.pRpcUdp6ListenerTable->table[i].ule_localscopeid);
}
TraceLeave("LoadUdp6ListenerTable");
return NO_ERROR;
}
DWORD
GetSysInfo(
MIB_SYSINFO **ppRpcSysInfo,
HANDLE hHeap,
DWORD dwAllocFlags
)
{
DWORD dwResult,dwValueType,dwValueLen;
PMIB_SYSINFO pRpcSysInfo;
HKEY hkeySysInfo;
DWORD dwBytes = 0, i, dwOidLen;
PCHAR pchBuff, pchStr, pchToken;
BOOL bOverride;
TraceEnter("GetSysInfo");
*ppRpcSysInfo = NULL;
pRpcSysInfo = HeapAlloc(hHeap,
dwAllocFlags,
sizeof(MIB_SYSINFO));
if(pRpcSysInfo is NULL)
{
dwResult = GetLastError();
TRACE1("Allocation failed with error %d",
dwResult);
TraceLeave("GetSysInfo");
return dwResult;
}
dwResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
REG_KEY_MIB2,
0,
KEY_ALL_ACCESS,
&hkeySysInfo);
if (dwResult isnot NO_ERROR) {
HeapFree(hHeap,
dwAllocFlags,
pRpcSysInfo);
TRACE1("Couldnt open mib2 registry key. Error %d", dwResult);
TraceLeave("GetSysInfo");
return dwResult;
}
dwValueLen = sizeof(pRpcSysInfo->dwSysServices);
dwResult = RegQueryValueEx(hkeySysInfo,
TEXT("sysServices"),
0,
&dwValueType,
(LPBYTE)&pRpcSysInfo->dwSysServices,
&dwValueLen
);
if (dwResult isnot NO_ERROR) {
HeapFree(hHeap,
dwAllocFlags,
pRpcSysInfo);
TRACE1("Couldnt read sysServices value. Error %d", dwResult);
TraceLeave("GetSysInfo");
return dwResult;
}
bOverride = FALSE;
do
{
//
// First get the length of the OID
//
dwValueLen = 0;
dwResult = RegQueryValueExA(hkeySysInfo,
"sysObjectID",
0,
&dwValueType,
NULL,
&dwValueLen);
if(((dwResult isnot ERROR_MORE_DATA) and (dwResult isnot NO_ERROR)) or
(dwValueLen is 0))
{
//
// The only two codes that give us a good buffer len are
// NO_ERROR and ERROR_MORE_DATA. If the error code is not one
// of those, or if the oid len is 0, just set the OID to system oid
//
break;
}
pchBuff = HeapAlloc(g_hPrivateHeap,
HEAP_ZERO_MEMORY,
dwValueLen + 1);
if(pchBuff is NULL)
{
break;
}
dwResult = RegQueryValueExA(hkeySysInfo,
"sysObjectID",
0,
&dwValueType,
pchBuff,
&dwValueLen);
if((dwResult isnot NO_ERROR) or
(dwValueType isnot REG_SZ) or
(dwValueLen is 0))
{
break;
}
//
// Parse out the oid and store it away
// pchBuff is NULL terminated so we use strtok to overwrite
// all the "." with \0. This way we figure out the number
// of ids. Then we allocate memory to hold those many ids
//
dwOidLen = 1;
pchToken = strtok(pchBuff,".");
while(pchToken)
{
dwOidLen++;
pchToken = strtok(NULL,".");
}
//
// If the leading OID is 0, there is a problem
//
if(atoi(pchBuff) is 0)
{
break;
}
pRpcSysInfo->aaSysObjectID.asnType = ASN_OBJECTIDENTIFIER;
pRpcSysInfo->aaSysObjectID.asnValue.object.idLength = dwOidLen;
pRpcSysInfo->aaSysObjectID.asnValue.object.ids =
SnmpUtilMemAlloc(dwOidLen * sizeof(UINT));
for(i = 0, pchStr = pchBuff; i < dwOidLen; i++)
{
pRpcSysInfo->aaSysObjectID.asnValue.object.ids[i] = atoi(pchStr);
pchStr += strlen(pchStr) + 1;
}
HeapFree(g_hPrivateHeap,
0,
pchBuff);
bOverride = TRUE;
}while(FALSE);
if(!bOverride)
{
SnmpUtilOidCpy(&pRpcSysInfo->aaSysObjectID.asnValue.object,
SnmpSvcGetEnterpriseOID());
}
dwValueLen = sizeof(pRpcSysInfo->rgbySysName);
dwResult = RegQueryValueEx(hkeySysInfo,
TEXT("sysName"),
0,
&dwValueType,
pRpcSysInfo->rgbySysName,
&dwValueLen
);
if (dwResult isnot NO_ERROR) {
TRACE1("Couldnt read sysName value. Error %d", dwResult);
dwValueLen = sizeof(pRpcSysInfo->rgbySysName);
if (!GetComputerNameA(pRpcSysInfo->rgbySysName, &dwValueLen)) {
HeapFree(hHeap,
dwAllocFlags,
pRpcSysInfo);
dwResult = GetLastError();
TRACE1("Couldnt read computer name. Error %d", dwResult);
TraceLeave("GetSysInfo");
return dwResult;
}
}
dwValueLen = sizeof(pRpcSysInfo->rgbySysContact);
dwResult = RegQueryValueEx(hkeySysInfo,
TEXT("sysContact"),
0,
&dwValueType,
pRpcSysInfo->rgbySysContact,
&dwValueLen
);
if (dwResult isnot NO_ERROR) {
pRpcSysInfo->rgbySysContact[0] = '\0';
}
dwValueLen = sizeof(pRpcSysInfo->rgbySysLocation);
dwResult = RegQueryValueEx(hkeySysInfo,
TEXT("sysLocation"),
0,
&dwValueType,
pRpcSysInfo->rgbySysLocation,
&dwValueLen
);
if (dwResult isnot NO_ERROR)
{
pRpcSysInfo->rgbySysLocation[0] = '\0';
}
RegCloseKey(hkeySysInfo);
strcpy(&pRpcSysInfo->rgbySysDescr[dwBytes], TEXT("Hardware: "));
dwBytes += strlen(TEXT("Hardware: "));
dwResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
REG_KEY_CPU,
0,
KEY_QUERY_VALUE |
KEY_ENUMERATE_SUB_KEYS,
&hkeySysInfo);
if (dwResult is NO_ERROR) {
dwValueLen = sizeof(pRpcSysInfo->rgbySysDescr) - dwBytes;
dwResult = RegQueryValueEx(hkeySysInfo,
TEXT("Identifier"),
0,
&dwValueType,
&pRpcSysInfo->rgbySysDescr[dwBytes],
&dwValueLen);
if (dwResult is NO_ERROR) {
dwBytes += dwValueLen - 1;
strcat(&pRpcSysInfo->rgbySysDescr[dwBytes++], TEXT(" "));
} else {
strcat(&pRpcSysInfo->rgbySysDescr[dwBytes], TEXT("CPU Unknown "));
dwBytes += strlen(TEXT("CPU Unknown "));
}
RegCloseKey(hkeySysInfo);
} else {
strcat(&pRpcSysInfo->rgbySysDescr[dwBytes], TEXT("CPU Unknown "));
dwBytes += strlen(TEXT("CPU Unknown "));
}
dwResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
REG_KEY_SYSTEM,
0,
KEY_QUERY_VALUE |
KEY_ENUMERATE_SUB_KEYS,
&hkeySysInfo);
if (dwResult is NO_ERROR) {
dwValueLen = sizeof(pRpcSysInfo->rgbySysDescr) - dwBytes;
dwResult = RegQueryValueEx(hkeySysInfo,
TEXT("Identifier"),
0,
&dwValueType,
&pRpcSysInfo->rgbySysDescr[dwBytes],
&dwValueLen);
if (dwResult is NO_ERROR) {
dwBytes += dwValueLen - 1;
strcat(&pRpcSysInfo->rgbySysDescr[dwBytes++], TEXT(" "));
} else {
strcat(&pRpcSysInfo->rgbySysDescr[dwBytes], TEXT("SystemType Unknown "));
dwBytes += strlen(TEXT("SystemType Unknown "));
}
RegCloseKey(hkeySysInfo);
} else {
strcat(&pRpcSysInfo->rgbySysDescr[dwBytes], TEXT("SystemType Unknown "));
dwBytes += strlen(TEXT("SystemType Unknown "));
}
strcat(&pRpcSysInfo->rgbySysDescr[dwBytes], TEXT("- Software: Windows 2000 Version "));
dwBytes += strlen(TEXT("- Software: Windows 2000 Version "));
dwResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
REG_KEY_VERSION,
0,
KEY_QUERY_VALUE |
KEY_ENUMERATE_SUB_KEYS,
&hkeySysInfo);
if (dwResult is NO_ERROR) {
dwValueLen = sizeof(pRpcSysInfo->rgbySysDescr) - dwBytes;
dwResult = RegQueryValueEx(hkeySysInfo,
TEXT("CurrentVersion"),
0,
&dwValueType,
&pRpcSysInfo->rgbySysDescr[dwBytes],
&dwValueLen);
if (dwResult is NO_ERROR) {
dwBytes += dwValueLen - 1;
strcat(&pRpcSysInfo->rgbySysDescr[dwBytes++], TEXT(" "));
} else {
strcat(&pRpcSysInfo->rgbySysDescr[dwBytes], TEXT("Unknown "));
dwBytes += strlen(TEXT("Unknown "));
}
strcat(&pRpcSysInfo->rgbySysDescr[dwBytes], TEXT("(Build "));
dwBytes += strlen(TEXT("(Build "));
dwValueLen = sizeof(pRpcSysInfo->rgbySysDescr) - dwBytes;
dwResult = RegQueryValueEx(hkeySysInfo,
TEXT("CurrentBuildNumber"),
0,
&dwValueType,
&pRpcSysInfo->rgbySysDescr[dwBytes],
&dwValueLen);
if (dwResult is NO_ERROR) {
dwBytes += dwValueLen - 1;
strcat(&pRpcSysInfo->rgbySysDescr[dwBytes++], TEXT(" "));
} else {
strcat(&pRpcSysInfo->rgbySysDescr[dwBytes], TEXT("Unknown "));
dwBytes += strlen(TEXT("Unknown "));
}
dwValueLen = sizeof(pRpcSysInfo->rgbySysDescr) - dwBytes;
dwResult = RegQueryValueEx(hkeySysInfo,
TEXT("CurrentType"),
0,
&dwValueType,
&pRpcSysInfo->rgbySysDescr[dwBytes],
&dwValueLen);
if (dwResult is NO_ERROR) {
dwBytes += dwValueLen - 1;
strcat(&pRpcSysInfo->rgbySysDescr[dwBytes++], TEXT(")"));
} else {
pRpcSysInfo->rgbySysDescr[dwBytes - 1] = ')';
}
RegCloseKey(hkeySysInfo);
} else {
strcat(&pRpcSysInfo->rgbySysDescr[dwBytes], TEXT("Unknown"));
dwBytes += strlen(TEXT("Unknown"));
}
*ppRpcSysInfo = pRpcSysInfo;
TraceLeave("GetSysInfo");
return NO_ERROR;
}