snmp/mib采用子代理模式，编码，部署(二)---多实例处理

snmp/mib采用子代理模式，编码，部署(二)---多实例处理
0.本文针对net-snmp中mib表做处理，即单张表对应后台多个实例.
1.源代码生成
拷贝GSC-MIB-0805.txt到/usr/share/snmp/mibs(具体看自己安装目录，如果找不到，下面解析mib时会报错报出路径)
重启snmpd服务，service restart snmpd
snmptranslate -Tp -IR GSC-MIB::atcaBoardTable //针对table表格实现

[root@VM-4-14-opencloudos mibs]# snmptranslate -Tp -IR GSC-MIB::atcaBoardTable
+--atcaBoardTable(5)
|
+--atcaBoardEntry(1)
| Index: atcaBoardInfoIndex
|
+-- ---- Unsigned atcaBoardInfoIndex(1)
| Range: 1..65535
+-- CR-- String atcaBoardCPU1Temperature(2)
+-- CR-- String atcaBoardCPU2Temperature(3)
+-- CR-- String atcaBoardPowerState(4)
+-- CR-- String atcaBoardRunSoftwareName(5)
+-- CR-- String atcaBoardCpuUtillization(6)
+-- CR-- String atcaBoardMemoryUtilization(7)
+-- CR-- String atcaBoardDiskUtilization(8)
+-- CR-- String atcaBoardPowerValue(9)

   至此mib解析成功，下面来生成表格处理迭代器代码.


2.代码生成
mib2c mib2c.iterate.conf GSC-MIB::atcaBoardTable
出现很多选项，自己可以看，选择合适的，这里我们选择最灵活的一种方式迭代器方式：2，2，1，1
[root@VM-4-14-opencloudos home]# mib2c mib2c.iterate.conf GSC-MIB::atcaBoardTable
Replacing previous mibNode mib2c.iterate.conf with GSC-MIB::atcaBoardTable
writing to -
mib2c has multiple configuration files depending on the type of
code you need to write. You must pick one depending on your need.

You requested mib2c to be run on the following part of the MIB tree:
OID: atcaBoardTable
numeric translation: .1.3.6.1.4.1.12001.5.5
number of scalars within: 0
number of tables within: 1
number of notifications within: 0

First, do you want to generate code that is compatible with the
ucd-snmp 4.X line of code, or code for the newer Net-SNMP 5.X code
base (which provides a much greater choice of APIs to pick from). You
can also generate C-header files containing define statements for
column numbers, enums, etc. Or do you simply want to translate the
MIB structures into documentation?

1) ucd-snmp style code
2) Net-SNMP style code
3) Generate header files
4) Generate documentation

Select your choice : 2

**********************************************************************
GENERATING CODE FOR TABLES:
**********************************************************************

The Net-SNMP agent API is extremely extensive and, in fact, lets
each programmer write agent code according to the style that works
best for them based on their experience and their preference. We're
going to ask you a serious of questions that will help mib2c
generate code that best suits *your* needs, as the programmer that
will be responsible for taking the code and further refining it. If
you don't like how the results look, you are always welcome to
re-run mib2c and select a different set of options.

There are essentially two tasks involved in processing requests
for OIDs within a MIB table - firstly identifying the relevant row
of the table for a given request, and then returning (or updating)
the appropriate column value within that row. Many MIB tables model
the state of some external system (the kernel, a device, processes,
etc), and the MIB implementation module (the code we're about to
produce a template for) acts as an interface between this underlying
system and the SNMP side. Other tables hold data internally that is
only available within the agent itself, or at least the master copy
of the data is held within the agent.

There are a number of different code templates that can be used to
implement MIB tables, using various approaches to these two tasks.

There are three basic approaches to identifying the relevant row:

1) Pass the request through to the table-specific code, and
identify the requested row there (for both GET and GETNEXT
requests). This is typically the most efficient way to get
up-to-date information, but relies on suitable
(programmer-provided) code within the MIB handler.
Most importantly, you should be an expert to use this choice.

This will produce code based on the table_dataset handler.

2) Have table-specific code to provide information about which
rows exist in the table (by iterating through them in turn),
but utilise standard helper code to select the appropriate
row for a given request. This is particularly suitable for
tables where the data is naturally stored in a "random" order
(or differently to the MIB table index), or where rows are
frequently added to or removed from the table.

However searching for the requested row is not very efficient,
and performance can be slow - particularly for large tables with
many rows.

3) Hold a locally cached copy of the contents of the table (or at
least a cache of which rows are valid), and utilise standard
helper code to select the appropriate row. This is
significantly faster than the iterator-based approach, but
cached data is inevitably slightly "stale" with respect to the
data from the underlying system being managed. This approach,
since it relies on caching of data, is also results in a larger
memory footprint. It is less appropriate for tables where rows
are frequently added or removed externally to the agent (i.e.,
not via SNMP requests).

This approach can also be used where _all_ use of the table is
via SNMP, and there is no external "underlying system". In
this case, the local cache is the canonical version of the
table.

4) Do not generate code for the tables.

Select the option that best fits your requirements: 2

Having identified the appropriate row for a given request, there are
three basic styles of code for returning (or updating) the requested
column value from within this row:

1) A single handler routine, which contains all the code needed to
handle GET and SET requests for each of the column objects.

The code typically looks like a single function with a large 'case'
statement covering each of the columns.

This will produce code based on the 'iterator' hepler.

2) A set of individual routines, each of which is concerned
with a particular aspect of processing the request.
Each column object within the table has one routine for
retrieving the current value, and another for setting a new one.

This will produce code based on the 'iterate_access' hepler.

3) A (different) set of individual routines, each of which is
smaller and more tightly focused than the code generated by
style 2. The aim here is to reduce the amount of SNMP specific
knowledge required to implement a module, and hide much of the
SNMP terminology and processing within standard generated code
(which can simply be used sight unseen).

This will produce code based on the 'mfd' hepler ('MIB for Dummies').

4) Do not generate code for the tables.

(In all cases, GETNEXT requests are automatically converted
into the equivalent GET request, so the MIB specific code
need only be concerned with GET and SET requests.).

Select the code style you wish to use: 1

The same template code can be generated using
mib2c -c mib2c.iterate.conf atcaBoardTable
This framework can work in one of two ways:

