windows-xp/Source/XPSP1/NT/net/snmp/subagent/hostmib/mib.c

/*
 *  mib.c v0.10
 *  Generated in conjunction with Management Factory scripts:
 *      script version: SNMPv1, 0.16, Apr 25, 1996
 *      project:        D:\TEMP\EXAMPLE\HOSTMIB
 *
 ****************************************************************************
 *                                                                          *
 *      (C) Copyright 1995 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 oids and tables used for the table driven design.
 *
 *  Functions:
 *
 *    UserMibInit()
 *
 *  Author:
 *
 *	D. D. Burns @ Webenable Inc.  Genned: Thu Nov 07 16:38:27 1996
 *
 *
 *  Revision History:
 *
 *      04/15/97        Changed "mibEventValue" to "hostmib.dll" from
 *                              "gendll.dll", and
 *                              "eventLogString" to "HostMIBAgent"
 *                              from "GenAgent".
 */


#include <windows.h>
#include <malloc.h>
#include <stdio.h>

#include <snmp.h>

#include "mib.h"
#include "smint.h"
#include "hostmsmi.h"

#include "HMCACHE.H"    // For Cache-build function prototypes

//
// Text String used in logging to the Application Event log
//

    //
    //  THE EVENT AND DLL STRINGS ARE DECLARED HERE - FILLED IN BY CASE TOOL.
    //  note- nyi, null strings supplied temporarily
    //

char eventLogString[13] = "HostMIBAgent\0" ;
char *EventLogString = eventLogString ;

char mibEventValue[12] = "hostmib.dll\0" ;

//
//  BEGIN generated code:
//	OIDs
//	variable_t table for the attributes of each class
//	class_info containing information about each class
//
//  NOTE:  This stub code will not work if a table exists in the middle of a
//	group. It will work if all tables are at the end of the group.
//
//	Variable tables
//		A NULL entry exists for each "hole" in the sequence of
//		attributes. For example, if attributes 1, 3, 4, and 7 are
//		defined, there will be a NULL entry in the variable table
//		corresponding to attribute 2, 5, and 6.  There is always
//		a NULL entry for 0 in the variable tables, since 0 is an
//		invalid OID arc value for an attribute.
//
//	Class table
//		The class table entries are ordered lexicographically to
//		facilitate SNMP GetNext processing.
//
static
UINT
subroot_array [ SUBROOT_LENGTH ] = {1, 3, 6, 1, 2, 1, 25 } ;
AsnObjectIdentifier
Subroot_oid = { SUBROOT_LENGTH, subroot_array } ;
static
UINT
host_array[ HOST_LENGTH ] = { HOST_SEQ } ;
AsnObjectIdentifier
host_oid = { HOST_LENGTH, host_array } ;
static
UINT
hrSystemUptime_array[ HRSYSTEMUPTIME_LENGTH ] = { HRSYSTEMUPTIME_SEQ } ;
AsnObjectIdentifier
hrSystemUptime_oid = { HRSYSTEMUPTIME_LENGTH, hrSystemUptime_array } ;
static
UINT
hrSystemDate_array[ HRSYSTEMDATE_LENGTH ] = { HRSYSTEMDATE_SEQ } ;
AsnObjectIdentifier
hrSystemDate_oid = { HRSYSTEMDATE_LENGTH, hrSystemDate_array } ;
static
UINT
hrSystemInitialLoadDevice_array[ HRSYSTEMINITIALLOADDEVICE_LENGTH ] = { HRSYSTEMINITIALLOADDEVICE_SEQ } ;
AsnObjectIdentifier
hrSystemInitialLoadDevice_oid = { HRSYSTEMINITIALLOADDEVICE_LENGTH, hrSystemInitialLoadDevice_array } ;
static
UINT
hrSystemInitialLoadParameters_array[ HRSYSTEMINITIALLOADPARAMETERS_LENGTH ] = { HRSYSTEMINITIALLOADPARAMETERS_SEQ } ;
AsnObjectIdentifier
hrSystemInitialLoadParameters_oid = { HRSYSTEMINITIALLOADPARAMETERS_LENGTH, hrSystemInitialLoadParameters_array } ;
static
UINT
hrSystemNumUsers_array[ HRSYSTEMNUMUSERS_LENGTH ] = { HRSYSTEMNUMUSERS_SEQ } ;
AsnObjectIdentifier
hrSystemNumUsers_oid = { HRSYSTEMNUMUSERS_LENGTH, hrSystemNumUsers_array } ;
static
UINT
hrSystemProcesses_array[ HRSYSTEMPROCESSES_LENGTH ] = { HRSYSTEMPROCESSES_SEQ } ;
AsnObjectIdentifier
hrSystemProcesses_oid = { HRSYSTEMPROCESSES_LENGTH, hrSystemProcesses_array } ;
static
UINT
hrSystemMaxProcesses_array[ HRSYSTEMMAXPROCESSES_LENGTH ] = { HRSYSTEMMAXPROCESSES_SEQ } ;
AsnObjectIdentifier
hrSystemMaxProcesses_oid = { HRSYSTEMMAXPROCESSES_LENGTH, hrSystemMaxProcesses_array } ;
static
UINT
hrSystem_array[ HRSYSTEM_LENGTH ] = { HRSYSTEM_SEQ } ;
AsnObjectIdentifier
hrSystem_oid = { HRSYSTEM_LENGTH, hrSystem_array } ;
variable_t
    hrSystem_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrSystemUptime_oid, ASN_RFC1155_TIMETICKS, NSM_READ_ONLY,
      GetHrSystemUptime, NULL,
      SMIGetTimeTicks, SMISetTimeTicks } , 
    { &hrSystemDate_oid, ASN_OCTETSTRING, NSM_READ_ONLY,
      GetHrSystemDate, NULL,
      SMIGetDateAndTime, SMISetDateAndTime } , 
    { &hrSystemInitialLoadDevice_oid, ASN_INTEGER, NSM_READ_WRITE,
      GetHrSystemInitialLoadDevice, SetHrSystemInitialLoadDevice,
      SMIGetInteger, SMISetInteger } , 
    { &hrSystemInitialLoadParameters_oid, ASN_OCTETSTRING, NSM_READ_WRITE,
      GetHrSystemInitialLoadParameters, SetHrSystemInitialLoadParameters,
      SMIGetInternationalDisplayString, SMISetInternationalDisplayString } , 
    { &hrSystemNumUsers_oid, ASN_RFC1155_GAUGE, NSM_READ_ONLY,
      GetHrSystemNumUsers, NULL,
      SMIGetGauge, SMISetGauge } , 
    { &hrSystemProcesses_oid, ASN_RFC1155_GAUGE, NSM_READ_ONLY,
      GetHrSystemProcesses, NULL,
      SMIGetGauge, SMISetGauge } , 
    { &hrSystemMaxProcesses_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrSystemMaxProcesses, NULL,
      SMIGetInteger, SMISetInteger } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrSystem_set_array[ MAX_HRSYSTEM_CODE + 1];
//  extern BYTE hrSystem_set_array[] ;
extern variable_t hrSystem_var_table[] ;
static
UINT
hrMemorySize_array[ HRMEMORYSIZE_LENGTH ] = { HRMEMORYSIZE_SEQ } ;
AsnObjectIdentifier
hrMemorySize_oid = { HRMEMORYSIZE_LENGTH, hrMemorySize_array } ;
static
UINT
hrStorage_array[ HRSTORAGE_LENGTH ] = { HRSTORAGE_SEQ } ;
AsnObjectIdentifier
hrStorage_oid = { HRSTORAGE_LENGTH, hrStorage_array } ;
variable_t
    hrStorage_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrMemorySize_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrMemorySize, NULL,
      SMIGetKBytes, SMISetKBytes } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrStorage_set_array[ MAX_HRSTORAGE_CODE + 1];
