int
event_Clone(RMON_ENTRY_T * eptr)
{ /* copy entry_bod -> clone */
CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body;
CRTL_ENTRY_T *clone = (CRTL_ENTRY_T *) eptr->tmp;
if (body->event_description)
clone->event_description = AGSTRDUP(body->event_description);
if (body->event_community)
clone->event_community = AGSTRDUP(body->event_community);
return 0;
}
/*
* 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
event_Create(RMON_ENTRY_T * eptr)
{ /* create the body: alloc it and set defaults */
CRTL_ENTRY_T *body;
eptr->body = AGMALLOC(sizeof(CRTL_ENTRY_T));
if (!eptr->body)
return -3;
body = (CRTL_ENTRY_T *) eptr->body;
/*
* set defaults
*/
body->event_description = NULL;
body->event_community = AGSTRDUP("public");
/*
* ag_trace ("Dbg: created event_community=<%s>", body->event_community);
*/
body->event_type = EVENT_NONE;
ROWDATAAPI_init(&body->scrlr,
MAX_LOG_ENTRIES_PER_CTRL,
MAX_LOG_ENTRIES_PER_CTRL,
sizeof(DATA_ENTRY_T), &data_destructor);
return 0;
}
int
event_Copy(RMON_ENTRY_T * eptr)
{
CRTL_ENTRY_T *body = (CRTL_ENTRY_T *) eptr->body;
CRTL_ENTRY_T *clone = (CRTL_ENTRY_T *) eptr->tmp;
if (body->event_type != clone->event_type) {
body->event_type = clone->event_type;
}
if (clone->event_description) {
if (body->event_description)
AGFREE(body->event_description);
body->event_description = AGSTRDUP(clone->event_description);
}
if (clone->event_community) {
if (body->event_community)
AGFREE(body->event_community);
body->event_community = AGSTRDUP(clone->event_community);
}
return 0;
}
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);
*/
}
int
stat_Create(RMON_ENTRY_T * eptr)
{ /* create the body: alloc it and set defaults */
CRTL_ENTRY_T *body;
static VAR_OID_T data_src_if_index_1 =
{ 11, {1, 3, 6, 1, 2, 1, 2, 2, 1, 1, 1} };
eptr->body = AGMALLOC(sizeof(CRTL_ENTRY_T));
if (!eptr->body)
return -3;
body = (CRTL_ENTRY_T *) eptr->body;
/*
* set defaults
*/
memcpy(&body->data_source, &data_src_if_index_1, sizeof(VAR_OID_T));
body->data_source.objid[body->data_source.length - 1] =
eptr->ctrl_index;
eptr->owner = AGSTRDUP("Startup Mgmt");
memset(&body->eth, 0, sizeof(ETH_STATS_T));
return 0;
}
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;
}
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;
}
