/** adds a new row to a dataset table */
NETSNMP_INLINE void
netsnmp_table_dataset_add_row(netsnmp_table_data_set *table,
netsnmp_table_row *row)
{
if (!table)
return;
netsnmp_table_data_add_row(table->table, row);
}
/** swaps out origrow with newrow. This does *not* delete/free anything! */
NETSNMP_INLINE void
netsnmp_table_data_replace_row(netsnmp_table_data *table,
netsnmp_table_row *origrow,
netsnmp_table_row *newrow)
{
netsnmp_table_data_remove_row(table, origrow);
netsnmp_table_data_add_row(table, newrow);
}
void
parse_notificationEvent(const char *token, char *line) {
char name_buf[64];
char oid_name_buf[SPRINT_MAX_LEN];
oid oid_buf[MAX_OID_LEN];
size_t oid_buf_len = MAX_OID_LEN;
int wild = 1;
netsnmp_table_row *row;
long tlong;
char tc;
/* get the owner */
const char *owner = "snmpd.conf";
/* get the name */
char *cp = copy_nword(line, name_buf, SPRINT_MAX_LEN);
if (!cp || name_buf[0] == '\0') {
config_perror("syntax error.");
return;
}
for(row = table_set->table->first_row; row; row = row->next) {
if (strcmp(row->indexes->val.string, owner) == 0 &&
strcmp(row->indexes->next_variable->val.string,
name_buf) == 0) {
config_perror("An eventd by that name has already been defined.");
return;
}
}
/* now, get all the trap oid */
cp = copy_nword(cp, oid_name_buf, SPRINT_MAX_LEN);
if (oid_name_buf[0] == '\0') {
config_perror("syntax error.");
return;
}
if (!snmp_parse_oid(oid_name_buf, oid_buf, &oid_buf_len)) {
snmp_log(LOG_ERR,"namebuf: %s\n",oid_name_buf);
config_perror("unable to parse trap oid");
return;
}
/*
* add to the mteEventNotificationtable to point to the
* notification and the objects.
*/
row = netsnmp_create_table_data_row();
/* indexes */
netsnmp_table_row_add_index(row, ASN_OCTET_STR, owner, strlen(owner));
netsnmp_table_row_add_index(row, ASN_PRIV_IMPLIED_OCTET_STR,
name_buf, strlen(name_buf));
/* columns */
netsnmp_set_row_column(row, COLUMN_MTEEVENTNOTIFICATION, ASN_OBJECT_ID,
(char *) oid_buf, oid_buf_len * sizeof(oid));
netsnmp_set_row_column(row, COLUMN_MTEEVENTNOTIFICATIONOBJECTSOWNER,
ASN_OCTET_STR, owner, strlen(owner));
netsnmp_set_row_column(row, COLUMN_MTEEVENTNOTIFICATIONOBJECTS,
ASN_OCTET_STR, name_buf, strlen(name_buf));
netsnmp_table_data_add_row(mteEventNotif_table_set->table, row);
/*
* add to the mteEventTable to make it a notification to trigger
* notification and the objects.
*/
row = netsnmp_create_table_data_row();
/* indexes */
netsnmp_table_row_add_index(row, ASN_OCTET_STR, owner, strlen(owner));
netsnmp_table_row_add_index(row, ASN_PRIV_IMPLIED_OCTET_STR,
name_buf, strlen(name_buf));
/* columns */
tc = (u_char)0x80;
netsnmp_set_row_column(row, COLUMN_MTEEVENTACTIONS, ASN_OCTET_STR,
&tc, 1);
tlong = MTETRIGGERENABLED_TRUE;
netsnmp_set_row_column(row, COLUMN_MTEEVENTENABLED,
ASN_INTEGER, (char *) &tlong, sizeof(tlong));
tlong = RS_ACTIVE;
netsnmp_set_row_column(row, COLUMN_MTEEVENTENTRYSTATUS,
ASN_INTEGER, (char *) &tlong, sizeof(tlong));
netsnmp_table_data_add_row(table_set->table, row);
/*
* now all the objects to put into the trap's object row
*/
while(cp) {
cp = copy_nword(cp, oid_name_buf, SPRINT_MAX_LEN);
if (strcmp(oid_name_buf, "-w") == 0) {
wild = 0;
continue;
}
oid_buf_len = MAX_OID_LEN;
if (!snmp_parse_oid(oid_name_buf, oid_buf, &oid_buf_len)) {
config_perror("unable to parse an object oid");
return;
}
mte_add_object_to_table("snmpd.conf", name_buf,
oid_buf, oid_buf_len, wild);
wild = 1;
}
}
/* Handles creation of new rows for the table */
static int sipOtherStatsTable_newRow(struct sip_snmp_handler *h)
{
netsnmp_table_row *row;
/* XXX: make sure applIndex is an index for your table */
static int applIndex = -1;
const char *func = "snmp_mod";
register struct sip_snmp_handler *c;
struct sip_snmp_obj *o;
int i, col;
/* get applIndex first */
if(applIndex == -1) {
applIndex = ser_getApplIndex();
if(applIndex == -1) {
LOG(L_ERR,"%s: Couldn't get application index, cannot create "
"new row\n", func);
return -1;
}
}
/* create the row */
row = netsnmp_create_table_data_row();
if(!row) {
LOG(L_ERR, "%s: Couldn't create new row, out of memory?\n", func);
return -1;
}
/* add indexes */
netsnmp_table_row_add_index(row,
ASN_INTEGER, &applIndex, sizeof(applIndex));
c = h;
for(i=1; i<SIPOTHERSTATSTABLE_INDEXES; i++) {
if(!c) {
LOG(L_ERR, "%s: Not enought indexes passed, need %d\n", func,
SIPOTHERSTATSTABLE_INDEXES);
netsnmp_table_data_delete_row(row);
return -1;
}
if(!c->sip_obj || !c->sip_obj->value.voidp) {
LOG(L_ERR, "%s: Invalid index passed\n", func);
netsnmp_table_data_delete_row(row);
return -1;
}
if(!netsnmp_table_row_add_index(row, ser_types[c->sip_obj->type],
c->sip_obj->value.voidp, c->sip_obj->val_len)) {
LOG(L_ERR, "%s: Error adding index to row\n", func);
netsnmp_table_data_delete_row(row);
return -1;
}
c = c->next;
}
/* add the data. We start from the last index, all the way to the
* end of the linked list */
c = h;
for(i=2; i<SIPOTHERSTATSTABLE_INDEXES; i++)
c = c->next;
col = 1;
while(c) {
if(col > SIPOTHERSTATSTABLE_COLUMNS) {
LOG(L_ERR, "%s: Too many columns for new row\n", func);
netsnmp_table_data_delete_row(row);
return -1;
}
o = c->sip_obj;
if(!o || !o->value.voidp) {
LOG(L_ERR, "%s: Invalid object to add to new row\n", func);
netsnmp_table_data_delete_row(row);
return -1;
}
if(netsnmp_set_row_column(row, col, ser_types[o->type],
o->value.voidp, o->val_len) != SNMPERR_SUCCESS) {
LOG(L_ERR, "%s: Error adding object to row\n", func);
netsnmp_table_data_delete_row(row);
return -1;
}
if(c->on_set)
netsnmp_mark_row_column_writable(row, col, 1);
/* next, please... */
c = c->next;
col++;
}
/* add the row to the table */
if(netsnmp_table_data_add_row(sipOtherStatsTable->table, row) !=
SNMPERR_SUCCESS) {
LOG(L_ERR, "%s: Error adding new row to table\n", func);
netsnmp_table_data_delete_row(row);
return -1;
}
return 0;
}
/* Adds a new object to the table. If the row doesn't exist is created.
* Assumes all objects go to the same row, and all the objects are
* new (replacing is done silently) */
static int sipOtherStatsTable_addObj(struct sip_snmp_handler *h, int col)
{
static netsnmp_table_row *row = NULL;
int applIndex; /* Default index for most tables */
int first = 0;
const char *func = "snmp_mod";
if(!row) { /* First time. Create row and add indexes */
/* Get index (applIndex). First since we don't need to undo it
* but it's still possible that it fails (e.g. if we get called
* at the wrong time) */
applIndex = ser_getApplIndex();
if(applIndex == -1) {
LOG(L_ERR, "%s: Failed getting table index\n", func);
return -1;
}
/* XXX: If table has more indexes init them here and add
* a similar call to row_add_index() as below */
/* Create the row */
row = netsnmp_create_table_data_row();
if(!row) {
LOG(L_ERR, "%s: failed creating table row\n", func);
return -1;
}
/* add the index(es) to the table */
if(!netsnmp_table_row_add_index(row, ASN_INTEGER, &applIndex,
sizeof(applIndex))) {
LOG(L_ERR, "%s: Error adding index to row\n", func);
netsnmp_table_data_delete_row(row);
row = NULL;
return -1;
}
first = 1;
}
/* sanity checks */
if(col < 1 || col > SIPOTHERSTATSTABLE_COLUMNS) {
LOG(L_ERR, "%s: Invalid column %d to add new object\n", func, col);
return -1;
}
if(!h || !h->sip_obj || !h->sip_obj->value.voidp) {
LOG(L_ERR, "%s: Invalid object to add\n", func);
return -1;
}
/* add object to row */
if(netsnmp_set_row_column(row, col, ser_types[h->sip_obj->type],
h->sip_obj->value.voidp, h->sip_obj->val_len)
!= SNMPERR_SUCCESS) {
LOG(L_ERR, "%s: Error adding new object to table\n", func);
return -1;
}
/* is it writable? */
if(h->on_set)
netsnmp_mark_row_column_writable(row, col, 1);
/* If first time, add the row. Subsequent times don't need to do
* anything since the table just has a pointer to our local row.
* However, if indexes were to change then the row needs to be
* replaced */
if(first) {
if(netsnmp_table_data_add_row(sipOtherStatsTable->table, row) !=
SNMPERR_SUCCESS) {
LOG(L_ERR, "%s: Error adding new row to table\n",func);
return -1;
}
}
/* Fin */
return 0;
}
/** @internal */
void
netsnmp_config_parse_add_row(const char *token, char *line)
{
char buf[SNMP_MAXBUF_MEDIUM];
char tname[SNMP_MAXBUF_MEDIUM];
size_t buf_size;
int rc;
data_set_tables *tables;
netsnmp_variable_list *vb; /* containing only types */
netsnmp_table_row *row;
netsnmp_table_data_set_storage *dr;
line = copy_nword(line, tname, SNMP_MAXBUF_MEDIUM);
tables = (data_set_tables *) netsnmp_get_list_data(auto_tables, tname);
if (!tables) {
config_pwarn("Unknown table trying to add a row");
return;
}
/*
* do the indexes first
*/
row = netsnmp_create_table_data_row();
for (vb = tables->table_set->table->indexes_template; vb;
vb = vb->next_variable) {
if (!line) {
config_pwarn("missing an index value");
return;
}
DEBUGMSGTL(("table_set_add_row", "adding index of type %d\n",
vb->type));
buf_size = SNMP_MAXBUF_MEDIUM;
line = read_config_read_memory(vb->type, line, buf, &buf_size);
netsnmp_table_row_add_index(row, vb->type, buf, buf_size);
}
/*
* then do the data
*/
for (dr = tables->table_set->default_row; dr; dr = dr->next) {
if (!line) {
config_pwarn("missing a data value. "
"All columns must be specified.");
snmp_log(LOG_WARNING," can't find value for column %d\n",
dr->column - 1);
return;
}
buf_size = SNMP_MAXBUF_MEDIUM;
line = read_config_read_memory(dr->type, line, buf, &buf_size);
DEBUGMSGTL(("table_set_add_row",
"adding data at column %d of type %d\n", dr->column,
dr->type));
netsnmp_set_row_column(row, dr->column, dr->type, buf, buf_size);
if (dr->writable)
netsnmp_mark_row_column_writable(row, dr->column, 1); /* make writable */
}
rc = netsnmp_table_data_add_row(tables->table_set->table, row);
if (SNMPERR_SUCCESS != rc) {
config_pwarn("error adding table row");
}
}
void
init_testhandler(void)
{
/*
* we're registering at .1.2.3.4
*/
netsnmp_handler_registration *my_test;
netsnmp_table_registration_info *table_info;
u_long ind1;
netsnmp_table_data *table;
netsnmp_table_data_set *table_set;
netsnmp_table_row *row;
DEBUGMSGTL(("testhandler", "initializing\n"));
/*
* basic handler test
*/
netsnmp_register_handler(netsnmp_create_handler_registration
("myTest", my_test_handler, my_test_oid, 4,
HANDLER_CAN_RONLY));
/*
* instance handler test
*/
netsnmp_register_instance(netsnmp_create_handler_registration
("myInstance", my_test_instance_handler,
my_instance_oid, 5, HANDLER_CAN_RWRITE));
netsnmp_register_ulong_instance("myulong",
my_data_ulong_instance, 4,
&my_ulong, NULL);
/*
* table helper test
*/
my_test = netsnmp_create_handler_registration("myTable",
my_test_table_handler,
my_table_oid, 4,
HANDLER_CAN_RONLY);
if (!my_test)
return;
table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
if (table_info == NULL)
return;
netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER, ASN_INTEGER,
0);
table_info->min_column = 3;
table_info->max_column = 3;
netsnmp_register_table(my_test, table_info);
/*
* data table helper test
*/
/*
* we'll construct a simple table here with two indexes: an
* integer and a string (why not). It'll contain only one
* column so the data pointer is merely the data in that
* column.
*/
table = netsnmp_create_table_data("data_table_test");
netsnmp_table_data_add_index(table, ASN_INTEGER);
netsnmp_table_data_add_index(table, ASN_OCTET_STR);
/*
* 1 partridge in a pear tree
*/
row = netsnmp_create_table_data_row();
ind1 = 1;
netsnmp_table_row_add_index(row, ASN_INTEGER, &ind1, sizeof(ind1));
netsnmp_table_row_add_index(row, ASN_OCTET_STR, "partridge",
strlen("partridge"));
row->data = (void *) "pear tree";
netsnmp_table_data_add_row(table, row);
/*
* 2 turtle doves
*/
row = netsnmp_create_table_data_row();
ind1 = 2;
netsnmp_table_row_add_index(row, ASN_INTEGER, &ind1, sizeof(ind1));
netsnmp_table_row_add_index(row, ASN_OCTET_STR, "turtle",
strlen("turtle"));
row->data = (void *) "doves";
netsnmp_table_data_add_row(table, row);
/*
* we're going to register it as a normal table too, so we get the
* automatically parsed column and index information
*/
table_info = SNMP_MALLOC_TYPEDEF(netsnmp_table_registration_info);
if (table_info == NULL)
return;
netsnmp_table_helper_add_indexes(table_info, ASN_INTEGER,
ASN_OCTET_STR, 0);
table_info->min_column = 3;
table_info->max_column = 3;
netsnmp_register_read_only_table_data
(netsnmp_create_handler_registration
("12days", my_data_table_handler, my_data_table_oid, 4,
HANDLER_CAN_RONLY), table, table_info);
}
static void parse_table_row(
int cpu,
char *p,
struct snmp_vars *sys,
netsnmp_table_data_set *data_set)
{
netsnmp_table_row *row;
row = netsnmp_create_table_data_row();
netsnmp_table_row_add_index(row, ASN_INTEGER, (u_char *)&cpu, sizeof(cpu));
if (sys == cputable) {
/* add cpuIndex as column too to break SMIv2 */
netsnmp_set_row_column(row, 1, sys->type, (char *)&cpu, sizeof(cpu));
}
for (++sys; p && sys->obj; sys++) {
char *val;
long long val64;
unsigned int uval32;
int val32;
struct counter64 c64;
p += strspn(p, " \t");
val = p;
if ((p = strpbrk(p, " \t")))
*p++ = '\0';
if (index(val, '.')) {
double d = strtod(val, NULL);
val64 = (long long)(d * 100);
} else
val64 = strtoll(val, NULL, 10);
switch (sys->type) {
case ASN_OCTET_STR:
netsnmp_set_row_column(row, sys->obj,
sys->type, (char *)val, strlen(val));
break;
case ASN_INTEGER:
case ASN_GAUGE:
val32 = (int)val64;
netsnmp_set_row_column(row, sys->obj,
sys->type, (char *)&val32, sizeof(val32));
break;
case ASN_COUNTER:
uval32 = (unsigned int)val64;
netsnmp_set_row_column(row, sys->obj,
sys->type, (char *)&uval32, sizeof(uval32));
break;
case ASN_COUNTER64:
c64.low = (uint32_t)val64;
c64.high = val64 >> 32;
netsnmp_set_row_column(row, sys->obj,
sys->type, (char *)&c64, sizeof(c64));
break;
default:
netsnmp_table_dataset_delete_row(row);
continue;
}
}
netsnmp_table_data_add_row(data_set->table, row);
}
