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