//  extern BYTE hrStorage_set_array[] ;
extern variable_t hrStorage_var_table[] ;
static
UINT
hrStorageOther_array[ HRSTORAGEOTHER_LENGTH ] = { HRSTORAGEOTHER_SEQ } ;
AsnObjectIdentifier
hrStorageOther_oid = { HRSTORAGEOTHER_LENGTH, hrStorageOther_array } ;
static
UINT
hrStorageRAM_array[ HRSTORAGERAM_LENGTH ] = { HRSTORAGERAM_SEQ } ;
AsnObjectIdentifier
hrStorageRAM_oid = { HRSTORAGERAM_LENGTH, hrStorageRAM_array } ;
static
UINT
hrStorageVirtualMemory_array[ HRSTORAGEVIRTUALMEMORY_LENGTH ] = { HRSTORAGEVIRTUALMEMORY_SEQ } ;
AsnObjectIdentifier
hrStorageVirtualMemory_oid = { HRSTORAGEVIRTUALMEMORY_LENGTH, hrStorageVirtualMemory_array } ;
static
UINT
hrStorageFixedDisk_array[ HRSTORAGEFIXEDDISK_LENGTH ] = { HRSTORAGEFIXEDDISK_SEQ } ;
AsnObjectIdentifier
hrStorageFixedDisk_oid = { HRSTORAGEFIXEDDISK_LENGTH, hrStorageFixedDisk_array } ;
static
UINT
hrStorageRemovableDisk_array[ HRSTORAGEREMOVABLEDISK_LENGTH ] = { HRSTORAGEREMOVABLEDISK_SEQ } ;
AsnObjectIdentifier
hrStorageRemovableDisk_oid = { HRSTORAGEREMOVABLEDISK_LENGTH, hrStorageRemovableDisk_array } ;
static
UINT
hrStorageFloppyDisk_array[ HRSTORAGEFLOPPYDISK_LENGTH ] = { HRSTORAGEFLOPPYDISK_SEQ } ;
AsnObjectIdentifier
hrStorageFloppyDisk_oid = { HRSTORAGEFLOPPYDISK_LENGTH, hrStorageFloppyDisk_array } ;
static
UINT
hrStorageCompactDisk_array[ HRSTORAGECOMPACTDISK_LENGTH ] = { HRSTORAGECOMPACTDISK_SEQ } ;
AsnObjectIdentifier
hrStorageCompactDisk_oid = { HRSTORAGECOMPACTDISK_LENGTH, hrStorageCompactDisk_array } ;
static
UINT
hrStorageRamDisk_array[ HRSTORAGERAMDISK_LENGTH ] = { HRSTORAGERAMDISK_SEQ } ;
AsnObjectIdentifier
hrStorageRamDisk_oid = { HRSTORAGERAMDISK_LENGTH, hrStorageRamDisk_array } ;
static
UINT
hrStorageTypes_array[ HRSTORAGETYPES_LENGTH ] = { HRSTORAGETYPES_SEQ } ;
AsnObjectIdentifier
hrStorageTypes_oid = { HRSTORAGETYPES_LENGTH, hrStorageTypes_array } ;
static
UINT
hrStorageIndex_array[ HRSTORAGEINDEX_LENGTH ] = { HRSTORAGEINDEX_SEQ } ;
AsnObjectIdentifier
hrStorageIndex_oid = { HRSTORAGEINDEX_LENGTH, hrStorageIndex_array } ;
static
UINT
hrStorageType_array[ HRSTORAGETYPE_LENGTH ] = { HRSTORAGETYPE_SEQ } ;
AsnObjectIdentifier
hrStorageType_oid = { HRSTORAGETYPE_LENGTH, hrStorageType_array } ;
static
UINT
hrStorageDesc_array[ HRSTORAGEDESC_LENGTH ] = { HRSTORAGEDESC_SEQ } ;
AsnObjectIdentifier
hrStorageDesc_oid = { HRSTORAGEDESC_LENGTH, hrStorageDesc_array } ;
static
UINT
hrStorageAllocationUnits_array[ HRSTORAGEALLOCATIONUNITS_LENGTH ] = { HRSTORAGEALLOCATIONUNITS_SEQ } ;
AsnObjectIdentifier
hrStorageAllocationUnits_oid = { HRSTORAGEALLOCATIONUNITS_LENGTH, hrStorageAllocationUnits_array } ;
static
UINT
hrStorageSize_array[ HRSTORAGESIZE_LENGTH ] = { HRSTORAGESIZE_SEQ } ;
AsnObjectIdentifier
hrStorageSize_oid = { HRSTORAGESIZE_LENGTH, hrStorageSize_array } ;
static
UINT
hrStorageUsed_array[ HRSTORAGEUSED_LENGTH ] = { HRSTORAGEUSED_SEQ } ;
AsnObjectIdentifier
hrStorageUsed_oid = { HRSTORAGEUSED_LENGTH, hrStorageUsed_array } ;
static
UINT
hrStorageAllocationFailures_array[ HRSTORAGEALLOCATIONFAILURES_LENGTH ] = { HRSTORAGEALLOCATIONFAILURES_SEQ } ;
AsnObjectIdentifier
hrStorageAllocationFailures_oid = { HRSTORAGEALLOCATIONFAILURES_LENGTH, hrStorageAllocationFailures_array } ;
static
UINT
hrStorageEntry_array[ HRSTORAGEENTRY_LENGTH ] = { HRSTORAGEENTRY_SEQ } ;
AsnObjectIdentifier
hrStorageEntry_oid = { HRSTORAGEENTRY_LENGTH, hrStorageEntry_array } ;
variable_t
    hrStorageEntry_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrStorageIndex_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrStorageIndex, NULL,
      SMIGetInteger, SMISetInteger } , 
    { &hrStorageType_oid, ASN_OBJECTIDENTIFIER, NSM_READ_ONLY,
      GetHrStorageType, NULL,
      SMIGetObjectId, SMISetObjectId } , 
    { &hrStorageDesc_oid, ASN_RFC1213_DISPSTRING, NSM_READ_ONLY,
      GetHrStorageDesc, NULL,
      SMIGetDispString, SMISetDispString } , 
    { &hrStorageAllocationUnits_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrStorageAllocationUnits, NULL,
      SMIGetInteger, SMISetInteger } , 
    { &hrStorageSize_oid, ASN_INTEGER, NSM_READ_WRITE,
      GetHrStorageSize, SetHrStorageSize,
      SMIGetInteger, SMISetInteger } , 
    { &hrStorageUsed_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrStorageUsed, NULL,
      SMIGetInteger, SMISetInteger } , 
    { &hrStorageAllocationFailures_oid, ASN_RFC1155_COUNTER, NSM_READ_ONLY,
      GetHrStorageAllocationFailures, NULL,
      SMIGetCounter, SMISetCounter } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrStorageEntry_set_array[ MAX_HRSTORAGEENTRY_CODE + 1];
