diff -r c3302cbcf163 -r 6eb7b62e444c oi-extras/net-snmp/sun/agent/modules/entityMib/entAliasMappingTable.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/oi-extras/net-snmp/sun/agent/modules/entityMib/entAliasMappingTable.c Wed Jun 22 00:51:55 2011 +0100 @@ -0,0 +1,617 @@ +/* + * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. + * + * U.S. Government Rights - Commercial software. Government users are subject + * to the Sun Microsystems, Inc. standard license agreement and applicable + * provisions of the FAR and its supplements. + * + * + * This distribution may include materials developed by third parties. Sun, + * Sun Microsystems, the Sun logo and Solaris are trademarks or registered + * trademarks of Sun Microsystems, Inc. in the U.S. and other countries. + * + */ +/* + * Note: this file originally auto-generated by mib2c using + * : mib2c.iterate.conf,v 5.5 2002/12/16 22:50:18 hardaker Exp $ + */ + +#include +#include +#include +#include "stdhdr.h" +#include "entAliasMappingTable.h" +#include "entLogicalTable.h" +#include "entPhysicalTable.h" +#include "entLastChangeTime.h" + +entAliasMappingTableEntry_t *gAliasMappingTableHead; +int gAliasMappingTableSize; +static logicalAlias *gCurAliasEntry; + + + +/** Initialize the entAliasMappingTable table by defining its contents and how it's structured */ +void +initialize_table_entAliasMappingTable(void) +{ + static oid entAliasMappingTable_oid[] = {1,3,6,1,2,1,47,1,3,2}; + netsnmp_table_registration_info *table_info; + netsnmp_handler_registration *my_handler; + netsnmp_iterator_info *iinfo; + + /* create the table structure itself */ + table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info); + iinfo = SNMP_MALLOC_TYPEDEF(netsnmp_iterator_info); + + /* if your table is read only, it's easiest to change the + HANDLER_CAN_RWRITE definition below to HANDLER_CAN_RONLY */ + /* Fix for 4910624 - changing HANDLER_CAN_RWRITE to HANDLER_CAN_RONLY */ + my_handler = netsnmp_create_handler_registration("entAliasMappingTable", + entAliasMappingTable_handler, + entAliasMappingTable_oid, + OID_LENGTH(entAliasMappingTable_oid), + HANDLER_CAN_RONLY); + /* End of Fix for 4910624 */ + + if (!my_handler || !table_info || !iinfo) + return; /* mallocs failed */ + + /*************************************************** + * Setting up the table's definition + */ + netsnmp_table_helper_add_indexes(table_info, + ASN_INTEGER, /* index: entPhysicalIndex */ + ASN_INTEGER, /* index: entAliasLogicalIndexOrZero */ + 0); + + table_info->min_column = 2; + table_info->max_column = 2; + + /* iterator access routines */ + iinfo->get_first_data_point = entAliasMappingTable_get_first_data_point; + iinfo->get_next_data_point = entAliasMappingTable_get_next_data_point; + + iinfo->table_reginfo = table_info; + + /*************************************************** + * registering the table with the master agent + */ + DEBUGMSGTL(("initialize_table_entAliasMappingTable", + "Registering table entAliasMappingTable as a table iterator\n")); + netsnmp_register_table_iterator(my_handler, iinfo); +} + +/** Initializes the entAliasMappingTable module */ +void +init_entAliasMappingTable(void) +{ + + /* here we initialize all the tables we're planning on supporting */ + initialize_table_entAliasMappingTable(); + gAliasMappingTableSize = 0; + gAliasMappingTableHead = NULL; + gCurAliasEntry = NULL; +} + +/** returns the first data point within the entAliasMappingTable table data. + + Set the my_loop_context variable to the first data point structure + of your choice (from which you can find the next one). This could + be anything from the first node in a linked list, to an integer + pointer containing the beginning of an array variable. + + Set the my_data_context variable to something to be returned to + you later that will provide you with the data to return in a given + row. This could be the same pointer as what my_loop_context is + set to, or something different. + + The put_index_data variable contains a list of snmp variable + bindings, one for each index in your table. Set the values of + each appropriately according to the data matching the first row + and return the put_index_data variable at the end of the function. +*/ +netsnmp_variable_list * +entAliasMappingTable_get_first_data_point(void **my_loop_context, void **my_data_context, + netsnmp_variable_list *put_index_data, + netsnmp_iterator_info *mydata) +{ + + netsnmp_variable_list *vptr; + entAliasMappingTableEntry_t *zRunner, *zpValidEntry; + logicalAlias *zlogicalAliases, *zValidAlias; + int bFound=0; + + zRunner = gAliasMappingTableHead; + zpValidEntry = NULL; + gCurAliasEntry = NULL; + while (zRunner) { + if (zRunner->entPhysicalIndex > 0) { + zlogicalAliases = zRunner->entlogicalAliases; + while ((zlogicalAliases != NULL) && + (zlogicalAliases->entAliasMapIdSize >= 0)){ + if (zlogicalAliases->entAliasLogicalIndexorZero >= 0) { + bFound = 1; + break; + } + zlogicalAliases++; + } + if (bFound) { + zpValidEntry = zRunner; + zValidAlias = zlogicalAliases; + break; + } + } + zRunner = zRunner->pNextEntry; + } + if (zRunner == NULL) return NULL; + + *my_loop_context = (void *) zpValidEntry; + *my_data_context = (void *) zValidAlias; + gCurAliasEntry = zValidAlias; + + vptr = put_index_data; + + snmp_set_var_value(vptr, (u_char *) &zpValidEntry->entPhysicalIndex, sizeof(zpValidEntry->entPhysicalIndex)); + vptr = vptr->next_variable; + snmp_set_var_value(vptr, (u_char *) &zValidAlias->entAliasLogicalIndexorZero, sizeof(zValidAlias->entAliasLogicalIndexorZero)); + vptr = vptr->next_variable; + + return put_index_data; +} + +/** functionally the same as entAliasMappingTable_get_first_data_point, but + my_loop_context has already been set to a previous value and should + be updated to the next in the list. For example, if it was a + linked list, you might want to cast it and the return + my_loop_context->next. The my_data_context pointer should be set + to something you need later and the indexes in put_index_data + updated again. */ + +netsnmp_variable_list * +entAliasMappingTable_get_next_data_point(void **my_loop_context, void **my_data_context, + netsnmp_variable_list *put_index_data, + netsnmp_iterator_info *mydata) +{ + + netsnmp_variable_list *vptr; + entAliasMappingTableEntry_t *zRunner, *zpValidEntry; + logicalAlias *zlogicalAliases, *zValidAlias; + int bFound=0; + + zRunner = (entAliasMappingTableEntry_t *)*my_loop_context; + zlogicalAliases = (logicalAlias *) *my_data_context; + zlogicalAliases = gCurAliasEntry; + + if (zlogicalAliases != NULL) + zlogicalAliases++; + + while (zRunner) { + if (zRunner->entPhysicalIndex > 0) { + while ((zlogicalAliases != NULL) && + (zlogicalAliases->entAliasMapIdSize >= 0)){ + if (zlogicalAliases->entAliasLogicalIndexorZero >= 0) { + bFound = 1; + break; + } + zlogicalAliases++; + } + if (bFound) { + zpValidEntry = zRunner; + zValidAlias = zlogicalAliases; + break; + } + } + zRunner = zRunner->pNextEntry; + if (zRunner) + zlogicalAliases = zRunner->entlogicalAliases; + } + if (zRunner == NULL) return NULL; + + *my_loop_context = (void *) zpValidEntry; + *my_data_context = (void *) zValidAlias; + gCurAliasEntry = zValidAlias; + + vptr = put_index_data; + + snmp_set_var_value(vptr, (u_char *) &zpValidEntry->entPhysicalIndex, sizeof(zpValidEntry->entPhysicalIndex)); + vptr = vptr->next_variable; + snmp_set_var_value(vptr, (u_char *) &zValidAlias->entAliasLogicalIndexorZero, sizeof(zValidAlias->entAliasLogicalIndexorZero)); + vptr = vptr->next_variable; + + return put_index_data; +} + +/** handles requests for the entAliasMappingTable table, if anything else needs to be done */ +int +entAliasMappingTable_handler( + netsnmp_mib_handler *handler, + netsnmp_handler_registration *reginfo, + netsnmp_agent_request_info *reqinfo, + netsnmp_request_info *requests) { + + netsnmp_request_info *request; + netsnmp_table_request_info *table_info; + netsnmp_variable_list *var; + logicalAlias *zAliasEntry; + + for(request = requests; request; request = request->next) { + var = request->requestvb; + if (request->processed != 0) + continue; + + /* perform anything here that you need to do before each + request is processed. */ + + /* the following extracts the my_data_context pointer set in + the loop functions above. You can then use the results to + help return data for the columns of the entAliasMappingTable table in question */ + zAliasEntry = (logicalAlias *) netsnmp_extract_iterator_context(request); + if (zAliasEntry == NULL) { + if (reqinfo->mode == MODE_GET) { + netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHINSTANCE); + continue; + } + /* XXX: no row existed, if you support creation and this is a + set, start dealing with it here, else continue */ + } + + /* extracts the information about the table from the request */ + table_info = netsnmp_extract_table_info(request); + /* table_info->colnum contains the column number requested */ + /* table_info->indexes contains a linked list of snmp variable + bindings for the indexes of the table. Values in the list + have been set corresponding to the indexes of the + request */ + if (table_info==NULL) { + continue; + } + + switch(reqinfo->mode) { + /* the table_iterator helper should change all GETNEXTs + into GETs for you automatically, so you don't have to + worry about the GETNEXT case. Only GETs and SETs need + to be dealt with here */ + case MODE_GET: + switch(table_info->colnum) { + case COLUMN_ENTALIASMAPPINGIDENTIFIER: + snmp_set_var_typed_value(var, ASN_OBJECT_ID, (u_char *) zAliasEntry->entAliasMapId, zAliasEntry->entAliasMapIdSize); + break; + + default: + /* We shouldn't get here */ + snmp_log(LOG_ERR, "problem encountered in entAliasMappingTable_handler: unknown column\n"); + } + break; + + case MODE_SET_RESERVE1: + /* set handling... */ + + default: + snmp_log(LOG_ERR, "problem encountered in entAliasMappingTable_handler: unsupported mode\n"); + } + } + return SNMP_ERR_NOERROR; +} + +/* Add an entry into the Alias Mapping Table + returns 0 for success + 1 for entry already exist + -1 for failure + -2 for stale index +*/ + +int +addAliasMappingTableEntry(int xentPhysicalIndex, int xentLogicalIndex, + oid *xAliasMapId, int xAliasMapIdSize) +{ + entAliasMappingTableEntry_t *zAliasTableEntry, *zRunner, *zlastEntry; + entPhysicalEntry_t *physentry; + entLogicalEntry_t *zLogicalEntry; + logicalAlias *zLogicalAliases; + + /* Fix for 4927412: Rejects NULL xAliasMapId */ + if (xAliasMapId == NULL) + return -1; + /* End of Fix for 4927412 */ + + /* Fix for 4888088: logical index cannot be smaller than zero, */ + /* and physical index cannot be smaller than */ + /* or equal to zero. -2 for stale entries */ + if (xentPhysicalIndex <= 0 || xentPhysicalIndex > MAX_ENTITY_INDEX || xentLogicalIndex < 0 || xentLogicalIndex > MAX_ENTITY_INDEX) + return -1; + physentry = getPhysicalTableStaleEntry(xentPhysicalIndex); + if (physentry != NULL) + return -2; + + zLogicalEntry = getLogicalTableStaleEntry(xentLogicalIndex); + if (zLogicalEntry != NULL) + return -2; + /* End of Fix for 4888088 */ + + physentry = getPhysicalTableEntry(xentPhysicalIndex); + + if (physentry != NULL) { + if (physentry->entPhysicalClass != 10) return (-1); + } else return (-1); + + if (xentLogicalIndex != 0) { + zLogicalEntry = getLogicalTableEntry(xentLogicalIndex); + if (zLogicalEntry == NULL) return (-1); + } + if (xAliasMapId == NULL) return (-1); + + zlastEntry = NULL; + zRunner = gAliasMappingTableHead; + while (zRunner != NULL) { + if (zRunner->entPhysicalIndex == xentPhysicalIndex) { + break; + } + zlastEntry = zRunner; + zRunner = zRunner->pNextEntry; + } + if (zRunner != NULL ) {/* Found a entry with physical index */ + logicalAlias *p; + p = zRunner->entlogicalAliases; + if (p == NULL) { + zLogicalAliases = (logicalAlias *) malloc(2 * sizeof (logicalAlias)); + if (!zLogicalAliases) return -1; + zLogicalAliases[0].entAliasLogicalIndexorZero = xentLogicalIndex; + zLogicalAliases[0].entAliasMapId = malloc(xAliasMapIdSize); + if (!zLogicalAliases[0].entAliasMapId) return -1; + memcpy(zLogicalAliases[0].entAliasMapId, xAliasMapId, + xAliasMapIdSize); + zLogicalAliases[0].entAliasMapIdSize = xAliasMapIdSize; + zLogicalAliases[1].entAliasLogicalIndexorZero = 0; + zLogicalAliases[1].entAliasMapId = NULL; + zLogicalAliases[1].entAliasMapIdSize = -1; + zRunner->entlogicalAliases = zLogicalAliases; + } else {/* Add phy index to last entry in the array */ + int i=0; + while (p != NULL && p->entAliasMapIdSize >= 0) { + if (p->entAliasLogicalIndexorZero == xentLogicalIndex) return (1); + if (p->entAliasMapIdSize < 0 ) { + p->entAliasLogicalIndexorZero = xentLogicalIndex; + p->entAliasMapId = malloc(xAliasMapIdSize); + if (!p->entAliasMapId) return -1; + memcpy(p->entAliasMapId, xAliasMapId, xAliasMapIdSize); + p->entAliasMapIdSize = xAliasMapIdSize; + } + p++; + i++; + } + zRunner->entlogicalAliases = + (logicalAlias *)realloc(zRunner->entlogicalAliases, (i + 2)*sizeof(logicalAlias)); + zRunner->entlogicalAliases[i].entAliasLogicalIndexorZero = + xentLogicalIndex; + zRunner->entlogicalAliases[i].entAliasMapId = + malloc(xAliasMapIdSize); + if (!zRunner->entlogicalAliases[i].entAliasMapId) return -1; + memcpy(zRunner->entlogicalAliases[i].entAliasMapId, xAliasMapId, + xAliasMapIdSize); + zRunner->entlogicalAliases[i].entAliasMapIdSize = xAliasMapIdSize; + zRunner->entlogicalAliases[i+1].entAliasLogicalIndexorZero = 0; + zRunner->entlogicalAliases[i+1].entAliasMapId = NULL; + zRunner->entlogicalAliases[i+1].entAliasMapIdSize = -1; + } + configChanged(); + return (0); + } + + /* New entry*/ + zAliasTableEntry = (entAliasMappingTableEntry_t *)malloc(sizeof(entAliasMappingTableEntry_t)); + if (!zAliasTableEntry) return -1; + zAliasTableEntry->entPhysicalIndex = xentPhysicalIndex; + zLogicalAliases = (logicalAlias *) malloc(2 * sizeof (logicalAlias)); + if (!zLogicalAliases) return -1; + zLogicalAliases[0].entAliasLogicalIndexorZero = xentLogicalIndex; + zLogicalAliases[0].entAliasMapId = malloc(xAliasMapIdSize); + if (!zLogicalAliases[0].entAliasMapId) return -1; + memcpy(zLogicalAliases[0].entAliasMapId, xAliasMapId, + xAliasMapIdSize); + zLogicalAliases[0].entAliasMapIdSize = xAliasMapIdSize; + zLogicalAliases[1].entAliasLogicalIndexorZero = 0; + zLogicalAliases[1].entAliasMapId = NULL; + zLogicalAliases[1].entAliasMapIdSize = -1; + zAliasTableEntry->entlogicalAliases = zLogicalAliases; + zAliasTableEntry->pNextEntry = NULL; + if (gAliasMappingTableHead){ + zlastEntry->pNextEntry = zAliasTableEntry; + } else { + gAliasMappingTableHead = zAliasTableEntry; + } + gAliasMappingTableSize++; + configChanged(); + return (0); +} + +/* Returns 0 for successful deletion + -1 for entry not found + -2 for stale entry +*/ +int +deleteAliasMappingTableEntry(int xentPhysicalIndex, int xentLogicalIndex) +{ + entAliasMappingTableEntry_t *zRunner; + logicalAlias *zLogicalAliases; + int zPhyIndx; + entPhysicalEntry_t *zPhysicalEntry; + entLogicalEntry_t *zLogicalEntry; + + /* Fix for 4888088: logical index cannot be smaller than zero, */ + /* and physical index cannot be smaller than */ + /* or equal to zero. -2 for stale entries */ + if (xentPhysicalIndex <= 0 || xentPhysicalIndex > MAX_ENTITY_INDEX || xentLogicalIndex < 0 || xentLogicalIndex > MAX_ENTITY_INDEX) + return -1; + zPhysicalEntry = getPhysicalTableStaleEntry(xentPhysicalIndex); + if (zPhysicalEntry != NULL) + return -2; + + zLogicalEntry = getLogicalTableStaleEntry(xentLogicalIndex); + if (zLogicalEntry != NULL) + return -2; + /* End of Fix for 4888088 */ + + zRunner = gAliasMappingTableHead; + + while (zRunner != NULL) { + zPhyIndx = zRunner->entPhysicalIndex; + + if (zPhyIndx > 0) { + if (zPhyIndx == xentPhysicalIndex) { + zLogicalAliases = zRunner->entlogicalAliases; + while (zLogicalAliases != NULL + && zLogicalAliases->entAliasMapIdSize >= 0) { + int zLogIndx = zLogicalAliases->entAliasLogicalIndexorZero; + if (zLogIndx >=0 ) { + if (zLogIndx == xentLogicalIndex) { + zLogicalAliases->entAliasLogicalIndexorZero = -1; + free(zLogicalAliases->entAliasMapId); + zLogicalAliases->entAliasMapId = NULL; + zLogicalAliases->entAliasMapIdSize = 0; + configChanged(); + return (0); + } + } + zLogicalAliases++; + } + return (-1); /* Entry not found */ + } + } + zRunner = zRunner->pNextEntry; + } + return (-1); +} + +static int +FreeAliasMappingTableEntry(entAliasMappingTableEntry_t *xEntry) +{ + logicalAlias *zAliases; + int nEntries=0; + if (xEntry == NULL) return (-1); + zAliases = xEntry->entlogicalAliases; + while (zAliases != NULL && zAliases->entAliasMapIdSize >= 0) { + /* Fix for 4906853: we only need to free it (and count) if */ + /* entAliasMapId != NULL. A better fix is to use a link list */ + /* instead of an array for this structure */ + if (zAliases->entAliasMapId != NULL) { + free(zAliases->entAliasMapId); + nEntries++; + } + /* End of Fix for 4906853 */ + zAliases++; + } + free(xEntry->entlogicalAliases); + free(xEntry); + xEntry = NULL; + return nEntries; +} + +/* Deletes all the entries in the table with primary index as + given physical index + Return number of entries deleted on success, + -1 on failure + -2 for a existing stale entry +*/ + +int +deleteAliasMappingPhysicalIndex(int xentPhysicalIndex) +{ + entAliasMappingTableEntry_t *zRunner, *temp, *prevEntry; + int zPhyIndx, nEntries=0; + entPhysicalEntry_t *zPhysicalEntry; + + /* Fix for 4888088: We do not need the check for 4883511 anymore, */ + /* because entAliasLogicalIndexorZero will never be set */ + /* to negative values. Instead we will check if the */ + /* entries are stale (except when xentLogicalIndex = 0) */ + if (xentPhysicalIndex <= 0 || xentPhysicalIndex > MAX_ENTITY_INDEX) + return -1; + zPhysicalEntry = getPhysicalTableStaleEntry(xentPhysicalIndex); + if (zPhysicalEntry != NULL) + return -2; + /* End of Fix for 4888088 */ + + zRunner = gAliasMappingTableHead; + prevEntry = NULL; + + while (zRunner != NULL) { + zPhyIndx = zRunner->entPhysicalIndex; + + if (zPhyIndx > 0) { + if (zPhyIndx == xentPhysicalIndex) { + temp = zRunner->pNextEntry; + zRunner->pNextEntry = NULL; + if (prevEntry) + prevEntry->pNextEntry = temp; + else + gAliasMappingTableHead = temp; + nEntries = FreeAliasMappingTableEntry(zRunner); + gAliasMappingTableSize--; + configChanged(); + return nEntries; + } + } + prevEntry = zRunner; + zRunner = zRunner->pNextEntry; + } + return (-1); +} + +/* Deletes all entries of the table for a given logical index. + Returns the number if entries deleted + -1 if the entry is not found + -2 if the logical index is stale + The memory allocated is freed when the primary index, physical index + is deleted. +*/ +int +deleteAliasMappingLogicalIndex(int xentLogicalIndex) +{ + entAliasMappingTableEntry_t *zRunner; + logicalAlias *zLogicalAliases; + int zPhyIndx, nFound=0; + entLogicalEntry_t *zLogicalEntry; + + /* Fix for 4888088: Here we are not allowing logical index = 0. We are */ + /* forcing the user to use deleteAliasMappingTableEntry */ + if (xentLogicalIndex <= 0 || xentLogicalIndex > MAX_ENTITY_INDEX) + return -1; + zLogicalEntry = getLogicalTableStaleEntry(xentLogicalIndex); + if (zLogicalEntry != NULL) + return -2; + /* End of Fix for 4888088 */ + + zRunner = gAliasMappingTableHead; + + while (zRunner != NULL) { + zPhyIndx = zRunner->entPhysicalIndex; + if (zPhyIndx > 0) { + zLogicalAliases = zRunner->entlogicalAliases; + while (zLogicalAliases != NULL + && zLogicalAliases->entAliasMapIdSize >= 0) { + int zLogIndx = zLogicalAliases->entAliasLogicalIndexorZero; + if (zLogIndx >= 0 ) { + if (zLogIndx == xentLogicalIndex) { + zLogicalAliases->entAliasLogicalIndexorZero = -1; + free(zLogicalAliases->entAliasMapId); + zLogicalAliases->entAliasMapId = NULL; + zLogicalAliases->entAliasMapIdSize = 0; + nFound++; + break; + } + } + zLogicalAliases++; + } + } + zRunner = zRunner->pNextEntry; + } + /* Fix for 4888088 */ + if (nFound) { + configChanged(); + return (nFound); + } else { + return -1; + } + /* End of Fix for 4888088 */ +}