RMON_ENTRY_T *ROWAPI_get_clone (TABLE_DEFINTION_T * table_ptr, u_long ctrl_index, size_t body_size)
{
register RMON_ENTRY_T *eptr;
if (ctrl_index < 1 || ctrl_index > 0xFFFFu)
{
ag_trace ("%s: index %ld out of range (1..65535)", table_ptr->name, (long) ctrl_index);
return NULL;
}
/*
* get it
*/
eptr = ROWAPI_find (table_ptr, ctrl_index);
if (!eptr)
{ /* try to create */
if (0 != ROWAPI_new (table_ptr, ctrl_index))
{
return NULL;
}
/*
* get it
*/
eptr = ROWAPI_find (table_ptr, ctrl_index);
if (!eptr) /* it is unbelievable, but ... :( */
return NULL;
}
eptr->new_status = eptr->status;
eptr->tmp = AGMALLOC (body_size);
if (!eptr->tmp)
{
if (eptr->only_just_created)
rowapi_delete (eptr);
return NULL;
}
memcpy (eptr->tmp, eptr->body, body_size);
if (table_ptr->ClbkClone)
table_ptr->ClbkClone (eptr);
if (eptr->new_owner)
AGFREE (eptr->new_owner);
return eptr->tmp;
}
int
event_api_send_alarm(u_char is_rising,
u_long alarm_index,
u_long event_index,
oid * alarmed_var,
size_t alarmed_var_length,
u_long sample_type,
u_long value, u_long the_threshold, char *alarm_descr)
{
RMON_ENTRY_T *eptr;
CRTL_ENTRY_T *evptr;
if (!event_index)
return SNMP_ERR_NOERROR;
#if 0
ag_trace("event_api_send_alarm(%d,%d,%d,'%s')",
(int) is_rising, (int) alarm_index, (int) event_index,
alarm_descr);
#endif
eptr = ROWAPI_find(table_ptr, event_index);
if (!eptr) {
/*
* ag_trace ("event cannot find entry %ld", event_index);
*/
return SNMP_ERR_NOSUCHNAME;
}
evptr = (CRTL_ENTRY_T *) eptr->body;
evptr->event_last_time_sent = AGUTIL_sys_up_time();
if (EVENT_TRAP == evptr->event_type
|| EVENT_LOG_AND_TRAP == evptr->event_type) {
event_send_trap(evptr, is_rising, alarm_index, value,
the_threshold, alarmed_var, alarmed_var_length,
sample_type);
}
if (EVENT_LOG == evptr->event_type
|| EVENT_LOG_AND_TRAP == evptr->event_type) {
register char *explain;
explain = create_explanaition(evptr, is_rising,
alarm_index, event_index,
alarmed_var, alarmed_var_length,
value, the_threshold,
sample_type, alarm_descr);
/*
* if (explain) ag_trace ("Dbg:'%s'", explain);
*/
event_save_log(evptr, explain);
if (explain)
AGFREE(explain);
}
return SNMP_ERR_NOERROR;
}
/*
* if (explain) ag_trace ("Dbg:'%s'", explain);
*/
event_save_log(evptr, explain);
if (explain)
AGFREE(explain);
}
return SNMP_ERR_NOERROR;
}
#if 1 /* debug, but may be used for init. TBD: may be token snmpd.conf ? */
int
add_event_entry(int ctrl_index,
char *event_description,
EVENT_TYPE_T event_type, char *event_community)
{
register RMON_ENTRY_T *eptr;
register CRTL_ENTRY_T *body;
int ierr;
ierr = ROWAPI_new(table_ptr, ctrl_index);
if (ierr) {
ag_trace("ROWAPI_new failed with %d", ierr);
return ierr;
}
eptr = ROWAPI_find(table_ptr, ctrl_index);
if (!eptr) {
ag_trace("ROWAPI_find failed");
return -4;
}
body = (CRTL_ENTRY_T *) eptr->body;
/*
* set parameters
*/
if (event_description) {
if (body->event_description)
AGFREE(body->event_description);
body->event_description = AGSTRDUP(event_description);
}
if (event_community) {
if (body->event_community)
AGFREE(body->event_community);
body->event_community = AGSTRDUP(event_community);
}
body->event_type = event_type;
eptr->new_status = RMON1_ENTRY_VALID;
ierr = ROWAPI_commit(table_ptr, ctrl_index);
if (ierr) {
ag_trace("ROWAPI_commit failed with %d", ierr);
}
return ierr;
}
/***************************************************
* Function:var_etherStatsEntry
* Purpose: Handles the request for etherStatsEntry variable instances
***************************************************/
u_char *
var_etherStatsEntry(struct variable * vp, oid * name, size_t * length,
int exact, size_t * var_len,
WriteMethod ** write_method)
{
static long long_return;
static CRTL_ENTRY_T theEntry;
RMON_ENTRY_T *hdr;
*write_method = write_etherStatsEntry;
hdr = ROWAPI_header_ControlEntry(vp, name, length, exact, var_len,
table_ptr,
&theEntry, sizeof(CRTL_ENTRY_T));
if (!hdr)
return NULL;
if (RMON1_ENTRY_VALID == hdr->status)
SYSTEM_get_eth_statistics(&theEntry.data_source, &theEntry.eth);
*var_len = sizeof(long);
switch (vp->magic) {
case IDetherStatsIndex:
long_return = hdr->ctrl_index;
return (u_char *) & long_return;
case IDetherStatsDataSource:
*var_len = sizeof(oid) * theEntry.data_source.length;
return (unsigned char *) theEntry.data_source.objid;
case IDetherStatsDropEvents:
long_return = 0; /* theEntry.eth.etherStatsDropEvents; */
return (u_char *) & long_return;
case IDetherStatsOctets:
long_return = theEntry.eth.octets;
return (u_char *) & long_return;
case IDetherStatsPkts:
long_return = theEntry.eth.packets;
return (u_char *) & long_return;
case IDetherStatsBroadcastPkts:
long_return = theEntry.eth.bcast_pkts;
return (u_char *) & long_return;
case IDetherStatsMulticastPkts:
long_return = theEntry.eth.mcast_pkts;
return (u_char *) & long_return;
case IDetherStatsCRCAlignErrors:
long_return = theEntry.eth.crc_align;
return (u_char *) & long_return;
case IDetherStatsUndersizePkts:
long_return = theEntry.eth.undersize;
return (u_char *) & long_return;
case IDetherStatsOversizePkts:
long_return = theEntry.eth.oversize;
return (u_char *) & long_return;
case IDetherStatsFragments:
long_return = theEntry.eth.fragments;
return (u_char *) & long_return;
case IDetherStatsJabbers:
long_return = theEntry.eth.jabbers;
return (u_char *) & long_return;
case IDetherStatsCollisions:
long_return = theEntry.eth.collisions;
return (u_char *) & long_return;
case IDetherStatsPkts64Octets:
long_return = theEntry.eth.pkts_64;
return (u_char *) & long_return;
case IDetherStatsPkts65to127Octets:
long_return = theEntry.eth.pkts_65_127;
return (u_char *) & long_return;
case IDetherStatsPkts128to255Octets:
long_return = theEntry.eth.pkts_128_255;
return (u_char *) & long_return;
case IDetherStatsPkts256to511Octets:
long_return = theEntry.eth.pkts_256_511;
return (u_char *) & long_return;
case IDetherStatsPkts512to1023Octets:
long_return = theEntry.eth.pkts_512_1023;
return (u_char *) & long_return;
case IDetherStatsPkts1024to1518Octets:
long_return = theEntry.eth.pkts_1024_1518;
return (u_char *) & long_return;
case IDetherStatsOwner:
if (hdr->owner) {
*var_len = strlen(hdr->owner);
return (unsigned char *) hdr->owner;
} else {
*var_len = 0;
return NETSNMP_REMOVE_CONST(unsigned char *, "");
}
case IDetherStatsStatus:
long_return = hdr->status;
return (u_char *) & long_return;
default:
ERROR_MSG("");
}; /* of switch by 'vp->magic' */
return NULL;
}
#if 1 /* debug, but may be used for init. TBD: may be token snmpd.conf ? */
int
add_statistics_entry(int ctrl_index, int ifIndex)
{
int ierr;
ierr = ROWAPI_new(table_ptr, ctrl_index);
switch (ierr) {
case -1:
ag_trace("max. number exedes\n");
break;
case -2:
ag_trace("malloc failed");
break;
case -3:
ag_trace("ClbkCreate failed");
break;
case 0:
break;
default:
ag_trace("Unknown code %d", ierr);
break;
}
if (!ierr) {
register RMON_ENTRY_T *eptr = ROWAPI_find(table_ptr, ctrl_index);
if (!eptr) {
ag_trace("cannot find it");
ierr = -4;
} else {
CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body;
body->data_source.objid[body->data_source.length - 1] =
ifIndex;
eptr->new_status = RMON1_ENTRY_VALID;
ierr = ROWAPI_commit(table_ptr, ctrl_index);
if (ierr) {
ag_trace("ROWAPI_commit returned %d", ierr);
}
}
}
return ierr;
}
void
ROWAPI_delete_clone(TABLE_DEFINTION_T * table_ptr, u_long ctrl_index)
{
register RMON_ENTRY_T *eptr;
eptr = ROWAPI_find(table_ptr, ctrl_index);
if (eptr) {
if (eptr->new_owner)
AGFREE(eptr->new_owner);
if (eptr->tmp) {
if (table_ptr->ClbkDelete)
table_ptr->ClbkDelete((RMON_ENTRY_T *) eptr->tmp);
AGFREE(eptr->tmp);
}
if (eptr->only_just_created) {
rowapi_delete(eptr);
}
}
}
RMON_ENTRY_T *ROWAPI_header_ControlEntry (struct variable * vp, oid * name,
size_t * length, int exact,
size_t * var_len,
TABLE_DEFINTION_T * table_ptr, void *entry_ptr, size_t entry_size)
{
long ctrl_index;
RMON_ENTRY_T *hdr = NULL;
if (0 != AGUTIL_advance_index_name (vp, name, length, exact))
{
ag_trace ("cannot advance_index_name");
return NULL;
}
ctrl_index = vp->namelen >= *length ? 0 : name[vp->namelen];
if (exact)
{
if (ctrl_index)
hdr = ROWAPI_find (table_ptr, ctrl_index);
}
else
{
if (ctrl_index)
hdr = ROWAPI_next (table_ptr, ctrl_index);
else
hdr = ROWAPI_first (table_ptr);
if (hdr)
{ /* set new index */
name[vp->namelen] = hdr->ctrl_index;
*length = vp->namelen + 1;
}
}
if (hdr)
memcpy (entry_ptr, hdr->body, entry_size);
return hdr;
}
static int
write_eventControl(int action, u_char * var_val, u_char var_val_type,
size_t var_val_len, u_char * statP,
oid * name, size_t name_len)
{
long long_temp;
char *char_temp;
int leaf_id, snmp_status;
static int prev_action = COMMIT;
RMON_ENTRY_T *hdr;
CRTL_ENTRY_T *cloned_body;
switch (action) {
case RESERVE1:
case FREE:
case UNDO:
case ACTION:
case COMMIT:
default:
return ROWAPI_do_another_action(name, eventEntryFirstIndexBegin,
action, &prev_action,
table_ptr, sizeof(CRTL_ENTRY_T));
case RESERVE2:
/*
* get values from PDU, check them and save them in the cloned entry
*/
long_temp = name[eventEntryFirstIndexBegin];
leaf_id = (int) name[eventEntryFirstIndexBegin - 1];
hdr = ROWAPI_find(table_ptr, long_temp); /* it MUST be OK */
cloned_body = (CRTL_ENTRY_T *) hdr->tmp;
switch (leaf_id) {
case Leaf_event_index:
return SNMP_ERR_NOTWRITABLE;
case Leaf_event_description:
char_temp = AGMALLOC(1 + MAX_event_description);
if (!char_temp)
return SNMP_ERR_TOOBIG;
snmp_status = AGUTIL_get_string_value(var_val, var_val_type,
var_val_len,
MAX_event_description,
1, NULL, char_temp);
if (SNMP_ERR_NOERROR != snmp_status) {
AGFREE(char_temp);
return snmp_status;
}
if (cloned_body->event_description)
AGFREE(cloned_body->event_description);
cloned_body->event_description = AGSTRDUP(char_temp);
/*
* ag_trace ("rx: event_description=<%s>", cloned_body->event_description);
*/
AGFREE(char_temp);
break;
case Leaf_event_type:
snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
var_val_len,
EVENT_NONE,
EVENT_LOG_AND_TRAP,
&long_temp);
if (SNMP_ERR_NOERROR != snmp_status) {
return snmp_status;
}
cloned_body->event_type = long_temp;
break;
case Leaf_event_last_time_sent:
return SNMP_ERR_NOTWRITABLE;
case Leaf_event_community:
char_temp = AGMALLOC(1 + MAX_event_community);
if (!char_temp)
return SNMP_ERR_TOOBIG;
snmp_status = AGUTIL_get_string_value(var_val, var_val_type,
var_val_len,
MAX_event_community,
1, NULL, char_temp);
if (SNMP_ERR_NOERROR != snmp_status) {
AGFREE(char_temp);
return snmp_status;
}
if (cloned_body->event_community)
AGFREE(cloned_body->event_community);
cloned_body->event_community = AGSTRDUP(char_temp);
AGFREE(char_temp);
break;
case Leaf_eventOwner:
if (hdr->new_owner)
AGFREE(hdr->new_owner);
hdr->new_owner = AGMALLOC(MAX_OWNERSTRING);;
if (!hdr->new_owner)
return SNMP_ERR_TOOBIG;
snmp_status = AGUTIL_get_string_value(var_val, var_val_type,
var_val_len,
MAX_OWNERSTRING,
1, NULL, hdr->new_owner);
if (SNMP_ERR_NOERROR != snmp_status) {
return snmp_status;
}
break;
case Leaf_eventStatus:
snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
var_val_len,
RMON1_ENTRY_VALID,
RMON1_ENTRY_INVALID,
&long_temp);
if (SNMP_ERR_NOERROR != snmp_status) {
return snmp_status;
}
hdr->new_status = long_temp;
break;
default:
ag_trace("%s:unknown leaf_id=%d\n", table_ptr->name,
(int) leaf_id);
return SNMP_ERR_NOSUCHNAME;
} /* of switch by 'leaf_id' */
break;
} /* of switch by actions */
prev_action = action;
return SNMP_ERR_NOERROR;
}
/***************************************************
* Function:write_etherStatsEntry
***************************************************/
static int
write_etherStatsEntry(int action, u_char * var_val, u_char var_val_type,
size_t var_val_len, u_char * statP,
oid * name, size_t name_len)
{
long long_temp;
int leaf_id, snmp_status;
static int prev_action = COMMIT;
RMON_ENTRY_T *hdr;
CRTL_ENTRY_T *cloned_body;
CRTL_ENTRY_T *body;
switch (action) {
case RESERVE1:
case FREE:
case UNDO:
case ACTION:
case COMMIT:
default:
snmp_status =
ROWAPI_do_another_action(name, etherStatsEntryFirstIndexBegin,
action, &prev_action, table_ptr,
sizeof(CRTL_ENTRY_T));
if (SNMP_ERR_NOERROR != snmp_status) {
ag_trace("failed action %d with %d", action, snmp_status);
}
break;
case RESERVE2:
/*
* get values from PDU, check them and save them in the cloned entry
*/
long_temp = name[etherStatsEntryFirstIndexBegin];
leaf_id = (int) name[etherStatsEntryFirstIndexBegin - 1];
hdr = ROWAPI_find(table_ptr, long_temp); /* it MUST be OK */
cloned_body = (CRTL_ENTRY_T *) hdr->tmp;
body = (CRTL_ENTRY_T *) hdr->body;
switch (leaf_id) {
case Leaf_etherStatsDataSource:
snmp_status = AGUTIL_get_oid_value(var_val, var_val_type,
var_val_len,
&cloned_body->data_source);
if (SNMP_ERR_NOERROR != snmp_status) {
return snmp_status;
}
if (RMON1_ENTRY_UNDER_CREATION != hdr->status &&
snmp_oid_compare(cloned_body->data_source.objid,
cloned_body->data_source.length,
body->data_source.objid,
body->data_source.length))
return SNMP_ERR_BADVALUE;
break;
break;
case Leaf_etherStatsOwner:
if (hdr->new_owner)
AGFREE(hdr->new_owner);
hdr->new_owner = AGMALLOC(MAX_OWNERSTRING);;
if (!hdr->new_owner)
return SNMP_ERR_TOOBIG;
snmp_status = AGUTIL_get_string_value(var_val, var_val_type,
var_val_len,
MAX_OWNERSTRING,
1, NULL, hdr->new_owner);
if (SNMP_ERR_NOERROR != snmp_status) {
return snmp_status;
}
break;
case Leaf_etherStatsStatus:
snmp_status = AGUTIL_get_int_value(var_val, var_val_type,
var_val_len,
RMON1_ENTRY_VALID,
RMON1_ENTRY_INVALID,
&long_temp);
if (SNMP_ERR_NOERROR != snmp_status) {
ag_trace("cannot browse etherStatsStatus");
return snmp_status;
}
hdr->new_status = long_temp;
break;
break;
default:
ag_trace("%s:unknown leaf_id=%d\n", table_ptr->name,
(int) leaf_id);
return SNMP_ERR_NOSUCHNAME;
} /* of switch by 'leaf_id' */
break;
} /* of switch by 'action' */
prev_action = action;
return SNMP_ERR_NOERROR;
}
RMON_ENTRY_T *
ROWDATAAPI_header_DataEntry(struct variable * vp, oid * name,
size_t * length, int exact,
size_t * var_len,
TABLE_DEFINTION_T * table_ptr,
SCROLLER_T * (*extract_scroller) (void *body),
size_t data_size, void *entry_ptr)
{
long ctrl_indx, data_index;
RMON_ENTRY_T *hdr = NULL;
SCROLLER_T *scrlr;
NEXTED_PTR_T *bptr = NULL;
register u_long iii;
if (0 != AGUTIL_advance_index_name(vp, name, length, exact)) {
ag_trace("cannot advance_index_name");
return NULL;
}
ctrl_indx = vp->namelen >= *length ? 0 : name[vp->namelen];
if (ctrl_indx)
data_index =
((int)(vp->namelen + 1) >= (int)*length) ? 0 : name[vp->namelen + 1];
else
data_index = 0;
if (exact) {
if (ctrl_indx && data_index) {
hdr = ROWAPI_find(table_ptr, ctrl_indx);
if (hdr) {
scrlr = extract_scroller(hdr->body);
bptr = scrlr->first_data_ptr;
for (iii = 0; iii < scrlr->data_stored && bptr;
iii++, bptr = bptr->next) {
if ((long)bptr->data_index == data_index)
break;
}
if (!bptr)
hdr = NULL;
}
}
} else {
if (ctrl_indx)
hdr = ROWAPI_find(table_ptr, ctrl_indx);
else
hdr = ROWAPI_first(table_ptr);
if (hdr) {
scrlr = extract_scroller(hdr->body);
/*
* ag_trace ("get next after (%d %d)", (int) ctrl_indx, (int) data_index);
*/
bptr = scrlr->first_data_ptr;
for (iii = 0; iii < scrlr->data_stored && bptr;
iii++, bptr = bptr->next) {
if (bptr->data_index && (long)bptr->data_index > data_index)
break;
}
if (bptr && (long)bptr->data_index <= data_index)
bptr = NULL;
if (!bptr) { /* travel to next row */
/*
* ag_trace ("Dbg: travel to next row");
*/
for (hdr = hdr->next; hdr; hdr = hdr->next) {
if (RMON1_ENTRY_VALID != hdr->status)
continue;
scrlr = extract_scroller(hdr->body);
if (scrlr->data_stored <= 0)
continue;
for (bptr = scrlr->first_data_ptr; bptr;
bptr = bptr->next) {
if (bptr->data_index)
break;
}
if (bptr)
break;
}
}
if (bptr) { /* set new index */
/*
* ag_trace ("Dbg: So (%d %d)", (int) hdr->index, (int) bptr->data_index);
*/
name[vp->namelen] = hdr->ctrl_index;
name[vp->namelen + 1] = bptr->data_index;
*length = vp->namelen + 2;
} else
hdr = NULL;
}
}
if (hdr)
memcpy(entry_ptr, bptr, data_size);
return hdr;
}
int
ROWAPI_commit(TABLE_DEFINTION_T * table_ptr, u_long ctrl_index)
{
register RMON_ENTRY_T *eptr;
eptr = ROWAPI_find(table_ptr, ctrl_index);
if (!eptr) {
ag_trace("Smth wrong ?");
return SNMP_ERR_GENERR;
}
eptr->only_just_created = 0;
switch (eptr->new_status) { /* this status we want to set */
case RMON1_ENTRY_CREATE_REQUEST: /* copy tmp => eprt */
if (eptr->new_owner) {
if (eptr->owner)
AGFREE(eptr->owner);
eptr->owner = AGSTRDUP(eptr->new_owner);
}
if (table_ptr->ClbkCopy && eptr->tmp)
table_ptr->ClbkCopy(eptr);
break;
case RMON1_ENTRY_INVALID:
ROWAPI_delete_clone(table_ptr, ctrl_index);
rowapi_delete(eptr);
#if 0 /* for debug */
dbg_f_AG_MEM_REPORT();
#endif
break;
case RMON1_ENTRY_VALID: /* copy tmp => eprt and activate */
/*
* Our MIB understanding extension: we permit to set
* VALID when entry doesn't exit, in this case PDU has to have
* the nessessary & valid set of non-default values
*/
if (eptr->new_owner) {
if (eptr->owner)
AGFREE(eptr->owner);
eptr->owner = AGSTRDUP(eptr->new_owner);
}
if (table_ptr->ClbkCopy && eptr->tmp)
table_ptr->ClbkCopy(eptr);
if (RMON1_ENTRY_VALID != eptr->status) {
rowapi_activate(table_ptr, eptr);
}
break;
case RMON1_ENTRY_UNDER_CREATION: /* deactivate (if need) and copy tmp => eprt */
/*
* Our MIB understanding extension: we permit to travel from
* VALID to 'UNDER_CREATION' state
*/
rowapi_deactivate(table_ptr, eptr);
if (eptr->new_owner) {
if (eptr->owner)
AGFREE(eptr->owner);
eptr->owner = AGSTRDUP(eptr->new_owner);
}
if (table_ptr->ClbkCopy && eptr->tmp)
table_ptr->ClbkCopy(eptr);
break;
}
ROWAPI_delete_clone(table_ptr, ctrl_index);
return SNMP_ERR_NOERROR;
}
int
ROWAPI_action_check(TABLE_DEFINTION_T * table_ptr, u_long ctrl_index)
{
register RMON_ENTRY_T *eptr;
eptr = ROWAPI_find(table_ptr, ctrl_index);
if (!eptr) {
ag_trace("Smth wrong ?");
return SNMP_ERR_GENERR;
}
/*
* test owner string
*/
if (RMON1_ENTRY_UNDER_CREATION != eptr->status) {
/*
* Only the same value is allowed
*/
if (eptr->new_owner &&
(!eptr->owner
|| strncmp(eptr->new_owner, eptr->owner, MAX_OWNERSTRING))) {
ag_trace("invalid owner string in ROWAPI_action_check");
ag_trace("eptr->new_owner=%p eptr->owner=%p", eptr->new_owner,
eptr->owner);
return SNMP_ERR_BADVALUE;
}
}
switch (eptr->new_status) { /* this status we want to set */
case RMON1_ENTRY_CREATE_REQUEST:
if (RMON1_ENTRY_UNDER_CREATION != eptr->status)
return SNMP_ERR_BADVALUE;
break;
case RMON1_ENTRY_INVALID:
break;
case RMON1_ENTRY_VALID:
if (RMON1_ENTRY_VALID == eptr->status) {
break; /* nothing to do */
}
if (RMON1_ENTRY_UNDER_CREATION != eptr->status) {
ag_trace("Validate %s: entry %ld has wrong status %d",
table_ptr->name, (long) ctrl_index,
(int) eptr->status);
return SNMP_ERR_BADVALUE;
}
/*
* Our MIB understanding extension: we permit to set
* VALID when entry doesn't exit, in this case PDU has to have
* the nessessary & valid set of non-default values
*/
if (table_ptr->ClbkValidate) {
return table_ptr->ClbkValidate(eptr);
}
break;
case RMON1_ENTRY_UNDER_CREATION:
/*
* Our MIB understanding extension: we permit to travel from
* VALID to 'UNDER_CREATION' state
*/
break;
}
return SNMP_ERR_NOERROR;
}
static int
write_alarmEntry (int action, u_char * var_val, u_char var_val_type,
size_t var_val_len, u_char * statP, oid * name, size_t name_len)
{
long long_tmp;
int leaf_id, snmp_status;
static int prev_action = COMMIT;
RMON_ENTRY_T *hdr;
CRTL_ENTRY_T *cloned_body;
CRTL_ENTRY_T *body;
switch (action)
{
case RESERVE1:
case FREE:
case UNDO:
case ACTION:
case COMMIT:
default:
return ROWAPI_do_another_action (name, alarmEntryFirstIndexBegin,
action, &prev_action, table_ptr, sizeof (CRTL_ENTRY_T));
case RESERVE2:
/*
* get values from PDU, check them and save them in the cloned entry
*/
long_tmp = name[alarmEntryFirstIndexBegin];
leaf_id = (int) name[alarmEntryFirstIndexBegin - 1];
hdr = ROWAPI_find (table_ptr, long_tmp); /* it MUST be OK */
cloned_body = (CRTL_ENTRY_T *) hdr->tmp;
body = (CRTL_ENTRY_T *) hdr->body;
switch (leaf_id)
{
case IDalarmInterval:
snmp_status = AGUTIL_get_int_value (var_val, var_val_type, var_val_len, 0, MMM_MAX, &long_tmp);
if (SNMP_ERR_NOERROR != snmp_status)
{
return snmp_status;
}
cloned_body->interval = long_tmp;
break;
case IDalarmVariable:
snmp_status = AGUTIL_get_oid_value (var_val, var_val_type, var_val_len, &cloned_body->var_name);
if (SNMP_ERR_NOERROR != snmp_status)
{
return snmp_status;
}
if (RMON1_ENTRY_UNDER_CREATION != hdr->status &&
snmp_oid_compare (cloned_body->var_name.objid,
cloned_body->var_name.length, body->var_name.objid, body->var_name.length))
return SNMP_ERR_BADVALUE;
break;
break;
case IDalarmSampleType:
snmp_status = AGUTIL_get_int_value (var_val, var_val_type,
var_val_len,
SAMPLE_TYPE_ABSOLUTE, SAMPLE_TYPE_DELTE, &long_tmp);
if (SNMP_ERR_NOERROR != snmp_status)
{
return snmp_status;
}
cloned_body->sample_type = long_tmp;
break;
case IDalarmStartupAlarm:
snmp_status = AGUTIL_get_int_value (var_val, var_val_type,
var_val_len, ALARM_RISING, ALARM_BOTH, &long_tmp);
if (SNMP_ERR_NOERROR != snmp_status)
{
return snmp_status;
}
cloned_body->startup_type = long_tmp;
break;
case IDalarmRisingThreshold:
snmp_status = AGUTIL_get_int_value (var_val, var_val_type, var_val_len, 0, MMM_MAX, &long_tmp);
if (SNMP_ERR_NOERROR != snmp_status)
{
return snmp_status;
}
cloned_body->rising_threshold = long_tmp;
break;
case IDalarmFallingThreshold:
snmp_status = AGUTIL_get_int_value (var_val, var_val_type, var_val_len, 0, 0xFFFFFFFFl, &long_tmp);
if (SNMP_ERR_NOERROR != snmp_status)
{
return snmp_status;
}
cloned_body->falling_threshold = long_tmp;
break;
case IDalarmRisingEventIndex:
snmp_status = AGUTIL_get_int_value (var_val, var_val_type, var_val_len, 0, /* min. value */
0, /* max. value */
&long_tmp);
if (SNMP_ERR_NOERROR != snmp_status)
{
return snmp_status;
}
cloned_body->rising_event_index = long_tmp;
break;
case IDalarmFallingEventIndex:
snmp_status = AGUTIL_get_int_value (var_val, var_val_type, var_val_len, 0, /* min. value */
0, /* max. value */
&long_tmp);
if (SNMP_ERR_NOERROR != snmp_status)
{
return snmp_status;
}
cloned_body->falling_event_index = long_tmp;
break;
case IDalarmOwner:
if (hdr->new_owner)
AGFREE (hdr->new_owner);
hdr->new_owner = AGMALLOC (MAX_OWNERSTRING);;
if (!hdr->new_owner)
return SNMP_ERR_TOOBIG;
snmp_status = AGUTIL_get_string_value (var_val, var_val_type,
var_val_len, MAX_OWNERSTRING, 1, NULL, hdr->new_owner);
if (SNMP_ERR_NOERROR != snmp_status)
{
return snmp_status;
}
break;
case IDalarmStatus:
snmp_status = AGUTIL_get_int_value (var_val, var_val_type,
var_val_len, RMON1_ENTRY_VALID, RMON1_ENTRY_INVALID, &long_tmp);
if (SNMP_ERR_NOERROR != snmp_status)
{
return snmp_status;
}
hdr->new_status = long_tmp;
break;
default:
ag_trace ("%s:unknown leaf_id=%d\n", table_ptr->name, (int) leaf_id);
return SNMP_ERR_NOSUCHNAME;
} /* of switch by 'leaf_id' */
break;
} /* of switch by actions */
prev_action = action;
return SNMP_ERR_NOERROR;
}
