home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 8 / CDASC08.ISO / VRAC / SNMPKT.ZIP / TESTDLL.C < prev    next >
C/C++ Source or Header  |  1992-11-13  |  10KB  |  296 lines
  1. /*++ BUILD Version: 0001    // Increment this if a change has global effects
  2.  
  3. Copyright (c) 1991  Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     testdll.c
  8.  
  9. Abstract:
  10.  
  11.     Sample SNMP Extension Agent for Windows NT.
  12.  
  13.     These files (testdll.c, testmib.c, and testmib.h) provide an example of 
  14.     how to structure an Extension Agent DLL which works in conjunction with 
  15.     the SNMP Extendible Agent for Windows NT.
  16.  
  17.     Extensive comments have been included to describe its structure and
  18.     operation.  See also "Microsoft Windows/NT SNMP Programmer's Reference".
  19.  
  20. Created:
  21.  
  22.     28-Jun-1991
  23.  
  24. Revision History:
  25.  
  26. --*/
  27.  
  28.  
  29.  
  30.  
  31. // General notes:
  32. //
  33. //   Microsoft's Extendible Agent for Windows NT is implemented by dynamically
  34. // linking to Extension Agent DLLs that implement portions of the MIB.  These
  35. // Extension Agents are configured in the Windows NT Registration Database.
  36. // When the Extendible Agent Service is started, it queries the registry to
  37. // determine which Extension Agent DLLs have been installed and need to be
  38. // loaded and initialized.  The Extendible Agent invokes various DLL entry
  39. // points (examples follow in this file) to request MIB queries and obtain
  40. // Extension Agent generated traps.
  41.  
  42.  
  43. // Necessary includes.
  44.  
  45. #include <windows.h>
  46. #include <malloc.h>
  47.  
  48. #include <snmp.h>
  49.  
  50.  
  51. // Contains definitions for the table structure describing the MIB.  This
  52. // is used in conjunction with testmib.c where the MIB requests are resolved.
  53.  
  54. #include "testmib.h"
  55.  
  56.  
  57. // Extension Agent DLLs need access to elapsed time agent has been active.
  58. // This is implemented by initializing the Extension Agent with a time zero
  59. // reference, and allowing the agent to compute elapsed time by subtracting
  60. // the time zero reference from the current system time.  This example
  61. // Extension Agent implements this reference with dwTimeZero.
  62.  
  63. DWORD dwTimeZero = 0;
  64.  
  65.  
  66. // Extension Agent DLLs that generate traps must create a Win32 Event object
  67. // to communicate occurence of traps to the Extendible Agent.  The event
  68. // handle is given to the Extendible Agent when the Extension Agent is 
  69. // initialized, it should be NULL if traps will not be generated.  This
  70. // example Extension Agent simulates the occurance of traps with hSimulateTrap.
  71.  
  72. HANDLE hSimulateTrap = NULL;
  73.  
  74.  
  75. // This is a standard Win32 DLL entry point.  See the Win32 SDK for more
  76. // information on its arguments and their meanings.  This example DLL does 
  77. // not perform any special actions using this mechanism.
  78.  
  79. BOOL APIENTRY LibMain(
  80.     HANDLE hDll,
  81.     DWORD  dwReason,
  82.     LPVOID lpReserved)
  83.     {
  84.     switch(dwReason)
  85.         {
  86.         case DLL_PROCESS_ATTACH:
  87.         case DLL_PROCESS_DETACH:
  88.         case DLL_THREAD_ATTACH:
  89.         case DLL_THREAD_DETACH:
  90.         default:
  91.             break;
  92.  
  93.         } // end switch()
  94.  
  95.     return TRUE;
  96.  
  97.     } // end DllEntryPoint()
  98.  
  99.  
  100. // Extension Agent DLLs provide the following entry point to coordinate the
  101. // initializations of the Extension Agent and the Extendible Agent.  The
  102. // Extendible Agent provides the Extension Agent with a time zero reference;
  103. // and the Extension Agent provides the Extendible Agent with an Event handle 
  104. // for communicating occurence of traps, and an object identifier representing
  105. // the root of the MIB subtree that the Extension Agent supports.
  106.  
  107. BOOL APIENTRY SnmpExtensionInit(
  108.     IN  DWORD               dwTimeZeroReference,
  109.     OUT HANDLE              *hPollForTrapEvent,
  110.     OUT AsnObjectIdentifier *supportedView)
  111.     {
  112.  
  113.     // Record the time reference provided by the Extendible Agent.
  114.  
  115.     dwTimeZero = dwTimeZeroReference;
  116.  
  117.  
  118.     // Create an Event that will be used to communicate the occurence of traps
  119.     // to the Extendible Agent.  The Extension Agent will assert this Event
  120.     // when a trap has occured.  This is explained further later in this file.
  121.  
  122.     if ((*hPollForTrapEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL)
  123.         {
  124.         // Indicate error?, be sure that NULL is returned to Extendible Agent.
  125.         }
  126.  
  127.  
  128.     // Indicate the MIB view supported by this Extension Agent, an object
  129.     // identifier representing the sub root of the MIB that is supported.
  130.  
  131.     *supportedView = MIB_OidPrefix; // NOTE!  structure copy
  132.  
  133.  
  134.     // Record the trap Event.  This example Extension Agent simulates traps by 
  135.     // generating a trap after every given number of processed requests.
  136.  
  137.     hSimulateTrap = *hPollForTrapEvent;
  138.  
  139.  
  140.     // Indicate that Extension Agent initialization was sucessfull.
  141.  
  142.     return TRUE;
  143.  
  144.     } // end SnmpExtensionInit()
  145.  
  146.  
  147. // Extension Agent DLLs provide the following entry point to communcate traps
  148. // to the Extendible Agent.  The Extendible Agent will query this entry point
  149. // when the trap Event (supplied at initialization time) is asserted, which
  150. // indicates that zero or more traps may have occured.  The Extendible Agent 
  151. // will repetedly call this entry point until FALSE is returned, indicating 
  152. // that all outstanding traps have been processed.
  153.  
  154. BOOL APIENTRY SnmpExtensionTrap(
  155.     OUT AsnObjectIdentifier *enterprise,
  156.     OUT AsnInteger          *genericTrap,
  157.     OUT AsnInteger          *specificTrap,
  158.     OUT AsnTimeticks        *timeStamp,
  159.     OUT RFC1157VarBindList  *variableBindings)
  160.     {
  161.     // The body of this routine is an extremely simple example/simulation of
  162.     // the trap functionality.  A real implementation will be more complex.
  163.  
  164.  
  165.     // The following define data inserted into the trap below.  The Lan Manager
  166.     // bytesAvailAlert from the Lan Manager Alerts-2 MIB is generated with an
  167.     // empty variable bindings list.
  168.  
  169.     static UINT OidList[]  = { 1, 3, 6, 1, 4, 1, 77, 2 };
  170.     static UINT OidListLen = 8;
  171.  
  172.  
  173.     // The following variable is used for the simulation, it allows a single
  174.     // trap to be generated and then causes FALSE to be returned indicating
  175.     // no more traps.
  176.  
  177.     static whichTime = 0;
  178.  
  179.  
  180.     // The following if/else support the simulation.
  181.  
  182.     if (whichTime == 0)
  183.         {
  184.         whichTime = 1;    // Supports the simulation.
  185.  
  186.  
  187.         // Communicate the trap data to the Extendible Agent.
  188.  
  189.         enterprise->idLength = OidListLen;
  190.         enterprise->ids = (UINT *)malloc(sizeof(UINT) * OidListLen);
  191.         memcpy(enterprise->ids, OidList, sizeof(UINT) * OidListLen);
  192.  
  193.         *genericTrap      = SNMP_GENERICTRAP_ENTERSPECIFIC;
  194.  
  195.         *specificTrap     = 1;                    // the bytesAvailAlert trap
  196.  
  197.         *timeStamp        = GetCurrentTime() - dwTimeZero;
  198.  
  199.         variableBindings->list = NULL;
  200.         variableBindings->len  = 0;
  201.  
  202.  
  203.         // Indicate that valid trap data exists in the parameters.
  204.  
  205.         return TRUE;
  206.         }
  207.     else
  208.         {
  209.         whichTime = 0;    // Supports the simulation.
  210.  
  211.  
  212.         // Indicate that no more traps are available and parameters do not
  213.         // refer to any valid data.
  214.  
  215.         return FALSE;
  216.         }
  217.  
  218.     } // end SnmpExtensionTrap()
  219.  
  220.  
  221. // Extension Agent DLLs provide the following entry point to resolve queries
  222. // for MIB variables in their supported MIB view (supplied at initialization
  223. // time).  The requestType is Get/GetNext/Set.
  224.  
  225. BOOL APIENTRY SnmpExtensionQuery(
  226.     IN BYTE                   requestType,
  227.     IN OUT RFC1157VarBindList *variableBindings,
  228.     OUT AsnInteger            *errorStatus,
  229.     OUT AsnInteger            *errorIndex)
  230.     {
  231.     static unsigned long requestCount = 0;  // Supports the trap simulation.
  232.     UINT    I;
  233.  
  234.  
  235.     // Iterate through the variable bindings list to resolve individual
  236.     // variable bindings.
  237.  
  238.     for ( I=0;I < variableBindings->len;I++ )
  239.         {
  240.         *errorStatus = ResolveVarBind( &variableBindings->list[I],
  241.                                        requestType );
  242.  
  243.  
  244.         // Test and handle case where Get Next past end of MIB view supported
  245.         // by this Extension Agent occurs.  Special processing is required to 
  246.         // communicate this situation to the Extendible Agent so it can take 
  247.         // appropriate action, possibly querying other Extension Agents.
  248.  
  249.         if ( *errorStatus == SNMP_ERRORSTATUS_NOSUCHNAME &&
  250.              requestType == MIB_ACTION_GETNEXT )
  251.            {
  252.            *errorStatus = SNMP_ERRORSTATUS_NOERROR;
  253.  
  254.  
  255.            // Modify variable binding of such variables so the OID points
  256.            // just outside the MIB view supported by this Extension Agent.
  257.            // The Extendible Agent tests for this, and takes appropriate
  258.            // action.
  259.  
  260.            SNMP_oidfree( &variableBindings->list[I].name );
  261.            SNMP_oidcpy( &variableBindings->list[I].name, &MIB_OidPrefix );
  262.            variableBindings->list[I].name.ids[MIB_PREFIX_LEN-1] ++;
  263.            }
  264.  
  265.  
  266.         // If an error was indicated, communicate error status and error
  267.         // index to the Extendible Agent.  The Extendible Agent will ensure
  268.         // that the origional variable bindings are returned in the response
  269.         // packet.
  270.  
  271.         if ( *errorStatus != SNMP_ERRORSTATUS_NOERROR )
  272.            {
  273.        *errorIndex = I+1;
  274.        goto Exit;
  275.        }
  276.         }
  277.  
  278. Exit:
  279.  
  280.  
  281.     // Supports the trap simulation.
  282.  
  283.     if (++requestCount % 3 == 0 && hSimulateTrap != NULL)
  284.         SetEvent(hSimulateTrap);
  285.  
  286.  
  287.     // Indicate that Extension Agent processing was sucessfull.
  288.  
  289.     return SNMPAPI_NOERROR;
  290.  
  291.     } // end SnmpExtensionQuery()
  292.  
  293.  
  294. //-------------------------------- END --------------------------------------
  295.  
  296.