/** handles requests for the mteEventNotificationTable table */ int mteEventNotificationTable_handler(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo, netsnmp_request_info *requests) { netsnmp_request_info *request; netsnmp_table_request_info *tinfo; struct mteEvent *entry; int ret; DEBUGMSGTL(("disman:event:mib", "Notification Table handler (%d)\n", reqinfo->mode)); switch (reqinfo->mode) { /* * Read-support (also covers GetNext requests) */ case MODE_GET: for (request = requests; request; request = request->next) { entry = (struct mteEvent *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); /* * The mteEventNotificationTable should only contains entries * for rows where the mteEventActions 'notification(0)' bit * is set. So skip entries where this isn't the case. */ if (!entry || !(entry->mteEventActions & MTE_EVENT_NOTIFICATION)) continue; switch (tinfo->colnum) { case COLUMN_MTEEVENTNOTIFICATION: snmp_set_var_typed_value(request->requestvb, ASN_OBJECT_ID, (u_char *) entry->mteNotification, entry->mteNotification_len*sizeof(oid)); break; case COLUMN_MTEEVENTNOTIFICATIONOBJECTSOWNER: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, (u_char *) entry->mteNotifyOwner, strlen(entry->mteNotifyOwner)); break; case COLUMN_MTEEVENTNOTIFICATIONOBJECTS: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, (u_char *) entry->mteNotifyObjects, strlen(entry->mteNotifyObjects)); break; } } break; /* * Write-support */ case MODE_SET_RESERVE1: for (request = requests; request; request = request->next) { tinfo = netsnmp_extract_table_info(request); /* * Since the mteEventNotificationTable only contains entries * for rows where the mteEventActions 'notification(0)' * bit is set, strictly speaking we should reject * assignments where this isn't the case. * But SET requests that include an assignment of the * 'notification(0)' bit at the same time are valid, * so would need to be accepted. Unfortunately, this * assignment is only applied in the COMMIT pass, so * it's difficult to detect whether this holds or not. * * Let's fudge things for now, by processing assignments * even if the 'notification(0)' bit isn't set. */ switch (tinfo->colnum) { case COLUMN_MTEEVENTNOTIFICATION: ret = netsnmp_check_vb_oid( request->requestvb ); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_MTEEVENTNOTIFICATIONOBJECTSOWNER: case COLUMN_MTEEVENTNOTIFICATIONOBJECTS: ret = netsnmp_check_vb_type_and_max_size( request->requestvb, ASN_OCTET_STR, MTE_STR1_LEN); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; default: netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOTWRITABLE); return SNMP_ERR_NOERROR; } /* * The Event MIB is somewhat ambiguous as to whether * mteEventNotificationTable (and mteEventSetTable) * entries can be modified once the main mteEventTable * entry has been marked 'active'. * But it's clear from discussion on the DisMan mailing * list is that the intention is not. * * So check for whether this row is already active, * and reject *all* SET requests if it is. */ entry = (struct mteEvent *) netsnmp_tdata_extract_entry(request); if (entry && entry->flags & MTE_EVENT_FLAG_ACTIVE ) { netsnmp_set_request_error(reqinfo, request, SNMP_ERR_INCONSISTENTVALUE); return SNMP_ERR_NOERROR; } } break; case MODE_SET_RESERVE2: case MODE_SET_FREE: case MODE_SET_UNDO: break; case MODE_SET_ACTION: for (request = requests; request; request = request->next) { entry = (struct mteEvent *) netsnmp_tdata_extract_entry(request); if (!entry) { /* * New rows must be created via the RowStatus column * (in the main mteEventTable) */ netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOCREATION); /* or inconsistentName? */ return SNMP_ERR_NOERROR; } } break; case MODE_SET_COMMIT: /* * All these assignments are "unfailable", so it's * (reasonably) safe to apply them in the Commit phase */ for (request = requests; request; request = request->next) { entry = (struct mteEvent *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_MTEEVENTNOTIFICATION: memset(entry->mteNotification, 0, sizeof(entry->mteNotification)); memcpy(entry->mteNotification, request->requestvb->val.objid, request->requestvb->val_len); entry->mteNotification_len = request->requestvb->val_len/sizeof(oid); break; case COLUMN_MTEEVENTNOTIFICATIONOBJECTSOWNER: memset(entry->mteNotifyOwner, 0, sizeof(entry->mteNotifyOwner)); memcpy(entry->mteNotifyOwner, request->requestvb->val.string, request->requestvb->val_len); break; case COLUMN_MTEEVENTNOTIFICATIONOBJECTS: memset(entry->mteNotifyObjects, 0, sizeof(entry->mteNotifyObjects)); memcpy(entry->mteNotifyObjects, request->requestvb->val.string, request->requestvb->val_len); break; } } break; } return SNMP_ERR_NOERROR; }
/** handles requests for the expObjectTable table */ int expObjectTable_handler(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo, netsnmp_request_info *requests) { netsnmp_request_info *request; netsnmp_table_request_info *tinfo; netsnmp_tdata_row *row; struct expObject *entry; struct expExpression *exp; char expOwner[EXP_STR1_LEN+1]; char expName[ EXP_STR1_LEN+1]; long objIndex; long ret; netsnmp_variable_list *vp; DEBUGMSGTL(("disman:expr:mib", "Expression Object Table handler (%d)\n", reqinfo->mode)); switch (reqinfo->mode) { /* * Read-support (also covers GetNext requests) */ case MODE_GET: for (request = requests; request; request = request->next) { entry = (struct expObject *)netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); if (!entry || !(entry->flags & EXP_OBJ_FLAG_VALID)) continue; switch (tinfo->colnum) { case COLUMN_EXPOBJECTID: snmp_set_var_typed_value(request->requestvb, ASN_OBJECT_ID, (u_char *) entry->expObjectID, entry->expObjectID_len*sizeof(oid)); break; case COLUMN_EXPOBJECTIDWILDCARD: ret = (entry->flags & EXP_OBJ_FLAG_OWILD) ? TV_TRUE : TV_FALSE; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; case COLUMN_EXPOBJECTSAMPLETYPE: snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, entry->expObjectSampleType); break; case COLUMN_EXPOBJECTDELTADISCONTINUITYID: /* * "This object [and the next two] are instantiated only if * expObjectSampleType is 'deltaValue' or 'changedValue'" */ if ( entry->expObjectSampleType == 1 ) continue; snmp_set_var_typed_value(request->requestvb, ASN_OBJECT_ID, (u_char *) entry->expObjDeltaD, entry->expObjDeltaD_len*sizeof(oid)); break; case COLUMN_EXPOBJECTDISCONTINUITYIDWILDCARD: if ( entry->expObjectSampleType == 1 ) continue; ret = (entry->flags & EXP_OBJ_FLAG_DWILD) ? TV_TRUE : TV_FALSE; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; case COLUMN_EXPOBJECTDISCONTINUITYIDTYPE: if ( entry->expObjectSampleType == 1 ) continue; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, entry->expObjDiscontinuityType); break; case COLUMN_EXPOBJECTCONDITIONAL: snmp_set_var_typed_value(request->requestvb, ASN_OBJECT_ID, (u_char *) entry->expObjCond, entry->expObjCond_len*sizeof(oid)); break; case COLUMN_EXPOBJECTCONDITIONALWILDCARD: ret = (entry->flags & EXP_OBJ_FLAG_CWILD) ? TV_TRUE : TV_FALSE; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; case COLUMN_EXPOBJECTENTRYSTATUS: /* What would indicate 'notReady' ? */ ret = (entry->flags & EXP_OBJ_FLAG_ACTIVE) ? RS_ACTIVE : RS_NOTINSERVICE; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; } } break; /* * Write-support */ case MODE_SET_RESERVE1: for (request = requests; request; request = request->next) { entry = (struct expObject *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_EXPOBJECTID: case COLUMN_EXPOBJECTDELTADISCONTINUITYID: case COLUMN_EXPOBJECTCONDITIONAL: ret = netsnmp_check_vb_oid(request->requestvb); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_EXPOBJECTIDWILDCARD: case COLUMN_EXPOBJECTDISCONTINUITYIDWILDCARD: case COLUMN_EXPOBJECTCONDITIONALWILDCARD: ret = netsnmp_check_vb_truthvalue(request->requestvb); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_EXPOBJECTSAMPLETYPE: case COLUMN_EXPOBJECTDISCONTINUITYIDTYPE: ret = netsnmp_check_vb_int_range(request->requestvb, 1, 3); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_EXPOBJECTENTRYSTATUS: ret = netsnmp_check_vb_rowstatus(request->requestvb, (entry ? RS_ACTIVE : RS_NONEXISTENT)); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; default: netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOTWRITABLE); return SNMP_ERR_NOERROR; } } break; case MODE_SET_RESERVE2: for (request = requests; request; request = request->next) { tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_EXPOBJECTENTRYSTATUS: switch (*request->requestvb->val.integer) { case RS_CREATEANDGO: case RS_CREATEANDWAIT: /* * Create an (empty) new row structure */ memset(expOwner, 0, sizeof(expOwner)); memcpy(expOwner, tinfo->indexes->val.string, tinfo->indexes->val_len); memset(expName, 0, sizeof(expName)); memcpy(expName, tinfo->indexes->next_variable->val.string, tinfo->indexes->next_variable->val_len); vp = tinfo->indexes->next_variable->next_variable; objIndex = *vp->val.integer; row = expObject_createRow(expOwner, expName, objIndex, 0); if (!row) { netsnmp_set_request_error(reqinfo, request, SNMP_ERR_RESOURCEUNAVAILABLE); return SNMP_ERR_NOERROR; } netsnmp_insert_tdata_row( request, row ); } } } break; case MODE_SET_FREE: for (request = requests; request; request = request->next) { tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_EXPOBJECTENTRYSTATUS: switch (*request->requestvb->val.integer) { case RS_CREATEANDGO: case RS_CREATEANDWAIT: /* * Tidy up after a failed row creation request */ entry = (struct expObject *) netsnmp_tdata_extract_entry(request); if (entry && !(entry->flags & EXP_OBJ_FLAG_VALID)) { row = (netsnmp_tdata_row *) netsnmp_tdata_extract_row(request); expObject_removeEntry( row ); } } } } break; case MODE_SET_ACTION: for (request = requests; request; request = request->next) { tinfo = netsnmp_extract_table_info(request); entry = (struct expObject *) netsnmp_tdata_extract_entry(request); if (!entry) { /* * New rows must be created via the RowStatus column */ netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOCREATION); /* or inconsistentName? */ return SNMP_ERR_NOERROR; } } break; case MODE_SET_UNDO: break; case MODE_SET_COMMIT: /* * All these assignments are "unfailable", so it's * (reasonably) safe to apply them in the Commit phase */ ret = 0; /* Flag to re-check expExpressionPrefix settings */ for (request = requests; request; request = request->next) { entry = (struct expObject *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_EXPOBJECTID: memset(entry->expObjectID, 0, sizeof(entry->expObjectID)); memcpy(entry->expObjectID, request->requestvb->val.string, request->requestvb->val_len); entry->expObjectID_len = request->requestvb->val_len; break; case COLUMN_EXPOBJECTIDWILDCARD: if (*request->requestvb->val.integer == TV_TRUE) entry->flags |= EXP_OBJ_FLAG_OWILD; else entry->flags &= ~EXP_OBJ_FLAG_OWILD; break; case COLUMN_EXPOBJECTSAMPLETYPE: entry->expObjectSampleType = *request->requestvb->val.integer; break; case COLUMN_EXPOBJECTDELTADISCONTINUITYID: memset(entry->expObjDeltaD, 0, sizeof(entry->expObjDeltaD)); memcpy(entry->expObjDeltaD, request->requestvb->val.string, request->requestvb->val_len); entry->expObjDeltaD_len = request->requestvb->val_len/sizeof(oid); /* XXX if ( snmp_oid_compare( entry->expObjDeltaD, entry->expObjDeltaD_len, sysUpTime_inst, sysUpTime_inst_len ) != 0 ) entry->flags |= EXP_OBJ_FLAG_DDISC; */ /* * If the OID used for the expExpressionPrefix object * has changed, then update the expression structure. */ if ( entry->flags & EXP_OBJ_FLAG_PREFIX ) { exp = expExpression_getEntry( entry->expOwner, entry->expName ); memcpy( exp->expPrefix, entry->expObjDeltaD, MAX_OID_LEN*sizeof(oid)); exp->expPrefix_len = entry->expObjDeltaD_len; } break; case COLUMN_EXPOBJECTDISCONTINUITYIDWILDCARD: if (*request->requestvb->val.integer == TV_TRUE) { /* * Possible new prefix OID candidate * Can't set the value here, since the OID * assignment might not have been processed yet. */ exp = expExpression_getEntry( entry->expOwner, entry->expName ); if (exp && exp->expPrefix_len == 0 ) ret = 1; /* Set the prefix later */ entry->flags |= EXP_OBJ_FLAG_DWILD; } else { if ( entry->flags | EXP_OBJ_FLAG_PREFIX ) { exp = expExpression_getEntry( entry->expOwner, entry->expName ); memset( exp->expPrefix, 0, MAX_OID_LEN*sizeof(oid)); exp->expPrefix_len = 0; ret = 1; /* Need a new prefix OID */ } entry->flags &= ~EXP_OBJ_FLAG_DWILD; } break; case COLUMN_EXPOBJECTDISCONTINUITYIDTYPE: entry->expObjDiscontinuityType = *request->requestvb->val.integer; break; case COLUMN_EXPOBJECTCONDITIONAL: memset(entry->expObjCond, 0, sizeof(entry->expObjCond)); memcpy(entry->expObjCond, request->requestvb->val.string, request->requestvb->val_len); entry->expObjCond_len = request->requestvb->val_len/sizeof(oid); break; case COLUMN_EXPOBJECTCONDITIONALWILDCARD: if (*request->requestvb->val.integer == TV_TRUE) entry->flags |= EXP_OBJ_FLAG_CWILD; else entry->flags &= ~EXP_OBJ_FLAG_CWILD; break; case COLUMN_EXPOBJECTENTRYSTATUS: switch (*request->requestvb->val.integer) { case RS_ACTIVE: entry->flags |= EXP_OBJ_FLAG_ACTIVE; break; case RS_NOTINSERVICE: entry->flags &= ~EXP_OBJ_FLAG_ACTIVE; break; case RS_CREATEANDGO: entry->flags |= EXP_OBJ_FLAG_ACTIVE; entry->flags |= EXP_OBJ_FLAG_VALID; break; case RS_CREATEANDWAIT: entry->flags |= EXP_OBJ_FLAG_VALID; break; case RS_DESTROY: row = (netsnmp_tdata_row *) netsnmp_tdata_extract_row(request); expObject_removeEntry(row); } } } /* * Need to check for changes in expExpressionPrefix handling */ for (request = requests; request; request = request->next) { entry = (struct expObject *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_EXPOBJECTDISCONTINUITYIDWILDCARD: /* * If a column has just been marked as wild, * then consider using it as the prefix OID */ if (*request->requestvb->val.integer == TV_TRUE) { exp = expExpression_getEntry( entry->expOwner, entry->expName ); if ( exp->expPrefix_len == 0 ) { memcpy( exp->expPrefix, entry->expObjDeltaD, MAX_OID_LEN*sizeof(oid)); exp->expPrefix_len = entry->expObjDeltaD_len; entry->flags |= EXP_OBJ_FLAG_PREFIX; } } /* * If it's just been marked as non-wildcarded * then we need to look for a new candidate. */ else { } break; } } break; } DEBUGMSGTL(("disman:expr:mib", "Expression Object handler - done \n")); return SNMP_ERR_NOERROR; }
/** handles requests for the mteEventSetTable table */ int mteEventSetTable_handler (netsnmp_mib_handler * handler, netsnmp_handler_registration * reginfo, netsnmp_agent_request_info * reqinfo, netsnmp_request_info * requests) { netsnmp_request_info *request; netsnmp_table_request_info *tinfo; struct mteEvent *entry; int ret; DEBUGMSGTL (("disman:event:mib", "Set Table handler (%d)\n", reqinfo->mode)); switch (reqinfo->mode) { /* * Read-support (also covers GetNext requests) */ case MODE_GET: for (request = requests; request; request = request->next) { if (request->processed) continue; entry = (struct mteEvent *) netsnmp_tdata_extract_entry (request); tinfo = netsnmp_extract_table_info (request); /* * The mteEventSetTable should only contains entries for * rows where the mteEventActions 'set(1)' bit is set. * So skip entries where this isn't the case. */ if (!entry || !(entry->mteEventActions & MTE_EVENT_SET)) continue; switch (tinfo->colnum) { case COLUMN_MTEEVENTSETOBJECT: snmp_set_var_typed_value (request->requestvb, ASN_OBJECT_ID, (u_char *) entry->mteSetOID, entry->mteSetOID_len * sizeof (oid)); break; case COLUMN_MTEEVENTSETOBJECTWILDCARD: ret = (entry->flags & MTE_SET_FLAG_OBJWILD) ? TV_TRUE : TV_FALSE; snmp_set_var_typed_integer (request->requestvb, ASN_INTEGER, ret); break; case COLUMN_MTEEVENTSETVALUE: snmp_set_var_typed_integer (request->requestvb, ASN_INTEGER, entry->mteSetValue); break; case COLUMN_MTEEVENTSETTARGETTAG: snmp_set_var_typed_value (request->requestvb, ASN_OCTET_STR, (u_char *) entry->mteSetTarget, strlen (entry->mteSetTarget)); break; case COLUMN_MTEEVENTSETCONTEXTNAME: snmp_set_var_typed_value (request->requestvb, ASN_OCTET_STR, (u_char *) entry->mteSetContext, strlen (entry->mteSetContext)); break; case COLUMN_MTEEVENTSETCONTEXTNAMEWILDCARD: ret = (entry->flags & MTE_SET_FLAG_CTXWILD) ? TV_TRUE : TV_FALSE; snmp_set_var_typed_integer (request->requestvb, ASN_INTEGER, ret); break; } } break; #ifndef NETSNMP_NO_WRITE_SUPPORT /* * Write-support */ case MODE_SET_RESERVE1: for (request = requests; request; request = request->next) { if (request->processed) continue; tinfo = netsnmp_extract_table_info (request); /* * Since the mteEventSetTable only contains entries for * rows where the mteEventActions 'set(1)' bit is set, * strictly speaking we should reject assignments where * this isn't the case. * But SET requests that include an assignment of the * 'set(1)' bit at the same time are valid, so would * need to be accepted. Unfortunately, this assignment * is only applied in the COMMIT pass, so it's difficult * to detect whether this holds or not. * * Let's fudge things for now, by processing assignments * even if the 'set(1)' bit isn't set. */ switch (tinfo->colnum) { case COLUMN_MTEEVENTSETOBJECT: ret = netsnmp_check_vb_oid (request->requestvb); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error (reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_MTEEVENTSETOBJECTWILDCARD: case COLUMN_MTEEVENTSETCONTEXTNAMEWILDCARD: ret = netsnmp_check_vb_truthvalue (request->requestvb); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error (reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_MTEEVENTSETVALUE: ret = netsnmp_check_vb_int (request->requestvb); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error (reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_MTEEVENTSETTARGETTAG: case COLUMN_MTEEVENTSETCONTEXTNAME: ret = netsnmp_check_vb_type_and_max_size (request->requestvb, ASN_OCTET_STR, MTE_STR2_LEN); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error (reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; default: netsnmp_set_request_error (reqinfo, request, SNMP_ERR_NOTWRITABLE); return SNMP_ERR_NOERROR; } /* * The Event MIB is somewhat ambiguous as to whether * mteEventSetTable (and mteEventNotificationTable) * entries can be modified once the main mteEventTable * entry has been marked 'active'. * But it's clear from discussion on the DisMan mailing * list is that the intention is not. * * So check for whether this row is already active, * and reject *all* SET requests if it is. */ entry = (struct mteEvent *) netsnmp_tdata_extract_entry (request); if (entry && entry->flags & MTE_EVENT_FLAG_ACTIVE) { netsnmp_set_request_error (reqinfo, request, SNMP_ERR_INCONSISTENTVALUE); return SNMP_ERR_NOERROR; } } break; case MODE_SET_RESERVE2: case MODE_SET_FREE: case MODE_SET_UNDO: break; case MODE_SET_ACTION: for (request = requests; request; request = request->next) { if (request->processed) continue; entry = (struct mteEvent *) netsnmp_tdata_extract_entry (request); if (!entry) { /* * New rows must be created via the RowStatus column * (in the main mteEventTable) */ netsnmp_set_request_error (reqinfo, request, SNMP_ERR_NOCREATION); /* or inconsistentName? */ return SNMP_ERR_NOERROR; } } break; case MODE_SET_COMMIT: /* * All these assignments are "unfailable", so it's * (reasonably) safe to apply them in the Commit phase */ for (request = requests; request; request = request->next) { if (request->processed) continue; entry = (struct mteEvent *) netsnmp_tdata_extract_entry (request); tinfo = netsnmp_extract_table_info (request); switch (tinfo->colnum) { case COLUMN_MTEEVENTSETOBJECT: memset (entry->mteSetOID, 0, sizeof (entry->mteSetOID)); memcpy (entry->mteSetOID, request->requestvb->val.objid, request->requestvb->val_len); entry->mteSetOID_len = request->requestvb->val_len / sizeof (oid); break; case COLUMN_MTEEVENTSETOBJECTWILDCARD: if (*request->requestvb->val.integer == TV_TRUE) entry->flags |= MTE_SET_FLAG_OBJWILD; else entry->flags &= ~MTE_SET_FLAG_OBJWILD; break; case COLUMN_MTEEVENTSETVALUE: entry->mteSetValue = *request->requestvb->val.integer; break; case COLUMN_MTEEVENTSETTARGETTAG: memset (entry->mteSetTarget, 0, sizeof (entry->mteSetTarget)); memcpy (entry->mteSetTarget, request->requestvb->val.string, request->requestvb->val_len); break; case COLUMN_MTEEVENTSETCONTEXTNAME: memset (entry->mteSetContext, 0, sizeof (entry->mteSetContext)); memcpy (entry->mteSetContext, request->requestvb->val.string, request->requestvb->val_len); break; case COLUMN_MTEEVENTSETCONTEXTNAMEWILDCARD: if (*request->requestvb->val.integer == TV_TRUE) entry->flags |= MTE_SET_FLAG_CTXWILD; else entry->flags &= ~MTE_SET_FLAG_CTXWILD; break; } } break; #endif /* !NETSNMP_NO_WRITE_SUPPORT */ } return SNMP_ERR_NOERROR; }
/** handles requests for the schedTable table */ int schedTable_handler(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo, netsnmp_request_info *requests) { netsnmp_request_info *request; netsnmp_table_request_info *tinfo; netsnmp_tdata_row *row; struct schedTable_entry *entry; int recalculate = 0; size_t len; char *cp; char owner[SCHED_STR1_LEN+1]; char name[ SCHED_STR1_LEN+1]; int ret; DEBUGMSGTL(("disman:schedule:mib", "Schedule handler (%d)\n", reqinfo->mode)); switch (reqinfo->mode) { /* * Read-support (also covers GetNext requests) */ case MODE_GET: for (request = requests; request; request = request->next) { if (request->processed) continue; entry = (struct schedTable_entry *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info( request); switch (tinfo->colnum) { case COLUMN_SCHEDDESCR: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, entry->schedDescr, strlen(entry->schedDescr)); break; case COLUMN_SCHEDINTERVAL: snmp_set_var_typed_integer(request->requestvb, ASN_UNSIGNED, entry->schedInterval); break; case COLUMN_SCHEDWEEKDAY: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, &entry->schedWeekDay, sizeof(entry->schedWeekDay)); break; case COLUMN_SCHEDMONTH: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, entry->schedMonth, sizeof(entry->schedMonth)); break; case COLUMN_SCHEDDAY: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, entry->schedDay, sizeof(entry->schedDay)); break; case COLUMN_SCHEDHOUR: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, entry->schedHour, sizeof(entry->schedHour)); break; case COLUMN_SCHEDMINUTE: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, entry->schedMinute, sizeof(entry->schedMinute)); break; case COLUMN_SCHEDCONTEXTNAME: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, entry->schedContextName, strlen(entry->schedContextName)); break; case COLUMN_SCHEDVARIABLE: snmp_set_var_typed_value(request->requestvb, ASN_OBJECT_ID, (u_char *)entry->schedVariable, entry->schedVariable_len*sizeof(oid)); break; case COLUMN_SCHEDVALUE: snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, entry->schedValue); break; case COLUMN_SCHEDTYPE: snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, entry->schedType); break; case COLUMN_SCHEDADMINSTATUS: ret = (entry->flags & SCHEDULE_FLAG_ENABLED ) ? TV_TRUE : TV_FALSE; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; case COLUMN_SCHEDOPERSTATUS: ret = (entry->flags & SCHEDULE_FLAG_ENABLED ) ? TV_TRUE : TV_FALSE; /* * Check for one-shot entries that have already fired */ if ((entry->schedType == SCHED_TYPE_ONESHOT) && (entry->schedLastRun != 0 )) ret = 3; /* finished(3) */ snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; case COLUMN_SCHEDFAILURES: snmp_set_var_typed_integer(request->requestvb, ASN_COUNTER, entry->schedFailures); break; case COLUMN_SCHEDLASTFAILURE: snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, entry->schedLastFailure); break; case COLUMN_SCHEDLASTFAILED: /* * Convert 'schedLastFailed' timestamp * into DateAndTime string */ cp = (char *) date_n_time( &entry->schedLastFailed, &len ); snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, cp, len); break; case COLUMN_SCHEDSTORAGETYPE: snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, entry->schedStorageType); break; case COLUMN_SCHEDROWSTATUS: ret = (entry->flags & SCHEDULE_FLAG_ACTIVE ) ? TV_TRUE : TV_FALSE; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; case COLUMN_SCHEDTRIGGERS: snmp_set_var_typed_integer(request->requestvb, ASN_COUNTER, entry->schedTriggers); break; } } break; /* * Write-support */ case MODE_SET_RESERVE1: for (request = requests; request; request = request->next) { if (request->processed) continue; entry = (struct schedTable_entry *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info( request); switch (tinfo->colnum) { case COLUMN_SCHEDDESCR: ret = netsnmp_check_vb_type_and_max_size( request->requestvb, ASN_OCTET_STR, SCHED_STR2_LEN); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_SCHEDINTERVAL: ret = netsnmp_check_vb_uint( request->requestvb ); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_SCHEDWEEKDAY: ret = netsnmp_check_vb_type_and_size( request->requestvb, ASN_OCTET_STR, 1); /* XXX - check for bit(7) set */ if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_SCHEDMONTH: ret = netsnmp_check_vb_type_and_size( /* max_size ?? */ request->requestvb, ASN_OCTET_STR, 2); /* XXX - check for bit(12)-bit(15) set */ if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_SCHEDDAY: ret = netsnmp_check_vb_type_and_size( /* max_size ?? */ request->requestvb, ASN_OCTET_STR, 4+4); /* XXX - check for bit(62) or bit(63) set */ if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_SCHEDHOUR: ret = netsnmp_check_vb_type_and_size( /* max_size ?? */ request->requestvb, ASN_OCTET_STR, 3); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_SCHEDMINUTE: ret = netsnmp_check_vb_type_and_size( /* max_size ?? */ request->requestvb, ASN_OCTET_STR, 8); /* XXX - check for bit(60)-bit(63) set */ if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_SCHEDCONTEXTNAME: ret = netsnmp_check_vb_type_and_max_size( request->requestvb, ASN_OCTET_STR, SCHED_STR1_LEN); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_SCHEDVARIABLE: ret = netsnmp_check_vb_oid( request->requestvb ); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_SCHEDVALUE: ret = netsnmp_check_vb_int( request->requestvb ); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_SCHEDTYPE: ret = netsnmp_check_vb_int_range( request->requestvb, SCHED_TYPE_PERIODIC, SCHED_TYPE_ONESHOT ); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_SCHEDADMINSTATUS: ret = netsnmp_check_vb_truthvalue( request->requestvb ); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, SNMP_ERR_WRONGTYPE); return SNMP_ERR_NOERROR; } break; case COLUMN_SCHEDSTORAGETYPE: ret = netsnmp_check_vb_int_range( request->requestvb, ST_NONE, ST_READONLY ); /* XXX - check valid/consistent assignments */ if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_SCHEDROWSTATUS: ret = netsnmp_check_vb_rowstatus( request->requestvb, (entry ? RS_ACTIVE: RS_NONEXISTENT)); /* XXX - check consistency assignments */ if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; default: netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOTWRITABLE); return SNMP_ERR_NOERROR; } } break; case MODE_SET_RESERVE2: for (request = requests; request; request = request->next) { if (request->processed) continue; tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_SCHEDROWSTATUS: switch (*request->requestvb->val.integer) { case RS_CREATEANDGO: case RS_CREATEANDWAIT: /* * Create an (empty) new row structure */ memset(owner, 0, SCHED_STR1_LEN+1); memset(name, 0, SCHED_STR1_LEN+1); memcpy(owner, tinfo->indexes->val.string, tinfo->indexes->val_len); memcpy(name, tinfo->indexes->next_variable->val.string, tinfo->indexes->next_variable->val_len); row = schedTable_createEntry(owner, name); if (!row) { netsnmp_set_request_error(reqinfo, request, SNMP_ERR_RESOURCEUNAVAILABLE); return SNMP_ERR_NOERROR; } netsnmp_insert_tdata_row(request, row); } } } break; case MODE_SET_FREE: for (request = requests; request; request = request->next) { if (request->processed) continue; tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_SCHEDROWSTATUS: switch (*request->requestvb->val.integer) { case RS_CREATEANDGO: case RS_CREATEANDWAIT: /* * Tidy up after a failed row creation request */ entry = (struct schedTable_entry *) netsnmp_tdata_extract_entry(request); if (entry && !(entry->flags & SCHEDULE_FLAG_VALID)) { row = (netsnmp_tdata_row *) netsnmp_tdata_extract_row(request); schedTable_removeEntry(row); } } } } break; case MODE_SET_ACTION: for (request = requests; request; request = request->next) { entry = (struct schedTable_entry *) netsnmp_tdata_extract_entry(request); if (!entry) { /* * New rows must be created via the RowStatus column */ netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOCREATION); /* or inconsistentName? */ return SNMP_ERR_NOERROR; } } break; case MODE_SET_UNDO: break; case MODE_SET_COMMIT: /* * All these assignments are "unfailable", so it's * (reasonably) safe to apply them in the Commit phase */ entry = NULL; for (request = requests; request; request = request->next) { if (request->processed) continue; entry = (struct schedTable_entry *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info( request); switch (tinfo->colnum) { case COLUMN_SCHEDDESCR: memset(entry->schedDescr, 0, sizeof(entry->schedDescr)); memcpy(entry->schedDescr, request->requestvb->val.string, request->requestvb->val_len); break; case COLUMN_SCHEDINTERVAL: entry->schedInterval = *request->requestvb->val.integer; recalculate = 1; break; case COLUMN_SCHEDWEEKDAY: entry->schedWeekDay = request->requestvb->val.string[0]; recalculate = 1; break; case COLUMN_SCHEDMONTH: entry->schedMonth[0] = request->requestvb->val.string[0]; entry->schedMonth[1] = request->requestvb->val.string[1]; recalculate = 1; break; case COLUMN_SCHEDDAY: memset(entry->schedDay, 0, sizeof(entry->schedDay)); memcpy(entry->schedDay, request->requestvb->val.string, request->requestvb->val_len); recalculate = 1; break; case COLUMN_SCHEDHOUR: entry->schedHour[0] = request->requestvb->val.string[0]; entry->schedHour[1] = request->requestvb->val.string[1]; entry->schedHour[2] = request->requestvb->val.string[2]; recalculate = 1; break; case COLUMN_SCHEDMINUTE: memset(entry->schedMinute, 0, sizeof(entry->schedMinute)); memcpy(entry->schedMinute, request->requestvb->val.string, request->requestvb->val_len); recalculate = 1; break; case COLUMN_SCHEDCONTEXTNAME: memset(entry->schedContextName, 0, sizeof(entry->schedContextName)); memcpy(entry->schedContextName, request->requestvb->val.string, request->requestvb->val_len); break; case COLUMN_SCHEDVARIABLE: memset(entry->schedVariable, 0, sizeof(entry->schedVariable)); memcpy(entry->schedVariable, request->requestvb->val.string, request->requestvb->val_len); entry->schedVariable_len = request->requestvb->val_len/sizeof(oid); break; case COLUMN_SCHEDVALUE: entry->schedValue = *request->requestvb->val.integer; break; case COLUMN_SCHEDTYPE: entry->schedType = *request->requestvb->val.integer; break; case COLUMN_SCHEDADMINSTATUS: if (*request->requestvb->val.integer == TV_TRUE) entry->flags |= SCHEDULE_FLAG_ENABLED; else entry->flags &= ~SCHEDULE_FLAG_ENABLED; break; case COLUMN_SCHEDSTORAGETYPE: entry->schedStorageType = *request->requestvb->val.integer; break; case COLUMN_SCHEDROWSTATUS: switch (*request->requestvb->val.integer) { case RS_ACTIVE: entry->flags |= SCHEDULE_FLAG_ACTIVE; break; case RS_CREATEANDGO: entry->flags |= SCHEDULE_FLAG_ACTIVE; entry->flags |= SCHEDULE_FLAG_VALID; entry->session = netsnmp_iquery_pdu_session(reqinfo->asp->pdu); break; case RS_CREATEANDWAIT: entry->flags |= SCHEDULE_FLAG_VALID; entry->session = netsnmp_iquery_pdu_session(reqinfo->asp->pdu); break; case RS_DESTROY: row = (netsnmp_tdata_row *) netsnmp_tdata_extract_row(request); schedTable_removeEntry(row); } recalculate = 1; break; } } if (recalculate) { netsnmp_assert(entry); sched_nextTime(entry); } break; } return SNMP_ERR_NOERROR; }
/** handles requests for the mteTriggerDeltaTable table */ int mteTriggerDeltaTable_handler(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo, netsnmp_request_info *requests) { netsnmp_request_info *request; netsnmp_table_request_info *tinfo; struct mteTrigger *entry; int ret; DEBUGMSGTL(("disman:event:mib", "Delta Table handler (%d)\n", reqinfo->mode)); switch (reqinfo->mode) { /* * Read-support (also covers GetNext requests) */ case MODE_GET: for (request = requests; request; request = request->next) { if (request->processed) continue; entry = (struct mteTrigger *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); /* * The mteTriggerBooleanTable should only contains entries for * rows where the mteTriggerSampleType is 'deltaValue(2)' * So skip entries where this isn't the case. */ if (!entry || !(entry->flags & MTE_TRIGGER_FLAG_DELTA )) { netsnmp_request_set_error(request, SNMP_NOSUCHINSTANCE); continue; } switch (tinfo->colnum) { case COLUMN_MTETRIGGERDELTADISCONTINUITYID: snmp_set_var_typed_value(request->requestvb, ASN_OBJECT_ID, (u_char *) entry->mteDeltaDiscontID, entry->mteDeltaDiscontID_len*sizeof(oid)); break; case COLUMN_MTETRIGGERDELTADISCONTINUITYIDWILDCARD: ret = (entry->flags & MTE_TRIGGER_FLAG_DWILD ) ? TV_TRUE : TV_FALSE; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; case COLUMN_MTETRIGGERDELTADISCONTINUITYIDTYPE: snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, entry->mteDeltaDiscontIDType); break; } } break; /* * Write-support */ case MODE_SET_RESERVE1: for (request = requests; request; request = request->next) { if (request->processed) continue; entry = (struct mteTrigger *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); /* * Since the mteTriggerDeltaTable only contains entries for * rows where mteTriggerSampleType is 'deltaValue(2)', * strictly speaking we should reject assignments where * this isn't the case. * But SET requests that include an assignment of * 'deltaValue(2)' at the same time are valid, so would * need to be accepted. Unfortunately, this assignment * is only applied in the COMMIT pass, so it's difficult * to detect whether this holds or not. * * Let's fudge things for now, by processing * assignments even if this value isn't set. */ switch (tinfo->colnum) { case COLUMN_MTETRIGGERDELTADISCONTINUITYID: ret = netsnmp_check_vb_oid(request->requestvb); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_MTETRIGGERDELTADISCONTINUITYIDWILDCARD: ret = netsnmp_check_vb_truthvalue(request->requestvb); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_MTETRIGGERDELTADISCONTINUITYIDTYPE: ret = netsnmp_check_vb_int_range(request->requestvb, MTE_DELTAD_TTICKS, MTE_DELTAD_DATETIME); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; default: netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOTWRITABLE); return SNMP_ERR_NOERROR; } /* * The Event MIB is somewhat ambiguous as to whether the * various trigger table entries can be modified once the * main mteTriggerTable entry has been marked 'active'. * But it's clear from discussion on the DisMan mailing * list is that the intention is not. * * So check for whether this row is already active, * and reject *all* SET requests if it is. */ entry = (struct mteTrigger *) netsnmp_tdata_extract_entry(request); if (entry && entry->flags & MTE_TRIGGER_FLAG_ACTIVE ) { netsnmp_set_request_error(reqinfo, request, SNMP_ERR_INCONSISTENTVALUE); return SNMP_ERR_NOERROR; } } break; case MODE_SET_RESERVE2: case MODE_SET_FREE: case MODE_SET_UNDO: break; case MODE_SET_ACTION: for (request = requests; request; request = request->next) { if (request->processed) continue; entry = (struct mteTrigger *) netsnmp_tdata_extract_entry(request); if (!entry) { /* * New rows must be created via the RowStatus column * (in the main mteTriggerTable) */ netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOCREATION); /* or inconsistentName? */ return SNMP_ERR_NOERROR; } } break; case MODE_SET_COMMIT: /* * All these assignments are "unfailable", so it's * (reasonably) safe to apply them in the Commit phase */ for (request = requests; request; request = request->next) { if (request->processed) continue; entry = (struct mteTrigger *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_MTETRIGGERDELTADISCONTINUITYID: if ( snmp_oid_compare( request->requestvb->val.objid, request->requestvb->val_len/sizeof(oid), _sysUpTime_instance, _sysUpTime_inst_len) != 0 ) { memset(entry->mteDeltaDiscontID, 0, sizeof(entry->mteDeltaDiscontID)); memcpy(entry->mteDeltaDiscontID, request->requestvb->val.string, request->requestvb->val_len); entry->mteDeltaDiscontID_len = request->requestvb->val_len/sizeof(oid); entry->flags &= ~MTE_TRIGGER_FLAG_SYSUPT; } break; case COLUMN_MTETRIGGERDELTADISCONTINUITYIDWILDCARD: if (*request->requestvb->val.integer == TV_TRUE) entry->flags |= MTE_TRIGGER_FLAG_DWILD; else entry->flags &= ~MTE_TRIGGER_FLAG_DWILD; break; case COLUMN_MTETRIGGERDELTADISCONTINUITYIDTYPE: entry->mteDeltaDiscontIDType = *request->requestvb->val.integer; break; } } break; } return SNMP_ERR_NOERROR; }
/** handles requests for the mteObjectsTable table */ int mteObjectsTable_handler(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo, netsnmp_request_info *requests) { netsnmp_request_info *request; netsnmp_table_request_info *tinfo; netsnmp_tdata_row *row; struct mteObject *entry; char mteOwner[MTE_STR1_LEN+1]; char mteOName[MTE_STR1_LEN+1]; long ret; DEBUGMSGTL(("disman:event:mib", "ObjTable handler (%d)\n", reqinfo->mode)); switch (reqinfo->mode) { /* * Read-support (also covers GetNext requests) */ case MODE_GET: for (request = requests; request; request = request->next) { entry = (struct mteObject *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); if (!entry) { netsnmp_set_request_error(reqinfo, request, SNMP_NOSUCHINSTANCE); continue; } switch (tinfo->colnum) { case COLUMN_MTEOBJECTSID: snmp_set_var_typed_value(request->requestvb, ASN_OBJECT_ID, (u_char *) entry->mteObjectID, entry->mteObjectID_len*sizeof(oid)); break; case COLUMN_MTEOBJECTSIDWILDCARD: ret = (entry->flags & MTE_OBJECT_FLAG_WILD ) ? TV_TRUE : TV_FALSE; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; case COLUMN_MTEOBJECTSENTRYSTATUS: ret = (entry->flags & MTE_OBJECT_FLAG_ACTIVE ) ? RS_ACTIVE : RS_NOTINSERVICE; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; } } break; #ifndef NETSNMP_NO_WRITE_SUPPORT /* * Write-support */ case MODE_SET_RESERVE1: for (request = requests; request; request = request->next) { entry = (struct mteObject *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_MTEOBJECTSID: ret = netsnmp_check_vb_oid( request->requestvb ); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } /* * Can't modify the OID of an active row * (an unnecessary restriction, IMO) */ if (entry && entry->flags & MTE_OBJECT_FLAG_ACTIVE ) { netsnmp_set_request_error(reqinfo, request, SNMP_ERR_INCONSISTENTVALUE); return SNMP_ERR_NOERROR; } break; case COLUMN_MTEOBJECTSIDWILDCARD: ret = netsnmp_check_vb_truthvalue( request->requestvb ); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } /* * Can't modify the wildcarding of an active row * (an unnecessary restriction, IMO) */ if (entry && entry->flags & MTE_OBJECT_FLAG_ACTIVE ) { netsnmp_set_request_error(reqinfo, request, SNMP_ERR_INCONSISTENTVALUE); return SNMP_ERR_NOERROR; } break; case COLUMN_MTEOBJECTSENTRYSTATUS: ret = netsnmp_check_vb_rowstatus(request->requestvb, (entry ? RS_ACTIVE : RS_NONEXISTENT)); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } /* An active row can only be deleted */ if (entry && entry->flags & MTE_OBJECT_FLAG_ACTIVE && *request->requestvb->val.integer == RS_NOTINSERVICE ) { netsnmp_set_request_error(reqinfo, request, SNMP_ERR_INCONSISTENTVALUE); return SNMP_ERR_NOERROR; } break; default: netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOTWRITABLE); return SNMP_ERR_NOERROR; } } break; case MODE_SET_RESERVE2: for (request = requests; request; request = request->next) { tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_MTEOBJECTSENTRYSTATUS: switch (*request->requestvb->val.integer) { case RS_CREATEANDGO: case RS_CREATEANDWAIT: /* * Create an (empty) new row structure */ memset(mteOwner, 0, sizeof(mteOwner)); memcpy(mteOwner, tinfo->indexes->val.string, tinfo->indexes->val_len); memset(mteOName, 0, sizeof(mteOName)); memcpy(mteOName, tinfo->indexes->next_variable->val.string, tinfo->indexes->next_variable->val_len); ret = *tinfo->indexes->next_variable->next_variable->val.integer; row = mteObjects_createEntry(mteOwner, mteOName, ret, 0); if (!row) { netsnmp_set_request_error(reqinfo, request, SNMP_ERR_RESOURCEUNAVAILABLE); return SNMP_ERR_NOERROR; } netsnmp_insert_tdata_row( request, row ); } } } break; case MODE_SET_FREE: for (request = requests; request; request = request->next) { tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_MTEOBJECTSENTRYSTATUS: switch (*request->requestvb->val.integer) { case RS_CREATEANDGO: case RS_CREATEANDWAIT: /* * Tidy up after a failed row creation request */ entry = (struct mteObject *) netsnmp_tdata_extract_entry(request); if (entry && !(entry->flags & MTE_OBJECT_FLAG_VALID)) { row = (netsnmp_tdata_row *) netsnmp_tdata_extract_row(request); mteObjects_removeEntry( row ); } } } } break; case MODE_SET_ACTION: for (request = requests; request; request = request->next) { entry = (struct mteObject *) netsnmp_tdata_extract_entry(request); if (!entry) { /* * New rows must be created via the RowStatus column */ netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOCREATION); /* or inconsistentName? */ return SNMP_ERR_NOERROR; } } break; case MODE_SET_UNDO: break; case MODE_SET_COMMIT: /* * All these assignments are "unfailable", so it's * (reasonably) safe to apply them in the Commit phase */ for (request = requests; request; request = request->next) { entry = (struct mteObject *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_MTEOBJECTSID: memset(entry->mteObjectID, 0, sizeof(entry->mteObjectID)); memcpy(entry->mteObjectID, request->requestvb->val.objid, request->requestvb->val_len); entry->mteObjectID_len = request->requestvb->val_len/sizeof(oid); break; case COLUMN_MTEOBJECTSIDWILDCARD: if (*request->requestvb->val.integer == TV_TRUE) entry->flags |= MTE_OBJECT_FLAG_WILD; else entry->flags &= ~MTE_OBJECT_FLAG_WILD; break; case COLUMN_MTEOBJECTSENTRYSTATUS: switch (*request->requestvb->val.integer) { case RS_ACTIVE: entry->flags |= MTE_OBJECT_FLAG_ACTIVE; break; case RS_CREATEANDGO: entry->flags |= MTE_OBJECT_FLAG_VALID; entry->flags |= MTE_OBJECT_FLAG_ACTIVE; break; case RS_CREATEANDWAIT: entry->flags |= MTE_OBJECT_FLAG_VALID; break; case RS_DESTROY: row = (netsnmp_tdata_row *) netsnmp_tdata_extract_row(request); mteObjects_removeEntry(row); } } } /** set up to save persistent store */ snmp_store_needed(NULL); break; #endif /* !NETSNMP_NO_WRITE_SUPPORT */ } return SNMP_ERR_NOERROR; }
/** handles requests for the mteTriggerTable table */ int mteTriggerTable_handler(netsnmp_mib_handler *handler, netsnmp_handler_registration *reginfo, netsnmp_agent_request_info *reqinfo, netsnmp_request_info *requests) { netsnmp_request_info *request; netsnmp_table_request_info *tinfo; netsnmp_tdata_row *row; struct mteTrigger *entry; char mteOwner[MTE_STR1_LEN+1]; char mteTName[MTE_STR1_LEN+1]; long ret; DEBUGMSGTL(("disman:event:mib", "Trigger Table handler (%d)\n", reqinfo->mode)); switch (reqinfo->mode) { /* * Read-support (also covers GetNext requests) */ case MODE_GET: for (request = requests; request; request = request->next) { if (request->processed) continue; entry = (struct mteTrigger *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_MTETRIGGERCOMMENT: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, entry->mteTriggerComment, strlen(entry->mteTriggerComment)); break; case COLUMN_MTETRIGGERTEST: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, &entry->mteTriggerTest, 1); break; case COLUMN_MTETRIGGERSAMPLETYPE: ret = (entry->flags & MTE_TRIGGER_FLAG_DELTA ) ? MTE_SAMPLE_DELTA : MTE_SAMPLE_ABSOLUTE; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; case COLUMN_MTETRIGGERVALUEID: snmp_set_var_typed_value(request->requestvb, ASN_OBJECT_ID, (u_char *) entry->mteTriggerValueID, entry->mteTriggerValueID_len*sizeof(oid)); break; case COLUMN_MTETRIGGERVALUEIDWILDCARD: ret = (entry->flags & MTE_TRIGGER_FLAG_VWILD ) ? TV_TRUE : TV_FALSE; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; case COLUMN_MTETRIGGERTARGETTAG: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, entry->mteTriggerTarget, strlen(entry->mteTriggerTarget)); break; case COLUMN_MTETRIGGERCONTEXTNAME: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, entry->mteTriggerContext, strlen(entry->mteTriggerContext)); break; case COLUMN_MTETRIGGERCONTEXTNAMEWILDCARD: ret = (entry->flags & MTE_TRIGGER_FLAG_CWILD ) ? TV_TRUE : TV_FALSE; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; case COLUMN_MTETRIGGERFREQUENCY: snmp_set_var_typed_integer(request->requestvb, ASN_UNSIGNED, entry->mteTriggerFrequency); break; case COLUMN_MTETRIGGEROBJECTSOWNER: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, entry->mteTriggerOOwner, strlen(entry->mteTriggerOOwner)); break; case COLUMN_MTETRIGGEROBJECTS: snmp_set_var_typed_value(request->requestvb, ASN_OCTET_STR, entry->mteTriggerObjects, strlen(entry->mteTriggerObjects)); break; case COLUMN_MTETRIGGERENABLED: ret = (entry->flags & MTE_TRIGGER_FLAG_ENABLED ) ? TV_TRUE : TV_FALSE; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; case COLUMN_MTETRIGGERENTRYSTATUS: ret = (entry->flags & MTE_TRIGGER_FLAG_ACTIVE ) ? RS_ACTIVE : RS_NOTINSERVICE; snmp_set_var_typed_integer(request->requestvb, ASN_INTEGER, ret); break; } } break; #ifndef NETSNMP_NO_WRITE_SUPPORT /* * Write-support */ case MODE_SET_RESERVE1: for (request = requests; request; request = request->next) { if (request->processed) continue; entry = (struct mteTrigger *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_MTETRIGGERCOMMENT: case COLUMN_MTETRIGGERTARGETTAG: case COLUMN_MTETRIGGERCONTEXTNAME: ret = netsnmp_check_vb_type_and_max_size( request->requestvb, ASN_OCTET_STR, MTE_STR2_LEN); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_MTETRIGGERTEST: ret = netsnmp_check_vb_type_and_size( request->requestvb, ASN_OCTET_STR, 1); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_MTETRIGGERSAMPLETYPE: ret = netsnmp_check_vb_int_range(request->requestvb, MTE_SAMPLE_ABSOLUTE, MTE_SAMPLE_DELTA); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_MTETRIGGERVALUEID: ret = netsnmp_check_vb_oid(request->requestvb); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_MTETRIGGERVALUEIDWILDCARD: case COLUMN_MTETRIGGERCONTEXTNAMEWILDCARD: case COLUMN_MTETRIGGERENABLED: ret = netsnmp_check_vb_truthvalue(request->requestvb); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_MTETRIGGERFREQUENCY: ret = netsnmp_check_vb_uint(request->requestvb); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_MTETRIGGEROBJECTSOWNER: case COLUMN_MTETRIGGEROBJECTS: ret = netsnmp_check_vb_type_and_max_size( request->requestvb, ASN_OCTET_STR, MTE_STR1_LEN); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; case COLUMN_MTETRIGGERENTRYSTATUS: ret = netsnmp_check_vb_rowstatus(request->requestvb, (entry ? RS_ACTIVE : RS_NONEXISTENT)); if (ret != SNMP_ERR_NOERROR) { netsnmp_set_request_error(reqinfo, request, ret); return SNMP_ERR_NOERROR; } break; default: netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOTWRITABLE); return SNMP_ERR_NOERROR; } /* * Once a row has been made active, it cannot be * modified except to delete it. There's no good * reason for this, but that's what the MIB says. * * The published version of the Event MIB even forbids * enabling (or disabling) an active row, which * would make this object completely pointless! * Fortunately this ludicrous decision has since been corrected. */ if (entry && entry->flags & MTE_TRIGGER_FLAG_ACTIVE ) { /* check for the acceptable assignments */ if ((tinfo->colnum == COLUMN_MTETRIGGERENABLED) || (tinfo->colnum == COLUMN_MTETRIGGERENTRYSTATUS && *request->requestvb->val.integer != RS_NOTINSERVICE)) continue; /* Otherwise, reject this request */ netsnmp_set_request_error(reqinfo, request, SNMP_ERR_INCONSISTENTVALUE); return SNMP_ERR_NOERROR; } } break; case MODE_SET_RESERVE2: for (request = requests; request; request = request->next) { if (request->processed) continue; tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_MTETRIGGERENTRYSTATUS: switch (*request->requestvb->val.integer) { case RS_CREATEANDGO: case RS_CREATEANDWAIT: /* * Create an (empty) new row structure */ memset(mteOwner, 0, sizeof(mteOwner)); memcpy(mteOwner, tinfo->indexes->val.string, tinfo->indexes->val_len); memset(mteTName, 0, sizeof(mteTName)); memcpy(mteTName, tinfo->indexes->next_variable->val.string, tinfo->indexes->next_variable->val_len); row = mteTrigger_createEntry(mteOwner, mteTName, 0); if (!row) { netsnmp_set_request_error(reqinfo, request, SNMP_ERR_RESOURCEUNAVAILABLE); return SNMP_ERR_NOERROR; } netsnmp_insert_tdata_row( request, row ); } } } break; case MODE_SET_FREE: for (request = requests; request; request = request->next) { if (request->processed) continue; tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_MTETRIGGERENTRYSTATUS: switch (*request->requestvb->val.integer) { case RS_CREATEANDGO: case RS_CREATEANDWAIT: /* * Tidy up after a failed row creation request */ entry = (struct mteTrigger *) netsnmp_tdata_extract_entry(request); if (entry && !(entry->flags & MTE_TRIGGER_FLAG_VALID)) { row = (netsnmp_tdata_row *) netsnmp_tdata_extract_row(request); mteTrigger_removeEntry( row ); } } } } break; case MODE_SET_ACTION: for (request = requests; request; request = request->next) { if (request->processed) continue; tinfo = netsnmp_extract_table_info(request); entry = (struct mteTrigger *) netsnmp_tdata_extract_entry(request); if (!entry) { /* * New rows must be created via the RowStatus column */ netsnmp_set_request_error(reqinfo, request, SNMP_ERR_NOCREATION); /* or inconsistentName? */ return SNMP_ERR_NOERROR; } } break; case MODE_SET_UNDO: break; case MODE_SET_COMMIT: /* * All these assignments are "unfailable", so it's * (reasonably) safe to apply them in the Commit phase */ for (request = requests; request; request = request->next) { if (request->processed) continue; entry = (struct mteTrigger *) netsnmp_tdata_extract_entry(request); tinfo = netsnmp_extract_table_info(request); switch (tinfo->colnum) { case COLUMN_MTETRIGGERCOMMENT: memset(entry->mteTriggerComment, 0, sizeof(entry->mteTriggerComment)); memcpy(entry->mteTriggerComment, request->requestvb->val.string, request->requestvb->val_len); break; case COLUMN_MTETRIGGERTEST: entry->mteTriggerTest = request->requestvb->val.string[0]; break; case COLUMN_MTETRIGGERSAMPLETYPE: if (*request->requestvb->val.integer == MTE_SAMPLE_DELTA) entry->flags |= MTE_TRIGGER_FLAG_DELTA; else entry->flags &= ~MTE_TRIGGER_FLAG_DELTA; break; case COLUMN_MTETRIGGERVALUEID: memset(entry->mteTriggerValueID, 0, sizeof(entry->mteTriggerValueID)); memcpy(entry->mteTriggerValueID, request->requestvb->val.string, request->requestvb->val_len); entry->mteTriggerValueID_len = request->requestvb->val_len/sizeof(oid); break; case COLUMN_MTETRIGGERVALUEIDWILDCARD: if (*request->requestvb->val.integer == TV_TRUE) entry->flags |= MTE_TRIGGER_FLAG_VWILD; else entry->flags &= ~MTE_TRIGGER_FLAG_VWILD; break; case COLUMN_MTETRIGGERTARGETTAG: memset(entry->mteTriggerTarget, 0, sizeof(entry->mteTriggerTarget)); memcpy(entry->mteTriggerTarget, request->requestvb->val.string, request->requestvb->val_len); break; case COLUMN_MTETRIGGERCONTEXTNAME: memset(entry->mteTriggerContext, 0, sizeof(entry->mteTriggerContext)); memcpy(entry->mteTriggerContext, request->requestvb->val.string, request->requestvb->val_len); break; case COLUMN_MTETRIGGERCONTEXTNAMEWILDCARD: if (*request->requestvb->val.integer == TV_TRUE) entry->flags |= MTE_TRIGGER_FLAG_CWILD; else entry->flags &= ~MTE_TRIGGER_FLAG_CWILD; break; case COLUMN_MTETRIGGERFREQUENCY: entry->mteTriggerFrequency = *request->requestvb->val.integer; break; case COLUMN_MTETRIGGEROBJECTSOWNER: memset(entry->mteTriggerOOwner, 0, sizeof(entry->mteTriggerOOwner)); memcpy(entry->mteTriggerOOwner, request->requestvb->val.string, request->requestvb->val_len); break; case COLUMN_MTETRIGGEROBJECTS: memset(entry->mteTriggerObjects, 0, sizeof(entry->mteTriggerObjects)); memcpy(entry->mteTriggerObjects, request->requestvb->val.string, request->requestvb->val_len); break; case COLUMN_MTETRIGGERENABLED: if (*request->requestvb->val.integer == TV_TRUE) entry->flags |= MTE_TRIGGER_FLAG_ENABLED; else entry->flags &= ~MTE_TRIGGER_FLAG_ENABLED; break; case COLUMN_MTETRIGGERENTRYSTATUS: switch (*request->requestvb->val.integer) { case RS_ACTIVE: entry->flags |= MTE_TRIGGER_FLAG_ACTIVE; mteTrigger_enable( entry ); break; case RS_CREATEANDGO: entry->flags |= MTE_TRIGGER_FLAG_ACTIVE; entry->flags |= MTE_TRIGGER_FLAG_VALID; entry->session = netsnmp_iquery_pdu_session(reqinfo->asp->pdu); mteTrigger_enable( entry ); break; case RS_CREATEANDWAIT: entry->flags |= MTE_TRIGGER_FLAG_VALID; entry->session = netsnmp_iquery_pdu_session(reqinfo->asp->pdu); break; case RS_DESTROY: row = (netsnmp_tdata_row *) netsnmp_tdata_extract_row(request); mteTrigger_removeEntry(row); } break; } } /** set up to save persistent store */ snmp_store_needed(NULL); break; #endif /* !NETSNMP_NO_WRITE_SUPPORT */ } return SNMP_ERR_NOERROR; }