#include <net-snmp/net-snmp-config.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <net-snmp/net-snmp-features.h>
#include <net-snmp/net-snmp-includes.h>
netsnmp_feature_child_of(oid_stash_all, libnetsnmp)
netsnmp_feature_child_of(oid_stash, oid_stash_all)
netsnmp_feature_child_of(oid_stash_no_free, oid_stash_all)
#ifndef NETSNMP_FEATURE_REMOVE_OID_STASH
/** @defgroup oid_stash Store and retrieve data referenced by an OID.
This is essentially a way of storing data associated with a given
OID. It stores a bunch of data pointers within a memory tree that
allows fairly efficient lookups with a heavily populated tree.
@ingroup library
@{
*/
/*
* xxx-rks: when you have some spare time:
*
* b) basically, everything currently creates one node per sub-oid,
* which is less than optimal. add code to create nodes with the
* longest possible OID per node, and split nodes when necessary
* during adds.
*
* c) If you are feeling really ambitious, also merge split nodes if
* possible on a delete.
*
* xxx-wes: uh, right, like I *ever* have that much time.
*
*/
/***************************************************************************
*
*
***************************************************************************/
/**
* Create an netsnmp_oid_stash node
*
* @param mysize the size of the child pointer array
*
* @return NULL on error, otherwise the newly allocated node
*/
netsnmp_oid_stash_node *
netsnmp_oid_stash_create_sized_node(size_t mysize)
{
netsnmp_oid_stash_node *ret;
ret = SNMP_MALLOC_TYPEDEF(netsnmp_oid_stash_node);
if (!ret)
return NULL;
ret->children = (netsnmp_oid_stash_node**) calloc(mysize, sizeof(netsnmp_oid_stash_node *));
if (!ret->children) {
free(ret);
return NULL;
}
ret->children_size = mysize;
return ret;
}
/** Creates a netsnmp_oid_stash_node.
* Assumes you want the default OID_STASH_CHILDREN_SIZE hash size for the node.
* @return NULL on error, otherwise the newly allocated node
*/
NETSNMP_INLINE netsnmp_oid_stash_node *
netsnmp_oid_stash_create_node(void)
{
return netsnmp_oid_stash_create_sized_node(OID_STASH_CHILDREN_SIZE);
}
netsnmp_feature_child_of(oid_stash_add_data, oid_stash_all)
#ifndef NETSNMP_FEATURE_REMOVE_OID_STASH_ADD_DATA
/** adds data to the stash at a given oid.
* @param root the top of the stash tree
* @param lookup the oid index to store the data at.
* @param lookup_len the length of the lookup oid.
* @param mydata the data to store
* @return SNMPERR_SUCCESS on success, SNMPERR_GENERR if data is
already there, SNMPERR_MALLOC on malloc failures or if arguments
passed in with NULL values.
*/
int
netsnmp_oid_stash_add_data(netsnmp_oid_stash_node **root,
const oid * lookup, size_t lookup_len, void *mydata)
{
netsnmp_oid_stash_node *curnode, *tmpp, *loopp;
unsigned int i;
if (!root || !lookup || lookup_len == 0)
return SNMPERR_GENERR;
if (!*root) {
*root = netsnmp_oid_stash_create_node();
if (!*root)
return SNMPERR_MALLOC;
}
DEBUGMSGTL(( "oid_stash", "stash_add_data "));
DEBUGMSGOID(("oid_stash", lookup, lookup_len));
DEBUGMSG(( "oid_stash", "\n"));
tmpp = NULL;
for (curnode = *root, i = 0; i < lookup_len; i++) {
tmpp = curnode->children[lookup[i] % curnode->children_size];
if (!tmpp) {
/*
* no child in array at all
*/
tmpp = curnode->children[lookup[i] % curnode->children_size] =
netsnmp_oid_stash_create_node();
tmpp->value = lookup[i];
tmpp->parent = curnode;
} else {
for (loopp = tmpp; loopp; loopp = loopp->next_sibling) {
if (loopp->value == lookup[i])
break;
}
if (loopp) {
tmpp = loopp;
} else {
/*
* none exists. Create it
*/
loopp = netsnmp_oid_stash_create_node();
loopp->value = lookup[i];
loopp->next_sibling = tmpp;
loopp->parent = curnode;
tmpp->prev_sibling = loopp;
curnode->children[lookup[i] % curnode->children_size] =
loopp;
tmpp = loopp;
}
/*
* tmpp now points to the proper node
*/
}
curnode = tmpp;
}
/*
* tmpp now points to the exact match
*/
if (curnode->thedata)
return SNMPERR_GENERR;
if (NULL == tmpp)
return SNMPERR_GENERR;
tmpp->thedata = mydata;
return SNMPERR_SUCCESS;
}
#endif /* NETSNMP_FEATURE_REMOVE_OID_STASH_ADD_DATA */
/** returns a node associated with a given OID.
* @param root the top of the stash tree
* @param lookup the oid to look up a node for.
* @param lookup_len the length of the lookup oid
*/
netsnmp_oid_stash_node *
netsnmp_oid_stash_get_node(netsnmp_oid_stash_node *root,
const oid * lookup, size_t lookup_len)
{
netsnmp_oid_stash_node *curnode, *tmpp, *loopp;
unsigned int i;
if (!root)
return NULL;
tmpp = NULL;
for (curnode = root, i = 0; i < lookup_len; i++) {
tmpp = curnode->children[lookup[i] % curnode->children_size];
if (!tmpp) {
return NULL;
} else {
for (loopp = tmpp; loopp; loopp = loopp->next_sibling) {
if (loopp->value == lookup[i])
break;
}
if (loopp) {
tmpp = loopp;
} else {
return NULL;
}
}
curnode = tmpp;
}
return tmpp;
}
/** returns the next node associated with a given OID. INCOMPLETE.
This is equivelent to a GETNEXT operation.
* @internal
* @param root the top of the stash tree
* @param lookup the oid to look up a node for.
* @param lookup_len the length of the lookup oid
*/
netsnmp_feature_child_of(oid_stash_iterate, oid_stash_all)
#ifndef NETSNMP_FEATURE_REMOVE_OID_STASH_ITERATE
netsnmp_oid_stash_node *
netsnmp_oid_stash_getnext_node(netsnmp_oid_stash_node *root,
oid * lookup, size_t lookup_len)
{
netsnmp_oid_stash_node *curnode, *tmpp, *loopp;
unsigned int i, j, bigger_than = 0, do_bigger = 0;
if (!root)
return NULL;
tmpp = NULL;
/* get closest matching node */
for (curnode = root, i = 0; i < lookup_len; i++) {
tmpp = curnode->children[lookup[i] % curnode->children_size];
if (!tmpp) {
break;
} else {
for (loopp = tmpp; loopp; loopp = loopp->next_sibling) {
if (loopp->value == lookup[i])
break;
}
if (loopp) {
tmpp = loopp;
} else {
break;
}
}
curnode = tmpp;
}
/* find the *next* node lexographically greater */
if (!curnode)
return NULL; /* ack! */
if (i+1 < lookup_len) {
bigger_than = lookup[i+1];
do_bigger = 1;
}
do {
/* check the children first */
tmpp = NULL;
/* next child must be (next) greater than our next search node */
/* XXX: should start this loop at best_nums[i]%... and wrap */
for(j = 0; j < curnode->children_size; j++) {
for (loopp = curnode->children[j];
loopp; loopp = loopp->next_sibling) {
if ((!do_bigger || loopp->value > bigger_than) &&
(!tmpp || tmpp->value > loopp->value)) {
tmpp = loopp;
/* XXX: can do better and include min_nums[i] */
if (tmpp->value <= curnode->children_size-1) {
/* best we can do. */
goto done_this_loop;
}
}
}
}
done_this_loop:
if (tmpp && tmpp->thedata)
/* found a node with data. Go with it. */
return tmpp;
if (tmpp) {
/* found a child node without data, maybe find a grandchild? */
do_bigger = 0;
curnode = tmpp;
} else {
/* no respectable children (the bums), we'll have to go up.
But to do so, they must be better than our current best_num + 1.
*/
do_bigger = 1;
bigger_than = curnode->value;
curnode = curnode->parent;
}
} while (curnode);
/* fell off the top */
return NULL;
}
#endif /* NETSNMP_FEATURE_REMOVE_OID_STASH_ITERATE */
netsnmp_feature_child_of(oid_stash_get_data, oid_stash_all)
#ifndef NETSNMP_FEATURE_REMOVE_OID_STASH_GET_DATA
/** returns a data pointer associated with a given OID.
This is equivelent to netsnmp_oid_stash_get_node, but returns only
the data not the entire node.
* @param root the top of the stash
* @param lookup the oid to search for
* @param lookup_len the length of the search oid.
*/
void *
netsnmp_oid_stash_get_data(netsnmp_oid_stash_node *root,
const oid * lookup, size_t lookup_len)
{
netsnmp_oid_stash_node *ret;
ret = netsnmp_oid_stash_get_node(root, lookup, lookup_len);
if (ret)
return ret->thedata;
return NULL;
}
#endif /* NETSNMP_FEATURE_REMOVE_OID_STASH_GET_DATA */
netsnmp_feature_child_of(oid_stash_store_all, oid_stash_all)
#ifndef NETSNMP_FEATURE_REMOVE_OID_STASH_STORE_ALL
/** a wrapper around netsnmp_oid_stash_store for use with a snmp_alarm.
* when calling snmp_alarm, you can list this as a callback. The
* clientarg should be a pointer to a netsnmp_oid_stash_save_info
* pointer. It can also be called directly, of course. The last
* argument (clientarg) is the only one that is used. The rest are
* ignored by the function.
* @param majorID
* @param minorID
* @param serverarg
* @param clientarg A pointer to a netsnmp_oid_stash_save_info structure.
*/
int
netsnmp_oid_stash_store_all(int majorID, int minorID,
void *serverarg, void *clientarg) {
oid oidbase[MAX_OID_LEN];
netsnmp_oid_stash_save_info *sinfo;
if (!clientarg)
return SNMP_ERR_NOERROR;
sinfo = (netsnmp_oid_stash_save_info *) clientarg;
netsnmp_oid_stash_store(*(sinfo->root), sinfo->token, sinfo->dumpfn,
oidbase,0);
return SNMP_ERR_NOERROR;
}
#endif /* NETSNMP_FEATURE_REMOVE_OID_STASH_STORE_ALL */
/** stores data in a starsh tree to peristent storage.
This function can be called to save all data in a stash tree to
Net-SNMP's percent storage. Make sure you register a parsing
function with the read_config system to re-incorperate your saved
data into future trees.
@param root the top of the stash to store.
@param tokenname the file token name to save in (passing "snmpd" will
save things into snmpd.conf).
@param dumpfn A function which can dump the data stored at a particular
node into a char buffer.
@param curoid must be a pointer to a OID array of length MAX_OID_LEN.
@param curoid_len must be 0 for the top level call.
*/
void
netsnmp_oid_stash_store(netsnmp_oid_stash_node *root,
const char *tokenname, NetSNMPStashDump *dumpfn,
oid *curoid, size_t curoid_len) {
char buf[SNMP_MAXBUF];
netsnmp_oid_stash_node *tmpp;
char *cp;
char *appname = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_APPTYPE);
int i;
if (!tokenname || !root || !curoid || !dumpfn)
return;
for (i = 0; i < (int)root->children_size; i++) {
if (root->children[i]) {
for (tmpp = root->children[i]; tmpp; tmpp = tmpp->next_sibling) {
curoid[curoid_len] = tmpp->value;
if (tmpp->thedata) {
snprintf(buf, sizeof(buf), "%s ", tokenname);
cp = read_config_save_objid(buf+strlen(buf), curoid,
curoid_len+1);
*cp++ = ' ';
*cp = '\0';
if ((*dumpfn)(cp, sizeof(buf) - strlen(buf),
tmpp->thedata, tmpp))
read_config_store(appname, buf);
}
netsnmp_oid_stash_store(tmpp, tokenname, dumpfn,
curoid, curoid_len+1);
}
}
}
}
/** For debugging: dump the netsnmp_oid_stash tree to stdout
@param root The top of the tree
@param prefix a character string prefix printed to the beginning of each line.
*/
void
oid_stash_dump(netsnmp_oid_stash_node *root, char *prefix)
{
char myprefix[MAX_OID_LEN * 4];
netsnmp_oid_stash_node *tmpp;
int prefix_len = strlen(prefix) + 1; /* actually it's +2 */
unsigned int i;
memset(myprefix, ' ', MAX_OID_LEN * 4);
myprefix[prefix_len] = '\0';
for (i = 0; i < root->children_size; i++) {
if (root->children[i]) {
for (tmpp = root->children[i]; tmpp; tmpp = tmpp->next_sibling) {
printf("%s%" NETSNMP_PRIo "d@%d: %s\n", prefix, tmpp->value, i,
(tmpp->thedata) ? "DATA" : "");
oid_stash_dump(tmpp, myprefix);
}
}
}
}
/** Frees the contents of a netsnmp_oid_stash tree.
@param root the top of the tree (or branch to be freed)
@param freefn The function to be called on each data (void *)
pointer. If left NULL the system free() function will be called
*/
void
netsnmp_oid_stash_free(netsnmp_oid_stash_node **root,
NetSNMPStashFreeNode *freefn) {
netsnmp_oid_stash_node *curnode, *tmpp;
unsigned int i;
if (!root || !*root)
return;
/* loop through all our children and free each node */
for (i = 0; i < (*root)->children_size; i++) {
if ((*root)->children[i]) {
for(tmpp = (*root)->children[i]; tmpp; tmpp = curnode) {
if (tmpp->thedata) {
if (freefn)
(*freefn)(tmpp->thedata);
else
free(tmpp->thedata);
}
curnode = tmpp->next_sibling;
netsnmp_oid_stash_free(&tmpp, freefn);
}
}
}
free((*root)->children);
free (*root);
*root = NULL;
}
#else /* NETSNMP_FEATURE_REMOVE_OID_STASH */
netsnmp_feature_unused(oid_stash);
#endif/* NETSNMP_FEATURE_REMOVE_OID_STASH */
#ifndef NETSNMP_FEATURE_REMOVE_OID_STASH_NO_FREE
void
netsnmp_oid_stash_no_free(void *bogus)
{
/* noop */
}
#endif /* NETSNMP_FEATURE_REMOVE_OID_STASH_NO_FREE */
/** @} */