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; }