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