1223 lines
40 KiB
C
1223 lines
40 KiB
C
/*
|
||
* HrPartitionEntry.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:
|
||
*
|
||
* Windows NT SNMP Extension Agent
|
||
*
|
||
* Abstract:
|
||
*
|
||
* This module contains the code for dealing with the get, set, and
|
||
* instance name routines for the HrPartitionEntry. Actual instrumentation code is
|
||
* supplied by the developer.
|
||
*
|
||
* Functions:
|
||
*
|
||
* A get and set routine for each attribute in the class.
|
||
*
|
||
* The routines for instances within the class.
|
||
*
|
||
* Author:
|
||
*
|
||
* D. D. Burns @ Webenable Inc
|
||
*
|
||
* Revision History:
|
||
*
|
||
* V1.00 - 04/28/97 D. D. Burns Genned: Thu Nov 07 16:43:52 1996
|
||
*
|
||
|
|
||
| The approach envisioned for generating the contents of this table consists
|
||
| of walking all physical drives (using CreateFile and the "physical drive"
|
||
| naming convention) and acquiring the partition information for each drive
|
||
| using Win32 API functions DeviceIoControl (IOCTL_DISK_GET_DRIVE_LAYOUT).
|
||
|
|
||
*/
|
||
|
||
|
||
#include <windows.h>
|
||
#include <malloc.h>
|
||
|
||
#include <snmp.h>
|
||
|
||
#include "mib.h"
|
||
#include "smint.h"
|
||
#include "hostmsmi.h"
|
||
#include "user.h" /* Developer supplied include file */
|
||
#include "HMCACHE.H" /* Cache-related definitions */
|
||
#include "HRDEVENT.H" /* HrDevice Table-related definitions */
|
||
|
||
|
||
/*
|
||
|==============================================================================
|
||
| A word about the cache for this sub-table.
|
||
|
|
||
| This is a unique sub-table within the hrDevice table in that it is doubly
|
||
| indexed.
|
||
|
|
||
| As a consequence, there are multiple instances of the cache-head,
|
||
| one for each simple instance of this table. Consequently there is no
|
||
| single, static instance of a cache-head to be found (as is typically the
|
||
| case for sub-tables of hrDevice) here at the start of the module.
|
||
|
|
||
| The "value" of the "hidden-context" attribute for a hrDevice table
|
||
| row for this sub-table has as its value a pointer to a slug of malloced
|
||
| memory containing the cache-head for that instance of this sub-table.
|
||
| (See "HMCACHE.C" for storage picture).
|
||
|
|
||
| Initialization of this sub-table occurs as part of the initialization
|
||
| of the HrDiskStorage sub-table (HRDISKST.C) in function "ProcessPartitions".
|
||
*/
|
||
|
||
/*
|
||
|==============================================================================
|
||
| Function Prototypes for this module.
|
||
*/
|
||
/* RollToNextFixedDisk - Helper Routine for HrPartitionEntryFindNextInstance */
|
||
static UINT
|
||
RollToNextFixedDisk (
|
||
UINT *dev_tmp_instance , /* ->Device Table Instance Arc ("1st") */
|
||
UINT *part_tmp_instance , /* ->Partition Table Instance Arc ("2nd") */
|
||
CACHEROW **dev_row, /* ->> Entry in hrDevice Table */
|
||
CACHEHEAD **part_cache /* ->> Cache-Header for Partition */
|
||
);
|
||
|
||
|
||
/*
|
||
* GetHrPartitionIndex
|
||
* A unique value for each partition on this long term storage device. The
|
||
* value for each long-term storage device must remain con
|
||
*
|
||
* Gets the value for HrPartitionIndex.
|
||
*
|
||
* Arguments:
|
||
*
|
||
* outvalue address to return variable value
|
||
* accesss Reserved for future security use
|
||
* instance address of instance name as ordered native
|
||
* data type(s)
|
||
*
|
||
* Return Codes:
|
||
*
|
||
* Standard PDU error codes.
|
||
*
|
||
* SNMP_ERRORSTATUS_NOERROR Successful get
|
||
* SNMP_ERRORSTATUS_GENERR Catch-all failure code
|
||
* mibtget.c v0.10
|
||
*
|
||
| =============== From WebEnable Design Spec Rev 3 04/11/97==================
|
||
| hrPartitionIndex
|
||
|
|
||
| ACCESS SYNTAX
|
||
| read-only INTEGER (1..2147483647)
|
||
|
|
||
| "A unique value for each partition on this long- term storage device. The
|
||
| value for each long-term storage device must remain constant at least from one
|
||
| re-initialization of the agent to the next re- initialization."
|
||
|
|
||
| DISCUSSION:
|
||
|
|
||
| (See discussion above for the table as a whole).
|
||
|
|
||
|============================================================================
|
||
| 1.3.6.1.2.1.25.3.7.1.1.<dev-instance>.<partition-instance>
|
||
| | | | |
|
||
| | | | *-hrPartitionIndex
|
||
| | | *-hrPartitionEntry
|
||
| | *-hrPartitionTable
|
||
| *-hrDevice
|
||
*/
|
||
|
||
UINT
|
||
GetHrPartitionIndex(
|
||
OUT Integer *outvalue ,
|
||
IN Access_Credential *access ,
|
||
IN InstanceName *instance )
|
||
|
||
{
|
||
ULONG disk_index; /* As fetched from instance structure */
|
||
ULONG part_index; /* As fetched from instance structure */
|
||
CACHEROW *disk_row; /* Row entry fetched from Disk cache */
|
||
CACHEROW *part_row; /* Row entry fetched from Part. cache */
|
||
CACHEHEAD *part_cache; /* HrPartition Table cache to search */
|
||
|
||
|
||
/*
|
||
| Grab the instance information
|
||
*/
|
||
disk_index = GET_INSTANCE(0);
|
||
part_index = GET_INSTANCE(1);
|
||
|
||
|
||
/*
|
||
|===========
|
||
| Index 1
|
||
| Use Disk-Index to find the right Disk-row entry in the hrDevice cache
|
||
*/
|
||
if ((disk_row = FindTableRow(disk_index, &hrDevice_cache)) == NULL) {
|
||
return SNMP_ERRORSTATUS_GENERR;
|
||
}
|
||
|
||
/* Grab a pointer to the hrPartition cache for this disk */
|
||
part_cache = disk_row->attrib_list[HIDDEN_CTX].u.cache;
|
||
|
||
|
||
/*
|
||
|===========
|
||
| Index 2
|
||
| Use Partition-Index to find the right row entry in the hrPartition cache
|
||
*/
|
||
if ((part_row = FindTableRow(part_index, part_cache)) == NULL) {
|
||
return SNMP_ERRORSTATUS_GENERR;
|
||
}
|
||
|
||
*outvalue = part_row->attrib_list[HRPT_INDEX].u.unumber_value;
|
||
|
||
return SNMP_ERRORSTATUS_NOERROR ;
|
||
|
||
} /* end of GetHrPartitionIndex() */
|
||
|
||
|
||
/*
|
||
* GetHrPartitionLabel
|
||
* A textual description of this partition.
|
||
*
|
||
* Gets the value for HrPartitionLabel.
|
||
*
|
||
* Arguments:
|
||
*
|
||
* outvalue address to return variable value
|
||
* accesss Reserved for future security use
|
||
* instance address of instance name as ordered native
|
||
* data type(s)
|
||
*
|
||
* Return Codes:
|
||
*
|
||
* Standard PDU error codes.
|
||
*
|
||
* SNMP_ERRORSTATUS_NOERROR Successful get
|
||
* SNMP_ERRORSTATUS_GENERR Catch-all failure code
|
||
* mibtget.c v0.10
|
||
*
|
||
| =============== From WebEnable Design Spec Rev 3 04/11/97==================
|
||
| hrPartitionLabel
|
||
|
|
||
| ACCESS SYNTAX
|
||
| read-only InternationalDisplayString (SIZE (0..128))
|
||
|
|
||
| "A textual description of this partition."
|
||
|
|
||
| DISCUSSION:
|
||
|
|
||
| This information for the entire drive is obtained using Win32 API CreateFile
|
||
| to open the device and DeviceIoControl to retrieve the needed information.
|
||
|
|
||
|============================================================================
|
||
| 1.3.6.1.2.1.25.3.7.1.2.<dev-instance>.<partition-instance>
|
||
| | | | |
|
||
| | | | *-hrPartitionLabel
|
||
| | | *-hrPartitionEntry
|
||
| | *-hrPartitionTable
|
||
| *-hrDevice
|
||
*/
|
||
|
||
UINT
|
||
GetHrPartitionLabel(
|
||
OUT InternationalDisplayString *outvalue ,
|
||
IN Access_Credential *access ,
|
||
IN InstanceName *instance )
|
||
|
||
{
|
||
ULONG disk_index; /* As fetched from instance structure */
|
||
ULONG part_index; /* As fetched from instance structure */
|
||
CACHEROW *disk_row; /* Row entry fetched from Disk cache */
|
||
CACHEROW *part_row; /* Row entry fetched from Part. cache */
|
||
CACHEHEAD *part_cache; /* HrPartition Table cache to search */
|
||
|
||
|
||
/*
|
||
| Grab the instance information
|
||
*/
|
||
disk_index = GET_INSTANCE(0);
|
||
part_index = GET_INSTANCE(1);
|
||
|
||
|
||
/*
|
||
|===========
|
||
| Index 1
|
||
| Use Disk-Index to find the right Disk-row entry in the hrDevice cache
|
||
*/
|
||
if ((disk_row = FindTableRow(disk_index, &hrDevice_cache)) == NULL) {
|
||
return SNMP_ERRORSTATUS_GENERR;
|
||
}
|
||
|
||
/* Grab a pointer to the hrPartition cache for this disk */
|
||
part_cache = disk_row->attrib_list[HIDDEN_CTX].u.cache;
|
||
|
||
|
||
/*
|
||
|===========
|
||
| Index 2
|
||
| Use Partition-Index to find the right row entry in the hrPartition cache
|
||
*/
|
||
if ((part_row = FindTableRow(part_index, part_cache)) == NULL) {
|
||
return SNMP_ERRORSTATUS_GENERR;
|
||
}
|
||
|
||
outvalue->string = part_row->attrib_list[HRPT_LABEL].u.string_value;
|
||
|
||
if (outvalue->string == NULL) {
|
||
outvalue->length = 0;
|
||
}
|
||
else {
|
||
outvalue->length = strlen(outvalue->string);
|
||
|
||
/* "Truncate" here to meet RFC as needed*/
|
||
if (outvalue->length > 128) {
|
||
outvalue->length = 128;
|
||
}
|
||
}
|
||
|
||
return SNMP_ERRORSTATUS_NOERROR ;
|
||
|
||
|
||
} /* end of GetHrPartitionLabel() */
|
||
|
||
|
||
/*
|
||
* GetHrPartitionID
|
||
* A descriptor which uniquely represents this partition to the responsible
|
||
* operating system. On some systems, this might take on
|
||
*
|
||
* Gets the value for HrPartitionID.
|
||
*
|
||
* Arguments:
|
||
*
|
||
* outvalue address to return variable value
|
||
* accesss Reserved for future security use
|
||
* instance address of instance name as ordered native
|
||
* data type(s)
|
||
*
|
||
* Return Codes:
|
||
*
|
||
* Standard PDU error codes.
|
||
*
|
||
* SNMP_ERRORSTATUS_NOERROR Successful get
|
||
* SNMP_ERRORSTATUS_GENERR Catch-all failure code
|
||
* mibtget.c v0.10
|
||
*
|
||
| =============== From WebEnable Design Spec Rev 3 04/11/97==================
|
||
| hrPartitionID
|
||
|
|
||
| ACCESS SYNTAX
|
||
| read-only OCTET STRING
|
||
|
|
||
| "A descriptor which uniquely represents this partition to the responsible
|
||
| operating system. On some systems, this might take on a binary
|
||
| representation."
|
||
|
|
||
| DISCUSSION:
|
||
|
|
||
| This information for the entire drive is obtained using Win32 API CreateFile
|
||
| to open the device and DeviceIoControl to retrieve the needed information.
|
||
|
|
||
|
|
||
|============================================================================
|
||
| 1.3.6.1.2.1.25.3.7.1.3.<dev-instance>.<partition-instance>
|
||
| | | | |
|
||
| | | | *-hrPartitionID
|
||
| | | *-hrPartitionEntry
|
||
| | *-hrPartitionTable
|
||
| *-hrDevice
|
||
*/
|
||
|
||
UINT
|
||
GetHrPartitionID(
|
||
OUT OctetString *outvalue ,
|
||
IN Access_Credential *access ,
|
||
IN InstanceName *instance )
|
||
|
||
{
|
||
ULONG disk_index; /* As fetched from instance structure */
|
||
ULONG part_index; /* As fetched from instance structure */
|
||
CACHEROW *disk_row; /* Row entry fetched from Disk cache */
|
||
CACHEROW *part_row; /* Row entry fetched from Part. cache */
|
||
CACHEHEAD *part_cache; /* HrPartition Table cache to search */
|
||
|
||
|
||
/*
|
||
| Grab the instance information
|
||
*/
|
||
disk_index = GET_INSTANCE(0);
|
||
part_index = GET_INSTANCE(1);
|
||
|
||
|
||
/*
|
||
|===========
|
||
| Index 1
|
||
| Use Disk-Index to find the right Disk-row entry in the hrDevice cache
|
||
*/
|
||
if ((disk_row = FindTableRow(disk_index, &hrDevice_cache)) == NULL) {
|
||
return SNMP_ERRORSTATUS_GENERR;
|
||
}
|
||
|
||
/* Grab a pointer to the hrPartition cache for this disk */
|
||
part_cache = disk_row->attrib_list[HIDDEN_CTX].u.cache;
|
||
|
||
|
||
/*
|
||
|===========
|
||
| Index 2
|
||
| Use Partition-Index to find the right row entry in the hrPartition cache
|
||
*/
|
||
if ((part_row = FindTableRow(part_index, part_cache)) == NULL) {
|
||
return SNMP_ERRORSTATUS_GENERR;
|
||
}
|
||
|
||
outvalue->string = (char *) &(part_row->attrib_list[HRPT_ID].u.unumber_value);
|
||
outvalue->length = 4;
|
||
|
||
return SNMP_ERRORSTATUS_NOERROR ;
|
||
|
||
} /* end of GetHrPartitionID() */
|
||
|
||
|
||
/*
|
||
* GetHrPartitionSize
|
||
* The size of this partition.
|
||
*
|
||
* Gets the value for HrPartitionSize.
|
||
*
|
||
* Arguments:
|
||
*
|
||
* outvalue address to return variable value
|
||
* accesss Reserved for future security use
|
||
* instance address of instance name as ordered native
|
||
* data type(s)
|
||
*
|
||
* Return Codes:
|
||
*
|
||
* Standard PDU error codes.
|
||
*
|
||
* SNMP_ERRORSTATUS_NOERROR Successful get
|
||
* SNMP_ERRORSTATUS_GENERR Catch-all failure code
|
||
* mibtget.c v0.10
|
||
*
|
||
| =============== From WebEnable Design Spec Rev 3 04/11/97==================
|
||
| hrPartitionSize
|
||
|
|
||
| ACCESS SYNTAX
|
||
| read-only KBytes
|
||
|
|
||
| "The size of this partition."
|
||
|
|
||
| DISCUSSION:
|
||
|
|
||
| This information for the entire drive is obtained using Win32 API CreateFile
|
||
| to open the device and DeviceIoControl to retrieve the needed information.
|
||
|
|
||
|============================================================================
|
||
| 1.3.6.1.2.1.25.3.7.1.4.<dev-instance>.<partition-instance>
|
||
| | | | |
|
||
| | | | *-hrPartitionSize
|
||
| | | *-hrPartitionEntry
|
||
| | *-hrPartitionTable
|
||
| *-hrDevice
|
||
*/
|
||
|
||
UINT
|
||
GetHrPartitionSize(
|
||
OUT KBytes *outvalue ,
|
||
IN Access_Credential *access ,
|
||
IN InstanceName *instance )
|
||
|
||
{
|
||
ULONG disk_index; /* As fetched from instance structure */
|
||
ULONG part_index; /* As fetched from instance structure */
|
||
CACHEROW *disk_row; /* Row entry fetched from Disk cache */
|
||
CACHEROW *part_row; /* Row entry fetched from Part. cache */
|
||
CACHEHEAD *part_cache; /* HrPartition Table cache to search */
|
||
|
||
|
||
/*
|
||
| Grab the instance information
|
||
*/
|
||
disk_index = GET_INSTANCE(0);
|
||
part_index = GET_INSTANCE(1);
|
||
|
||
|
||
/*
|
||
|===========
|
||
| Index 1
|
||
| Use Disk-Index to find the right Disk-row entry in the hrDevice cache
|
||
*/
|
||
if ((disk_row = FindTableRow(disk_index, &hrDevice_cache)) == NULL) {
|
||
return SNMP_ERRORSTATUS_GENERR;
|
||
}
|
||
|
||
/* Grab a pointer to the hrPartition cache for this disk */
|
||
part_cache = disk_row->attrib_list[HIDDEN_CTX].u.cache;
|
||
|
||
|
||
/*
|
||
|===========
|
||
| Index 2
|
||
| Use Partition-Index to find the right row entry in the hrPartition cache
|
||
*/
|
||
if ((part_row = FindTableRow(part_index, part_cache)) == NULL) {
|
||
return SNMP_ERRORSTATUS_GENERR;
|
||
}
|
||
|
||
*outvalue = part_row->attrib_list[HRPT_SIZE].u.unumber_value;
|
||
|
||
return SNMP_ERRORSTATUS_NOERROR ;
|
||
|
||
} /* end of GetHrPartitionSize() */
|
||
|
||
|
||
/*
|
||
* GetHrPartitionFSIndex
|
||
* The index of the file system mounted on this partition. If no file
|
||
* system is mounted on this partition, then this value shall b
|
||
*
|
||
* Gets the value for HrPartitionFSIndex.
|
||
*
|
||
* Arguments:
|
||
*
|
||
* outvalue address to return variable value
|
||
* accesss Reserved for future security use
|
||
* instance address of instance name as ordered native
|
||
* data type(s)
|
||
*
|
||
* Return Codes:
|
||
*
|
||
* Standard PDU error codes.
|
||
*
|
||
* SNMP_ERRORSTATUS_NOERROR Successful get
|
||
* SNMP_ERRORSTATUS_GENERR Catch-all failure code
|
||
* mibtget.c v0.10
|
||
*
|
||
| =============== From WebEnable Design Spec Rev 3 04/11/97==================
|
||
| hrPartitionFSIndex
|
||
|
|
||
| ACCESS SYNTAX
|
||
| read-only INTEGER (0..2147483647)
|
||
|
|
||
| "The index of the file system mounted on this partition. If no file system is
|
||
| mounted on this partition, then this value shall be zero. Note that multiple
|
||
| partitions may point to one file system, denoting that that file system
|
||
| resides on those partitions. Multiple file systems may not reside on one
|
||
| partition."
|
||
|
|
||
| DISCUSSION:
|
||
|
|
||
| This information for the entire drive is obtained using Win32 API CreateFile
|
||
| to open the device and DeviceIoControl to retrieve the needed information.
|
||
|
|
||
|============================================================================
|
||
| 1.3.6.1.2.1.25.3.7.1.5.<dev-instance>.<partition-instance>
|
||
| | | | |
|
||
| | | | *-hrPartitionFSIndex
|
||
| | | *-hrPartitionEntry
|
||
| | *-hrPartitionTable
|
||
| *-hrDevice
|
||
*/
|
||
|
||
UINT
|
||
GetHrPartitionFSIndex(
|
||
OUT Integer *outvalue ,
|
||
IN Access_Credential *access ,
|
||
IN InstanceName *instance )
|
||
|
||
{
|
||
ULONG disk_index; /* As fetched from instance structure */
|
||
ULONG part_index; /* As fetched from instance structure */
|
||
CACHEROW *disk_row; /* Row entry fetched from Disk cache */
|
||
CACHEROW *part_row; /* Row entry fetched from Part. cache */
|
||
CACHEHEAD *part_cache; /* HrPartition Table cache to search */
|
||
|
||
|
||
/*
|
||
| Grab the instance information
|
||
*/
|
||
disk_index = GET_INSTANCE(0);
|
||
part_index = GET_INSTANCE(1);
|
||
|
||
|
||
/*
|
||
|===========
|
||
| Index 1
|
||
| Use Disk-Index to find the right Disk-row entry in the hrDevice cache
|
||
*/
|
||
if ((disk_row = FindTableRow(disk_index, &hrDevice_cache)) == NULL) {
|
||
return SNMP_ERRORSTATUS_GENERR;
|
||
}
|
||
|
||
/* Grab a pointer to the hrPartition cache for this disk */
|
||
part_cache = disk_row->attrib_list[HIDDEN_CTX].u.cache;
|
||
|
||
|
||
/*
|
||
|===========
|
||
| Index 2
|
||
| Use Partition-Index to find the right row entry in the hrPartition cache
|
||
*/
|
||
if ((part_row = FindTableRow(part_index, part_cache)) == NULL) {
|
||
return SNMP_ERRORSTATUS_GENERR;
|
||
}
|
||
|
||
*outvalue = part_row->attrib_list[HRPT_FSINDEX].u.unumber_value;
|
||
|
||
return SNMP_ERRORSTATUS_NOERROR ;
|
||
|
||
} /* end of GetHrPartitionFSIndex() */
|
||
|
||
|
||
/*
|
||
* HrPartitionEntryFindInstance
|
||
*
|
||
* This routine is used to verify that the specified instance is
|
||
* valid.
|
||
*
|
||
* Arguments:
|
||
*
|
||
* FullOid Address for the full oid - group, variable,
|
||
* and instance information
|
||
* instance Address for instance specification as an oid
|
||
*
|
||
* Return Codes:
|
||
*
|
||
* SNMP_ERRORSTATUS_NOERROR Instance found and valid
|
||
* SNMP_ERRORSTATUS_NOSUCHNAME Invalid instance
|
||
*
|
||
*/
|
||
|
||
UINT
|
||
HrPartitionEntryFindInstance( IN ObjectIdentifier *FullOid ,
|
||
IN OUT ObjectIdentifier *instance )
|
||
{
|
||
UINT dev_tmp_instance ; /* Device Table Instance Arc */
|
||
UINT part_tmp_instance ; /* Partition Table Instance Arc */
|
||
CACHEROW *dev_row; /* --> Entry in hrDevice Table */
|
||
CACHEHEAD *part_cache; /* --> Cache-Header for Partition*/
|
||
|
||
|
||
//
|
||
// Developer instrumentation code to find appropriate instance goes here.
|
||
// For non-tables, it is not necessary to modify this routine. However, if
|
||
// there is any context that needs to be set, it can be done here.
|
||
//
|
||
|
||
if ( FullOid->idLength <= HRPARTITIONENTRY_VAR_INDEX )
|
||
// No instance was specified
|
||
return SNMP_ERRORSTATUS_NOSUCHNAME ;
|
||
// Instance is 2 arcs for this table:
|
||
else if ( FullOid->idLength != HRPARTITIONENTRY_VAR_INDEX + 2 )
|
||
// Instance length is more than 2, or 1 exactly, either way: error
|
||
return SNMP_ERRORSTATUS_NOSUCHNAME ;
|
||
else
|
||
// The only valid instance for a non-table are instance 0. If this
|
||
// is a non-table, the following code validates the instances. If this
|
||
// is a table, developer modification is necessary below.
|
||
|
||
/*
|
||
| Check the first of two instance arcs here. The first should
|
||
| select a valid entry in hrDiskStorage cache. This guarantees
|
||
| that a disk is being selected. If a valid entry is present in
|
||
| hrDiskStorage cache, then a corresponding row should be in the
|
||
| main hrDevice table (and having checked hrDiskStorage first, we
|
||
| don't have to verify the type of the entry in hrDevice).
|
||
|
|
||
| The corresponding hrDevice row entry should have a hidden-context
|
||
| that is a non-NULL pointer to a CACHEHEAD **if** the first instance
|
||
| arc is truly selecting a Fixed-Disk (which is the only kind of disk
|
||
| for which HrPartition sub-tables are constructed).
|
||
*/
|
||
dev_tmp_instance = FullOid->ids[ HRPARTITIONENTRY_VAR_INDEX ] ;
|
||
|
||
if ( FindTableRow(dev_tmp_instance, &hrDiskStorage_cache) == NULL ) {
|
||
return SNMP_ERRORSTATUS_NOSUCHNAME ;
|
||
}
|
||
|
||
/*
|
||
| Ok, there is an entry in hrDiskStorage, now go get the corresponding
|
||
| hrDevice entry... it **will be** for a Disk.
|
||
*/
|
||
if ( (dev_row = FindTableRow(dev_tmp_instance, &hrDevice_cache))
|
||
== NULL ) {
|
||
return SNMP_ERRORSTATUS_GENERR ;
|
||
}
|
||
|
||
/*
|
||
| Check to be sure there is a cache tucked into the hidden-context,
|
||
| this assures us it is a Fixed Disk and that there is something to
|
||
| search given the second instance arc. (The cache header may be
|
||
| for an empty cache, but it will support a search).
|
||
*/
|
||
if (dev_row->attrib_list[HIDDEN_CTX].attrib_type != CA_CACHE ||
|
||
(part_cache = dev_row->attrib_list[HIDDEN_CTX].u.cache) == NULL) {
|
||
return SNMP_ERRORSTATUS_NOSUCHNAME ;
|
||
}
|
||
|
||
/*
|
||
| First instance arc ("dev_tmp_instance") is kosher... check the second,
|
||
| ("part_tmp_instance") it should select a valid entry in the cache
|
||
| whose header pointer is in HIDDEN_CTX.
|
||
*/
|
||
part_tmp_instance = FullOid->ids[ HRPARTITIONENTRY_VAR_INDEX + 1] ;
|
||
if ( FindTableRow(part_tmp_instance, part_cache) == NULL ) {
|
||
return SNMP_ERRORSTATUS_NOSUCHNAME ;
|
||
}
|
||
|
||
else
|
||
{
|
||
// the both instances are valid. Create the instance portion of
|
||
// the OID to be returned from this call.
|
||
instance->ids[ 0 ] = dev_tmp_instance ;
|
||
instance->ids[ 1 ] = part_tmp_instance ;
|
||
instance->idLength = 2 ;
|
||
}
|
||
|
||
return SNMP_ERRORSTATUS_NOERROR ;
|
||
|
||
} /* end of HrPartitionEntryFindInstance() */
|
||
|
||
|
||
|
||
/*
|
||
* HrPartitionEntryFindNextInstance
|
||
*
|
||
* This routine is called to get the next instance. If no instance
|
||
* was passed than return the first instance (1).
|
||
*
|
||
* Arguments:
|
||
*
|
||
* FullOid Address for the full oid - group, variable,
|
||
* and instance information
|
||
* instance Address for instance specification as an oid
|
||
*
|
||
* Return Codes:
|
||
*
|
||
* SNMP_ERRORSTATUS_NOERROR Instance found and valid
|
||
* SNMP_ERRORSTATUS_NOSUCHNAME Invalid instance
|
||
*
|
||
*/
|
||
|
||
UINT
|
||
HrPartitionEntryFindNextInstance( IN ObjectIdentifier *FullOid ,
|
||
IN OUT ObjectIdentifier *instance )
|
||
{
|
||
UINT dev_tmp_instance=0; /* Device Table Instance Arc ("1st") */
|
||
UINT part_tmp_instance=0; /* Partition Table Instance Arc ("2nd")*/
|
||
CACHEROW *hrDevice_row; /* Looked-up row in hrDevice table */
|
||
CACHEROW *dev_row = NULL; /* --> Entry in hrDiskStorage Table */
|
||
CACHEROW *part_row = NULL; /* --> Entry in hrPartition Table */
|
||
CACHEHEAD *part_cache=NULL; /* --> Cache-Header for Partition */
|
||
UINT ret_status; /* Status to be returned by this func */
|
||
|
||
|
||
//
|
||
// Developer supplied code to find the next instance of class goes here.
|
||
// If this is a class with cardinality 1, no modification of this routine
|
||
// is necessary unless additional context needs to be set.
|
||
// If the FullOid does not specify an instance, then the only instance
|
||
// of the class is returned. If this is a table, the first row of the
|
||
// table is returned.
|
||
//
|
||
// If an instance is specified and this is a non-table class, then NOSUCHNAME
|
||
// is returned so that correct MIB rollover processing occurs. If this is
|
||
// a table, then the next instance is the one following the current instance.
|
||
// If there are no more instances in the table, return NOSUCHNAME.
|
||
//
|
||
|
||
/*
|
||
| With two numeric indices to deal with on this table, we're attempting
|
||
| to cover the following situations:
|
||
|
|
||
| 1) No instance arcs provided at all. In this case, we need to look up
|
||
| and return the instance arcs that select the first fixed-disk and
|
||
| the first partition within that disk. We cover this case as a
|
||
| "standalone" case.
|
||
|
|
||
| 2) Only the hrdevice ("disk selecting") first instance arc is provided.
|
||
| In this case, we'll "assume" an initial partition-selecting instance
|
||
| arc of "0", and continue processing with the code that covers case 3.
|
||
|
|
||
| 3) Two or more instance arcs are provided, in which case we just use the
|
||
| first of two arcs as the hrdevice ("disk selecting") "first" instance
|
||
| arc and the second arc as the hrPartition ("partition selecting")
|
||
| "second" instance arc, ignoring any remaining arcs.
|
||
|
|
||
| The "Party Line" on this logic is that it works even if the "fixed-disk"
|
||
| entries don't have monotonically increasing indices the way the
|
||
| cache-population code currently creates them and even if the partition
|
||
| cache (table) has no entries for a particular disk (it must, however
|
||
| have a cache).
|
||
*/
|
||
|
||
|
||
if ( FullOid->idLength <= HRPARTITIONENTRY_VAR_INDEX ) {
|
||
|
||
/* CASE 1
|
||
|
|
||
| No instance arcs were provided, so we want to setup local instance
|
||
| arcs that select the first hrDevice table "Fixed Disk" entry and the
|
||
| first "Partition" entry within that disk (if any disk and if any
|
||
| partitions within that disk).
|
||
|
|
||
| Entry into "RollToNextFixedDisk()" is special for this case as
|
||
| "dev_row" is NULL, so it'll roll to the first legal Fixed-Disk.
|
||
*/
|
||
ret_status =
|
||
RollToNextFixedDisk(&dev_tmp_instance, // hrDiskStorage arc
|
||
&part_tmp_instance, // hrPartition arc
|
||
&dev_row, // row in hrDiskStorage
|
||
&part_cache // cache for hrPartition
|
||
);
|
||
|
||
/* If we got a no-good return status */
|
||
if (ret_status != SNMP_ERRORSTATUS_NOERROR) {
|
||
return ( ret_status );
|
||
}
|
||
|
||
/*
|
||
| Ok, all we need to do is roll into the hrPartition table using the
|
||
| second instance arc returned above (which will be zero) to find
|
||
| the true first entry in the hrPartition table cache so we can return
|
||
| it's index as the second instance arc, (or keep rolling if the
|
||
| partition table (cache) is empty (which it really shouldn't be, but
|
||
| we have it covered if it is)).
|
||
|
|
||
| All this is performed by the "General Roll" code below.
|
||
*/
|
||
}
|
||
|
||
else { /* Some instance arcs provided */
|
||
|
||
if ( FullOid->idLength == HRPARTITIONENTRY_VAR_INDEX + 1 ) {
|
||
|
||
/* CASE 2
|
||
|
|
||
| Exactly one instance arc is provided,
|
||
| so use it and assume the second arc is 0.
|
||
*/
|
||
dev_tmp_instance = FullOid->ids[ HRPARTITIONENTRY_VAR_INDEX ] ;
|
||
part_tmp_instance = 0;
|
||
}
|
||
|
||
else {
|
||
|
||
/* CASE 3
|
||
|
|
||
| Two or more instance arcs are provided,
|
||
| so use the first two arcs and ignore the rest.
|
||
*/
|
||
dev_tmp_instance = FullOid->ids[ HRPARTITIONENTRY_VAR_INDEX ] ;
|
||
part_tmp_instance = FullOid->ids[ HRPARTITIONENTRY_VAR_INDEX + 1] ;
|
||
}
|
||
|
||
/* Show "No HrPartition Cache Selected Yet" (at entry time: NULL) */
|
||
|
||
/*
|
||
| At this point, we need to know whether the first instance arc
|
||
| actually selects a Fixed-Disk entry in hrDevice (and hrDiskStorage)
|
||
| that has an hrPartition table that we can "roll" thru.
|
||
|
|
||
| Attempt a direct ("non-rolling") lookup on the hrDiskStorage table
|
||
| cache with the first instance arc.
|
||
*/
|
||
dev_row = FindTableRow(dev_tmp_instance, &hrDiskStorage_cache);
|
||
|
||
/*
|
||
| If (an entry is found)
|
||
*/
|
||
if ( dev_row != NULL) {
|
||
|
||
/* If (the entry is for a "Fixed-Disk") */
|
||
if ( dev_row->attrib_list[HRDS_REMOVABLE].u.unumber_value
|
||
== FALSE) {
|
||
|
||
/*
|
||
| Perform "FindTableRow" on hrdevice cache using first
|
||
| instance arc.
|
||
*/
|
||
hrDevice_row = FindTableRow(dev_tmp_instance, &hrDevice_cache);
|
||
|
||
/*
|
||
| If (no hrdevice entry was found)
|
||
*/
|
||
if ( hrDevice_row == NULL) {
|
||
return SNMP_ERRORSTATUS_GENERR ;
|
||
}
|
||
|
||
/*
|
||
| If the hrdevice entry DOES NOT have a
|
||
| cache associated with it . . .
|
||
*/
|
||
if ( (hrDevice_row->attrib_list[HIDDEN_CTX].attrib_type
|
||
!= CA_CACHE) ||
|
||
|
||
(hrDevice_row->attrib_list[HIDDEN_CTX].u.cache
|
||
== NULL)) {
|
||
|
||
return SNMP_ERRORSTATUS_GENERR ;
|
||
}
|
||
|
||
/*
|
||
| Select the cache from the hrdevice disk entry as the
|
||
| HrPartition table cache to be searched in the following
|
||
| logic.
|
||
*/
|
||
part_cache = hrDevice_row->attrib_list[HIDDEN_CTX].u.cache;
|
||
|
||
} /* if entry was fixed-disk */
|
||
|
||
} /* if entry was found */
|
||
|
||
/*
|
||
| At this point, if a hrpartition cache has been selected (!NULL),
|
||
| the first instance arc has selected a fixed-disk entry
|
||
| and there is no need to "roll" on the first index.
|
||
|
|
||
| Otherwise we've got to "reset" the second instance arc
|
||
| to "0" and do a rolling lookup on the first arc for
|
||
| another Fixed-disk entry (that should have a partition-cache).
|
||
*/
|
||
|
||
/* if (an hrpartition cache has NOT been selected) */
|
||
if (part_cache == NULL) {
|
||
|
||
/* Perform "RollToNextFixedDisk" processing */
|
||
ret_status =
|
||
RollToNextFixedDisk(&dev_tmp_instance, // hrDiskStorage arc
|
||
&part_tmp_instance, // hrPartition arc
|
||
&dev_row, // row in hrDiskStorage
|
||
&part_cache // hrPartition cache
|
||
);
|
||
|
||
/* If we got a no-good return status */
|
||
if (ret_status != SNMP_ERRORSTATUS_NOERROR) {
|
||
return ( ret_status ); // (either NOSUCH or GENERR)
|
||
}
|
||
}
|
||
|
||
} /* else Some instance arcs provided */
|
||
|
||
/*
|
||
| At this point, we have:
|
||
|
|
||
| + a valid hrPartition cache to search,
|
||
| + the second instance arc to search it with (by "rolling"),
|
||
| + the first instance arc that is valid, (but may need to be
|
||
| rolled again if there are no valid partitions found).
|
||
|
|
||
| We can now do a "General Roll" to land on the proper Partition entry.
|
||
*/
|
||
|
||
while (1) { /* "General Roll" */
|
||
|
||
/*
|
||
| Do a "FindNextTableRow" (rolling) lookup on the hrpartition
|
||
| cache with the current value of the second instance arc.
|
||
|
|
||
| if (an entry was found)
|
||
*/
|
||
if ((part_row = FindNextTableRow(part_tmp_instance, part_cache))
|
||
!= NULL ) {
|
||
|
||
/*
|
||
| Return the current first arc and the index from the returned
|
||
| entry as the second instance arc and signal NOERROR.
|
||
*/
|
||
instance->ids[ 0 ] = dev_tmp_instance ;
|
||
instance->ids[ 1 ] = part_row->index;
|
||
instance->idLength = 2 ;
|
||
|
||
return SNMP_ERRORSTATUS_NOERROR ;
|
||
}
|
||
|
||
/*
|
||
| Fell off the end of the current hrPartition cache, must
|
||
| go get another hrPartition cache from the next fixed-disk entry.
|
||
|
|
||
| Perform "RollToNextFixedDisk" processing
|
||
*/
|
||
ret_status =
|
||
RollToNextFixedDisk(&dev_tmp_instance, // hrDiskStorage arc
|
||
&part_tmp_instance, // hrPartition arc
|
||
&dev_row, // row in hrDiskStorage
|
||
&part_cache // hrPartition cache
|
||
);
|
||
|
||
if (ret_status != SNMP_ERRORSTATUS_NOERROR) {
|
||
return ( ret_status ); // (either NOSUCH or GENERR)
|
||
}
|
||
|
||
} /* while */
|
||
|
||
|
||
} /* end of HrPartitionEntryFindNextInstance() */
|
||
|
||
/* RollToNextFixedDisk - Helper Routine for HrPartitionEntryFindNextInstance */
|
||
/* RollToNextFixedDisk - Helper Routine for HrPartitionEntryFindNextInstance */
|
||
/* RollToNextFixedDisk - Helper Routine for HrPartitionEntryFindNextInstance */
|
||
|
||
static UINT
|
||
RollToNextFixedDisk (
|
||
/* Index */
|
||
UINT *dev_tmp_instance, /* ->Device Table Instance Arc ("1st") */
|
||
UINT *part_tmp_instance, /* ->Partition Table Instance Arc ("2nd") */
|
||
CACHEROW **dev_row, /* ->> Entry in hrDevice Table */
|
||
CACHEHEAD **part_cache /* ->> Cache-Header for Partition */
|
||
)
|
||
|
||
/*
|
||
| EXPLICIT INPUTS:
|
||
|
|
||
| "dev_tmp_instance" & "part_tmp_instance" are pointers to the "current"
|
||
| instance arcs for the hrDevice and hrPartition table respectively.
|
||
|
|
||
| Note that "*dev_tmp_instance" is also implicitly the index into the
|
||
| hrDiskStorage table as well.
|
||
|
|
||
| "dev_row" - is a pointer to the pointer to the hrDiskStorage
|
||
| row currently selected by "*dev_tmp_instance". It is the
|
||
| case that "*dev_row" might be null, indicating that no row
|
||
| has been selected yet.
|
||
|
|
||
| "part_cache" is a pointer to the pointer to any selected hrPartition
|
||
| table (ie a cache taken from an hrDevice row for a fixed-disk). If
|
||
| no such partition cache has been selected yet, then "*part_cache" is
|
||
| NULL.
|
||
|
|
||
| IMPLICIT INPUTS:
|
||
|
|
||
| "HrDiskStorage_cache" may be referenced if "*dev_row" is NULL.
|
||
|
|
||
| OUTPUTS:
|
||
|
|
||
| On Success:
|
||
| Function returns SNMP_ERRORSTATUS_NOERROR when the roll to the next
|
||
| Fixed-Disk hrDiskStorage entry has succeeded. New "first" and "second"
|
||
| instance arcs are returned as well as the cache for the hrPartition
|
||
| table that needs to be searched using the "second" arc.
|
||
|
|
||
| On any Failure:
|
||
| Function returns SNMP_ERRORSTATUS_GENERR if it bumps into what it
|
||
| thinks should be a Fixed-Disk entry in hrDevice but the entry does
|
||
| not have an hrPartition table cache as it should.
|
||
|
|
||
| Function returns SNMP_ERRORSTATUS_NOSUCHNAME if it can't find another
|
||
| hrDevice entry for a Fixed-Disk.
|
||
|
|
||
| THE BIG PICTURE:
|
||
|
|
||
| This function takes care of the details of "rolling" to the next
|
||
| Fixed-Disk entry in hrDevice (& HrDiskStorage) on behalf of
|
||
| "HrPartitionEntryFindNextInstance()".
|
||
|
|
||
| OTHER THINGS TO KNOW:
|
||
|
|
||
| Because we rolling at the device "level", we reset the "instance"
|
||
| arc for the partition level back to zero so that a FindNextTableRow
|
||
| using zero will select the first entry in the selected hrPartition
|
||
| Table (cache) being returned by this function.
|
||
*/
|
||
{
|
||
CACHEROW *hrDevice_row; /* Looked-up row in hrDevice table */
|
||
|
||
|
||
/* Reset the second instance arc to "0" */
|
||
*part_tmp_instance = 0;
|
||
|
||
while (1) { /* Forever . . . */
|
||
|
||
/*
|
||
| Try to get the "next" hrDiskStorage row
|
||
| given our pointer to the current row.
|
||
|
|
||
| If no "current" row, start with the first in hrDiskStorage
|
||
| and riffle upward until we get the row "after" the row that
|
||
| the current device instance arc would have selected.
|
||
*/
|
||
|
||
/* if (there is no current hrDiskStorage row) */
|
||
if (*dev_row == NULL) {
|
||
|
||
/* If the cache is empty . . . */
|
||
if ( (*dev_row =
|
||
FindNextTableRow(*dev_tmp_instance, &hrDiskStorage_cache))
|
||
== NULL) {
|
||
return SNMP_ERRORSTATUS_NOSUCHNAME;
|
||
}
|
||
}
|
||
else {
|
||
|
||
/*
|
||
| Perform "GetNextTableRow" on current hrdiskstorage entry
|
||
|
|
||
| if (processing returned no-next-entry)
|
||
*/
|
||
if ( (*dev_row = GetNextTableRow((*dev_row))) == NULL) {
|
||
return SNMP_ERRORSTATUS_NOSUCHNAME;
|
||
}
|
||
}
|
||
|
||
/*
|
||
| Ok, we've got a "next" row in hrDiskStorage. If it isn't for a fixed
|
||
| disk, we've got to go around again in hopes of finding one that is.
|
||
*/
|
||
|
||
/* if (entry is not for Fixed-Disk (skip Removables)) */
|
||
if ( (*dev_row)->attrib_list[HRDS_REMOVABLE].u.unumber_value == TRUE) {
|
||
continue; /* Skippity doo-dah */
|
||
}
|
||
|
||
/*
|
||
| Set current first instance arc value to index of current entry:
|
||
| it is the "next" row following the row for which the original
|
||
| device instance arc selected.
|
||
*/
|
||
*dev_tmp_instance = (*dev_row)->index;
|
||
|
||
/*
|
||
| Ok, now we've got to go over to the big hrDevice table and hope to
|
||
| find the corresponding hrDevice row given the row index we're on in
|
||
| hrDiskStorage. As this is coded, I realize that we could have put
|
||
| the HIDDEN_CTX attribute in the hrDiskStorage entry rather than
|
||
| the hrDevice entry and saved this lookup, but it matters little.
|
||
*/
|
||
|
||
/*
|
||
| Do "FindTableRow" on hrdevice cache using first instance arc
|
||
|
|
||
| if (no hrdevice entry was found) */
|
||
if ( (hrDevice_row = FindTableRow(*dev_tmp_instance, &hrDevice_cache))
|
||
== NULL) {
|
||
/*
|
||
| There should be an hrDevice table entry for every entry in
|
||
| hrDiskStorage. This seems not to be the case for some reason.
|
||
*/
|
||
return SNMP_ERRORSTATUS_GENERR ;
|
||
}
|
||
|
||
/* If (the hrdevice entry DOES NOT have a cache associated with it) */
|
||
if ( (hrDevice_row->attrib_list[HIDDEN_CTX].attrib_type != CA_CACHE) ||
|
||
(hrDevice_row->attrib_list[HIDDEN_CTX].u.cache == NULL) ) {
|
||
/*
|
||
| There should be a cache in the HIDDEN_CTX attribute for all fixed
|
||
| disks.
|
||
*/
|
||
return SNMP_ERRORSTATUS_GENERR ;
|
||
}
|
||
|
||
/*
|
||
| Select and return the cache from the hrDevice fixed-disk row entry as
|
||
| the HrPartition table cache to be searched on return.
|
||
*/
|
||
*part_cache = hrDevice_row->attrib_list[HIDDEN_CTX].u.cache;
|
||
|
||
return SNMP_ERRORSTATUS_NOERROR;
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* HrPartitionEntryConvertInstance
|
||
*
|
||
* This routine is used to convert the object id specification of an
|
||
* instance into an ordered native representation. The object id format
|
||
* is that object identifier that is returned from the Find Instance
|
||
* or Find Next Instance routines. It is NOT the full object identifier
|
||
* that contains the group and variable object ids as well. The native
|
||
* representation is an argc/argv-like structure that contains the
|
||
* ordered variables that define the instance. This is specified by
|
||
* the MIB's INDEX clause. See RFC 1212 for information about the INDEX
|
||
* clause.
|
||
*
|
||
*
|
||
* Arguments:
|
||
*
|
||
* oid_spec Address of the object id instance specification
|
||
* native_spec Address to return the ordered native instance
|
||
* specification
|
||
*
|
||
* Return Codes:
|
||
*
|
||
* SUCCESS Conversion complete successfully
|
||
* FAILURE Unable to convert object id into native format
|
||
*
|
||
*/
|
||
|
||
UINT
|
||
HrPartitionEntryConvertInstance( IN ObjectIdentifier *oid_spec ,
|
||
IN OUT InstanceName *native_spec )
|
||
{
|
||
static char *array[2];/* The address of this (char *) is passed back */
|
||
/* as an array of pointers to instance arc numbers */
|
||
|
||
static ULONG inst1, /* The addresses of these ULONGs are passed back */
|
||
inst2; /* (Obviously, no "free()" action is needed) */
|
||
|
||
/* We expect the two arcs in "oid_spec" */
|
||
inst1 = oid_spec->ids[0];
|
||
array[0] = (char *) &inst1;
|
||
|
||
inst2 = oid_spec->ids[1];
|
||
array[1] = (char *) &inst2;
|
||
|
||
native_spec->count = 2;
|
||
native_spec->array = array;
|
||
|
||
return SUCCESS ;
|
||
|
||
} /* end of HrPartitionEntryConvertInstance() */
|
||
|
||
|
||
|
||
|
||
/*
|
||
* HrPartitionEntryFreeInstance
|
||
*
|
||
* This routine is used to free an ordered native representation of an
|
||
* instance name.
|
||
*
|
||
* Arguments:
|
||
*
|
||
* instance Address to return the ordered native instance
|
||
* specification
|
||
*
|
||
* Return Codes:
|
||
*
|
||
*
|
||
*/
|
||
|
||
void
|
||
HrPartitionEntryFreeInstance( IN OUT InstanceName *instance )
|
||
{
|
||
|
||
//
|
||
// Developer supplied code to free native representation of instance name goes here.
|
||
//
|
||
|
||
} /* end of HrPartitionEntryFreeInstance() */
|