1) Hold a local cached copy of some external data
which is then used to service incoming requests.

2) Query the external data directly for each request.

The first is typically more efficient, but results in
slightly "stale" data (depending on the expiration timeout
for the cache) and greater memory usage. The second can
provide more up-to-date information, but at the cost of
higher processing overheads.

Which is more appropriate for your needs?
Select your choice : 1

writing to atcaBoardTable.h
writing to atcaBoardTable.c

**********************************************************************
* NOTE WELL: The code generated by mib2c is only a template. *YOU* *
* must fill in the code before it'll work most of the time. In many *
* cases, spots that MUST be edited within the files are marked with *
* /* XXX */ or /* TODO */ comments. *
**********************************************************************
running indent on atcaBoardTable.h
running indent on atcaBoardTable.c

3.代码修改
其中迭代器产生的table并不是必须要使用，我们需要的是它的框架代码。可以用自己定义的数据来替代table表，也可以在其他业务代码时插入table表，在snmp请求中查询
table表，本代码中实例只有6个，只使用table表存储index，其余字段使用自定义数组存储数据。贴上前后代码可使用merage比较。
3.1 原有代码
/*
* Note: this file originally auto-generated by mib2c
* using mib2c.iterate.conf
*/

#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include "atcaBoardTable.h"

/** Initializes the atcaBoardTable module */
void
init_atcaBoardTable(void)
{
/* here we initialize all the tables we're planning on supporting */
initialize_table_atcaBoardTable();
}

/** Initialize the atcaBoardTable table by defining its contents and how it's structured */
void
initialize_table_atcaBoardTable(void)
{
const oid atcaBoardTable_oid[] = {1,3,6,1,4,1,12001,5,5};
const size_t atcaBoardTable_oid_len = OID_LENGTH(atcaBoardTable_oid);
netsnmp_handler_registration *reg;
netsnmp_iterator_info *iinfo;
netsnmp_table_registration_info *table_info;

DEBUGMSGTL(("atcaBoardTable:init", "initializing table atcaBoardTable\n"));

reg = netsnmp_create_handler_registration(
"atcaBoardTable", atcaBoardTable_handler,
atcaBoardTable_oid, atcaBoardTable_oid_len,
HANDLER_CAN_RWRITE
);

table_info = SNMP_MALLOC_TYPEDEF( netsnmp_table_registration_info );
netsnmp_table_helper_add_indexes(table_info,
ASN_UNSIGNED, /* index: atcaBoardInfoIndex */
0);
table_info->min_column = COLUMN_ATCABOARDCPU1TEMPERATURE;
table_info->max_column = COLUMN_ATCABOARDPOWERVALUE;

iinfo = SNMP_MALLOC_TYPEDEF( netsnmp_iterator_info );
iinfo->get_first_data_point = atcaBoardTable_get_first_data_point;
iinfo->get_next_data_point = atcaBoardTable_get_next_data_point;
iinfo->table_reginfo = table_info;

netsnmp_register_table_iterator( reg, iinfo );
netsnmp_inject_handler_before( reg,
netsnmp_get_cache_handler(ATCABOARDTABLE_TIMEOUT,
atcaBoardTable_load, atcaBoardTable_free,
atcaBoardTable_oid, atcaBoardTable_oid_len),
TABLE_ITERATOR_NAME);

/* Initialise the contents of the table here */
}

/* Typical data structure for a row entry */
struct atcaBoardTable_entry {
/* Index values */
u_long atcaBoardInfoIndex;

/* Column values */
char atcaBoardCPU1Temperature[NNN];
size_t atcaBoardCPU1Temperature_len;
char old_atcaBoardCPU1Temperature[NNN];
size_t old_atcaBoardCPU1Temperature_len;
char atcaBoardCPU2Temperature[NNN];
size_t atcaBoardCPU2Temperature_len;
char old_atcaBoardCPU2Temperature[NNN];
size_t old_atcaBoardCPU2Temperature_len;
char atcaBoardPowerState[NNN];
size_t atcaBoardPowerState_len;
char old_atcaBoardPowerState[NNN];
size_t old_atcaBoardPowerState_len;
char atcaBoardRunSoftwareName[NNN];
size_t atcaBoardRunSoftwareName_len;
char old_atcaBoardRunSoftwareName[NNN];
size_t old_atcaBoardRunSoftwareName_len;
char atcaBoardCpuUtillization[NNN];
size_t atcaBoardCpuUtillization_len;
char old_atcaBoardCpuUtillization[NNN];
size_t old_atcaBoardCpuUtillization_len;
char atcaBoardMemoryUtilization[NNN];
size_t atcaBoardMemoryUtilization_len;
char old_atcaBoardMemoryUtilization[NNN];
size_t old_atcaBoardMemoryUtilization_len;
char atcaBoardDiskUtilization[NNN];
size_t atcaBoardDiskUtilization_len;
char old_atcaBoardDiskUtilization[NNN];
size_t old_atcaBoardDiskUtilization_len;
char atcaBoardPowerValue[NNN];
size_t atcaBoardPowerValue_len;
char old_atcaBoardPowerValue[NNN];
size_t old_atcaBoardPowerValue_len;

/* Illustrate using a simple linked list */
int valid;
struct atcaBoardTable_entry *next;
};

struct atcaBoardTable_entry *atcaBoardTable_head;

/* create a new row in the (unsorted) table */
struct atcaBoardTable_entry *
atcaBoardTable_createEntry(
u_long atcaBoardInfoIndex,
) {
struct atcaBoardTable_entry *entry;

entry = SNMP_MALLOC_TYPEDEF(struct atcaBoardTable_entry);
if (!entry)
return NULL;

entry->atcaBoardInfoIndex = atcaBoardInfoIndex;
entry->next = atcaBoardTable_head;
atcaBoardTable_head = entry;
return entry;
}

/* remove a row from the table */
void
atcaBoardTable_removeEntry( struct atcaBoardTable_entry *entry ) {
struct atcaBoardTable_entry *ptr, *prev;

if (!entry)
return; /* Nothing to remove */

for ( ptr = atcaBoardTable_head, prev = NULL;
ptr != NULL;
prev = ptr, ptr = ptr->next ) {
if ( ptr == entry )
break;
}
if ( !ptr )
return; /* Can't find it */

if ( prev == NULL )
atcaBoardTable_head = ptr->next;
else
prev->next = ptr->next;

SNMP_FREE( entry ); /* XXX - release any other internal resources */
}

