| /* |
| * Host Resources MIB - Device group implementation - hr_device.c |
| * |
| */ |
| /* Portions of this file are subject to the following copyright(s). See |
| * the Net-SNMP's COPYING file for more details and other copyrights |
| * that may apply: |
| */ |
| /* |
| * Portions of this file are copyrighted by: |
| * Copyright © 2003 Sun Microsystems, Inc. All rights reserved. |
| * Use is subject to license terms specified in the COPYING file |
| * distributed with the Net-SNMP package. |
| */ |
| |
| #include <net-snmp/net-snmp-config.h> |
| #if HAVE_STRING_H |
| #include <string.h> |
| #else |
| #include <strings.h> |
| #endif |
| |
| #include "host_res.h" |
| #include "hr_device.h" |
| |
| /********************* |
| * |
| * Kernel & interface information, |
| * and internal forward declarations |
| * |
| *********************/ |
| |
| int Get_Next_Device(void); |
| |
| PFV init_device[HRDEV_TYPE_MAX]; |
| PFIV next_device[HRDEV_TYPE_MAX]; |
| PFV save_device[HRDEV_TYPE_MAX]; |
| int dev_idx_inc[HRDEV_TYPE_MAX]; |
| |
| PFS device_descr[HRDEV_TYPE_MAX]; |
| PFO device_prodid[HRDEV_TYPE_MAX]; |
| PFI device_status[HRDEV_TYPE_MAX]; |
| PFI device_errors[HRDEV_TYPE_MAX]; |
| |
| int current_type; |
| |
| void Init_Device(void); |
| int header_hrdevice(struct variable *, oid *, size_t *, int, |
| size_t *, WriteMethod **); |
| |
| |
| /********************* |
| * |
| * Initialisation & common implementation functions |
| * |
| *********************/ |
| |
| #define HRDEV_INDEX 1 |
| #define HRDEV_TYPE 2 |
| #define HRDEV_DESCR 3 |
| #define HRDEV_ID 4 |
| #define HRDEV_STATUS 5 |
| #define HRDEV_ERRORS 6 |
| |
| struct variable4 hrdevice_variables[] = { |
| {HRDEV_INDEX, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, |
| var_hrdevice, 2, {1, 1}}, |
| {HRDEV_TYPE, ASN_OBJECT_ID, NETSNMP_OLDAPI_RONLY, |
| var_hrdevice, 2, {1, 2}}, |
| {HRDEV_DESCR, ASN_OCTET_STR, NETSNMP_OLDAPI_RONLY, |
| var_hrdevice, 2, {1, 3}}, |
| {HRDEV_ID, ASN_OBJECT_ID, NETSNMP_OLDAPI_RONLY, |
| var_hrdevice, 2, {1, 4}}, |
| {HRDEV_STATUS, ASN_INTEGER, NETSNMP_OLDAPI_RONLY, |
| var_hrdevice, 2, {1, 5}}, |
| {HRDEV_ERRORS, ASN_COUNTER, NETSNMP_OLDAPI_RONLY, |
| var_hrdevice, 2, {1, 6}} |
| }; |
| oid hrdevice_variables_oid[] = { 1, 3, 6, 1, 2, 1, 25, 3, 2 }; |
| |
| |
| void |
| init_hr_device(void) |
| { |
| int i; |
| |
| /* |
| * Initially assume no devices |
| * Insert pointers to initialisation/get_next routines |
| * for particular device types as they are implemented |
| * (set up in the appropriate 'init_*()' routine ) |
| */ |
| |
| for (i = 0; i < HRDEV_TYPE_MAX; ++i) { |
| init_device[i] = NULL; |
| next_device[i] = NULL; |
| save_device[i] = NULL; |
| dev_idx_inc[i] = 0; /* Assume random indices */ |
| |
| device_descr[i] = NULL; |
| device_prodid[i] = NULL; |
| device_status[i] = NULL; |
| device_errors[i] = NULL; |
| } |
| |
| REGISTER_MIB("host/hr_device", hrdevice_variables, variable4, |
| hrdevice_variables_oid); |
| } |
| |
| |
| /* |
| * header_hrdevice(... |
| * Arguments: |
| * vp IN - pointer to variable entry that points here |
| * name IN/OUT - IN/name requested, OUT/name found |
| * length IN/OUT - length of IN/OUT oid's |
| * exact IN - TRUE if an exact match was requested |
| * var_len OUT - length of variable or 0 if function returned |
| * write_method |
| * |
| */ |
| |
| int |
| header_hrdevice(struct variable *vp, |
| oid * name, |
| size_t * length, |
| int exact, size_t * var_len, WriteMethod ** write_method) |
| { |
| #define HRDEV_ENTRY_NAME_LENGTH 11 |
| oid newname[MAX_OID_LEN]; |
| int dev_idx, LowIndex = -1, LowType = -1; |
| int result; |
| |
| DEBUGMSGTL(("host/hr_device", "var_hrdevice: ")); |
| DEBUGMSGOID(("host/hr_device", name, *length)); |
| DEBUGMSG(("host/hr_device", " %d\n", exact)); |
| |
| memcpy((char *) newname, (char *) vp->name, |
| (int) vp->namelen * sizeof(oid)); |
| |
| |
| /* |
| * Find the "next" device entry. |
| * If we're in the middle of the table, then there's |
| * no point in examining earlier types of devices, |
| * so set the starting type to that of the variable |
| * being queried. |
| * If we've moved from one column of the table to another, |
| * then we need to start at the beginning again. |
| * (i.e. the 'compare' fails to match) |
| * Similarly if we're at the start of the table |
| * (i.e. *length is too short to be a full instance) |
| */ |
| |
| if ((snmp_oid_compare(vp->name, vp->namelen, name, vp->namelen) == 0) |
| && (*length > HRDEV_ENTRY_NAME_LENGTH)) |
| current_type = (name[HRDEV_ENTRY_NAME_LENGTH] >> HRDEV_TYPE_SHIFT); |
| else |
| current_type = 0; |
| |
| Init_Device(); |
| for (;;) { |
| dev_idx = Get_Next_Device(); |
| DEBUGMSG(("host/hr_device", "(index %d ....", dev_idx)); |
| if (dev_idx == -1) |
| break; |
| if (LowType != -1 && LowType < (dev_idx >> HRDEV_TYPE_SHIFT)) |
| break; |
| newname[HRDEV_ENTRY_NAME_LENGTH] = dev_idx; |
| DEBUGMSGOID(("host/hr_device", newname, *length)); |
| DEBUGMSG(("host/hr_device", "\n")); |
| result = snmp_oid_compare(name, *length, newname, vp->namelen + 1); |
| if (exact && (result == 0)) { |
| if (save_device[current_type] != NULL) |
| (*save_device[current_type]) (); |
| LowIndex = dev_idx; |
| break; |
| } |
| if ((!exact && (result < 0)) && |
| (LowIndex == -1 || dev_idx < LowIndex)) { |
| if (save_device[current_type] != NULL) |
| (*save_device[current_type]) (); |
| LowIndex = dev_idx; |
| LowType = (dev_idx >> HRDEV_TYPE_SHIFT); |
| if (dev_idx_inc[LowType]) /* Increasing indices => now done */ |
| break; |
| } |
| |
| } |
| |
| if (LowIndex == -1) { |
| DEBUGMSGTL(("host/hr_device", "... index out of range\n")); |
| return (MATCH_FAILED); |
| } |
| |
| newname[HRDEV_ENTRY_NAME_LENGTH] = LowIndex; |
| memcpy((char *) name, (char *) newname, |
| ((int) vp->namelen + 1) * sizeof(oid)); |
| *length = vp->namelen + 1; |
| *write_method = (WriteMethod*)0; |
| *var_len = sizeof(long); /* default to 'long' results */ |
| |
| DEBUGMSGTL(("host/hr_device", "... get device stats ")); |
| DEBUGMSGOID(("host/hr_device", name, *length)); |
| DEBUGMSG(("host/hr_device", "\n")); |
| |
| return LowIndex; |
| } |
| |
| |
| oid device_type_id[] = { 1, 3, 6, 1, 2, 1, 25, 3, 1, 99 }; /* hrDeviceType99 */ |
| int device_type_len = |
| sizeof(device_type_id) / sizeof(device_type_id[0]); |
| |
| |
| /********************* |
| * |
| * System specific implementation functions |
| * |
| *********************/ |
| |
| |
| u_char * |
| var_hrdevice(struct variable *vp, |
| oid * name, |
| size_t * length, |
| int exact, size_t * var_len, WriteMethod ** write_method) |
| { |
| int dev_idx, type; |
| oid *oid_p; |
| const char *tmp_str; |
| static char string[1024]; |
| |
| really_try_next: |
| dev_idx = |
| header_hrdevice(vp, name, length, exact, var_len, write_method); |
| if (dev_idx == MATCH_FAILED) |
| return NULL; |
| |
| type = (dev_idx >> HRDEV_TYPE_SHIFT); |
| |
| switch (vp->magic) { |
| case HRDEV_INDEX: |
| long_return = dev_idx; |
| return (u_char *) & long_return; |
| case HRDEV_TYPE: |
| device_type_id[device_type_len - 1] = type; |
| *var_len = sizeof(device_type_id); |
| return (u_char *) device_type_id; |
| case HRDEV_DESCR: |
| if ((device_descr[type] != NULL) && |
| (NULL!=(tmp_str=((*device_descr[type])(dev_idx))))) { |
| strlcpy(string, tmp_str, sizeof(string)); |
| } else |
| #if NETSNMP_NO_DUMMY_VALUES |
| goto try_next; |
| #else |
| sprintf(string, "a black box of some sort"); |
| #endif |
| *var_len = strlen(string); |
| return (u_char *) string; |
| case HRDEV_ID: |
| if (device_prodid[type] != NULL) |
| oid_p = ((*device_prodid[type]) (dev_idx, var_len)); |
| else { |
| oid_p = nullOid; |
| *var_len = nullOidLen; |
| } |
| return (u_char *) oid_p; |
| case HRDEV_STATUS: |
| if (device_status[type] != NULL) |
| long_return = ((*device_status[type]) (dev_idx)); |
| else |
| #if NETSNMP_NO_DUMMY_VALUES |
| goto try_next; |
| #else |
| long_return = 2; /* Assume running */ |
| #endif |
| if ( !long_return ) |
| goto try_next; |
| return (u_char *) & long_return; |
| case HRDEV_ERRORS: |
| if (device_errors[type] != NULL) |
| long_return = (*device_errors[type]) (dev_idx); |
| else |
| #if NETSNMP_NO_DUMMY_VALUES |
| goto try_next; |
| #else |
| long_return = 0; /* Assume OK */ |
| #endif |
| return (u_char *) & long_return; |
| default: |
| DEBUGMSGTL(("snmpd", "unknown sub-id %d in var_hrdevice\n", |
| vp->magic)); |
| } |
| |
| try_next: |
| if (!exact) |
| goto really_try_next; |
| |
| return NULL; |
| } |
| |
| |
| /********************* |
| * |
| * Internal implementation functions |
| * |
| *********************/ |
| |
| |
| void |
| Init_Device(void) |
| { |
| /* |
| * Find the first non-NULL initialisation function |
| * and call it |
| */ |
| while (current_type < HRDEV_TYPE_MAX && |
| init_device[current_type] == NULL) |
| if (++current_type >= HRDEV_TYPE_MAX) |
| return; |
| /* Check current_type, if >= MAX first time into loop, would fail below */ |
| if (current_type < HRDEV_TYPE_MAX) |
| (*init_device[current_type]) (); |
| } |
| |
| int |
| Get_Next_Device(void) |
| { |
| int result = -1; |
| |
| /* |
| * Call the 'next device' function for the current |
| * type of device |
| * |
| * TODO: save the necessary information about that device |
| */ |
| if (current_type < HRDEV_TYPE_MAX && next_device[current_type] != NULL) |
| result = (*next_device[current_type]) (); |
| |
| /* |
| * No more devices of the current type. |
| * Try the next type (if any) |
| */ |
| if (result == -1) { |
| if (++current_type >= HRDEV_TYPE_MAX) { |
| current_type = 0; |
| return -1; |
| } |
| Init_Device(); |
| return Get_Next_Device(); |
| } |
| return result; |
| } |
