/*
* Portions of this file are subject to the following copyright(s). See
* the Net-SNMP's COPYING file for more details and other copyrights
* that may apply:
*
* Portions of this file are copyrighted by:
* Copyright (c) 2016 VMware, Inc. All rights reserved.
* Use is subject to license terms specified in the COPYING file
* distributed with the Net-SNMP package.
*/
#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-features.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include <net-snmp/agent/row_merge.h>
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
netsnmp_feature_provide(row_merge)
netsnmp_feature_child_of(row_merge, row_merge_all)
netsnmp_feature_child_of(row_merge_all, mib_helpers)
#ifndef NETSNMP_FEATURE_REMOVE_ROW_MERGE
/** @defgroup row_merge row_merge
* Calls sub handlers with request for one row at a time.
* @ingroup utilities
* This helper splits a whole bunch of requests into chunks based on the row
* index that they refer to, and passes all requests for a given row to the lower handlers.
* This is useful for handlers that don't want to process multiple rows at the
* same time, but are happy to iterate through the request list for a single row.
* @{
*/
/** returns a row_merge handler that can be injected into a given
* handler chain.
*/
netsnmp_mib_handler *
netsnmp_get_row_merge_handler(int prefix_len)
{
netsnmp_mib_handler *ret = NULL;
ret = netsnmp_create_handler("row_merge",
netsnmp_row_merge_helper_handler);
if (ret) {
ret->myvoid = (void *)(intptr_t)prefix_len;
}
return ret;
}
/** functionally the same as calling netsnmp_register_handler() but also
* injects a row_merge handler at the same time for you. */
netsnmp_feature_child_of(register_row_merge, row_merge_all)
#ifndef NETSNMP_FEATURE_REMOVE_REGISTER_ROW_MERGE
int
netsnmp_register_row_merge(netsnmp_handler_registration *reginfo)
{
netsnmp_mib_handler *handler;
if (!reginfo)
return MIB_REGISTRATION_FAILED;
handler = netsnmp_get_row_merge_handler(reginfo->rootoid_len+1);
if (handler &&
(netsnmp_inject_handler(reginfo, handler) == SNMPERR_SUCCESS))
return netsnmp_register_handler(reginfo);
snmp_log(LOG_ERR, "failed to register row_merge\n");
netsnmp_handler_free(handler);
netsnmp_handler_registration_free(reginfo);
return MIB_REGISTRATION_FAILED;
}
#endif /* NETSNMP_FEATURE_REMOVE_REGISTER_ROW_MERGE */
static void
_rm_status_free(void *mem)
{
netsnmp_row_merge_status *rm_status = (netsnmp_row_merge_status*)mem;
if (NULL != rm_status->saved_requests)
free(rm_status->saved_requests);
if (NULL != rm_status->saved_status)
free(rm_status->saved_status);
free(mem);
}
/** retrieve row_merge_status
*/
netsnmp_row_merge_status *
netsnmp_row_merge_status_get(netsnmp_handler_registration *reginfo,
netsnmp_agent_request_info *reqinfo,
int create_missing)
{
netsnmp_row_merge_status *rm_status;
char buf[64];
int rc;
/*
* see if we've already been here
*/
rc = snprintf(buf, sizeof(buf), "row_merge:%p", reginfo);
if ((-1 == rc) || ((size_t)rc >= sizeof(buf))) {
snmp_log(LOG_ERR,"error creating key\n");
return NULL;
}
rm_status = (netsnmp_row_merge_status*)netsnmp_agent_get_list_data(reqinfo, buf);
if ((NULL == rm_status) && create_missing) {
netsnmp_data_list *data_list;
rm_status = SNMP_MALLOC_TYPEDEF(netsnmp_row_merge_status);
if (NULL == rm_status) {
snmp_log(LOG_ERR,"error allocating memory\n");
return NULL;
}
data_list = netsnmp_create_data_list(buf, rm_status,
_rm_status_free);
if (NULL == data_list) {
free(rm_status);
return NULL;
}
netsnmp_agent_add_list_data(reqinfo, data_list);
}
return rm_status;
}
/** Determine if this is the first row
*
* returns 1 if this is the first row for this pass of the handler.
*/
int
netsnmp_row_merge_status_first(netsnmp_handler_registration *reginfo,
netsnmp_agent_request_info *reqinfo)
{
netsnmp_row_merge_status *rm_status;
/*
* find status
*/
rm_status = netsnmp_row_merge_status_get(reginfo, reqinfo, 0);
if (NULL == rm_status)
return 0;
return (rm_status->count == 1) ? 1 : (rm_status->current == 1);
}
/** Determine if this is the last row
*
* returns 1 if this is the last row for this pass of the handler.
*/
int
netsnmp_row_merge_status_last(netsnmp_handler_registration *reginfo,
netsnmp_agent_request_info *reqinfo)
{
netsnmp_row_merge_status *rm_status;
/*
* find status
*/
rm_status = netsnmp_row_merge_status_get(reginfo, reqinfo, 0);
if (NULL == rm_status)
return 0;
return (rm_status->count == 1) ? 1 :
(rm_status->current == rm_status->rows);
}
#define ROW_MERGE_WAITING 0
#define ROW_MERGE_ACTIVE 1
#define ROW_MERGE_DONE 2
#define ROW_MERGE_HEAD 3
/** Implements the row_merge handler */
int
netsnmp_row_merge_helper_handler(netsnmp_mib_handler *handler,
netsnmp_handler_registration *reginfo,
netsnmp_agent_request_info *reqinfo,
netsnmp_request_info *requests)
{
netsnmp_request_info *request, **saved_requests;
char *saved_status;
netsnmp_row_merge_status *rm_status;
int i, j, ret, tail, count, final_rc = SNMP_ERR_NOERROR;
/*
* Use the prefix length as supplied during registration, rather
* than trying to second-guess what the MIB implementer wanted.
*/
int SKIP_OID = (int)(intptr_t)handler->myvoid;
DEBUGMSGTL(("helper:row_merge", "Got request (%d): ", SKIP_OID));
DEBUGMSGOID(("helper:row_merge", reginfo->rootoid, reginfo->rootoid_len));
DEBUGMSG(("helper:row_merge", "\n"));
/*
* find or create status
*/
rm_status = netsnmp_row_merge_status_get(reginfo, reqinfo, 1);
/*
* Count the requests, and set up an array to keep
* track of the original order.
*/
for (count = 0, request = requests; request; request = request->next) {
DEBUGIF("helper:row_merge") {
DEBUGMSGTL(("helper:row_merge", " got varbind: "));
DEBUGMSGOID(("helper:row_merge", request->requestvb->name,
request->requestvb->name_length));
DEBUGMSG(("helper:row_merge", "\n"));
}
count++;
}
/*
* Optimization: skip all this if there is just one request
*/
if(count == 1) {
rm_status->count = count;
if (requests->processed)
return SNMP_ERR_NOERROR;
return netsnmp_call_next_handler(handler, reginfo, reqinfo, requests);
}
/*
* we really should only have to do this once, instead of every pass.
* as a precaution, we'll do it every time, but put in some asserts
* to see if we have to.
*/
/*
* if the count changed, re-do everything
*/
if ((0 != rm_status->count) && (rm_status->count != count)) {
/*
* ok, i know next/bulk can cause this condition. Probably
* GET, too. need to rethink this mode counting. maybe
* add the mode to the rm_status structure? xxx-rks
*/
if ((reqinfo->mode != MODE_GET) &&
(reqinfo->mode != MODE_GETNEXT) &&
(reqinfo->mode != MODE_GETBULK)) {
netsnmp_assert((NULL != rm_status->saved_requests) &&
(NULL != rm_status->saved_status));
}
DEBUGMSGTL(("helper:row_merge", "count changed! do over...\n"));
SNMP_FREE(rm_status->saved_requests);
SNMP_FREE(rm_status->saved_status);
rm_status->count = 0;
rm_status->rows = 0;
}
if (0 == rm_status->count) {
/*
* allocate memory for saved structure
*/
rm_status->saved_requests =
(netsnmp_request_info**)calloc(count+1,
sizeof(netsnmp_request_info*));
rm_status->saved_status = (char*)calloc(count,sizeof(char));
}
saved_status = rm_status->saved_status;
saved_requests = rm_status->saved_requests;
/*
* set up saved requests, and set any processed requests to done
*/
i = 0;
for (request = requests; request; request = request->next, i++) {
if (request->processed) {
saved_status[i] = ROW_MERGE_DONE;
DEBUGMSGTL(("helper:row_merge", " skipping processed oid: "));
DEBUGMSGOID(("helper:row_merge", request->requestvb->name,
request->requestvb->name_length));
DEBUGMSG(("helper:row_merge", "\n"));
}
else
saved_status[i] = ROW_MERGE_WAITING;
if (0 != rm_status->count)
netsnmp_assert(saved_requests[i] == request);
saved_requests[i] = request;
saved_requests[i]->prev = NULL;
}
saved_requests[i] = NULL;
/*
* Note that saved_requests[count] is valid
* (because of the 'count+1' in the calloc above),
* but NULL (since it's past the end of the list).
* This simplifies the re-linking later.
*/
/*
* Work through the (unprocessed) requests in order.
* For each of these, search the rest of the list for any
* matching indexes, and link them into a new list.
*/
for (i=0; i<count; i++) {
if (saved_status[i] != ROW_MERGE_WAITING)
continue;
if (0 == rm_status->count)
rm_status->rows++;
DEBUGMSGTL(("helper:row_merge", " row %d oid[%d]: ", rm_status->rows, i));
DEBUGMSGOID(("helper:row_merge", saved_requests[i]->requestvb->name,
saved_requests[i]->requestvb->name_length));
DEBUGMSG(("helper:row_merge", "\n"));
saved_requests[i]->next = NULL;
saved_status[i] = ROW_MERGE_HEAD;
tail = i;
for (j=i+1; j<count; j++) {
if (saved_status[j] != ROW_MERGE_WAITING)
continue;
DEBUGMSGTL(("helper:row_merge", "? oid[%d]: ", j));
DEBUGMSGOID(("helper:row_merge",
saved_requests[j]->requestvb->name,
saved_requests[j]->requestvb->name_length));
if (!snmp_oid_compare(
saved_requests[i]->requestvb->name+SKIP_OID,
saved_requests[i]->requestvb->name_length-SKIP_OID,
saved_requests[j]->requestvb->name+SKIP_OID,
saved_requests[j]->requestvb->name_length-SKIP_OID)) {
DEBUGMSG(("helper:row_merge", " match\n"));
saved_requests[tail]->next = saved_requests[j];
saved_requests[j]->next = NULL;
saved_requests[j]->prev = saved_requests[tail];
saved_status[j] = ROW_MERGE_ACTIVE;
tail = j;
}
else
DEBUGMSG(("helper:row_merge", " no match\n"));
}
}
/*
* not that we have a list for each row, call next handler...
*/
if (0 == rm_status->count)
rm_status->count = count;
rm_status->current = 0;
for (i=0; i<count; i++) {
if (saved_status[i] != ROW_MERGE_HEAD)
continue;
/*
* found the head of a new row,
* call the next handler with this list
*/
rm_status->current++;
ret = netsnmp_call_next_handler(handler, reginfo, reqinfo,
saved_requests[i]);
if (ret != SNMP_ERR_NOERROR) {
snmp_log(LOG_WARNING,
"bad rc (%d) from next handler in row_merge\n", ret);
if (SNMP_ERR_NOERROR == final_rc)
final_rc = ret;
}
}
/*
* restore original linked list
*/
for (i=0; i<count; i++) {
saved_requests[i]->next = saved_requests[i+1];
if (i>0)
saved_requests[i]->prev = saved_requests[i-1];
}
return final_rc;
}
/**
* initializes the row_merge helper which then registers a row_merge
* handler as a run-time injectable handler for configuration file
* use.
*/
void
netsnmp_init_row_merge(void)
{
netsnmp_register_handler_by_name("row_merge",
netsnmp_get_row_merge_handler(-1));
}
#else /* NETSNMP_FEATURE_REMOVE_ROW_MERGE */
netsnmp_feature_unused(row_merge);
#endif /* NETSNMP_FEATURE_REMOVE_ROW_MERGE */
/** @} */