/* Example cache handling - set up linked list from a suitable file */
int
atcaBoardTable_load( netsnmp_cache *cache, void *vmagic ) {
FILE *fp;
struct atcaBoardTable_entry *this;
char buf[STRMAX];

/* The basic load routine template assumes that the data to
be reported is held in a file - with one row of the file
for each row of the table.
If your data is available via a different API, you
should amend this initial block (and the control of the
'while' loop) accordingly.
'XXX' marks where the template is incomplete and
code will definitely need to be added. */

fp = fopen( "/data/for/atcaBoardTable", "r" );
if ( !fp ) {
return -1;
}
while ( fgets( buf, STRMAX, fp )) {
this = SNMP_MALLOC_TYPEDEF( struct atcaBoardTable_entry );
/* XXX - Unpick 'buf' to extract the individual field values
and then populate the 'this' data structure with them */

this->next = atcaBoardTable_head;
atcaBoardTable_head = this; /* Iterate helper is fine with unordered lists! */
}
fclose(fp);
return 0; /* OK */
}

void
atcaBoardTable_free( netsnmp_cache *cache, void *vmagic ) {
struct atcaBoardTable_entry *this, *that;

for ( this = atcaBoardTable_head; this; this=that ) {
that = this->next;
SNMP_FREE( this ); /* XXX - release any other internal resources */
}
atcaBoardTable_head = NULL;
}

/* Example iterator hook routines - using 'get_next' to do most of the work */
netsnmp_variable_list *
atcaBoardTable_get_first_data_point(void **my_loop_context,
void **my_data_context,
netsnmp_variable_list *put_index_data,
netsnmp_iterator_info *mydata)
{
*my_loop_context = atcaBoardTable_head;
return atcaBoardTable_get_next_data_point(my_loop_context, my_data_context,
put_index_data, mydata );
}

netsnmp_variable_list *
atcaBoardTable_get_next_data_point(void **my_loop_context,
void **my_data_context,
netsnmp_variable_list *put_index_data,
netsnmp_iterator_info *mydata)
{
struct atcaBoardTable_entry *entry = (struct atcaBoardTable_entry *)*my_loop_context;
netsnmp_variable_list *idx = put_index_data;

if ( entry ) {
snmp_set_var_typed_integer( idx, ASN_UNSIGNED, entry->atcaBoardInfoIndex );
idx = idx->next_variable;
*my_data_context = (void *)entry;
*my_loop_context = (void *)entry->next;
return put_index_data;
} else {
return NULL;
}
}

netsnmp_request_info *request;
netsnmp_table_request_info *table_info;
struct atcaBoardTable_entry *table_entry;

DEBUGMSGTL(("atcaBoardTable:handler", "Processing request (%d)\n", reqinfo->mode));

/*
* Write-support
*/
case MODE_SET_RESERVE1:
for (request=requests; request; request=request->next) {
table_entry = (struct atcaBoardTable_entry *)
netsnmp_extract_iterator_context(request);
table_info = netsnmp_extract_table_info( request);

switch (table_info->colnum) {
case COLUMN_ATCABOARDCPU1TEMPERATURE:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardCPU1Temperature));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
case COLUMN_ATCABOARDCPU2TEMPERATURE:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardCPU2Temperature));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
case COLUMN_ATCABOARDPOWERSTATE:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardPowerState));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
case COLUMN_ATCABOARDRUNSOFTWARENAME:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardRunSoftwareName));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
case COLUMN_ATCABOARDCPUUTILLIZATION:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardCpuUtillization));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
case COLUMN_ATCABOARDMEMORYUTILIZATION:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardMemoryUtilization));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
case COLUMN_ATCABOARDDISKUTILIZATION:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardDiskUtilization));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
case COLUMN_ATCABOARDPOWERVALUE:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardPowerValue));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
default:
netsnmp_set_request_error( reqinfo, request,
SNMP_ERR_NOTWRITABLE );
return SNMP_ERR_NOERROR;
}
}
break;

case MODE_SET_RESERVE2:
for (request=requests; request; request=request->next) {
table_entry = (struct atcaBoardTable_entry *)
netsnmp_extract_iterator_context(request);
table_info = netsnmp_extract_table_info( request);

switch (table_info->colnum) {
case COLUMN_ATCABOARDCPU1TEMPERATURE:
case COLUMN_ATCABOARDCPU2TEMPERATURE:
case COLUMN_ATCABOARDPOWERSTATE:
case COLUMN_ATCABOARDRUNSOFTWARENAME:
case COLUMN_ATCABOARDCPUUTILLIZATION:
case COLUMN_ATCABOARDMEMORYUTILIZATION:
case COLUMN_ATCABOARDDISKUTILIZATION:
case COLUMN_ATCABOARDPOWERVALUE:
if ( !table_row ) {
table_row = atcaBoardTable_createEntry(
, *table_info->indexes->val.integer
);
if (table_row) {
netsnmp_insert_iterator_context( request, table_row );
} else {
netsnmp_set_request_error( reqinfo, request,
SNMP_ERR_RESOURCEUNAVAILABLE );
return SNMP_ERR_NOERROR;
}
}
break;
}
}
break;

case MODE_SET_FREE:
for (request=requests; request; request=request->next) {
table_entry = (struct atcaBoardTable_entry *)
netsnmp_extract_iterator_context(request);
table_info = netsnmp_extract_table_info( request);

switch (table_info->colnum) {
case COLUMN_ATCABOARDCPU1TEMPERATURE:
case COLUMN_ATCABOARDCPU2TEMPERATURE:
case COLUMN_ATCABOARDPOWERSTATE:
case COLUMN_ATCABOARDRUNSOFTWARENAME:
case COLUMN_ATCABOARDCPUUTILLIZATION:
case COLUMN_ATCABOARDMEMORYUTILIZATION:
case COLUMN_ATCABOARDDISKUTILIZATION:
case COLUMN_ATCABOARDPOWERVALUE:
if ( table_entry && !table_entry->valid ) {
atcaBoardTable_removeEntry(table_data, table_row );
}
break;
}
}
break;

