/*
* gendll.c v0.11 March 14, 1996
*
****************************************************************************
* *
* (C) Copyright 1995, 1996 DIGITAL EQUIPMENT CORPORATION *
* *
* This software is an unpublished work protected under the *
* the copyright laws of the United States of America, all *
* rights reserved. *
* *
* In the event this software is licensed for use by the United *
* States Government, all use, duplication or disclosure by the *
* United States Government is subject to restrictions as set *
* forth in either subparagraph (c)(1)(ii) of the Rights in *
* Technical Data And Computer Software Clause at DFARS *
* 252.227-7013, or the Commercial Computer Software Restricted *
* Rights Clause at FAR 52.221-19, whichever is applicable. *
* *
****************************************************************************
*
* Facility:
*
* SNMP Extension Agent
*
* Abstract:
*
* This module contains the code for plugging into the Windows NT Extendible
* Agent. It contains the dll's main routine and the three exported SNMP
* routines.
*
* Functions:
*
* DllMain()
* SnmpExtensionInit()
* SnmpExtensionTrap()
* SnmpExtensionQuery()
*
* Author:
* Miriam Amos Nihart, Kathy Faust
*
* Date:
* 2/17/95
*
* Revision History:
* 6/26/95 KKF, register using Subroot_oid
* 7/31/95 ags readded above code + uncommented calls to SNMP_oidfree
* 3/14/96 kkf, modified SNMPExtensionTrap
*/
// General notes:
//
// Microsoft's Extendible Agent for Windows NT is implemented by dynamically
// linking to Extension Agent DLLs that implement portions of the MIB. These
// Extension Agents are configured in the Windows NT Registration Database.
// When the Extendible Agent Service is started, it queries the registry to
// determine which Extension Agent DLLs have been installed and need to be
// loaded and initialized. The Extendible Agent invokes various DLL entry
// points (examples follow in this file) to request MIB queries and obtain
// Extension Agent generated traps.
// Necessary includes.
#include <windows.h>
#include <malloc.h>
#include <stdio.h>
#include <snmp.h>
//
// The file mib.h is a user supplied header file (could be from a code
// generator). This file should contain the definition, macros, forward
// declarations, etc. The file mib_xtrn.h contains the external
// declarations for the variable tables and classes composing this MIB.
//
#include "mib.h"
#include "mib_xtrn.h"
// Extension Agent DLLs need access to the elapsed time that the agent has
// been active. This is implemented by initializing the Extension Agent
// with a time zero reference, and allowing the agent to compute elapsed
// time by subtracting the time zero reference from the current system time.
// This example Extension Agent implements this reference with dwTimeZero.
DWORD dwTimeZero = 0 ;
extern DWORD dwTimeZero ;
//
// Trap Queue
//
q_hdr_t trap_q = { NULL, NULL } ;
extern q_hdr_t trap_q ; // make it global
HANDLE hTrapQMutex ;
extern HANDLE hTrapQMutex ;
HANDLE hEnabledTraps ;
extern HANDLE hEnabledTraps ;
/*
* DllMain
*
* This is a standard Win32 DLL entry point. See the Win32 SDK for more
* information on its arguments and their meanings. This example DLL does
* not perform any special actions using this mechanism.
*
* Arguments:
*
* Results:
*
* Side Effects:
*
*/
BOOL WINAPI
DllMain( HANDLE hDll ,
DWORD dwReason ,
LPVOID lpReserved )
{
switch( dwReason )
{
case DLL_PROCESS_ATTACH :
case DLL_PROCESS_DETACH :
case DLL_THREAD_ATTACH :
case DLL_THREAD_DETACH :
default :
break ;
}
return TRUE ;
} /* end of DllMain() (the DllEntryPoint) */
/*
* SnmpExtensionInit
*
* Extension Agent DLLs provide the following entry point to coordinate the
* initializations of the Extension Agent and the Extendible Agent. The
* Extendible Agent provides the Extension Agent with a time zero reference;
* and the Extension Agent provides the Extendible Agent with an Event
* handle for communicating occurence of traps, and an object identifier
* representing the root of the MIB subtree that the Extension Agent
* supports.
*
* Traps support is determined by the user in the UserMibInit() routine.
* If a valid handle from CreateEvent() is returned in the argument
* hPollForTrapEvent, then traps have been implemented and the SNMP
* Extendible Agent will poll this Extension Agent to retrieve the traps
* upon notification through the SetEvent() routine. Polling is done
* through the SnmpExtensionTrap() routine. If NULL is returned in the
* argument hPollForTrapEvent, there are no traps.
*
* Arguments:
*
* Results:
*
*/
BOOL WINAPI
SnmpExtensionInit( IN DWORD dwTimeZeroReference ,
OUT HANDLE *hPollForTrapEvent ,
OUT AsnObjectIdentifier *supportedView )
{
// Record the time reference provided by the Extendible Agent.
dwTimeZero = dwTimeZeroReference ;
// Indicate the MIB view supported by this Extension Agent, an object
// identifier representing the sub root of the MIB that is supported.
*supportedView = Subroot_oid ; // NOTE! structure copy
// *supportedView = *(class_info[ 0 ].oid) ; // NOTE! structure copy
// Call the User's initialization routine
if ( !UserMibInit( hPollForTrapEvent ) )
return FALSE ;
// Indicate that Extension Agent initialization was successful.
return TRUE ;
} /* end of SnmpExtensionInit() */
/*
* SnmpExtensionTrap
*
* Extension Agent DLLs provide the following entry point to communicate
* traps to the Extendible Agent. The Extendible Agent will query this
* entry point when the trap Event (supplied at initialization time) is
* asserted, which indicates that zero or more traps may have occured.
* The Extendible Agent will repetedly call this entry point until FALSE
* is returned, indicating that all outstanding traps have been processed.
*
* Arguments:
*
* Results:
*
|=========================================================================
| There are no Traps associated with the HostMIB. Consequently this
| routine is taken over and used to refresh the cached information
| associated with SNMP attribute "hrProcessorLoad" (in "HRPROCES.C") thru
| a call to function "hrProcessLoad_Refresh()" (also in "HRPROCES.C").
|
| This function is being entered because a timer has expired that was
| initialized by code in "TrapInit()" (in "GENNT.C"). The timer automatically
| resets itself.
|
| All the standard generated code is subsumed by a simple call to
| "hrProcessLoad_Refresh()".
*/
BOOL WINAPI
SnmpExtensionTrap( OUT AsnObjectIdentifier *enterprise ,
OUT AsnInteger *genericTrap ,
OUT AsnInteger *specificTrap ,
OUT AsnTimeticks *timeStamp ,
OUT RFC1157VarBindList *variableBindings )
{
#if 0
tcb_t *entry ;
// Traps are process by processing the traps on the trap queue.
// The Extendible Agent will call this routine upon the receipt of
// the event on the handle passed back in the SnmpExtensionInit routine.
// The Extendible Agent calls this return back as long as this routine
// returns true.
// acquire mutex for trap_q
WaitForSingleObject( hTrapQMutex, INFINITE ) ;
// Dequeue a trap entry
QUEUE_REMOVE( trap_q, entry ) ;
// release the mutex for trap_q
ReleaseMutex( hTrapQMutex ) ;
if (entry == NULL)
return FALSE ;
*enterprise = entry->enterprise ; // note structure copy
*genericTrap = entry->genericTrap ;
*specificTrap = entry->specificTrap ;
*timeStamp = entry->timeStamp ;
*variableBindings = entry->varBindList ; // note structure copy
free(entry) ;
return TRUE ;
#endif
/*
|========================
| Special HostMIB code:
*/
/* Re-fetch CPU statistics from kernel */
hrProcessLoad_Refresh();
/* Don't call again until the timer goes off again */
return FALSE;
} /* end of SnmpExtensionTrap() */
/*
* SnmpExtensionQuery
*
* Extension Agent DLLs provide the following entry point to resolve queries
* for MIB variables in their supported MIB view (supplied at initialization
* time). The requestType is Get/GetNext/Set.
*
* Arguments:
*
* Results:
*
*/
BOOL WINAPI
SnmpExtensionQuery( IN BYTE requestType ,
IN OUT RFC1157VarBindList *variableBindings ,
OUT AsnInteger *errorStatus ,
OUT AsnInteger *errorIndex )
{
UINT index ;
UINT *tmp ;
UINT status ;
// Iterate through the variable bindings list to resolve individual
// variable bindings.
for ( index = 0 ; index < variableBindings->len ; index++ )
{
*errorStatus = ResolveVarBind( &variableBindings->list[ index ] ,
requestType ) ;
// Test and handle case where Get Next past end of MIB view supported
// by this Extension Agent occurs. Special processing is required to
// communicate this situation to the Extendible Agent so it can take
// appropriate action, possibly querying other Extension Agents.
if ( *errorStatus == SNMP_ERRORSTATUS_NOSUCHNAME &&
requestType == MIB_ACTION_GETNEXT )
{
*errorStatus = SNMP_ERRORSTATUS_NOERROR ;
// Modify variable binding of such variables so the OID points
// just outside the MIB view supported by this Extension Agent.
// The Extendible Agent tests for this, and takes appropriate
// action.
SNMP_oidfree( &variableBindings->list[ index ].name ) ;
status = SNMP_oidcpy( &variableBindings->list[ index ].name, &Subroot_oid ) ;
if ( !status )
{
*errorStatus = SNMP_ERRORSTATUS_GENERR;
}
else
{
tmp = variableBindings->list[ index ].name.ids ;
(tmp[ SUBROOT_LENGTH - 1 ])++ ;
}
}
// If an error was indicated, communicate error status and error
// index to the Extendible Agent. The Extendible Agent will ensure
// that the origional variable bindings are returned in the response
// packet.
if ( *errorStatus != SNMP_ERRORSTATUS_NOERROR )
{
*errorIndex = index + 1 ;
goto Exit ;
}
}
Exit:
// Indicate that Extension Agent processing was sucessfull.
return SNMPAPI_NOERROR ;
} /* end of SnmpExtensionQuery() */
/* end of gendll.c */