自学教程：C++ CONTAINER_REMOVE函数代码示例

intdelete_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 */

intdelete_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);	}}

intdelete_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).  */voidsctpAssocRemAddrTable_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;}

voidnetsnmp_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 */voidcpqSasPhyDrvTable_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 */}

intsnmpNotifyFilter_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 intunregister_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 */voiddel_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);    }}

voiddelete_(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"));	}		}

intdelete_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();}

//.........这里部分代码省略.........					    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 */voidipv6InterfaceTable_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);//.........这里部分代码省略.........

/** * 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. * */intipAddressTable_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);            /*//.........这里部分代码省略.........

/** *  * @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 */voidipv4InterfaceTable_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());}