case MODE_SET_ACTION:
for (request=requests; request; request=request->next) {
table_entry = (struct atcaBoardTable_entry *)
netsnmp_extract_iterator_context(request);
table_info = netsnmp_extract_table_info( request);

switch (table_info->colnum) {
case COLUMN_ATCABOARDCPU1TEMPERATURE:
memcpy( table_entry->old_atcaBoardCPU1Temperature,
table_entry->atcaBoardCPU1Temperature,
sizeof(table_entry->atcaBoardCPU1Temperature));
table_entry->old_atcaBoardCPU1Temperature_len =
table_entry->atcaBoardCPU1Temperature_len;
memset( table_entry->atcaBoardCPU1Temperature, 0,
sizeof(table_entry->atcaBoardCPU1Temperature));
memcpy( table_entry->atcaBoardCPU1Temperature,
request->requestvb->val.string,
request->requestvb->val_len);
table_entry->atcaBoardCPU1Temperature_len =
request->requestvb->val_len;
break;
case COLUMN_ATCABOARDCPU2TEMPERATURE:
memcpy( table_entry->old_atcaBoardCPU2Temperature,
table_entry->atcaBoardCPU2Temperature,
sizeof(table_entry->atcaBoardCPU2Temperature));
table_entry->old_atcaBoardCPU2Temperature_len =
table_entry->atcaBoardCPU2Temperature_len;
memset( table_entry->atcaBoardCPU2Temperature, 0,
sizeof(table_entry->atcaBoardCPU2Temperature));
memcpy( table_entry->atcaBoardCPU2Temperature,
request->requestvb->val.string,
request->requestvb->val_len);
table_entry->atcaBoardCPU2Temperature_len =
request->requestvb->val_len;
break;
case COLUMN_ATCABOARDPOWERSTATE:
memcpy( table_entry->old_atcaBoardPowerState,
table_entry->atcaBoardPowerState,
sizeof(table_entry->atcaBoardPowerState));
table_entry->old_atcaBoardPowerState_len =
table_entry->atcaBoardPowerState_len;
memset( table_entry->atcaBoardPowerState, 0,
sizeof(table_entry->atcaBoardPowerState));
memcpy( table_entry->atcaBoardPowerState,
request->requestvb->val.string,
request->requestvb->val_len);
table_entry->atcaBoardPowerState_len =
request->requestvb->val_len;
break;
case COLUMN_ATCABOARDRUNSOFTWARENAME:
memcpy( table_entry->old_atcaBoardRunSoftwareName,
table_entry->atcaBoardRunSoftwareName,
sizeof(table_entry->atcaBoardRunSoftwareName));
table_entry->old_atcaBoardRunSoftwareName_len =
table_entry->atcaBoardRunSoftwareName_len;
memset( table_entry->atcaBoardRunSoftwareName, 0,
sizeof(table_entry->atcaBoardRunSoftwareName));
memcpy( table_entry->atcaBoardRunSoftwareName,
request->requestvb->val.string,
request->requestvb->val_len);
table_entry->atcaBoardRunSoftwareName_len =
request->requestvb->val_len;
break;
case COLUMN_ATCABOARDCPUUTILLIZATION:
memcpy( table_entry->old_atcaBoardCpuUtillization,
table_entry->atcaBoardCpuUtillization,
sizeof(table_entry->atcaBoardCpuUtillization));
table_entry->old_atcaBoardCpuUtillization_len =
table_entry->atcaBoardCpuUtillization_len;
memset( table_entry->atcaBoardCpuUtillization, 0,
sizeof(table_entry->atcaBoardCpuUtillization));
memcpy( table_entry->atcaBoardCpuUtillization,
request->requestvb->val.string,
request->requestvb->val_len);
table_entry->atcaBoardCpuUtillization_len =
request->requestvb->val_len;
break;
case COLUMN_ATCABOARDMEMORYUTILIZATION:
memcpy( table_entry->old_atcaBoardMemoryUtilization,
table_entry->atcaBoardMemoryUtilization,
sizeof(table_entry->atcaBoardMemoryUtilization));
table_entry->old_atcaBoardMemoryUtilization_len =
table_entry->atcaBoardMemoryUtilization_len;
memset( table_entry->atcaBoardMemoryUtilization, 0,
sizeof(table_entry->atcaBoardMemoryUtilization));
memcpy( table_entry->atcaBoardMemoryUtilization,
request->requestvb->val.string,
request->requestvb->val_len);
table_entry->atcaBoardMemoryUtilization_len =
request->requestvb->val_len;
break;
case COLUMN_ATCABOARDDISKUTILIZATION:
memcpy( table_entry->old_atcaBoardDiskUtilization,
table_entry->atcaBoardDiskUtilization,
sizeof(table_entry->atcaBoardDiskUtilization));
table_entry->old_atcaBoardDiskUtilization_len =
table_entry->atcaBoardDiskUtilization_len;
memset( table_entry->atcaBoardDiskUtilization, 0,
sizeof(table_entry->atcaBoardDiskUtilization));
memcpy( table_entry->atcaBoardDiskUtilization,
request->requestvb->val.string,
request->requestvb->val_len);
table_entry->atcaBoardDiskUtilization_len =
request->requestvb->val_len;
break;
case COLUMN_ATCABOARDPOWERVALUE:
memcpy( table_entry->old_atcaBoardPowerValue,
table_entry->atcaBoardPowerValue,
sizeof(table_entry->atcaBoardPowerValue));
table_entry->old_atcaBoardPowerValue_len =
table_entry->atcaBoardPowerValue_len;
memset( table_entry->atcaBoardPowerValue, 0,
sizeof(table_entry->atcaBoardPowerValue));
memcpy( table_entry->atcaBoardPowerValue,
request->requestvb->val.string,
request->requestvb->val_len);
table_entry->atcaBoardPowerValue_len =
request->requestvb->val_len;
break;
}
}
break;