//  extern BYTE hrStorageEntry_set_array[] ;
extern variable_t hrStorageEntry_var_table[] ;
static
UINT
hrDeviceOther_array[ HRDEVICEOTHER_LENGTH ] = { HRDEVICEOTHER_SEQ } ;
AsnObjectIdentifier
hrDeviceOther_oid = { HRDEVICEOTHER_LENGTH, hrDeviceOther_array } ;
static
UINT
hrDeviceUnknown_array[ HRDEVICEUNKNOWN_LENGTH ] = { HRDEVICEUNKNOWN_SEQ } ;
AsnObjectIdentifier
hrDeviceUnknown_oid = { HRDEVICEUNKNOWN_LENGTH, hrDeviceUnknown_array } ;
static
UINT
hrDeviceProcessor_array[ HRDEVICEPROCESSOR_LENGTH ] = { HRDEVICEPROCESSOR_SEQ } ;
AsnObjectIdentifier
hrDeviceProcessor_oid = { HRDEVICEPROCESSOR_LENGTH, hrDeviceProcessor_array } ;
static
UINT
hrDeviceNetwork_array[ HRDEVICENETWORK_LENGTH ] = { HRDEVICENETWORK_SEQ } ;
AsnObjectIdentifier
hrDeviceNetwork_oid = { HRDEVICENETWORK_LENGTH, hrDeviceNetwork_array } ;
static
UINT
hrDevicePrinter_array[ HRDEVICEPRINTER_LENGTH ] = { HRDEVICEPRINTER_SEQ } ;
AsnObjectIdentifier
hrDevicePrinter_oid = { HRDEVICEPRINTER_LENGTH, hrDevicePrinter_array } ;
static
UINT
hrDeviceDiskStorage_array[ HRDEVICEDISKSTORAGE_LENGTH ] = { HRDEVICEDISKSTORAGE_SEQ } ;
AsnObjectIdentifier
hrDeviceDiskStorage_oid = { HRDEVICEDISKSTORAGE_LENGTH, hrDeviceDiskStorage_array } ;
static
UINT
hrDeviceVideo_array[ HRDEVICEVIDEO_LENGTH ] = { HRDEVICEVIDEO_SEQ } ;
AsnObjectIdentifier
hrDeviceVideo_oid = { HRDEVICEVIDEO_LENGTH, hrDeviceVideo_array } ;
static
UINT
hrDeviceAudio_array[ HRDEVICEAUDIO_LENGTH ] = { HRDEVICEAUDIO_SEQ } ;
AsnObjectIdentifier
hrDeviceAudio_oid = { HRDEVICEAUDIO_LENGTH, hrDeviceAudio_array } ;
static
UINT
hrDeviceCoprocessor_array[ HRDEVICECOPROCESSOR_LENGTH ] = { HRDEVICECOPROCESSOR_SEQ } ;
AsnObjectIdentifier
hrDeviceCoprocessor_oid = { HRDEVICECOPROCESSOR_LENGTH, hrDeviceCoprocessor_array } ;
static
UINT
hrDeviceKeyboard_array[ HRDEVICEKEYBOARD_LENGTH ] = { HRDEVICEKEYBOARD_SEQ } ;
AsnObjectIdentifier
hrDeviceKeyboard_oid = { HRDEVICEKEYBOARD_LENGTH, hrDeviceKeyboard_array } ;
static
UINT
hrDeviceModem_array[ HRDEVICEMODEM_LENGTH ] = { HRDEVICEMODEM_SEQ } ;
AsnObjectIdentifier
hrDeviceModem_oid = { HRDEVICEMODEM_LENGTH, hrDeviceModem_array } ;
static
UINT
hrDeviceParallelPort_array[ HRDEVICEPARALLELPORT_LENGTH ] = { HRDEVICEPARALLELPORT_SEQ } ;
AsnObjectIdentifier
hrDeviceParallelPort_oid = { HRDEVICEPARALLELPORT_LENGTH, hrDeviceParallelPort_array } ;
static
UINT
hrDevicePointing_array[ HRDEVICEPOINTING_LENGTH ] = { HRDEVICEPOINTING_SEQ } ;
AsnObjectIdentifier
hrDevicePointing_oid = { HRDEVICEPOINTING_LENGTH, hrDevicePointing_array } ;
static
UINT
hrDeviceSerialPort_array[ HRDEVICESERIALPORT_LENGTH ] = { HRDEVICESERIALPORT_SEQ } ;
AsnObjectIdentifier
hrDeviceSerialPort_oid = { HRDEVICESERIALPORT_LENGTH, hrDeviceSerialPort_array } ;
static
UINT
hrDeviceTape_array[ HRDEVICETAPE_LENGTH ] = { HRDEVICETAPE_SEQ } ;
AsnObjectIdentifier
hrDeviceTape_oid = { HRDEVICETAPE_LENGTH, hrDeviceTape_array } ;
static
UINT
hrDeviceClock_array[ HRDEVICECLOCK_LENGTH ] = { HRDEVICECLOCK_SEQ } ;
AsnObjectIdentifier
hrDeviceClock_oid = { HRDEVICECLOCK_LENGTH, hrDeviceClock_array } ;
static
UINT
hrDeviceVolatileMemory_array[ HRDEVICEVOLATILEMEMORY_LENGTH ] = { HRDEVICEVOLATILEMEMORY_SEQ } ;
AsnObjectIdentifier
hrDeviceVolatileMemory_oid = { HRDEVICEVOLATILEMEMORY_LENGTH, hrDeviceVolatileMemory_array } ;
static
UINT
hrDeviceNonVolatileMemory_array[ HRDEVICENONVOLATILEMEMORY_LENGTH ] = { HRDEVICENONVOLATILEMEMORY_SEQ } ;
AsnObjectIdentifier
hrDeviceNonVolatileMemory_oid = { HRDEVICENONVOLATILEMEMORY_LENGTH, hrDeviceNonVolatileMemory_array } ;
static
UINT
hrDeviceTypes_array[ HRDEVICETYPES_LENGTH ] = { HRDEVICETYPES_SEQ } ;
AsnObjectIdentifier
hrDeviceTypes_oid = { HRDEVICETYPES_LENGTH, hrDeviceTypes_array } ;
static
UINT
hrDeviceIndex_array[ HRDEVICEINDEX_LENGTH ] = { HRDEVICEINDEX_SEQ } ;
AsnObjectIdentifier
hrDeviceIndex_oid = { HRDEVICEINDEX_LENGTH, hrDeviceIndex_array } ;
static
UINT
hrDeviceType_array[ HRDEVICETYPE_LENGTH ] = { HRDEVICETYPE_SEQ } ;
AsnObjectIdentifier
hrDeviceType_oid = { HRDEVICETYPE_LENGTH, hrDeviceType_array } ;
static
UINT
hrDeviceDesc_array[ HRDEVICEDESC_LENGTH ] = { HRDEVICEDESC_SEQ } ;
AsnObjectIdentifier
hrDeviceDesc_oid = { HRDEVICEDESC_LENGTH, hrDeviceDesc_array } ;
static
UINT
hrDeviceID_array[ HRDEVICEID_LENGTH ] = { HRDEVICEID_SEQ } ;
AsnObjectIdentifier
hrDeviceID_oid = { HRDEVICEID_LENGTH, hrDeviceID_array } ;
static
UINT
hrDeviceStatus_array[ HRDEVICESTATUS_LENGTH ] = { HRDEVICESTATUS_SEQ } ;
AsnObjectIdentifier
hrDeviceStatus_oid = { HRDEVICESTATUS_LENGTH, hrDeviceStatus_array } ;
static
UINT
hrDeviceErrors_array[ HRDEVICEERRORS_LENGTH ] = { HRDEVICEERRORS_SEQ } ;
AsnObjectIdentifier
hrDeviceErrors_oid = { HRDEVICEERRORS_LENGTH, hrDeviceErrors_array } ;
static
UINT
hrDeviceEntry_array[ HRDEVICEENTRY_LENGTH ] = { HRDEVICEENTRY_SEQ } ;
AsnObjectIdentifier
hrDeviceEntry_oid = { HRDEVICEENTRY_LENGTH, hrDeviceEntry_array } ;
variable_t
    hrDeviceEntry_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrDeviceIndex_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrDeviceIndex, NULL,
      SMIGetInteger, SMISetInteger } , 
    { &hrDeviceType_oid, ASN_OBJECTIDENTIFIER, NSM_READ_ONLY,
      GetHrDeviceType, NULL,
      SMIGetObjectId, SMISetObjectId } , 
    { &hrDeviceDesc_oid, ASN_RFC1213_DISPSTRING, NSM_READ_ONLY,
      GetHrDeviceDesc, NULL,
      SMIGetDispString, SMISetDispString } , 
    { &hrDeviceID_oid, ASN_OBJECTIDENTIFIER, NSM_READ_ONLY,
      GetHrDeviceID, NULL,
      SMIGetProductID, SMISetProductID } , 
    { &hrDeviceStatus_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrDeviceStatus, NULL,
      SMIGetINThrDeviceStatus, SMISetINThrDeviceStatus } , 
    { &hrDeviceErrors_oid, ASN_RFC1155_COUNTER, NSM_READ_ONLY,
      GetHrDeviceErrors, NULL,
      SMIGetCounter, SMISetCounter } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrDeviceEntry_set_array[ MAX_HRDEVICEENTRY_CODE + 1];
//  extern BYTE hrDeviceEntry_set_array[] ;
extern variable_t hrDeviceEntry_var_table[] ;
static
UINT
hrProcessorFrwID_array[ HRPROCESSORFRWID_LENGTH ] = { HRPROCESSORFRWID_SEQ } ;
AsnObjectIdentifier
hrProcessorFrwID_oid = { HRPROCESSORFRWID_LENGTH, hrProcessorFrwID_array } ;
static
UINT
hrProcessorLoad_array[ HRPROCESSORLOAD_LENGTH ] = { HRPROCESSORLOAD_SEQ } ;
AsnObjectIdentifier
hrProcessorLoad_oid = { HRPROCESSORLOAD_LENGTH, hrProcessorLoad_array } ;
static
UINT
hrProcessorEntry_array[ HRPROCESSORENTRY_LENGTH ] = { HRPROCESSORENTRY_SEQ } ;
AsnObjectIdentifier
hrProcessorEntry_oid = { HRPROCESSORENTRY_LENGTH, hrProcessorEntry_array } ;
variable_t
    hrProcessorEntry_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrProcessorFrwID_oid, ASN_OBJECTIDENTIFIER, NSM_READ_ONLY,
      GetHrProcessorFrwID, NULL,
      SMIGetProductID, SMISetProductID } , 
    { &hrProcessorLoad_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrProcessorLoad, NULL,
      SMIGetInteger, SMISetInteger } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrProcessorEntry_set_array[ MAX_HRPROCESSORENTRY_CODE + 1];
//  extern BYTE hrProcessorEntry_set_array[] ;
extern variable_t hrProcessorEntry_var_table[] ;
static
UINT
hrNetworkIfIndex_array[ HRNETWORKIFINDEX_LENGTH ] = { HRNETWORKIFINDEX_SEQ } ;
AsnObjectIdentifier
hrNetworkIfIndex_oid = { HRNETWORKIFINDEX_LENGTH, hrNetworkIfIndex_array } ;
static
UINT
hrNetworkEntry_array[ HRNETWORKENTRY_LENGTH ] = { HRNETWORKENTRY_SEQ } ;
AsnObjectIdentifier
hrNetworkEntry_oid = { HRNETWORKENTRY_LENGTH, hrNetworkEntry_array } ;
variable_t
    hrNetworkEntry_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrNetworkIfIndex_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrNetworkIfIndex, NULL,
      SMIGetInteger, SMISetInteger } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrNetworkEntry_set_array[ MAX_HRNETWORKENTRY_CODE + 1];
