int delete_hotswap_row (SaHpiDomainIdT domain_id, SaHpiResourceIdT resource_id) { saHpiHotSwapTable_context *ctx; oid hotswap_oid[HOTSWAP_INDEX_NR]; netsnmp_index hotswap_index; int rc = AGENT_ERR_NOT_FOUND; DEBUGMSGTL ((AGENT, "delete_hotswap_row (%d, %d). Entry\n", domain_id, resource_id)); hotswap_oid[0] = domain_id; hotswap_oid[1] = resource_id; // Possible more indexs? hotswap_index.oids = (oid *) & hotswap_oid; hotswap_index.len = HOTSWAP_INDEX_NR; ctx = CONTAINER_FIND (cb.container, &hotswap_index); if (ctx) { CONTAINER_REMOVE (cb.container, ctx); saHpiHotSwapTable_delete_row (ctx); rc = AGENT_ERR_NOERROR; } DEBUGMSGTL ((AGENT, "delete_hotswap_row. Exit (rc: %d).\n", rc)); return rc; }
/** * @internal * commit irreversible actions */ int _mfd_ipv4InterfaceTable_irreversible_commit(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *agtreq_info, netsnmp_request_info *requests) { ipv4InterfaceTable_rowreq_ctx *rowreq_ctx = netsnmp_container_table_row_extract(requests); DEBUGMSGTL(("internal:ipv4InterfaceTable:_mfd_ipv4InterfaceTable_irreversible:commit", "called\n")); netsnmp_assert(NULL != rowreq_ctx); /* * check for and handle row creation/deletion * and update column exist flags... */ if (rowreq_ctx->rowreq_flags & MFD_ROW_DELETED) { CONTAINER_REMOVE(ipv4InterfaceTable_if_ctx.container, rowreq_ctx); } else { if (rowreq_ctx->column_set_flags) { rowreq_ctx->column_set_flags = 0; } } return SNMP_ERR_NOERROR; } /* _mfd_ipv4InterfaceTable_irreversible_commit */
int delete_watchdog_row (SaHpiDomainIdT domain_id, SaHpiResourceIdT resource_id, SaHpiWatchdogNumT num) { saHpiWatchdogTable_context *ctx; oid index_oid[WATCHDOG_INDEX_NR]; netsnmp_index index; int rc = AGENT_ERR_NOT_FOUND; DEBUGMSGTL ((AGENT, "delete_watchdog_row (%d, %d, %d). Entry.\n", domain_id, resource_id, num)); // Look at the MIB to find out what the indexs are index_oid[0] = domain_id; index_oid[1] = resource_id; index_oid[2] = num; // Possible more indexes? index.oids = (oid *) & index_oid; index.len = WATCHDOG_INDEX_NR; ctx = CONTAINER_FIND (cb.container, &index); if (ctx) { CONTAINER_REMOVE (cb.container, ctx); saHpiWatchdogTable_delete_row (ctx); watchdog_count = CONTAINER_SIZE (cb.container); rc = AGENT_ERR_NOERROR; } DEBUGMSGTL ((AGENT, "delete_watchdog_row. Exit (rc: %d).\n", rc)); return rc; }
/* * Removes the row indexed by userIndex and contactIndex, and free's up the * memory allocated to it. If the row could not be found, then nothing is done. */ void deleteContactRow(int userIndex, int contactIndex) { openserSIPContactTable_context *theRow; netsnmp_index indexToRemove; oid indexToRemoveOID[2]; /* Form the OID Index of the row so we can search for it */ indexToRemoveOID[0] = userIndex; indexToRemoveOID[1] = contactIndex; indexToRemove.oids = indexToRemoveOID; indexToRemove.len = 2; theRow = CONTAINER_FIND(cb.container, &indexToRemove); /* The ContactURI is shared memory, the index.oids was allocated from * pkg_malloc(), and theRow was made with the NetSNMP API which uses * malloc() */ if (theRow != NULL) { CONTAINER_REMOVE(cb.container, &indexToRemove); pkg_free(theRow->openserSIPContactURI); pkg_free(theRow->index.oids); free(theRow); } }
/* Removes an SNMP row indexed by userIndex, and frees the string and index it * pointed to. */ void deleteRegUserRow(int userIndex) { openserSIPRegUserTable_context *theRow; netsnmp_index indexToRemove; oid indexToRemoveOID; indexToRemoveOID = userIndex; indexToRemove.oids = &indexToRemoveOID; indexToRemove.len = 1; theRow = CONTAINER_FIND(cb.container, &indexToRemove); /* The userURI is shared memory, the index.oids was allocated from * pkg_malloc(), and theRow was made with the NetSNMP API which uses * malloc() */ if (theRow != NULL) { CONTAINER_REMOVE(cb.container, &indexToRemove); pkg_free(theRow->openserSIPUserUri); pkg_free(theRow->index.oids); free(theRow); } }
int delete_ThdPosHysteresis_row (SaHpiDomainIdT domain_id, SaHpiResourceIdT resource_id, SaHpiSensorNumT sensor_num) { saHpiSensorThdPosHysteresisTable_context *ctx; oid index_oid[SENSOR_THD_INDEX_NR]; netsnmp_index sensor_reading_index; int rc = AGENT_ERR_NOT_FOUND; DEBUGMSGTL ((AGENT, "delete_ThdPosHysteresis_row (%d, %d, %d). Entry.\n", domain_id, resource_id, sensor_num)); // Look at the MIB to find out what the indexs are index_oid[0] = domain_id; index_oid[1] = resource_id; index_oid[2] = sensor_num; // Possible more indexs? sensor_reading_index.oids = (oid *) & index_oid; sensor_reading_index.len = SENSOR_THD_INDEX_NR; ctx = CONTAINER_FIND (cb.container, &sensor_reading_index); if (ctx) { CONTAINER_REMOVE (cb.container, ctx); saHpiSensorThdPosHysteresisTable_delete_row (ctx); rc = AGENT_ERR_NOERROR; } DEBUGMSGTL ((AGENT, "delete_ThdPosHysteresis_row. Exit (rc: %d).\n", rc)); return rc; }
/** * @internal * wrapper */ static int _mfd_dot11ConfTotalTrapGroupTable_post_request(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *agtreq_info, netsnmp_request_info *requests) { dot11ConfTotalTrapGroupTable_rowreq_ctx *rowreq_ctx; int rc = dot11ConfTotalTrapGroupTable_post_request(dot11ConfTotalTrapGroupTable_if_ctx.user_ctx); if (MFD_SUCCESS != rc) { /* * nothing we can do about it but log it */ DEBUGMSGTL(("internal:dot11ConfTotalTrapGroupTable","error %d from " "dot11ConfTotalTrapGroupTable_post_request\n", rc)); } /* * if there are no errors, check for and handle row creation/deletion */ rc = netsnmp_check_requests_error(requests); if ((SNMP_ERR_NOERROR == rc) && (NULL != (rowreq_ctx = netsnmp_container_table_row_extract(requests)))) { if (rowreq_ctx->rowreq_flags & MFD_ROW_CREATED) { rowreq_ctx->rowreq_flags &= ~MFD_ROW_CREATED; CONTAINER_INSERT(dot11ConfTotalTrapGroupTable_if_ctx.container, rowreq_ctx); } else if (rowreq_ctx->rowreq_flags & MFD_ROW_DELETED) { CONTAINER_REMOVE(dot11ConfTotalTrapGroupTable_if_ctx.container, rowreq_ctx); dot11ConfTotalTrapGroupTable_release_rowreq_ctx(rowreq_ctx); } } return SNMP_ERR_NOERROR; } /* _mfd_dot11ConfTotalTrapGroupTable_post_request */
static void _cert_map_remove(certToTSN_entry *entry) { netsnmp_container *maps; netsnmp_cert_map map; if (NULL == entry) return; DEBUGMSGTL(("tlstmCertToTSNTable:map:remove", "pri %ld, fp %s\n", entry->tlstmCertToTSNID, entry->fingerprint)); /** get current active maps */ maps = netsnmp_cert_map_container(); if (NULL == maps) return; map.priority = entry->tlstmCertToTSNID; map.fingerprint = entry->fingerprint; if (CONTAINER_REMOVE(maps, &map) != 0) { snmp_log(LOG_ERR, "could not remove certificate map"); } entry->map_flags = 0; }
/* * Remove all entries from sctpAssocRemAddrTable, which are not marked as valid. * All valid entries are then marked as invalid (to delete them in next cache * load, if the entry is not updated). */ void sctpAssocRemAddrTable_delete_invalid(netsnmp_container *remAddrTable) { netsnmp_container *to_delete = netsnmp_container_find("lifo"); CONTAINER_FOR_EACH(remAddrTable, sctpAssocRemAddrTable_collect_invalid, to_delete); while (CONTAINER_SIZE(to_delete)) { sctpAssocRemAddrTable_entry *entry = CONTAINER_FIRST(to_delete); CONTAINER_REMOVE(remAddrTable, entry); sctpAssocRemAddrTable_entry_free(entry); CONTAINER_REMOVE(to_delete, NULL); } CONTAINER_FREE(to_delete); }
/** * * @sessionid * * @return */ SaErrorT clear_domain_info_entry(SaHpiDomainIdT domain_id) { SaErrorT rv = SA_OK; netsnmp_index *row_idx; saHpiDomainInfoTable_context *ctx; DEBUGMSGTL ((AGENT, "clear_domain_info_entry, called\n")); DEBUGMSGTL ((AGENT, " domainId [%d]\n", domain_id)); row_idx = CONTAINER_FIRST(cb.container); if (row_idx) //At least one entry was found. { do { ctx = CONTAINER_FIND(cb.container, row_idx); row_idx = CONTAINER_NEXT(cb.container, row_idx); if (ctx->index.oids[saHpiDomainId_INDEX] == domain_id) { /* all conditions met remove row */ CONTAINER_REMOVE (cb.container, ctx); saHpiDomainInfoTable_delete_row (ctx); domain_info_entry_count = CONTAINER_SIZE (cb.container); DEBUGMSGTL ((AGENT, "clear_domain_info_entry:" " found row: removing\n")); } } while (row_idx); } return rv; }
/** * removes a row from the given table and returns it (no free's called) * * returns the row pointer itself on successful removing. * or NULL on failure (bad arguments) */ netsnmp_tdata_row *netsnmp_tdata_remove_row (netsnmp_tdata * table, netsnmp_tdata_row * row) { if (!row || !table) return NULL; CONTAINER_REMOVE (table->container, row); return row; }
void netsnmp_swinst_entry_remove(netsnmp_container * container, netsnmp_swinst_entry *entry) { DEBUGMSGTL(("swinst:container", "remove\n")); if (!entry) return; /* Nothing to remove */ CONTAINER_REMOVE(container, entry); }
/** remove a row from the table */ void cpqSasPhyDrvTable_removeEntry(netsnmp_container * container, cpqSasPhyDrvTable_entry * entry) { if (!entry) return; /* Nothing to remove */ CONTAINER_REMOVE(container, entry); if (entry) SNMP_FREE(entry); /* XXX - release any other internal resources */ }
int snmpNotifyFilter_storage_remove(snmpNotifyFilter_data_storage *data) { int rc; if (NULL == data) return SNMPERR_GENERR; DEBUGMSGTL(("internal:snmpNotifyFilter", "removing row\n")); rc = CONTAINER_REMOVE(_container, data); if (0 != rc) return SNMPERR_GENERR; return SNMPERR_SUCCESS; }
/** * check entry for update */ static void _check_for_updates(ipIfStatsTable_rowreq_ctx * rowreq_ctx, netsnmp_container *stats) { netsnmp_systemstats_entry *ifstats_entry; /* * check for matching entry. works because indexes are the same. */ ifstats_entry = (netsnmp_systemstats_entry*)CONTAINER_FIND(stats, rowreq_ctx->data); if (NULL == ifstats_entry) { DEBUGMSGTL(("ipIfStatsTable:access", "updating missing entry\n")); /* * mark row as missing, so we can set discontinuity * when it comes back. * * what else should we do? set refresh to 0? that's not quite right... */ rowreq_ctx->known_missing = 1; } else { DEBUGMSGTL(("ipIfStatsTable:access", "updating existing entry\n")); /* * Check for changes & update */ netsnmp_access_systemstats_entry_update(rowreq_ctx->data, ifstats_entry); /* * set discontinuity if previously missing. */ if (1 == rowreq_ctx->known_missing) { rowreq_ctx->known_missing = 0; rowreq_ctx->ipIfStatsDiscontinuityTime = netsnmp_get_agent_uptime(); ipIfStatsTable_lastChange_set(netsnmp_get_agent_uptime()); } /* * remove entry from container */ CONTAINER_REMOVE(stats, ifstats_entry); netsnmp_access_systemstats_entry_free(ifstats_entry); } }
/** remove a row from the table */ static int unregister_cb(int major, int minor, void* serv, void* client) { sysORTable_entry *value; netsnmp_iterator* it = CONTAINER_ITERATOR(table); DEBUGMSGTL(("mibII/sysORTable/unregister_cb", "unregister_cb(%d, %d, %p, %p)\n", major, minor, serv, client)); sysORLastChange = ((struct sysORTable*)(serv))->OR_uptime; while ((value = (sysORTable_entry*)ITERATOR_NEXT(it)) && value->data != serv); ITERATOR_RELEASE(it); if(value) { CONTAINER_REMOVE(table, value); free(value); } return SNMP_ERR_NOERROR; }
/** * * @domainId * @resourceId * * @return */ SaErrorT clear_sensor_normal_max(SaHpiDomainIdT domainId, SaHpiResourceIdT resourceId) { SaErrorT rv = SA_OK; netsnmp_index *row_idx; saHpiSensorReadingNormalMaxTable_context *sen_norm_max_ctx; DEBUGMSGTL ((AGENT, "clear_sensor_normal_max, called\n")); DEBUGMSGTL ((AGENT, " domainId [%d]\n", domainId)); DEBUGMSGTL ((AGENT, " resourceId [%d]\n", resourceId)); row_idx = CONTAINER_FIRST(cb.container); if (row_idx) //At least one entry was found. { do { /* based on the found row_idx get the pointer */ /* to its context (row data) */ sen_norm_max_ctx = CONTAINER_FIND(cb.container, row_idx); /* before we delete the context we should get the */ /* next row (context) if any before we delete this */ /* one. */ row_idx = CONTAINER_NEXT(cb.container, row_idx); if ((sen_norm_max_ctx->index.oids[saHpiSenNormMaxDomainId_INDEX] == domainId) && (sen_norm_max_ctx->index.oids[saHpiSenNormMaxResourceId_INDEX] == resourceId)) { /* all conditions met remove row */ CONTAINER_REMOVE (cb.container, sen_norm_max_ctx); saHpiSensorReadingNormalMaxTable_delete_row (sen_norm_max_ctx); DEBUGMSGTL ((AGENT, "clear_sensor_normal_max: " "found row: removing\n")); } } while (row_idx); } return rv; }
/** * Remove a client */ void del_radiusAccClientExtTable(dm_id id) { netsnmp_index idx; oid soid[1]; radiusAccClientExtTable_context *row; if (!my_handler) return; idx.len = 1; idx.oids = &soid[0]; soid[0] = id; row = CONTAINER_FIND(cb.container, &idx); if (row) { CONTAINER_REMOVE(cb.container, row); free(row); } }
/** * check entry for update */ static void _check_entry_for_updates (ipDefaultRouterTable_rowreq_ctx * rowreq_ctx, void **magic) { netsnmp_container *defaultrouter_container = magic[0]; netsnmp_container *to_delete = (netsnmp_container *) magic[1]; /* * check for matching entry using secondary index. */ netsnmp_defaultrouter_entry *defaultrouter_entry = CONTAINER_FIND (defaultrouter_container, rowreq_ctx->data); if (NULL == defaultrouter_entry) { DEBUGMSGTL (("ipDefaultRouterTable:access", "removing missing entry\n")); if (NULL == to_delete) { magic[1] = to_delete = netsnmp_container_find ("lifo"); if (NULL == to_delete) snmp_log (LOG_ERR, "couldn't create delete container\n"); } if (NULL != to_delete) CONTAINER_INSERT (to_delete, rowreq_ctx); } else { DEBUGMSGTL (("ipDefaultRouterTable:access", "updating existing entry\n")); /* * Check for changes & update */ netsnmp_access_defaultrouter_entry_update (rowreq_ctx->data, defaultrouter_entry); /* * remove entry from ifcontainer */ CONTAINER_REMOVE (defaultrouter_container, defaultrouter_entry); netsnmp_access_defaultrouter_entry_free (defaultrouter_entry); } }
/** * check entry for update */ static void _check_entry_for_updates(ipAddressTable_rowreq_ctx * rowreq_ctx, void **magic) { netsnmp_container *ipaddress_container = (netsnmp_container*)magic[0]; netsnmp_container *to_delete = (netsnmp_container*)magic[1]; /* * check for matching entry using secondary index. */ netsnmp_ipaddress_entry *ipaddress_entry = (netsnmp_ipaddress_entry*) CONTAINER_FIND(ipaddress_container, rowreq_ctx->data); if (NULL == ipaddress_entry) { DEBUGMSGTL(("ipAddressTable:access", "removing missing entry\n")); if (NULL == to_delete) { magic[1] = to_delete = netsnmp_container_find("lifo"); if (NULL == to_delete) snmp_log(LOG_ERR, "couldn't create delete container\n"); } if (NULL != to_delete) CONTAINER_INSERT(to_delete, rowreq_ctx); } else { DEBUGMSGTL(("ipAddressTable:access", "updating existing entry\n")); /* * Check for changes & update */ if (netsnmp_access_ipaddress_entry_update(rowreq_ctx->data, ipaddress_entry) > 0) rowreq_ctx->ipAddressLastChanged = netsnmp_get_agent_uptime(); /* * remove entry from ifcontainer */ CONTAINER_REMOVE(ipaddress_container, ipaddress_entry); netsnmp_access_ipaddress_entry_free(ipaddress_entry); } }
void delete_(unsigned int clientreg, void *clientarg) { netsnmp_index index; netSnmpIETFWGTable_context *x; netSnmpIETFWGTable_context blah; oid tmp[4]; tmp[0]=3; tmp[1]='A'; tmp[2] ='B'; tmp[3] ='C'; index.oids = tmp; index.len = 4; blah.index = index; DEBUGMSGTL((AGENT,"Delete first some table.")); x = CONTAINER_FIND(cb.container, &blah); DEBUGMSGTL((AGENT,"Found object [%X]\n",x)); if (x) { DEBUGMSGTL((AGENT,"Deleteing object\n")); CONTAINER_REMOVE(cb.container,x); DEBUGMSGTL((AGENT,"Object deleted\n")); } }
int delete_rdr_row (SaHpiDomainIdT domain_id, SaHpiResourceIdT resource_id, SaHpiEntryIdT num, SaHpiRdrTypeT type) { saHpiRdrTable_context *ctx; oid rdr_oid[RDR_INDEX_NR]; netsnmp_index rdr_index; int rc = AGENT_ERR_NOT_FOUND; DEBUGMSGTL ((AGENT, "delete_rdr_row (%d, %d, %d, %d). Entry.\n", domain_id, resource_id, num, type)); // Look at the MIB to find out what the indexs are rdr_oid[0] = domain_id; rdr_oid[1] = resource_id; rdr_oid[2] = num; rdr_oid[3] = type; // Possible more indexs? rdr_index.oids = (oid *) & rdr_oid; rdr_index.len = RDR_INDEX_NR; ctx = CONTAINER_FIND (cb.container, &rdr_index); if (ctx) { CONTAINER_REMOVE (cb.container, ctx); saHpiRdrTable_delete_row (ctx); rdr_count = CONTAINER_SIZE (cb.container); rc = AGENT_ERR_NOERROR; } DEBUGMSGTL ((AGENT, "delete_rdr_row. Exit (rc: %d)\n", rc)); return rc; }
/** * * @session_id * @resource_id * @saHpiEventLogRowPointer * @aHpiEventLogRowPointer_len * * @return */ SaErrorT domain_event_log_clear(SaHpiSessionIdT session_id, SaHpiResourceIdT resource_id, oid *saHpiEventLogRowPointer, size_t saHpiEventLogRowPointer_len, int modifyTotal) { oid domain_evt_oid[DOMAIN_EVENT_LOG_INDEX_NR]; netsnmp_index domain_evt_idx; netsnmp_index *domain_index; saHpiDomainEventLogTable_context *domain_evt_ctx; DR_XREF *dr_entry; SaHpiDomainIdResourceIdArrayT dr_pair; int column_len = 2; DEBUGMSGTL ((AGENT, "domain_event_log_clear, called\n")); DEBUGMSGTL ((AGENT, "Attempting to delete domain el row with the following indexes:\n")); DEBUGMSGTL ((AGENT," Domain [%ld]\n", saHpiEventLogRowPointer[saHpiDomainEventLogTable_oid_len + column_len])); DEBUGMSGTL ((AGENT," Entry id [%ld]\n", saHpiEventLogRowPointer[saHpiDomainEventLogTable_oid_len + column_len + 1])); DEBUGMSGTL ((AGENT," Severity [%s]\n", oh_lookup_severity( saHpiEventLogRowPointer[saHpiDomainEventLogTable_oid_len + column_len + 2]-1))); /* BUILD oid for new row */ /* assign the number of indices */ domain_evt_idx.len = DOMAIN_EVENT_LOG_INDEX_NR; /** Index saHpiDomainId is external */ domain_evt_oid[0] = saHpiEventLogRowPointer[saHpiDomainEventLogTable_oid_len + column_len]; /** Index saHpiDomainEventEntryId is external */ domain_evt_oid[1] = saHpiEventLogRowPointer[saHpiDomainEventLogTable_oid_len + column_len + 1]; /** Index saHpiEventSeverity is external */ domain_evt_oid[2] = saHpiEventLogRowPointer[saHpiDomainEventLogTable_oid_len + column_len + 2]; /* assign the indices to the index */ domain_evt_idx.oids = (oid *) & domain_evt_oid; domain_index = CONTAINER_FIRST(cb.container); domain_evt_ctx = CONTAINER_FIND(cb.container, &domain_evt_idx); if (!domain_evt_ctx) { DEBUGMSGTL ((AGENT, "domain_event_log_clear did not find a row to delete\n")); } else { DEBUGMSGTL ((AGENT, "domain_event_log_clear found row to delete\n")); CONTAINER_REMOVE(cb.container, domain_evt_ctx); saHpiDomainEventLogTable_delete_row(domain_evt_ctx); /* Reset the entry id for this domain/resource pair */ dr_pair.domainId_resourceId_arry[0] = saHpiEventLogRowPointer[saHpiDomainEventLogTable_oid_len + column_len]; dr_pair.domainId_resourceId_arry[1] = resource_id; dr_entry = domain_resoruce_pair_lookup(&dr_pair, &dr_table); if (dr_entry == NULL) { DEBUGMSGTL ((AGENT, "ERROR: domain_event_log_clear() domain_resoruce_pair_lookup returned NULL\n")); return AGENT_ERR_INTERNAL_ERROR; } DEBUGMSGTL ((AGENT, "domain_event_log_clear() resetting entry_id to 0\n")); dr_entry->entry_id = 0; domain_event_log_entry_count = CONTAINER_SIZE (cb.container); if (modifyTotal == MIB_TRUE) { domain_event_log_entry_count_total--; } } return SA_OK; }
/** * check entry for update * */ static void _check_interface_entry_for_updates(ifTable_rowreq_ctx * rowreq_ctx, netsnmp_container *ifcontainer) { char oper_changed = 0; /* * check for matching entry. We can do this directly, since * both containers use the same index. */ netsnmp_interface_entry *ifentry = CONTAINER_FIND(ifcontainer, rowreq_ctx); #ifdef USING_IP_MIB_IPV4INTERFACETABLE_IPV4INTERFACETABLE_MODULE /* * give ipv4If table a crack at the entry */ ipv4InterfaceTable_check_entry_for_updates(rowreq_ctx, ifentry); #endif #ifdef USING_IP_MIB_IPV6INTERFACETABLE_IPV6INTERFACETABLE_MODULE /* * give ipv6If table a crack at the entry */ ipv6InterfaceTable_check_entry_for_updates(rowreq_ctx, ifentry); #endif if (NULL == ifentry) { /* * if this is the first time we detected that this interface is * missing, set admin/oper status down, and set last change. * * yyy-rks: when, if ever, would we consider an entry * deleted (and thus need to update ifTableLastChanged)? */ if (!rowreq_ctx->known_missing) { DEBUGMSGTL(("ifTable:access", "updating missing entry\n")); rowreq_ctx->known_missing = 1; rowreq_ctx->data.ifAdminStatus = IFADMINSTATUS_DOWN; if ((!(rowreq_ctx->data.ifentry->ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_LASTCHANGE)) && (rowreq_ctx->data.ifOperStatus != IFOPERSTATUS_DOWN)) oper_changed = 1; rowreq_ctx->data.ifOperStatus = IFOPERSTATUS_DOWN; } } else { DEBUGMSGTL(("ifTable:access", "updating existing entry\n")); #ifdef USING_IF_MIB_IFXTABLE_IFXTABLE_MODULE { int rc = strcmp(rowreq_ctx->data.ifName, ifentry->name); netsnmp_assert(rc == 0); } #endif /* * if the interface was missing, but came back, clear the * missing flag and set the discontinuity time. (if an os keeps * persistent counters, tough cookies. We'll cross that * bridge if we come to it). */ if (rowreq_ctx->known_missing) { rowreq_ctx->known_missing = 0; #ifdef USING_IF_MIB_IFXTABLE_IFXTABLE_MODULE rowreq_ctx->data.ifCounterDiscontinuityTime = netsnmp_get_agent_uptime(); #endif } /* * Check for changes, then update */ if ((!(ifentry->ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_LASTCHANGE)) && (rowreq_ctx->data.ifOperStatus != ifentry->oper_status)) oper_changed = 1; netsnmp_access_interface_entry_copy(rowreq_ctx->data.ifentry, ifentry); /* * remove entry from temporary ifcontainer */ CONTAINER_REMOVE(ifcontainer, ifentry); netsnmp_access_interface_entry_free(ifentry); } /* * if ifOperStatus changed, update ifLastChange */ if (oper_changed) rowreq_ctx->data.ifLastChange = netsnmp_get_agent_uptime(); }
int delete_sensor_row (SaHpiDomainIdT domain_id, SaHpiResourceIdT resource_id, SaHpiSensorNumT sensor_num) { saHpiSensorTable_context *ctx; oid index_oid[SENSOR_INDEX_NR]; netsnmp_index sensor_index; int rc = AGENT_ERR_NOT_FOUND; DEBUGMSGTL ((AGENT, "delete_sensor_row (%d, %d, %d). Entry.\n", domain_id, resource_id, sensor_num)); // Look at the MIB to find out what the indexs are index_oid[0] = domain_id; index_oid[1] = resource_id; index_oid[2] = sensor_num; // Possible more indexs? sensor_index.oids = (oid *) & index_oid; sensor_index.len = SENSOR_INDEX_NR; ctx = CONTAINER_FIND (cb.container, &sensor_index); if (ctx) { rc = delete_ReadingCurrent_row (ctx->domain_id, ctx->resource_id, ctx->saHpiSensorIndex); if (rc != AGENT_ERR_NOERROR) DEBUGMSGTL ((AGENT, "call to delete_ReadingCurrent failed with rc: %d\n", rc)); if (ctx->flags & SAHPI_SRF_MIN) { rc = delete_ReadingMin_row (ctx->domain_id, ctx->resource_id, ctx->saHpiSensorIndex); if (rc != AGENT_ERR_NOERROR) DEBUGMSGTL ((AGENT, "call to delete_ReadingMin failed with rc: %d\n", rc)); } if (ctx->flags & SAHPI_SRF_MAX) { rc = delete_ReadingMax_row (ctx->domain_id, ctx->resource_id, ctx->saHpiSensorIndex); if (rc != AGENT_ERR_NOERROR) DEBUGMSGTL ((AGENT, "call to delete_ReadingMaxfailed with rc: %d\n", rc)); } if (ctx->flags & SAHPI_SRF_NORMAL_MIN) { rc = delete_ReadingNormalMin_row (ctx->domain_id, ctx->resource_id, ctx->saHpiSensorIndex); if (rc != AGENT_ERR_NOERROR) DEBUGMSGTL ((AGENT, "call to delete_ReadingNormalMin failed with rc: %d\n", rc)); } if (ctx->flags & SAHPI_SRF_NORMAL_MAX) { rc = delete_ReadingNormalMax_row (ctx->domain_id, ctx->resource_id, ctx->saHpiSensorIndex); if (rc != AGENT_ERR_NOERROR) DEBUGMSGTL ((AGENT, "call to delete_ReadingNormalMax failed with rc: %d\n", rc)); } if (ctx->flags & SAHPI_SRF_NOMINAL) { rc = delete_ReadingNominal_row (ctx->domain_id, ctx->resource_id, ctx->saHpiSensorIndex); if (rc != AGENT_ERR_NOERROR) DEBUGMSGTL ((AGENT, "call to delete_ReadingNominal failed with rc: %d\n", rc)); } /* * Threshold rows */ if (ctx->saHpiSensorHasThresholds == MIB_TRUE) { rc = delete_ThdLowCritical_row (ctx->domain_id, ctx->resource_id, ctx->saHpiSensorIndex); if (rc != AGENT_ERR_NOERROR) DEBUGMSGTL ((AGENT, "call to delete_ThdLowCritical failed with rc: %d\n", rc)); rc = delete_ThdLowMajor_row (ctx->domain_id, ctx->resource_id, ctx->saHpiSensorIndex); if (rc != AGENT_ERR_NOERROR) DEBUGMSGTL ((AGENT, "call to delete_ThdLowMajor failed with rc: %d\n", rc)); rc = delete_ThdLowMinor_row (ctx->domain_id, ctx->resource_id, ctx->saHpiSensorIndex); if (rc != AGENT_ERR_NOERROR) DEBUGMSGTL ((AGENT, "call to delete_ThdLowMinor failed with rc: %d\n", rc)); rc = delete_ThdUpCritical_row (ctx->domain_id, ctx->resource_id, ctx->saHpiSensorIndex); if (rc != AGENT_ERR_NOERROR) DEBUGMSGTL ((AGENT, "call to delete_ThdUpCritical failed with rc: %d\n", rc)); rc = delete_ThdUpMajor_row (ctx->domain_id, ctx->resource_id, ctx->saHpiSensorIndex); if (rc != AGENT_ERR_NOERROR) DEBUGMSGTL ((AGENT, "call to delete_ThdUpMajor failed with rc: %d\n", rc)); rc = delete_ThdUpMinor_row (ctx->domain_id, ctx->resource_id, ctx->saHpiSensorIndex); if (rc != AGENT_ERR_NOERROR) DEBUGMSGTL ((AGENT, "call to delete_ThdUpMinor failed with rc: %d\n", rc)); rc = delete_ThdPosHysteresis_row (ctx->domain_id, ctx->resource_id, ctx->saHpiSensorIndex); if (rc != AGENT_ERR_NOERROR) DEBUGMSGTL ((AGENT, "call to delete_ThdPosHysteresis failed with rc: %d\n", rc)); rc = delete_ThdNegHysteresis_row (ctx->domain_id, ctx->resource_id, ctx->saHpiSensorIndex); if (rc != AGENT_ERR_NOERROR) DEBUGMSGTL ((AGENT, "call to delete_ThdNegHysteresis failed with rc: %d\n", rc)); } CONTAINER_REMOVE (cb.container, ctx); saHpiSensorTable_delete_row (ctx); sensor_count = CONTAINER_SIZE (cb.container); rc = AGENT_ERR_NOERROR; } DEBUGMSGTL ((AGENT, "delete_sensor_row. Exit (rc: %d).\n", rc)); return rc; }
/** * @internal * determine if we want a ifTable row in our container */ void ipv6InterfaceTable_check_entry_for_updates(const ifTable_rowreq_ctx * ift_rrc, netsnmp_interface_entry *entry) { netsnmp_container *c = ipv6InterfaceTable_container_get(); ifTable_rowreq_ctx *ip6if_rrc; int changed = 0; DEBUGMSGTL(("verbose:ipv6InterfaceTable:check_entry_for_updates", "called\n")); /* * do we have a corresponding row? */ ip6if_rrc = CONTAINER_FIND(c, ift_rrc); if (NULL == ip6if_rrc) { /* * no corresponding row. should we have one? */ if ((NULL != entry) && (entry->ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_IPV6)) { /* * yes. */ DEBUGMSGTL(("ipv6InterfaceTable:check_entry_for_updates", "inserted row for index %d\n", entry->index)); CONTAINER_INSERT(c, ift_rrc); changed = 1; } } else { /* * found corresponding row. is it still applicable? */ if ((NULL == entry) || (0 == (entry->ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_IPV6))) { /* * no */ DEBUGMSGTL(("ipv6InterfaceTable:check_entry_for_updates", "removed row for index %d\n", ift_rrc->data.ifentry->index)); CONTAINER_REMOVE(c, ift_rrc); changed = 1; } else { /* * still applicable. anything changed? */ if (/** retransmit */ ((entry-> ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_V6_RETRANSMIT) && (entry->retransmit_v6 != ift_rrc->data.ifentry->retransmit_v6)) || /** reasm */ ((entry-> ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_V6_REASMMAX) && (entry->reasm_max_v6 != ift_rrc->data.ifentry->reasm_max_v6)) || /** reachable time */ ((entry-> ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_V6_REACHABLE) && (entry->reachable_time != ift_rrc->data.ifentry->reachable_time)) || /** if id */ ((entry->ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_V6_IFID) && ((entry->v6_if_id_len != ift_rrc->data.ifentry->v6_if_id_len) || (0 != memcmp(entry->v6_if_id, ift_rrc->data.ifentry->v6_if_id, entry->v6_if_id_len)))) || /** forwarding */ ((entry-> ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_V6_FORWARDING) && (entry->forwarding_v6 != ift_rrc->data.ifentry->forwarding_v6))) { DEBUGMSGTL(("ipv6InterfaceTable:check_entry_for_updates", "row changed for index %d\n", ift_rrc->data.ifentry->index)); changed = 1; } } } /* * if something changed, update table last changed */ if (changed) ipv6InterfaceTable_lastChange_set(netsnmp_get_agent_uptime()); }
static void process_set_group (netsnmp_index * o, void *c) { /* xxx-rks: should we continue processing after an error?? */ set_context *context = (set_context *) c; netsnmp_request_group *ag = (netsnmp_request_group *) o; int rc = SNMP_ERR_NOERROR; switch (context->agtreq_info->mode) { case MODE_SET_RESERVE1: /** -> SET_RESERVE2 || SET_FREE */ /* * if not a new row, save undo info */ if (ag->row_created == 0) { if (context->tad->cb->duplicate_row) ag->undo_info = context->tad->cb->duplicate_row (ag->existing_row); else ag->undo_info = NULL; if (NULL == ag->undo_info) { rc = SNMP_ERR_RESOURCEUNAVAILABLE; break; } } if (context->tad->cb->set_reserve1) context->tad->cb->set_reserve1 (ag); break; case MODE_SET_RESERVE2: /** -> SET_ACTION || SET_FREE */ if (context->tad->cb->set_reserve2) context->tad->cb->set_reserve2 (ag); break; case MODE_SET_ACTION: /** -> SET_COMMIT || SET_UNDO */ if (context->tad->cb->set_action) context->tad->cb->set_action (ag); break; case MODE_SET_COMMIT: /** FINAL CHANCE ON SUCCESS */ if (ag->row_created == 0) { /* * this is an existing row, has it been deleted? */ if (ag->row_deleted == 1) { DEBUGMSGT ((TABLE_ARRAY_NAME, "action: deleting row\n")); if (CONTAINER_REMOVE (ag->table, ag->existing_row) != 0) { rc = SNMP_ERR_COMMITFAILED; break; } } } else if (ag->row_deleted == 0) { /* * new row (that hasn't been deleted) should be inserted */ DEBUGMSGT ((TABLE_ARRAY_NAME, "action: inserting row\n")); if (CONTAINER_INSERT (ag->table, ag->existing_row) != 0) { rc = SNMP_ERR_COMMITFAILED; break; } } if (context->tad->cb->set_commit) context->tad->cb->set_commit (ag); /** no more use for undo_info, so free it */ if (ag->undo_info) { context->tad->cb->delete_row (ag->undo_info); ag->undo_info = NULL; } #if 0 /* XXX-rks: finish row cooperative notifications * if the table has requested it, send cooperative notifications * for row operations. */ if (context->tad->notifications) { if (ag->undo_info) { if (!ag->existing_row) netsnmp_monitor_notify (EVENT_ROW_DEL); else netsnmp_monitor_notify (EVENT_ROW_MOD); } else netsnmp_monitor_notify (EVENT_ROW_ADD); } #endif if ((ag->row_created == 0) && (ag->row_deleted == 1)) { context->tad->cb->delete_row (ag->existing_row); ag->existing_row = NULL; } break; case MODE_SET_FREE: /** FINAL CHANCE ON FAILURE */ if (context->tad->cb->set_free) context->tad->cb->set_free (ag); /** no more use for undo_info, so free it */ if (ag->row_created == 1) { if (context->tad->cb->delete_row) context->tad->cb->delete_row (ag->existing_row); ag->existing_row = NULL; } else { if (context->tad->cb->delete_row) context->tad->cb->delete_row (ag->undo_info); ag->undo_info = NULL; } break; case MODE_SET_UNDO: /** FINAL CHANCE ON FAILURE */ /* * status already set - don't change it now */ if (context->tad->cb->set_undo) context->tad->cb->set_undo (ag); /* * no more use for undo_info, so free it */ if (ag->row_created == 0) { /* * restore old values */ context->tad->cb->row_copy (ag->existing_row, ag->undo_info); context->tad->cb->delete_row (ag->undo_info); ag->undo_info = NULL; } else { context->tad->cb->delete_row (ag->existing_row); ag->existing_row = NULL; } break; default: snmp_log (LOG_ERR, "unknown mode processing SET for " "netsnmp_table_array_helper_handler\n"); rc = SNMP_ERR_GENERR; break; } if (rc) netsnmp_set_request_error (context->agtreq_info, ag->list->ri, rc); }
/** * load initial data * * TODO:350:M: Implement ipAddressTable data load * This function will also be called by the cache helper to load * the container again (after the container free function has been * called to free the previous contents). * * @param container container to which items should be inserted * * @retval MFD_SUCCESS : success. * @retval MFD_RESOURCE_UNAVAILABLE : Can't access data source * @retval MFD_ERROR : other error. * * This function is called to load the index(es) (and data, optionally) * for the every row in the data set. * * @remark * While loading the data, the only important thing is the indexes. * If access to your data is cheap/fast (e.g. you have a pointer to a * structure in memory), it would make sense to update the data here. * If, however, the accessing the data invovles more work (e.g. parsing * some other existing data, or peforming calculations to derive the data), * then you can limit yourself to setting the indexes and saving any * information you will need later. Then use the saved information in * ipAddressTable_row_prep() for populating data. * * @note * If you need consistency between rows (like you want statistics * for each row to be from the same time frame), you should set all * data here. * */ int ipAddressTable_container_load(netsnmp_container *container) { netsnmp_container *ipaddress_container; void *tmp_ptr[2]; DEBUGMSGTL(("verbose:ipAddressTable:ipAddressTable_cache_load", "called\n")); /* * TODO:351:M: |-> Load/update data in the ipAddressTable container. * loop over your ipAddressTable data, allocate a rowreq context, * set the index(es) [and data, optionally] and insert into * the container. */ ipaddress_container = netsnmp_access_ipaddress_container_load(NULL, NETSNMP_ACCESS_IPADDRESS_LOAD_ADDL_IDX_BY_ADDR); /* * we just got a fresh copy of interface data. compare it to * what we've already got, and make any adjustments, saving * missing addresses to be deleted. */ tmp_ptr[0] = ipaddress_container->next; tmp_ptr[1] = NULL; CONTAINER_FOR_EACH(container, (netsnmp_container_obj_func *) _check_entry_for_updates, tmp_ptr); /* * now add any new interfaces */ CONTAINER_FOR_EACH(ipaddress_container, (netsnmp_container_obj_func *) _add_new_entry, container); /* * free the container. we've either claimed each entry, or released it, * so the access function doesn't need to clear the container. */ netsnmp_access_ipaddress_container_free(ipaddress_container, NETSNMP_ACCESS_IPADDRESS_FREE_DONT_CLEAR); /* * remove deleted addresses from table container */ if (NULL != tmp_ptr[1]) { netsnmp_container *tmp_container = (netsnmp_container *) tmp_ptr[1]; ipAddressTable_rowreq_ctx *tmp_ctx; /* * this works because the tmp_container is a linked list, * which can be used like a stack... */ while (CONTAINER_SIZE(tmp_container)) { /* * get from delete list */ tmp_ctx = (ipAddressTable_rowreq_ctx*)CONTAINER_FIRST(tmp_container); /* * release context, delete from table container */ CONTAINER_REMOVE(container, tmp_ctx); ipAddressTable_release_rowreq_ctx(tmp_ctx); /* * pop off delete list */ CONTAINER_REMOVE(tmp_container, NULL); } } DEBUGMSGT(("verbose:ipAddressTable:ipAddressTable_cache_load", "%lu records\n", (unsigned long)CONTAINER_SIZE(container))); return MFD_SUCCESS; }
/** * * @domainId * @resourceId * * @return */ SaErrorT clear_ctrl_digital(SaHpiDomainIdT domainId, SaHpiResourceIdT resourceId) { SaErrorT rv = SA_OK; netsnmp_index *row_idx; saHpiCtrlDigitalTable_context *ctrl_ctx; DEBUGMSGTL ((AGENT, "clear_ctrl_digital, called\n")); DEBUGMSGTL ((AGENT, " domainId [%d]\n", domainId)); DEBUGMSGTL ((AGENT, " resourceId [%d]\n", resourceId)); DR_XREF *dr_entry; SaHpiDomainIdResourceIdArrayT dr_pair; /* reset any existing indexEntry value */ dr_pair.domainId_resourceId_arry[0] = domainId; dr_pair.domainId_resourceId_arry[1] = resourceId; dr_entry = domain_resoruce_pair_lookup(&dr_pair, &dr_table); if (dr_entry == NULL) { DEBUGMSGTL ((AGENT, "INFO: clear_ctrl_digital() domain_resource_pair_get returned NULL\n")); return SA_ERR_HPI_NOT_PRESENT; } else { dr_entry->entry_id = 0; } row_idx = CONTAINER_FIRST(cb.container); if (row_idx) //At least one entry was found. { do { /* based on the found row_idx get the pointer */ /* to its context (row data) */ ctrl_ctx = CONTAINER_FIND(cb.container, row_idx); /* before we delete the context we should get the */ /* next row (context) if any before we delete this */ /* one. */ row_idx = CONTAINER_NEXT(cb.container, row_idx); if ((ctrl_ctx->index.oids[saHpiCtrlDigitalDomainId_INDEX] == domainId) && (ctrl_ctx->index.oids[saHpiCtrlDigitalResourceEntryId_INDEX] == resourceId)) { /* all conditions met remove row */ CONTAINER_REMOVE (cb.container, ctrl_ctx); saHpiCtrlDigitalTable_delete_row (ctrl_ctx); ctrl_digital_entry_count = CONTAINER_SIZE (cb.container); DEBUGMSGTL ((AGENT, "clear_ctrl_digital: " "found row: removing\n")); } } while (row_idx); } return rv; }
/** * @internal * determine if we want a ifTable row in our container */ void ipv4InterfaceTable_check_entry_for_updates(const ifTable_rowreq_ctx * ift_rrc, netsnmp_interface_entry *entry) { netsnmp_container *c = ipv4InterfaceTable_container_get(); ifTable_rowreq_ctx *ip4if_rrc; int changed = 0; DEBUGMSGTL(("verbose:ipv4InterfaceTable:check_entry_for_updates", "called\n")); /* * do we have a corresponding row? */ ip4if_rrc = CONTAINER_FIND(c, ift_rrc); if (NULL == ip4if_rrc) { /* * no corresponding row. should we have one? */ if ((NULL != entry) && (entry->ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_IPV4)) { /* * yes. */ DEBUGMSGTL(("ipv4InterfaceTable:check_entry_for_updates", "inserted row for %d\n", entry->index)); CONTAINER_INSERT(c, ift_rrc); changed = 1; } } else { /* * found corresponding row. is it still applicable? */ if ((NULL == entry) || (0 == (entry->ns_flags & NETSNMP_INTERFACE_FLAGS_HAS_IPV4))) { /* * no */ DEBUGMSGTL(("ipv4InterfaceTable:check_entry_for_updates", "removed row for %d\n", ift_rrc->data.ifentry->index)); CONTAINER_REMOVE(c, ift_rrc); changed = 1; } else { /* * still applicable. anything changed? */ if ((entry->retransmit_v4 != ift_rrc->data.ifentry->retransmit_v4) || (entry->reasm_max_v4 != ift_rrc->data.ifentry->reasm_max_v4)) { DEBUGMSGTL(("ipv4InterfaceTable:check_entry_for_updates", "row changed for %d\n", ift_rrc->data.ifentry->index)); changed = 1; } } } /* * if something changed, update table last changed */ if (changed) ipv4InterfaceTable_lastChange_set(netsnmp_get_agent_uptime()); }