case MODE_SET_UNDO:
for (request=requests; request; request=request->next) {
table_entry = (struct atcaBoardTable_entry *)
netsnmp_extract_iterator_context(request);
table_info = netsnmp_extract_table_info( request);

switch (table_info->colnum) {
case COLUMN_ATCABOARDCPU1TEMPERATURE:
if ( table_entry && !table_entry->valid ) {
atcaBoardTable_removeEntry(table_data, table_row );
} else {
memcpy( table_entry->atcaBoardCPU1Temperature,
table_entry->old_atcaBoardCPU1Temperature,
sizeof(table_entry->atcaBoardCPU1Temperature));
memset( table_entry->old_atcaBoardCPU1Temperature, 0,
sizeof(table_entry->atcaBoardCPU1Temperature));
table_entry->atcaBoardCPU1Temperature_len =
table_entry->old_atcaBoardCPU1Temperature_len;
}
break;
case COLUMN_ATCABOARDCPU2TEMPERATURE:
if ( table_entry && !table_entry->valid ) {
atcaBoardTable_removeEntry(table_data, table_row );
} else {
memcpy( table_entry->atcaBoardCPU2Temperature,
table_entry->old_atcaBoardCPU2Temperature,
sizeof(table_entry->atcaBoardCPU2Temperature));
memset( table_entry->old_atcaBoardCPU2Temperature, 0,
sizeof(table_entry->atcaBoardCPU2Temperature));
table_entry->atcaBoardCPU2Temperature_len =
table_entry->old_atcaBoardCPU2Temperature_len;
}
break;
case COLUMN_ATCABOARDPOWERSTATE:
if ( table_entry && !table_entry->valid ) {
atcaBoardTable_removeEntry(table_data, table_row );
} else {
memcpy( table_entry->atcaBoardPowerState,
table_entry->old_atcaBoardPowerState,
sizeof(table_entry->atcaBoardPowerState));
memset( table_entry->old_atcaBoardPowerState, 0,
sizeof(table_entry->atcaBoardPowerState));
table_entry->atcaBoardPowerState_len =
table_entry->old_atcaBoardPowerState_len;
}
break;
case COLUMN_ATCABOARDRUNSOFTWARENAME:
if ( table_entry && !table_entry->valid ) {
atcaBoardTable_removeEntry(table_data, table_row );
} else {
memcpy( table_entry->atcaBoardRunSoftwareName,
table_entry->old_atcaBoardRunSoftwareName,
sizeof(table_entry->atcaBoardRunSoftwareName));
memset( table_entry->old_atcaBoardRunSoftwareName, 0,
sizeof(table_entry->atcaBoardRunSoftwareName));
table_entry->atcaBoardRunSoftwareName_len =
table_entry->old_atcaBoardRunSoftwareName_len;
}
break;
case COLUMN_ATCABOARDCPUUTILLIZATION:
if ( table_entry && !table_entry->valid ) {
atcaBoardTable_removeEntry(table_data, table_row );
} else {
memcpy( table_entry->atcaBoardCpuUtillization,
table_entry->old_atcaBoardCpuUtillization,
sizeof(table_entry->atcaBoardCpuUtillization));
memset( table_entry->old_atcaBoardCpuUtillization, 0,
sizeof(table_entry->atcaBoardCpuUtillization));
table_entry->atcaBoardCpuUtillization_len =
table_entry->old_atcaBoardCpuUtillization_len;
}
break;
case COLUMN_ATCABOARDMEMORYUTILIZATION:
if ( table_entry && !table_entry->valid ) {
atcaBoardTable_removeEntry(table_data, table_row );
} else {
memcpy( table_entry->atcaBoardMemoryUtilization,
table_entry->old_atcaBoardMemoryUtilization,
sizeof(table_entry->atcaBoardMemoryUtilization));
memset( table_entry->old_atcaBoardMemoryUtilization, 0,
sizeof(table_entry->atcaBoardMemoryUtilization));
table_entry->atcaBoardMemoryUtilization_len =
table_entry->old_atcaBoardMemoryUtilization_len;
}
break;
case COLUMN_ATCABOARDDISKUTILIZATION:
if ( table_entry && !table_entry->valid ) {
atcaBoardTable_removeEntry(table_data, table_row );
} else {
memcpy( table_entry->atcaBoardDiskUtilization,
table_entry->old_atcaBoardDiskUtilization,
sizeof(table_entry->atcaBoardDiskUtilization));
memset( table_entry->old_atcaBoardDiskUtilization, 0,
sizeof(table_entry->atcaBoardDiskUtilization));
table_entry->atcaBoardDiskUtilization_len =
table_entry->old_atcaBoardDiskUtilization_len;
}
break;
case COLUMN_ATCABOARDPOWERVALUE:
if ( table_entry && !table_entry->valid ) {
atcaBoardTable_removeEntry(table_data, table_row );
} else {
memcpy( table_entry->atcaBoardPowerValue,
table_entry->old_atcaBoardPowerValue,
sizeof(table_entry->atcaBoardPowerValue));
memset( table_entry->old_atcaBoardPowerValue, 0,
sizeof(table_entry->atcaBoardPowerValue));
table_entry->atcaBoardPowerValue_len =
table_entry->old_atcaBoardPowerValue_len;
}
break;
}
}
break;

case MODE_SET_COMMIT:
for (request=requests; request; request=request->next) {
table_entry = (struct atcaBoardTable_entry *)
netsnmp_extract_iterator_context(request);
table_info = netsnmp_extract_table_info( request);

switch (table_info->colnum) {
case COLUMN_ATCABOARDCPU1TEMPERATURE:
case COLUMN_ATCABOARDCPU2TEMPERATURE:
case COLUMN_ATCABOARDPOWERSTATE:
case COLUMN_ATCABOARDRUNSOFTWARENAME:
case COLUMN_ATCABOARDCPUUTILLIZATION:
case COLUMN_ATCABOARDMEMORYUTILIZATION:
case COLUMN_ATCABOARDDISKUTILIZATION:
case COLUMN_ATCABOARDPOWERVALUE:
if ( table_entry && !table_entry->valid ) {
table_entry->valid = 1;
}
}
}
break;
}
return SNMP_ERR_NOERROR;
}

3.2 修改后代码
/*
* Note: this file originally auto-generated by mib2c
* using mib2c.iterate.conf
* add by zhuwei 20250331
*/

#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include "atcaBoardTable.h"

#include "atca_data.h"