//  extern BYTE hrNetworkEntry_set_array[] ;
extern variable_t hrNetworkEntry_var_table[] ;
static
UINT
hrPrinterStatus_array[ HRPRINTERSTATUS_LENGTH ] = { HRPRINTERSTATUS_SEQ } ;
AsnObjectIdentifier
hrPrinterStatus_oid = { HRPRINTERSTATUS_LENGTH, hrPrinterStatus_array } ;
static
UINT
hrPrinterDetectedErrorState_array[ HRPRINTERDETECTEDERRORSTATE_LENGTH ] = { HRPRINTERDETECTEDERRORSTATE_SEQ } ;
AsnObjectIdentifier
hrPrinterDetectedErrorState_oid = { HRPRINTERDETECTEDERRORSTATE_LENGTH, hrPrinterDetectedErrorState_array } ;
static
UINT
hrPrinterEntry_array[ HRPRINTERENTRY_LENGTH ] = { HRPRINTERENTRY_SEQ } ;
AsnObjectIdentifier
hrPrinterEntry_oid = { HRPRINTERENTRY_LENGTH, hrPrinterEntry_array } ;
variable_t
    hrPrinterEntry_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrPrinterStatus_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrPrinterStatus, NULL,
      SMIGetINThrPrinterStatus, SMISetINThrPrinterStatus } , 
    { &hrPrinterDetectedErrorState_oid, ASN_OCTETSTRING, NSM_READ_ONLY,
      GetHrPrinterDetectedErrorState, NULL,
      SMIGetOctetString, SMISetOctetString } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrPrinterEntry_set_array[ MAX_HRPRINTERENTRY_CODE + 1];
//  extern BYTE hrPrinterEntry_set_array[] ;
extern variable_t hrPrinterEntry_var_table[] ;
static
UINT
hrDiskStorageAccess_array[ HRDISKSTORAGEACCESS_LENGTH ] = { HRDISKSTORAGEACCESS_SEQ } ;
AsnObjectIdentifier
hrDiskStorageAccess_oid = { HRDISKSTORAGEACCESS_LENGTH, hrDiskStorageAccess_array } ;
static
UINT
hrDiskStorageMedia_array[ HRDISKSTORAGEMEDIA_LENGTH ] = { HRDISKSTORAGEMEDIA_SEQ } ;
AsnObjectIdentifier
hrDiskStorageMedia_oid = { HRDISKSTORAGEMEDIA_LENGTH, hrDiskStorageMedia_array } ;
static
UINT
hrDiskStorageRemoveble_array[ HRDISKSTORAGEREMOVEBLE_LENGTH ] = { HRDISKSTORAGEREMOVEBLE_SEQ } ;
AsnObjectIdentifier
hrDiskStorageRemoveble_oid = { HRDISKSTORAGEREMOVEBLE_LENGTH, hrDiskStorageRemoveble_array } ;
static
UINT
hrDiskStorageCapacity_array[ HRDISKSTORAGECAPACITY_LENGTH ] = { HRDISKSTORAGECAPACITY_SEQ } ;
AsnObjectIdentifier
hrDiskStorageCapacity_oid = { HRDISKSTORAGECAPACITY_LENGTH, hrDiskStorageCapacity_array } ;
static
UINT
hrDiskStorageEntry_array[ HRDISKSTORAGEENTRY_LENGTH ] = { HRDISKSTORAGEENTRY_SEQ } ;
AsnObjectIdentifier
hrDiskStorageEntry_oid = { HRDISKSTORAGEENTRY_LENGTH, hrDiskStorageEntry_array } ;
variable_t
    hrDiskStorageEntry_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrDiskStorageAccess_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrDiskStorageAccess, NULL,
      SMIGetINTAccess, SMISetINTAccess } , 
    { &hrDiskStorageMedia_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrDiskStorageMedia, NULL,
      SMIGetINThrDiskStorageMedia, SMISetINThrDiskStorageMedia } , 
    { &hrDiskStorageRemoveble_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrDiskStorageRemoveble, NULL,
      SMIGetBoolean, SMISetBoolean } , 
    { &hrDiskStorageCapacity_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrDiskStorageCapacity, NULL,
      SMIGetKBytes, SMISetKBytes } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrDiskStorageEntry_set_array[ MAX_HRDISKSTORAGEENTRY_CODE + 1];
//  extern BYTE hrDiskStorageEntry_set_array[] ;
extern variable_t hrDiskStorageEntry_var_table[] ;
static
UINT
hrPartitionIndex_array[ HRPARTITIONINDEX_LENGTH ] = { HRPARTITIONINDEX_SEQ } ;
AsnObjectIdentifier
hrPartitionIndex_oid = { HRPARTITIONINDEX_LENGTH, hrPartitionIndex_array } ;
static
UINT
hrPartitionLabel_array[ HRPARTITIONLABEL_LENGTH ] = { HRPARTITIONLABEL_SEQ } ;
AsnObjectIdentifier
hrPartitionLabel_oid = { HRPARTITIONLABEL_LENGTH, hrPartitionLabel_array } ;
static
UINT
hrPartitionID_array[ HRPARTITIONID_LENGTH ] = { HRPARTITIONID_SEQ } ;
AsnObjectIdentifier
hrPartitionID_oid = { HRPARTITIONID_LENGTH, hrPartitionID_array } ;
static
UINT
hrPartitionSize_array[ HRPARTITIONSIZE_LENGTH ] = { HRPARTITIONSIZE_SEQ } ;
AsnObjectIdentifier
hrPartitionSize_oid = { HRPARTITIONSIZE_LENGTH, hrPartitionSize_array } ;
static
UINT
hrPartitionFSIndex_array[ HRPARTITIONFSINDEX_LENGTH ] = { HRPARTITIONFSINDEX_SEQ } ;
AsnObjectIdentifier
hrPartitionFSIndex_oid = { HRPARTITIONFSINDEX_LENGTH, hrPartitionFSIndex_array } ;
static
UINT
hrPartitionEntry_array[ HRPARTITIONENTRY_LENGTH ] = { HRPARTITIONENTRY_SEQ } ;
AsnObjectIdentifier
hrPartitionEntry_oid = { HRPARTITIONENTRY_LENGTH, hrPartitionEntry_array } ;
variable_t
    hrPartitionEntry_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrPartitionIndex_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrPartitionIndex, NULL,
      SMIGetInteger, SMISetInteger } , 
    { &hrPartitionLabel_oid, ASN_OCTETSTRING, NSM_READ_ONLY,
      GetHrPartitionLabel, NULL,
      SMIGetInternationalDisplayString, SMISetInternationalDisplayString } , 
    { &hrPartitionID_oid, ASN_OCTETSTRING, NSM_READ_ONLY,
      GetHrPartitionID, NULL,
      SMIGetOctetString, SMISetOctetString } , 
    { &hrPartitionSize_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrPartitionSize, NULL,
      SMIGetKBytes, SMISetKBytes } , 
    { &hrPartitionFSIndex_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrPartitionFSIndex, NULL,
      SMIGetInteger, SMISetInteger } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrPartitionEntry_set_array[ MAX_HRPARTITIONENTRY_CODE + 1];
