/* * 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 #include #include #include #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() */