/*
* $Id$
*
*/
#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-features.h>
#include <stdio.h>
#if HAVE_STDLIB_H
#include <stdlib.h>
#endif
#if HAVE_MALLOC_H
#include <malloc.h>
#endif
#include <sys/types.h>
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/types.h>
#include <net-snmp/library/snmp_api.h>
#include <net-snmp/library/container.h>
#include <net-snmp/library/tools.h>
#include <net-snmp/library/snmp_assert.h>
#include <net-snmp/library/container_iterator.h>
netsnmp_feature_child_of(container_iterator, container_types)
#ifndef NETSNMP_FEATURE_REMOVE_CONTAINER_ITERATOR
/**
* Holds iterator information containing functions which should be called
* by the iterator_handler to loop over your data set and sort it in a
* SNMP specific manner.
*
* The iterator_info typedef can be used instead of directly calling this
* struct if you would prefer.
*/
typedef struct iterator_info_s {
/*
* netsnmp_conatiner must be first
*/
netsnmp_container c;
/*
* iterator data
*/
Netsnmp_Iterator_Loop_Key *get_first;
Netsnmp_Iterator_Loop_Key *get_next;
Netsnmp_Iterator_Loop_Data *get_data;
Netsnmp_Iterator_Data *free_user_ctx;
Netsnmp_Iterator_Ctx *init_loop_ctx;
Netsnmp_Iterator_Ctx *cleanup_loop_ctx;
Netsnmp_Iterator_Ctx_Dup *save_pos;
Netsnmp_Iterator_Data * release_data;
Netsnmp_Iterator_Data * insert_data;
Netsnmp_Iterator_Data * remove_data;
Netsnmp_Iterator_Op * get_size;
int sorted;
/** This can be used by client handlers to store any
information they need */
void *user_ctx;
} iterator_info;
/**********************************************************************
*
* iterator
*
**********************************************************************/
static void *
_iterator_get(iterator_info *ii, const void *key)
{
int cmp, rc = SNMP_ERR_NOERROR;
netsnmp_ref_void best = { NULL };
netsnmp_ref_void tmp = { NULL };
netsnmp_ref_void loop_ctx = { NULL };
DEBUGMSGT(("container_iterator",">%s\n", "_iterator_get"));
if(ii->init_loop_ctx)
ii->init_loop_ctx(ii->user_ctx, &loop_ctx);
rc = ii->get_first(ii->user_ctx, &loop_ctx, &tmp);
if(SNMP_ERR_NOERROR != rc) {
if(SNMP_ENDOFMIBVIEW != rc)
snmp_log(LOG_ERR, "bad rc %d from get_next\n", rc);
}
else {
for( ;
(NULL != tmp.val) && (SNMP_ERR_NOERROR == rc);
rc = ii->get_next(ii->user_ctx, &loop_ctx, &tmp) ) {
/*
* if keys are equal, we are done.
*/
cmp = ii->c.compare(tmp.val, key);
if(0 == cmp) {
best.val = tmp.val;
if(ii->get_data)
ii->get_data(ii->user_ctx, &loop_ctx, &best);
}
/*
* if data is sorted and if key is greater,
* we are done (not found)
*/
if((cmp > 0) && ii->sorted)
break;
} /* end for */
}
if(ii->cleanup_loop_ctx)
ii->cleanup_loop_ctx(ii->user_ctx,&loop_ctx);
return best.val;
}
/**
*
* NOTE: the returned data context can be reused, to save from
* having to allocate memory repeatedly. However, in this case,
* the get_data and get_pos functions must be implemented to
* return unique memory that will be saved for later comparisons.
*/
static void *
_iterator_get_next(iterator_info *ii, const void *key)
{
int cmp, rc = SNMP_ERR_NOERROR;
netsnmp_ref_void best_val = { NULL };
netsnmp_ref_void best_ctx = { NULL };
netsnmp_ref_void tmp = { NULL };
netsnmp_ref_void loop_ctx = { NULL };
DEBUGMSGT(("container_iterator",">%s\n", "_iterator_get_next"));
/*
* initialize loop context
*/
if(ii->init_loop_ctx)
ii->init_loop_ctx(ii->user_ctx, &loop_ctx);
/*
* get first item
*/
rc = ii->get_first(ii->user_ctx, &loop_ctx, &tmp);
if(SNMP_ERR_NOERROR == rc) {
/*
* special case: if key is null, find the first item.
* this is each if the container is sorted, since we're
* already done! Otherwise, get the next item for the
* first comparison in the loop below.
*/
if (NULL == key) {
if(ii->get_data)
ii->save_pos(ii->user_ctx, &loop_ctx, &best_ctx, 1);
best_val.val = tmp.val;
if(ii->sorted)
tmp.val = NULL; /* so we skip for loop */
else
rc = ii->get_next(ii->user_ctx, &loop_ctx, &tmp);
}
/*
* loop over remaining items
*/
for( ;
(NULL != tmp.val) && (rc == SNMP_ERR_NOERROR);
rc = ii->get_next(ii->user_ctx, &loop_ctx, &tmp) ) {
/*
* if we have a key, this is a get-next, and we need to compare
* the key to the tmp value to see if the tmp value is greater
* than the key, but less than any previous match.
*
* if there is no key, this is a get-first, and we need to
* compare the best value agains the tmp value to see if the
* tmp value is lesser than the best match.
*/
if(key) /* get next */
cmp = ii->c.compare(tmp.val, key);
else { /* get first */
/*
* best value and tmp value should never be equal,
* otherwise we'd be comparing a pointer to itself.
* (see note on context reuse in comments above function.
*/
if(best_val.val == tmp.val) {
snmp_log(LOG_ERR,"illegal reuse of data context in "
"container_iterator\n");
rc = SNMP_ERR_GENERR;
break;
}
cmp = ii->c.compare(best_val.val, tmp.val);
}
if(cmp > 0) {
/*
* if we don't have a key (get-first) or a current best match,
* then the comparison above is all we need to know that
* tmp is the best match. otherwise, compare against the
* current best match.
*/
if((NULL == key) || (NULL == best_val.val) ||
((cmp=ii->c.compare(tmp.val, best_val.val)) < 0) ) {
DEBUGMSGT(("container_iterator:results"," best match\n"));
best_val.val = tmp.val;
if(ii->get_data)
ii->save_pos(ii->user_ctx, &loop_ctx, &best_ctx, 1);
}
}
else if((cmp == 0) && ii->sorted && key) {
/*
* if keys are equal and container is sorted, then we know
* the next key will be the one we want.
* NOTE: if no vars, treat as generr, since we
* went past the end of the container when we know
* the next item is the one we want. (IGN-A)
*/
rc = ii->get_next(ii->user_ctx, &loop_ctx, &tmp);
if(SNMP_ERR_NOERROR == rc) {
best_val.val = tmp.val;
if(ii->get_data)
ii->save_pos(ii->user_ctx, &loop_ctx, &best_ctx, 1);
}
else if(SNMP_ENDOFMIBVIEW == rc)
rc = SNMPERR_GENERR; /* not found */
break;
}
} /* end for */
}
/*
* no vars is ok, except as noted above (IGN-A)
*/
if(SNMP_ENDOFMIBVIEW == rc)
rc = SNMP_ERR_NOERROR;
/*
* get data, iff necessary
* clear return value iff errors
*/
if(SNMP_ERR_NOERROR == rc) {
if(ii->get_data && best_val.val) {
rc = ii->get_data(ii->user_ctx, &best_ctx, &best_val);
if(SNMP_ERR_NOERROR != rc) {
snmp_log(LOG_ERR, "bad rc %d from get_data\n", rc);
best_val.val = NULL;
}
}
}
else if(SNMP_ENDOFMIBVIEW != rc) {
snmp_log(LOG_ERR, "bad rc %d from get_next\n", rc);
best_val.val = NULL;
}
/*
* if we have a saved loop ctx, clean it up
*/
if((best_ctx.val != NULL) && (best_ctx.val != loop_ctx.val) &&
(ii->cleanup_loop_ctx))
ii->cleanup_loop_ctx(ii->user_ctx,&best_ctx);
/*
* clean up loop ctx
*/
if(ii->cleanup_loop_ctx)
ii->cleanup_loop_ctx(ii->user_ctx,&loop_ctx);
DEBUGMSGT(("container_iterator:results"," returning %p\n", best_val.val));
return best_val.val;
}
/**********************************************************************
*
* container
*
**********************************************************************/
static void
_iterator_free(iterator_info *ii)
{
DEBUGMSGT(("container_iterator",">%s\n", "_iterator_free"));
if(NULL == ii)
return;
if(ii->user_ctx)
ii->free_user_ctx(ii->user_ctx,ii->user_ctx);
free(ii);
}
static void *
_iterator_find(iterator_info *ii, const void *data)
{
DEBUGMSGT(("container_iterator",">%s\n", "_iterator_find"));
if((NULL == ii) || (NULL == data))
return NULL;
return _iterator_get(ii, data);
}
static void *
_iterator_find_next(iterator_info *ii, const void *data)
{
DEBUGMSGT(("container_iterator",">%s\n", "_iterator_find_next"));
if(NULL == ii)
return NULL;
return _iterator_get_next(ii, data);
}
static int
_iterator_insert(iterator_info *ii, const void *data)
{
DEBUGMSGT(("container_iterator",">%s\n", "_iterator_insert"));
if(NULL == ii)
return -1;
if(NULL == ii->insert_data)
return -1;
return ii->insert_data(ii->user_ctx, data);
}
static int
_iterator_remove(iterator_info *ii, const void *data)
{
DEBUGMSGT(("container_iterator",">%s\n", "_iterator_remove"));
if(NULL == ii)
return -1;
if(NULL == ii->remove_data)
return -1;
return ii->remove_data(ii->user_ctx, data);
}
static int
_iterator_release(iterator_info *ii, const void *data)
{
DEBUGMSGT(("container_iterator",">%s\n", "_iterator_release"));
if(NULL == ii)
return -1;
if(NULL == ii->release_data)
return -1;
return ii->release_data(ii->user_ctx, data);
}
static size_t
_iterator_size(iterator_info *ii)
{
size_t count = 0;
netsnmp_ref_void loop_ctx = { NULL };
netsnmp_ref_void tmp = { NULL };
DEBUGMSGT(("container_iterator",">%s\n", "_iterator_size"));
if(NULL == ii)
return -1;
if(NULL != ii->get_size)
return ii->get_size(ii->user_ctx);
/*
* no get_size. loop and count ourselves
*/
if(ii->init_loop_ctx)
ii->init_loop_ctx(ii->user_ctx, &loop_ctx);
for( ii->get_first(ii->user_ctx, &loop_ctx, &tmp);
NULL != tmp.val;
ii->get_next(ii->user_ctx, &loop_ctx, &tmp) )
++count;
if(ii->cleanup_loop_ctx)
ii->cleanup_loop_ctx(ii->user_ctx,&loop_ctx);
return count;
}
static void
_iterator_for_each(iterator_info *ii, netsnmp_container_obj_func *f,
void *ctx)
{
netsnmp_ref_void loop_ctx = { NULL };
netsnmp_ref_void tmp = { NULL };
DEBUGMSGT(("container_iterator",">%s\n", "_iterator_foreach"));
if(NULL == ii)
return;
if(ii->init_loop_ctx)
ii->init_loop_ctx(ii->user_ctx, &loop_ctx);
for( ii->get_first(ii->user_ctx, &loop_ctx, &tmp);
NULL != tmp.val;
ii->get_next(ii->user_ctx, &loop_ctx, &tmp) )
(*f) (tmp.val, ctx);
if(ii->cleanup_loop_ctx)
ii->cleanup_loop_ctx(ii->user_ctx,&loop_ctx);
}
static void
_iterator_clear(netsnmp_container *container, netsnmp_container_obj_func *f,
void *context)
{
snmp_log(LOG_WARNING,"clear is meaningless for iterator container.\n");
}
/**********************************************************************
*
*/
netsnmp_container*
netsnmp_container_iterator_get(void *iterator_user_ctx,
netsnmp_container_compare * compare,
Netsnmp_Iterator_Loop_Key * get_first,
Netsnmp_Iterator_Loop_Key * get_next,
Netsnmp_Iterator_Loop_Data * get_data,
Netsnmp_Iterator_Ctx_Dup * save_pos,
Netsnmp_Iterator_Ctx * init_loop_ctx,
Netsnmp_Iterator_Ctx * cleanup_loop_ctx,
Netsnmp_Iterator_Data * free_user_ctx,
int sorted)
{
iterator_info *ii;
/*
* sanity checks
*/
if(get_data && ! save_pos) {
snmp_log(LOG_ERR, "save_pos required with get_data\n");
return NULL;
}
/*
* allocate memory
*/
ii = SNMP_MALLOC_TYPEDEF(iterator_info);
if (NULL==ii) {
snmp_log(LOG_ERR, "couldn't allocate memory\n");
return NULL;
}
/*
* init container structure with iterator functions
*/
ii->c.cfree = (netsnmp_container_rc*)_iterator_free;
ii->c.compare = compare;
ii->c.get_size = (netsnmp_container_size*)_iterator_size;
ii->c.init = NULL;
ii->c.insert = (netsnmp_container_op*)_iterator_insert;
ii->c.remove = (netsnmp_container_op*)_iterator_remove;
ii->c.release = (netsnmp_container_op*)_iterator_release;
ii->c.find = (netsnmp_container_rtn*)_iterator_find;
ii->c.find_next = (netsnmp_container_rtn*)_iterator_find_next;
ii->c.get_subset = NULL;
ii->c.get_iterator = NULL;
ii->c.for_each = (netsnmp_container_func*)_iterator_for_each;
ii->c.clear = _iterator_clear;
/*
* init iterator structure with user functions
*/
ii->get_first = get_first;
ii->get_next = get_next;
ii->get_data = get_data;
ii->save_pos = save_pos;
ii->init_loop_ctx = init_loop_ctx;
ii->cleanup_loop_ctx = cleanup_loop_ctx;
ii->free_user_ctx = free_user_ctx;
ii->sorted = sorted;
ii->user_ctx = iterator_user_ctx;
return (netsnmp_container*)ii;
}
void
netsnmp_container_iterator_set_data_cb(netsnmp_container *c,
Netsnmp_Iterator_Data * insert_data,
Netsnmp_Iterator_Data * remove_data,
Netsnmp_Iterator_Op * get_size)
{
iterator_info *ii = (iterator_info *)c;
if(NULL == ii)
return;
ii->insert_data = insert_data;
ii->remove_data = remove_data;
ii->get_size = get_size;
}
#else /* NETSNMP_FEATURE_REMOVE_CONTAINER_ITERATOR */
netsnmp_feature_unused(container_iterator);
#endif /* NETSNMP_FEATURE_REMOVE_CONTAINER_ITERATOR */