#define NNN 32
#define STRMAX 256

extern ATCA_STATUS_INFO_T gAtcaStatusInfo;

struct atcaBoardTable_entry *
atcaBoardTable_createNewEntry(u_long atcaBoardInfoIndex,struct atcaBoardTable_entry *entryInsert) ;
struct atcaBoardTable_entry *atcaBoardTable_createEntry(u_long atcaBoardInfoIndex) ;
/** Initializes the atcaBoardTable module */
void
init_atcaBoardTable(void)
{
/* here we initialize all the tables we're planning on supporting */
initialize_table_atcaBoardTable();
}

DEBUGMSGTL(("atcaBoardTable:init", "initializing table atcaBoardTable\n"));

reg = netsnmp_create_handler_registration(
"atcaBoardTable", atcaBoardTable_handler,
atcaBoardTable_oid, atcaBoardTable_oid_len,
HANDLER_CAN_RWRITE
);

table_info = SNMP_MALLOC_TYPEDEF( netsnmp_table_registration_info );
netsnmp_table_helper_add_indexes(table_info,
ASN_UNSIGNED, /* index: atcaBoardInfoIndex */
0);
table_info->min_column = COLUMN_ATCABOARDINFOINDEX;
table_info->max_column = COLUMN_ATCABOARDPOWERVALUE;

iinfo = SNMP_MALLOC_TYPEDEF( netsnmp_iterator_info );
iinfo->get_first_data_point = atcaBoardTable_get_first_data_point;
iinfo->get_next_data_point = atcaBoardTable_get_next_data_point;
iinfo->table_reginfo = table_info;

netsnmp_register_table_iterator( reg, iinfo );
netsnmp_inject_handler_before( reg,
netsnmp_get_cache_handler(ATCABOARDTABLE_TIMEOUT,
atcaBoardTable_load, atcaBoardTable_free,
atcaBoardTable_oid, atcaBoardTable_oid_len),
TABLE_ITERATOR_NAME);

/* Initialise the contents of the table here */
   atcaBoardTable_createEntry(1);
   atcaBoardTable_createEntry(2);
   atcaBoardTable_createEntry(3);
   atcaBoardTable_createEntry(4);
   atcaBoardTable_createEntry(5);
   atcaBoardTable_createEntry(6);
}

/* Typical data structure for a row entry */
struct atcaBoardTable_entry {
/* Index values */
u_long atcaBoardInfoIndex;

/* Illustrate using a simple linked list */
int valid;
struct atcaBoardTable_entry *next;
};

struct atcaBoardTable_entry *atcaBoardTable_head;

/* create a new row in the (unsorted) table */
struct atcaBoardTable_entry *
atcaBoardTable_createEntry(u_long atcaBoardInfoIndex)
{
struct atcaBoardTable_entry *entry;

entry = SNMP_MALLOC_TYPEDEF(struct atcaBoardTable_entry);
if (!entry)
return NULL;

entry->atcaBoardInfoIndex = atcaBoardInfoIndex;
entry->next = atcaBoardTable_head;
atcaBoardTable_head = entry;
return entry;
}

struct atcaBoardTable_entry *
atcaBoardTable_createNewEntry(u_long atcaBoardInfoIndex,struct atcaBoardTable_entry *entryInsert)
{
struct atcaBoardTable_entry *entry;

entry = SNMP_MALLOC_TYPEDEF(struct atcaBoardTable_entry);
if (!entry)
return NULL;

*entry = *entryInsert;
entry->atcaBoardInfoIndex = atcaBoardInfoIndex;
entry->next = atcaBoardTable_head;
atcaBoardTable_head = entry;
return entry;
}

/* remove a row from the table */
void
atcaBoardTable_removeEntry( struct atcaBoardTable_entry *entry ) {
struct atcaBoardTable_entry *ptr, *prev;

if (!entry)
return; /* Nothing to remove */

for ( ptr = atcaBoardTable_head, prev = NULL;
ptr != NULL;
prev = ptr, ptr = ptr->next ) {
if ( ptr == entry )
break;
}
if ( !ptr )
return; /* Can't find it */

if ( prev == NULL )
atcaBoardTable_head = ptr->next;
else
prev->next = ptr->next;

SNMP_FREE( entry ); /* XXX - release any other internal resources */
}

/* Example cache handling - set up linked list from a suitable file */
int
atcaBoardTable_load( netsnmp_cache *cache, void *vmagic ) {
FILE *fp;
struct atcaBoardTable_entry *this;
char buf[STRMAX];

this->next = atcaBoardTable_head;
atcaBoardTable_head = this; /* Iterate helper is fine with unordered lists! */
}
fclose(fp);
return 0; /* OK */
}

void
atcaBoardTable_free( netsnmp_cache *cache, void *vmagic ) {
struct atcaBoardTable_entry *this, *that;

for ( this = atcaBoardTable_head; this; this=that ) {
that = this->next;
SNMP_FREE( this ); /* XXX - release any other internal resources */
}
atcaBoardTable_head = NULL;
}

/** handles requests for the atcaBoardTable table */
int
atcaBoardTable_handler(
netsnmp_mib_handler *handler,
netsnmp_handler_registration *reginfo,
netsnmp_agent_request_info *reqinfo,
netsnmp_request_info *requests)
{
int ret;
netsnmp_request_info *request;
netsnmp_table_request_info *table_info;
struct atcaBoardTable_entry *table_entry;

DEBUGMSGTL(("atcaBoardTable:handler", "Processing request (%d)\n", reqinfo->mode));

switch (reqinfo->mode) {
/*
* Read-support (also covers GetNext requests)
*/
case MODE_GET:
for (request=requests; request; request=request->next) {
table_entry = (struct atcaBoardTable_entry *)
netsnmp_extract_iterator_context(request);
table_info = netsnmp_extract_table_info( request);

switch (table_info->colnum) {

case COLUMN_ATCABOARDINFOINDEX:
if ( !table_entry ) {
netsnmp_set_request_error(reqinfo, request,
SNMP_NOSUCHINSTANCE);
continue;
}
snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER,
                                           gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].slot);
break;
case COLUMN_ATCABOARDCPU1TEMPERATURE:
if ( !table_entry ) {
netsnmp_set_request_error(reqinfo, request,
SNMP_NOSUCHINSTANCE);
continue;
}
snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR,
                                       gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardCPU1Temperature,
                                       strlen(gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardCPU1Temperature));
break;
case COLUMN_ATCABOARDCPU2TEMPERATURE:
if ( !table_entry ) {
netsnmp_set_request_error(reqinfo, request,
SNMP_NOSUCHINSTANCE);
continue;
}
#if 0
snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR,
table_entry->atcaBoardCPU2Temperature,
table_entry->atcaBoardCPU2Temperature_len);
#endif
snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR,
                                       gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardCPU2Temperature,
                                       strlen(gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardCPU2Temperature));