//  extern BYTE hrPartitionEntry_set_array[] ;
extern variable_t hrPartitionEntry_var_table[] ;
static
UINT
hrFSIndex_array[ HRFSINDEX_LENGTH ] = { HRFSINDEX_SEQ } ;
AsnObjectIdentifier
hrFSIndex_oid = { HRFSINDEX_LENGTH, hrFSIndex_array } ;
static
UINT
hrFSMountPoint_array[ HRFSMOUNTPOINT_LENGTH ] = { HRFSMOUNTPOINT_SEQ } ;
AsnObjectIdentifier
hrFSMountPoint_oid = { HRFSMOUNTPOINT_LENGTH, hrFSMountPoint_array } ;
static
UINT
hrFSRemoteMountPoint_array[ HRFSREMOTEMOUNTPOINT_LENGTH ] = { HRFSREMOTEMOUNTPOINT_SEQ } ;
AsnObjectIdentifier
hrFSRemoteMountPoint_oid = { HRFSREMOTEMOUNTPOINT_LENGTH, hrFSRemoteMountPoint_array } ;
static
UINT
hrFSType_array[ HRFSTYPE_LENGTH ] = { HRFSTYPE_SEQ } ;
AsnObjectIdentifier
hrFSType_oid = { HRFSTYPE_LENGTH, hrFSType_array } ;
static
UINT
hrFSAccess_array[ HRFSACCESS_LENGTH ] = { HRFSACCESS_SEQ } ;
AsnObjectIdentifier
hrFSAccess_oid = { HRFSACCESS_LENGTH, hrFSAccess_array } ;
static
UINT
hrFSBootable_array[ HRFSBOOTABLE_LENGTH ] = { HRFSBOOTABLE_SEQ } ;
AsnObjectIdentifier
hrFSBootable_oid = { HRFSBOOTABLE_LENGTH, hrFSBootable_array } ;
static
UINT
hrFSStorageIndex_array[ HRFSSTORAGEINDEX_LENGTH ] = { HRFSSTORAGEINDEX_SEQ } ;
AsnObjectIdentifier
hrFSStorageIndex_oid = { HRFSSTORAGEINDEX_LENGTH, hrFSStorageIndex_array } ;
static
UINT
hrFSLastFullBackupDate_array[ HRFSLASTFULLBACKUPDATE_LENGTH ] = { HRFSLASTFULLBACKUPDATE_SEQ } ;
AsnObjectIdentifier
hrFSLastFullBackupDate_oid = { HRFSLASTFULLBACKUPDATE_LENGTH, hrFSLastFullBackupDate_array } ;
static
UINT
hrFSLastPartialBackupDate_array[ HRFSLASTPARTIALBACKUPDATE_LENGTH ] = { HRFSLASTPARTIALBACKUPDATE_SEQ } ;
AsnObjectIdentifier
hrFSLastPartialBackupDate_oid = { HRFSLASTPARTIALBACKUPDATE_LENGTH, hrFSLastPartialBackupDate_array } ;
static
UINT
hrFSEntry_array[ HRFSENTRY_LENGTH ] = { HRFSENTRY_SEQ } ;
AsnObjectIdentifier
hrFSEntry_oid = { HRFSENTRY_LENGTH, hrFSEntry_array } ;
variable_t
    hrFSEntry_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrFSIndex_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrFSIndex, NULL,
      SMIGetInteger, SMISetInteger } , 
    { &hrFSMountPoint_oid, ASN_OCTETSTRING, NSM_READ_ONLY,
      GetHrFSMountPoint, NULL,
      SMIGetInternationalDisplayString, SMISetInternationalDisplayString } , 
    { &hrFSRemoteMountPoint_oid, ASN_OCTETSTRING, NSM_READ_ONLY,
      GetHrFSRemoteMountPoint, NULL,
      SMIGetInternationalDisplayString, SMISetInternationalDisplayString } , 
    { &hrFSType_oid, ASN_OBJECTIDENTIFIER, NSM_READ_ONLY,
      GetHrFSType, NULL,
      SMIGetObjectId, SMISetObjectId } , 
    { &hrFSAccess_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrFSAccess, NULL,
      SMIGetINTAccess, SMISetINTAccess } , 
    { &hrFSBootable_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrFSBootable, NULL,
      SMIGetBoolean, SMISetBoolean } , 
    { &hrFSStorageIndex_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrFSStorageIndex, NULL,
      SMIGetInteger, SMISetInteger } , 
    { &hrFSLastFullBackupDate_oid, ASN_OCTETSTRING, NSM_READ_WRITE,
      GetHrFSLastFullBackupDate, SetHrFSLastFullBackupDate,
      SMIGetDateAndTime, SMISetDateAndTime } , 
    { &hrFSLastPartialBackupDate_oid, ASN_OCTETSTRING, NSM_READ_WRITE,
      GetHrFSLastPartialBackupDate, SetHrFSLastPartialBackupDate,
      SMIGetDateAndTime, SMISetDateAndTime } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrFSEntry_set_array[ MAX_HRFSENTRY_CODE + 1];
//  extern BYTE hrFSEntry_set_array[] ;
extern variable_t hrFSEntry_var_table[] ;
static
UINT
hrFSOther_array[ HRFSOTHER_LENGTH ] = { HRFSOTHER_SEQ } ;
AsnObjectIdentifier
hrFSOther_oid = { HRFSOTHER_LENGTH, hrFSOther_array } ;
static
UINT
hrFSUnknown_array[ HRFSUNKNOWN_LENGTH ] = { HRFSUNKNOWN_SEQ } ;
AsnObjectIdentifier
hrFSUnknown_oid = { HRFSUNKNOWN_LENGTH, hrFSUnknown_array } ;
static
UINT
hrFSBerkeleyFFS_array[ HRFSBERKELEYFFS_LENGTH ] = { HRFSBERKELEYFFS_SEQ } ;
AsnObjectIdentifier
hrFSBerkeleyFFS_oid = { HRFSBERKELEYFFS_LENGTH, hrFSBerkeleyFFS_array } ;
static
UINT
hrFSSys5FS_array[ HRFSSYS5FS_LENGTH ] = { HRFSSYS5FS_SEQ } ;
AsnObjectIdentifier
hrFSSys5FS_oid = { HRFSSYS5FS_LENGTH, hrFSSys5FS_array } ;
/*
 *    DOS
 */
static
UINT
hrFSFat_array[ HRFSFAT_LENGTH ] = { HRFSFAT_SEQ } ;
AsnObjectIdentifier
hrFSFat_oid = { HRFSFAT_LENGTH, hrFSFat_array } ;
/*
 *    OS/2 High Performance File System
 */
static
UINT
hrFSHPFS_array[ HRFSHPFS_LENGTH ] = { HRFSHPFS_SEQ } ;
AsnObjectIdentifier
hrFSHPFS_oid = { HRFSHPFS_LENGTH, hrFSHPFS_array } ;
/*
 *    Macintosh Hierarchical File System
 */
static
UINT
hrFSHFS_array[ HRFSHFS_LENGTH ] = { HRFSHFS_SEQ } ;
AsnObjectIdentifier
hrFSHFS_oid = { HRFSHFS_LENGTH, hrFSHFS_array } ;
/*
 *    Macintosh File System
 */
static
UINT
hrFSMFS_array[ HRFSMFS_LENGTH ] = { HRFSMFS_SEQ } ;
AsnObjectIdentifier
hrFSMFS_oid = { HRFSMFS_LENGTH, hrFSMFS_array } ;
/*
 *    Windows NT
 */
static
UINT
hrFSNTFS_array[ HRFSNTFS_LENGTH ] = { HRFSNTFS_SEQ } ;
AsnObjectIdentifier
hrFSNTFS_oid = { HRFSNTFS_LENGTH, hrFSNTFS_array } ;
static
UINT
hrFSVNode_array[ HRFSVNODE_LENGTH ] = { HRFSVNODE_SEQ } ;
AsnObjectIdentifier
hrFSVNode_oid = { HRFSVNODE_LENGTH, hrFSVNode_array } ;
static
UINT
hrFSJournaled_array[ HRFSJOURNALED_LENGTH ] = { HRFSJOURNALED_SEQ } ;
AsnObjectIdentifier
hrFSJournaled_oid = { HRFSJOURNALED_LENGTH, hrFSJournaled_array } ;
/*
 *    CD File System
 */
static
UINT
hrFSiso9660_array[ HRFSISO9660_LENGTH ] = { HRFSISO9660_SEQ } ;
AsnObjectIdentifier
hrFSiso9660_oid = { HRFSISO9660_LENGTH, hrFSiso9660_array } ;
static
UINT
hrFSRockRidge_array[ HRFSROCKRIDGE_LENGTH ] = { HRFSROCKRIDGE_SEQ } ;
AsnObjectIdentifier
hrFSRockRidge_oid = { HRFSROCKRIDGE_LENGTH, hrFSRockRidge_array } ;
static
UINT
hrFSNFS_array[ HRFSNFS_LENGTH ] = { HRFSNFS_SEQ } ;
AsnObjectIdentifier
hrFSNFS_oid = { HRFSNFS_LENGTH, hrFSNFS_array } ;
static
UINT
hrFSNetware_array[ HRFSNETWARE_LENGTH ] = { HRFSNETWARE_SEQ } ;
AsnObjectIdentifier
hrFSNetware_oid = { HRFSNETWARE_LENGTH, hrFSNetware_array } ;
/*
 *    Andrew File System
 */
static
UINT
hrFSAFS_array[ HRFSAFS_LENGTH ] = { HRFSAFS_SEQ } ;
AsnObjectIdentifier
hrFSAFS_oid = { HRFSAFS_LENGTH, hrFSAFS_array } ;
/*
 *    OSF DCE Distributed File System
 */
