/*
* 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;
}
int
ROWAPI_do_another_action (oid * name, int tbl_first_index_begin,
int action, int *prev_action, TABLE_DEFINTION_T * table_ptr, size_t entry_size)
{
long long_temp;
RMON_ENTRY_T *tmp;
if (action == *prev_action)
return SNMP_ERR_NOERROR; /* I want to process it only once ! */
*prev_action = action;
long_temp = name[tbl_first_index_begin];
switch (action)
{
case RESERVE1:
tmp = ROWAPI_get_clone (table_ptr, long_temp, entry_size);
if (!tmp)
{
ag_trace ("RESERVE1: cannot get clone\n");
return SNMP_ERR_TOOBIG;
}
break;
case FREE: /* if RESERVEx failed: release any resources that have been allocated */
case UNDO: /* if ACTION failed: release any resources that have been allocated */
ROWAPI_delete_clone (table_ptr, long_temp);
break;
case ACTION:
long_temp = ROWAPI_action_check (table_ptr, long_temp);
if (0 != long_temp)
return long_temp;
break;
case COMMIT:
long_temp = ROWAPI_commit (table_ptr, long_temp);
if (0 != long_temp) /* it MUST NOT be */
return long_temp;
break;
default:
ag_trace ("Unknown action %d", (int) action);
return SNMP_ERR_GENERR;
} /* of switch by actions */
return SNMP_ERR_NOERROR;
}
void *
ROWDATAAPI_locate_new_data(SCROLLER_T * scrlr)
{
register NEXTED_PTR_T *bptr;
if (!scrlr->current_data_ptr) { /* there was wrap */
bptr = scrlr->first_data_ptr;
if (!bptr) {
ag_trace("Err: SCROLLER_T:locate_new_data: internal error :(");
return NULL;
}
scrlr->first_data_ptr = bptr->next;
scrlr->last_data_ptr->next = bptr;
scrlr->last_data_ptr = (NEXTED_PTR_T *) bptr;
bptr->next = 0;
} else {
bptr = scrlr->current_data_ptr;
scrlr->current_data_ptr = bptr->next;
++scrlr->data_stored;
}
scrlr->data_total_number++;
return bptr;
}
/***************************************************
* Function:var_etherStats2Entry
* Purpose: Handles the request for etherStats2Entry variable instances
***************************************************/
u_char *
var_etherStats2Entry(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 = NULL;
hdr = ROWAPI_header_ControlEntry(vp, name, length, exact, var_len,
table_ptr,
&theEntry, sizeof(CRTL_ENTRY_T));
if (!hdr)
return NULL;
*var_len = sizeof(long); /* default */
switch (vp->magic) {
case IDetherStatsDroppedFrames:
long_return = 0;
return (u_char *) & long_return;
case IDetherStatsCreateTime:
long_return = theEntry.etherStatsCreateTime;
return (u_char *) & long_return;
default:
ag_trace("%s: unknown vp->magic=%d", table_ptr->name,
(int) vp->magic);
ERROR_MSG("");
}; /* of switch by 'vp->magic' */
return NULL;
}
static void rowapi_delete (RMON_ENTRY_T * eold)
{
register RMON_ENTRY_T *eptr;
register RMON_ENTRY_T *prev = NULL;
TABLE_DEFINTION_T *table_ptr;
table_ptr = (TABLE_DEFINTION_T *) eold->table_ptr;
/*
* delete timout scheduling
*/
snmp_alarm_unregister (eold->timer_id);
ag_trace ("Entry %ld in %s has been deleted", eold->ctrl_index, table_ptr->name);
/*
* It it was valid entry => deactivate it
*/
if (RMON1_ENTRY_VALID == eold->status)
{
if (table_ptr->ClbkDeactivate)
table_ptr->ClbkDeactivate (eold);
}
/*
* delete it in users's sence
*/
if (table_ptr->ClbkDelete)
table_ptr->ClbkDelete ((RMON_ENTRY_T *) eold->body);
if (eold->body)
{
AGFREE (eold->body);
}
if (eold->owner)
AGFREE (eold->owner);
/*
* delete it from the list in table
*/
table_ptr->current_number_of_entries--;
for (eptr = table_ptr->first; eptr; eptr = eptr->next)
{
if (eptr == eold)
break;
prev = eptr;
}
if (prev)
prev->next = eold->next;
else
table_ptr->first = eold->next;
AGFREE (eold);
}
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;
}
int alarm_Deactivate (RMON_ENTRY_T * eptr)
{
CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body;
snmp_alarm_unregister (body->timer_id);
#if 0 /* KUKU */
ag_trace ("kuku_sum=%ld kuku_cnt=%ld sp=%ld", (long) kuku_sum, (long) kuku_cnt, (long) (kuku_sum / kuku_cnt));
#endif
return 0;
}
static char *
create_explanaition(CRTL_ENTRY_T * evptr, u_char is_rising,
u_long alarm_index, u_long event_index,
oid * alarmed_var,
size_t alarmed_var_length,
u_long value, u_long the_threshold,
u_long sample_type, char *alarm_descr)
{
#define UNEQ_LENGTH (1 + 11 + 4 + 11 + 1 + 20)
char expl[UNEQ_LENGTH];
static char c_oid[SPRINT_MAX_LEN];
size_t sz;
char *descr;
register char *pch;
register char *tmp;
snprint_objid(c_oid, sizeof(c_oid)-1, alarmed_var, alarmed_var_length);
c_oid[sizeof(c_oid)-1] = '\0';
for (pch = c_oid;;) {
tmp = strchr(pch, '.');
if (!tmp)
break;
if (isdigit(tmp[1]) || '"' == tmp[1])
break;
pch = tmp + 1;
}
snprintf(expl, UNEQ_LENGTH, "=%ld %s= %ld :%ld, %ld",
(unsigned long) value,
is_rising ? ">" : "<",
(unsigned long) the_threshold,
(long) alarm_index, (long) event_index);
sz = 3 + strlen(expl) + strlen(pch);
if (alarm_descr)
sz += strlen(alarm_descr);
descr = AGMALLOC(sz);
if (!descr) {
ag_trace("Can't allocate event description");
return NULL;
}
if (alarm_descr) {
strcpy(descr, alarm_descr);
strcat(descr, ":");
} else
*descr = '\0';
strcat(descr, pch);
strcat(descr, expl);
return descr;
}
int alarm_Validate (RMON_ENTRY_T * eptr)
{
CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body;
if (body->rising_threshold <= body->falling_threshold)
{
ag_trace ("alarm_Validate failed: %lu must be > %lu", body->rising_threshold, body->falling_threshold);
return SNMP_ERR_BADVALUE;
}
return 0;
}
int
alarm_Activate(RMON_ENTRY_T * eptr)
{
CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body;
int ierr;
#if 0 /* KUKU */
kuku_sum = 0;
kuku_cnt = 0;
#endif
ierr = fetch_var_val(body->var_name.objid,
body->var_name.length, &body->last_abs_value);
if (SNMP_ERR_NOERROR != ierr) {
ag_trace("Can't fetch var_name");
return ierr;
}
if (SAMPLE_TYPE_ABSOLUTE != body->sample_type) {
/*
* check startup alarm
*/
if (ALARM_RISING == body->startup_type ||
ALARM_BOTH == body->startup_type) {
if (body->last_abs_value >= body->rising_threshold) {
event_api_send_alarm(1, eptr->ctrl_index,
body->rising_event_index,
body->var_name.objid,
body->var_name.length,
ALARM_RISING, body->value,
body->rising_threshold,
"Startup Rising");
}
}
if (ALARM_FALLING == body->startup_type ||
ALARM_BOTH == body->startup_type) {
if (body->last_abs_value <= body->falling_threshold) {
event_api_send_alarm(0, eptr->ctrl_index,
body->falling_event_index,
body->var_name.objid,
body->var_name.length,
ALARM_RISING, body->value,
body->falling_threshold,
"Startup Falling");
}
}
}
body->timer_id = snmp_alarm_register(body->interval, SA_REPEAT,
alarm_check_var, eptr);
return 0;
}
static int rowapi_activate (TABLE_DEFINTION_T * table_ptr, RMON_ENTRY_T * eptr)
{
RMON1_ENTRY_STATUS_T prev_status = eptr->status;
eptr->status = RMON1_ENTRY_VALID;
if (table_ptr->ClbkActivate)
{
if (0 != table_ptr->ClbkActivate (eptr))
{
ag_trace ("Can't activate entry #%ld in %s", eptr->ctrl_index, table_ptr->name);
eptr->status = prev_status;
return SNMP_ERR_BADVALUE;
}
}
snmp_alarm_unregister (eptr->timer_id);
eptr->timer_id = 0;
ag_trace ("Entry %ld in %s has been activated", eptr->ctrl_index, table_ptr->name);
return SNMP_ERR_NOERROR;
}
static void realloc_number_of_data (SCROLLER_T * scrlr, long dlong)
{
void *bptr; /* DATA_ENTRY_T */
NEXTED_PTR_T *prev = NULL;
void *first = NULL;
if (dlong > 0)
{
for (; dlong; dlong--, prev = bptr, scrlr->data_created++)
{
bptr = AGMALLOC (scrlr->data_size);
if (!bptr)
{
ag_trace ("Err: no memory for data");
break;
}
memset (bptr, 0, scrlr->data_size);
if (prev)
prev->next = bptr;
else
first = bptr;
} /* of loop by malloc bucket */
if (!scrlr->current_data_ptr)
scrlr->current_data_ptr = first;
if (scrlr->last_data_ptr)
{
scrlr->last_data_ptr->next = first;
}
else
scrlr->first_data_ptr = first;
scrlr->last_data_ptr = bptr;
}
else
{
for (; dlong && scrlr->data_created > 0; dlong++)
{
if (scrlr->current_data_ptr)
delete_data_entry (scrlr, scrlr->current_data_ptr);
else
delete_data_entry (scrlr, scrlr->first_data_ptr);
}
}
}
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;
}
static void
rowapi_too_long_creation_callback(unsigned int clientreg, void *clientarg)
{
RMON_ENTRY_T *eptr;
TABLE_DEFINTION_T *table_ptr;
eptr = (RMON_ENTRY_T *) clientarg;
table_ptr = (TABLE_DEFINTION_T *) eptr->table_ptr;
if (RMON1_ENTRY_VALID != eptr->status) {
ag_trace("row #%d in %s was under creation more then %ld sec.",
eptr->ctrl_index, table_ptr->name,
(long) MAX_CREATION_TIME);
rowapi_delete(eptr);
} else {
snmp_alarm_unregister(eptr->timer_id);
}
}
static int rowapi_deactivate (TABLE_DEFINTION_T * table_ptr, RMON_ENTRY_T * eptr)
{
if (RMON1_ENTRY_UNDER_CREATION == eptr->status)
{
/*
* nothing to do
*/
return SNMP_ERR_NOERROR;
}
if (table_ptr->ClbkDeactivate)
table_ptr->ClbkDeactivate (eptr);
eptr->status = RMON1_ENTRY_UNDER_CREATION;
eptr->timer_id = snmp_alarm_register (MAX_CREATION_TIME, 0, rowapi_too_long_creation_callback, eptr);
ag_trace ("Entry %ld in %s has been deactivated", eptr->ctrl_index, table_ptr->name);
return SNMP_ERR_NOERROR;
}
static netsnmp_variable_list *
oa_bind_var(netsnmp_variable_list * prev,
void *value, int type, size_t sz_val, oid * oid, size_t sz_oid)
{
netsnmp_variable_list *var;
var = (netsnmp_variable_list *) malloc(sizeof(netsnmp_variable_list));
if (!var) {
ag_trace("FATAL: cannot malloc in oa_bind_var\n");
exit(-1); /* Sorry :( */
}
memset(var, 0, sizeof(netsnmp_variable_list));
var->next_variable = prev;
snmp_set_var_objid(var, oid, sz_oid);
snmp_set_var_value(var, (u_char *) value, sz_val);
var->type = type;
return var;
}
static void
event_save_log(CRTL_ENTRY_T * body, char *event_descr)
{
register DATA_ENTRY_T *lptr;
lptr = ROWDATAAPI_locate_new_data(&body->scrlr);
if (!lptr) {
ag_trace("Err: event_save_log:cannot locate ?");
return;
}
lptr->log_time = body->event_last_time_sent;
if (lptr->log_description)
AGFREE(lptr->log_description);
lptr->log_description = AGSTRDUP(event_descr);
lptr->data_index = ROWDATAAPI_get_total_number(&body->scrlr);
/*
* ag_trace ("log has been saved, data_index=%d", (int) lptr->data_index);
*/
}
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;
}
int alarm_Copy (RMON_ENTRY_T * eptr)
{
CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body;
CRTL_ENTRY_T *clone = (CRTL_ENTRY_T *) eptr->tmp;
if (RMON1_ENTRY_VALID == eptr->status && clone->rising_threshold <= clone->falling_threshold)
{
ag_trace ("alarm_Copy failed: invalid thresholds");
return SNMP_ERR_BADVALUE;
}
if (clone->interval != body->interval)
{
if (RMON1_ENTRY_VALID == eptr->status)
{
snmp_alarm_unregister (body->timer_id);
body->timer_id = snmp_alarm_register (clone->interval, SA_REPEAT, alarm_check_var, eptr);
}
body->interval = clone->interval;
}
if (snmp_oid_compare (clone->var_name.objid, clone->var_name.length, body->var_name.objid, body->var_name.length))
{
memcpy (&body->var_name, &clone->var_name, sizeof (VAR_OID_T));
}
body->sample_type = clone->sample_type;
body->startup_type = clone->startup_type;
body->sample_type = clone->sample_type;
body->rising_threshold = clone->rising_threshold;
body->falling_threshold = clone->falling_threshold;
body->rising_event_index = clone->rising_event_index;
body->falling_event_index = clone->falling_event_index;
/*
* ag_trace ("alarm_Copy: rising_threshold=%lu falling_threshold=%lu",
* body->rising_threshold, body->falling_threshold);
*/
return 0;
}
/***************************************************
* 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;
}
/*
* creates an entry, locats it in proper sorted order by index
* Row is initialized to zero,
* except: 'next', 'table_ptr', 'index',
* 'timer_id' & 'status'=(RMON1_ENTRY_UNDER_CREATION)
* Calls (if need) ClbkCreate.
* Schedules for timeout under entry creation (id of this
* scheduling is saved in 'timer_id').
* Returns 0: OK,
-1:max. number exedes;
-2:malloc failed;
-3:ClbkCreate failed */
int
ROWAPI_new(TABLE_DEFINTION_T * table_ptr, u_long ctrl_index)
{
register RMON_ENTRY_T *eptr;
register RMON_ENTRY_T *prev = NULL;
register RMON_ENTRY_T *enew;
/*
* check on 'max.number'
*/
if (table_ptr->max_number_of_entries > 0 &&
table_ptr->current_number_of_entries >=
table_ptr->max_number_of_entries)
return -1;
/*
* allocate memory for the header
*/
enew = (RMON_ENTRY_T *) AGMALLOC(sizeof(RMON_ENTRY_T));
if (!enew)
return -2;
/*
* init the header
*/
memset(enew, 0, sizeof(RMON_ENTRY_T));
enew->ctrl_index = ctrl_index;
enew->table_ptr = (void *) table_ptr;
enew->status = RMON1_ENTRY_UNDER_CREATION;
enew->only_just_created = 1;
/*
* create the body: alloc it and set defaults
*/
if (table_ptr->ClbkCreate) {
if (0 != table_ptr->ClbkCreate(enew)) {
AGFREE(enew);
return -3;
}
}
table_ptr->current_number_of_entries++;
/*
* find the place : before 'eptr' and after 'prev'
*/
for (eptr = table_ptr->first; eptr; eptr = eptr->next) {
if (ctrl_index < eptr->ctrl_index)
break;
prev = eptr;
}
/*
* insert it
*/
enew->next = eptr;
if (prev)
prev->next = enew;
else
table_ptr->first = enew;
enew->timer_id = snmp_alarm_register(MAX_CREATION_TIME, 0,
rowapi_too_long_creation_callback,
enew);
ag_trace("Entry %ld in %s has been created",
enew->ctrl_index, table_ptr->name);
return 0;
}
static void
event_send_trap(CRTL_ENTRY_T * evptr, u_char is_rising,
u_int alarm_index,
u_int value, u_int the_threshold,
oid * alarmed_var, size_t alarmed_var_length,
u_int sample_type)
{
static oid objid_snmptrap[] = { 1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0 };
static oid rmon1_trap_oid[] = { 1, 3, 6, 1, 2, 1, 16, 0, 0 };
static oid alarm_index_oid[] =
{ 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 1, 0 };
static oid alarmed_var_oid[] =
{ 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 3, 0 };
static oid sample_type_oid[] =
{ 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 4, 0 };
static oid value_oid[] = { 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 5, 0 };
static oid threshold_oid[] = { 1, 3, 6, 1, 2, 1, 16, 3, 1, 1, 7, 0 }; /* rising case */
netsnmp_variable_list *var_list = NULL;
/*
* set the last 'oid' : risingAlarm or fallingAlarm
*/
if (is_rising) {
rmon1_trap_oid[8] = 1;
threshold_oid[10] = 7;
} else {
rmon1_trap_oid[8] = 2;
threshold_oid[10] = 8;
}
alarm_index_oid[11] = alarm_index;
alarmed_var_oid[11] = alarm_index;
sample_type_oid[11] = alarm_index;
value_oid[11] = alarm_index;
threshold_oid[11] = alarm_index;
/*
* build the var list
*/
snmp_varlist_add_variable(&var_list, objid_snmptrap,
OID_LENGTH(objid_snmptrap),
ASN_OBJECT_ID, (u_char *) rmon1_trap_oid,
sizeof(rmon1_trap_oid));
snmp_varlist_add_variable(&var_list, alarm_index_oid,
OID_LENGTH(alarm_index_oid),
ASN_INTEGER, (u_char *) &alarm_index,
sizeof(u_int));
snmp_varlist_add_variable(&var_list, alarmed_var_oid,
OID_LENGTH(alarmed_var_oid),
ASN_OBJECT_ID, (u_char *) alarmed_var,
alarmed_var_length * sizeof(oid));
snmp_varlist_add_variable(&var_list, sample_type_oid,
OID_LENGTH(sample_type_oid),
ASN_INTEGER, (u_char *) &sample_type,
sizeof(u_int));
snmp_varlist_add_variable(&var_list, value_oid,
OID_LENGTH(value_oid),
ASN_INTEGER, (u_char *) &value,
sizeof(u_int));
snmp_varlist_add_variable(&var_list, threshold_oid,
OID_LENGTH(threshold_oid),
ASN_INTEGER, (u_char *) &the_threshold,
sizeof(u_int));
send_v2trap(var_list);
ag_trace("rmon trap has been sent");
snmp_free_varbind(var_list);
}
unsigned char *
var_eventTable(struct variable *vp,
oid * name,
size_t * length,
int exact, size_t * var_len, WriteMethod ** write_method)
{
static long long_ret;
static CRTL_ENTRY_T theEntry;
RMON_ENTRY_T *hdr;
*write_method = write_eventControl;
hdr = ROWAPI_header_ControlEntry(vp, name, length, exact, var_len,
table_ptr,
&theEntry, sizeof(CRTL_ENTRY_T));
if (!hdr)
return NULL;
*var_len = sizeof(long); /* default */
switch (vp->magic) {
case EVENTINDEX:
long_ret = hdr->ctrl_index;
return (unsigned char *) &long_ret;
case EVENTDESCRIPTION:
if (theEntry.event_description) {
*var_len = strlen(theEntry.event_description);
return (unsigned char *) theEntry.event_description;
} else {
*var_len = 0;
return zero_octet_string;
}
case EVENTTYPE:
long_ret = theEntry.event_type;
return (unsigned char *) &long_ret;
case EVENTCOMMUNITY:
if (theEntry.event_community) {
*var_len = strlen(theEntry.event_community);
return (unsigned char *) theEntry.event_community;
} else {
*var_len = 0;
return zero_octet_string;
}
case EVENTLASTTIMESENT:
long_ret = theEntry.event_last_time_sent;
return (unsigned char *) &long_ret;
case EVENTOWNER:
if (hdr->owner) {
*var_len = strlen(hdr->owner);
return (unsigned char *) hdr->owner;
} else {
*var_len = 0;
return zero_octet_string;
}
case EVENTSTATUS:
long_ret = hdr->status;
return (unsigned char *) &long_ret;
default:
ag_trace("EventControlTable: unknown vp->magic=%d",
(int) vp->magic);
ERROR_MSG("");
}
return NULL;
}
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;
}
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;
}
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;
}
u_char *var_alarmEntry (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_alarmEntry;
hdr = ROWAPI_header_ControlEntry (vp, name, length, exact, var_len, table_ptr, &theEntry, sizeof (CRTL_ENTRY_T));
if (!hdr)
return NULL;
*var_len = sizeof (long); /* default */
switch (vp->magic)
{
case IDalarmIndex:
long_return = hdr->ctrl_index;
return (u_char *) & long_return;
case IDalarmInterval:
long_return = theEntry.interval;
return (u_char *) & long_return;
case IDalarmVariable:
*var_len = sizeof (oid) * theEntry.var_name.length;
return (unsigned char *) theEntry.var_name.objid;
return (u_char *) & long_return;
case IDalarmSampleType:
long_return = theEntry.sample_type;
return (u_char *) & long_return;
case IDalarmValue:
long_return = theEntry.value;
return (u_char *) & long_return;
case IDalarmStartupAlarm:
long_return = theEntry.startup_type;
return (u_char *) & long_return;
case IDalarmRisingThreshold:
long_return = theEntry.rising_threshold;
return (u_char *) & long_return;
case IDalarmFallingThreshold:
long_return = theEntry.falling_threshold;
return (u_char *) & long_return;
case IDalarmRisingEventIndex:
long_return = theEntry.rising_event_index;
return (u_char *) & long_return;
case IDalarmFallingEventIndex:
long_return = theEntry.falling_event_index;
return (u_char *) & long_return;
case IDalarmOwner:
if (hdr->owner)
{
*var_len = strlen (hdr->owner);
return (unsigned char *) hdr->owner;
}
else
{
*var_len = 0;
return (unsigned char *) "";
}
case IDalarmStatus:
long_return = hdr->status;
return (u_char *) & long_return;
default:
ag_trace ("%s: unknown vp->magic=%d", table_ptr->name, (int) vp->magic);
ERROR_MSG ("");
}; /* of switch by 'vp->magic' */
return NULL;
}
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;
}