break;
case COLUMN_ATCABOARDPOWERSTATE:
if ( !table_entry ) {
netsnmp_set_request_error(reqinfo, request,
SNMP_NOSUCHINSTANCE);
continue;
}
snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR,
gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardPowerState,
strlen(gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardPowerState));
break;
case COLUMN_ATCABOARDRUNSOFTWARENAME:
if ( !table_entry ) {
netsnmp_set_request_error(reqinfo, request,
SNMP_NOSUCHINSTANCE);
continue;
}
snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR,
gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardRunSoftwareName,
strlen(gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardRunSoftwareName));
break;
case COLUMN_ATCABOARDCPUUTILLIZATION:
if ( !table_entry ) {
netsnmp_set_request_error(reqinfo, request,
SNMP_NOSUCHINSTANCE);
continue;
}
snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR,
gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardCpuUtillization,
strlen(gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardCpuUtillization));
break;
case COLUMN_ATCABOARDMEMORYUTILIZATION:
if ( !table_entry ) {
netsnmp_set_request_error(reqinfo, request,
SNMP_NOSUCHINSTANCE);
continue;
}
snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR,
gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardMemoryUtilization,
strlen(gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardMemoryUtilization));
break;
case COLUMN_ATCABOARDDISKUTILIZATION:
if ( !table_entry ) {
netsnmp_set_request_error(reqinfo, request,
SNMP_NOSUCHINSTANCE);
continue;
}
snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR,
gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardDiskUtilization,
strlen(gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardDiskUtilization));
break;
case COLUMN_ATCABOARDPOWERVALUE:
if ( !table_entry ) {
netsnmp_set_request_error(reqinfo, request,
SNMP_NOSUCHINSTANCE);
continue;
}
snmp_set_var_typed_value( request->requestvb, ASN_OCTET_STR,
gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardPowerValue,
strlen(gAtcaStatusInfo.boardInfo[table_entry->atcaBoardInfoIndex-1].atcaBoardPowerValue));
break;
default:
netsnmp_set_request_error(reqinfo, request,
SNMP_NOSUCHOBJECT);
break;
}
}
break;
   #if 0
/*
* Write-support
*/
case MODE_SET_RESERVE1:

for (request=requests; request; request=request->next) {
table_entry = (struct atcaBoardTable_entry *)
netsnmp_extract_iterator_context(request);
table_info = netsnmp_extract_table_info( request);

switch (table_info->colnum) {
case COLUMN_ATCABOARDCPU1TEMPERATURE:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardCPU1Temperature));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
case COLUMN_ATCABOARDCPU2TEMPERATURE:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardCPU2Temperature));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
case COLUMN_ATCABOARDPOWERSTATE:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardPowerState));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
case COLUMN_ATCABOARDRUNSOFTWARENAME:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardRunSoftwareName));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
case COLUMN_ATCABOARDCPUUTILLIZATION:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardCpuUtillization));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
case COLUMN_ATCABOARDMEMORYUTILIZATION:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardMemoryUtilization));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
case COLUMN_ATCABOARDDISKUTILIZATION:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardDiskUtilization));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
case COLUMN_ATCABOARDPOWERVALUE:
   /* or possibly 'netsnmp_check_vb_type_and_size' */
ret = netsnmp_check_vb_type_and_max_size(
request->requestvb, ASN_OCTET_STR, sizeof(table_entry->atcaBoardPowerValue));
if ( ret != SNMP_ERR_NOERROR ) {
netsnmp_set_request_error( reqinfo, request, ret );
return SNMP_ERR_NOERROR;
}
break;
default:
netsnmp_set_request_error( reqinfo, request,
SNMP_ERR_NOTWRITABLE );
return SNMP_ERR_NOERROR;
}
}
break;
case MODE_SET_RESERVE2:
for (request=requests; request; request=request->next) {
table_entry = (struct atcaBoardTable_entry *)
netsnmp_extract_iterator_context(request);
table_info = netsnmp_extract_table_info( request);

switch (table_info->colnum) {
case COLUMN_ATCABOARDCPU1TEMPERATURE:
case COLUMN_ATCABOARDCPU2TEMPERATURE:
case COLUMN_ATCABOARDPOWERSTATE:
case COLUMN_ATCABOARDRUNSOFTWARENAME:
case COLUMN_ATCABOARDCPUUTILLIZATION:
case COLUMN_ATCABOARDMEMORYUTILIZATION:
case COLUMN_ATCABOARDDISKUTILIZATION:
case COLUMN_ATCABOARDPOWERVALUE:
if ( !table_row ) {
                   struct atcaBoardTable_entry *table_row;
table_row = atcaBoardTable_createEntry(*table_info->indexes->val.integer);
if (table_row) {
netsnmp_insert_iterator_context( request, table_row );
} else {
netsnmp_set_request_error( reqinfo, request,
SNMP_ERR_RESOURCEUNAVAILABLE );
return SNMP_ERR_NOERROR;
}
}
break;
}
}
break;

if ( table_entry && !table_entry->valid ) {
atcaBoardTable_removeEntry(table_data, table_row );
}

break;
}
}
break;