static
UINT
hrFSDFS_array[ HRFSDFS_LENGTH ] = { HRFSDFS_SEQ } ;
AsnObjectIdentifier
hrFSDFS_oid = { HRFSDFS_LENGTH, hrFSDFS_array } ;
static
UINT
hrFSApplshare_array[ HRFSAPPLSHARE_LENGTH ] = { HRFSAPPLSHARE_SEQ } ;
AsnObjectIdentifier
hrFSApplshare_oid = { HRFSAPPLSHARE_LENGTH, hrFSApplshare_array } ;
static
UINT
hrFSRFS_array[ HRFSRFS_LENGTH ] = { HRFSRFS_SEQ } ;
AsnObjectIdentifier
hrFSRFS_oid = { HRFSRFS_LENGTH, hrFSRFS_array } ;
/*
 *    Data General
 */
static
UINT
hrFSDGFS_array[ HRFSDGFS_LENGTH ] = { HRFSDGFS_SEQ } ;
AsnObjectIdentifier
hrFSDGFS_oid = { HRFSDGFS_LENGTH, hrFSDGFS_array } ;
/*
 *    SVR4 Boot File System
 */
static
UINT
hrFSBFS_array[ HRFSBFS_LENGTH ] = { HRFSBFS_SEQ } ;
AsnObjectIdentifier
hrFSBFS_oid = { HRFSBFS_LENGTH, hrFSBFS_array } ;
static
UINT
hrFSTypes_array[ HRFSTYPES_LENGTH ] = { HRFSTYPES_SEQ } ;
AsnObjectIdentifier
hrFSTypes_oid = { HRFSTYPES_LENGTH, hrFSTypes_array } ;
static
UINT
hrSWOSIndex_array[ HRSWOSINDEX_LENGTH ] = { HRSWOSINDEX_SEQ } ;
AsnObjectIdentifier
hrSWOSIndex_oid = { HRSWOSINDEX_LENGTH, hrSWOSIndex_array } ;
static
UINT
hrSWRun_array[ HRSWRUN_LENGTH ] = { HRSWRUN_SEQ } ;
AsnObjectIdentifier
hrSWRun_oid = { HRSWRUN_LENGTH, hrSWRun_array } ;
variable_t
    hrSWRun_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrSWOSIndex_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrSWOSIndex, NULL,
      SMIGetInteger, SMISetInteger } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrSWRun_set_array[ MAX_HRSWRUN_CODE + 1];
//  extern BYTE hrSWRun_set_array[] ;
extern variable_t hrSWRun_var_table[] ;
static
UINT
hrSWRunIndex_array[ HRSWRUNINDEX_LENGTH ] = { HRSWRUNINDEX_SEQ } ;
AsnObjectIdentifier
hrSWRunIndex_oid = { HRSWRUNINDEX_LENGTH, hrSWRunIndex_array } ;
static
UINT
hrSWRunName_array[ HRSWRUNNAME_LENGTH ] = { HRSWRUNNAME_SEQ } ;
AsnObjectIdentifier
hrSWRunName_oid = { HRSWRUNNAME_LENGTH, hrSWRunName_array } ;
static
UINT
hrSWRunID_array[ HRSWRUNID_LENGTH ] = { HRSWRUNID_SEQ } ;
AsnObjectIdentifier
hrSWRunID_oid = { HRSWRUNID_LENGTH, hrSWRunID_array } ;
static
UINT
hrSWRunPath_array[ HRSWRUNPATH_LENGTH ] = { HRSWRUNPATH_SEQ } ;
AsnObjectIdentifier
hrSWRunPath_oid = { HRSWRUNPATH_LENGTH, hrSWRunPath_array } ;
static
UINT
hrSWRunParameters_array[ HRSWRUNPARAMETERS_LENGTH ] = { HRSWRUNPARAMETERS_SEQ } ;
AsnObjectIdentifier
hrSWRunParameters_oid = { HRSWRUNPARAMETERS_LENGTH, hrSWRunParameters_array } ;
static
UINT
hrSWRunType_array[ HRSWRUNTYPE_LENGTH ] = { HRSWRUNTYPE_SEQ } ;
AsnObjectIdentifier
hrSWRunType_oid = { HRSWRUNTYPE_LENGTH, hrSWRunType_array } ;
static
UINT
hrSWRunStatus_array[ HRSWRUNSTATUS_LENGTH ] = { HRSWRUNSTATUS_SEQ } ;
AsnObjectIdentifier
hrSWRunStatus_oid = { HRSWRUNSTATUS_LENGTH, hrSWRunStatus_array } ;
static
UINT
hrSWRunEntry_array[ HRSWRUNENTRY_LENGTH ] = { HRSWRUNENTRY_SEQ } ;
AsnObjectIdentifier
hrSWRunEntry_oid = { HRSWRUNENTRY_LENGTH, hrSWRunEntry_array } ;
variable_t
    hrSWRunEntry_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrSWRunIndex_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrSWRunIndex, NULL,
      SMIGetInteger, SMISetInteger } , 
    { &hrSWRunName_oid, ASN_OCTETSTRING, NSM_READ_ONLY,
      GetHrSWRunName, NULL,
      SMIGetInternationalDisplayString, SMISetInternationalDisplayString } , 
    { &hrSWRunID_oid, ASN_OBJECTIDENTIFIER, NSM_READ_ONLY,
      GetHrSWRunID, NULL,
      SMIGetProductID, SMISetProductID } , 
    { &hrSWRunPath_oid, ASN_OCTETSTRING, NSM_READ_ONLY,
      GetHrSWRunPath, NULL,
      SMIGetInternationalDisplayString, SMISetInternationalDisplayString } , 
    { &hrSWRunParameters_oid, ASN_OCTETSTRING, NSM_READ_ONLY,
      GetHrSWRunParameters, NULL,
      SMIGetInternationalDisplayString, SMISetInternationalDisplayString } , 
    { &hrSWRunType_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrSWRunType, NULL,
      SMIGetINTSWType, SMISetINTSWType } , 
    { &hrSWRunStatus_oid, ASN_INTEGER, NSM_READ_WRITE,
      GetHrSWRunStatus, SetHrSWRunStatus,
      SMIGetINThrSWRunStatus, SMISetINThrSWRunStatus } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrSWRunEntry_set_array[ MAX_HRSWRUNENTRY_CODE + 1];
//  extern BYTE hrSWRunEntry_set_array[] ;
extern variable_t hrSWRunEntry_var_table[] ;
static
UINT
hrSWRunPerfCPU_array[ HRSWRUNPERFCPU_LENGTH ] = { HRSWRUNPERFCPU_SEQ } ;
AsnObjectIdentifier
hrSWRunPerfCPU_oid = { HRSWRUNPERFCPU_LENGTH, hrSWRunPerfCPU_array } ;
static
UINT
hrSWRunPerfMem_array[ HRSWRUNPERFMEM_LENGTH ] = { HRSWRUNPERFMEM_SEQ } ;
AsnObjectIdentifier
hrSWRunPerfMem_oid = { HRSWRUNPERFMEM_LENGTH, hrSWRunPerfMem_array } ;
static
UINT
hrSWRunPerfEntry_array[ HRSWRUNPERFENTRY_LENGTH ] = { HRSWRUNPERFENTRY_SEQ } ;
AsnObjectIdentifier
hrSWRunPerfEntry_oid = { HRSWRUNPERFENTRY_LENGTH, hrSWRunPerfEntry_array } ;
variable_t
    hrSWRunPerfEntry_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrSWRunPerfCPU_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrSWRunPerfCPU, NULL,
      SMIGetInteger, SMISetInteger } , 
    { &hrSWRunPerfMem_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrSWRunPerfMem, NULL,
      SMIGetKBytes, SMISetKBytes } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrSWRunPerfEntry_set_array[ MAX_HRSWRUNPERFENTRY_CODE + 1];
