You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
930 lines
21 KiB
930 lines
21 KiB
/*++
|
|
|
|
Copyright (c) 1992-1997 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
subagnts.c
|
|
|
|
Abstract:
|
|
|
|
Contains definitions for manipulating subagent structures.
|
|
|
|
Environment:
|
|
|
|
User Mode - Win32
|
|
|
|
Revision History:
|
|
|
|
10-Feb-1997 DonRyan
|
|
Rewrote to implement SNMPv2 support.
|
|
|
|
--*/
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Include files //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "globals.h"
|
|
#include "subagnts.h"
|
|
#include "regions.h"
|
|
#include "snmpmgmt.h"
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Private procedures //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL
|
|
FindSubagent(
|
|
PSUBAGENT_LIST_ENTRY * ppSLE,
|
|
LPSTR pPathname
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Locates subagent in list.
|
|
|
|
Arguments:
|
|
|
|
ppSLE - pointer to receive pointer to entry.
|
|
|
|
pPathname - pointer to pathname to find.
|
|
|
|
Return Values:
|
|
|
|
Returns true if successful.
|
|
|
|
--*/
|
|
|
|
{
|
|
PLIST_ENTRY pLE;
|
|
PSUBAGENT_LIST_ENTRY pSLE;
|
|
|
|
// initialize
|
|
*ppSLE = NULL;
|
|
|
|
// obtain pointer to head
|
|
pLE = g_Subagents.Flink;
|
|
|
|
// process all entries in list
|
|
while (pLE != &g_Subagents) {
|
|
|
|
// retrieve pointer to trap destination structure
|
|
pSLE = CONTAINING_RECORD(pLE, SUBAGENT_LIST_ENTRY, Link);
|
|
|
|
// compare pathname string with entry
|
|
if (!strcmp(pSLE->pPathname, pPathname)) {
|
|
|
|
// transfer
|
|
*ppSLE = pSLE;
|
|
|
|
// success
|
|
return TRUE;
|
|
}
|
|
|
|
// next entry
|
|
pLE = pLE->Flink;
|
|
}
|
|
|
|
// failure
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
AddSubagentRegion(
|
|
PSUBAGENT_LIST_ENTRY pSLE,
|
|
AsnObjectIdentifier * pPrefixOid
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Adds subagent supported region to structure.
|
|
|
|
Arguments:
|
|
|
|
pSLE - pointer to subagent structure.
|
|
|
|
pPrefixOid - pointer to supported region.
|
|
|
|
Return Values:
|
|
|
|
Returns true if successful.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL fOk = FALSE;
|
|
PMIB_REGION_LIST_ENTRY pRLE = NULL;
|
|
|
|
// allocate region
|
|
if (AllocRLE(&pRLE)) {
|
|
|
|
// copy prefix to structure
|
|
if (SnmpUtilOidCpy(&pRLE->PrefixOid, pPrefixOid) == 0)
|
|
{
|
|
FreeRLE(pRLE);
|
|
return fOk;
|
|
}
|
|
|
|
// copy prefix as temporary limit
|
|
if (SnmpUtilOidCpy(&pRLE->LimitOid, pPrefixOid) == 0)
|
|
{
|
|
FreeRLE(pRLE);
|
|
return fOk;
|
|
}
|
|
|
|
// save pointer
|
|
pRLE->pSLE = pSLE;
|
|
|
|
// modify limit oid to be one past the prefix
|
|
++pRLE->LimitOid.ids[pRLE->LimitOid.idLength - 1];
|
|
|
|
SNMPDBG((
|
|
SNMP_LOG_TRACE,
|
|
"SNMP: SVC: %s supports %s.\n",
|
|
pSLE->pPathname,
|
|
SnmpUtilOidToA(&pRLE->PrefixOid)
|
|
));
|
|
|
|
// attach to mib region to subagent structure
|
|
InsertTailList(&pSLE->SupportedRegions, &pRLE->Link);
|
|
|
|
// success
|
|
fOk = TRUE;
|
|
}
|
|
|
|
return fOk;
|
|
}
|
|
|
|
BOOL
|
|
OfferInternalMgmtVariables(
|
|
PSUBAGENT_LIST_ENTRY pSLE
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
if the subagent is willing to monitor the SNMP service
|
|
this function is offering it a pointer to the internal
|
|
management variables
|
|
|
|
Arguments:
|
|
|
|
pSLE - pointer to subagent structure.
|
|
|
|
Return Values:
|
|
|
|
Returns true anyway.
|
|
|
|
--*/
|
|
{
|
|
if (pSLE->pfnSnmpExtensionMonitor != NULL)
|
|
{
|
|
__try {
|
|
|
|
// attempt to initialize agent
|
|
(*pSLE->pfnSnmpExtensionMonitor)(&snmpMgmtBase);
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
SNMPDBG((
|
|
SNMP_LOG_ERROR,
|
|
"SNMP: SVC: exception 0x%08lx offering internals to %s.\n",
|
|
GetExceptionCode(),
|
|
pSLE->pPathname
|
|
));
|
|
|
|
// failure
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
LoadSubagentRegions(
|
|
PSUBAGENT_LIST_ENTRY pSLE
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads subagent supported regions.
|
|
|
|
Arguments:
|
|
|
|
pSLE - pointer to subagent structure.
|
|
|
|
Return Values:
|
|
|
|
Returns true if successful.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL fOk = FALSE;
|
|
HANDLE hSubagentTrapEvent = NULL;
|
|
AsnObjectIdentifier PrefixOid = { 0, NULL };
|
|
|
|
__try {
|
|
|
|
// attempt to initialize agent
|
|
if ((*pSLE->pfnSnmpExtensionInit)(
|
|
g_dwUpTimeReference,
|
|
&hSubagentTrapEvent,
|
|
&PrefixOid
|
|
)) {
|
|
|
|
// store subagent trap event handle
|
|
pSLE->hSubagentTrapEvent = hSubagentTrapEvent;
|
|
|
|
// add subagent region to list entry
|
|
fOk = AddSubagentRegion(pSLE, &PrefixOid);
|
|
|
|
// check to see if subagent supports additional regions
|
|
if (fOk && (pSLE->pfnSnmpExtensionInitEx != NULL)) {
|
|
|
|
BOOL fMoreRegions = TRUE;
|
|
|
|
// get other regions
|
|
while (fOk && fMoreRegions) {
|
|
|
|
// retrieve next supported region
|
|
fMoreRegions = (*pSLE->pfnSnmpExtensionInitEx)(
|
|
&PrefixOid
|
|
);
|
|
|
|
// validate
|
|
if (fMoreRegions) {
|
|
|
|
// add subagent region to list entry
|
|
fOk = AddSubagentRegion(pSLE, &PrefixOid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
SNMPDBG((
|
|
SNMP_LOG_ERROR,
|
|
"SNMP: SVC: exception 0x%08lx loading %s.\n",
|
|
GetExceptionCode(),
|
|
pSLE->pPathname
|
|
));
|
|
|
|
// failure
|
|
fOk = FALSE;
|
|
}
|
|
|
|
return fOk;
|
|
}
|
|
|
|
|
|
BOOL
|
|
LoadSubagent(
|
|
PSUBAGENT_LIST_ENTRY pSLE
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Loads subagent dll and initializes.
|
|
|
|
Arguments:
|
|
|
|
pSLE - pointer to subagent structure.
|
|
|
|
Return Values:
|
|
|
|
Returns true if successful.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL fOk = FALSE;
|
|
|
|
// attempt to load subagent library - we use the altered search path flag so that
|
|
// the subagent can load DLLs that live in its directory
|
|
pSLE->hSubagentDll = LoadLibraryExA(pSLE->pPathname, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
|
|
|
|
// validate handle
|
|
if (pSLE->hSubagentDll != NULL) {
|
|
|
|
// load primary initialization routine
|
|
pSLE->pfnSnmpExtensionInit = (PFNSNMPEXTENSIONINIT)
|
|
GetProcAddress(
|
|
pSLE->hSubagentDll,
|
|
SNMP_EXTENSION_INIT
|
|
);
|
|
|
|
// load secondary initialization routine
|
|
pSLE->pfnSnmpExtensionInitEx = (PFNSNMPEXTENSIONINITEX)
|
|
GetProcAddress(
|
|
pSLE->hSubagentDll,
|
|
SNMP_EXTENSION_INIT_EX
|
|
);
|
|
|
|
// load secondary initialization routine
|
|
pSLE->pfnSnmpExtensionClose = (PFNSNMPEXTENSIONCLOSE)
|
|
GetProcAddress(
|
|
pSLE->hSubagentDll,
|
|
SNMP_EXTENSION_CLOSE
|
|
);
|
|
|
|
// load the extension monitor routine
|
|
pSLE->pfnSnmpExtensionMonitor = (PFNSNMPEXTENSIONMONITOR)
|
|
GetProcAddress(
|
|
pSLE->hSubagentDll,
|
|
SNMP_EXTENSION_MONITOR
|
|
);
|
|
|
|
// load snmpv1-based subagent request routine
|
|
pSLE->pfnSnmpExtensionQuery = (PFNSNMPEXTENSIONQUERY)
|
|
GetProcAddress(
|
|
pSLE->hSubagentDll,
|
|
SNMP_EXTENSION_QUERY
|
|
);
|
|
|
|
// load snmpv2-based subagent request routine
|
|
pSLE->pfnSnmpExtensionQueryEx = (PFNSNMPEXTENSIONQUERYEX)
|
|
GetProcAddress(
|
|
pSLE->hSubagentDll,
|
|
SNMP_EXTENSION_QUERY_EX
|
|
);
|
|
|
|
// load snmpv1-based subagent trap routine
|
|
pSLE->pfnSnmpExtensionTrap = (PFNSNMPEXTENSIONTRAP)
|
|
GetProcAddress(
|
|
pSLE->hSubagentDll,
|
|
SNMP_EXTENSION_TRAP
|
|
);
|
|
|
|
// validate subagent agent entry points
|
|
if ((pSLE->pfnSnmpExtensionInit != NULL) &&
|
|
((pSLE->pfnSnmpExtensionQuery != NULL) ||
|
|
(pSLE->pfnSnmpExtensionQueryEx != NULL))) {
|
|
|
|
// load supported regions
|
|
if (fOk = LoadSubagentRegions(pSLE)) // !!intentional assignement!!
|
|
{
|
|
// offering internal management variables;
|
|
fOk = OfferInternalMgmtVariables(pSLE);
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
DWORD errCode = GetLastError();
|
|
LPTSTR pPathname;
|
|
|
|
#ifdef UNICODE
|
|
SnmpUtilUTF8ToUnicode(&pPathname, pSLE->pPathname, TRUE);
|
|
#else
|
|
pPathname = pSLE->pPathname;
|
|
#endif
|
|
|
|
SNMPDBG((
|
|
SNMP_LOG_ERROR,
|
|
"SNMP: SVC: error %d loading subagent.\n",
|
|
errCode
|
|
));
|
|
|
|
ReportSnmpEvent(
|
|
SNMP_EVENT_INVALID_EXTENSION_AGENT_DLL,
|
|
1,
|
|
&pPathname,
|
|
errCode);
|
|
|
|
#ifdef UNICODE
|
|
SnmpUtilMemFree(pPathname);
|
|
#endif
|
|
}
|
|
|
|
return fOk;
|
|
}
|
|
|
|
|
|
BOOL
|
|
AddSubagentByDll(
|
|
LPSTR pPathname,
|
|
UCHAR uchInitFlags
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Adds subagent to list.
|
|
|
|
Arguments:
|
|
|
|
pPathname - pointer to subagent's dll path.
|
|
|
|
Return Values:
|
|
|
|
Returns true if successful.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL fOk = FALSE;
|
|
PSUBAGENT_LIST_ENTRY pSLE = NULL;
|
|
|
|
// attempt to locate in list
|
|
if (FindSubagent(&pSLE, pPathname)) {
|
|
|
|
SNMPDBG((
|
|
SNMP_LOG_WARNING,
|
|
"SNMP: SVC: duplicate entry for %s.\n",
|
|
pPathname
|
|
));
|
|
|
|
// success
|
|
fOk = TRUE;
|
|
|
|
} else {
|
|
|
|
// allocate subagent structure
|
|
if (AllocSLE(&pSLE, pPathname, uchInitFlags)) {
|
|
|
|
SNMPDBG((
|
|
SNMP_LOG_TRACE,
|
|
"SNMP: SVC: processing subagent %s.\n",
|
|
pPathname
|
|
));
|
|
|
|
// initialize subagent
|
|
if (LoadSubagent(pSLE)) {
|
|
|
|
// insert into valid communities list
|
|
InsertTailList(&g_Subagents, &pSLE->Link);
|
|
|
|
// success
|
|
fOk = TRUE;
|
|
}
|
|
|
|
// cleanup
|
|
if (!fOk) {
|
|
|
|
// release
|
|
FreeSLE(pSLE);
|
|
}
|
|
}
|
|
}
|
|
|
|
return fOk;
|
|
}
|
|
|
|
|
|
BOOL
|
|
AddSubagentByKey(
|
|
LPTSTR pKey
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Adds subagent to list.
|
|
|
|
Arguments:
|
|
|
|
pKey - pointer to subagent's registry key path.
|
|
|
|
Return Values:
|
|
|
|
Returns true if successful.
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY hKey;
|
|
LONG lStatus;
|
|
DWORD dwIndex;
|
|
DWORD dwNameSize;
|
|
DWORD dwValueSize;
|
|
DWORD dwValueType;
|
|
CHAR szName[MAX_PATH];
|
|
CHAR szValue[MAX_PATH];
|
|
BOOL fOk = FALSE;
|
|
PSUBAGENT_LIST_ENTRY pSLE = NULL;
|
|
|
|
|
|
// open registry subkey
|
|
lStatus = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
pKey,
|
|
0,
|
|
KEY_READ,
|
|
&hKey
|
|
);
|
|
|
|
// validate return code
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
|
|
// initialize
|
|
dwIndex = 0;
|
|
|
|
// initialize buffer sizes
|
|
dwNameSize = sizeof(szName)/sizeof(szName[0]); // size in TCHARs
|
|
dwValueSize = sizeof(szValue); // size in bytes
|
|
|
|
// loop until error or end of list
|
|
while (lStatus == ERROR_SUCCESS) {
|
|
|
|
// read next value
|
|
lStatus = RegEnumValueA(
|
|
hKey,
|
|
dwIndex,
|
|
szName,
|
|
&dwNameSize,
|
|
NULL,
|
|
&dwValueType,
|
|
szValue,
|
|
&dwValueSize
|
|
);
|
|
|
|
// validate return code
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
|
|
if (dwValueType == REG_EXPAND_SZ || dwValueType == REG_SZ)
|
|
{
|
|
|
|
// check to see if value is pathname
|
|
if (!_stricmp(szName, REG_VALUE_SUBAGENT_PATH)) {
|
|
|
|
DWORD dwRequired;
|
|
CHAR szExpanded[MAX_PATH];
|
|
|
|
// expand environment strings in path
|
|
dwRequired = ExpandEnvironmentStringsA(
|
|
szValue,
|
|
szExpanded,
|
|
sizeof(szExpanded)/sizeof(szExpanded[0])
|
|
);
|
|
|
|
if ((dwRequired != 0) &&
|
|
(dwRequired <= sizeof(szExpanded)/sizeof(szExpanded[0]))
|
|
)
|
|
{
|
|
|
|
// load subagent library - no flags set
|
|
fOk = AddSubagentByDll(szExpanded, 0);
|
|
}
|
|
|
|
break; // bail...
|
|
}
|
|
}
|
|
|
|
// initialize buffer sizes
|
|
dwNameSize = sizeof(szName)/sizeof(szName[0]);
|
|
dwValueSize = sizeof(szValue);
|
|
|
|
// next
|
|
dwIndex++;
|
|
|
|
} else if (lStatus == ERROR_NO_MORE_ITEMS) {
|
|
|
|
// failure
|
|
fOk = FALSE;
|
|
}
|
|
}
|
|
|
|
// release handle
|
|
RegCloseKey(hKey);
|
|
}
|
|
else
|
|
{
|
|
// the registry key for this subagent could not be located.
|
|
ReportSnmpEvent(
|
|
SNMP_EVENT_INVALID_EXTENSION_AGENT_KEY,
|
|
1,
|
|
&pKey,
|
|
lStatus);
|
|
}
|
|
|
|
return fOk;
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Public procedures //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
BOOL
|
|
AllocSLE(
|
|
PSUBAGENT_LIST_ENTRY * ppSLE,
|
|
LPSTR pPathname,
|
|
UCHAR uchInitFlags
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Allocates trap destination structure and initializes.
|
|
|
|
Arguments:
|
|
|
|
ppSLE - pointer to receive pointer to entry.
|
|
|
|
pPathname - pointer to subgent's dll path.
|
|
|
|
Return Values:
|
|
|
|
Returns true if successful.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL fOk = FALSE;
|
|
PSUBAGENT_LIST_ENTRY pSLE = NULL;
|
|
|
|
// attempt to allocate structure
|
|
pSLE = AgentMemAlloc(sizeof(SUBAGENT_LIST_ENTRY));
|
|
|
|
// validate
|
|
if (pSLE != NULL) {
|
|
|
|
// allocate memory for trap destination string
|
|
pSLE->pPathname = AgentMemAlloc(strlen(pPathname)+1);
|
|
|
|
// validate
|
|
if (pSLE->pPathname != NULL) {
|
|
|
|
// transfer trap destination string
|
|
strcpy(pSLE->pPathname, pPathname);
|
|
|
|
// set the initial flags value
|
|
pSLE->uchFlags = uchInitFlags;
|
|
|
|
// initialize list of supported regions
|
|
InitializeListHead(&pSLE->SupportedRegions);
|
|
|
|
// success
|
|
fOk = TRUE;
|
|
}
|
|
|
|
// cleanup
|
|
if (!fOk) {
|
|
|
|
// release
|
|
FreeSLE(pSLE);
|
|
|
|
// re-init
|
|
pSLE = NULL;
|
|
}
|
|
}
|
|
|
|
// transfer
|
|
*ppSLE = pSLE;
|
|
|
|
return fOk;
|
|
}
|
|
|
|
|
|
BOOL
|
|
FreeSLE(
|
|
PSUBAGENT_LIST_ENTRY pSLE
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Releases subagent structure.
|
|
|
|
Arguments:
|
|
|
|
pSLE - pointer to list entry to be freed.
|
|
|
|
Return Values:
|
|
|
|
Returns true if successful.
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL fOk = TRUE;
|
|
|
|
// validate pointer
|
|
if (pSLE != NULL) {
|
|
|
|
SNMPDBG((
|
|
SNMP_LOG_VERBOSE,
|
|
"SNMP: SVC: unloading %s.\n",
|
|
pSLE->pPathname
|
|
));
|
|
|
|
// release manager structures
|
|
UnloadRegions(&pSLE->SupportedRegions);
|
|
|
|
// validate subagent dll handle
|
|
if (pSLE->hSubagentDll != NULL) {
|
|
|
|
__try {
|
|
if (pSLE->pfnSnmpExtensionClose != NULL)
|
|
(*pSLE->pfnSnmpExtensionClose)();
|
|
|
|
|
|
} __except (EXCEPTION_EXECUTE_HANDLER) {
|
|
|
|
SNMPDBG((
|
|
SNMP_LOG_ERROR,
|
|
"SNMP: SVC: exception 0x%08lx unloading %s.\n",
|
|
GetExceptionCode(),
|
|
pSLE->pPathname
|
|
));
|
|
|
|
}
|
|
|
|
// unload subagent
|
|
FreeLibrary(pSLE->hSubagentDll);
|
|
pSLE->hSubagentDll = NULL;
|
|
}
|
|
|
|
// release string
|
|
AgentMemFree(pSLE->pPathname);
|
|
|
|
// release structure
|
|
AgentMemFree(pSLE);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
LoadSubagents(
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Constructs list of subagents.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Values:
|
|
|
|
Returns true if successful.
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY hKey;
|
|
LONG lStatus;
|
|
DWORD dwIndex;
|
|
DWORD dwNameSize;
|
|
DWORD dwValueSize;
|
|
DWORD dwValueType;
|
|
TCHAR szName[MAX_PATH];
|
|
TCHAR szValue[MAX_PATH];
|
|
LPTSTR pszKey = REG_KEY_EXTENSION_AGENTS;
|
|
BOOL fOk = FALSE;
|
|
|
|
SNMPDBG((
|
|
SNMP_LOG_TRACE,
|
|
"SNMP: SVC: loading subagents.\n"
|
|
));
|
|
|
|
// Open the ..SNMP\Parameters\ExtensionAgents subkey
|
|
lStatus = RegOpenKeyEx(
|
|
HKEY_LOCAL_MACHINE,
|
|
pszKey,
|
|
0,
|
|
KEY_READ,
|
|
&hKey
|
|
);
|
|
|
|
// validate return code
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
|
|
// initialize
|
|
dwIndex = 0;
|
|
|
|
// initialize buffer sizes
|
|
dwNameSize = sizeof(szName) / sizeof(szName[0]); // size in number of TCHARs
|
|
dwValueSize = sizeof(szValue); // size in number of bytes
|
|
|
|
// loop until error or end of list
|
|
while (lStatus == ERROR_SUCCESS) {
|
|
|
|
// read next value
|
|
lStatus = RegEnumValue(
|
|
hKey,
|
|
dwIndex,
|
|
szName,
|
|
&dwNameSize,
|
|
NULL,
|
|
&dwValueType,
|
|
(LPBYTE)szValue,
|
|
&dwValueSize
|
|
);
|
|
|
|
// validate return code
|
|
if (lStatus == ERROR_SUCCESS) {
|
|
|
|
if (dwValueType == REG_SZ)
|
|
{
|
|
|
|
// add subagent to list
|
|
AddSubagentByKey(szValue);
|
|
}
|
|
|
|
// re-initialize buffer sizes
|
|
dwNameSize = sizeof(szName) / sizeof(szName[0]); // size in number of TCHARs
|
|
dwValueSize = sizeof(szValue); // size in number of bytes
|
|
|
|
// next
|
|
dwIndex++;
|
|
|
|
} else if (lStatus == ERROR_NO_MORE_ITEMS) {
|
|
|
|
// success
|
|
fOk = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!fOk) {
|
|
|
|
SNMPDBG((
|
|
SNMP_LOG_ERROR,
|
|
"SNMP: SVC: error %d processing Subagents subkey.\n",
|
|
lStatus
|
|
));
|
|
|
|
// report event
|
|
ReportSnmpEvent(
|
|
SNMP_EVENT_INVALID_REGISTRY_KEY,
|
|
1,
|
|
&pszKey,
|
|
lStatus
|
|
);
|
|
}
|
|
|
|
return fOk;
|
|
}
|
|
|
|
|
|
BOOL
|
|
UnloadSubagents(
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Destroys list of subagents.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Values:
|
|
|
|
Returns true if successful.
|
|
|
|
--*/
|
|
|
|
{
|
|
PLIST_ENTRY pLE;
|
|
PSUBAGENT_LIST_ENTRY pSLE;
|
|
|
|
// process entries until list is empty
|
|
while (!IsListEmpty(&g_Subagents)) {
|
|
|
|
// extract next entry from head of list
|
|
pLE = RemoveHeadList(&g_Subagents);
|
|
|
|
// retrieve pointer to community structure
|
|
pSLE = CONTAINING_RECORD(pLE, SUBAGENT_LIST_ENTRY, Link);
|
|
|
|
// release
|
|
FreeSLE(pSLE);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|