case MODE_SET_COMMIT:
for (request=requests; request; request=request->next) {
table_entry = (struct atcaBoardTable_entry *)
netsnmp_extract_iterator_context(request);
table_info = netsnmp_extract_table_info( request);

switch (table_info->colnum) {
case COLUMN_ATCABOARDCPU1TEMPERATURE:
case COLUMN_ATCABOARDCPU2TEMPERATURE:
case COLUMN_ATCABOARDPOWERSTATE:
case COLUMN_ATCABOARDRUNSOFTWARENAME:
case COLUMN_ATCABOARDCPUUTILLIZATION:
case COLUMN_ATCABOARDMEMORYUTILIZATION:
case COLUMN_ATCABOARDDISKUTILIZATION:
case COLUMN_ATCABOARDPOWERVALUE:
if ( table_entry && !table_entry->valid ) {
table_entry->valid = 1;
}
}
}
break;
   #endif

   default:
       netsnmp_set_request_error( reqinfo, request,
                               SNMP_ERR_NOTWRITABLE );
}
return SNMP_ERR_NOERROR;
}

4.编译运行
主循环程序见上一篇博客.
[root@VM-4-14-opencloudos home]# snmpwalk -v2c -c public localhost 1.3.6.1.4.1.12001.5.5
SNMPv2-SMI::enterprises.12001.5.5.1.1.1 = INTEGER: 1
SNMPv2-SMI::enterprises.12001.5.5.1.1.2 = INTEGER: 2
SNMPv2-SMI::enterprises.12001.5.5.1.1.3 = INTEGER: 3
SNMPv2-SMI::enterprises.12001.5.5.1.1.4 = INTEGER: 4
SNMPv2-SMI::enterprises.12001.5.5.1.1.5 = INTEGER: 5
SNMPv2-SMI::enterprises.12001.5.5.1.1.6 = INTEGER: 6
SNMPv2-SMI::enterprises.12001.5.5.1.2.1 = STRING: "40C"
SNMPv2-SMI::enterprises.12001.5.5.1.2.2 = STRING: "40C"
SNMPv2-SMI::enterprises.12001.5.5.1.2.3 = STRING: "40C"
SNMPv2-SMI::enterprises.12001.5.5.1.2.4 = STRING: "40C"
SNMPv2-SMI::enterprises.12001.5.5.1.2.5 = STRING: "40C"
SNMPv2-SMI::enterprises.12001.5.5.1.2.6 = STRING: "40C"
SNMPv2-SMI::enterprises.12001.5.5.1.3.1 = STRING: "50C"
SNMPv2-SMI::enterprises.12001.5.5.1.3.2 = STRING: "50C"
SNMPv2-SMI::enterprises.12001.5.5.1.3.3 = STRING: "50C"
SNMPv2-SMI::enterprises.12001.5.5.1.3.4 = STRING: "50C"
SNMPv2-SMI::enterprises.12001.5.5.1.3.5 = STRING: "50C"
SNMPv2-SMI::enterprises.12001.5.5.1.3.6 = STRING: "50C"
SNMPv2-SMI::enterprises.12001.5.5.1.4.1 = STRING: "POWER OK"
SNMPv2-SMI::enterprises.12001.5.5.1.4.2 = STRING: "POWER OK"
SNMPv2-SMI::enterprises.12001.5.5.1.4.3 = STRING: "POWER OK"
SNMPv2-SMI::enterprises.12001.5.5.1.4.4 = STRING: "POWER OK"
SNMPv2-SMI::enterprises.12001.5.5.1.4.5 = STRING: "POWER OK"
SNMPv2-SMI::enterprises.12001.5.5.1.4.6 = STRING: "POWER OK"
SNMPv2-SMI::enterprises.12001.5.5.1.5.1 = STRING: "SNMP"
SNMPv2-SMI::enterprises.12001.5.5.1.5.2 = STRING: "SNMP"
SNMPv2-SMI::enterprises.12001.5.5.1.5.3 = STRING: "SNMP"
SNMPv2-SMI::enterprises.12001.5.5.1.5.4 = STRING: "SNMP"
SNMPv2-SMI::enterprises.12001.5.5.1.5.5 = STRING: "SNMP"
SNMPv2-SMI::enterprises.12001.5.5.1.5.6 = STRING: "SNMP"
SNMPv2-SMI::enterprises.12001.5.5.1.6.1 = STRING: "X86_64"
SNMPv2-SMI::enterprises.12001.5.5.1.6.2 = STRING: "X86_64"
SNMPv2-SMI::enterprises.12001.5.5.1.6.3 = STRING: "X86_64"
SNMPv2-SMI::enterprises.12001.5.5.1.6.4 = STRING: "X86_64"
SNMPv2-SMI::enterprises.12001.5.5.1.6.5 = STRING: "X86_64"
SNMPv2-SMI::enterprises.12001.5.5.1.6.6 = STRING: "X86_64"
SNMPv2-SMI::enterprises.12001.5.5.1.7.1 = STRING: "8192M"
SNMPv2-SMI::enterprises.12001.5.5.1.7.2 = STRING: "8192M"
SNMPv2-SMI::enterprises.12001.5.5.1.7.3 = STRING: "8192M"
SNMPv2-SMI::enterprises.12001.5.5.1.7.4 = STRING: "8192M"
SNMPv2-SMI::enterprises.12001.5.5.1.7.5 = STRING: "8192M"
SNMPv2-SMI::enterprises.12001.5.5.1.7.6 = STRING: "8192M"
SNMPv2-SMI::enterprises.12001.5.5.1.8.1 = STRING: "256G"
SNMPv2-SMI::enterprises.12001.5.5.1.8.2 = STRING: "256G"
SNMPv2-SMI::enterprises.12001.5.5.1.8.3 = STRING: "256G"
SNMPv2-SMI::enterprises.12001.5.5.1.8.4 = STRING: "256G"
SNMPv2-SMI::enterprises.12001.5.5.1.8.5 = STRING: "256G"
SNMPv2-SMI::enterprises.12001.5.5.1.8.6 = STRING: "256G"
SNMPv2-SMI::enterprises.12001.5.5.1.9.1 = STRING: "?"
SNMPv2-SMI::enterprises.12001.5.5.1.9.2 = STRING: "?"
SNMPv2-SMI::enterprises.12001.5.5.1.9.3 = STRING: "?"
SNMPv2-SMI::enterprises.12001.5.5.1.9.4 = STRING: "?"
SNMPv2-SMI::enterprises.12001.5.5.1.9.5 = STRING: "?"
SNMPv2-SMI::enterprises.12001.5.5.1.9.6 = STRING: "?"