//  extern BYTE hrSWRunPerfEntry_set_array[] ;
extern variable_t hrSWRunPerfEntry_var_table[] ;
static
UINT
hrSWInstalledLastChange_array[ HRSWINSTALLEDLASTCHANGE_LENGTH ] = { HRSWINSTALLEDLASTCHANGE_SEQ } ;
AsnObjectIdentifier
hrSWInstalledLastChange_oid = { HRSWINSTALLEDLASTCHANGE_LENGTH, hrSWInstalledLastChange_array } ;
static
UINT
hrSWInstalledLastUpdateTime_array[ HRSWINSTALLEDLASTUPDATETIME_LENGTH ] = { HRSWINSTALLEDLASTUPDATETIME_SEQ } ;
AsnObjectIdentifier
hrSWInstalledLastUpdateTime_oid = { HRSWINSTALLEDLASTUPDATETIME_LENGTH, hrSWInstalledLastUpdateTime_array } ;
static
UINT
hrSWInstalled_array[ HRSWINSTALLED_LENGTH ] = { HRSWINSTALLED_SEQ } ;
AsnObjectIdentifier
hrSWInstalled_oid = { HRSWINSTALLED_LENGTH, hrSWInstalled_array } ;
variable_t
    hrSWInstalled_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrSWInstalledLastChange_oid, ASN_RFC1155_TIMETICKS, NSM_READ_ONLY,
      GetHrSWInstalledLastChange, NULL,
      SMIGetTimeTicks, SMISetTimeTicks } , 
    { &hrSWInstalledLastUpdateTime_oid, ASN_RFC1155_TIMETICKS, NSM_READ_ONLY,
      GetHrSWInstalledLastUpdateTime, NULL,
      SMIGetTimeTicks, SMISetTimeTicks } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrSWInstalled_set_array[ MAX_HRSWINSTALLED_CODE + 1];
//  extern BYTE hrSWInstalled_set_array[] ;
extern variable_t hrSWInstalled_var_table[] ;
static
UINT
hrSWInstalledIndex_array[ HRSWINSTALLEDINDEX_LENGTH ] = { HRSWINSTALLEDINDEX_SEQ } ;
AsnObjectIdentifier
hrSWInstalledIndex_oid = { HRSWINSTALLEDINDEX_LENGTH, hrSWInstalledIndex_array } ;
static
UINT
hrSWInstalledName_array[ HRSWINSTALLEDNAME_LENGTH ] = { HRSWINSTALLEDNAME_SEQ } ;
AsnObjectIdentifier
hrSWInstalledName_oid = { HRSWINSTALLEDNAME_LENGTH, hrSWInstalledName_array } ;
static
UINT
hrSWInstalledID_array[ HRSWINSTALLEDID_LENGTH ] = { HRSWINSTALLEDID_SEQ } ;
AsnObjectIdentifier
hrSWInstalledID_oid = { HRSWINSTALLEDID_LENGTH, hrSWInstalledID_array } ;
static
UINT
hrSWInstalledType_array[ HRSWINSTALLEDTYPE_LENGTH ] = { HRSWINSTALLEDTYPE_SEQ } ;
AsnObjectIdentifier
hrSWInstalledType_oid = { HRSWINSTALLEDTYPE_LENGTH, hrSWInstalledType_array } ;
static
UINT
hrSWInstalledDate_array[ HRSWINSTALLEDDATE_LENGTH ] = { HRSWINSTALLEDDATE_SEQ } ;
AsnObjectIdentifier
hrSWInstalledDate_oid = { HRSWINSTALLEDDATE_LENGTH, hrSWInstalledDate_array } ;
static
UINT
hrSWInstalledEntry_array[ HRSWINSTALLEDENTRY_LENGTH ] = { HRSWINSTALLEDENTRY_SEQ } ;
AsnObjectIdentifier
hrSWInstalledEntry_oid = { HRSWINSTALLEDENTRY_LENGTH, hrSWInstalledEntry_array } ;
variable_t
    hrSWInstalledEntry_var_table[] = {
    { NULL, ASN_NULL, NSM_NO_ACCESS, NULL, NULL, NULL, NULL } ,
    { &hrSWInstalledIndex_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrSWInstalledIndex, NULL,
      SMIGetInteger, SMISetInteger } , 
    { &hrSWInstalledName_oid, ASN_OCTETSTRING, NSM_READ_ONLY,
      GetHrSWInstalledName, NULL,
      SMIGetInternationalDisplayString, SMISetInternationalDisplayString } , 
    { &hrSWInstalledID_oid, ASN_OBJECTIDENTIFIER, NSM_READ_ONLY,
      GetHrSWInstalledID, NULL,
      SMIGetProductID, SMISetProductID } , 
    { &hrSWInstalledType_oid, ASN_INTEGER, NSM_READ_ONLY,
      GetHrSWInstalledType, NULL,
      SMIGetINTSWType, SMISetINTSWType } , 
    { &hrSWInstalledDate_oid, ASN_OCTETSTRING, NSM_READ_ONLY,
      GetHrSWInstalledDate, NULL,
      SMIGetDateAndTime, SMISetDateAndTime } , 
    } ;
// Next two lines are platform specific 
//  BYTE hrSWInstalledEntry_set_array[ MAX_HRSWINSTALLEDENTRY_CODE + 1];
//  extern BYTE hrSWInstalledEntry_set_array[] ;
extern variable_t hrSWInstalledEntry_var_table[] ;
class_t
    class_info[] = { 
    // hrSystem
    { NON_TABLE, &hrSystem_oid, HRSYSTEM_VAR_INDEX,
      MIN_HRSYSTEM_CODE, MAX_HRSYSTEM_CODE,
      HrSystemFindInstance, HrSystemFindNextInstance,
      HrSystemConvertInstance, HrSystemFreeInstance,
      hrSystem_var_table } , 

    // hrStorage
    { NON_TABLE, &hrStorage_oid, HRSTORAGE_VAR_INDEX,
      MIN_HRSTORAGE_CODE, MAX_HRSTORAGE_CODE,
      HrStorageFindInstance, HrStorageFindNextInstance,
      HrStorageConvertInstance, HrStorageFreeInstance,
      hrStorage_var_table } , 

    // hrStorageEntry
    { TABLE, &hrStorageEntry_oid, HRSTORAGEENTRY_VAR_INDEX,
      MIN_HRSTORAGEENTRY_CODE, MAX_HRSTORAGEENTRY_CODE,
      HrStorageEntryFindInstance, HrStorageEntryFindNextInstance,
      HrStorageEntryConvertInstance, HrStorageEntryFreeInstance,
      hrStorageEntry_var_table } , 

    // hrDeviceEntry
    { TABLE, &hrDeviceEntry_oid, HRDEVICEENTRY_VAR_INDEX,
      MIN_HRDEVICEENTRY_CODE, MAX_HRDEVICEENTRY_CODE,
      HrDeviceEntryFindInstance, HrDeviceEntryFindNextInstance,
      HrDeviceEntryConvertInstance, HrDeviceEntryFreeInstance,
      hrDeviceEntry_var_table } , 

    // hrProcessorEntry
    { TABLE, &hrProcessorEntry_oid, HRPROCESSORENTRY_VAR_INDEX,
      MIN_HRPROCESSORENTRY_CODE, MAX_HRPROCESSORENTRY_CODE,
      HrProcessorEntryFindInstance, HrProcessorEntryFindNextInstance,
      HrProcessorEntryConvertInstance, HrProcessorEntryFreeInstance,
      hrProcessorEntry_var_table } , 

    // hrNetworkEntry
    { TABLE, &hrNetworkEntry_oid, HRNETWORKENTRY_VAR_INDEX,
      MIN_HRNETWORKENTRY_CODE, MAX_HRNETWORKENTRY_CODE,
      HrNetworkEntryFindInstance, HrNetworkEntryFindNextInstance,
      HrNetworkEntryConvertInstance, HrNetworkEntryFreeInstance,
      hrNetworkEntry_var_table } , 

    // hrPrinterEntry
    { TABLE, &hrPrinterEntry_oid, HRPRINTERENTRY_VAR_INDEX,
      MIN_HRPRINTERENTRY_CODE, MAX_HRPRINTERENTRY_CODE,
      HrPrinterEntryFindInstance, HrPrinterEntryFindNextInstance,
      HrPrinterEntryConvertInstance, HrPrinterEntryFreeInstance,
      hrPrinterEntry_var_table } , 

    // hrDiskStorageEntry
    { TABLE, &hrDiskStorageEntry_oid, HRDISKSTORAGEENTRY_VAR_INDEX,
      MIN_HRDISKSTORAGEENTRY_CODE, MAX_HRDISKSTORAGEENTRY_CODE,
      HrDiskStorageEntryFindInstance, HrDiskStorageEntryFindNextInstance,
      HrDiskStorageEntryConvertInstance, HrDiskStorageEntryFreeInstance,
      hrDiskStorageEntry_var_table } , 

    // hrPartitionEntry
    { TABLE, &hrPartitionEntry_oid, HRPARTITIONENTRY_VAR_INDEX,
      MIN_HRPARTITIONENTRY_CODE, MAX_HRPARTITIONENTRY_CODE,
      HrPartitionEntryFindInstance, HrPartitionEntryFindNextInstance,
      HrPartitionEntryConvertInstance, HrPartitionEntryFreeInstance,
      hrPartitionEntry_var_table } , 

    // hrFSEntry
    { TABLE, &hrFSEntry_oid, HRFSENTRY_VAR_INDEX,
      MIN_HRFSENTRY_CODE, MAX_HRFSENTRY_CODE,
      HrFSEntryFindInstance, HrFSEntryFindNextInstance,
      HrFSEntryConvertInstance, HrFSEntryFreeInstance,
      hrFSEntry_var_table } , 

    // hrSWRun
    { NON_TABLE, &hrSWRun_oid, HRSWRUN_VAR_INDEX,
      MIN_HRSWRUN_CODE, MAX_HRSWRUN_CODE,
      HrSWRunFindInstance, HrSWRunFindNextInstance,
      HrSWRunConvertInstance, HrSWRunFreeInstance,
      hrSWRun_var_table } , 

    // hrSWRunEntry
    { TABLE, &hrSWRunEntry_oid, HRSWRUNENTRY_VAR_INDEX,
      MIN_HRSWRUNENTRY_CODE, MAX_HRSWRUNENTRY_CODE,
      HrSWRunEntryFindInstance, HrSWRunEntryFindNextInstance,
      HrSWRunEntryConvertInstance, HrSWRunEntryFreeInstance,
      hrSWRunEntry_var_table } , 

    // hrSWRunPerfEntry
    { TABLE, &hrSWRunPerfEntry_oid, HRSWRUNPERFENTRY_VAR_INDEX,
      MIN_HRSWRUNPERFENTRY_CODE, MAX_HRSWRUNPERFENTRY_CODE,
      HrSWRunPerfEntryFindInstance, HrSWRunPerfEntryFindNextInstance,
      HrSWRunPerfEntryConvertInstance, HrSWRunPerfEntryFreeInstance,
      hrSWRunPerfEntry_var_table } , 

    // hrSWInstalled
    { NON_TABLE, &hrSWInstalled_oid, HRSWINSTALLED_VAR_INDEX,
      MIN_HRSWINSTALLED_CODE, MAX_HRSWINSTALLED_CODE,
      HrSWInstalledFindInstance, HrSWInstalledFindNextInstance,
      HrSWInstalledConvertInstance, HrSWInstalledFreeInstance,
      hrSWInstalled_var_table } , 

    // hrSWInstalledEntry
    { TABLE, &hrSWInstalledEntry_oid, HRSWINSTALLEDENTRY_VAR_INDEX,
      MIN_HRSWINSTALLEDENTRY_CODE, MAX_HRSWINSTALLEDENTRY_CODE,
      HrSWInstalledEntryFindInstance, HrSWInstalledEntryFindNextInstance,
      HrSWInstalledEntryConvertInstance, HrSWInstalledEntryFreeInstance,
      hrSWInstalledEntry_var_table } , 
    } ; 

