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