extern class_t class_info[] ;

extern char *EventLogString ;
extern char mibEventValue[] ;




/*
 *  UserMibInit
 *
 *    This routine is to allow user to initialize any variable at the time of
 *    dll's activation.  This routine setups up the registry for application
 *    event logging and calls out to the trap initialization code.  The user
 *    specific code follows.
 *
 *  Arguments:
 *
 *    hPollForTrapEvent    handle for traps - this is used to coordinate
 *                         between the Extendible Agent and this Extension
 *                         Agent.  It is passed to the TrapInit() routine.
 *                             - NULL indicates no traps
 *                             - value from CreateEvent() indicates traps
 *                               are implemented and the Extendible agent
 *                               must poll for them
 *
 *  Return Code:
 *
 *    SUCCESS     Successful initialization
 *    FAILURE     Unable to initialize
 *
 */

UINT
UserMibInit( IN OUT HANDLE *hPollForTrapEvent )
{
    HKEY hkey ;
    DWORD dwData ;
    UCHAR valuebuf[ 80 ] ;
    char mibEventKey[ 256 ] ;


    // The user must initialize the Event Log handle.  NULL in the first
    // argument indicates that the log is on the local machine.  The text
    // string for the second argument is the same as the subkey in the
    // registry under
    //       HKEY_LOCAL_MACHINE
    //         SYSTEM
    //           CurrentControlSet
    //             Services
    //               EventLog
    //                 Application
    //                   GenAgent    (for this example)
    //
    // But first create the subkey and set the values associated with it.
    // The subkey uses the eventLogString name.

    memset( mibEventKey, '\0', sizeof( UCHAR ) * 256 ) ;
    sprintf( mibEventKey ,
             "SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\%s" ,
             eventLogString ) ;
    if ( RegCreateKey( HKEY_LOCAL_MACHINE, mibEventKey, &hkey ) )
        return FAILURE ;

    memset( valuebuf, '\0', sizeof( UCHAR ) * 80 ) ;
    sprintf( valuebuf, "%%SystemRoot%%\\System32\\%s", mibEventValue ) ;
    if ( RegSetValueEx( hkey ,
                        "EventMessageFile" ,  // Value name
                        0 ,                   // must be zero
                        REG_EXPAND_SZ ,       // value type
                        (LPBYTE) valuebuf ,   // address of value data
                        strlen( valuebuf ) + 1 ) )
        return FAILURE ;
    dwData = EVENTLOG_ERROR_TYPE |
             EVENTLOG_WARNING_TYPE |
             EVENTLOG_INFORMATION_TYPE ;
    if ( RegSetValueEx( hkey ,
                        "TypesSupported" ,    // Value name
                        0 ,                   // must be zero
                        REG_DWORD ,           // value type
                        (LPBYTE)&dwData ,     // address of value data
                        sizeof( DWORD ) ) )   // length of value data
        return FAILURE ;
    RegCloseKey( hkey ) ;

    //
    //  USER'S INITIALIZATION CODE HERE.
    //

    /* 
    ||=============================================================
    || NOTE: Order of these initialization is important!
    ||       Some later inits may depend on earlier inits
    ||       ..see below
    ||=============================================================
    */


    /* HRSYSTEM DEPENDS:
    |  =================
    |   hrSystem Table has no cache, but the value of 
    |   "HrSystemInitialLoadDevice" depends on the hrDevice table having been
    |   initialized.
    */


    /* HRSTORAGE DEPENDS:
    |  =================
    |   None.
    */
    if (Gen_Hrstorage_Cache() == FALSE)      { return FAILURE ; }


    /* HRFSTABLE DEPENDS:
    |  =================
    |   The HRSTORAGE cache is searched in order to set the value of
    |   all "hrFSStorageIndex" attributes.
    */
    if (Gen_HrFSTable_Cache() == FALSE)      { return FAILURE ; }


    /* HRDEVICE DEPENDS:
    |  =================
    |   The HRFSTABLE cache is searched in order to set the values for
    |   "hrPartitionFSIndex" attributes in the hrPartition sub-table of
    |   the hrdevice table.
    |
    | Debugging Note:
    |  If you temporarily "no-op" the next line (and trigger the
    |  actual invocation of this cache build function from, say,
    |  function "SetHrStorageSize()" by sending a "SET" of that variable),
    |  you also need to "no-op" the invocation of "TrapInit()" below,
    |  otherwise the subagent will trap when the hrProcessorLoad timer
    |  (set-up by "TrapInit()" below) goes off.
    */
    if (Gen_HrDevice_Cache() == FALSE)       { return FAILURE ; }


    /* HRSWINSTALLED DEPENDS:
    |  ======================
    |   None.
    */
    if (Gen_HrSWInstalled_Cache() == FALSE)  { return FAILURE ; }


    /* HRSWRUN/PERF DEPENDS:
    |  =====================
    |   None.  This function is called repeatedly to refresh the cache
    |   at intervals of CACHE_MAX_AGE (defined in "HRSWRUNE.C").
    */
    if (Gen_HrSWRun_Cache() == FALSE)        { return FAILURE ; }


    /*
    | This "TrapInit" processing is deferred until after Gen_HrDevice_Cache()
    | processing has been done.
    |
    | Because no traps are defined by HostMIB, we use the mechanism
    | (by which the main SNMP agent "polls" for Traps when an event goes off)
    | to actually cause the HostMIB subagent to be periodically entered so
    | that timer-counts needed to accurately report "hrProcessorLoad"
    | values for each CPU may be refreshed.
    |
    | The hrProcessor sub-table initialization is performed as part of
    | hrDevice table init.  Buffer initialization for hrProcessorLoad is done
    | as part of this initialization and must be complete before we do this
    | "TrapInit()" call.
    |
    | "TrapInit()" in reality sets up the timer handle returned as 
    | "hPollForTrapEvent".  The function that is entered when the timer 
    | goes off ("hrProcessLoad_Refresh()" in "HRPROCES.C") expects the 
    | buffer initialization to have already been performed... hence the 
    | call to "TrapInit()" must follow other cache initialization.
    */    
    TrapInit( hPollForTrapEvent ) ;

    return SUCCESS ;

} /* end of UserMibInit() */